aoye 0.0.6 → 0.0.8

package/dist/aoye.cjs.js

@@ -2,30 +2,34 @@
 
 var bobeShared = require('bobe-shared');
 
-const evt = new bobeShared.BaseEvent();
+const rawToProxy = /* @__PURE__ */ new WeakMap();
+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();
 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);
@@ -130,6 +134,26 @@ class PriorityQueue {
   }
 }
 
+var __defProp$3 = Object.defineProperty;
+var __getOwnPropSymbols$4 = Object.getOwnPropertySymbols;
+var __hasOwnProp$4 = Object.prototype.hasOwnProperty;
+var __propIsEnum$4 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$3 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$4.call(b, prop))
+      __defNormalProp$3(a, prop, b[prop]);
+  if (__getOwnPropSymbols$4)
+    for (var prop of __getOwnPropSymbols$4(b)) {
+      if (__propIsEnum$4.call(b, prop))
+        __defNormalProp$3(a, prop, b[prop]);
+    }
+  return a;
+};
+const DefaultTaskControlReturn = {
+  finished: true,
+  startNewCallbackAble: true
+};
 class TaskQueue {
   constructor(callbackAble, aIsUrgent) {
     this.callbackAble = callbackAble;
@@ -153,21 +177,30 @@ 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$3(__spreadValues$3({}, 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));
   }
 }
 
+var Keys = /* @__PURE__ */ ((Keys2) => {
+  Keys2["Iterator"] = "__AOYE_ITERATOR";
+  Keys2["Raw"] = "__AOYE_RAW";
+  Keys2["Deep"] = "__AOYE_DEEP";
+  Keys2["Scope"] = "__AOYE_SCOPE";
+  return Keys2;
+})(Keys || {});
+
 let channel = globalThis.MessageChannel ? new MessageChannel() : null;
 if (globalThis.MessageChannel) {
   channel = new MessageChannel();
@@ -191,55 +224,121 @@ const p = Promise.resolve();
 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 toRaw = (a) => {
+  if (typeof a === "object" && a !== null && a[Keys.Raw]) {
+    return toRaw(a[Keys.Raw]);
+  }
+  return a;
 };
-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();
+    /** 每当 Set 或 BatchSet 开始时标记 */
+    this.firstEffectItem = null;
+    /** 记录 Set 或 BatchSet 产生的最后一个 Effect */
+    this.lastEffectItem = null;
+  }
+  endSet() {
+    var _a;
+    if (!this.firstEffectItem) return;
+    const subQueue = this.effectQueue.subRef(this.firstEffectItem, this.lastEffectItem);
+    (_a = this.onOneSetEffectsAdded) == null ? void 0 : _a.call(this, subQueue, this.effectQueue);
+    this.firstEffectItem = null;
+    this.lastEffectItem = null;
+  }
+  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;
   }
 }
-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));
+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);
+    });
+  }
 }
-function macroScheduler(effects) {
-  macroSTaskQueue = macroSTaskQueue || TaskQueue.create({ callbackAble: macro, aIsUrgent: (a, b) => a.time < b.time });
-  macroSTaskQueue.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);
+  }
+}
+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;
-var __hasOwnProp$2 = Object.prototype.hasOwnProperty;
-var __propIsEnum$2 = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues$1 = (a, b) => {
+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$2.call(b, prop))
-      __defNormalProp$1(a, prop, b[prop]);
-  if (__getOwnPropSymbols$2)
-    for (var prop of __getOwnPropSymbols$2(b)) {
-      if (__propIsEnum$2.call(b, prop))
-        __defNormalProp$1(a, prop, b[prop]);
+    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;
 };
