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

package/dist/server.js

@@ -1,4 +1,4 @@
-import { getOwner, getContext, getNextChildId, createOwner, runWithOwner, setContext, NotReadyError, onCleanup, isWrappable, flatten, createRoot } from '@solidjs/signals';
+import { getOwner, getContext, getNextChildId, createOwner, NotReadyError, runWithOwner, onCleanup, isWrappable, setContext, flatten, createRoot } from '@solidjs/signals';
 export { $PROXY, $REFRESH, $TRACK, NotReadyError, createOwner, createRoot, enableExternalSource, enforceLoadingBoundary, flatten, getNextChildId, getOwner, isEqual, isWrappable, merge, omit, onCleanup, runWithOwner, snapshot, storePath } from '@solidjs/signals';
 
 const NoHydrateContext = {
@@ -63,7 +63,7 @@ function createMemo(compute, value, options) {
       processResult(comp, result, owner, ctx, options?.deferStream, options?.ssrSource);
     } catch (err) {
       if (err instanceof NotReadyError) {
-        err.source?.then(() => update());
+        err.source?.then(() => update(), () => update());
       }
       comp.error = err;
       comp.computed = true;
@@ -148,20 +148,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 = 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 NotReadyError(result);
-    }
+    comp.error = new NotReadyError(result);
     return;
   }
   const iterator = result?.[Symbol.asyncIterator];
@@ -171,6 +182,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;
@@ -198,6 +210,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);
             }
           })
         };
@@ -209,6 +224,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") {
@@ -310,6 +331,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;
@@ -377,6 +399,9 @@ function createProjection(fn, initialValue = {}, options) {
                   value: undefined
                 };
               });
+            },
+            return(value) {
+              return iter.return?.(value);
             }
           })
         };
