aoye 0.0.52 → 0.0.54

package/dist/aoye.cjs.js

@@ -484,7 +484,11 @@ function link(up = null, down = null) {
   }
   up.emitTail = line;
   if (recHead) {
-    recTail.nextRecLine = line;
+    if (recTail) {
+      recTail.nextRecLine = line;
+    } else {
+      down.recHead = line;
+    }
   } else {
     down.recHead = line;
   }
@@ -547,7 +551,11 @@ function outLink(up = null, down = null) {
   }
   up.emitTail = line;
   if (recHead) {
-    recTail.nextRecLine = line;
+    if (recTail) {
+      recTail.nextRecLine = line;
+    } else {
+      down.recHead = line;
+    }
   } else {
     down.recHead = line;
   }
@@ -750,11 +758,195 @@ State.Unknown | State.Dirty;
 State.ScopeReady | State.ScopeAbort;
 State.ScopeAbort;
 
+const trackIterator = (cells, scope) => {
+  let iter = cells.get(Keys.Iterator);
+  if (!iter) {
+    iter = new Signal(0);
+    iter.scope = scope;
+    cells.set(Keys.Iterator, iter);
+  }
+  iter.get();
+};
+const triggerIterator = cells => {
+  const iter = cells.get(Keys.Iterator);
+  if (iter) {
+    iter.set((iter.value || 0) + 1);
+  }
+};
+const trackKey = (cells, scope, key) => {
+  let cell = cells.get(key);
+  if (!cell) {
+    cell = new Signal(undefined);
+    cell.scope = scope;
+    cells.set(key, cell);
+  }
+  cell.get();
+};
+const triggerKey = (cells, key) => {
+  const cell = cells.get(key);
+  if (cell) {
+    cell.set((cell.value === undefined ? 0 : cell.value) + 1);
+  }
+};
+const createSharedHandler = (cells, scope, deep, targetIsMap) => {
+  const iterate = (rawTarget, iteratorFn) => {
+    trackIterator(cells, scope);
+    const rawIter = rawTarget[iteratorFn]();
+    if (!deep) return rawIter;
+    const rawNext = rawIter.next.bind(rawIter);
+    rawIter.next = () => {
+      const result = rawNext();
+      if (!result.done) {
+        if (iteratorFn === 'entries') {
+          result.value[0] = deepSignal(result.value[0], scope);
+          result.value[1] = deepSignal(result.value[1], scope);
+        } else {
+          result.value = deepSignal(result.value, scope);
+        }
+      }
+      return result;
+    };
+    return rawIter;
+  };
+  return {
+    has(key) {
+      const target = this[Keys.Raw];
+      trackKey(cells, scope, key);
+      return target.has(key);
+    },
+    delete(key) {
+      const target = this[Keys.Raw];
+      batchStart();
+      const had = target.has(key);
+      const result = target.delete(key);
+      if (had) {
+        triggerKey(cells, key);
+        cells.delete(key);
+        triggerIterator(cells);
+      }
+      batchEnd();
+      return result;
+    },
+    clear() {
+      const target = this[Keys.Raw];
+      batchStart();
+      const hadItems = target.size > 0;
+      target.clear();
+      const iterCell = cells.get(Keys.Iterator);
+      cells.clear();
+      if (iterCell) cells.set(Keys.Iterator, iterCell);
+      if (hadItems) {
+        triggerIterator(cells);
+      }
+      batchEnd();
+    },
+    forEach(callback, thisArg) {
+      const target = this[Keys.Raw];
+      trackIterator(cells, scope);
+      const wrap = val => deep ? deepSignal(val, scope) : val;
+      target.forEach((v, k) => {
+        callback.call(thisArg, wrap(v), wrap(k), this);
+      });
+    },
+    keys() {
+      return iterate(this[Keys.Raw], 'keys');
+    },
+    values() {
+      return iterate(this[Keys.Raw], 'values');
+    },
+    entries() {
+      return iterate(this[Keys.Raw], 'entries');
+    },
+    [Symbol.iterator]() {
+      return iterate(this[Keys.Raw], targetIsMap ? 'entries' : 'values');
+    }
+  };
+};
+const createMapHandler = (cells, scope, deep) => ({
+  get(key) {
+    const target = this[Keys.Raw];
+    trackKey(cells, scope, key);
+    const value = target.get(key);
+    return deep ? deepSignal(value, scope) : value;
+  },
+  set(key, value) {
+    const target = this[Keys.Raw];
+    batchStart();
+    target.set(key, value);
+    let cell = cells.get(key);
+    if (!cell) {
+      cell = new Signal(value);
+      cell.scope = scope;
+      cells.set(key, cell);
+    } else {
+      cell.set(value);
+    }
+    triggerIterator(cells);
+    batchEnd();
+    return this;
+  }
+});
+const createSetHandler = (cells, scope, _deep) => ({
+  add(value) {
+    const target = this[Keys.Raw];
+    batchStart();
+    const had = target.has(value);
+    target.add(value);
+    let cell = cells.get(value);
+    if (!cell) {
+      cell = new Signal(value);
+      cell.scope = scope;
+      cells.set(value, cell);
+    } else {
+      cell.set(value);
+    }
+    if (!had) {
+      triggerIterator(cells);
+    }
+    batchEnd();
+    return this;
+  }
+});
+const mergeHandlers = (...handlers) => Object.assign({}, ...handlers);
+
 const deepSignal = (target, scope, deep = true) => {
   const isObj = typeof target === 'object' && target !== null;
   if (!isObj || target[Keys.Raw] || target[Keys.ProxyFreeObject]) return target;
   const p = rawToProxy.get(target);
   if (p) return p;
+  const targetIsMap = target instanceof Map;
+  const targetIsSet = target instanceof Set;
+  if (targetIsMap || targetIsSet) {
+    const cells = new Map();
+    const meta = {
+      deep,
+      scope,
+      cells
+    };
+    const shared = createSharedHandler(cells, scope, deep, targetIsMap);
+    const specific = targetIsMap ? createMapHandler(cells, scope, deep) : createSetHandler(cells, scope);
+    const instrumentations = mergeHandlers(shared, specific);
+    const proxy = new Proxy(target, {
+      get(_obj, prop, receiver) {
+        if (prop === Keys.Raw) return target;
+        if (prop === Keys.Meta) return meta;
+        if (prop === Symbol.toStringTag) return targetIsMap ? 'Map' : 'Set';
+        if (prop === 'size') {
+          trackIterator(cells, scope);
+          return Reflect.get(target, 'size', target);
+        }
+        if (prop in instrumentations) {
+          const fn = instrumentations[prop];
+          return typeof fn === 'function' ? fn.bind(receiver) : fn;
+        }
+        const value = Reflect.get(target, prop, receiver);
+        if (typeof value === 'function') return value;
+        return deep ? deepSignal(value, scope) : value;
+      }
+    });
+    rawToProxy.set(target, proxy);
+    return proxy;
+  }
   const cells = new Map();
   const targetIsArray = Array.isArray(target);
   const targetIsStore = Boolean(target.constructor?.[IsStore]);
@@ -803,6 +995,7 @@ const deepSignal = (target, scope, deep = true) => {
       if (targetIsStore && isIgnoreKey(obj.constructor[StoreIgnoreKeys], prop) || typeof value === 'function') {
         return Reflect.set(obj, prop, value, receiver);
       }
+      const isNewKey = !Reflect.has(obj, prop);
       batchStart();
       const success = Reflect.set(obj, prop, value, receiver);
       const cell = cells.get(prop);
@@ -811,8 +1004,8 @@ const deepSignal = (target, scope, deep = true) => {
       }
       if (targetIsArray) {
         handleArraySet(obj, prop, value, receiver);
-      } else {
-        triggerIter(obj, prop, value, receiver);
+      } else if (isNewKey) {
+        receiver[Keys.Iterator] = (receiver[Keys.Raw][Keys.Iterator] || 0) + 1;
       }
       batchEnd();
       return success;
@@ -822,8 +1015,11 @@ const deepSignal = (target, scope, deep = true) => {
         return Reflect.deleteProperty(obj, prop);
       }
       cells.delete(prop);
-      triggerIter(obj, prop, undefined, proxy);
-      return Reflect.deleteProperty(obj, prop);
+      const result = Reflect.deleteProperty(obj, prop);
+      if (!targetIsArray) {
+        proxy[Keys.Iterator] = (obj[Keys.Iterator] || 0) + 1;
+      }
+      return result;
     },
     ownKeys(obj) {
       if (targetIsArray) {
@@ -831,7 +1027,7 @@ const deepSignal = (target, scope, deep = true) => {
       } else {
         proxy[Keys.Iterator];
       }
-      return Reflect.ownKeys(obj);
+      return Reflect.ownKeys(obj).filter(key => key !== Keys.Iterator);
     }
   });
   rawToProxy.set(target, proxy);
