@rlabs-inc/signals 1.3.0 → 1.4.0

package/dist/index.js

@@ -54,10 +54,13 @@ __export(exports_src, {
   readVersion: () => readVersion,
   proxy: () => proxy,
   peek: () => peek,
+  onScopeDispose: () => onScopeDispose,
   neverEquals: () => neverEquals,
   mutableSource: () => mutableSource,
   markReactions: () => markReactions,
+  linkedSignal: () => linkedSignal,
   isReactive: () => isReactive,
+  isLinkedSignal: () => isLinkedSignal,
   isDirty: () => isDirty,
   isBinding: () => isBinding,
   incrementWriteVersion: () => incrementWriteVersion,
@@ -65,15 +68,18 @@ __export(exports_src, {
   incrementBatchDepth: () => incrementBatchDepth,
   getWriteVersion: () => getWriteVersion,
   getReadVersion: () => getReadVersion,
+  getCurrentScope: () => getCurrentScope,
   getBatchDepth: () => getBatchDepth,
   get: () => get,
   flushSync: () => flushSync,
   equals: () => equals,
+  effectScope: () => effectScope,
   effect: () => effect,
   disconnectDerived: () => disconnectDerived,
   destroyEffect: () => destroyEffect,
   derived: () => derived,
   decrementBatchDepth: () => decrementBatchDepth,
+  createSelector: () => createSelector,
   createEquals: () => createEquals,
   createEffect: () => createEffect,
   createDerived: () => createDerived,
@@ -97,6 +103,7 @@ __export(exports_src, {
   REACTIVE_MARKER: () => REACTIVE_MARKER,
   REACTION_IS_UPDATING: () => REACTION_IS_UPDATING,
   MAYBE_DIRTY: () => MAYBE_DIRTY,
+  LINKED_SYMBOL: () => LINKED_SYMBOL,
   INERT: () => INERT,
   EFFECT_RAN: () => EFFECT_RAN,
   EFFECT_PRESERVED: () => EFFECT_PRESERVED,
@@ -107,7 +114,8 @@ __export(exports_src, {
   DERIVED: () => DERIVED,
   CLEAN: () => CLEAN,
   BRANCH_EFFECT: () => BRANCH_EFFECT,
-  BLOCK_EFFECT: () => BLOCK_EFFECT
+  BLOCK_EFFECT: () => BLOCK_EFFECT,
+  BINDING_SYMBOL: () => BINDING_SYMBOL
 });
 module.exports = __toCommonJS(exports_src);
 
@@ -176,6 +184,9 @@ var UNINITIALIZED = Symbol.for("rlabs.signals.uninitialized");
 var STALE_REACTION = Symbol.for("rlabs.signals.stale_reaction");
 var STATE_SYMBOL = Symbol.for("rlabs.signals.state");
 var REACTIVE_MARKER = Symbol.for("rlabs.signals.reactive");
+var BINDING_SYMBOL = Symbol.for("rlabs.signals.binding");
+var LINKED_SYMBOL = Symbol.for("rlabs.signals.linked");
+var SOURCE = 1 << 0;
 var STATUS_MASK = ~(DIRTY | MAYBE_DIRTY | CLEAN);
 
 // src/core/globals.ts
@@ -300,6 +311,9 @@ function setUpdateEffectImpl(impl) {
 function flushEffects() {
   const roots = clearQueuedRootEffects();
   for (const root of roots) {
+    if ((root.f & INERT) !== 0) {
+      continue;
+    }
     if (isDirty(root)) {
       updateEffectImpl(root);
     }
@@ -310,7 +324,7 @@ function processEffectTree(effect) {
   let child = effect.first;
   while (child !== null) {
     const next = child.next;
-    if (isDirty(child)) {
+    if ((child.f & INERT) === 0 && isDirty(child)) {
       updateEffectImpl(child);
     }
     if (child.first !== null) {
@@ -323,6 +337,9 @@ function flushPendingReactions() {
   const reactions = [...pendingReactions];
   clearPendingReactions();
   for (const reaction of reactions) {
+    if ((reaction.f & INERT) !== 0) {
+      continue;
+    }
     if (isDirty(reaction)) {
       if ("parent" in reaction) {
         updateEffectImpl(reaction);
@@ -354,6 +371,9 @@ function flushSync(fn) {
         continue;
       }
       for (const root of roots) {
+        if ((root.f & INERT) !== 0) {
+          continue;
+        }
         if (isDirty(root)) {
           updateEffectImpl(root);
         }
@@ -400,13 +420,63 @@ function get(signal) {
     }
   }
   if ((signal.f & DERIVED) !== 0) {
-    const derived = signal;
-    if (isDirty(derived)) {
-      updateDerived(derived);
-    }
+    updateDerivedChain(signal);
   }
   return signal.v;
 }
+var updateCycleId = 0;
+var processedInCycle = new WeakMap;
+function updateDerivedChain(target) {
+  if ((target.f & (DIRTY | MAYBE_DIRTY)) === 0) {
+    return;
+  }
+  const cycleId = ++updateCycleId;
+  const chain = [target];
+  processedInCycle.set(target, cycleId);
+  let idx = 0;
+  while (idx < chain.length) {
+    const current = chain[idx];
+    idx++;
+    if ((current.f & (DIRTY | MAYBE_DIRTY)) === 0) {
+      continue;
+    }
+    const deps = current.deps;
+    if (deps !== null) {
+      for (let i = 0;i < deps.length; i++) {
+        const dep = deps[i];
+        if ((dep.f & DERIVED) !== 0 && (dep.f & (DIRTY | MAYBE_DIRTY)) !== 0 && processedInCycle.get(dep) !== cycleId) {
+          chain.push(dep);
+          processedInCycle.set(dep, cycleId);
+        }
+      }
+    }
+  }
+  for (let i = chain.length - 1;i >= 0; i--) {
+    const current = chain[i];
+    if ((current.f & (DIRTY | MAYBE_DIRTY)) === 0) {
+      continue;
+    }
+    if ((current.f & DIRTY) !== 0) {
+      updateDerived(current);
+    } else {
+      const deps = current.deps;
+      let needsUpdate = false;
+      if (deps !== null) {
+        for (let j = 0;j < deps.length; j++) {
+          if (deps[j].wv > current.wv) {
+            needsUpdate = true;
+            break;
+          }
+        }
+      }
+      if (needsUpdate) {
+        updateDerived(current);
+      } else {
+        setSignalStatus(current, CLEAN);
+      }
+    }
+  }
+}
 function set(signal, value) {
   if (activeReaction !== null && (activeReaction.f & DERIVED) !== 0) {
     throw new Error("Cannot write to signals inside a derived. " + "Deriveds should be pure computations with no side effects.");
@@ -422,20 +492,24 @@ function set(signal, value) {
   return value;
 }
 function markReactions(signal, status) {
-  const reactions = signal.reactions;
-  if (reactions === null)
-    return;
-  for (let i = 0;i < reactions.length; i++) {
-    const reaction = reactions[i];
-    const flags = reaction.f;
-    const notDirty = (flags & DIRTY) === 0;
-    if (notDirty) {
-      setSignalStatus(reaction, status);
-    }
-    if ((flags & DERIVED) !== 0) {
-      markReactions(reaction, MAYBE_DIRTY);
-    } else if (notDirty) {
-      scheduleEffect(reaction);
+  const stack = [{ signal, status }];
+  while (stack.length > 0) {
+    const { signal: currentSignal, status: currentStatus } = stack.pop();
+    const reactions = currentSignal.reactions;
+    if (reactions === null)
+      continue;
+    for (let i = 0;i < reactions.length; i++) {
+      const reaction = reactions[i];
+      const flags = reaction.f;
+      const notDirty = (flags & DIRTY) === 0;
+      if (notDirty) {
+        setSignalStatus(reaction, currentStatus);
+      }
+      if ((flags & DERIVED) !== 0) {
+        stack.push({ signal: reaction, status: MAYBE_DIRTY });
+      } else if (notDirty) {
+        scheduleEffect(reaction);
+      }
     }
   }
 }
@@ -446,22 +520,66 @@ function isDirty(reaction) {
   if ((reaction.f & DIRTY) !== 0) {
     return true;
   }
-  if ((reaction.f & MAYBE_DIRTY) !== 0) {
-    const deps = reaction.deps;
-    if (deps !== null) {
-      for (let i = 0;i < deps.length; i++) {
-        const dep = deps[i];
-        if ((dep.f & DERIVED) !== 0) {
-          if (isDirty(dep)) {
-            updateDerived(dep);
-          }
+  if ((reaction.f & MAYBE_DIRTY) === 0) {
+    return false;
+  }
+  const toCheck = [reaction];
+  const toUpdate = [];
+  let idx = 0;
+  while (idx < toCheck.length) {
+    const current = toCheck[idx];
+    idx++;
+    if ((current.f & DIRTY) !== 0) {
+      continue;
+    }
+    if ((current.f & MAYBE_DIRTY) === 0) {
+      continue;
+    }
+    const deps2 = current.deps;
+    if (deps2 !== null) {
+      for (let i = 0;i < deps2.length; i++) {
+        const dep = deps2[i];
+        if ((dep.f & DERIVED) !== 0 && (dep.f & (DIRTY | MAYBE_DIRTY)) !== 0) {
+          toCheck.push(dep);
         }
-        if (dep.wv > reaction.wv) {
-          return true;
+      }
+    }
+  }
+  for (let i = toCheck.length - 1;i >= 0; i--) {
+    const current = toCheck[i];
+    if ((current.f & DERIVED) === 0) {
+      continue;
+    }
+    if ((current.f & DIRTY) !== 0) {
+      updateDerived(current);
+    } else if ((current.f & MAYBE_DIRTY) !== 0) {
+      const deps2 = current.deps;
+      let needsUpdate = false;
+      if (deps2 !== null) {
+        for (let j = 0;j < deps2.length; j++) {
+          if (deps2[j].wv > current.wv) {
+            needsUpdate = true;
+            break;
+          }
         }
       }
+      if (needsUpdate) {
+        updateDerived(current);
+      } else {
+        setSignalStatus(current, CLEAN);
+      }
+    }
+  }
+  if ((reaction.f & DIRTY) !== 0) {
+    return true;
+  }
+  const deps = reaction.deps;
+  if (deps !== null) {
+    for (let i = 0;i < deps.length; i++) {
+      if (deps[i].wv > reaction.wv) {
+        return true;
+      }
     }
-    setSignalStatus(reaction, CLEAN);
   }
   return false;
 }
@@ -614,6 +732,7 @@ function stateRaw(initialValue) {
 }
 
 // src/deep/proxy.ts
+var proxyCache = new WeakMap;
 var proxyCleanup = new FinalizationRegistry((data) => {
   data.version.reactions = null;
   for (const src of data.sources.values()) {
@@ -625,6 +744,9 @@ function shouldProxy(value) {
   if (value === null || typeof value !== "object") {
     return false;
   }
+  if (BINDING_SYMBOL in value) {
+    return false;
+  }
   const proto = Object.getPrototypeOf(value);
   return proto === Object.prototype || proto === Array.prototype || proto === null;
 }
@@ -639,6 +761,10 @@ function proxy(value) {
   if (!shouldProxy(value) || isProxy(value)) {
     return value;
   }
+  const cached = proxyCache.get(value);
+  if (cached) {
+    return cached;
+  }
   const sources = new Map;
   const version = source(0);
   const isArray = Array.isArray(value);
@@ -690,7 +816,7 @@ function proxy(value) {
       }
       return currentValue;
     },
-    set(target, prop, newValue, receiver) {
+    set(target, prop, newValue) {
       const exists = prop in target;
       let s = sources.get(prop);
       if (s === undefined) {
@@ -700,29 +826,35 @@ function proxy(value) {
         s = withParent(() => source(undefined));
         sources.set(prop, s);
       }
-      const proxied = withParent(() => shouldProxy(newValue) ? proxy(newValue) : newValue);
+      let proxied;
+      if (shouldProxy(newValue)) {
+        proxied = withParent(() => proxy(newValue));
+      } else {
+        proxied = newValue;
+      }
       set(s, proxied);
-      Reflect.set(target, prop, newValue, receiver);
-      if (isArray && prop === "length") {
-        const oldLength = s.v;
-        const newLength = newValue;
-        for (let i = newLength;i < oldLength; i++) {
-          const indexKey = String(i);
-          const indexSource = sources.get(indexKey);
-          if (indexSource !== undefined) {
-            set(indexSource, UNINITIALIZED);
-          } else if (i in target) {
-            const deletedSource = withParent(() => source(UNINITIALIZED));
-            sources.set(indexKey, deletedSource);
+      target[prop] = newValue;
+      if (isArray) {
+        if (prop === "length") {
+          const oldLength = s.v;
+          const newLength = newValue;
+          for (let i = newLength;i < oldLength; i++) {
+            const indexKey = String(i);
+            const indexSource = sources.get(indexKey);
+            if (indexSource !== undefined) {
+              set(indexSource, UNINITIALIZED);
+            } else if (i in target) {
+              const deletedSource = withParent(() => source(UNINITIALIZED));
+              sources.set(indexKey, deletedSource);
+            }
           }
-        }
-      }
-      if (isArray && typeof prop === "string") {
-        const index = Number(prop);
-        if (Number.isInteger(index) && index >= 0) {
-          const lengthSource = sources.get("length");
-          if (lengthSource !== undefined && index >= lengthSource.v) {
-            set(lengthSource, index + 1);
+        } else if (typeof prop === "string") {
+          const index = Number(prop);
+          if (Number.isInteger(index) && index >= 0) {
+            const lengthSource = sources.get("length");
+            if (lengthSource !== undefined && index >= lengthSource.v) {
+              set(lengthSource, index + 1);
+            }
           }
         }
       }
@@ -743,7 +875,7 @@ function proxy(value) {
         }
         set(version, get(version) + 1);
       }
-      return Reflect.deleteProperty(target, prop);
+      return delete target[prop];
     },
     has(target, prop) {
       if (prop === STATE_SYMBOL) {
@@ -782,6 +914,7 @@ function proxy(value) {
     }
   });
   proxyCleanup.register(proxyObj, { sources, version });
+  proxyCache.set(value, proxyObj);
   return proxyObj;
 }
 function toRaw(value) {
@@ -871,6 +1004,123 @@ function disconnectDerived(derived2) {
   derived2.reactions = null;
   destroyDerivedEffects(derived2);
 }
+// src/primitives/scope.ts
+var activeScope = null;
+function getCurrentScope() {
+  return activeScope;
+}
+function setActiveScope(scope) {
+  const prev = activeScope;
+  activeScope = scope;
+  return prev;
+}
+
+class EffectScopeImpl {
+  _active = true;
+  _paused = false;
+  effects = [];
+  cleanups = [];
+  parent = null;
+  scopes = null;
+  constructor(detached = false) {
+    this.parent = activeScope;
+    if (!detached && this.parent) {
+      if (this.parent.scopes === null) {
+        this.parent.scopes = [];
+      }
+      this.parent.scopes.push(this);
+    }
+  }
+  get active() {
+    return this._active;
+  }
+  get paused() {
+    return this._paused;
+  }
+  run(fn) {
+    if (!this._active) {
+      return;
+    }
+    const prevScope = setActiveScope(this);
+    try {
+      return fn();
+    } finally {
+      setActiveScope(prevScope);
+    }
+  }
+  stop() {
+    if (!this._active)
+      return;
+    for (const effect of [...this.effects]) {
+      destroyEffect(effect);
+    }
+    this.effects.length = 0;
+    for (const cleanup of this.cleanups) {
+      try {
+        cleanup();
+      } catch {}
+    }
+    this.cleanups.length = 0;
+    if (this.scopes) {
+      for (const scope of this.scopes) {
+        scope.stop();
+      }
+      this.scopes.length = 0;
+    }
+    if (this.parent?.scopes) {
+      const idx = this.parent.scopes.indexOf(this);
+      if (idx !== -1) {
+        this.parent.scopes.splice(idx, 1);
+      }
+    }
+    this._active = false;
+  }
+  pause() {
+    if (!this._active || this._paused)
+      return;
+    this._paused = true;
+    for (const effect of this.effects) {
+      effect.f |= INERT;
+    }
+    if (this.scopes) {
+      for (const scope of this.scopes) {
+        scope.pause();
+      }
+    }
+  }
+  resume() {
+    if (!this._active || !this._paused)
+      return;
+    this._paused = false;
+    for (const effect of this.effects) {
+      effect.f &= ~INERT;
+      if ((effect.f & DIRTY) !== 0) {
+        scheduleEffect(effect);
+      }
+    }
+    if (this.scopes) {
+      for (const scope of this.scopes) {
+        scope.resume();
+      }
+    }
+  }
+}
+function effectScope(detached) {
+  return new EffectScopeImpl(detached);
+}
+function onScopeDispose(fn) {
+  if (activeScope) {
+    activeScope.cleanups.push(fn);
+  } else {
+    console.warn("onScopeDispose() called outside of scope context");
+  }
+}
+function registerEffectWithScope(effect) {
+  if (activeScope) {
+    activeScope.effects.push(effect);
+  }
+}
+
 // src/primitives/effect.ts
 function createEffect(type, fn, sync, push = true) {
   const parent = activeEffect;
@@ -886,6 +1136,7 @@ function createEffect(type, fn, sync, push = true) {
     next: null,
     wv: 0
   };
+  registerEffectWithScope(effect);
   if (sync) {
     updateEffect(effect);
     effect.f |= EFFECT_RAN;
@@ -998,7 +1249,6 @@ effect.tracking = function effectTracking() {
 var bindingCleanup = new FinalizationRegistry((internalSource) => {
   internalSource.reactions = null;
 });
-var BINDING_SYMBOL = Symbol("binding");
 function isBinding(value) {
   return value !== null && typeof value === "object" && BINDING_SYMBOL in value;
 }
@@ -1084,6 +1334,130 @@ function untrack(fn) {
   }
 }
 var peek = untrack;
+
+// src/primitives/linked.ts
+function linkedSignal(config) {
+  let sourceFn;
+  let computation;
+  let equalsFn = Object.is;
+  if (typeof config === "function") {
+    const fn = config;
+    sourceFn = fn;
+    computation = (s) => s;
+  } else {
+    sourceFn = config.source;
+    computation = config.computation;
+    if (config.equal) {
+      equalsFn = config.equal;
+    }
+  }
+  let prevSource = undefined;
+  let prevValue = undefined;
+  let initialized = false;
+  const valueSignal = signal(undefined, { equals: equalsFn });
+  const sourceTracker = derived(() => {
+    const newSource = sourceFn();
+    return newSource;
+  });
+  let manualOverride = false;
+  let lastKnownSource = undefined;
+  const dispose = effect.pre(() => {
+    const currentSource = sourceTracker.value;
+    const sourceChanged = initialized && !Object.is(lastKnownSource, currentSource);
+    if (!initialized || sourceChanged) {
+      const previous = initialized ? { source: prevSource, value: prevValue } : undefined;
+      const newValue = computation(currentSource, previous);
+      prevSource = currentSource;
+      prevValue = newValue;
+      lastKnownSource = currentSource;
+      initialized = true;
+      manualOverride = false;
+      untrack(() => {
+        valueSignal.value = newValue;
+      });
+    }
+  });
+  const accessor = {
+    [LINKED_SYMBOL]: true,
+    get value() {
+      sourceTracker.value;
+      const currentSource = untrack(() => sourceTracker.value);
+      if (initialized && !Object.is(lastKnownSource, currentSource)) {
+        flushSync();
+      }
+      return valueSignal.value;
+    },
+    set value(newValue) {
+      manualOverride = true;
+      prevValue = newValue;
+      valueSignal.value = newValue;
+    },
+    get peek() {
+      return untrack(() => valueSignal.value);
+    }
+  };
+  return accessor;
+}
+function isLinkedSignal(value) {
+  return value !== null && typeof value === "object" && LINKED_SYMBOL in value;
+}
+// src/primitives/selector.ts
+function createSelector(source2, fn = (k, v) => k === v) {
+  const subscribers = new Map;
+  const reactionKeys = new WeakMap;
+  let prevValue;
+  let initialized = false;
+  effect.pre(() => {
+    const value = source2();
+    if (initialized && !Object.is(prevValue, value)) {
+      for (const [key, reactions] of subscribers) {
+        const wasSelected = fn(key, prevValue);
+        const isSelected = fn(key, value);
+        if (wasSelected !== isSelected) {
+          const toRemove = [];
+          for (const reaction of reactions) {
+            if ((reaction.f & DESTROYED) !== 0) {
+              toRemove.push(reaction);
+              continue;
+            }
+            setSignalStatus(reaction, DIRTY);
+            if ((reaction.f & EFFECT) !== 0 && (reaction.f & DERIVED) === 0) {
+              scheduleEffect(reaction);
+            }
+          }
+          for (const r of toRemove) {
+            reactions.delete(r);
+          }
+        }
+      }
+    }
+    prevValue = value;
+    initialized = true;
+  });
+  return (key) => {
+    const currentValue = prevValue;
+    if (activeReaction !== null) {
+      const reaction = activeReaction;
+      if ((reaction.f & DESTROYED) === 0) {
+        let keySubscribers = subscribers.get(key);
+        if (!keySubscribers) {
+          keySubscribers = new Set;
+          subscribers.set(key, keySubscribers);
+        }
+        if (!keySubscribers.has(reaction)) {
+          keySubscribers.add(reaction);
+          let keys = reactionKeys.get(reaction);
+          if (!keys) {
+            keys = new Set;
+            reactionKeys.set(reaction, keys);
+          }
+          keys.add(key);
+        }
+      }
+    }
+    return fn(key, currentValue);
+  };
+}
 // src/collections/map.ts
 var mapCleanup = new FinalizationRegistry((data) => {
   data.version.reactions = null;