aoye 0.0.6 → 0.0.7

package/dist/aoye.esm.js

@@ -1,29 +1,33 @@
-import { BaseEvent, SortMap } from 'bobe-shared';
+import { BaseEvent, SortMap, Queue } from 'bobe-shared';
 
-const evt = new BaseEvent();
+new BaseEvent();
 const G = {
   /** 原子 signal 更新次数 */
   version: 0,
   id: 0,
   /** scope 销毁任务序号 */
   scopeDisposeI: 0,
-  PullingSignal: null
+  PullingSignal: null,
+  /** 表示当前处于 pull 递归中 */
+  PullingRecurseDeep: 0
 };
-const dirtyLeafs = new SortMap();
+new 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);
@@ -128,6 +132,26 @@ class PriorityQueue {
   }
 }
 
+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;
@@ -151,18 +175,19 @@ class TaskQueue {
     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));
   }
 }
 
@@ -190,40 +215,88 @@ const micro = (cb) => {
   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 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;
@@ -556,32 +629,46 @@ var __objRest = (source, exclude) => {
   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) {
@@ -621,6 +708,7 @@ const _Signal = class _Signal {
    */
   pullRecurse(shouldLink = true) {
     var _a, _b;
+    G.PullingRecurseDeep++;
     let downstream = G.PullingSignal;
     const isScope = this.state & State.IsScope;
     if (
@@ -636,6 +724,7 @@ const _Signal = class _Signal {
         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;
@@ -653,9 +742,11 @@ const _Signal = class _Signal {
       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() {
@@ -666,10 +757,10 @@ const _Signal = class _Signal {
     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;
@@ -679,7 +770,7 @@ const _Signal = class _Signal {
           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;
@@ -697,7 +788,7 @@ const _Signal = class _Signal {
           node.state &= ~State.Unknown;
         }
         node.version = G.version;
-        node.state &= ~State.Check;
+        pullingPostprocess(node);
         return noGoSibling;
       }
     });
@@ -736,6 +827,7 @@ const _Signal = class _Signal {
     G.version++;
     markDeep(this);
   }
+  /** 返回值为 true 表示已处理 */
   runIfDirty() {
     this.state & (State.Unknown | State.Dirty) && this.v;
   }
@@ -750,6 +842,54 @@ const _Signal = class _Signal {
 _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;
@@ -766,13 +906,26 @@ var __spreadValues = (a, b) => {
     }
   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;
   }
@@ -841,6 +994,12 @@ const customEffect = (opt) => {
     return effect(init, __spreadValues(__spreadValues({}, opt), innerOpt));
   });
 };
+const isSignal = (value) => {
+  return value instanceof Signal;
+};
+const isScope = (value) => {
+  return value instanceof Signal;
+};
 
-export { $, Scheduler, TaskQueue, clean, customEffect, effect, runWithPulling, scheduler, scope };
+export { $, Keys, Scheduler, TaskQueue, clean, customEffect, effect, isScope, isSignal, registerScheduler, runWithPulling, scope };
 //# sourceMappingURL=aoye.esm.js.map