@@ -252,7 +351,7 @@ const DefaultDFSOpt = {
   breakNode: null
 };
 function dfs(root, opt = {}) {
-  const { isUp, begin, complete, breakStack: lineStack, breakLine } = __spreadValues$1(__spreadValues$1({}, DefaultDFSOpt), opt);
+  const { isUp, begin, complete, breakStack: lineStack, breakLine } = __spreadValues$2(__spreadValues$2({}, DefaultDFSOpt), opt);
   let node = opt.breakNode || root;
   let line = breakLine;
   const listKey = isUp ? "recStart" : "emitStart";
@@ -538,52 +637,89 @@ function clean(cb) {
 function runWithPulling(fn, signal) {
   const prevPulling = G.PullingSignal;
   G.PullingSignal = signal;
-  fn();
+  const res = fn();
   G.PullingSignal = prevPulling;
+  return res;
 }
 
-var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
-var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
-var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
+class Batch {
+  constructor() {
+    this.deep = 0;
+  }
+  start() {
+    this.deep++;
+  }
+  end() {
+    this.deep--;
+    if (this.deep !== 0) return;
+    for (const key in _scheduler) {
+      const instance = _scheduler[key];
+      instance.endSet();
+    }
+  }
+  inBatch() {
+    return this.deep > 0;
+  }
+}
+const batch = new Batch();
+
+var __getOwnPropSymbols$2 = Object.getOwnPropertySymbols;
+var __hasOwnProp$2 = Object.prototype.hasOwnProperty;
+var __propIsEnum$2 = Object.prototype.propertyIsEnumerable;
 var __objRest = (source, exclude) => {
   var target = {};
   for (var prop in source)
-    if (__hasOwnProp$1.call(source, prop) && exclude.indexOf(prop) < 0)
+    if (__hasOwnProp$2.call(source, prop) && exclude.indexOf(prop) < 0)
       target[prop] = source[prop];
-  if (source != null && __getOwnPropSymbols$1)
-    for (var prop of __getOwnPropSymbols$1(source)) {
-      if (exclude.indexOf(prop) < 0 && __propIsEnum$1.call(source, prop))
+  if (source != null && __getOwnPropSymbols$2)
+    for (var prop of __getOwnPropSymbols$2(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum$2.call(source, prop))
         target[prop] = source[prop];
     }
   return target;
 };
 const markDeep = (signal) => {
-  let level = 0;
+  let level = 0, 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 (!instance.firstEffectItem) {
+          instance.firstEffectItem = item;
+        }
+        instance.lastEffectItem = item;
+        updatedSchedulers.add(key);
       }
       level++;
     }
   });