@@ -428,7 +453,7 @@ function deep(store) {
 }
 function mapArray(list, mapFn, options = {}) {
   const parent = createOwner();
-  return () => {
+  return createMemo(() => {
     const items = list();
     let s = [];
     if (items && items.length) {
@@ -445,54 +470,93 @@ function mapArray(list, mapFn, options = {}) {
       })];
     }
     return s;
-  };
+  });
 }
 function repeat(count, mapFn, options = {}) {
   const owner = createOwner();
-  const len = count();
-  const offset = options.from?.() || 0;
-  let s = [];
-  if (len) {
-    runWithOwner(owner, () => {
-      for (let i = 0; i < len; i++) {
-        const itemOwner = createOwner();
-        s.push(runWithOwner(itemOwner, () => mapFn(i + offset)));
-      }
-    });
-  } else if (options.fallback) {
-    s = [runWithOwner(owner, () => {
-      const fo = createOwner();
-      return runWithOwner(fo, () => options.fallback());
-    })];
-  }
-  return () => s;
+  return createMemo(() => {
+    const len = count();
+    const offset = options.from?.() || 0;
+    if (!len) {
+      if (!options.fallback) return [];
+      return [runWithOwner(owner, () => {
+        const fallbackOwner = createOwner();
+        return runWithOwner(fallbackOwner, () => options.fallback());
+      })];
+    }
+    return runWithOwner(owner, () => Array.from({
+      length: len
+    }, (_, i) => {
+      const itemOwner = createOwner();
+      return 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 runWithOwner(owner, () => {
+      const parentHandler = getContext(ErrorContext);
+      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 = createOwner();
   const parent = getOwner();
-  if (parent?.id != null) getNextChildId(parent);
-  owner.id = owner.id + "0";
-  return runWithOwner(owner, () => {
+  const owner = createOwner();
+  const resolve = () => {
+    const resolved = ctx.resolve(runWithOwner(createOwner(), fn));
+    if (resolved?.p?.length) throw new NotReadyError(Promise.all(resolved.p));
+    return resolved;
+  };
+  const renderFallback = err => ctx ? runWithOwner(parent, () => {
+    const fallbackOwner = createOwner();
+    return runWithOwner(fallbackOwner, () => fallback(err, () => {}));
+  }) : fallback(err, () => {});
+  const serializeError = err => {
+    if (ctx && owner.id && !runWithOwner(owner, () => getContext(NoHydrateContext))) {
+      ctx.serialize(owner.id, err);
+    }
+  };
+  const handleError = err => {
+    serializeError(err);
+    return renderFallback(err);
+  };
+  return () => {
     let result;
-    setContext(ErrorContext, err => {
-      if (ctx && !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 NotReadyError) throw err;
+        handled = true;
+        result = handleError(err);
+        throw err;
+      }) : runWithOwner(owner, fn);
     } catch (err) {
-      if (ctx && !getContext(NoHydrateContext) && owner.id) ctx.serialize(owner.id, err);
-      result = fallback(err, () => {});
+      if (err instanceof 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;
@@ -568,7 +632,9 @@ function children(fn) {
   return memo;
 }
 function ssrRunInScope(fn) {
-  return fn;
+  const owner = getOwner();
+  if (!owner) return fn;
+  return Array.isArray(fn) ? fn.map(hole => () => runWithOwner(owner, hole)) : () => runWithOwner(owner, fn);
 }
 
 function enableHydration() {}
@@ -625,6 +691,136 @@ function createUniqueId() {
   return getNextChildId(o);
 }
 
+function ssrHandleError(err) {
+  if (err instanceof NotReadyError) {
+    return err.source;
+  }
+  const handler = 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 = getOwner();
+  const parentHandler = parent && runWithOwner(parent, () => getContext(ErrorContext));
+  const o = 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 {
+      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 NotReadyError) throw new InvalidTopLevelAsyncReadError();
+        throw err;
+      }
+    });
+  }
+  let ret = runDiscovery();
+  if (!ret?.p?.length) {
+    commitBoundaryState();
+    return () => ret;
+  }
+  const fallbackOwner = createOwner({
+    id
+  });
+  const fallbackResult = runWithOwner(fallbackOwner, () => ctx.async ? ctx.ssr([`<template id="pl-${id}"></template>`, `<!--pl-${id}-->`], ctx.escape(fallback())) : fallback());
+  if (ctx.async) {
+    done = ctx.registerFragment(id);
+    (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]);
+      } catch (err) {
+        finalizeError(err);
+      }
+    })();
+    return () => fallbackResult;
+  }
+  commitBoundaryState();
+  ctx.serialize(id, "$$f");
+  return () => fallbackResult;
+}
+function NoHydration(props) {
+  const o = createOwner();
+  return runWithOwner(o, () => {
+    setContext(NoHydrateContext, true);
+    return props.children;
+  });
+}
+function Hydration(props) {
+  if (!getContext(NoHydrateContext)) return props.children;
+  const o = createOwner({
+    id: props.id ?? ""
+  });
+  return runWithOwner(o, () => {
+    setContext(NoHydrateContext, false);
+    return props.children;
+  });
+}
+
 function For(props) {
   const options = "fallback" in props ? {
     keyed: props.keyed,
@@ -632,7 +828,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 ? {
@@ -685,106 +881,8 @@ function Errored(props) {
     return typeof f === "function" && f.length ? f(err, reset) : f;
   });
 }
-
-function ssrHandleError(err) {
-  if (err instanceof NotReadyError) {
-    return err.source;
-  }
-  const handler = getContext(ErrorContext);
-  if (handler) {
-    handler(err);
-    return;
-  }
-  throw err;
-}
 function Loading(props) {
-  const ctx = sharedConfig.context;
-  if (!ctx) {
-    return createLoadingBoundary(() => props.children, () => props.fallback);
-  }
-  const o = 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 = runWithOwner(o, () => {
-      try {
-        return ctx.resolve(props.children);
-      } catch (err) {
-        runPromise = ssrHandleError(err);
-      }
-    });
-    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;
-  }
-  const fallbackOwner = createOwner({
-    id
-  });
-  getNextChildId(fallbackOwner);
-  if (ctx.async) {
-    const done = ctx.registerFragment(id);
-    (async () => {
-      try {
-        while (runPromise) {
-          o.dispose(false);
-          await runPromise;
-          runPromise = undefined;
-          ret = runInitially();
-        }
-        for (const args of serializeBuffer) origSerialize(args[0], args[1], args[2]);
-        serializeBuffer = [];
-        while (ret.p.length) {
-          await Promise.all(ret.p);
-          ret = runWithOwner(o, () => ctx.ssr(ret.t, ...ret.h));
-        }
-        done(ret.t[0]);
-      } catch (err) {
-        done(undefined, err);
-      }
-    })();
-    return 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 runWithOwner(fallbackOwner, () => props.fallback);
-}
-function NoHydration(props) {
-  const o = createOwner();
-  return runWithOwner(o, () => {
-    setContext(NoHydrateContext, true);
-    return props.children;
-  });
-}
-function Hydration(props) {
-  if (!getContext(NoHydrateContext)) return props.children;
-  const o = createOwner({
-    id: props.id ?? ""
-  });
-  return runWithOwner(o, () => {
-    setContext(NoHydrateContext, false);
-    return props.children;
-  });
+  return createLoadingBoundary(() => props.children, () => props.fallback);
 }
 
 const DEV = undefined;