@estjs/signals 0.0.17-beta.7 → 0.0.18-beta.1

package/dist/signals.dev.js

@@ -1,4 +1,4 @@
-import { isFunction, isObject, warn, error, isPlainObject, isArray, isSet, isMap, isWeakMap, isWeakSet, hasChanged, isStringNumber, hasOwn, isUndefined } from '@estjs/shared';
+import { isArray, isFunction, isObject, warn, error, isPlainObject, isSet, isMap, isWeakMap, isWeakSet, hasChanged, isDate, isRegExp, isNull, isPromise, hasOwn, isStringNumber, isUndefined } from '@estjs/shared';
 
 // src/signal.ts
 
@@ -305,6 +305,17 @@ function isValidLink(checkLink, sub) {
 }
 var targetMap = /* @__PURE__ */ new WeakMap();
 var triggerVersion = 0;
+var triggerEffects = [];
+var triggerDepth = 0;
+function startTriggerEffects() {
+  const effects = triggerDepth === 0 ? triggerEffects : [];
+  triggerDepth++;
+  return effects;
+}
+function endTriggerEffects(effects) {
+  effects.length = 0;
+  triggerDepth--;
+}
 function collectTriggeredEffects(dep, effects, version) {
   if (!dep) {
     return;
@@ -335,46 +346,127 @@ function track(target, key) {
   linkReactiveNode(dep, activeSub);
 }
 function trigger(target, type, key, newValue) {
-  var _a5;
+  var _a6;
   const depsMap = targetMap.get(target);
   if (!depsMap) {
     return;
   }
-  const effects = [];
+  const effects = startTriggerEffects();
   const version = ++triggerVersion;
-  if (key !== void 0) {
-    if (Array.isArray(key)) {
-      for (const element of key) {
-        collectTriggeredEffects(depsMap.get(element), effects, version);
+  try {
+    if (key !== void 0) {
+      if (isArray(key)) {
+        for (const element of key) {
+          collectTriggeredEffects(depsMap.get(element), effects, version);
+        }
+      } else {
+        collectTriggeredEffects(depsMap.get(key), effects, version);
       }
-    } else {
-      collectTriggeredEffects(depsMap.get(key), effects, version);
     }
+    if (type === "ADD" || type === "DELETE" || type === "CLEAR") {
+      const iterationKey = isArray(target) ? ARRAY_ITERATE_KEY : ITERATE_KEY;
+      collectTriggeredEffects(depsMap.get(iterationKey), effects, version);
+    }
+    for (const effect2 of effects) {
+      if (isFunction(effect2.onTrigger)) {
+        effect2.onTrigger({
+          effect: effect2,
+          target,
+          type,
+          key,
+          newValue
+        });
+      }
+      if (effect2.flag & 2 /* WATCHING */) {
+        (_a6 = effect2.notify) == null ? void 0 : _a6.call(effect2);
+      } else if (effect2.flag & 1 /* MUTABLE */) {
+        effect2.flag |= 16 /* DIRTY */;
+        if (effect2.subLink) {
+          propagate(effect2.subLink);
+        }
+      }
+    }
+  } finally {
+    endTriggerEffects(effects);
   }
-  if (type === "ADD" || type === "DELETE" || type === "CLEAR") {
-    const iterationKey = Array.isArray(target) ? ARRAY_ITERATE_KEY : ITERATE_KEY;
-    collectTriggeredEffects(depsMap.get(iterationKey), effects, version);
-  }
-  for (const effect2 of effects) {
-    if (isFunction(effect2.onTrigger)) {
-      effect2.onTrigger({
-        effect: effect2,
-        target,
-        type,
-        key,
-        newValue
-      });
+}
+function trackNode(node) {
+  if (!activeSub || isUntracking) return;
+  linkReactiveNode(node, activeSub);
+}
+function triggerNode(node) {
+  var _a6;
+  const link = node.subLink;
+  if (!link) return;
+  const effects = startTriggerEffects();
+  const version = ++triggerVersion;
+  try {
+    for (let current = link; current; current = current.nextSubLink) {
+      const effect2 = current.subNode;
+      if (effect2._triggerVersion === version) {
+        continue;
+      }
+      effect2._triggerVersion = version;
+      effects.push(effect2);
     }
-    if (effect2.flag & 2 /* WATCHING */) {
-      (_a5 = effect2.notify) == null ? void 0 : _a5.call(effect2);
-    } else if (effect2.flag & 1 /* MUTABLE */) {
-      effect2.flag |= 16 /* DIRTY */;
-      if (effect2.subLink) {
-        propagate(effect2.subLink);
+    for (const effect2 of effects) {
+      if (effect2.flag & 2 /* WATCHING */) {
+        (_a6 = effect2.notify) == null ? void 0 : _a6.call(effect2);
+      } else if (effect2.flag & 1 /* MUTABLE */) {
+        effect2.flag |= 16 /* DIRTY */;
+        if (effect2.subLink) {
+          propagate(effect2.subLink);
+        }
       }
     }
+  } finally {
+    endTriggerEffects(effects);
   }
 }
+var ReactiveProperty = class {
+  constructor(_target, _key) {
+    this._target = _target;
+    this._key = _key;
+    this.flag = 1 /* MUTABLE */;
+  }
+  /**
+   * Read the property value and track the dependency.
+   *
+   * Uses trackNode(this) — bypasses targetMap/Dep. The ReactiveProperty itself
+   * IS the depNode, so linkReactiveNode connects the active subscriber directly
+   * to this node's subLink chain.
+   *
+   * Nested proxy wrapping and signal auto-unwrapping are handled by the caller
+   * (the reactive proxy get trap), keeping this method self-contained and free
+   * of a circular dependency on the rest of reactive.ts.
+   */
+  getValue() {
+    trackNode(this);
+    return this._target[this._key];
+  }
+  /**
+   * Update the property value and notify subscribers.
+   *
+   * Uses triggerNode(this) — directly walks the subLink chain, bypassing
+   * targetMap + collectTriggeredEffects.
+   *
+   * @param rawValue - The new (already unrawed) value.
+   * @param oldValue - The previous value, read BEFORE Reflect.set.
+   */
+  setValue(rawValue, oldValue) {
+    if (Object.is(oldValue, rawValue)) {
+      return;
+    }
+    triggerNode(this);
+  }
+  /**
+   * Invalidate this property (called on delete).
+   * Notifies subscribers that the value is gone.
+   */
+  invalidate() {
+    triggerNode(this);
+  }
+};
 var reactiveCaches = /* @__PURE__ */ new WeakMap();
 var shallowReactiveCaches = /* @__PURE__ */ new WeakMap();
 function toRaw(value) {
@@ -433,7 +525,7 @@ function createArrayInstrumentations() {
       const isShallowMode = isShallow(this);
       track(arr, ARRAY_ITERATE_KEY);
       const res = Array.prototype[key].apply(arr, args);
-      if (!Array.isArray(res)) {
+      if (!isArray(res)) {
         return res;
       }
       return res.map((item) => isObject(item) ? reactiveImpl(item, isShallowMode) : item);
@@ -468,7 +560,7 @@ function createArrayInstrumentations() {
           if (done) {
             return { value, done };
           }
-          if (Array.isArray(value)) {
+          if (isArray(value)) {
             return {
               value: value.map((v) => isObject(v) ? reactiveImpl(v, isShallowMode) : v),
               done
@@ -530,6 +622,32 @@ var arrayHandlers = (shallow) => ({
       }
     }
     return result;
+  },
+  has: (target, key) => {
+    const result = Reflect.has(target, key);
+    if (typeof key !== "symbol") {
+      if (isStringNumber(key)) {
+        track(target, key);
+      }
+      track(target, ARRAY_KEY);
+    }
+    return result;
+  },
+  deleteProperty: (target, key) => {
+    const hadKey = hasOwn(target, key);
+    const result = Reflect.deleteProperty(target, key);
+    if (hadKey && result) {
+      if (isStringNumber(key)) {
+        trigger(target, TriggerOpTypes.DELETE, [key, ARRAY_ITERATE_KEY, ARRAY_KEY]);
+      } else {
+        trigger(target, TriggerOpTypes.DELETE, key);
+      }
+    }
+    return result;
+  },
+  ownKeys: (target) => {
+    track(target, ARRAY_ITERATE_KEY);
+    return Reflect.ownKeys(target);
   }
 });
 var shallowArrayHandlers = arrayHandlers(true);
@@ -696,7 +814,7 @@ var collectionInstrumentations = {
         if (isShallowMode) {
           return { value, done };
         }
-        if (Array.isArray(value)) {
+        if (isArray(value)) {
           return {
             value: value.map((v) => isObject(v) ? reactiveImpl(v) : v),
             done
@@ -887,9 +1005,43 @@ var weakInstrumentations = {
     return result;
   }
 };
+var targetPropertyMaps = /* @__PURE__ */ new WeakMap();
+function getTargetDepSize(target, key) {
+  var _a6, _b2;
+  const rawTarget = (_a6 = target["_RAW" /* RAW */]) != null ? _a6 : target;
+  const prop = (_b2 = targetPropertyMaps.get(rawTarget)) == null ? void 0 : _b2.get(key);
+  if (!(prop == null ? void 0 : prop.subLink)) return 0;
+  let size = 0;
+  for (let link = prop.subLink; link; link = link.nextSubLink) size++;
+  return size;
+}
+function getPropertyMap(target) {
+  let map = targetPropertyMaps.get(target);
+  if (!map) {
+    map = /* @__PURE__ */ new Map();
+    targetPropertyMaps.set(target, map);
+  }
+  return map;
+}
+function trackProperty(target, key) {
+  if (!activeSub) {
+    return target[key];
+  }
+  const pm = getPropertyMap(target);
+  let prop = pm.get(key);
+  if (!prop) {
+    prop = new ReactiveProperty(target, key);
+    pm.set(key, prop);
+  }
+  return prop.getValue();
+}
 var objectHandlers = (shallow) => ({
   /**
    * Reads an object property, unwraps signals, and tracks the access.
+   *
+   * Own properties use the per-property signal fast path (trackNode),
+   * which bypasses the targetMap → Map → Dep indirection.
+   * Prototype-chain properties fall back to the standard track() path.
    */
   get(target, key, receiver) {
     if (key === "_RAW" /* RAW */) {
@@ -901,6 +1053,14 @@ var objectHandlers = (shallow) => ({
     if (key === "_IS_SHALLOW" /* IS_SHALLOW */) {
       return shallow;
     }
+    if (activeSub && hasOwn(target, key)) {
+      const result = trackProperty(target, key);
+      const unwrapped = isSignal(result) ? result.value : result;
+      if (isObject(unwrapped) && !shallow) {
+        return reactiveImpl(unwrapped);
+      }
+      return unwrapped;
+    }
     const value = Reflect.get(target, key, receiver);
     const valueUnwrapped = isSignal(value) ? value.value : value;
     track(target, key);
@@ -914,6 +1074,14 @@ var objectHandlers = (shallow) => ({
     const oldValue = Reflect.get(target, key, receiver);
     const rawValue = toRaw(value);
     const result = Reflect.set(target, key, rawValue, receiver);
+    if (hadKey) {
+      const pm = targetPropertyMaps.get(target);
+      const prop = pm == null ? void 0 : pm.get(key);
+      if (prop) {
+        prop.setValue(rawValue, oldValue);
+        return result;
+      }
+    }
     if (hasStoredValueChanged(rawValue, oldValue)) {
       trigger(target, hadKey ? TriggerOpTypes.SET : TriggerOpTypes.ADD, key, rawValue);
     }
@@ -923,6 +1091,12 @@ var objectHandlers = (shallow) => ({
     const hadKey = hasOwn(target, key);
     const result = Reflect.deleteProperty(target, key);
     if (hadKey && result) {
+      const pm = targetPropertyMaps.get(target);
+      const prop = pm == null ? void 0 : pm.get(key);
+      if (prop) {
+        pm.delete(key);
+        prop.invalidate();
+      }
       trigger(target, TriggerOpTypes.DELETE, key, void 0);
     }
     return result;
@@ -1154,6 +1328,7 @@ function isSignal(value) {
 }
 var queue = /* @__PURE__ */ new Set();
 var activePreFlushCbs = /* @__PURE__ */ new Set();
+var activePostFlushCbs = /* @__PURE__ */ new Set();
 var p = Promise.resolve();
 var isFlushPending = false;
 var RECURSION_LIMIT = 100;
@@ -1174,6 +1349,10 @@ function queuePreFlushCb(cb) {
   activePreFlushCbs.add(cb);
   queueFlush();
 }
+function queuePostFlushJob(cb) {
+  activePostFlushCbs.add(cb);
+  queueFlush();
+}
 function flushJobs() {
   isFlushPending = false;
   flushPreFlushCbs();
@@ -1186,7 +1365,7 @@ function flushJobs() {
           `[Scheduler] Maximum recursive flush count (${RECURSION_LIMIT}) exceeded. This usually means an effect or watch callback is mutating a reactive dependency it also reads, causing an infinite update loop. The remaining queued jobs have been dropped to keep the app responsive.`
         );
       }
-      return;
+      break;
     }
     const jobs = [...queue];
     queue.clear();
@@ -1200,6 +1379,7 @@ function flushJobs() {
       }
     }
   }
+  flushPostFlushCbs();
 }
 function flushPreFlushCbs() {
   const callbacks = Array.from(activePreFlushCbs);
@@ -1214,6 +1394,20 @@ function flushPreFlushCbs() {
     }
   }
 }
+function flushPostFlushCbs() {
+  if (activePostFlushCbs.size === 0) return;
+  const callbacks = Array.from(activePostFlushCbs);
+  activePostFlushCbs.clear();
+  for (const callback of callbacks) {
+    try {
+      callback();
+    } catch (_error) {
+      {
+        error("Error executing post-flush callback:", _error);
+      }
+    }
+  }
+}
 function createScheduler(effect2, flush) {
   switch (flush) {
     case "sync":
@@ -1266,7 +1460,7 @@ var EffectScope = class {
   constructor(detached = false, parent = void 0) {
     this.detached = detached;
     this.parent = parent;
-    this._active = true;
+    this._state = 0 /* Active */;
     // Use Sets instead of arrays for O(1) add/delete instead of O(n) indexOf+splice
     this.effects = /* @__PURE__ */ new Set();
     this.scopes = /* @__PURE__ */ new Set();
@@ -1277,36 +1471,46 @@ var EffectScope = class {
     }
   }
   get active() {
-    return this._active;
+    return this._state !== 2 /* Disposed */;
+  }
+  /** Whether the scope is paused. */
+  get isPaused() {
+    return this._state === 1 /* Paused */;
+  }
+  /** Whether the scope has been stopped / disposed. */
+  get isDisposed() {
+    return this._state === 2 /* Disposed */;
   }
   pause() {
-    var _a5;
-    if (!this._active) {
+    var _a6;
+    if (this._state !== 0 /* Active */) {
       return;
     }
+    this._state = 1 /* Paused */;
     for (const scope of this.scopes) {
       scope.pause();
     }
     for (const effect2 of this.effects) {
-      (_a5 = effect2.pause) == null ? void 0 : _a5.call(effect2);
+      (_a6 = effect2.pause) == null ? void 0 : _a6.call(effect2);
     }
   }
   resume() {
-    var _a5;
-    if (!this._active) {
+    var _a6;
+    if (this._state !== 1 /* Paused */) {
       return;
     }
+    this._state = 0 /* Active */;
     for (const scope of this.scopes) {
       scope.resume();
     }
     for (const effect2 of this.effects) {
-      (_a5 = effect2.resume) == null ? void 0 : _a5.call(effect2);
+      (_a6 = effect2.resume) == null ? void 0 : _a6.call(effect2);
     }
   }
   run(fn) {
-    if (!this._active) {
+    if (this._state === 2 /* Disposed */) {
       {
-        warn("cannot run an inactive effect scope.");
+        warn("cannot run a disposed effect scope.");
       }
       return;
     }
@@ -1319,27 +1523,42 @@ var EffectScope = class {
     }
   }
   stop(fromParent = false) {
-    if (!this._active) {
+    if (this._state === 2 /* Disposed */) {
       return;
     }
-    this._active = false;
-    for (const scope of this.scopes) {
-      scope.stop(true);
-    }
-    this.scopes.clear();
-    const effects = Array.from(this.effects);
-    this.effects.clear();
-    for (const effect2 of effects) {
-      effect2.stop();
-    }
-    for (let i = 0; i < this.cleanups.length; i++) {
-      this.cleanups[i]();
-    }
-    this.cleanups.length = 0;
-    if (!fromParent && this.parent) {
-      this.parent.scopes.delete(this);
+    this._state = 2 /* Disposed */;
+    try {
+      for (const scope of this.scopes) {
+        try {
+          scope.stop(true);
+        } catch (error_) {
+          if (true) error("[EffectScope] child scope disposal threw:", error_);
+        }
+      }
+      this.scopes.clear();
+      const effects = Array.from(this.effects);
+      this.effects.clear();
+      for (const effect2 of effects) {
+        try {
+          effect2.stop();
+        } catch (error_) {
+          if (true) error("[EffectScope] effect disposal threw:", error_);
+        }
+      }
+      for (let i = 0; i < this.cleanups.length; i++) {
+        try {
+          this.cleanups[i]();
+        } catch (error_) {
+          if (true) error("[EffectScope] cleanup threw:", error_);
+        }
+      }
+      this.cleanups.length = 0;
+    } finally {
+      if (!fromParent && this.parent) {
+        this.parent.scopes.delete(this);
+      }
+      this.parent = void 0;
     }
-    this.parent = void 0;
   }
   _record(effect2) {
     this.effects.add(effect2);
@@ -1507,9 +1726,9 @@ var EffectImpl = class {
     const prevSub = startTracking(this);
     try {
       return this.fn();
-    } catch (error5) {
+    } catch (error6) {
       this.flag |= 16 /* DIRTY */;
-      throw error5;
+      throw error6;
     } finally {
       this.flag &= -513 /* RUNNING */;
       endTracking(this, prevSub);
@@ -1535,13 +1754,13 @@ var EffectImpl = class {
    * @returns {void}
    */
   notify() {
-    var _a5, _b2, _c, _d;
+    var _a6, _b2, _c, _d;
     const flags = this.flag;
     if (!this._active || flags & (256 /* PAUSED */ | 512 /* RUNNING */ | 16 /* DIRTY */)) {
       return;
     }
     this.flag = flags | 16 /* DIRTY */;
-    if ((_a5 = this.options) == null ? void 0 : _a5.onTrigger) {
+    if ((_a6 = this.options) == null ? void 0 : _a6.onTrigger) {
       this.options.onTrigger({
         effect: this,
         target: {},
@@ -1574,7 +1793,7 @@ var EffectImpl = class {
    * @returns {void}
    */
   stop() {
-    var _a5;
+    var _a6;
     if (!this._active) {
       return;
     }
@@ -1604,7 +1823,7 @@ var EffectImpl = class {
         );
       }
     }
-    if ((_a5 = this.options) == null ? void 0 : _a5.onStop) {
+    if ((_a6 = this.options) == null ? void 0 : _a6.onStop) {
       this.options.onStop();
     }
   }
@@ -1751,7 +1970,7 @@ var ComputedImpl = class {
     const hadValue = oldValue !== NO_VALUE;
     const prevSub = startTracking(this);
     try {
-      const newValue = this.getter();
+      const newValue = this.getter(hadValue ? oldValue : void 0);
       const flags = this.flag;
       const subs = this.subLink;
       const clearMask = ~(16 /* DIRTY */ | 32 /* PENDING */);
@@ -1871,13 +2090,13 @@ function cloneInitialState(value, seen = /* @__PURE__ */ new WeakMap()) {
   if (seen.has(value)) {
     return seen.get(value);
   }
-  if (value instanceof Date) {
+  if (isDate(value)) {
     return new Date(value.getTime());
   }
-  if (value instanceof RegExp) {
+  if (isRegExp(value)) {
     return new RegExp(value.source, value.flags);
   }
-  if (value instanceof Map) {
+  if (isMap(value)) {
     const clone2 = /* @__PURE__ */ new Map();
     seen.set(value, clone2);
     value.forEach((mapValue, mapKey) => {
@@ -1885,7 +2104,7 @@ function cloneInitialState(value, seen = /* @__PURE__ */ new WeakMap()) {
     });
     return clone2;
   }
-  if (value instanceof Set) {
+  if (isSet(value)) {
     const clone2 = /* @__PURE__ */ new Set();
     seen.set(value, clone2);
     value.forEach((setValue) => {
@@ -1893,7 +2112,7 @@ function cloneInitialState(value, seen = /* @__PURE__ */ new WeakMap()) {
     });
     return clone2;
   }
-  if (Array.isArray(value)) {
+  if (isArray(value)) {
     const clone2 = [];
     seen.set(value, clone2);
     value.forEach((item, index) => {
@@ -1902,7 +2121,7 @@ function cloneInitialState(value, seen = /* @__PURE__ */ new WeakMap()) {
     return clone2;
   }
   const prototype = Object.getPrototypeOf(value);
-  if (prototype !== Object.prototype && prototype !== null) {
+  if (prototype !== Object.prototype && !isNull(prototype)) {
     return value;
   }
   const clone = Object.create(prototype);
@@ -1933,11 +2152,58 @@ function createOptionsStore(options) {
       };
     }
     set.add(callback);
-    return () => set.delete(callback);
+    const unsubscribe = () => set.delete(callback);
+    onScopeDispose(
+      unsubscribe,
+      /* failSilently */
+      true
+    );
+    return unsubscribe;
+  };
+  let activeTransaction = null;
+  const flushTransaction = (transaction) => {
+    if (transaction.depth === 0 && transaction.pending === 0 && !transaction.notified) {
+      transaction.notified = true;
+      notify(reactiveState);
+    }
   };
   const commit = (mutate) => {
-    batch(mutate);
-    notify(reactiveState);
+    const transaction = activeTransaction != null ? activeTransaction : {
+      depth: 0,
+      pending: 0,
+      notified: false
+    };
+    const previousTransaction = activeTransaction;
+    transaction.depth++;
+    let result;
+    try {
+      activeTransaction = transaction;
+      result = batch(mutate);
+    } catch (error6) {
+      transaction.depth--;
+      activeTransaction = previousTransaction;
+      throw error6;
+    }
+    activeTransaction = previousTransaction;
+    if (isPromise(result)) {
+      transaction.pending++;
+      transaction.depth--;
+      return result.then(
+        (value) => {
+          transaction.pending--;
+          flushTransaction(transaction);
+          return value;
+        },
+        (error6) => {
+          transaction.pending--;
+          flushTransaction(transaction);
+          throw error6;
+        }
+      );
+    }
+    transaction.depth--;
+    flushTransaction(transaction);
+    return result;
   };
   const defaultActions = {
     $patch(payload) {
@@ -1960,7 +2226,15 @@ function createOptionsStore(options) {
       actionCallbacks.delete(callback);
     },
     $reset() {
-      commit(() => Object.assign(reactiveState, initState));
+      commit(() => {
+        const fresh = cloneInitialState(initState);
+        for (const key of Object.keys(reactiveState)) {
+          if (!Object.prototype.hasOwnProperty.call(fresh, key)) {
+            delete reactiveState[key];
+          }
+        }
+        Object.assign(reactiveState, fresh);
+      });
     }
   };
   const store = {};
@@ -1978,7 +2252,7 @@ function createOptionsStore(options) {
     value: reactiveState,
     enumerable: true,
     configurable: true,
-    writable: true
+    writable: false
   });
   Object.assign(store, defaultActions);
   if (getters) {
@@ -1998,9 +2272,7 @@ function createOptionsStore(options) {
       const action = actions[key];
       if (action) {
         store[key] = (...args) => {
-          const result = action.apply(store, args);
-          actionCallbacks.forEach((callback) => callback(reactiveState));
-          return result;
+          return commit(() => action.apply(store, args));
         };
       }
     }
@@ -2072,6 +2344,12 @@ var RefImpl = class extends (_b = SignalImpl, _a4 = "_IS_REF" /* IS_REF */, _b)
     if (sub) {
       linkReactiveNode(this, sub);
     }
+    if (this.flag & 16 /* DIRTY */ && this.shouldUpdate()) {
+      const subs = this.subLink;
+      if (subs) {
+        shallowPropagate(subs);
+      }
+    }
     return this._value;
   }
   /**
@@ -2087,6 +2365,7 @@ var RefImpl = class extends (_b = SignalImpl, _a4 = "_IS_REF" /* IS_REF */, _b)
       newValue = newValue.value;
     }
     if (hasChanged(this._value, newValue)) {
+      this._oldValue = this._rawValue;
       this._rawValue = newValue;
       this._value = newValue;
       this.flag |= 16 /* DIRTY */;
@@ -2108,6 +2387,45 @@ function ref(value = void 0) {
 function isRef(value) {
   return !!value && !!value["_IS_REF" /* IS_REF */];
 }
+var _a5;
+_a5 = "_IS_COMPUTED" /* IS_COMPUTED */;
+var ObjectPropertyRef = class {
+  constructor(obj, key, defaultValue) {
+    this.obj = obj;
+    this.key = key;
+    this.defaultValue = defaultValue;
+    this[_a5] = true;
+  }
+  get value() {
+    const value = this.obj[this.key];
+    return value !== void 0 ? value : this.defaultValue;
+  }
+  set value(value) {
+    this.obj[this.key] = value;
+  }
+  peek() {
+    return untrack(() => this.value);
+  }
+};
+function unref(value) {
+  if (isSignal(value) || isRef(value) || isComputed(value)) {
+    return value.value;
+  }
+  if (isFunction(value)) {
+    return value();
+  }
+  return value;
+}
+function toRef(obj, key, defaultValue) {
+  return new ObjectPropertyRef(obj, key, defaultValue);
+}
+function toRefs(obj) {
+  const result = {};
+  for (const key of Object.keys(obj)) {
+    result[key] = toRef(obj, key);
+  }
+  return result;
+}
 var INITIAL_WATCHER_VALUE = {};
 var _traverseSeen = /* @__PURE__ */ new Set();
 var _traverseBusy = false;
@@ -2118,7 +2436,7 @@ function traverseValue(value, seen) {
   seen.add(value);
   if (isSignal(value) || isComputed(value)) {
     traverseValue(value.value, seen);
-  } else if (Array.isArray(value)) {
+  } else if (isArray(value)) {
     for (const element of value) {
       traverseValue(element, seen);
     }
@@ -2168,7 +2486,7 @@ function resolveSingleSource(source) {
   return () => source;
 }
 function resolveSource(source) {
-  if (Array.isArray(source)) {
+  if (isArray(source)) {
     const getters = source.map((s) => resolveSingleSource(s));
     return () => getters.map((g) => g());
   }
@@ -2179,7 +2497,7 @@ function watch(source, callback, options = {}) {
   let oldValue = INITIAL_WATCHER_VALUE;
   let lastValue;
   let active = true;
-  const isSingleReactive = !Array.isArray(source) && isReactive(source);
+  const isSingleReactive = !isArray(source) && isReactive(source);
   const needTraverse = deep && !isSingleReactive;
   const getter = resolveSource(source);
   let cleanup;
@@ -2188,8 +2506,8 @@ function watch(source, callback, options = {}) {
       cleanup = void 0;
       try {
         fn();
-      } catch (error5) {
-        warn("[watch] cleanup handler threw:", error5);
+      } catch (error6) {
+        warn("[watch] cleanup handler threw:", error6);
       }
     };
   };
@@ -2238,4 +2556,4 @@ function watch(source, callback, options = {}) {
   return stop2;
 }
 
-export { EffectScope, TriggerOpTypes, batch, computed, createStore, effect, effectScope, endBatch, getBatchDepth, getCurrentScope, isBatching, isComputed, isEffect, isReactive, isRef, isShallow, isSignal, memoEffect, nextTick, onScopeDispose, queueJob, queuePreFlushCb, reactive, ref, setCurrentScope, shallowReactive, shallowSignal, signal, startBatch, stop, toRaw, toReactive, trigger, untrack, watch };
+export { EffectScope, TriggerOpTypes, batch, computed, createStore, effect, effectScope, endBatch, getBatchDepth, getCurrentScope, getTargetDepSize, isBatching, isComputed, isEffect, isReactive, isRef, isShallow, isSignal, memoEffect, nextTick, onScopeDispose, queueJob, queuePostFlushJob, queuePreFlushCb, reactive, ref, setCurrentScope, shallowReactive, shallowSignal, signal, startBatch, stop, toRaw, toReactive, toRef, toRefs, trigger, unref, untrack, watch };