aoye 0.0.7 → 0.0.8

package/dist/aoye.cjs.js

@@ -2,6 +2,7 @@
 
 var bobeShared = require('bobe-shared');
 
+const rawToProxy = /* @__PURE__ */ new WeakMap();
 new bobeShared.BaseEvent();
 const G = {
   /** 原子 signal 更新次数 */
@@ -13,7 +14,6 @@ const G = {
   /** 表示当前处于 pull 递归中 */
   PullingRecurseDeep: 0
 };
-new bobeShared.SortMap();
 var State = /* @__PURE__ */ ((State2) => {
   State2[State2["Clean"] = 0] = "Clean";
   State2[State2["LinkScopeOnly"] = 256] = "LinkScopeOnly";
@@ -134,19 +134,19 @@ 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) => {
+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$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]);
+    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;
 };
@@ -178,7 +178,7 @@ class TaskQueue {
     const fn = taskQueue.peek();
     if (!fn) return this.isScheduling = false;
     let info = fn() || {};
-    info = __spreadValues$2(__spreadValues$2({}, DefaultTaskControlReturn), info);
+    info = __spreadValues$3(__spreadValues$3({}, DefaultTaskControlReturn), info);
     if (info.finished) {
       taskQueue.poll();
       if (taskQueue.size() === 0) {
@@ -193,6 +193,14 @@ class TaskQueue {
   }
 }
 
+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();
@@ -216,10 +224,28 @@ const p = Promise.resolve();
 const micro = (cb) => {
   p.then(cb);
 };
+const toRaw = (a) => {
+  if (typeof a === "object" && a !== null && a[Keys.Raw]) {
+    return toRaw(a[Keys.Raw]);
+  }
+  return a;
+};
 
 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;
@@ -300,19 +326,19 @@ const _scheduler = {
 };
 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;
 };
@@ -325,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";
@@ -611,27 +637,49 @@ 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, firstEffectItem, lastEffectItem, updatedSchedulers = /* @__PURE__ */ new Set();
+  let level = 0, updatedSchedulers = /* @__PURE__ */ new Set();
   dfs(signal, {
     isUp: false,
     begin: ({ node }) => {
@@ -651,18 +699,19 @@ const markDeep = (signal) => {
         const key = node.scheduler;
         const instance = _scheduler[key];
         const item = instance.addEffect(node);
-        if (!firstEffectItem) {
-          firstEffectItem = item;
+        if (!instance.firstEffectItem) {
+          instance.firstEffectItem = item;
         }
-        lastEffectItem = item;
+        instance.lastEffectItem = item;
         updatedSchedulers.add(key);
       }
       level++;
     }
   });
-  for (const key of updatedSchedulers) {
+  if (batch.inBatch()) return;
+  for (const key in _scheduler) {
     const instance = _scheduler[key];
-    instance == null ? void 0 : instance.onOneSetEffectsAdded(instance.effectQueue.subRef(firstEffectItem, lastEffectItem), instance.effectQueue);
+    instance.endSet();
   }
 };
 const pullingPostprocess = (node) => {
@@ -693,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() {
@@ -844,41 +896,74 @@ 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) => {
+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) return target;
-  if (proxyMap.has(target)) return proxyMap.get(target);
+  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) {
-      if (prop === Keys.Raw) {
-        return target;
+      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 value = Reflect.get(obj, prop, receiver);
-      const wrappedValue = deep ? deepSignal(value) : value;
+      const wrappedValue = deep ? deepSignal(value, scope) : value;
       const s = Signal.create(wrappedValue, {
         scheduler: Scheduler.Sync,
-        isScope: false
+        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) : value;
+        cell.v = deep ? deepSignal(value, scope) : value;
+      }
+      if (targetIsArray) {
+        handleArraySet(obj, prop, value, receiver);
       }
-      return Reflect.set(obj, prop, value, receiver);
+      batch.end();
+      return success;
     },
     // 【核心修改】拦截 delete 操作
     deleteProperty(obj, prop) {
@@ -886,11 +971,320 @@ const deepSignal = (target, deep = true) => {
         cells.delete(prop);
       }
       return Reflect.deleteProperty(obj, prop);
+    },
+    ownKeys(obj) {
+      if (targetIsArray) {
+        proxy.length;
+      } else {
+        proxy[Keys.Iterator];
+      }
+      return Reflect.ownKeys(obj);
     }
   });
-  proxyMap.set(target, proxy);
+  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;
@@ -927,7 +1321,7 @@ const $ = (init, opt = {}) => {
     intiValue = null;
     customPull = init;
   } else if (opt.mode !== "ref" && typeof init === "object" && init !== null) {
-    return deepSignal(init, opt.deep);
+    return deepSignal(init, G.PullingSignal, opt.deep);
   } else {
     intiValue = init;
   }
@@ -1007,6 +1401,7 @@ exports.$ = $;
 exports.Keys = Keys;
 exports.Scheduler = Scheduler;
 exports.TaskQueue = TaskQueue;
+exports.batch = batch;
 exports.clean = clean;
 exports.customEffect = customEffect;
 exports.effect = effect;