solid-js 2.0.0-beta.4 → 2.0.0-beta.6

package/dist/server.cjs

@@ -64,7 +64,7 @@ function createMemo(compute, value, options) {
       processResult(comp, result, owner, ctx, options?.deferStream, options?.ssrSource);
     } catch (err) {
       if (err instanceof signals.NotReadyError) {
-        err.source?.then(() => update());
+        err.source?.then(() => update(), () => update());
       }
       comp.error = err;
       comp.computed = true;
@@ -149,20 +149,31 @@ function createDeepProxy(target, patches, basePath = []) {
 function processResult(comp, result, owner, ctx, deferStream, ssrSource) {
   if (comp.disposed) return;
   const id = owner.id;
-  const uninitialized = comp.value === undefined;
   const noHydrate = signals.getContext(NoHydrateContext, owner);
   if (result instanceof Promise) {
+    if (result.s === 1) {
+      comp.value = result.v;
+      comp.error = undefined;
+      return;
+    }
+    if (result.s === 2) {
+      comp.error = result.v;
+      return;
+    }
     result.then(v => {
       result.s = 1;
       result.v = v;
       if (comp.disposed) return;
       comp.value = v;
       comp.error = undefined;
-    }, () => {});
+    }, err => {
+      result.s = 2;
+      result.v = err;
+      if (comp.disposed) return;
+      comp.error = err;
+    });
     if (ctx?.async && ctx.serialize && id && !noHydrate) ctx.serialize(id, result, deferStream);
-    if (uninitialized) {
-      comp.error = new signals.NotReadyError(result);
-    }
+    comp.error = new signals.NotReadyError(result);
     return;
   }
   const iterator = result?.[Symbol.asyncIterator];
@@ -172,6 +183,7 @@ function processResult(comp, result, owner, ctx, deferStream, ssrSource) {
       const promise = iter.next().then(v => {
         promise.s = 1;
         promise.v = v.value;
+        if (!v.done) closeAsyncIterator(iter);
         if (comp.disposed) return v.value;
         comp.value = v.value;
         comp.error = undefined;
@@ -199,6 +211,9 @@ function processResult(comp, result, owner, ctx, deferStream, ssrSource) {
                 return firstNext.then(r => r);
               }
               return iter.next().then(r => r);
+            },
+            return(value) {
+              return iter.return?.(value);
             }
           })
         };
@@ -210,6 +225,12 @@ function processResult(comp, result, owner, ctx, deferStream, ssrSource) {
   }
   comp.value = result;
 }
+function closeAsyncIterator(iter, value) {
+  const returned = iter.return?.(value);
+  if (returned && typeof returned.then === "function") {
+    returned.then(undefined, () => {});
+  }
+}
 function serverEffect(compute, effectFn, value, options) {
   const ssrSource = options?.ssrSource;
   if (ssrSource === "client" || ssrSource === "initial") {
@@ -311,6 +332,7 @@ function createProjection(fn, initialValue = {}, options) {
     if (ssrSource === "hybrid") {
       const promise = iter.next().then(r => {
         promise.s = 1;
+        if (!r.done) closeAsyncIterator(iter);
         if (disposed) {
           promise.v = state;
           return state;
@@ -378,6 +400,9 @@ function createProjection(fn, initialValue = {}, options) {
                   value: undefined
                 };
               });
+            },
+            return(value) {
+              return iter.return?.(value);
             }
           })
         };
@@ -392,13 +417,14 @@ function createProjection(fn, initialValue = {}, options) {
       promise.s = 1;
       if (disposed) {
         promise.v = state;
-        return;
+        return state;
       }
       if (v !== undefined && v !== state) {
         Object.assign(state, v);
       }
       promise.v = state;
       markReady();
+      return state;
     }, () => {});
     if (ctx?.async && !signals.getContext(NoHydrateContext) && owner.id) ctx.serialize(owner.id, promise, options?.deferStream);
     const [pending, markReady] = createPendingProxy(state, promise);
