aoye 0.0.52 → 0.0.54

package/dist/index.d.ts

@@ -132,6 +132,10 @@ declare class Signal<T = any> {
 
 declare const batchStart: () => number;
 declare const batchEnd: () => void;
+/** effect、computed 回调执行的唯一 id
+ * 用于判断重复依赖属于同一 effect、effect、computed
+ */
+declare const batchDeep: () => number;
 declare function clean(onClean: OnClean): void;
 
 declare const execIdInc: () => number;
@@ -202,7 +206,17 @@ declare class Store {
     static Current: Store;
     constructor();
     parent: () => Store | null;
-    static new<T extends Store = any, P extends Store = any, O extends string = ''>(this: new (...args: any[]) => T, keyMap?: PRecord<keyof T, keyof Omit<P, O> | DeepOmitPath<P, O>>, staticMap?: PRecord<keyof T, any>): T;
+    /**
+     * 创建子 Store 实例并传递属性：
+     * Store.new({ prop1: `v1+v2`, prop2: (p) => p.v3 * p.v4 }, { prop3: 123 })
+     *
+     * keyMap：childKey → 表达式
+     *   - string：解析为 with(parentStore) { ... } 表达式，结果包装为 Computed
+     *   - Function：直接包装为 Computed(() => fn(parentStore))
+     *
+     * staticMap：childKey → 静态值，直接赋值
+     */
+    static new<T extends Store = any, P extends Store = any, O extends string = ''>(this: new (...args: any[]) => T, keyMap?: PRecord<keyof T, keyof Omit<P, O> | DeepOmitPath<P, O>> | Record<string, string | Function>, staticMap?: PRecord<keyof T, any>): T;
     map<P extends Store = any, O extends string = ''>(keyMap?: PRecord<keyof this, keyof Omit<P, O> | DeepOmitPath<P, O>>): void;
 }
 
@@ -229,5 +243,5 @@ declare function effectUt(callback: (...args: ValueDiff[]) => void, depOrOpt?: a
 declare function effect(callback: (...args: ValueDiff[]) => void, depOrOpt?: any[] | CustomEffectOpt, opt?: CustomEffectOpt): Effect;
 declare function scope(...args: any[]): any;
 
-export { $, Computed, Effect, EffectStrType2Enum, IsStore, Keys, NoopEffect, ScheduleStatus, ScheduleType, Scope, Signal, Store, StoreIgnoreKeys, batchEnd, batchStart, clean, deepSignal, effect, effectUt, execId, execIdInc, getPulling, ide, macro, micro, noopEffect, now, runWithPulling, scope, setExecId, setPulling, shareSignal, toRaw };
+export { $, Computed, Effect, EffectStrType2Enum, IsStore, Keys, NoopEffect, ScheduleStatus, ScheduleType, Scope, Signal, Store, StoreIgnoreKeys, batchDeep, batchEnd, batchStart, clean, deepSignal, effect, effectUt, execId, execIdInc, getPulling, ide, macro, micro, noopEffect, now, runWithPulling, scope, setExecId, setPulling, shareSignal, toRaw };
 export type { CreateScope, CreateTaskProps, CustomEffectOpt, DeepOmitPath, DeepPath, DeepValue, Dispose, Key, Link, MatchValue, Mix, OnClean, OutLink, PRecord, ScheduleTypeStr, SideEffect, SignalNode, SignalType, Task, TaskControlReturn, ValueDiff };

package/dist/index.umd.js

@@ -486,7 +486,11 @@
     }
     up.emitTail = line;
     if (recHead) {
-      recTail.nextRecLine = line;
+      if (recTail) {
+        recTail.nextRecLine = line;
+      } else {
+        down.recHead = line;
+      }
     } else {
       down.recHead = line;
     }
@@ -549,7 +553,11 @@
     }
     up.emitTail = line;
     if (recHead) {
-      recTail.nextRecLine = line;
+      if (recTail) {
+        recTail.nextRecLine = line;
+      } else {
+        down.recHead = line;
+      }
     } else {
       down.recHead = line;
     }
@@ -752,11 +760,195 @@
   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]);
@@ -805,6 +997,7 @@
         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);
@@ -813,8 +1006,8 @@
         }
         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;
@@ -824,8 +1017,11 @@
           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) {
@@ -833,7 +1029,7 @@
         } else {
           proxy[Keys.Iterator];
         }
-        return Reflect.ownKeys(obj);
+        return Reflect.ownKeys(obj).filter(key => key !== Keys.Iterator);
       }
     });
     rawToProxy.set(target, proxy);
@@ -1210,6 +1406,7 @@
     args[0] = wrapCb;
   }
 
+  const isParentKey = (parentStore, expr) => expr in parentStore[Keys.Raw];
   class Store {
     static [IsStore] = true;
     static [StoreIgnoreKeys] = ['ui', 'raw'];
@@ -1220,18 +1417,31 @@
       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;
@@ -1378,6 +1588,7 @@
   exports.Signal = Signal;
   exports.Store = Store;
   exports.StoreIgnoreKeys = StoreIgnoreKeys;
+  exports.batchDeep = batchDeep;
   exports.batchEnd = batchEnd;
   exports.batchStart = batchStart;
   exports.clean = clean;