solid-js 2.0.0-beta.1 → 2.0.0-beta.2

package/dist/server.cjs

@@ -30,25 +30,12 @@ function getObserver() {
 }
 function createSignal(first, second, third) {
   if (typeof first === "function") {
-    const ssrSource = third?.ssrSource;
-    if (ssrSource === "initial" || ssrSource === "client") {
-      signals.createOwner();
-      let value = second;
-      return [() => value, v => {
-        return value = typeof v === "function" ? v(value) : v;
-      }];
-    }
-    const memoOpts = third?.deferStream || ssrSource ? {
+    const opts = third?.deferStream || third?.ssrSource ? {
       deferStream: third?.deferStream,
-      ssrSource
+      ssrSource: third?.ssrSource
     } : undefined;
-    const memo = createMemo(p => {
-      let value = first(p ? p[0]() : second);
-      return [() => value, v => {
-        return value = typeof v === "function" ? v(value) : v;
-      }];
-    }, undefined, memoOpts);
-    return [() => memo()[0](), v => memo()[1](v)];
+    const memo = createMemo(prev => first(prev), second, opts);
+    return [memo, () => undefined];
   }
   return [() => first, v => {
     return first = typeof v === "function" ? v(first) : v;
@@ -185,42 +172,39 @@ function processResult(comp, result, owner, ctx, deferStream, ssrSource) {
       const promise = iter.next().then(v => {
         promise.s = 1;
         promise.v = v.value;
-        if (comp.disposed) return;
+        if (comp.disposed) return v.value;
         comp.value = v.value;
         comp.error = undefined;
+        return v.value;
       }, () => {});
       if (ctx?.async && ctx.serialize && id && !noHydrate) ctx.serialize(id, promise, deferStream);
-      if (uninitialized) {
-        comp.error = new signals.NotReadyError(promise);
-      }
+      comp.error = new signals.NotReadyError(promise);
     } else {
       const firstNext = iter.next();
       const firstReady = firstNext.then(r => {
         if (comp.disposed) return;
         if (!r.done) {
           comp.value = r.value;
-          comp.error = undefined;
         }
+        comp.error = undefined;
+        return Promise.resolve();
       }, () => {});
-      let servedFirst = false;
-      const tapped = {
-        [Symbol.asyncIterator]: () => ({
-          next() {
-            if (!servedFirst) {
-              servedFirst = true;
-              return firstNext.then(r => {
-                if (!r.done && !comp.disposed) comp.value = r.value;
-                return r;
-              });
+      if (ctx?.async && ctx.serialize && id && !noHydrate) {
+        let tappedFirst = true;
+        const tapped = {
+          [Symbol.asyncIterator]: () => ({
+            next() {
+              if (tappedFirst) {
+                tappedFirst = false;
+                return firstNext.then(r => r);
+              }
+              return iter.next().then(r => r);
             }
-            return iter.next().then(r => r);
-          }
-        })
-      };
-      if (ctx?.async && ctx.serialize && id && !noHydrate) ctx.serialize(id, tapped, deferStream);
-      if (uninitialized) {
-        comp.error = new signals.NotReadyError(firstReady);
+          })
+        };
+        ctx.serialize(id, tapped, deferStream);
       }
+      comp.error = new signals.NotReadyError(firstReady);
     }
     return;
   }
@@ -329,13 +313,14 @@ function createProjection(fn, initialValue = {}, options) {
         promise.s = 1;
         if (disposed) {
           promise.v = state;
-          return;
+          return state;
         }
         if (r.value !== undefined && r.value !== state) {
           Object.assign(state, r.value);
         }
         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);
@@ -351,50 +336,53 @@ function createProjection(fn, initialValue = {}, options) {
           }
         }
         markReady(JSON.parse(JSON.stringify(state)));
+        return Promise.resolve();
       }, () => {
         markReady();
       });
-      let servedFirst = false;
-      const tapped = {
-        [Symbol.asyncIterator]: () => ({
-          next() {
-            if (!servedFirst) {
-              servedFirst = true;
-              return firstNext.then(r => {
-                if (!r.done && !disposed) return {
-                  done: false,
-                  value: state
+      if (ctx?.async && !signals.getContext(NoHydrateContext) && owner.id) {
+        let tappedFirst = true;
+        const tapped = {
+          [Symbol.asyncIterator]: () => ({
+            next() {
+              if (tappedFirst) {
+                tappedFirst = false;
+                return firstNext.then(r => {
+                  if (r.done) return {
+                    done: true,
+                    value: undefined
+                  };
+                  return {
+                    done: false,
+                    value: JSON.parse(JSON.stringify(state))
+                  };
+                });
+              }
+              return iter.next().then(r => {
+                if (disposed) return {
+                  done: true,
+                  value: undefined
                 };
+                const flushed = patches.splice(0);
+                if (!r.done) {
+                  if (r.value !== undefined && r.value !== draft) {
+                    Object.assign(state, r.value);
+                  }
+                  return {
+                    done: false,
+                    value: flushed
+                  };
+                }
                 return {
-                  done: r.done,
+                  done: true,
                   value: undefined
                 };
               });
             }
-            return iter.next().then(r => {
-              if (disposed) return {
-                done: true,
-                value: undefined
-              };
-              const flushed = patches.splice(0);
-              if (!r.done) {
-                if (r.value !== undefined && r.value !== draft) {
-                  Object.assign(state, r.value);
-                }
-                return {
-                  done: false,
-                  value: flushed
-                };
-              }
-              return {
-                done: true,
-                value: undefined
-              };
-            });
-          }
-        })
-      };
-      if (ctx?.async && !signals.getContext(NoHydrateContext) && owner.id) ctx.serialize(owner.id, tapped, options?.deferStream);
+          })
+        };
+        ctx.serialize(owner.id, tapped, options?.deferStream);
+      }
       const [pending, markReady] = createPendingProxy(state, firstReady);
       return pending;
     }
@@ -806,6 +794,10 @@ Object.defineProperty(exports, "$PROXY", {
   enumerable: true,
   get: function () { return signals.$PROXY; }
 });
+Object.defineProperty(exports, "$REFRESH", {
+  enumerable: true,
+  get: function () { return signals.$REFRESH; }
+});
 Object.defineProperty(exports, "$TRACK", {
   enumerable: true,
   get: function () { return signals.$TRACK; }
@@ -858,6 +850,10 @@ Object.defineProperty(exports, "runWithOwner", {
   enumerable: true,
   get: function () { return signals.runWithOwner; }
 });
+Object.defineProperty(exports, "setOnUnhandledAsync", {
+  enumerable: true,
+  get: function () { return signals.setOnUnhandledAsync; }
+});
 Object.defineProperty(exports, "snapshot", {
   enumerable: true,
   get: function () { return signals.snapshot; }

package/dist/server.js

@@ -1,5 +1,5 @@
 import { getOwner, getContext, getNextChildId, createOwner, runWithOwner, onCleanup, NotReadyError, isWrappable, setContext, flatten, createRoot } from '@solidjs/signals';
-export { $PROXY, $TRACK, NotReadyError, createOwner, createRoot, flatten, getNextChildId, getOwner, isEqual, isWrappable, merge, omit, onCleanup, runWithOwner, snapshot, storePath } from '@solidjs/signals';
+export { $PROXY, $REFRESH, $TRACK, NotReadyError, createOwner, createRoot, flatten, getNextChildId, getOwner, isEqual, isWrappable, merge, omit, onCleanup, runWithOwner, setOnUnhandledAsync, snapshot, storePath } from '@solidjs/signals';
 
 const NoHydrateContext = {
   id: Symbol("NoHydrateContext"),
@@ -29,25 +29,12 @@ function getObserver() {
 }
 function createSignal(first, second, third) {
   if (typeof first === "function") {
-    const ssrSource = third?.ssrSource;
-    if (ssrSource === "initial" || ssrSource === "client") {
-      createOwner();
-      let value = second;
-      return [() => value, v => {
-        return value = typeof v === "function" ? v(value) : v;
-      }];
-    }
-    const memoOpts = third?.deferStream || ssrSource ? {
+    const opts = third?.deferStream || third?.ssrSource ? {
       deferStream: third?.deferStream,
-      ssrSource
+      ssrSource: third?.ssrSource
     } : undefined;
-    const memo = createMemo(p => {
-      let value = first(p ? p[0]() : second);
-      return [() => value, v => {
-        return value = typeof v === "function" ? v(value) : v;
-      }];
-    }, undefined, memoOpts);
-    return [() => memo()[0](), v => memo()[1](v)];
+    const memo = createMemo(prev => first(prev), second, opts);
+    return [memo, () => undefined];
   }
   return [() => first, v => {
     return first = typeof v === "function" ? v(first) : v;
@@ -184,42 +171,39 @@ function processResult(comp, result, owner, ctx, deferStream, ssrSource) {
       const promise = iter.next().then(v => {
         promise.s = 1;
         promise.v = v.value;
-        if (comp.disposed) return;
+        if (comp.disposed) return v.value;
         comp.value = v.value;
         comp.error = undefined;
+        return v.value;
       }, () => {});
       if (ctx?.async && ctx.serialize && id && !noHydrate) ctx.serialize(id, promise, deferStream);
-      if (uninitialized) {
-        comp.error = new NotReadyError(promise);
-      }
+      comp.error = new NotReadyError(promise);
     } else {
       const firstNext = iter.next();
       const firstReady = firstNext.then(r => {
         if (comp.disposed) return;
         if (!r.done) {
           comp.value = r.value;
-          comp.error = undefined;
         }
+        comp.error = undefined;
+        return Promise.resolve();
       }, () => {});
-      let servedFirst = false;
-      const tapped = {
-        [Symbol.asyncIterator]: () => ({
-          next() {
-            if (!servedFirst) {
-              servedFirst = true;
-              return firstNext.then(r => {
-                if (!r.done && !comp.disposed) comp.value = r.value;
-                return r;
-              });
+      if (ctx?.async && ctx.serialize && id && !noHydrate) {
+        let tappedFirst = true;
+        const tapped = {
+          [Symbol.asyncIterator]: () => ({
+            next() {
+              if (tappedFirst) {
+                tappedFirst = false;
+                return firstNext.then(r => r);
+              }
+              return iter.next().then(r => r);
             }
-            return iter.next().then(r => r);
-          }
-        })
-      };
-      if (ctx?.async && ctx.serialize && id && !noHydrate) ctx.serialize(id, tapped, deferStream);
-      if (uninitialized) {
-        comp.error = new NotReadyError(firstReady);
+          })
+        };
+        ctx.serialize(id, tapped, deferStream);
       }
+      comp.error = new NotReadyError(firstReady);
     }
     return;
   }
@@ -328,13 +312,14 @@ function createProjection(fn, initialValue = {}, options) {
         promise.s = 1;
         if (disposed) {
           promise.v = state;
-          return;
+          return state;
         }
         if (r.value !== undefined && r.value !== state) {
           Object.assign(state, r.value);
         }
         promise.v = state;
         markReady();
+        return state;
       }, () => {});
       if (ctx?.async && !getContext(NoHydrateContext) && owner.id) ctx.serialize(owner.id, promise, options?.deferStream);
       const [pending, markReady] = createPendingProxy(state, promise);
@@ -350,50 +335,53 @@ function createProjection(fn, initialValue = {}, options) {
           }
         }
         markReady(JSON.parse(JSON.stringify(state)));
+        return Promise.resolve();
       }, () => {
         markReady();
       });
-      let servedFirst = false;
-      const tapped = {
-        [Symbol.asyncIterator]: () => ({
-          next() {
-            if (!servedFirst) {
-              servedFirst = true;
-              return firstNext.then(r => {
-                if (!r.done && !disposed) return {
-                  done: false,
-                  value: state
+      if (ctx?.async && !getContext(NoHydrateContext) && owner.id) {
+        let tappedFirst = true;
+        const tapped = {
+          [Symbol.asyncIterator]: () => ({
+            next() {
+              if (tappedFirst) {
+                tappedFirst = false;
+                return firstNext.then(r => {
+                  if (r.done) return {
+                    done: true,
+                    value: undefined
+                  };
+                  return {
+                    done: false,
+                    value: JSON.parse(JSON.stringify(state))
+                  };
+                });
+              }
+              return iter.next().then(r => {
+                if (disposed) return {
+                  done: true,
+                  value: undefined
                 };
+                const flushed = patches.splice(0);
+                if (!r.done) {
+                  if (r.value !== undefined && r.value !== draft) {
+                    Object.assign(state, r.value);
+                  }
+                  return {
+                    done: false,
+                    value: flushed
+                  };
+                }
                 return {
-                  done: r.done,
+                  done: true,
                   value: undefined
                 };
               });
             }
-            return iter.next().then(r => {
-              if (disposed) return {
-                done: true,
-                value: undefined
-              };
-              const flushed = patches.splice(0);
-              if (!r.done) {
-                if (r.value !== undefined && r.value !== draft) {
-                  Object.assign(state, r.value);
-                }
-                return {
-                  done: false,
-                  value: flushed
-                };
-              }
-              return {
-                done: true,
-                value: undefined
-              };
-            });
-          }
-        })
-      };
-      if (ctx?.async && !getContext(NoHydrateContext) && owner.id) ctx.serialize(owner.id, tapped, options?.deferStream);
+          })
+        };
+        ctx.serialize(owner.id, tapped, options?.deferStream);
+      }
       const [pending, markReady] = createPendingProxy(state, firstReady);
       return pending;
     }

package/dist/solid.cjs

@@ -2,6 +2,7 @@
 
 var signals = require('@solidjs/signals');
 
+const IS_DEV = false;
 const $DEVCOMP = Symbol(0);
 function createContext(defaultValue, options) {
   const id = Symbol(options && options.name || "");
@@ -132,11 +133,41 @@ function subFetch(fn, prev) {
     Promise = ogPromise;
   }
 }
-function consumeFirstSync(ai) {
-  const iter = ai[Symbol.asyncIterator]();
-  const r = iter.next();
-  const value = !(r instanceof Promise) && !r.done ? r.value : undefined;
-  return [value, iter];
+function syncThenable(value) {
+  return {
+    then(fn) {
+      fn(value);
+    }
+  };
+}
+function normalizeIterator(it) {
+  let first = true;
+  let buffered = null;
+  return {
+    next() {
+      if (first) {
+        first = false;
+        const r = it.next();
+        return r && typeof r.then === "function" ? r : syncThenable(r);
+      }
+      if (buffered) {
+        const b = buffered;
+        buffered = null;
+        return b;
+      }
+      let latest = it.next();
+      if (latest && typeof latest.then === "function") return latest;
+      while (!latest.done) {
+        const peek = it.next();
+        if (peek && typeof peek.then === "function") {
+          buffered = peek;
+          break;
+        }
+        latest = peek;
+      }
+      return Promise.resolve(latest);
+    }
+  };
 }
 function applyPatches(target, patches) {
   for (const patch of patches) {
@@ -153,24 +184,6 @@ function applyPatches(target, patches) {
     }
   }
 }
-function scheduleIteratorConsumption(iter, apply) {
-  const consume = () => {
-    while (true) {
-      const n = iter.next();
-      if (n instanceof Promise) {
-        n.then(r => {
-          if (r.done) return;
-          apply(r.value);
-          consume();
-        });
-        return;
-      }
-      if (n.done) break;
-      apply(n.value);
-    }
-  };
-  consume();
-}
 function isAsyncIterable(v) {
   return v != null && typeof v[Symbol.asyncIterator] === "function";
 }
@@ -178,34 +191,85 @@ function hydrateSignalFromAsyncIterable(coreFn, compute, value, options) {
   const parent = signals.getOwner();
   const expectedId = signals.peekNextChildId(parent);
   if (!sharedConfig.has(expectedId)) return null;
-  const initP = sharedConfig.load(expectedId);
-  if (!isAsyncIterable(initP)) return null;
-  const [firstValue, iter] = consumeFirstSync(initP);
-  const [get, set] = signals.createSignal(firstValue);
-  const result = coreFn(() => get(), firstValue, options);
-  scheduleIteratorConsumption(iter, v => {
-    set(() => v);
-    signals.flush();
-  });
-  return result;
+  const loaded = sharedConfig.load(expectedId);
+  if (!isAsyncIterable(loaded)) return null;
+  const it = normalizeIterator(loaded[Symbol.asyncIterator]());
+  const iterable = {
+    [Symbol.asyncIterator]() {
+      return it;
+    }
+  };
+  return coreFn(() => iterable, value, options);
 }
 function hydrateStoreFromAsyncIterable(coreFn, initialValue, options) {
   const parent = signals.getOwner();
   const expectedId = signals.peekNextChildId(parent);
   if (!sharedConfig.has(expectedId)) return null;
-  const initP = sharedConfig.load(expectedId);
-  if (!isAsyncIterable(initP)) return null;
-  const [firstState, iter] = consumeFirstSync(initP);
-  const [store, setStore] = coreFn(() => {}, firstState ?? initialValue, options);
-  scheduleIteratorConsumption(iter, patches => {
-    setStore(d => {
-      applyPatches(d, patches);
-    });
-  });
-  return [store, setStore];
+  const loaded = sharedConfig.load(expectedId);
+  if (!isAsyncIterable(loaded)) return null;
+  const srcIt = loaded[Symbol.asyncIterator]();
+  let isFirst = true;
+  let buffered = null;
+  return coreFn(draft => {
+    const process = res => {
+      if (res.done) return {
+        done: true,
+        value: undefined
+      };
+      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);
+        }
+      } else {
+        applyPatches(draft, res.value);
+      }
+      return {
+        done: false,
+        value: undefined
+      };
+    };
+    return {
+      [Symbol.asyncIterator]() {
+        return {
+          next() {
+            if (isFirst) {
+              const r = srcIt.next();
+              return r && typeof r.then === "function" ? r.then(process) : syncThenable(process(r));
+            }
+            if (buffered) {
+              const b = buffered;
+              buffered = null;
+              return b.then(process);
+            }
+            let r = srcIt.next();
+            if (r && typeof r.then === "function") {
+              return r.then(process);
+            }
+            let result = process(r);
+            while (!r.done) {
+              const peek = srcIt.next();
+              if (peek && typeof peek.then === "function") {
+                buffered = peek;
+                break;
+              }
+              r = peek;
+              if (!r.done) result = process(r);
+            }
+            return Promise.resolve(result);
+          }
+        };
+      }
+    };
+  }, initialValue, options);
 }
 function hydratedCreateMemo(compute, value, options) {
-  if (!sharedConfig.hydrating) return signals.createMemo(compute, value, options);
+  if (!sharedConfig.hydrating) {
+    return signals.createMemo(compute, value, options);
+  }
   markTopLevelSnapshotScope();
   const ssrSource = options?.ssrSource;
   if (ssrSource === "client") {
@@ -357,14 +421,16 @@ function hydratedCreateOptimisticStore(first, second, third) {
   return signals.createOptimisticStore(wrapStoreFn(first, ssrSource), second, third);
 }
 function hydratedCreateProjection(fn, initialValue, options) {
-  if (!sharedConfig.hydrating) return signals.createProjection(fn, initialValue, options);
+  if (!sharedConfig.hydrating) {
+    return signals.createProjection(fn, initialValue, options);
+  }
   markTopLevelSnapshotScope();
   const ssrSource = options?.ssrSource;
   if (ssrSource === "client" || ssrSource === "initial") {
     return signals.createProjection(draft => draft, initialValue, options);
   }
-  const aiResult = hydrateStoreFromAsyncIterable(signals.createStore, initialValue, options);
-  if (aiResult !== null) return aiResult[0];
+  const aiResult = hydrateStoreFromAsyncIterable(signals.createProjection, initialValue, options);
+  if (aiResult !== null) return aiResult;
   return signals.createProjection(wrapStoreFn(fn, ssrSource), initialValue, options);
 }
 function hydratedEffect(coreFn, compute, effectFn, value, options) {
@@ -637,15 +703,10 @@ function Show(props) {
     if (c) {
       const child = props.children;
       const fn = typeof child === "function" && child.length > 0;
-      return fn ? signals.untrack(() => {
-        try {
-          return child(() => {
-            if (!signals.untrack(condition)) throw narrowedError("Show");
-            return conditionValue();
-          });
-        } finally {
-        }
-      }) : child;
+      return fn ? signals.untrack(() => child(() => {
+        if (!signals.untrack(condition)) throw narrowedError("Show");
+        return conditionValue();
+      }), IS_DEV) : child;
     }
     return props.fallback;
   }, undefined, undefined);
@@ -673,15 +734,10 @@ function Switch(props) {
     const [index, conditionValue, mp] = sel;
     const child = mp.children;
     const fn = typeof child === "function" && child.length > 0;
-    return fn ? signals.untrack(() => {
-      try {
-        return child(() => {
-          if (signals.untrack(switchFunc)()?.[0] !== index) throw narrowedError("Match");
-          return conditionValue();
-        });
-      } finally {
-      }
-    }) : child;
+    return fn ? signals.untrack(() => child(() => {
+      if (signals.untrack(switchFunc)()?.[0] !== index) throw narrowedError("Match");
+      return conditionValue();
+    }), IS_DEV) : child;
   }, undefined, undefined);
 }
 function Match(props) {
@@ -702,6 +758,10 @@ Object.defineProperty(exports, "$PROXY", {
   enumerable: true,
   get: function () { return signals.$PROXY; }
 });
+Object.defineProperty(exports, "$REFRESH", {
+  enumerable: true,
+  get: function () { return signals.$REFRESH; }
+});
 Object.defineProperty(exports, "$TRACK", {
   enumerable: true,
   get: function () { return signals.$TRACK; }
@@ -814,6 +874,10 @@ Object.defineProperty(exports, "runWithOwner", {
   enumerable: true,
   get: function () { return signals.runWithOwner; }
 });
+Object.defineProperty(exports, "setOnUnhandledAsync", {
+  enumerable: true,
+  get: function () { return signals.setOnUnhandledAsync; }
+});
 Object.defineProperty(exports, "snapshot", {
   enumerable: true,
   get: function () { return signals.snapshot; }