@solidjs/signals 0.13.13 → 2.0.0-beta.7

package/README.md

@@ -1,6 +1,6 @@
 # @solidjs/signals
 
-The reactive core that powers [SolidJS 2.0](https://github.com/solidjs/solid). This is a standalone signals library designed for rendering — it includes first-class support for async, transitions, optimistic updates, and deeply reactive stores that go beyond what general-purpose signals libraries offer.
+The reactive core that powers [SolidJS 2.0](https://github.com/solidjs/solid). It is developed in the Solid monorepo and includes first-class support for async, transitions, optimistic updates, and deeply reactive stores that go beyond what general-purpose signals libraries offer.
 
 > **Status:** Beta — this package is the reactive foundation of SolidJS 2.0 Beta. The API is stabilizing but may still have breaking changes before a final release.
 
@@ -240,14 +240,15 @@ createRoot(dispose => {
 
 ## Development
 
+From the monorepo root:
+
 ```bash
 pnpm install
-pnpm build          # Rollup build (dev/prod/node outputs)
-pnpm test           # Run tests
-pnpm test:watch     # Watch mode
-pnpm test:gc        # Tests with GC exposed
-pnpm bench          # Benchmarks
-pnpm format         # Prettier + import sorting
+pnpm --filter @solidjs/signals build
+pnpm --filter @solidjs/signals test
+pnpm --filter @solidjs/signals test:watch
+pnpm --filter @solidjs/signals test:gc
+pnpm --filter @solidjs/signals bench
 ```
 
 ## License

package/dist/dev.js

@@ -426,7 +426,7 @@ class GlobalQueue extends Queue {
             stashedOptimisticReads = new Set();
             for (let i = 0; i < stashedTransition._optimisticNodes.length; i++) {
               const node = stashedTransition._optimisticNodes[i];
-              if (node._fn || node._pureWrite) continue;
+              if (node._fn || node._ownedWrite) continue;
               stashedOptimisticReads.add(node);
               queueStashedOptimisticEffects(node);
             }
@@ -790,6 +790,7 @@ function unobserved(el) {
     dep = unlinkSubs(dep);
   }
   el._deps = null;
+  el._depsTail = null;
   disposeChildren(el, true);
 }
 function link(dep, sub) {
@@ -1489,7 +1490,7 @@ function computed(fn, initialValue, options) {
       (transparent ? context?.id : context?.id != null ? getNextChildId(context) : undefined),
     _transparent: transparent || undefined,
     _equals: options?.equals != null ? options.equals : isEqual,
-    _pureWrite: !!options?.pureWrite,
+    _ownedWrite: !!options?.ownedWrite,
     _unobserved: options?.unobserved,
     _disposal: null,
     _queue: context?._queue ?? globalQueue,
@@ -1538,7 +1539,7 @@ function computed(fn, initialValue, options) {
   if (parent) self._height = parent._height + 1;
   if (snapshotCaptureActive && ownerInSnapshotScope(context)) self._inSnapshotScope = true;
   if (externalSourceConfig) {
-    const bridgeSignal = signal(undefined, { equals: false, pureWrite: true });
+    const bridgeSignal = signal(undefined, { equals: false, ownedWrite: true });
     const source = externalSourceConfig.factory(self._fn, () => {
       setSignal(bridgeSignal, undefined);
     });
@@ -1560,7 +1561,7 @@ function computed(fn, initialValue, options) {
 function signal(v, options, firewall = null) {
   const s = {
     _equals: options?.equals != null ? options.equals : isEqual,
-    _pureWrite: !!options?.pureWrite,
+    _ownedWrite: !!options?.ownedWrite,
     _noSnapshot: !!options?._noSnapshot,
     _unobserved: options?.unobserved,
     _value: v,
@@ -1672,10 +1673,16 @@ function read(el) {
   }
   let c = context;
   if (c?._root) c = c._parentComputed;
-  if (refreshing && el._fn) recompute(el);
-  if (el._flags & REACTIVE_LAZY) {
-    el._flags &= ~REACTIVE_LAZY;
-    recompute(el, true);
+  const computed = el;
+  if (typeof computed._fn === "function") {
+    const comp = el;
+    if (refreshing && !(comp._flags & REACTIVE_DISPOSED)) recompute(comp);
+    if (comp._flags & REACTIVE_LAZY) {
+      comp._flags &= ~REACTIVE_LAZY;
+      recompute(comp, true);
+    } else if (comp._flags & REACTIVE_DISPOSED) {
+      recompute(comp, true);
+    }
   }
   const owner = el._firewall || el;
   if (strictRead && owner._statusFlags & STATUS_PENDING) {
@@ -1695,7 +1702,6 @@ function read(el) {
     throw new Error(message);
   }
   if (c && tracking) {
-    if (el._fn && el._flags & REACTIVE_DISPOSED) recompute(el);
     link(el, c);
     if (owner._fn) {
       const isZombie = el._flags & REACTIVE_ZOMBIE;
@@ -1780,7 +1786,8 @@ function read(el) {
     if (c && stale && shouldReadStashedOptimisticValue(el)) return el._value;
     return el._overrideValue;
   }
-  return !c ||
+  const value =
+    !c ||
     (currentOptimisticLane !== null &&
       (el._overrideValue !== undefined ||
         el._optimisticLane ||
@@ -1788,14 +1795,26 @@ function read(el) {
         !!(owner._statusFlags & STATUS_PENDING))) ||
     el._pendingValue === NOT_PENDING ||
     (stale && el._transition && activeTransition !== el._transition)
-    ? el._value
-    : el._pendingValue;
+      ? el._value
+      : el._pendingValue;
+  if (
+    !c &&
+    owner === el &&
+    typeof computed._fn === "function" &&
+    !computed._preventAutoDisposal &&
+    !(owner._statusFlags & STATUS_PENDING) &&
+    !computed._parent &&
+    !el._subs
+  ) {
+    unobserved(el);
+  }
+  return value;
 }
 function setSignal(el, v) {
-  if (!el._pureWrite && !context?._childrenForbidden && context && el._firewall !== context) {
+  if (!el._ownedWrite && !context?._childrenForbidden && context && el._firewall !== context) {
     const message =
       "Writing to a Signal inside an owned scope (component, computation) is not allowed. " +
-      "Move the write outside or set the `pureWrite` option if this is intentional.";
+      "Move the write outside or set the `ownedWrite` option if this is intentional.";
     emitDiagnostic({
       code: "SIGNAL_WRITE_IN_OWNED_SCOPE",
       kind: "write",
@@ -1879,7 +1898,7 @@ function runWithOwner(owner, fn) {
 }
 function getPendingSignal(el) {
   if (!el._pendingSignal) {
-    el._pendingSignal = optimisticSignal(false, { pureWrite: true });
+    el._pendingSignal = optimisticSignal(false, { ownedWrite: true });
     if (el._parentSource) {
       el._pendingSignal._parentSource = el;
     }
@@ -2065,16 +2084,18 @@ function effect(compute, effect, error, initialValue, options) {
       node._queue.notify(node, STATUS_PENDING | STATUS_ERROR, actualStatus, actualError);
       if (_hitUnhandledAsync) {
         resetUnhandledAsync();
-        const err = new Error("An async value must be rendered inside a Loading boundary.");
-        emitDiagnostic({
-          code: "ASYNC_OUTSIDE_LOADING_BOUNDARY",
-          kind: "async",
-          severity: "error",
-          message: err.message,
-          ownerId: node.id,
-          ownerName: node._name
-        });
-        if (!node._queue.notify(node, STATUS_ERROR, STATUS_ERROR)) throw err;
+        if (!node._queue.notify(node, STATUS_ERROR, STATUS_ERROR)) {
+          const message = "An async value must be rendered inside a Loading boundary.";
+          emitDiagnostic({
+            code: "ASYNC_OUTSIDE_LOADING_BOUNDARY",
+            kind: "async",
+            severity: "error",
+            message: message,
+            ownerId: node.id,
+            ownerName: node._name
+          });
+          throw new Error(message);
+        }
       }
     }
   };
@@ -2257,27 +2278,28 @@ function accessor(node) {
   fn.$r = true;
   return fn;
 }
-function createSignal(first, second, third) {
+function createSignal(first, second) {
   if (typeof first === "function") {
-    const node = computed(first, second, third);
+    const node = computed(first, undefined, second);
+    node._preventAutoDisposal = true;
     return [accessor(node), setSignal.bind(null, node)];
   }
   const node = signal(first, second);
   registerGraph(node, getOwner());
   return [accessor(node), setSignal.bind(null, node)];
 }
-function createMemo(compute, value, options) {
-  let node = computed(compute, value, options);
+function createMemo(compute, options) {
+  let node = computed(compute, undefined, options);
   return accessor(node);
 }
-function createEffect(compute, effectFn, value, options) {
-  effect(compute, effectFn.effect || effectFn, effectFn.error, value, {
+function createEffect(compute, effectFn, options) {
+  effect(compute, effectFn.effect || effectFn, effectFn.error, undefined, {
     ...options,
     name: options?.name ?? "effect"
   });
 }
-function createRenderEffect(compute, effectFn, value, options) {
-  effect(compute, effectFn, undefined, value, {
+function createRenderEffect(compute, effectFn, options) {
+  effect(compute, effectFn, undefined, undefined, {
     render: true,
     ...{ ...options, name: options?.name ?? "effect" }
   });
@@ -2331,9 +2353,10 @@ function resolve(fn) {
     });
   });
 }
-function createOptimistic(first, second, third) {
+function createOptimistic(first, second) {
   if (typeof first === "function") {
-    const node = optimisticComputed(first, second, third);
+    const node = optimisticComputed(first, undefined, second);
+    node._preventAutoDisposal = true;
     return [accessor(node), setSignal.bind(null, node)];
   }
   const node = optimisticSignal(first, second);
@@ -2499,7 +2522,7 @@ function reconcile(value, key) {
     applyState(value, state, keyFn);
   };
 }
-function createProjectionInternal(fn, initialValue = {}, options) {
+function createProjectionInternal(fn, seed, options) {
   let node;
   const wrappedMap = new WeakMap();
   const wrapper = s => {
@@ -2519,7 +2542,7 @@ function createProjectionInternal(fn, initialValue = {}, options) {
     wrappedMap.set(source, wrapped);
     return wrapped;
   };
-  const wrappedStore = wrapProjection(initialValue);
+  const wrappedStore = wrapProjection(seed);
   node = computed(() => {
     const owner = getOwner();
     let settled = false;
@@ -2542,8 +2565,8 @@ function createProjectionInternal(fn, initialValue = {}, options) {
   node._preventAutoDisposal = true;
   return { store: wrappedStore, node: node };
 }
-function createProjection(fn, initialValue = {}, options) {
-  return createProjectionInternal(fn, initialValue, options).store;
+function createProjection(fn, seed, options) {
+  return createProjectionInternal(fn, seed, options).store;
 }
 function createWriteTraps(isActive) {
   const traps = {
@@ -3021,7 +3044,7 @@ function createStore(first, second, options) {
 function createOptimisticStore(first, second, options) {
   GlobalQueue._clearOptimisticStore ||= clearOptimisticStore;
   const derived = typeof first === "function";
-  const initialValue = (derived ? second : first) ?? {};
+  const initialValue = derived ? second : first;
   const fn = derived ? first : undefined;
   const { store: wrappedStore } = createOptimisticProjectionInternal(fn, initialValue, options);
   return [wrappedStore, fn => storeSetter(wrappedStore, fn)];
@@ -3055,7 +3078,7 @@ function clearOptimisticStore(store) {
   }
   delete target[STORE_OPTIMISTIC_OVERRIDE];
 }
-function createOptimisticProjectionInternal(fn, initialValue = {}, options) {
+function createOptimisticProjectionInternal(fn, initialValue, options) {
   let node;
   const wrappedMap = new WeakMap();
   const wrapper = s => {
@@ -3386,7 +3409,7 @@ function mapArray(list, map, options) {
         }
       }
     : map;
-  return createMemo(
+  const node = computed(
     updateKeyedMap.bind({
       _owner: createOwner(),
       _len: 0,
@@ -3401,8 +3424,10 @@ function mapArray(list, map, options) {
       _fallback: options?.fallback
     })
   );
+  node._preventAutoDisposal = true;
+  return accessor(node);
 }
-const pureOptions = { pureWrite: true };
+const pureOptions = { ownedWrite: true };
 function updateKeyedMap() {
   const newItems = this._list() || [],
     newLen = newItems.length;
@@ -3539,17 +3564,21 @@ function repeat(count, map, options) {
         }
       }
     : map;
-  return updateRepeat.bind({
-    _owner: createOwner(),
-    _len: 0,
-    _offset: 0,
-    _count: count,
-    _map: wrappedMap,
-    _nodes: [],
-    _mappings: [],
-    _from: options?.from,
-    _fallback: options?.fallback
-  });
+  const node = computed(
+    updateRepeat.bind({
+      _owner: createOwner(),
+      _len: 0,
+      _offset: 0,
+      _count: count,
+      _map: wrappedMap,
+      _nodes: [],
+      _mappings: [],
+      _from: options?.from,
+      _fallback: options?.fallback
+    })
+  );
+  node._preventAutoDisposal = true;
+  return accessor(node);
 }
 function updateRepeat() {
   const newLen = this._count();
@@ -3652,8 +3681,8 @@ class RevealController {
   _collapsedAccessor;
   _slots = [];
   _parentController;
-  _disabled = signal(false, { pureWrite: true, _noSnapshot: true });
-  _collapsed = signal(false, { pureWrite: true, _noSnapshot: true });
+  _disabled = signal(false, { ownedWrite: true, _noSnapshot: true });
+  _collapsed = signal(false, { ownedWrite: true, _noSnapshot: true });
   _ready = true;
   _evaluating = false;
   constructor(together, collapsed) {
@@ -3676,8 +3705,8 @@ class RevealController {
     if (this._slots.includes(slot)) return;
     this._slots.push(slot);
     const together = !!untrack(this._togetherAccessor);
-    setSignal(slot._disabled, true),
-      setSignal(slot._collapsed, together ? false : !!untrack(this._collapsedAccessor));
+    (setSignal(slot._disabled, true),
+      setSignal(slot._collapsed, together ? false : !!untrack(this._collapsedAccessor)));
     untrack(() => this.evaluate());
   }
   unregister(slot) {
@@ -3719,8 +3748,8 @@ class CollectionQueue extends Queue {
   _sources = new Set();
   _tree;
   _pending = true;
-  _disabled = signal(false, { pureWrite: true, _noSnapshot: true });
-  _collapsed = signal(false, { pureWrite: true, _noSnapshot: true });
+  _disabled = signal(false, { ownedWrite: true, _noSnapshot: true });
+  _collapsed = signal(false, { ownedWrite: true, _noSnapshot: true });
   _revealController;
   _initialized = false;
   _onFn;
@@ -3836,7 +3865,7 @@ function createCollectionBoundary(type, fn, fallback, onFn) {
   const decision = computed(() => {
     if (!read(queue._disabled)) {
       const resolved = read(tree);
-      if (!untrack(() => read(queue._disabled))) return (queue._initialized = true), resolved;
+      if (!untrack(() => read(queue._disabled))) return ((queue._initialized = true), resolved);
     }
     if (_revealUsed && read(queue._collapsed)) return undefined;
     return fallback(queue);