-  for (const key in dirtyLeafs.data) {
-    const effects = dirtyLeafs.data[key];
-    const scheduler = _scheduler[key];
-    scheduler(effects);
+  if (batch.inBatch()) return;
+  for (const key in _scheduler) {
+    const instance = _scheduler[key];
+    instance.endSet();
+  }
+};
+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) {
@@ -606,13 +742,16 @@ const _Signal = class _Signal {
     this.clean = null;
   }
   static create(nextValue, _a) {
-    var _b = _a, { customPull, isScope, immediate } = _b, rest = __objRest(_b, ["customPull", "isScope", "immediate"]);
+    var _b = _a, { customPull, isScope, scope, immediate } = _b, rest = __objRest(_b, ["customPull", "isScope", "scope", "immediate"]);
     const s = new _Signal(nextValue, customPull);
     s.pull = s.customPull || s.DEFAULT_PULL;
     Object.assign(s, rest);
     if (isScope) {
       s.state |= State.IsScope;
     }
+    if (scope !== void 0) {
+      s.scope = scope;
+    }
     return s;
   }
   DEFAULT_PULL() {
@@ -623,6 +762,7 @@ const _Signal = class _Signal {
    */
   pullRecurse(shouldLink = true) {
     var _a, _b;
+    G.PullingRecurseDeep++;
     let downstream = G.PullingSignal;
     const isScope = this.state & State.IsScope;
     if (
@@ -638,6 +778,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;
@@ -655,9 +796,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() {
@@ -668,10 +811,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;
@@ -681,7 +824,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;
@@ -699,7 +842,7 @@ const _Signal = class _Signal {
           node.state &= ~State.Unknown;
         }
         node.version = G.version;
-        node.state &= ~State.Check;
+        pullingPostprocess(node);
         return noGoSibling;
       }
     });
@@ -738,6 +881,7 @@ const _Signal = class _Signal {
     G.version++;
     markDeep(this);
   }
+  /** 返回值为 true 表示已处理 */
   runIfDirty() {
     this.state & (State.Unknown | State.Dirty) && this.v;
   }
@@ -752,6 +896,396 @@ const _Signal = class _Signal {
 _Signal.Pulling = null;
 let Signal = _Signal;
 
+var __defProp$1 = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
+var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
+var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$1 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$1.call(b, prop))
+      __defNormalProp$1(a, prop, b[prop]);
+  if (__getOwnPropSymbols$1)
+    for (var prop of __getOwnPropSymbols$1(b)) {
+      if (__propIsEnum$1.call(b, prop))
+        __defNormalProp$1(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+const deepSignal = (target, scope, deep = true) => {
+  const isObj = typeof target === "object" && target !== null;
+  if (!isObj || target[Keys.Raw]) return target;
+  if (rawToProxy.has(target)) return rawToProxy.get(target);
+  const cells = /* @__PURE__ */ new Map();
+  const targetIsArray = Array.isArray(target);
+  const proxy = new Proxy(target, {
+    get(obj, prop, receiver) {
+      switch (prop) {
+        case Keys.Raw:
+          return target;
+        case Keys.Deep:
+          return deep;
+        case Keys.Scope:
+          return scope;
+      }
+      const value = Reflect.get(obj, prop, receiver);
+      const valueIsFn = typeof value === "function";
+      if (valueIsFn) {
+        if (targetIsArray) {
+          return arrayMethodReWrites[prop] || value;
+        } else {
+          return value;
+        }
+      }
+      if (cells.has(prop)) {
+        return cells.get(prop).v;
+      }
+      const wrappedValue = deep ? deepSignal(value, scope) : value;
+      const s = Signal.create(wrappedValue, {
+        scheduler: Scheduler.Sync,
+        isScope: false,
+        scope
+      });
+      cells.set(prop, s);
+      return s.v;
+    },
+    set(obj, prop, value, receiver) {
+      batch.start();
+      const success = Reflect.set(obj, prop, value, receiver);
+      if (cells.has(prop)) {
+        const cell = cells.get(prop);
+        cell.v = deep ? deepSignal(value, scope) : value;
+      }
+      if (targetIsArray) {
+        handleArraySet(obj, prop, value, receiver);
+      }
+      batch.end();
+      return success;
+    },
+    // 【核心修改】拦截 delete 操作
+    deleteProperty(obj, prop) {
+      if (cells.has(prop)) {
+        cells.delete(prop);
+      }
+      return Reflect.deleteProperty(obj, prop);
+    },
+    ownKeys(obj) {
+      if (targetIsArray) {
+        proxy.length;
+      } else {
+        proxy[Keys.Iterator];
+      }
+      return Reflect.ownKeys(obj);
+    }
+  });
+  rawToProxy.set(target, proxy);
+  return proxy;
+};
+function handleArraySet(arr, prop, value, receiver) {
+  if (prop === "length") ; else if (bobeShared.isNatureNumStr(prop)) {
+    receiver[Keys.Iterator] = (arr[Keys.Iterator] || 0) + 1;
+  } else ;
+}
+const arrayMethodReWrites = {};
+["pop", "push", "shift", "splice", "unshift", "copyWithin", "reverse", "fill"].forEach((key) => {
+  arrayMethodReWrites[key] = function(...args) {
+    batch.start();
+    const fn = Array.prototype[key];
+    const res = runWithPulling(() => fn.call(this, ...args), null);
+    this[Keys.Iterator] = (this[Keys.Raw][Keys.Iterator] || 0) + 1;
+    batch.end();
+    return res;
+  };
+});
+["includes", "indexOf", "lastIndexOf"].forEach((key) => {
+  arrayMethodReWrites[key] = function(...args) {
+    const fn = Array.prototype[key];
+    const that = toRaw(this);
+    let result = fn.call(that, ...args);
+    const value = args[0];
+    if ((result === false || result === -1) && typeof value === "object" && value !== null) {
+      if (value[Keys.Raw]) {
+        args[0] = value[Keys.Raw];
+        result = fn.call(that, ...args);
+      }
+      if (rawToProxy.has(value)) {
+        args[0] = rawToProxy.get(value);
+        result = fn.call(that, ...args);
+      }
+    }
+    this[Keys.Iterator];
+    return result;
+  };
+});
+[Symbol.iterator, "values", "entries"].forEach((key) => {
+  const isEntries = key === "entries";
+  arrayMethodReWrites[key] = function(...args) {
+    const fn = Array.prototype[key];
+    const rawArray = toRaw(this);
+    const iter = fn.call(rawArray, ...args);
+    const scope = this[Keys.Scope];
+    const isDeep = this[Keys.Deep];
+    if (isDeep) {
+      const rawNext = iter.next.bind(iter);
+      iter.next = () => {
+        const result = rawNext();
+        if (!result.done) {
+          if (isEntries) {
+            result.value[1] = deepSignal(result.value[1], scope);
+          } else {
+            result.value = deepSignal(result.value, scope);
+          }
+        }
+        return result;
+      };
+    }
+    this[Keys.Iterator];
+    return iter;
+  };
+});
+arrayMethodReWrites.filter = function(callback, thisArg) {
+  const scope = this[Keys.Scope];
+  const isDeep = this[Keys.Deep];
+  const that = toRaw(this);
+  const result = [];
+  let resultIndex = 0;
+  const userThis = thisArg || that;
+  const len = that.length;
+  for (let i = 0; i < len; i++) {
+    if (i in that) {
+      const value = isDeep ? deepSignal(that[i], scope) : that[i];
+      if (callback.call(userThis, value, i, userThis)) {
+        result[resultIndex++] = value;
+      }
+    }
+  }
+  this[Keys.Iterator];
+  return result;
+};
+arrayMethodReWrites.slice = function(start, end) {
+  const scope = this[Keys.Scope];
+  const isDeep = this[Keys.Deep];
+  const that = toRaw(this);
+  const len = that.length;
+  let k = start || 0;
+  if (k < 0) {
+    k = Math.max(len + k, 0);
+  } else {
+    k = Math.min(k, len);
+  }
+  let final = end === void 0 ? len : end;
+  if (final < 0) {
+    final = Math.max(len + final, 0);
+  } else {
+    final = Math.min(final, len);
+  }
+  const count = Math.max(final - k, 0);
+  const result = new Array(count);
+  for (let i = 0; i < count; i++) {
+    if (i + k in that) {
+      result[i] = isDeep ? deepSignal(that[i + k], scope) : that[i + k];
+    }
+  }
+  this[Keys.Iterator];
+  return result;
+};
+arrayMethodReWrites.toReversed = function() {
+  const scope = this[Keys.Scope];
+  const isDeep = this[Keys.Deep];
+  const that = toRaw(this);
+  const len = that.length;
+  const result = new Array(len);
+  let k = 0;
+  while (k < len) {
+    result[k] = isDeep ? deepSignal(that[len - 1 - k], scope) : that[len - 1 - k];
+    k++;
+  }
+  this[Keys.Iterator];
+  return result;
+};
+arrayMethodReWrites.toSpliced = function(start, deleteCount, ...items) {
+  const scope = this[Keys.Scope];
+  const isDeep = this[Keys.Deep];
+  const that = toRaw(this);
+  const len = that.length;
+  let relativeStart = start >> 0;
+  let actualStart = relativeStart < 0 ? Math.max(len + relativeStart, 0) : Math.min(relativeStart, len);
+  let actualDeleteCount;
+  if (arguments.length === 0) {
+    actualDeleteCount = 0;
+  } else if (arguments.length === 1) {
+    actualDeleteCount = len - actualStart;
+  } else {
+    let dc = deleteCount >> 0;
+    actualDeleteCount = Math.min(Math.max(dc, 0), len - actualStart);
+  }
+  const insertCount = items.length;
+  const newLen = len - actualDeleteCount + insertCount;
+  const result = new Array(newLen);
+  for (let i = 0; i < actualStart; i++) {
+    result[i] = isDeep ? deepSignal(that[i], scope) : that[i];
+  }
+  for (let i = 0; i < insertCount; i++) {
+    result[actualStart + i] = isDeep ? deepSignal(items[i], scope) : items[i];
+  }
+  const remainingStart = actualStart + actualDeleteCount;
+  const resultOffset = actualStart + insertCount;
+  for (let i = 0; i < len - remainingStart; i++) {
+    result[resultOffset + i] = isDeep ? deepSignal(that[remainingStart + i], scope) : that[remainingStart + i];
+  }
+  this[Keys.Iterator];
+  return result;
+};
+arrayMethodReWrites.with = function(index, value) {
+  const scope = this[Keys.Scope];
+  const isDeep = this[Keys.Deep];
+  const that = toRaw(this);
+  const len = that.length;
+  let relativeIndex = Number(index) || 0;
+  let actualIndex = relativeIndex >= 0 ? relativeIndex : len + relativeIndex;
+  if (actualIndex >= len || actualIndex < 0) {
+    throw new RangeError(`Invalid index: ${index}`);
+  }
+  const result = new Array(len);
+  for (let i = 0; i < len; i++) {
+    if (i === actualIndex) {
+      result[i] = isDeep ? deepSignal(value, scope) : value;
+    } else {
+      result[i] = isDeep ? deepSignal(that[i], scope) : that[i];
+    }
+  }
+  this[Keys.Iterator];
+  return result;
+};
+arrayMethodReWrites.concat = function(...items) {
+  const scope = this[Keys.Scope];
+  const isDeep = this[Keys.Deep];
+  const that = toRaw(this);
+  const selfLen = that.length;
+  let totalLength = selfLen;
+  for (let i = 0; i < items.length; i++) {
+    const item = items[i];
+    if (Array.isArray(item)) {
+      totalLength += item.length;
+    } else {
+      totalLength += 1;
+    }
+  }
+  const result = new Array(totalLength);
+  let k = 0;
+  for (; k < selfLen; k++) {
+    if (k in that) {
+      result[k] = isDeep ? deepSignal(that[k], scope) : that[k];
+    }
+  }
+  for (let i = 0; i < items.length; i++) {
+    const item = items[i];
+    if (Array.isArray(item)) {
+      for (let j = 0; j < item.length; j++) {
+        if (j in item) {
+          result[k] = isDeep ? deepSignal(item[j], scope) : item[j];
+        }
+        k++;
+      }
+    } else {
+      result[k] = isDeep ? deepSignal(item, scope) : item;
+      k++;
+    }
+  }
+  this[Keys.Iterator];
+  return result;
+};
+const GetMethodConf = {
+  wrapReturn: false,
+  wrapArgs: 1
+};
+[
+  __spreadValues$1({
+    key: "every"
+  }, GetMethodConf),
+  __spreadValues$1({
+    key: "find",
+    wrapReturn: true
+  }, GetMethodConf),
+  __spreadProps(__spreadValues$1({
+    key: "findLast"
+  }, GetMethodConf), {
+    wrapReturn: true
+  }),
+  __spreadValues$1({
+    key: "findIndex"
+  }, GetMethodConf),
+  __spreadValues$1({
+    key: "findLastIndex"
+  }, GetMethodConf),
+  __spreadValues$1({
+    key: "forEach"
+  }, GetMethodConf),
+  __spreadValues$1({
+    key: "map"
+  }, GetMethodConf),
+  __spreadValues$1({
+    key: "some"
+  }, GetMethodConf),
+  __spreadProps(__spreadValues$1({
+    key: "reduce"
+  }, GetMethodConf), {
+    wrapArgs: 2
+  }),
+  __spreadProps(__spreadValues$1({
+    key: "reduceRight"
+  }, GetMethodConf), {
+    wrapArgs: 2
+  })
+].forEach(({ key, wrapReturn, wrapArgs }) => {
+  arrayMethodReWrites[key] = function(...args) {
+    const scope = this[Keys.Scope];
+    const fn = Array.prototype[key];
+    const isDeep = this[Keys.Deep];
+    const that = toRaw(this);
+    warpCallbackArgs(isDeep, args, scope, wrapArgs);
+    let result = fn.call(that, ...args);
+    if (wrapReturn && isDeep) {
+      result = deepSignal(result, scope);
+    }
+    this[Keys.Iterator];
+    return result;
+  };
+});
+arrayMethodReWrites.toSorted = function(...args) {
+  const fn = Array.prototype["toSorted"];
+  const scope = this[Keys.Scope];
+  const isDeep = this[Keys.Deep];
+  const that = toRaw(this);
+  warpCallbackArgs(isDeep, args, scope, 3);
+  let result = fn.call(that, ...args);
+  this[Keys.Iterator];
+  return isDeep ? result.map((it) => deepSignal(it, scope)) : result;
+};
+["join", "toString", "toLocaleString"].forEach((key) => {
+  arrayMethodReWrites[key] = function(...args) {
+    const fn = Array.prototype[key];
+    const that = toRaw(this);
+    const result = fn.call(that, ...args);
+    this[Keys.Iterator];
+    return result;
+  };
+});
+function warpCallbackArgs(isDeep, args, scope, wrapArgs = 1) {
+  const callback = args[0];
+  const wrapCb = function(...cbArgs) {
+    if (isDeep) {
+      if (wrapArgs & 1) cbArgs[0] = deepSignal(cbArgs[0], scope);
+      if (wrapArgs & 2) cbArgs[1] = deepSignal(cbArgs[1], scope);
+    }
+    return callback.call(this, ...cbArgs);
+  };
+  args[0] = wrapCb;
+}
+
 var __defProp = Object.defineProperty;
 var __getOwnPropSymbols = Object.getOwnPropertySymbols;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
@@ -768,13 +1302,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, G.PullingSignal, opt.deep);
   } else {
     intiValue = init;
   }
@@ -843,14 +1390,24 @@ const customEffect = (opt) => {
     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.batch = batch;
 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;
 //# sourceMappingURL=aoye.cjs.js.map