@solidjs/signals 2.0.0-beta.7 → 2.0.0-beta.8

package/dist/dev.js

@@ -240,6 +240,23 @@ let inTrackedQueueCallback = false;
 let _enforceLoadingBoundary = false;
 let _hitUnhandledAsync = false;
 let stashedOptimisticReads = null;
+const transientStoreNodes = new Set();
+function registerTransientStoreNode(node) {
+  transientStoreNodes.add(node);
+}
+function sweepTransientStoreNodes() {
+  if (transientStoreNodes.size === 0) return;
+  for (const node of transientStoreNodes) {
+    if (node._subs !== null) {
+      transientStoreNodes.delete(node);
+      continue;
+    }
+    if (node._pendingValue !== NOT_PENDING) continue;
+    if (node._overrideValue !== undefined && node._overrideValue !== NOT_PENDING) continue;
+    transientStoreNodes.delete(node);
+    node._unobserved?.();
+  }
+}
 function resetUnhandledAsync() {
   _hitUnhandledAsync = false;
 }
@@ -589,6 +606,7 @@ function finalizePureQueue(completingTransition = null, incomplete = false) {
       optimisticStores.clear();
       schedule();
     }
+    sweepTransientStoreNodes();
     cleanupCompletedLanes(completingTransition);
   }
 }