@@ -1208,6 +1404,7 @@ function warpCallbackArgs(isDeep, args, scope, wrapArgs = 0b01) {
   args[0] = wrapCb;
 }
 
+const isParentKey = (parentStore, expr) => expr in parentStore[Keys.Raw];
 class Store {
   static [IsStore] = true;
   static [StoreIgnoreKeys] = ['ui', 'raw'];
@@ -1218,18 +1415,31 @@ class Store {
     return proxy;
   }
   parent = () => null;
-  static new(keyMap = {}, staticMap = {}) {
+  static new(keyMap, staticMap) {
     const parentStore = Store.Current;
     const child = new this();
-    if (parentStore) {
+    if (parentStore && keyMap) {
+      const cells = child[Keys.Meta].cells;
       for (const childKey in keyMap) {
-        const parentKey = keyMap[childKey];
-        shareSignal(parentStore, parentKey, child, childKey);
+        const expr = keyMap[childKey];
+        if (typeof expr === 'function') {
+          cells.set(childKey, new Computed(() => expr(parentStore)));
+          child[Keys.Raw][childKey] = undefined;
+        } else if (typeof expr === 'string') {
+          if (isParentKey(parentStore, expr)) {
+            shareSignal(parentStore, expr, child, childKey);
+          } else {
+            const fn = new Function('data', `let v;with(data){v=${expr};}return v;`);
+            cells.set(childKey, new Computed(() => fn(parentStore)));
+            child[Keys.Raw][childKey] = undefined;
+          }
+        } else {
+          shareSignal(parentStore, expr, child, childKey);
+        }
       }
     }
     for (const key in staticMap) {
-      const value = staticMap[key];
-      child[key] = value;
+      child[key] = staticMap[key];
     }
     child.parent = () => parentStore;
     Store.Current = parentStore;
@@ -1376,6 +1586,7 @@ exports.Scope = Scope;
 exports.Signal = Signal;
 exports.Store = Store;
 exports.StoreIgnoreKeys = StoreIgnoreKeys;
+exports.batchDeep = batchDeep;
 exports.batchEnd = batchEnd;
 exports.batchStart = batchStart;
 exports.clean = clean;