335 lines
9.1 KiB
JavaScript
Executable File
335 lines
9.1 KiB
JavaScript
Executable File
/*
|
|
Flags
|
|
0x01 01 watch enabled
|
|
0x02 02 read layer enabled
|
|
0x04 04 write layer enable
|
|
0x08 08 initial state
|
|
0x10 16 changing state
|
|
0x20 32 immediate change
|
|
*/
|
|
(()=>{
|
|
let pipeLine = function(wire){
|
|
let _caches = {};
|
|
let _cache_version = null;
|
|
this.reads = [];
|
|
this.writes = [];
|
|
this.filters = new Map();
|
|
this.read = (fn,pr) => this.reads.push({fn,pr});
|
|
this.write = (fn,pr) => this.writes.push({fn,pr});
|
|
this.filter = (name, fn) => this.filters.set(name,fn);
|
|
this.get = (val,filters = []) => {
|
|
let real = val;
|
|
if(filters.length)
|
|
{
|
|
if(_cache_version !== wire.version())
|
|
{
|
|
_caches = {};
|
|
};
|
|
for (const name of filters)
|
|
{
|
|
if(_caches[name])
|
|
{
|
|
real = _caches[name];
|
|
continue;
|
|
}
|
|
let func = this.filters.get(name);
|
|
if(func)
|
|
{
|
|
func(real, e => {
|
|
real = e;
|
|
_caches[name] = e;
|
|
});
|
|
}
|
|
};
|
|
_cache_version = wire.version();
|
|
};
|
|
|
|
let fns = this.reads.sort((a,b) => (a?.pr|0) - (b?.pr|0));
|
|
for (const { fn } of fns) {
|
|
fn( real, e => real = e );
|
|
};
|
|
return real;
|
|
};
|
|
this.set = () => {
|
|
let fns = this.writes.sort((a,b) => (a?.pr|0) - (b?.pr|0)),
|
|
real = val;
|
|
for (const { fn } of fns) {
|
|
fn( real, e => real = e );
|
|
};
|
|
return real;
|
|
};
|
|
}
|
|
pipeLine.prototype.read = function(fn,pr){
|
|
this.reads.push({fn,pr})
|
|
}
|
|
pipeLine.prototype.write = function(fn,pr){
|
|
this.writes.writes({fn,pr})
|
|
}
|
|
pipeLine.prototype.get = function(val){
|
|
let fns = this.reads.sort((a,b) => (a?.pr|0) - (b?.pr|0)),
|
|
real = val;
|
|
for (const { fn } of fns) {
|
|
fn( real, e => real = e );
|
|
};
|
|
return real;
|
|
}
|
|
pipeLine.prototype.set = function(val){
|
|
let fns = this.writes.sort((a,b) => (a?.pr|0) - (b?.pr|0)),
|
|
real = val;
|
|
for (const { fn } of fns) {
|
|
fn( real, e => real = e );
|
|
};
|
|
return real;
|
|
}
|
|
function é(defaultValue)
|
|
{
|
|
if(this instanceof é)
|
|
{
|
|
this.value = é.extract(defaultValue);
|
|
this._version = 0;
|
|
this.effects = [];
|
|
this.piping = new pipeLine(this);
|
|
this.flag = 8;
|
|
}else{
|
|
return new é(defaultValue)
|
|
}
|
|
}
|
|
é.fingerPrint = Symbol("wire");
|
|
é.isWire = n => n?.fp == é.fingerPrint;
|
|
é.extract = (e,v) => {
|
|
if(typeof e=='function')
|
|
{
|
|
return é.freeze(e(v))
|
|
}else{
|
|
return é.freeze(e);
|
|
}
|
|
};
|
|
é.freeze = a => {
|
|
if(Object.isFrozen(a))
|
|
{
|
|
return a;
|
|
}
|
|
switch(typeof a)
|
|
{
|
|
case "object":{
|
|
if(Array.isArray(a))
|
|
{
|
|
let k = [...a];
|
|
for (let name = 0; name < k.length; name++) {
|
|
let value = k[name];
|
|
if(typeof value == "object")
|
|
{
|
|
k[name]=é.freeze(value);
|
|
}
|
|
};
|
|
Object.freeze(k);
|
|
return k;
|
|
}else{
|
|
let k = Object.assign({}, a);
|
|
for (const [name, value] of Object.entries(k)) {
|
|
if(typeof value == "object")
|
|
{
|
|
k[name]=é.freeze(value);
|
|
}
|
|
};
|
|
Object.freeze(k);
|
|
return k;
|
|
}
|
|
}
|
|
default: return a;
|
|
};
|
|
};
|
|
é.isSame = (a,b) => !é.diff(a,b);
|
|
é.watch = (fn, assoc) => {
|
|
for (const wireVar of assoc)
|
|
{
|
|
if(é.isWire(wireVar))
|
|
{
|
|
wireVar.watch(fn);
|
|
}
|
|
}
|
|
};
|
|
é.diff = (a,b,c) => {
|
|
let cursoryDiffResult = cDiff(a,b);
|
|
if(cursoryDiffResult == cDiff.adiff)
|
|
{
|
|
return adiff(a,b,c||[])
|
|
}else{
|
|
return cursoryDiffResult == cDiff.some ? false : true;
|
|
}
|
|
}
|
|
const adiff = (a,b,c) => {
|
|
if(c.includes(a) && c.includes(b))
|
|
{
|
|
console.error("Circular object detected !")
|
|
return cObjectDiff(a,b);
|
|
}
|
|
let typea = a instanceof Array ? 0 : a.byteLength ? 1 : 2;
|
|
let typeb = b instanceof Array ? 0 : b.byteLength ? 1 : 2;
|
|
if(typea != typeb)
|
|
{
|
|
return true;
|
|
}
|
|
if(typea==0)
|
|
{
|
|
if(a.length != b.length)
|
|
{
|
|
return true
|
|
}
|
|
for(let k = 0; k < a.length; k++)
|
|
{
|
|
if(é.diff(a[k], b[k]))
|
|
{
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
if(a instanceof Object)
|
|
{
|
|
if(Object.keys(a).length != Object.keys(b).length)
|
|
{
|
|
return true
|
|
}
|
|
c.push(a);
|
|
c.push(b);
|
|
for (const key in a)
|
|
{
|
|
if (Object.hasOwnProperty.call(a, key))
|
|
{
|
|
if(é.diff(a[key], b[key], c))
|
|
{
|
|
return true
|
|
}
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
}
|
|
const cArrDiff = (a,b) => {
|
|
return a.length != b.length || !a.every((v,i) => a[i] === v)
|
|
};
|
|
const cObjectDiff = (a,b) => {
|
|
return cArrDiff(
|
|
Object.keys(a),
|
|
Object.keys(b)
|
|
);
|
|
};
|
|
const cDiff = (a,b) => {
|
|
switch(typeof a)
|
|
{
|
|
case "undefined":
|
|
case "function":{
|
|
return typeof a == typeof b ? cDiff.some : cDiff.different
|
|
}
|
|
case "symbol":
|
|
case "bigint":
|
|
case "boolean":
|
|
case "number":
|
|
case "string":{
|
|
return a === b ? cDiff.some : cDiff.different;
|
|
}
|
|
case "object":{
|
|
return cDiff.adiff;
|
|
}
|
|
};
|
|
}
|
|
cDiff.adiff = -1;
|
|
cDiff.some = 0;
|
|
cDiff.different = 1;
|
|
|
|
é.prototype.fp = é.fingerPrint;
|
|
é.prototype.diff = é.diff;
|
|
é.prototype.get = function(...filters){
|
|
if(this.flag & 2)
|
|
{
|
|
return this.piping.get(this.value,filters)
|
|
}else{
|
|
return this.value
|
|
}
|
|
};
|
|
é.prototype.set = function(newValue){
|
|
if(this.flag & 16)
|
|
{
|
|
return;
|
|
}
|
|
newValue = é.extract(newValue, this.value);
|
|
if(this.flag & 4)
|
|
{
|
|
newValue = this.piping.set(newValue)
|
|
};
|
|
if(this.diff(newValue,this.value))
|
|
{
|
|
this.flag = this.flag | 16;
|
|
if(this.flag & 1)
|
|
{
|
|
schedule((()=>{
|
|
this.effects.filter(e => e.o).forEach(k => k())
|
|
}));
|
|
}
|
|
this.value = newValue;
|
|
this._version++;
|
|
if(this.flag & 1)
|
|
{
|
|
schedule((()=>{
|
|
this.effects.forEach(e => e.f());
|
|
}));
|
|
}
|
|
this.flag = this.flag ^ 16;
|
|
}
|
|
};
|
|
const schedule = function(fn){
|
|
schedule.jobs.push(fn)
|
|
if(!schedule.executing)
|
|
{
|
|
requestAnimationFrame(()=>{
|
|
for (const fn of schedule.jobs) {
|
|
try{
|
|
fn()
|
|
}catch(e){
|
|
console.error(e)
|
|
}
|
|
};
|
|
schedule.jobs=[];
|
|
})
|
|
}
|
|
};
|
|
schedule.executing = false;
|
|
schedule.jobs = [];
|
|
é.prototype.watch = function(fn){
|
|
this.flag = this.flag | 1;
|
|
let k = {
|
|
f:fn,
|
|
o:undefined
|
|
};
|
|
requestAnimationFrame(()=> {
|
|
k.o = fn();
|
|
})
|
|
this.effects.push(k);
|
|
};
|
|
é.prototype.version = function(){
|
|
return this._version;
|
|
}
|
|
é.prototype.equalTo = function(value){
|
|
return é.isSame(value, this.value)
|
|
}
|
|
é.prototype.read = function(argument1, argument2, argument3){
|
|
this.flag = this.flag | 2;
|
|
if(typeof argument1=="string")
|
|
{
|
|
this.piping.filter(argument1, argument2, argument3);
|
|
}else{
|
|
this.piping.read(argument1, argument2)
|
|
}
|
|
}
|
|
é.prototype.write = function(value, pr){
|
|
this.flag = this.flag | 4;
|
|
this.piping.write(value, pr)
|
|
}
|
|
|
|
try{
|
|
module.exports = é;
|
|
}catch{
|
|
window.é = é;
|
|
}
|
|
})(); |