@@ -429,7 +455,7 @@ function deep(store) {
 }
 function mapArray(list, mapFn, options = {}) {
   const parent = signals.createOwner();
-  return () => {
+  return createMemo(() => {
     const items = list();
     let s = [];
     if (items && items.length) {
@@ -446,54 +472,93 @@ function mapArray(list, mapFn, options = {}) {
       })];
     }
     return s;
-  };
+  });
 }
 function repeat(count, mapFn, options = {}) {
   const owner = signals.createOwner();
-  const len = count();
-  const offset = options.from?.() || 0;
-  let s = [];
-  if (len) {
-    signals.runWithOwner(owner, () => {
-      for (let i = 0; i < len; i++) {
-        const itemOwner = signals.createOwner();
-        s.push(signals.runWithOwner(itemOwner, () => mapFn(i + offset)));
-      }
-    });
-  } else if (options.fallback) {
-    s = [signals.runWithOwner(owner, () => {
-      const fo = signals.createOwner();
-      return signals.runWithOwner(fo, () => options.fallback());
-    })];
-  }
-  return () => s;
+  return createMemo(() => {
+    const len = count();
+    const offset = options.from?.() || 0;
+    if (!len) {
+      if (!options.fallback) return [];
+      return [signals.runWithOwner(owner, () => {
+        const fallbackOwner = signals.createOwner();
+        return signals.runWithOwner(fallbackOwner, () => options.fallback());
+      })];
+    }
+    return signals.runWithOwner(owner, () => Array.from({
+      length: len
+    }, (_, i) => {
+      const itemOwner = signals.createOwner();
+      return signals.runWithOwner(itemOwner, () => mapFn(i + offset));
+    }));
+  });
 }
 const ErrorContext = {
   id: Symbol("ErrorContext"),
   defaultValue: null
 };
+function runWithBoundaryErrorContext(owner, render, onError, context, boundaryId) {
+  const prevCtx = sharedConfig.context;
+  const prevBoundary = context?._currentBoundaryId;
+  if (context) {
+    sharedConfig.context = context;
+    if (boundaryId !== undefined) context._currentBoundaryId = boundaryId;
+  }
+  try {
+    return signals.runWithOwner(owner, () => {
+      const parentHandler = signals.getContext(ErrorContext);
+      signals.setContext(ErrorContext, err => onError(err, parentHandler));
+      return render();
+    });
+  } finally {
+    if (context) {
+      if (boundaryId !== undefined) context._currentBoundaryId = prevBoundary;
+      sharedConfig.context = prevCtx;
+    }
+  }
+}
 function createErrorBoundary(fn, fallback) {
   const ctx = sharedConfig.context;
-  const owner = signals.createOwner();
   const parent = signals.getOwner();
-  if (parent?.id != null) signals.getNextChildId(parent);
-  owner.id = owner.id + "0";
-  return signals.runWithOwner(owner, () => {
+  const owner = signals.createOwner();
+  const resolve = () => {
+    const resolved = ctx.resolve(signals.runWithOwner(signals.createOwner(), fn));
+    if (resolved?.p?.length) throw new signals.NotReadyError(Promise.all(resolved.p));
+    return resolved;
+  };
+  const renderFallback = err => ctx ? signals.runWithOwner(parent, () => {
+    const fallbackOwner = signals.createOwner();
+    return signals.runWithOwner(fallbackOwner, () => fallback(err, () => {}));
+  }) : fallback(err, () => {});
+  const serializeError = err => {
+    if (ctx && owner.id && !signals.runWithOwner(owner, () => signals.getContext(NoHydrateContext))) {
+      ctx.serialize(owner.id, err);
+    }
+  };
+  const handleError = err => {
+    serializeError(err);
+    return renderFallback(err);
+  };
+  return () => {
     let result;
-    signals.setContext(ErrorContext, err => {
-      if (ctx && !signals.getContext(NoHydrateContext) && owner.id) ctx.serialize(owner.id, err);
-      result = fallback(err, () => {});
-    });
+    let handled = false;
+    if (ctx) owner.dispose(false);
     try {
-      result = fn();
+      result = ctx ? runWithBoundaryErrorContext(owner, resolve, err => {
+        if (err instanceof signals.NotReadyError) throw err;
+        handled = true;
+        result = handleError(err);
+        throw err;
+      }) : signals.runWithOwner(owner, fn);
     } catch (err) {
-      if (ctx && !signals.getContext(NoHydrateContext) && owner.id) ctx.serialize(owner.id, err);
-      result = fallback(err, () => {});
+      if (err instanceof signals.NotReadyError) throw err;
+      result = handled ? result : handleError(err);
     }
-    return () => result;
-  });
+    return result;
+  };
 }
