@estjs/signals 0.0.16-beta.2 → 0.0.16-beta.4

package/dist/signals.dev.cjs.js

@@ -32,78 +32,7 @@ var WEAK_COLLECTION_KEY = /* @__PURE__ */ Symbol("WeakCollection_Key" );
 var ITERATE_KEY = /* @__PURE__ */ Symbol("Iterate_Key" );
 var ARRAY_ITERATE_KEY = /* @__PURE__ */ Symbol("Array_Iterate_Key" );
 
-// src/propagation.ts
-function enqueueEffect(effect2) {
-  var _a5;
-  (_a5 = effect2 == null ? void 0 : effect2.notify) == null ? void 0 : _a5.call(effect2);
-}
-function propagate(link) {
-  let next = link.nextSubLink;
-  let stack;
-  top: do {
-    const sub = link.subNode;
-    const watcherBit = sub.flag & 2 /* WATCHING */;
-    let flags = sub.flag;
-    if (!(flags & (16 /* DIRTY */ | 32 /* PENDING */ | 8 /* RECURSED */ | 4 /* RECURSED_CHECK */))) {
-      sub.flag = flags | 32 /* PENDING */;
-      if (watcherBit) {
-        enqueueEffect(sub);
-      }
-    } else if (!(flags & (8 /* RECURSED */ | 4 /* RECURSED_CHECK */))) {
-      flags = 0 /* NONE */;
-    } else if (!(flags & 4 /* RECURSED_CHECK */)) {
-      sub.flag = flags & -9 /* RECURSED */ | 32 /* PENDING */;
-    } else if (!(flags & (16 /* DIRTY */ | 32 /* PENDING */)) && isValidLink(link, sub)) {
-      sub.flag = flags | (8 /* RECURSED */ | 32 /* PENDING */);
-      if (watcherBit) {
-        enqueueEffect(sub);
-      }
-      flags &= 1 /* MUTABLE */;
-    } else {
-      flags = 0 /* NONE */;
-    }
-    if (flags & 1 /* MUTABLE */) {
-      const subSubs = sub.subLink;
-      if (subSubs !== void 0) {
-        const nextSub = subSubs.nextSubLink;
-        if (nextSub !== void 0) {
-          stack = { value: next, prev: stack };
-          next = nextSub;
-        }
-        link = subSubs;
-        continue;
-      }
-    }
-    if ((link = next) !== void 0) {
-      next = link.nextSubLink;
-      continue;
-    }
-    while (stack !== void 0) {
-      link = stack.value;
-      stack = stack.prev;
-      if (link !== void 0) {
-        next = link.nextSubLink;
-        continue top;
-      }
-    }
-    break;
-  } while (true);
-}
-function shallowPropagate(link) {
-  while (link) {
-    const sub = link.subNode;
-    const flags = sub.flag;
-    if ((flags & (32 /* PENDING */ | 16 /* DIRTY */)) === 32 /* PENDING */) {
-      sub.flag = flags | 16 /* DIRTY */;
-      if ((flags & (2 /* WATCHING */ | 4 /* RECURSED_CHECK */)) === 2 /* WATCHING */) {
-        enqueueEffect(sub);
-      }
-    }
-    link = link.nextSubLink;
-  }
-}
-
-// src/link.ts
+// src/system.ts
 var currentLinkVersion = 0;
 var activeSub;
 var isUntracking = false;
@@ -124,6 +53,10 @@ var Dep = class {
     }
   }
 };
