aoye 0.0.6 → 0.0.7

package/dist/index.umd.js

@@ -4,30 +4,34 @@
   (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.Aoye = {}, global.BobeShared));
 })(this, (function (exports, bobeShared) { 'use strict';
 
-  const evt = new bobeShared.BaseEvent();
+  new bobeShared.BaseEvent();
   const G = {
     /** 原子 signal 更新次数 */
     version: 0,
     id: 0,
     /** scope 销毁任务序号 */
     scopeDisposeI: 0,
-    PullingSignal: null
+    PullingSignal: null,
+    /** 表示当前处于 pull 递归中 */
+    PullingRecurseDeep: 0
   };
-  const dirtyLeafs = new bobeShared.SortMap();
+  new bobeShared.SortMap();
   var State = /* @__PURE__ */ ((State2) => {
     State2[State2["Clean"] = 0] = "Clean";
-    State2[State2["LinkScopeOnly"] = 64] = "LinkScopeOnly";
-    State2[State2["ScopeAbort"] = 32] = "ScopeAbort";
-    State2[State2["ScopeReady"] = 16] = "ScopeReady";
-    State2[State2["IsScope"] = 8] = "IsScope";
+    State2[State2["LinkScopeOnly"] = 256] = "LinkScopeOnly";
+    State2[State2["ScopeAbort"] = 128] = "ScopeAbort";
+    State2[State2["ScopeReady"] = 64] = "ScopeReady";
+    State2[State2["IsScope"] = 32] = "IsScope";
+    State2[State2["PullingDirty"] = 16] = "PullingDirty";
+    State2[State2["PullingUnknown"] = 8] = "PullingUnknown";
     State2[State2["Unknown"] = 4] = "Unknown";
     State2[State2["Dirty"] = 2] = "Dirty";
-    State2[State2["Check"] = 1] = "Check";
+    State2[State2["Pulling"] = 1] = "Pulling";
     return State2;
   })(State || {});
   const DirtyState = 4 /* Unknown */ | 2 /* Dirty */;
-  const ScopeExecuted = 16 /* ScopeReady */ | 32 /* ScopeAbort */;
-  const ScopeAbort = 32 /* ScopeAbort */;
+  const ScopeExecuted = 64 /* ScopeReady */ | 128 /* ScopeAbort */;
+  const ScopeAbort = 128 /* ScopeAbort */;
 
   const leakI = (y, max) => y < 0 || y >= max ? null : y;
   const getLeft = (x, max) => leakI(x * 2 + 1, max);
@@ -132,6 +136,26 @@
     }
   }
 
+  var __defProp$2 = Object.defineProperty;
+  var __getOwnPropSymbols$3 = Object.getOwnPropertySymbols;
+  var __hasOwnProp$3 = Object.prototype.hasOwnProperty;
+  var __propIsEnum$3 = Object.prototype.propertyIsEnumerable;
+  var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __spreadValues$2 = (a, b) => {
+    for (var prop in b || (b = {}))
+      if (__hasOwnProp$3.call(b, prop))
+        __defNormalProp$2(a, prop, b[prop]);
+    if (__getOwnPropSymbols$3)
+      for (var prop of __getOwnPropSymbols$3(b)) {
+        if (__propIsEnum$3.call(b, prop))
+          __defNormalProp$2(a, prop, b[prop]);
+      }
+    return a;
+  };
+  const DefaultTaskControlReturn = {
+    finished: true,
+    startNewCallbackAble: true
+  };
   class TaskQueue {
     constructor(callbackAble, aIsUrgent) {
       this.callbackAble = callbackAble;
@@ -155,18 +179,19 @@
       const { taskQueue } = this;
       const fn = taskQueue.peek();
       if (!fn) return this.isScheduling = false;
-      const hasRemain = fn();
-      if (hasRemain) {
-        this.callbackAble(this.scheduleTask.bind(this));
-        return;
+      let info = fn() || {};
+      info = __spreadValues$2(__spreadValues$2({}, DefaultTaskControlReturn), info);
+      if (info.finished) {
+        taskQueue.poll();
+        if (taskQueue.size() === 0) {
+          return this.isScheduling = false;
+        }
       }
-      taskQueue.poll();
-      evt.emit("one", fn);
-      if (taskQueue.size() === 0) {
-        evt.emit("done", fn);
-        return this.isScheduling = false;
+      if (info.startNewCallbackAble) {
+        this.callbackAble(this.scheduleTask.bind(this));
+      } else {
+        this.scheduleTask();
       }
-      this.callbackAble(this.scheduleTask.bind(this));
     }
   }
 
@@ -194,40 +219,88 @@
     p.then(cb);
   };
 
-  var Scheduler = /* @__PURE__ */ ((Scheduler2) => {
-    Scheduler2["Sync"] = "__Sync_";
-    Scheduler2["Layout"] = "__Layout_";
-    Scheduler2["Micro"] = "__Micro_";
-    Scheduler2["Macro"] = "__Macro_";
-    return Scheduler2;
-  })(Scheduler || {});
-  const _scheduler = {
-    ["__Sync_" /* Sync */]: defaultScheduler,
-    ["__Micro_" /* Micro */]: microScheduler,
-    ["__Macro_" /* Macro */]: macroScheduler,
-    ["__Layout_" /* Layout */]: layoutScheduler
-  };
-  const scheduler = (key, value) => _scheduler[key] = value;
-  function defaultScheduler(effects) {
-    for (const effect of effects) {
-      effect.runIfDirty();
+  class Scheduler {
+    constructor() {
+      this.effectQueue = new bobeShared.Queue();
+    }
+    addEffect(effect) {
+      var _a;
+      const item = this.effectQueue.push(effect);
+      (_a = this.onEffectAdded) == null ? void 0 : _a.call(this, effect, item, this.effectQueue);
+      return item;
+    }
+  }
+  Scheduler.Sync = "__Sync_";
+  Scheduler.Layout = "__Layout_";
+  Scheduler.Micro = "__Micro_";
+  Scheduler.Macro = "__Macro_";
+  class SyncScheduler extends Scheduler {
+    onOneSetEffectsAdded(subQueue, queue) {
+      subQueue.forEach((effect, item) => {
+        effect.runIfDirty();
+        subQueue.delete(item);
+      });
     }
   }
-  let microSTaskQueue;
-  let macroSTaskQueue;
-  let layoutSTaskQueue;
-  function microScheduler(effects) {
-    microSTaskQueue = microSTaskQueue || TaskQueue.create({ callbackAble: micro, aIsUrgent: (a, b) => a.time < b.time });
-    microSTaskQueue.pushTask(defaultScheduler.bind(null, effects));
+  class MicroScheduler extends Scheduler {
+    constructor() {
+      super(...arguments);
+      this.taskQueue = TaskQueue.create({ callbackAble: micro, aIsUrgent: (a, b) => a.time < b.time });
+    }
+    onOneSetEffectsAdded(subQueue, queue) {
+      const task = () => {
+        subQueue.forEach((effect, item) => {
+          effect.runIfDirty();
+          subQueue.delete(item);
+        });
+        return {
+          finished: true,
+          startNewCallbackAble: false
+        };
+      };
+      task.time = Date.now();
+      this.taskQueue.pushTask(task);
+    }
   }
-  function macroScheduler(effects) {
-    macroSTaskQueue = macroSTaskQueue || TaskQueue.create({ callbackAble: macro, aIsUrgent: (a, b) => a.time < b.time });
-    macroSTaskQueue.pushTask(defaultScheduler.bind(null, effects));
+  class MacroScheduler extends Scheduler {
+    constructor() {
+      super(...arguments);
+      this.taskQueue = TaskQueue.create({ callbackAble: macro, aIsUrgent: (a, b) => a.time < b.time });
+    }
+    onOneSetEffectsAdded(subQueue, queue) {
+      const task = () => {
+        subQueue.forEach((effect, item) => {
+          effect.runIfDirty();
+          subQueue.delete(item);
+        });
+      };
+      task.time = Date.now();
+      this.taskQueue.pushTask(task);
+    }
   }
-  function layoutScheduler(effects) {
-    layoutSTaskQueue = layoutSTaskQueue || TaskQueue.create({ callbackAble: macro, aIsUrgent: (a, b) => a.time < b.time });
-    layoutSTaskQueue.pushTask(defaultScheduler.bind(null, effects));
+  class LayoutScheduler extends Scheduler {
+    constructor() {
+      super(...arguments);
+      this.taskQueue = TaskQueue.create({ callbackAble: macro, aIsUrgent: (a, b) => a.time < b.time });
+    }
+    onOneSetEffectsAdded(subQueue, queue) {
+      const task = () => {
+        subQueue.forEach((effect, item) => {
+          effect.runIfDirty();
+          subQueue.delete(item);
+        });
+      };
+      task.time = Date.now();
+      this.taskQueue.pushTask(task);
+    }
   }
+  const _scheduler = {
+    [Scheduler.Sync]: new SyncScheduler(),
+    [Scheduler.Micro]: new MicroScheduler(),
+    [Scheduler.Macro]: new MacroScheduler(),
+    [Scheduler.Layout]: new LayoutScheduler()
+  };
+  const registerScheduler = (key, Ctor) => _scheduler[key] = new Ctor();
 
   var __defProp$1 = Object.defineProperty;
   var __getOwnPropSymbols$2 = Object.getOwnPropertySymbols;
@@ -560,32 +633,46 @@
     return target;
   };
   const markDeep = (signal) => {
-    let level = 0;
+    let level = 0, firstEffectItem, lastEffectItem, updatedSchedulers = /* @__PURE__ */ new Set();
     dfs(signal, {
       isUp: false,
       begin: ({ node }) => {
-        if (node.state & (State.Check | State.Unknown | State.Dirty) || node.isDisabled()) {
+        if (node.isDisabled()) {
           return true;
         }
+        const inPullingArea = node.state & State.Pulling;
+        const Unknown = inPullingArea ? State.PullingUnknown : State.Unknown;
         const isEffect = level > 0;
         const isLeaf = !node.emitStart || node.emitStart.downstream === node.scope;
         if (isEffect) {
-          node.state |= State.Unknown;
+          node.state |= Unknown;
         } else if (!isLeaf) {
           node.state |= State.Dirty;
         }
-        if (isLeaf && isEffect) {
-          dirtyLeafs.add(node.scheduler, node);
+        if (isLeaf && isEffect && !inPullingArea) {
+          const key = node.scheduler;
+          const instance = _scheduler[key];
+          const item = instance.addEffect(node);
+          if (!firstEffectItem) {
+            firstEffectItem = item;
+          }
+          lastEffectItem = item;
+          updatedSchedulers.add(key);
         }
         level++;
       }
     });
-    for (const key in dirtyLeafs.data) {
-      const effects = dirtyLeafs.data[key];
-      const scheduler = _scheduler[key];
-      scheduler(effects);
+    for (const key of updatedSchedulers) {
+      const instance = _scheduler[key];
+      instance == null ? void 0 : instance.onOneSetEffectsAdded(instance.effectQueue.subRef(firstEffectItem, lastEffectItem), instance.effectQueue);
+    }
+  };
+  const pullingPostprocess = (node) => {
+    node.state &= ~State.Pulling;
+    if (node.state & State.PullingUnknown) {
+      node.state &= ~State.PullingUnknown;
+      node.state |= State.Unknown;
     }
-    dirtyLeafs.clear();
   };
   const _Signal = class _Signal {
     constructor(nextValue, customPull) {
@@ -625,6 +712,7 @@
      */
     pullRecurse(shouldLink = true) {
       var _a, _b;
+      G.PullingRecurseDeep++;
       let downstream = G.PullingSignal;
       const isScope = this.state & State.IsScope;
       if (
@@ -640,6 +728,7 @@
           return this.value;
         }
         this.recEnd = null;
+        this.state |= State.Pulling;
         G.PullingSignal = this;
         (_a = this.clean) == null ? void 0 : _a.call(this);
         this.clean = null;
@@ -657,9 +746,11 @@
         console.error("\u8BA1\u7B97\u5C5E\u6027\u62A5\u9519\u8FD9\u6B21\u4E0D\u89E6\u53D1\uFF0C\u540E\u7EED\u72B6\u6001\u53EF\u80FD\u51FA\u9519", error);
         return this.value;
       } finally {
+        pullingPostprocess(this);
         const toDel = (_b = this.recEnd) == null ? void 0 : _b.nextRecLine;
         unlinkRecWithScope(toDel);
         G.PullingSignal = downstream;
+        G.PullingRecurseDeep--;
       }
     }
     pullDeep() {
@@ -670,10 +761,10 @@
       dfs(signal, {
         isUp: true,
         begin: ({ node }) => {
-          if (node.state & State.Check || !(node.state & DirtyState) || node.isDisabled()) {
+          if (node.state & State.Pulling || !(node.state & DirtyState) || node.isDisabled()) {
             return true;
           }
-          node.state |= State.Check;
+          node.state |= State.Pulling;
         },
         complete: ({ node, notGoDeep: currentClean, walkedLine }) => {
           let noGoSibling = false;
@@ -683,7 +774,7 @@
             if (!node.recStart && node.value !== node.nextValue) {
               node.markDownStreamsDirty();
               node.state &= ~State.Dirty;
-              node.state &= ~State.Check;
+              node.state &= ~State.Pulling;
               return;
             } else {
               const prevPulling = G.PullingSignal;
@@ -701,7 +792,7 @@
             node.state &= ~State.Unknown;
           }
           node.version = G.version;
-          node.state &= ~State.Check;
+          pullingPostprocess(node);
           return noGoSibling;
         }
       });
@@ -740,6 +831,7 @@
       G.version++;
       markDeep(this);
     }
+    /** 返回值为 true 表示已处理 */
     runIfDirty() {
       this.state & (State.Unknown | State.Dirty) && this.v;
     }
@@ -754,6 +846,54 @@
   _Signal.Pulling = null;
   let Signal = _Signal;
 
+  var Keys = /* @__PURE__ */ ((Keys2) => {
+    Keys2["Iterator"] = "__Aoye_Iterator";
+    Keys2["Raw"] = "__Aoye_Raw";
+    return Keys2;
+  })(Keys || {});
+
+  const proxyMap = /* @__PURE__ */ new WeakMap();
+  const deepSignal = (target, deep = true) => {
+    const isObj = typeof target === "object" && target !== null;
+    if (!isObj) return target;
+    if (proxyMap.has(target)) return proxyMap.get(target);
+    const cells = /* @__PURE__ */ new Map();
+    const proxy = new Proxy(target, {
+      get(obj, prop, receiver) {
+        if (prop === Keys.Raw) {
+          return target;
+        }
+        if (cells.has(prop)) {
+          return cells.get(prop).v;
+        }
+        const value = Reflect.get(obj, prop, receiver);
+        const wrappedValue = deep ? deepSignal(value) : value;
+        const s = Signal.create(wrappedValue, {
+          scheduler: Scheduler.Sync,
+          isScope: false
+        });
+        cells.set(prop, s);
+        return s.v;
+      },
+      set(obj, prop, value, receiver) {
+        if (cells.has(prop)) {
+          const cell = cells.get(prop);
+          cell.v = deep ? deepSignal(value) : value;
+        }
+        return Reflect.set(obj, prop, value, receiver);
+      },
+      // 【核心修改】拦截 delete 操作
+      deleteProperty(obj, prop) {
+        if (cells.has(prop)) {
+          cells.delete(prop);
+        }
+        return Reflect.deleteProperty(obj, prop);
+      }
+    });
+    proxyMap.set(target, proxy);
+    return proxy;
+  };
+
   var __defProp = Object.defineProperty;
   var __getOwnPropSymbols = Object.getOwnPropertySymbols;
   var __hasOwnProp = Object.prototype.hasOwnProperty;
@@ -770,13 +910,26 @@
       }
     return a;
   };
+  const DefaultCustomSignalOpt = {
+    /** 三种模式
+     * 1. auto:   根据值类型自动判断 默认
+     * 2. ref:    对任何值使用 {v: xxx} 进行包装
+     * 3. proxy:  使用 proxy 进行包装
+     */
+    mode: "auto",
+    /** 是否深度响应式 */
+    deep: true
+  };
   ({
     scheduler: Scheduler.Sync});
-  const $ = (init) => {
+  const $ = (init, opt = {}) => {
+    opt = __spreadValues(__spreadValues({}, DefaultCustomSignalOpt), opt);
     let intiValue, customPull;
-    if (init instanceof Function) {
+    if (typeof init === "function") {
       intiValue = null;
       customPull = init;
+    } else if (opt.mode !== "ref" && typeof init === "object" && init !== null) {
+      return deepSignal(init, opt.deep);
     } else {
       intiValue = init;
     }
@@ -845,15 +998,24 @@
       return effect(init, __spreadValues(__spreadValues({}, opt), innerOpt));
     });
   };
+  const isSignal = (value) => {
+    return value instanceof Signal;
+  };
+  const isScope = (value) => {
+    return value instanceof Signal;
+  };
 
   exports.$ = $;
+  exports.Keys = Keys;
   exports.Scheduler = Scheduler;
   exports.TaskQueue = TaskQueue;
   exports.clean = clean;
   exports.customEffect = customEffect;
   exports.effect = effect;
+  exports.isScope = isScope;
+  exports.isSignal = isSignal;
+  exports.registerScheduler = registerScheduler;
   exports.runWithPulling = runWithPulling;
-  exports.scheduler = scheduler;
   exports.scope = scope;
 
 }));