-function createLoadingBoundary(fn, fallback, options) {
+function createLoadingBoundary$1(fn, fallback, options) {
   try {
     const result = fn();
     return () => result;
@@ -504,6 +569,10 @@ function createLoadingBoundary(fn, fallback, options) {
     throw err;
   }
 }
+function createRevealOrder(fn, _options) {
+  const o = signals.createOwner();
+  return signals.runWithOwner(o, fn);
+}
 function untrack(fn) {
   return fn();
 }
@@ -569,7 +638,9 @@ function children(fn) {
   return memo;
 }
 function ssrRunInScope(fn) {
-  return fn;
+  const owner = signals.getOwner();
+  if (!owner) return fn;
+  return Array.isArray(fn) ? fn.map(hole => () => signals.runWithOwner(owner, hole)) : () => signals.runWithOwner(owner, fn);
 }
 
 function enableHydration() {}
@@ -626,6 +697,155 @@ function createUniqueId() {
   return signals.getNextChildId(o);
 }
 
+const RevealGroupContext = {
+  id: Symbol("RevealGroupContext"),
+  defaultValue: null
+};
+function ssrHandleError(err) {
+  if (err instanceof signals.NotReadyError) {
+    return err.source;
+  }
+  const handler = signals.getContext(ErrorContext);
+  if (handler) {
+    handler(err);
+    return;
+  }
+  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) {
+    return createLoadingBoundary$1(fn, fallback);
+  }
+  const ctx = currentCtx;
+  const parent = signals.getOwner();
+  const parentHandler = parent && signals.runWithOwner(parent, () => signals.getContext(ErrorContext));
+  const revealGroup = parent && signals.runWithOwner(parent, () => signals.getContext(RevealGroupContext));
+  const o = signals.createOwner();
+  const id = o.id;
+  o.id = id + "00";
+  let done;
+  let handledRenderError;
+  let serializeBuffer = [];
+  const bufferedCtx = Object.create(ctx);
+  bufferedCtx.serialize = (id, value, deferStream) => {
+    serializeBuffer.push([id, value, deferStream]);
+  };
+  bufferedCtx._currentBoundaryId = id;
+  function flushSerializeBuffer() {
+    for (const args of serializeBuffer) ctx.serialize(args[0], args[1], args[2]);
+    serializeBuffer = [];
+  }
+  function commitBoundaryState() {
+    flushSerializeBuffer();
+    const modules = ctx.getBoundaryModules?.(id);
+    if (modules) ctx.serialize(id + "_assets", modules);
+  }
+  function runLoadingPhase(render) {
+    handledRenderError = undefined;
+    return runWithBoundaryErrorContext(o, render, (err, parentHandler) => {
+      handledRenderError = err;
+      if (done?.(undefined, err)) throw err;
+      if (parentHandler) {
+        parentHandler(err);
+        return;
+      }
+      throw err;
+    }, bufferedCtx, id);
+  }
+  function finalizeError(err) {
+    if (handledRenderError === err) {
+      handledRenderError = undefined;
+      return;
+    }
+    if (done?.(undefined, err)) return;
+    if (!parentHandler) throw err;
+    try {
+      signals.runWithOwner(parent, () => parentHandler(err));
+    } catch (caught) {
+      if (caught !== err) throw caught;
+    }
+  }
+  function runDiscovery() {
+    o.dispose(false);
+    serializeBuffer = [];
+    return runLoadingPhase(() => {
+      try {
+        return ctx.resolve(fn());
+      } catch (err) {
+        if (err instanceof signals.NotReadyError) throw new InvalidTopLevelAsyncReadError();
+        throw err;
+      }
+    });
+  }
+  let ret = runDiscovery();
+  if (!ret?.p?.length) {
+    commitBoundaryState();
+    return () => ret;
+  }
+  const collapseFallback = revealGroup ? revealGroup.register(id) : false;
+  if (collapseFallback && !ctx.async) {
+    commitBoundaryState();
+    ctx.serialize(id, "$$f");
+    return () => undefined;
+  }
+  const fallbackOwner = signals.createOwner({
+    id
+  });
+  const fallbackResult = signals.runWithOwner(fallbackOwner, () => {
+    if (!ctx.async) return fallback();
+    const tpl = collapseFallback ? [`<template id="pl-${id}">`, `</template><!--pl-${id}-->`] : [`<template id="pl-${id}"></template>`, `<!--pl-${id}-->`];
+    return ctx.ssr(tpl, ctx.escape(fallback()));
+  });
+  if (ctx.async) {
+    const regOpts = revealGroup ? {
+      revealGroup: revealGroup.id
+    } : undefined;
+    done = ctx.registerFragment(id, regOpts);
+    (async () => {
+      try {
+        commitBoundaryState();
+        while (ret.p.length) {
+          await Promise.all(ret.p).catch(() => {});
+          ret = runLoadingPhase(() => ctx.ssr(ret.t, ...ret.h));
+        }
+        flushSerializeBuffer();
+        done(ret.t[0]);
+        if (revealGroup) revealGroup.onResolved(id);
+      } catch (err) {
+        finalizeError(err);
+      }
+    })();
+    return () => fallbackResult;
+  }
+  commitBoundaryState();
+  ctx.serialize(id, "$$f");
+  return () => fallbackResult;
+}
+function NoHydration(props) {
+  const o = signals.createOwner();
+  return signals.runWithOwner(o, () => {
+    signals.setContext(NoHydrateContext, true);
+    return props.children;
+  });
+}
+function Hydration(props) {
+  if (!signals.getContext(NoHydrateContext)) return props.children;
+  const o = signals.createOwner({
+    id: props.id ?? ""
+  });
+  return signals.runWithOwner(o, () => {
+    signals.setContext(NoHydrateContext, false);
+    return props.children;
+  });
+}
+
 function For(props) {
   const options = "fallback" in props ? {
     keyed: props.keyed,
@@ -633,7 +853,7 @@ function For(props) {
   } : {
     keyed: props.keyed
   };
-  return createMemo(mapArray(() => props.each, props.children, options));
+  return mapArray(() => props.each, props.children, options);
 }
 function Repeat(props) {
   const options = "fallback" in props ? {
@@ -686,105 +906,98 @@ function Errored(props) {
     return typeof f === "function" && f.length ? f(err, reset) : f;
   });
 }
-
-function ssrHandleError(err) {
-  if (err instanceof signals.NotReadyError) {
-    return err.source;
-  }
-  const handler = signals.getContext(ErrorContext);
-  if (handler) {
-    handler(err);
-    return;
-  }
-  throw err;
-}
 function Loading(props) {
-  const ctx = sharedConfig.context;
-  if (!ctx) {
-    return createLoadingBoundary(() => props.children, () => props.fallback);
-  }
+  return createLoadingBoundary(() => props.children, () => props.fallback);
+}
+function Reveal(props) {
   const o = signals.createOwner();
   const id = o.id;
-  o.id = id + "00";
-  let runPromise;
-  let serializeBuffer = [];
-  const origSerialize = ctx.serialize;
-  function runInitially() {
-    o.dispose(false);
-    serializeBuffer = [];
-    ctx.serialize = (id, p, deferStream) => {
-      serializeBuffer.push([id, p, deferStream]);
-    };
-    const prevBoundary = ctx._currentBoundaryId;
-    ctx._currentBoundaryId = id;
-    const result = signals.runWithOwner(o, () => {
-      try {
-        return ctx.resolve(props.children);
-      } catch (err) {
-        runPromise = ssrHandleError(err);
+  const together = !!props.together;
+  const collapsed = !!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.");
+    }
+    let count = 0;
+    return signals.runWithOwner(o, () => {
+      signals.setContext(RevealGroupContext, {
+        id,
+        register(_key) {
+          count++;
+          if (collapsedByParent) return true;
+          return !together && collapsed && count > 1;
+        },
+        onResolved() {}
+      });
+      return props.children;
+    });
+  }
+  const ctx = sharedConfig.context;
+  const keys = [];
+  const resolved = new Set();
+  const composites = new Map();
+  let frontier = 0;
+  const parent = signals.getOwner();
+  const parentGroup = parent ? signals.runWithOwner(parent, () => signals.getContext(RevealGroupContext)) : null;
+  let collapsedByParent = false;
+  if (parentGroup) {
+    collapsedByParent = parentGroup.register(id, {
+      onActivate: () => {
+        collapsedByParent = false;
+        advanceFrontier();
       }
     });
-    ctx._currentBoundaryId = prevBoundary;
-    ctx.serialize = origSerialize;
-    return result;
   }
-  let ret = runInitially();
-  if (!(runPromise || ret?.p?.length)) {
-    for (const args of serializeBuffer) origSerialize(args[0], args[1], args[2]);
-    serializeBuffer = [];
-    const modules = ctx.getBoundaryModules?.(id);
-    if (modules) ctx.serialize(id + "_assets", modules);
-    return ret;
+  function notifyParentIfDone() {
+    if (parentGroup && resolved.size === keys.length) {
+      parentGroup.onResolved(id);
+    }
   }
-  const fallbackOwner = signals.createOwner({
-    id
-  });
-  signals.getNextChildId(fallbackOwner);
-  if (ctx.async) {
-    const done = ctx.registerFragment(id);
-    (async () => {
-      try {
-        while (runPromise) {
-          o.dispose(false);
-          await runPromise;
-          runPromise = undefined;
-          ret = runInitially();
+  function advanceFrontier() {
+    while (frontier < keys.length && resolved.has(keys[frontier])) {
+      if (!composites.has(keys[frontier])) ctx.revealFragments?.([keys[frontier]]);
+      frontier++;
+    }
+    if (frontier < keys.length) {
+      const activate = composites.get(keys[frontier]);
+      if (activate) activate();else if (!together && collapsed) ctx.revealFallbacks?.(keys.slice(frontier));
+    }
+    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;
+      },
+      onResolved(key) {
+        resolved.add(key);
+        if (collapsedByParent) {
+          notifyParentIfDone();
+          return;
         }
-        for (const args of serializeBuffer) origSerialize(args[0], args[1], args[2]);
-        serializeBuffer = [];
-        while (ret.p.length) {
-          await Promise.all(ret.p);
-          ret = signals.runWithOwner(o, () => ctx.ssr(ret.t, ...ret.h));
+        if (together) {
+          if (resolved.size === keys.length) {
+            ctx.revealFragments?.(id);
+            notifyParentIfDone();
+          }
+        } else {
+          advanceFrontier();
         }
-        done(ret.t[0]);
-      } catch (err) {
-        done(undefined, err);
       }
-    })();
-    return signals.runWithOwner(fallbackOwner, () => ctx.ssr([`<template id="pl-${id}"></template>`, `<!--pl-${id}-->`], ctx.escape(props.fallback)));
-  }
-  for (const args of serializeBuffer) origSerialize(args[0], args[1], args[2]);
-  serializeBuffer = [];
-  const modules = ctx.getBoundaryModules?.(id);
-  if (modules) ctx.serialize(id + "_assets", modules);
-  ctx.serialize(id, "$$f");
-  return signals.runWithOwner(fallbackOwner, () => props.fallback);
-}
-function NoHydration(props) {
-  const o = signals.createOwner();
-  return signals.runWithOwner(o, () => {
-    signals.setContext(NoHydrateContext, true);
-    return props.children;
-  });
-}
-function Hydration(props) {
-  if (!signals.getContext(NoHydrateContext)) return props.children;
-  const o = signals.createOwner({
-    id: props.id ?? ""
-  });
-  return signals.runWithOwner(o, () => {
-    signals.setContext(NoHydrateContext, false);
-    return props.children;
+    });
+    const result = props.children;
+    if (parentGroup && keys.length === 0) {
+      parentGroup.onResolved(id);
+    }
+    return result;
   });
 }
 
@@ -834,6 +1047,10 @@ Object.defineProperty(exports, "getOwner", {
   enumerable: true,
   get: function () { return signals.getOwner; }
 });
+Object.defineProperty(exports, "isDisposed", {
+  enumerable: true,
+  get: function () { return signals.isDisposed; }
+});
 Object.defineProperty(exports, "isEqual", {
   enumerable: true,
   get: function () { return signals.isEqual; }
@@ -876,6 +1093,7 @@ exports.Match = Match;
 exports.NoHydrateContext = NoHydrateContext;
 exports.NoHydration = NoHydration;
 exports.Repeat = Repeat;
+exports.Reveal = Reveal;
 exports.Show = Show;
 exports.Switch = Switch;
 exports.action = action;
@@ -892,6 +1110,7 @@ exports.createOptimisticStore = createOptimisticStore;
 exports.createProjection = createProjection;
 exports.createReaction = createReaction;
 exports.createRenderEffect = createRenderEffect;
+exports.createRevealOrder = createRevealOrder;
 exports.createSignal = createSignal;
 exports.createStore = createStore;
 exports.createTrackedEffect = createTrackedEffect;