+function enqueueEffect(effect2) {
+  var _a5;
+  (_a5 = effect2 == null ? void 0 : effect2.notify) == null ? void 0 : _a5.call(effect2);
+}
 function linkReactiveNode(depNode, subNode) {
   if (isUntracking) {
     return void 0;
@@ -147,10 +80,8 @@ function linkReactiveNode(depNode, subNode) {
     version: currentLinkVersion,
     depNode,
     subNode,
-    // Subscriber chain pointers (horizontal)
     prevSubLink: prevSub,
     nextSubLink: void 0,
-    // Dependency chain pointers (vertical)
     prevDepLink: prevDep,
     nextDepLink: nextDep
   };
@@ -169,15 +100,13 @@ function linkReactiveNode(depNode, subNode) {
   }
   depNode.subLinkTail = newLink;
   subNode.depLinkTail = newLink;
-  {
-    if (subNode.onTrack && shared.isFunction(subNode == null ? void 0 : subNode.onTrack)) {
-      subNode.onTrack({
-        effect: subNode,
-        target: depNode,
-        type: "get",
-        key: void 0
-      });
-    }
+  if (subNode.onTrack && shared.isFunction(subNode.onTrack)) {
+    subNode.onTrack({
+      effect: subNode,
+      target: depNode,
+      type: "get",
+      key: void 0
+    });
   }
   return newLink;
 }
@@ -215,12 +144,10 @@ function unlinkReactiveNode(linkNode, subNode = linkNode.subNode) {
       if (!depNode.isDep) {
         depNode.flag |= 16 /* DIRTY */;
       }
-      {
-        if (depNode.depLink) {
-          shared.error(
-            "[Link] Cascading cleanup failed: depNode still has dependency links. This indicates a bug in the unlinking logic."
-          );
-        }
+      if (depNode.depLink) {
+        shared.error(
+          "[Link] Cascading cleanup failed: depNode still has dependency links. This indicates a bug in the unlinking logic."
+        );
       }
     }
   }
@@ -240,7 +167,7 @@ function checkDirty(link, sub) {
       if ((depFlags & (1 /* MUTABLE */ | 16 /* DIRTY */)) === (1 /* MUTABLE */ | 16 /* DIRTY */)) {
         const subs = dep.subLink;
         if (subs && subs.nextSubLink) {
-          shallowPropagate2(subs);
+          shallowPropagate(subs);
         }
         currentDirty = true;
       } else if ((depFlags & (1 /* MUTABLE */ | 32 /* PENDING */)) === (1 /* MUTABLE */ | 32 /* PENDING */)) {
@@ -288,16 +215,71 @@ function checkDirty(link, sub) {
     return dirty;
   } while (true);
 }
-function shallowPropagate2(link) {
+function shallowPropagate(link) {
   while (link) {
     const sub = link.subNode;
     const flags = sub.flag;
     if ((flags & (32 /* PENDING */ | 16 /* DIRTY */)) === 32 /* PENDING */) {
       sub.flag = flags | 16 /* DIRTY */;
+      if ((flags & (2 /* WATCHING */ | 4 /* RECURSED_CHECK */)) === 2 /* WATCHING */) {
+        enqueueEffect(sub);
+      }
     }
     link = link.nextSubLink;
   }
 }
+function propagate(link) {
+  let next = link.nextSubLink;
+  let stack;
+  top: do {
+    const sub = link.subNode;
+    const watcherBit = sub.flag & 2 /* WATCHING */;
+    let flags = sub.flag;
+    if (!(flags & (16 /* DIRTY */ | 32 /* PENDING */ | 8 /* RECURSED */ | 4 /* RECURSED_CHECK */))) {
+      sub.flag = flags | 32 /* PENDING */;
+      if (watcherBit) {
+        enqueueEffect(sub);
+      }
+    } else if (!(flags & (8 /* RECURSED */ | 4 /* RECURSED_CHECK */))) {
+      flags = 0 /* NONE */;
+    } else if (!(flags & 4 /* RECURSED_CHECK */)) {
+      sub.flag = flags & -9 /* RECURSED */ | 32 /* PENDING */;
+    } else if (!(flags & (16 /* DIRTY */ | 32 /* PENDING */)) && isValidLink(link, sub)) {
+      sub.flag = flags | (8 /* RECURSED */ | 32 /* PENDING */);
+      if (watcherBit) {
+        enqueueEffect(sub);
+      }
+      flags &= 1 /* MUTABLE */;
+    } else {
+      flags = 0 /* NONE */;
+    }
+    if (flags & 1 /* MUTABLE */) {
+      const subSubs = sub.subLink;
+      if (subSubs !== void 0) {
+        const nextSub = subSubs.nextSubLink;
+        if (nextSub !== void 0) {
+          stack = { value: next, prev: stack };
+          next = nextSub;
+        }
+        link = subSubs;
+        continue;
+      }
+    }
+    if ((link = next) !== void 0) {
+      next = link.nextSubLink;
+      continue;
+    }
+    while (stack !== void 0) {
+      link = stack.value;
+      stack = stack.prev;
+      if (link !== void 0) {
+        next = link.nextSubLink;
+        continue top;
+      }
+    }
+    break;
+  } while (true);
+}
 function setActiveSub(sub) {
   const prev = activeSub;
   activeSub = sub;
@@ -1051,7 +1033,7 @@ var SignalImpl = class {
     if (flags & 16 /* DIRTY */ && this.shouldUpdate()) {
       const subs = this.subLink;
       if (subs) {
-        shallowPropagate2(subs);
+        shallowPropagate(subs);
       }
     }
     return this._value;
@@ -1263,6 +1245,133 @@ function isBatching() {
 function getBatchDepth() {
   return batchDepth;
 }
+var activeEffectScope;
+var EffectScope = class {
+  constructor(detached = false, parent = void 0) {
+    this.detached = detached;
+    this.parent = parent;
+    this._active = true;
+    this.effects = [];
+    this.scopes = [];
+    this.cleanups = [];
+    if (!detached && activeEffectScope) {
+      this.parent = activeEffectScope;
+      activeEffectScope.scopes.push(this);
+    }
+  }
+  get active() {
+    return this._active;
+  }
+  pause() {
+    var _a5, _b2;
+    if (!this._active) {
+      return;
+    }
+    for (let i = 0; i < this.scopes.length; i++) {
+      this.scopes[i].pause();
+    }
+    for (let i = 0; i < this.effects.length; i++) {
+      (_b2 = (_a5 = this.effects[i]).pause) == null ? void 0 : _b2.call(_a5);
+    }
+  }
+  resume() {
+    var _a5, _b2;
+    if (!this._active) {
+      return;
+    }
+    for (let i = 0; i < this.scopes.length; i++) {
+      this.scopes[i].resume();
+    }
+    for (let i = 0; i < this.effects.length; i++) {
+      (_b2 = (_a5 = this.effects[i]).resume) == null ? void 0 : _b2.call(_a5);
+    }
+  }
+  run(fn) {
+    if (!this._active) {
+      {
+        shared.warn("cannot run an inactive effect scope.");
+      }
+      return;
+    }
+    const prevScope = activeEffectScope;
+    activeEffectScope = this;
+    try {
+      return fn();
+    } finally {
+      activeEffectScope = prevScope;
+    }
+  }
+  stop(fromParent = false) {
+    if (!this._active) {
+      return;
+    }
+    this._active = false;
+    for (let i = 0; i < this.scopes.length; i++) {
+      this.scopes[i].stop(true);
+    }
+    this.scopes.length = 0;
+    const effects = this.effects.slice();
+    this.effects.length = 0;
+    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) {
+      const index = this.parent.scopes.indexOf(this);
+      if (index >= 0) {
+        this.parent.scopes.splice(index, 1);
+      }
+    }
+    this.parent = void 0;
+  }
+  _record(effect2) {
+    this.effects.push(effect2);
+    effect2.scope = this;
+  }
+  _remove(effect2) {
+    const index = this.effects.indexOf(effect2);
+    if (index >= 0) {
+      this.effects.splice(index, 1);
+    }
+  }
+  _pushCleanup(fn) {
+    this.cleanups.push(fn);
+  }
+};
+function effectScope(detached = false) {
+  return new EffectScope(detached);
+}
+function getCurrentScope() {
+  return activeEffectScope;
+}
+function setCurrentScope(scope) {
+  const prevScope = activeEffectScope;
+  activeEffectScope = scope;
+  return prevScope;
+}
+function onScopeDispose(fn, failSilently = false) {
+  if (activeEffectScope) {
+    activeEffectScope._pushCleanup(fn);
+  } else if (!failSilently) {
+    shared.warn("onScopeDispose() is called when there is no active effect scope to be associated with.");
+  }
+}
+function recordDisposable(effect2, scope = activeEffectScope) {
+  if (scope && scope.active) {
+    scope._record(effect2);
+  }
+}
+function releaseDisposable(effect2) {
+  const scope = effect2.scope;
+  if (!scope) {
+    return;
+  }
+  effect2.scope = void 0;
+  scope._remove(effect2);
+}
 
 // src/effect.ts
 var _a2;
@@ -1292,6 +1401,7 @@ var EffectImpl = class {
         if (options.onTrigger) this.onTrigger = options.onTrigger;
       }
     }
+    recordDisposable(this);
   }
   /**
    * Check if the Effect is active.
@@ -1455,12 +1565,10 @@ var EffectImpl = class {
   stop() {
     var _a5;
     if (!this._active) {
-      {
-        shared.warn("[Effect] Attempting to stop an already stopped effect.");
-      }
       return;
     }
     this._active = false;
+    releaseDisposable(this);
     let dep = this.depLink;
     while (dep) {
       dep = unlinkReactiveNode(dep, this);
@@ -1542,11 +1650,13 @@ var ComputedImpl = class {
     //  Cache
     // Use symbol sentinel to distinguish "no value" from undefined/null values
     this._value = NO_VALUE;
+    this._active = true;
     this.getter = getter;
     this.setter = setter;
     this.onTrack = onTrack;
     this.onTrigger = onTrigger;
     this.flag |= 16 /* DIRTY */;
+    recordDisposable(this);
   }
   /**
    * Returns the current value.
@@ -1554,6 +1664,9 @@ var ComputedImpl = class {
    * @returns {T} The current value.
    */
   get value() {
+    if (!this.active) {
+      return this._value === NO_VALUE ? this.getter() : this._value;
+    }
     if (activeSub) {
       linkReactiveNode(this, activeSub);
     }
@@ -1595,11 +1708,17 @@ var ComputedImpl = class {
    * @returns {T} The current value.
    */
   peek() {
+    if (!this.active) {
+      return this._value === NO_VALUE ? this.getter() : this._value;
+    }
     if (this._value === NO_VALUE) {
       this.recompute();
     }
     return this._value;
   }
+  get active() {
+    return this._active;
+  }
   /**
    * Recompute the value
    *
@@ -1612,6 +1731,12 @@ var ComputedImpl = class {
    * @private
    */
   recompute() {
+    if (!this._active) {
+      if (this._value === NO_VALUE) {
+        this._value = this.getter();
+      }
+      return;
+    }
     const oldValue = this._value;
     const hadValue = oldValue !== NO_VALUE;
     const prevSub = startTracking(this);
@@ -1670,6 +1795,24 @@ var ComputedImpl = class {
     }
     return shared.hasChanged(this._value, oldValue);
   }
+  stop() {
+    if (!this._active) {
+      return;
+    }
+    this._active = false;
+    releaseDisposable(this);
+    let dep = this.depLink;
+    while (dep) {
+      dep = unlinkReactiveNode(dep, this);
+    }
+    let sub = this.subLink;
+    while (sub) {
+      sub = unlinkReactiveNode(sub);
+    }
+    this.depLinkTail = void 0;
+    this.subLinkTail = void 0;
+    this.flag &= -49;
+  }
 };
 function computed(getterOrOptions) {
   if (isComputed(getterOrOptions)) {
@@ -2022,13 +2165,16 @@ function watch(source, callback, options = {}) {
   };
 }
 
+exports.EffectScope = EffectScope;
 exports.TriggerOpTypes = TriggerOpTypes;
 exports.batch = batch;
 exports.computed = computed;
 exports.createStore = createStore;
 exports.effect = effect;
+exports.effectScope = effectScope;
 exports.endBatch = endBatch;
 exports.getBatchDepth = getBatchDepth;
+exports.getCurrentScope = getCurrentScope;
 exports.isBatching = isBatching;
 exports.isComputed = isComputed;
 exports.isEffect = isEffect;
@@ -2038,10 +2184,12 @@ exports.isShallow = isShallow;
 exports.isSignal = isSignal;
 exports.memoEffect = memoEffect;
 exports.nextTick = nextTick;
+exports.onScopeDispose = onScopeDispose;
 exports.queueJob = queueJob;
 exports.queuePreFlushCb = queuePreFlushCb;
 exports.reactive = reactive;
 exports.ref = ref;
+exports.setCurrentScope = setCurrentScope;
 exports.shallowReactive = shallowReactive;
 exports.shallowSignal = shallowSignal;
 exports.signal = signal;