aoye 0.0.7 → 0.0.9

package/dist/index.umd.js

@@ -4,6 +4,7 @@
   (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.Aoye = {}, global.BobeShared));
 })(this, (function (exports, bobeShared) { 'use strict';
 
+  const rawToProxy = /* @__PURE__ */ new WeakMap();
   new bobeShared.BaseEvent();
   const G = {
     /** 原子 signal 更新次数 */
@@ -15,7 +16,6 @@
     /** 表示当前处于 pull 递归中 */
     PullingRecurseDeep: 0
   };
-  new bobeShared.SortMap();
   var State = /* @__PURE__ */ ((State2) => {
     State2[State2["Clean"] = 0] = "Clean";
     State2[State2["LinkScopeOnly"] = 256] = "LinkScopeOnly";
@@ -136,19 +136,19 @@
     }
   }
 
-  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;
   };
@@ -180,7 +180,7 @@
       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) {
@@ -195,6 +195,16 @@
     }
   }
 
+  var Keys = /* @__PURE__ */ ((Keys2) => {
+    Keys2["Iterator"] = "__AOYE_ITERATOR";
+    Keys2["Raw"] = "__AOYE_RAW";
+    Keys2["Deep"] = "__AOYE_DEEP";
+    Keys2["Scope"] = "__AOYE_SCOPE";
+    Keys2["Cells"] = "__AOYE_CELLS";
+    return Keys2;
+  })(Keys || {});
+  const IsStore = /* @__PURE__ */ Symbol("__AOYE_IS_STORE"), StoreIgnoreKeys = /* @__PURE__ */ Symbol("__AOYE_IGNORE_KEYS");
+
   let channel = globalThis.MessageChannel ? new MessageChannel() : null;
   if (globalThis.MessageChannel) {
     channel = new MessageChannel();
@@ -218,10 +228,28 @@
   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;
@@ -238,7 +266,7 @@
     onOneSetEffectsAdded(subQueue, queue) {
       subQueue.forEach((effect, item) => {
         effect.runIfDirty();
-        subQueue.delete(item);
+        queue.delete(item);
       });
     }
   }
@@ -251,7 +279,7 @@
       const task = () => {
         subQueue.forEach((effect, item) => {
           effect.runIfDirty();
-          subQueue.delete(item);
+          queue.delete(item);
         });
         return {
           finished: true,
@@ -271,7 +299,7 @@
       const task = () => {
         subQueue.forEach((effect, item) => {
           effect.runIfDirty();
-          subQueue.delete(item);
+          queue.delete(item);
         });
       };
       task.time = Date.now();
@@ -287,7 +315,7 @@
       const task = () => {
         subQueue.forEach((effect, item) => {
           effect.runIfDirty();
-          subQueue.delete(item);
+          queue.delete(item);
         });
       };
       task.time = Date.now();
@@ -302,19 +330,19 @@
   };
   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;
   };
@@ -327,7 +355,7 @@
     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";
@@ -613,27 +641,49 @@
   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 }) => {
@@ -653,18 +703,19 @@
           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) => {
@@ -695,13 +746,16 @@
       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() {
@@ -846,53 +900,486 @@
   _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) => {
+    var _a;
     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 targetIsStore = Boolean((_a = target.constructor) == null ? void 0 : _a[IsStore]);
     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;
+          case Keys.Cells:
+            return cells;
+        }
+        if (targetIsStore && obj.constructor[StoreIgnoreKeys].includes(prop)) {
+          return Reflect.get(obj, prop, receiver);
+        }
+        const desc = Reflect.getOwnPropertyDescriptor(obj, prop);
+        const isGetter = desc && typeof desc.get === "function";
+        if (isGetter) {
+          return handleGetterAsComputed(obj, prop, receiver, cells, 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) {
+        if (targetIsStore && obj.constructor[StoreIgnoreKeys].includes(prop)) {
+          return Reflect.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;
         }
-        return Reflect.set(obj, prop, value, receiver);
+        if (targetIsArray) {
+          handleArraySet(obj, prop, value, receiver);
+        }
+        batch.end();
+        return success;
       },
       // 【核心修改】拦截 delete 操作
       deleteProperty(obj, prop) {
+        if (targetIsStore && obj.constructor[StoreIgnoreKeys].includes(prop)) {
+          return Reflect.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);
       }
     });
-    proxyMap.set(target, proxy);
+    rawToProxy.set(target, proxy);
     return proxy;
   };
+  const shareSignal = (from, fromPath, to, toPath) => {
+    try {
+      const toPaths = toPath.split(".");
+      const formPaths = Array.isArray(fromPath) ? fromPath : fromPath.split(".");
+      runWithPulling(() => {
+        const { target: fromTarget, key: fromKey } = getTargetAndKey(from, formPaths);
+        fromTarget[fromKey];
+        const fromSignal = fromTarget[Keys.Cells].get(fromKey);
+        const { target: toTarget, key: toKey } = getTargetAndKey(to, toPaths);
+        toTarget[Keys.Cells].set(toKey, fromSignal);
+      }, null);
+    } catch (error) {
+      console.error("\u6620\u5C04\u4E86\u4E0D\u5B58\u5728\u7684Key\uFF01");
+      throw error;
+    }
+  };
+  function getTargetAndKey(obj, paths) {
+    let target = obj;
+    let key = "";
+    const len = paths.length;
+    for (let i = 0; i < len; i++) {
+      key = paths[i];
+      if (i < len - 1) {
+        target = target[key];
+      }
+    }
+    return { target, key };
+  }
+  function handleGetterAsComputed(obj, prop, receiver, cells, scope) {
+    if (cells.has(prop)) {
+      return cells.get(prop).v;
+    }
+    const s = Signal.create(null, {
+      customPull: () => Reflect.get(obj, prop, receiver),
+      scheduler: Scheduler.Sync,
+      isScope: false,
+      scope
+    });
+    cells.set(prop, s);
+    return s.v;
+  }
+  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 _a, _b;
+  _b = IsStore, _a = StoreIgnoreKeys;
+  const _Store = class _Store {
+    constructor() {
+      const proxy = deepSignal(this, G.PullingSignal, true);
+      _Store.Current = proxy;
+      return proxy;
+    }
+    static new(keyMap = {}) {
+      const parentStore = _Store.Current;
+      const child = new this();
+      if (parentStore) {
+        for (const childKey in keyMap) {
+          const parentKey = keyMap[childKey];
+          shareSignal(parentStore, parentKey, child, childKey);
+        }
+      }
+      _Store.Current = parentStore;
+      return child;
+    }
+    set(fn) {
+      effect(() => {
+        const props = fn();
+        Object.assign(this, props);
+      });
+    }
+  };
+  _Store[_b] = true;
+  _Store[_a] = ["ui", "raw"];
+  _Store.Current = null;
+  let Store = _Store;
 
   var __defProp = Object.defineProperty;
   var __getOwnPropSymbols = Object.getOwnPropertySymbols;
@@ -929,7 +1416,7 @@
       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;
     }
@@ -1006,9 +1493,13 @@
   };
 
   exports.$ = $;
+  exports.IsStore = IsStore;
   exports.Keys = Keys;
   exports.Scheduler = Scheduler;
+  exports.Store = Store;
+  exports.StoreIgnoreKeys = StoreIgnoreKeys;
   exports.TaskQueue = TaskQueue;
+  exports.batch = batch;
   exports.clean = clean;
   exports.customEffect = customEffect;
   exports.effect = effect;