aoye 0.0.52 → 0.0.53

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, raw) => {
+  const iter = cells.get(Keys.Iterator);
+  if (iter) {
+    iter.set((raw[Keys.Iterator] || 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, target);
+      }
+      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, target);
+      }
+      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, target);
+    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, target);
+    }
+    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);
@@ -1376,6 +1572,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;