solid-js 2.0.0-beta.7 → 2.0.0-beta.8

package/dist/dev.cjs

@@ -294,9 +294,12 @@ function hydrateSignalFromAsyncIterable(coreFn, compute, options) {
       return it;
     }
   };
-  return coreFn(() => iterable, options);
+  return coreFn(prev => {
+    subFetch(compute, prev);
+    return iterable;
+  }, options);
 }
-function hydrateStoreFromAsyncIterable(coreFn, initialValue, options) {
+function hydrateStoreFromAsyncIterable(coreFn, fn, initialValue, options) {
   const parent = signals.getOwner();
   const expectedId = signals.peekNextChildId(parent);
   if (!sharedConfig.has(expectedId)) return null;
@@ -306,6 +309,10 @@ function hydrateStoreFromAsyncIterable(coreFn, initialValue, options) {
   let isFirst = true;
   let buffered = null;
   return coreFn(draft => {
+    const {
+      proxy
+    } = createShadowDraft(draft);
+    subFetch(fn, proxy);
     const process = res => {
       if (res.done) return {
         done: true,
@@ -313,11 +320,16 @@ function hydrateStoreFromAsyncIterable(coreFn, initialValue, options) {
       };
       if (isFirst) {
         isFirst = false;
-        if (Array.isArray(res.value)) {
-          for (let i = 0; i < res.value.length; i++) draft[i] = res.value[i];
-          draft.length = res.value.length;
-        } else {
-          Object.assign(draft, res.value);
+        signals.setSnapshotCapture(false);
+        try {
+          if (Array.isArray(res.value)) {
+            for (let i = 0; i < res.value.length; i++) draft[i] = res.value[i];
+            draft.length = res.value.length;
+          } else {
+            Object.assign(draft, res.value);
+          }
+        } finally {
+          signals.setSnapshotCapture(true);
         }
       } else {
         applyPatches(draft, res.value);
@@ -386,13 +398,6 @@ function hydratedCreateMemo(compute, options) {
     setHydrated(true);
     return memo;
   }
-  if (ssrSource === "initial") {
-    return signals.createMemo(prev => {
-      if (!sharedConfig.hydrating) return compute(prev);
-      subFetch(compute, prev);
-      return prev;
-    }, options);
-  }
   const aiResult = hydrateSignalFromAsyncIterable(signals.createMemo, compute, options);
   if (aiResult !== null) return aiResult;
   return signals.createMemo(prev => readSerializedOrCompute(compute, prev), options);
@@ -412,13 +417,6 @@ function hydratedCreateSignal(fn, second) {
     setHydrated(true);
     return sig;
   }
-  if (ssrSource === "initial") {
-    return signals.createSignal(prev => {
-      if (!sharedConfig.hydrating) return fn(prev);
-      subFetch(fn, prev);
-      return prev;
-    }, second);
-  }
   const aiResult = hydrateSignalFromAsyncIterable(signals.createSignal, fn, second);
   if (aiResult !== null) return aiResult;
   return signals.createSignal(prev => readSerializedOrCompute(fn, prev), second);
@@ -458,13 +456,6 @@ function hydratedCreateOptimistic(fn, second) {
     setHydrated(true);
     return sig;
   }
-  if (ssrSource === "initial") {
-    return signals.createOptimistic(prev => {
-      if (!sharedConfig.hydrating) return fn(prev);
-      subFetch(fn, prev);
-      return prev;
-    }, second);
-  }
   const aiResult = hydrateSignalFromAsyncIterable(signals.createOptimistic, fn, second);
   if (aiResult !== null) return aiResult;
   return signals.createOptimistic(prev => readSerializedOrCompute(fn, prev), second);
@@ -508,7 +499,7 @@ function hydrateStoreLikeFn(coreFn, fn, initialValue, options, ssrSource) {
     setHydrated(true);
     return result;
   }
-  const aiResult = hydrateStoreFromAsyncIterable(coreFn, initialValue, options);
+  const aiResult = hydrateStoreFromAsyncIterable(coreFn, fn, initialValue, options);
   if (aiResult !== null) return aiResult;
   return coreFn(wrapStoreFn(fn), initialValue, options);
 }
@@ -516,21 +507,18 @@ function hydratedCreateStore(first, second, third) {
   if (typeof first !== "function" || !sharedConfig.hydrating) return signals.createStore(first, second, third);
   markTopLevelSnapshotScope();
   const ssrSource = third?.ssrSource;
-  if (ssrSource === "initial") return signals.createStore(second ?? {});
   return hydrateStoreLikeFn(signals.createStore, first, second ?? {}, third, ssrSource);
 }
 function hydratedCreateOptimisticStore(first, second, third) {
   if (typeof first !== "function" || !sharedConfig.hydrating) return signals.createOptimisticStore(first, second, third);
   markTopLevelSnapshotScope();
   const ssrSource = third?.ssrSource;
-  if (ssrSource === "initial") return signals.createOptimisticStore(second ?? {});
   return hydrateStoreLikeFn(signals.createOptimisticStore, first, second ?? {}, third, ssrSource);
 }
 function hydratedCreateProjection(fn, initialValue, options) {
   if (!sharedConfig.hydrating) return signals.createProjection(fn, initialValue, options);
   markTopLevelSnapshotScope();
   const ssrSource = options?.ssrSource;
-  if (ssrSource === "initial") return signals.createProjection(draft => draft, initialValue, options);
   return hydrateStoreLikeFn(signals.createProjection, fn, initialValue, options, ssrSource);
 }
 function hydratedEffect(coreFn, compute, effectFn, options) {
@@ -552,14 +540,6 @@ function hydratedEffect(coreFn, compute, effectFn, options) {
     setHydrated(true);
     return;
   }
-  if (ssrSource === "initial") {
-    coreFn(prev => {
-      if (!sharedConfig.hydrating) return compute(prev);
-      subFetch(compute, prev);
-      return prev;
-    }, effectFn, options);
-    return;
-  }
   markTopLevelSnapshotScope();
   coreFn(prev => readSerializedOrCompute(compute, prev), effectFn, options);
 }
@@ -887,7 +867,7 @@ function Loading(props) {
 }
 function Reveal(props) {
   return signals.createRevealOrder(() => props.children, {
-    together: () => !!props.together,
+    order: () => props.order ?? "sequential",
     collapsed: () => !!props.collapsed
   });
 }

package/dist/dev.js

@@ -293,9 +293,12 @@ function hydrateSignalFromAsyncIterable(coreFn, compute, options) {
       return it;
     }
   };
-  return coreFn(() => iterable, options);
+  return coreFn(prev => {
+    subFetch(compute, prev);
+    return iterable;
+  }, options);
 }
-function hydrateStoreFromAsyncIterable(coreFn, initialValue, options) {
+function hydrateStoreFromAsyncIterable(coreFn, fn, initialValue, options) {
   const parent = getOwner();
   const expectedId = peekNextChildId(parent);
   if (!sharedConfig.has(expectedId)) return null;
@@ -305,6 +308,10 @@ function hydrateStoreFromAsyncIterable(coreFn, initialValue, options) {
   let isFirst = true;
   let buffered = null;
   return coreFn(draft => {
+    const {
+      proxy
+    } = createShadowDraft(draft);
+    subFetch(fn, proxy);
     const process = res => {
       if (res.done) return {
         done: true,
@@ -312,11 +319,16 @@ function hydrateStoreFromAsyncIterable(coreFn, initialValue, options) {
       };
       if (isFirst) {
         isFirst = false;
-        if (Array.isArray(res.value)) {
-          for (let i = 0; i < res.value.length; i++) draft[i] = res.value[i];
-          draft.length = res.value.length;
-        } else {
-          Object.assign(draft, res.value);
+        setSnapshotCapture(false);
+        try {
+          if (Array.isArray(res.value)) {
+            for (let i = 0; i < res.value.length; i++) draft[i] = res.value[i];
+            draft.length = res.value.length;
+          } else {
+            Object.assign(draft, res.value);
+          }
+        } finally {
+          setSnapshotCapture(true);
         }
       } else {
         applyPatches(draft, res.value);
@@ -385,13 +397,6 @@ function hydratedCreateMemo(compute, options) {
     setHydrated(true);
     return memo;
   }
-  if (ssrSource === "initial") {
-    return createMemo$1(prev => {
-      if (!sharedConfig.hydrating) return compute(prev);
-      subFetch(compute, prev);
-      return prev;
-    }, options);
-  }
   const aiResult = hydrateSignalFromAsyncIterable(createMemo$1, compute, options);
   if (aiResult !== null) return aiResult;
   return createMemo$1(prev => readSerializedOrCompute(compute, prev), options);
@@ -411,13 +416,6 @@ function hydratedCreateSignal(fn, second) {
     setHydrated(true);
     return sig;
   }
-  if (ssrSource === "initial") {
-    return createSignal$1(prev => {
-      if (!sharedConfig.hydrating) return fn(prev);
-      subFetch(fn, prev);
-      return prev;
-    }, second);
-  }
   const aiResult = hydrateSignalFromAsyncIterable(createSignal$1, fn, second);
   if (aiResult !== null) return aiResult;
   return createSignal$1(prev => readSerializedOrCompute(fn, prev), second);
@@ -457,13 +455,6 @@ function hydratedCreateOptimistic(fn, second) {
     setHydrated(true);
     return sig;
   }
-  if (ssrSource === "initial") {
-    return createOptimistic$1(prev => {
-      if (!sharedConfig.hydrating) return fn(prev);
-      subFetch(fn, prev);
-      return prev;
-    }, second);
-  }
   const aiResult = hydrateSignalFromAsyncIterable(createOptimistic$1, fn, second);
   if (aiResult !== null) return aiResult;
   return createOptimistic$1(prev => readSerializedOrCompute(fn, prev), second);
@@ -507,7 +498,7 @@ function hydrateStoreLikeFn(coreFn, fn, initialValue, options, ssrSource) {
     setHydrated(true);
     return result;
   }
-  const aiResult = hydrateStoreFromAsyncIterable(coreFn, initialValue, options);
+  const aiResult = hydrateStoreFromAsyncIterable(coreFn, fn, initialValue, options);
   if (aiResult !== null) return aiResult;
   return coreFn(wrapStoreFn(fn), initialValue, options);
 }
@@ -515,21 +506,18 @@ function hydratedCreateStore(first, second, third) {
   if (typeof first !== "function" || !sharedConfig.hydrating) return createStore$1(first, second, third);
   markTopLevelSnapshotScope();
   const ssrSource = third?.ssrSource;
-  if (ssrSource === "initial") return createStore$1(second ?? {});
   return hydrateStoreLikeFn(createStore$1, first, second ?? {}, third, ssrSource);
 }
 function hydratedCreateOptimisticStore(first, second, third) {
   if (typeof first !== "function" || !sharedConfig.hydrating) return createOptimisticStore$1(first, second, third);
   markTopLevelSnapshotScope();
   const ssrSource = third?.ssrSource;
-  if (ssrSource === "initial") return createOptimisticStore$1(second ?? {});
   return hydrateStoreLikeFn(createOptimisticStore$1, first, second ?? {}, third, ssrSource);
 }
 function hydratedCreateProjection(fn, initialValue, options) {
   if (!sharedConfig.hydrating) return createProjection$1(fn, initialValue, options);
   markTopLevelSnapshotScope();
   const ssrSource = options?.ssrSource;
-  if (ssrSource === "initial") return createProjection$1(draft => draft, initialValue, options);
   return hydrateStoreLikeFn(createProjection$1, fn, initialValue, options, ssrSource);
 }
 function hydratedEffect(coreFn, compute, effectFn, options) {
@@ -551,14 +539,6 @@ function hydratedEffect(coreFn, compute, effectFn, options) {
     setHydrated(true);
     return;
   }
-  if (ssrSource === "initial") {
-    coreFn(prev => {
-      if (!sharedConfig.hydrating) return compute(prev);
-      subFetch(compute, prev);
-      return prev;
-    }, effectFn, options);
-    return;
-  }
   markTopLevelSnapshotScope();
   coreFn(prev => readSerializedOrCompute(compute, prev), effectFn, options);
 }
@@ -886,7 +866,7 @@ function Loading(props) {
 }
 function Reveal(props) {
   return createRevealOrder(() => props.children, {
-    together: () => !!props.together,
+    order: () => props.order ?? "sequential",
     collapsed: () => !!props.collapsed
   });
 }

package/dist/server.cjs

@@ -129,7 +129,7 @@ function createMemo(compute, options) {
     }
   }
   const ssrSource = options?.ssrSource;
-  if (ssrSource === "initial" || ssrSource === "client") {
+  if (ssrSource === "client") {
     comp.computed = true;
   } else if (!options?.lazy) {
     update();
@@ -325,7 +325,7 @@ function closeAsyncIterator(iter, value) {
 }
 function serverEffect(compute, effectFn, options) {
   const ssrSource = options?.ssrSource;
-  if (ssrSource === "client" || ssrSource === "initial") {
+  if (ssrSource === "client") {
     signals.createOwner();
     return;
   }
@@ -406,7 +406,7 @@ function createProjection(fn, initialValue, options) {
   const ctx = sharedConfig.context;
   const owner = signals.createOwner();
   const [state] = createStore(initialValue);
-  if (options?.ssrSource === "initial" || options?.ssrSource === "client") {
+  if (options?.ssrSource === "client") {
     return state;
   }
   let disposed = false;
@@ -826,12 +826,6 @@ function ssrHandleError(err) {
   }
   throw err;
 }
-class InvalidTopLevelAsyncReadError extends Error {
-  constructor() {
-    super("Async values must be read within a tracking scope (JSX, a memo, or an effect's compute function).");
-    this.name = "InvalidTopLevelAsyncReadError";
-  }
-}
 function createLoadingBoundary(fn, fallback, options) {
   const currentCtx = sharedConfig.context;
   if (!currentCtx) {
@@ -846,6 +840,7 @@ function createLoadingBoundary(fn, fallback, options) {
   o.id = id + "00";
   let done;
   let handledRenderError;
+  let retryPromise;
   let serializeBuffer = [];
   const bufferedCtx = Object.create(ctx);
   bufferedCtx.serialize = (id, value, deferStream) => {
@@ -889,21 +884,26 @@ function createLoadingBoundary(fn, fallback, options) {
   function runDiscovery() {
     o.dispose(false);
     serializeBuffer = [];
+    retryPromise = undefined;
     return runLoadingPhase(() => {
       try {
         return ctx.resolve(fn());
       } catch (err) {
-        if (err instanceof signals.NotReadyError) throw new InvalidTopLevelAsyncReadError();
+        if (err instanceof signals.NotReadyError) {
+          retryPromise = err.source;
+          return undefined;
+        }
         throw err;
       }
     });
   }
   let ret = runDiscovery();
-  if (!ret?.p?.length) {
+  if (!retryPromise && !ret?.p?.length) {
     commitBoundaryState();
     return () => ret;
   }
-  const collapseFallback = revealGroup ? revealGroup.register(id) : false;
+  const regResult = revealGroup ? revealGroup.register(id) : null;
+  const collapseFallback = regResult?.collapseFallback ?? false;
   if (collapseFallback && !ctx.async) {
     commitBoundaryState();
     ctx.serialize(id, "$$f");
@@ -924,6 +924,10 @@ function createLoadingBoundary(fn, fallback, options) {
     done = ctx.registerFragment(id, regOpts);
     (async () => {
       try {
+        while (retryPromise) {
+          await retryPromise.catch(() => {});
+          ret = runDiscovery();
+        }
         commitBoundaryState();
         while (ret.p.length) {
           await Promise.all(ret.p).catch(() => {});
@@ -1026,15 +1030,16 @@ function Loading(props) {
 function Reveal(props) {
   const o = signals.createOwner();
   const id = o.id;
-  const together = !!props.together;
-  const collapsed = !!props.collapsed;
+  const order = props.order ?? "sequential";
+  const collapsed = order === "sequential" && !!props.collapsed;
   if (!sharedConfig.context?.async) {
     const parent = signals.getOwner();
     const parentGroup = parent ? signals.runWithOwner(parent, () => signals.getContext(RevealGroupContext)) : null;
     let collapsedByParent = false;
     if (parentGroup) {
-      collapsedByParent = parentGroup.register(id);
-      if (collapsed || together) console.warn("Nested <Reveal> with collapsed/together won't coordinate correctly with renderToString. Use renderToStream for full support.");
+      const reg = parentGroup.register(id);
+      collapsedByParent = reg.collapseFallback;
+      if (order === "together" || collapsed) console.warn("Nested <Reveal> with collapsed/together won't coordinate correctly with renderToString. Use renderToStream for full support.");
     }
     let count = 0;
     return signals.runWithOwner(o, () => {
@@ -1042,8 +1047,11 @@ function Reveal(props) {
         id,
         register(_key) {
           count++;
-          if (collapsedByParent) return true;
-          return !together && collapsed && count > 1;
+          const collapseFallback = collapsedByParent || order === "sequential" && collapsed && count > 1;
+          return {
+            collapseFallback,
+            held: false
+          };
         },
         onResolved() {}
       });
@@ -1053,58 +1061,129 @@ function Reveal(props) {
   const ctx = sharedConfig.context;
   const keys = [];
   const resolved = new Set();
+  const minimallyResolved = new Set();
   const composites = new Map();
+  const activated = new Set();
+  const stash = [];
+  const collapsedLeafKeys = [];
   let frontier = 0;
+  let heldByParent = false;
+  let collapsedByParent = false;
+  let selfMinimallyResolved = false;
+  let notifiedParentDone = false;
   const parent = signals.getOwner();
   const parentGroup = parent ? signals.runWithOwner(parent, () => signals.getContext(RevealGroupContext)) : null;
-  let collapsedByParent = false;
   if (parentGroup) {
-    collapsedByParent = parentGroup.register(id, {
+    const reg = parentGroup.register(id, {
       onActivate: () => {
-        collapsedByParent = false;
-        advanceFrontier();
+        if (!heldByParent) return;
+        heldByParent = false;
+        if (collapsedByParent) {
+          collapsedByParent = false;
+          if (collapsedLeafKeys.length) {
+            ctx.revealFallbacks?.([...collapsedLeafKeys]);
+            collapsedLeafKeys.length = 0;
+          }
+        }
+        if (order === "sequential") advanceFrontier();else if (order === "together") checkTogetherRelease();else naturalRelease();
       }
     });
+    collapsedByParent = reg.collapseFallback;
+    heldByParent = reg.held;
   }
   function notifyParentIfDone() {
+    if (notifiedParentDone) return;
     if (parentGroup && resolved.size === keys.length) {
+      notifiedParentDone = true;
       parentGroup.onResolved(id);
     }
   }
+  function activateComposite(key) {
+    if (activated.has(key)) return;
+    activated.add(key);
+    composites.get(key)();
+  }
+  function updateSelfMinimallyResolved() {
+    if (selfMinimallyResolved) return;
+    if (keys.length === 0) selfMinimallyResolved = true;else if (order === "together") selfMinimallyResolved = minimallyResolved.size === keys.length;else if (order === "sequential") selfMinimallyResolved = minimallyResolved.has(keys[0]);
+    else selfMinimallyResolved = resolved.size > 0;
+    if (selfMinimallyResolved) parentGroup?.onMinimallyResolved?.(id);
+  }
   function advanceFrontier() {
+    if (heldByParent) return;
     while (frontier < keys.length && resolved.has(keys[frontier])) {
-      if (!composites.has(keys[frontier])) ctx.revealFragments?.([keys[frontier]]);
+      const k = keys[frontier];
+      if (composites.has(k)) activateComposite(k);else ctx.revealFragments?.([k]);
       frontier++;
     }
     if (frontier < keys.length) {
-      const activate = composites.get(keys[frontier]);
-      if (activate) activate();else if (!together && collapsed) ctx.revealFallbacks?.(keys.slice(frontier));
+      const k = keys[frontier];
+      if (composites.has(k)) activateComposite(k);else if (order === "sequential" && collapsed) ctx.revealFallbacks?.([k]);
     }
     notifyParentIfDone();
   }
+  function checkTogetherRelease() {
+    if (order !== "together" || heldByParent) return;
+    if (minimallyResolved.size < keys.length) return;
+    if (stash.length) {
+      ctx.revealFragments?.([...stash]);
+      stash.length = 0;
+    }
+    composites.forEach((_, key) => activateComposite(key));
+    notifyParentIfDone();
+  }
+  function naturalRelease() {
+    if (stash.length) {
+      ctx.revealFragments?.([...stash]);
+      stash.length = 0;
+    }
+    composites.forEach((_, key) => activateComposite(key));
+    notifyParentIfDone();
+  }
   return signals.runWithOwner(o, () => {
     signals.setContext(RevealGroupContext, {
       id,
       register(key, options) {
         keys.push(key);
-        if (options?.onActivate) composites.set(key, options.onActivate);
-        if (collapsedByParent) return true;
-        return !together && collapsed && keys.length > 1;
+        const isComposite = !!options?.onActivate;
+        if (isComposite) composites.set(key, options.onActivate);
+        const selfCollapse = order === "sequential" && collapsed && keys.length > 1;
+        const collapseFallback = collapsedByParent || selfCollapse;
+        if (collapseFallback && !isComposite) collapsedLeafKeys.push(key);
+        let held = heldByParent;
+        if (!held) {
+          if (order === "together") held = true;else if (order === "sequential" && keys.length > 1) held = true;
+        }
+        return {
+          collapseFallback,
+          held
+        };
       },
       onResolved(key) {
         resolved.add(key);
-        if (collapsedByParent) {
-          notifyParentIfDone();
-          return;
-        }
-        if (together) {
-          if (resolved.size === keys.length) {
-            ctx.revealFragments?.(id);
-            notifyParentIfDone();
+        const isLeaf = !composites.has(key);
+        if (isLeaf) {
+          if (order === "together") {
+            stash.push(key);
+          } else if (order === "natural" && heldByParent) {
+            stash.push(key);
+          } else if (order === "natural") {
+            ctx.revealFragments?.([key]);
           }
+          markMinimallyResolved(key);
+          if (order === "sequential" && !heldByParent) advanceFrontier();
+          if (order === "natural") updateSelfMinimallyResolved();
         } else {
-          advanceFrontier();
+          if (!heldByParent) {
+            if (order === "sequential") advanceFrontier();else if (order === "natural") activateComposite(key);
+          }
+          if (order === "together") checkTogetherRelease();
+          if (order === "natural") updateSelfMinimallyResolved();
         }
+        notifyParentIfDone();
+      },
+      onMinimallyResolved(key) {
+        markMinimallyResolved(key);
       }
     });
     const result = props.children;
@@ -1113,6 +1192,12 @@ function Reveal(props) {
     }
     return result;
   });
+  function markMinimallyResolved(key) {
+    if (minimallyResolved.has(key)) return;
+    minimallyResolved.add(key);
+    updateSelfMinimallyResolved();
+    if (order === "together") checkTogetherRelease();
+  }
 }
 
 const DEV = undefined;