@@ -1383,7 +1401,9 @@ function recompute(el, create = false) {
     if (lane) currentOptimisticLane = lane;
   }
   try {
-    value = handleAsync(el, el._fn(value));
+    const prevInFlight = el._inFlight;
+    const fnResult = el._fn(value);
+    value = el._inFlight !== prevInFlight ? fnResult : handleAsync(el, fnResult);
     clearStatus(el, create);
     const resolvedLane = resolveLane(el);
     if (resolvedLane) {
@@ -1482,7 +1502,7 @@ function updateIfNecessary(el) {
   }
   el._flags = el._flags & (REACTIVE_SNAPSHOT_STALE | REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT);
 }
-function computed(fn, initialValue, options) {
+function computed(fn, options) {
   const transparent = options?.transparent ?? false;
   const self = {
     id:
@@ -1497,7 +1517,7 @@ function computed(fn, initialValue, options) {
     _context: context?._context ?? defaultContext,
     _childCount: 0,
     _fn: fn,
-    _value: initialValue,
+    _value: undefined,
     _height: 0,
     _child: null,
     _nextHeap: undefined,
@@ -1592,8 +1612,8 @@ function optimisticSignal(v, options) {
   s._overrideValue = NOT_PENDING;
   return s;
 }
-function optimisticComputed(fn, initialValue, options) {
-  const c = computed(fn, initialValue, options);
+function optimisticComputed(fn, options) {
+  const c = computed(fn, options);
   c._overrideValue = NOT_PENDING;
   return c;
 }
@@ -2041,26 +2061,23 @@ function hasContext(context, owner) {
 function isUndefined(value) {
   return typeof value === "undefined";
 }
-function effect(compute, effect, error, initialValue, options) {
+function effect(compute, effect, error, options) {
   let initialized = false;
-  const node = computed(
-    options?.render ? p => staleValues(() => compute(p)) : compute,
-    initialValue,
-    {
-      ...options,
-      equals: () => {
-        node._modified = !node._error;
-        if (initialized) node._queue.enqueue(node._type, runEffect.bind(node));
-        return false;
-      },
-      lazy: true
-    }
-  );
-  node._prevValue = initialValue;
+  const isUser = !!options?.user;
+  const node = computed(isUser ? compute : p => staleValues(() => compute(p)), {
+    ...options,
+    equals: () => {
+      node._modified = !node._error;
+      if (initialized) node._queue.enqueue(node._type, runEffect.bind(node));
+      return false;
+    },
+    lazy: true
+  });
+  node._prevValue = undefined;
   node._effectFn = effect;
   node._errorFn = error;
   node._cleanup = undefined;
-  node._type = options?.render ? EFFECT_RENDER : EFFECT_USER;
+  node._type = isUser ? EFFECT_USER : EFFECT_RENDER;
   node._notifyStatus = (status, error) => {
     const actualStatus = status !== undefined ? status : node._statusFlags;
     const actualError = error !== undefined ? error : node._error;
@@ -2085,23 +2102,24 @@ function effect(compute, effect, error, initialValue, options) {
       if (_hitUnhandledAsync) {
         resetUnhandledAsync();
         if (!node._queue.notify(node, STATUS_ERROR, STATUS_ERROR)) {
-          const message = "An async value must be rendered inside a Loading boundary.";
+          const message =
+            "An async value was read outside a Loading boundary. The root mount will be deferred until all pending async settles.";
           emitDiagnostic({
             code: "ASYNC_OUTSIDE_LOADING_BOUNDARY",
             kind: "async",
-            severity: "error",
+            severity: "warn",
             message: message,
             ownerId: node.id,
             ownerName: node._name
           });
-          throw new Error(message);
+          console.warn(message);
         }
       }
     }
   };
   recompute(node, true);
   !options?.defer &&
-    (node._type === EFFECT_USER
+    (node._type === EFFECT_USER || options?.schedule
       ? node._queue.enqueue(node._type, runEffect.bind(node))
       : runEffect.call(node));
   initialized = true;
@@ -2169,7 +2187,6 @@ function trackedEffect(fn, options) {
       }
       node._cleanup = cleanup;
     },
-    undefined,
     { ...options, lazy: true }
   );
   node._cleanup = undefined;
@@ -2280,7 +2297,7 @@ function accessor(node) {
 }
 function createSignal(first, second) {
   if (typeof first === "function") {
-    const node = computed(first, undefined, second);
+    const node = computed(first, second);
     node._preventAutoDisposal = true;
     return [accessor(node), setSignal.bind(null, node)];
   }
@@ -2289,20 +2306,17 @@ function createSignal(first, second) {
   return [accessor(node), setSignal.bind(null, node)];
 }
 function createMemo(compute, options) {
-  let node = computed(compute, undefined, options);
+  let node = computed(compute, options);
   return accessor(node);
 }
 function createEffect(compute, effectFn, options) {
-  effect(compute, effectFn.effect || effectFn, effectFn.error, undefined, {
-    ...options,
-    name: options?.name ?? "effect"
+  effect(compute, effectFn.effect || effectFn, effectFn.error, {
+    user: true,
+    ...{ ...options, name: options?.name ?? "effect" }
   });
 }
 function createRenderEffect(compute, effectFn, options) {
-  effect(compute, effectFn, undefined, undefined, {
-    render: true,
-    ...{ ...options, name: options?.name ?? "effect" }
-  });
+  effect(compute, effectFn, undefined, { ...options, name: options?.name ?? "effect" });
 }
 function createTrackedEffect(compute, options) {
   trackedEffect(compute, { ...options, name: options?.name ?? "trackedEffect" });
@@ -2327,8 +2341,11 @@ function createReaction(effectFn, options) {
           dispose(node);
         },
         effectFn.error,
-        undefined,
-        { defer: true, ...(true ? { ...options, name: options?.name ?? "effect" } : options) }
+        {
+          ...(true ? { ...options, name: options?.name ?? "effect" } : options),
+          user: true,
+          defer: true
+        }
       );
     });
   };
@@ -2355,7 +2372,7 @@ function resolve(fn) {
 }
 function createOptimistic(first, second) {
   if (typeof first === "function") {
-    const node = optimisticComputed(first, undefined, second);
+    const node = optimisticComputed(first, second);
     node._preventAutoDisposal = true;
     return [accessor(node), setSignal.bind(null, node)];
   }
@@ -2543,31 +2560,39 @@ function createProjectionInternal(fn, seed, options) {
     return wrapped;
   };
   const wrappedStore = wrapProjection(seed);
-  node = computed(() => {
-    const owner = getOwner();
-    let settled = false;
-    let result;
-    const draft = new Proxy(
-      wrappedStore,
-      createWriteTraps(() => !settled || owner._inFlight === result)
-    );
-    storeSetter(draft, s => {
-      result = fn(s);
-      settled = true;
-      const value = handleAsync(owner, result, value => {
-        value !== s &&
-          value !== undefined &&
-          storeSetter(wrappedStore, reconcile(value, options?.key || "id"));
-      });
-      value !== s && value !== undefined && reconcile(value, options?.key || "id")(wrappedStore);
-    });
-  });
+  node = computed(
+    () => {
+      if (!node) node = getOwner();
+      runProjectionComputed(wrappedStore, fn, options?.key || "id");
+    },
+    options?.name ? { name: options.name } : undefined
+  );
   node._preventAutoDisposal = true;
   return { store: wrappedStore, node: node };
 }
 function createProjection(fn, seed, options) {
   return createProjectionInternal(fn, seed, options).store;
 }
+function runProjectionComputed(wrappedStore, fn, key, wrapCommit) {
+  const owner = getOwner();
+  let settled = false;
+  let result;
+  const draft = new Proxy(
+    wrappedStore,
+    createWriteTraps(() => !settled || owner._inFlight === result)
+  );
+  storeSetter(draft, s => {
+    result = fn(s);
+    settled = true;
+    const commit = v => {
+      if (v === s || v === undefined) return;
+      const write = () => storeSetter(wrappedStore, reconcile(v, key));
+      wrapCommit ? wrapCommit(write) : write();
+    };
+    commit(handleAsync(owner, result, commit));
+  });
+  return owner;
+}
 function createWriteTraps(isActive) {
   const traps = {
     get(_, prop) {
@@ -2677,7 +2702,7 @@ function getNode(nodes, property, value, firewall, equals = isEqual, optimistic,
     {
       equals: equals,
       unobserved() {
-        delete nodes[property];
+        if (nodes[property] === s) delete nodes[property];
       }
     },
     firewall
@@ -2751,19 +2776,51 @@ function prepareStoreWrite(target, store, property) {
   if (useOptimistic) trackOptimisticStore(store);
   return { base: base, overrideKey: overrideKey, state: state };
 }
-function notifyStoreProperty(target, property, mode, value) {
-  if (target[STORE_HAS]?.[property]) setSignal(target[STORE_HAS][property], mode !== "delete");
+function upsertStoreNode(target, nodes, property, prev, snapshotProps) {
+  if (nodes[property]) return nodes[property];
+  const initial = isWrappable(prev) ? wrap(prev, target) : prev;
+  const node = getNode(
+    nodes,
+    property,
+    initial,
+    target[STORE_FIREWALL],
+    isEqual,
+    target[STORE_OPTIMISTIC],
+    snapshotProps
+  );
+  registerTransientStoreNode(node);
+  return node;
+}
+function notifyStoreProperty(target, property, mode, value, prev, prevHas) {
+  const skipUpsert = projectionWriteActive || target[STORE_OPTIMISTIC];
+  const newHas = mode !== "delete";
+  const existingHas = target[STORE_HAS]?.[property];
+  if (existingHas) {
+    setSignal(existingHas, newHas);
+  } else if (!skipUpsert && mode !== "invalidate" && prevHas !== newHas) {
+    const hasNode = upsertStoreNode(target, getNodes(target, STORE_HAS), property, prevHas);
+    setSignal(hasNode, newHas);
+  }
   const nodes = getNodes(target, STORE_NODE);
   if (mode === "set") {
-    nodes[property] &&
+    if (nodes[property]) {
       setSignal(nodes[property], () => (isWrappable(value) ? wrap(value, target) : value));
+    } else if (!skipUpsert) {
+      const node = upsertStoreNode(target, nodes, property, prev, target[STORE_SNAPSHOT_PROPS]);
+      setSignal(node, () => (isWrappable(value) ? wrap(value, target) : value));
+    }
   } else if (mode === "invalidate") {
     if (nodes[property]) {
       setSignal(nodes[property], {});
       delete nodes[property];
     }
   } else {
-    nodes[property] && setSignal(nodes[property], undefined);
+    if (nodes[property]) {
+      setSignal(nodes[property], undefined);
+    } else if (!skipUpsert) {
+      const node = upsertStoreNode(target, nodes, property, prev, target[STORE_SNAPSHOT_PROPS]);
+      setSignal(node, undefined);
+    }
   }
   nodes[$TRACK] && setSignal(nodes[$TRACK], undefined);
 }
@@ -2860,18 +2917,13 @@ const storeTraps = {
         : target[STORE_OVERRIDE] && property in target[STORE_OVERRIDE]
           ? target[STORE_OVERRIDE][property] !== $DELETED
           : property in target[STORE_VALUE];
-    if (!writeOnly(target[$PROXY])) {
-      getObserver() &&
-        read(
-          getNode(
-            getNodes(target, STORE_HAS),
-            property,
-            has,
-            target[STORE_FIREWALL],
-            isEqual,
-            target[STORE_OPTIMISTIC]
-          )
-        );
+    if (writeOnly(target[$PROXY])) return has;
+    const nodes = getNodes(target, STORE_HAS);
+    if (nodes[property]) return read(nodes[property]);
+    if (getObserver()) {
+      return read(
+        getNode(nodes, property, has, target[STORE_FIREWALL], isEqual, target[STORE_OPTIMISTIC])
+      );
     }
     return has;
   },
@@ -2890,6 +2942,12 @@ const storeTraps = {
             : target[STORE_OVERRIDE] && property in target[STORE_OVERRIDE]
               ? target[STORE_OVERRIDE][property]
               : base;
+        const prevHas =
+          target[STORE_OPTIMISTIC_OVERRIDE] && property in target[STORE_OPTIMISTIC_OVERRIDE]
+            ? target[STORE_OPTIMISTIC_OVERRIDE][property] !== $DELETED
+            : target[STORE_OVERRIDE] && property in target[STORE_OVERRIDE]
+              ? target[STORE_OVERRIDE][property] !== $DELETED
+              : property in target[STORE_VALUE];
         const value = rawValue?.[$TARGET]?.[STORE_VALUE] ?? rawValue;
         const isArrayIndexWrite = Array.isArray(state) && property !== "length";
         const nextIndex = isArrayIndexWrite ? parseInt(property) + 1 : 0;
@@ -2909,11 +2967,21 @@ const storeTraps = {
           override[property] = value;
           if (nextLength !== undefined) override.length = nextLength;
         }
-        notifyStoreProperty(target, property, "set", value);
-        if (Array.isArray(state)) {
+        notifyStoreProperty(target, property, "set", value, prev, prevHas);
+        if (Array.isArray(state) && property !== "length" && nextLength !== undefined) {
           const nodes = getNodes(target, STORE_NODE);
-          const lengthValue = property === "length" ? value : nextLength;
-          lengthValue !== undefined && nodes.length && setSignal(nodes.length, lengthValue);
+          if (nodes.length) {
+            setSignal(nodes.length, nextLength);
+          } else if (!projectionWriteActive && !target[STORE_OPTIMISTIC]) {
+            const node = upsertStoreNode(
+              target,
+              nodes,
+              "length",
+              len,
+              target[STORE_SNAPSHOT_PROPS]
+            );
+            setSignal(node, nextLength);
+          }
         }
         if (true) DEV$1.hooks.onStoreNodeUpdate?.(target[$PROXY], property, value, prev);
       });
@@ -2971,7 +3039,7 @@ const storeTraps = {
         } else if (target[overrideKey] && property in target[overrideKey]) {
           delete target[overrideKey][property];
         } else return true;
-        notifyStoreProperty(target, property, "delete");
+        notifyStoreProperty(target, property, "delete", undefined, prev, true);
       });
     }
     return true;
@@ -3101,37 +3169,25 @@ function createOptimisticProjectionInternal(fn, initialValue, options) {
   };
   const wrappedStore = wrapProjection(initialValue);
   if (fn) {
-    node = computed(() => {
-      const owner = getOwner();
-      let settled = false;
-      let result;
-      const draft = new Proxy(
-        wrappedStore,
-        createWriteTraps(() => !settled || owner._inFlight === result)
-      );
+    const wrapCommit = write => {
       setProjectionWriteActive(true);
       try {
-        storeSetter(draft, s => {
-          result = fn(s);
-          settled = true;
-          const value = handleAsync(owner, result, value => {
-            setProjectionWriteActive(true);
-            try {
-              value !== s &&
-                value !== undefined &&
-                storeSetter(wrappedStore, reconcile(value, options?.key || "id"));
-            } finally {
-              setProjectionWriteActive(false);
-            }
-          });
-          value !== s &&
-            value !== undefined &&
-            reconcile(value, options?.key || "id")(wrappedStore);
-        });
+        write();
       } finally {
         setProjectionWriteActive(false);
       }
-    });
+    };
+    node = computed(
+      () => {
+        setProjectionWriteActive(true);
+        try {
+          runProjectionComputed(wrappedStore, fn, options?.key || "id", wrapCommit);
+        } finally {
+          setProjectionWriteActive(false);
+        }
+      },
+      options?.name ? { name: options.name } : undefined
+    );
     node._preventAutoDisposal = true;
   }
   return { store: wrappedStore, node: node };
@@ -3635,7 +3691,7 @@ function compare(key, a, b) {
   return key ? key(a) === key(b) : true;
 }
 function boundaryComputed(fn, propagationMask) {
-  const node = computed(fn, undefined, { lazy: true });
+  const node = computed(fn, { lazy: true });
   node._notifyStatus = (status, error) => {
     const flags = status !== undefined ? status : node._statusFlags;
     const actualError = error !== undefined ? error : node._error;
@@ -3660,12 +3716,16 @@ const ON_INIT = Symbol();
 const RevealControllerContext = createContext(null);
 let _revealUsed = false;
 const FALSE_ACCESSOR = () => false;
+const SEQUENTIAL_ACCESSOR = () => "sequential";
 function isRevealController(slot) {
   return slot instanceof RevealController;
 }
 function isSlotReady(slot) {
   return isRevealController(slot) ? slot.isReady() : slot._sources.size === 0 && !slot._pending;
 }
+function isSlotMinimallyReady(slot) {
+  return isRevealController(slot) ? slot.isMinimallyReady() : isSlotReady(slot);
+}
 function setSlotState(slot, controller, disabled, collapsed) {
   setSignal(slot._disabled, disabled);
   setSignal(slot._collapsed, collapsed);
@@ -3677,16 +3737,17 @@ function setSlotState(slot, controller, disabled, collapsed) {
     slot._revealController = undefined;
 }
 class RevealController {
-  _togetherAccessor;
+  _orderAccessor;
   _collapsedAccessor;
   _slots = [];
   _parentController;
   _disabled = signal(false, { ownedWrite: true, _noSnapshot: true });
   _collapsed = signal(false, { ownedWrite: true, _noSnapshot: true });
   _ready = true;
+  _minimallyReady = true;
   _evaluating = false;
-  constructor(together, collapsed) {
-    this._togetherAccessor = together;
+  constructor(order, collapsed) {
+    this._orderAccessor = order;
     this._collapsedAccessor = collapsed;
   }
   _forEachOwnedSlot(fn) {
@@ -3701,12 +3762,37 @@ class RevealController {
   isReady() {
     return this._forEachOwnedSlot(isSlotReady);
   }
+  isMinimallyReady() {
+    const order = untrack(this._orderAccessor);
+    if (order === "together") return this.isReady();
+    if (order === "natural") {
+      let hasSlot = false;
+      let anyReady = false;
+      this._forEachOwnedSlot(slot => {
+        hasSlot = true;
+        if (isSlotMinimallyReady(slot)) {
+          anyReady = true;
+          return false;
+        }
+      });
+      return !hasSlot || anyReady;
+    }
+    let firstReady = true;
+    this._forEachOwnedSlot(slot => {
+      firstReady = isSlotMinimallyReady(slot);
+      return false;
+    });
+    return firstReady;
+  }
   register(slot) {
     if (this._slots.includes(slot)) return;
     this._slots.push(slot);
-    const together = !!untrack(this._togetherAccessor);
+    const order = untrack(this._orderAccessor);
     (setSignal(slot._disabled, true),
-      setSignal(slot._collapsed, together ? false : !!untrack(this._collapsedAccessor)));
+      setSignal(
+        slot._collapsed,
+        order === "sequential" ? !!untrack(this._collapsedAccessor) : false
+      ));
     untrack(() => this.evaluate());
   }
   unregister(slot) {
@@ -3718,29 +3804,52 @@ class RevealController {
     if (this._evaluating) return;
     this._evaluating = true;
     const wasReady = this._ready;
+    const wasMinReady = this._minimallyReady;
     try {
       const disabled = disabledOverride ?? read(this._disabled),
-        collapseTail = !!untrack(this._collapsedAccessor),
+        order = untrack(this._orderAccessor),
+        collapseTail = order === "sequential" && !!untrack(this._collapsedAccessor),
         collapsed = collapsedOverride ?? collapseTail;
-      if (disabled && collapsed)
-        this._forEachOwnedSlot(slot => setSlotState(slot, this, true, true));
-      else if (!!untrack(this._togetherAccessor)) {
-        const ready = this.isReady();
-        this._forEachOwnedSlot(slot => setSlotState(slot, this, !ready, false));
+      if (disabled) {
+        this._forEachOwnedSlot(slot => setSlotState(slot, this, true, collapsed));
+      } else if (order === "natural") {
+        this._forEachOwnedSlot(slot => {
+          if (isRevealController(slot)) {
+            setSignal(slot._collapsed, false);
+            setSignal(slot._disabled, false);
+            slot.evaluate(false, false);
+          } else {
+            setSlotState(slot, this, !isSlotReady(slot), false);
+          }
+        });
+      } else if (order === "together") {
+        const minReady = this._forEachOwnedSlot(isSlotMinimallyReady);
+        this._forEachOwnedSlot(slot => setSlotState(slot, this, !minReady, false));
       } else {
         let pendingSeen = false;
         this._forEachOwnedSlot(slot => {
           if (pendingSeen) return setSlotState(slot, this, true, collapseTail);
           if (isSlotReady(slot)) return setSlotState(slot, this, false, false);
           pendingSeen = true;
-          setSlotState(slot, this, true, false);
+          if (isRevealController(slot)) {
+            setSignal(slot._collapsed, false);
+            setSignal(slot._disabled, false);
+            slot.evaluate(false, false);
+          } else {
+            setSlotState(slot, this, true, false);
+          }
         });
       }
     } finally {
       this._ready = this.isReady();
+      this._minimallyReady = this.isMinimallyReady();
       this._evaluating = false;
     }
-    if (this._parentController && wasReady !== this._ready) this._parentController.evaluate();
+    if (
+      this._parentController &&
+      (wasReady !== this._ready || wasMinReady !== this._minimallyReady)
+    )
+      this._parentController.evaluate();
   }
 }
 class CollectionQueue extends Queue {
@@ -3889,14 +3998,14 @@ function createRevealOrder(fn, options) {
   _revealUsed = true;
   const owner = createOwner();
   const parentController = getContext(RevealControllerContext);
-  const together = options?.together || FALSE_ACCESSOR,
+  const order = options?.order || SEQUENTIAL_ACCESSOR,
     collapsed = options?.collapsed || FALSE_ACCESSOR;
-  const controller = new RevealController(together, collapsed);
+  const controller = new RevealController(order, collapsed);
   setContext(RevealControllerContext, controller, owner);
   return runWithOwner(owner, () => {
     const value = fn();
     computed(() => {
-      together();
+      order();
       collapsed();
       controller.evaluate();
     });