solid-js 1.4.7 → 1.5.0-beta.0

package/dist/server.js

@@ -3,6 +3,16 @@ const $PROXY = Symbol("solid-proxy");
 const $DEVCOMP = Symbol("solid-dev-component");
 const DEV = {};
 const ERROR = Symbol("error");
+function castError(err) {
+  if (err instanceof Error || typeof err === "string") return err;
+  return new Error("Unknown error");
+}
+function handleError(err) {
+  err = castError(err);
+  const fns = lookup(Owner, ERROR);
+  if (!fns) throw err;
+  for (const f of fns) f(err);
+}
 const UNOWNED = {
   context: null,
   owner: null
@@ -20,9 +30,7 @@ function createRoot(fn, detachedOwner) {
   try {
     result = fn(() => {});
   } catch (err) {
-    const fns = lookup(Owner, ERROR);
-    if (!fns) throw err;
-    fns.forEach(f => f(err));
+    handleError(err);
   } finally {
     Owner = owner;
   }
@@ -41,9 +49,7 @@ function createComputed(fn, value) {
   try {
     fn(value);
   } catch (err) {
-    const fns = lookup(Owner, ERROR);
-    if (!fns) throw err;
-    fns.forEach(f => f(err));
+    handleError(err);
   } finally {
     Owner = Owner.owner;
   }
@@ -64,9 +70,7 @@ function createMemo(fn, value) {
   try {
     v = fn(value);
   } catch (err) {
-    const fns = lookup(Owner, ERROR);
-    if (!fns) throw err;
-    fns.forEach(f => f(err));
+    handleError(err);
   } finally {
     Owner = Owner.owner;
   }
@@ -311,16 +315,14 @@ function Switch(props) {
 function Match(props) {
   return props;
 }
-const NoErrors = {};
 function resetErrorBoundaries() {}
 function ErrorBoundary(props) {
-  let error = NoErrors,
-      res;
+  let error, res;
   const ctx = sharedConfig.context;
   const id = ctx.id + ctx.count;
   onError(err => error = err);
   createMemo(() => res = props.children);
-  if (error !== NoErrors) {
+  if (error) {
     ctx.writeResource(id, error, true);
     setHydrateContext({ ...ctx,
       count: 0
@@ -408,7 +410,7 @@ function createResource(source, fetcher, options = {}) {
         return res;
       }).catch(err => {
         read.loading = false;
-        read.error = error = err;
+        read.error = error = castError(err);
         p = null;
         notifySuspense(contexts);
       });
@@ -426,10 +428,17 @@ function createResource(source, fetcher, options = {}) {
 }
 function lazy(fn) {
   let resolved;
-  const p = fn();
+  let p;
+  let load = () => {
+    if (!p) {
+      p = fn();
+      p.then(mod => resolved = mod.default);
+    }
+    return p;
+  };
   const contexts = new Set();
-  p.then(mod => resolved = mod.default);
   const wrap = props => {
+    load();
     const id = sharedConfig.context.id.slice(0, -1);
     if (resolved) return resolved(props);
     const ctx = useContext(SuspenseContext);
@@ -447,7 +456,7 @@ function lazy(fn) {
     });
     return "";
   };
-  wrap.preload = () => p;
+  wrap.preload = load;
   return wrap;
 }
 function suspenseComplete(c) {
@@ -504,24 +513,20 @@ function Suspense(props) {
   }
   const res = runSuspense();
   if (suspenseComplete(value)) {
-    ctx.writeResource(id, null);
+    ctx.writeResource(id, "$$$");
     return res;
   }
   onError(err => {
     if (!done || !done(undefined, err)) throw err;
   });
   done = ctx.async ? ctx.registerFragment(id) : undefined;
-  if (ctx.streaming) {
+  if (ctx.async) {
     setHydrateContext(undefined);
     const res = {
       t: `<span id="pl-${id}">${resolveSSRNode(props.fallback)}</span>`
     };
     setHydrateContext(ctx);
     return res;
-  } else if (ctx.async) {
-    return {
-      t: `<![${id}]>`
-    };
   }
   setHydrateContext({ ...ctx,
     count: 0,

package/dist/solid.cjs

@@ -138,7 +138,6 @@ const signalOptions = {
 };
 let ERROR = null;
 let runEffects = runQueue;
-const NOTPENDING = {};
 const STALE = 1;
 const PENDING = 2;
 const UNOWNED = {
@@ -147,6 +146,7 @@ const UNOWNED = {
   context: null,
   owner: null
 };
+const NO_INIT = {};
 const [transPending, setTransPending] = /*@__PURE__*/createSignal(false);
 var Owner = null;
 let Transition = null;
@@ -183,12 +183,11 @@ function createSignal(value, options) {
     value,
     observers: null,
     observerSlots: null,
-    pending: NOTPENDING,
     comparator: options.equals || undefined
   };
   const setter = value => {
     if (typeof value === "function") {
-      if (Transition && Transition.running && Transition.sources.has(s)) value = value(s.pending !== NOTPENDING ? s.pending : s.tValue);else value = value(s.pending !== NOTPENDING ? s.pending : s.value);
+      if (Transition && Transition.running && Transition.sources.has(s)) value = value(s.tValue);else value = value(s.value);
     }
     return writeSignal(s, value);
   };
@@ -227,7 +226,6 @@ function createReaction(onInvalidate, options) {
 function createMemo(fn, value, options) {
   options = options ? Object.assign({}, signalOptions, options) : signalOptions;
   const c = createComputation(fn, value, true, 0);
-  c.pending = NOTPENDING;
   c.observers = null;
   c.observerSlots = null;
   c.comparator = options.equals || undefined;
@@ -249,34 +247,33 @@ function createResource(source, fetcher, options) {
     source = true;
   }
   options || (options = {});
-  const contexts = new Set(),
-        [value, setValue] = createSignal(options.initialValue),
-        [track, trigger] = createSignal(undefined, {
-    equals: false
-  }),
-        [loading, setLoading] = createSignal(false),
-        [error, setError] = createSignal();
   let err = undefined,
       pr = null,
-      initP = null,
+      initP = NO_INIT,
       id = null,
       loadedUnderTransition = false,
       scheduled = false,
       resolved = ("initialValue" in options),
       dynamic = typeof source === "function" && createMemo(source);
+  const contexts = new Set(),
+        [value, setValue] = options.store ? options.store(options.initialValue) : createSignal(options.initialValue),
+        [track, trigger] = createSignal(undefined, {
+    equals: false
+  }),
+        [state, setState] = createSignal(resolved ? "ready" : "unresolved");
   if (sharedConfig.context) {
     id = `${sharedConfig.context.id}${sharedConfig.context.count++}`;
-    if (sharedConfig.load) initP = sharedConfig.load(id);
+    let v;
+    if (sharedConfig.load && (v = sharedConfig.load(id))) initP = v[0];
   }
-  function loadEnd(p, v, e, key) {
+  function loadEnd(p, v, success, key) {
     if (pr === p) {
       pr = null;
       resolved = true;
-      if (initP && (p === initP || v === initP) && options.onHydrated) queueMicrotask(() => options.onHydrated(key, {
+      if ((p === initP || v === initP) && options.onHydrated) queueMicrotask(() => options.onHydrated(key, {
         value: v
       }));
-      initP = null;
-      setError(err = e);
+      initP = NO_INIT;
       if (Transition && p && loadedUnderTransition) {
         Transition.promises.delete(p);
         loadedUnderTransition = false;
@@ -286,19 +283,20 @@ function createResource(source, fetcher, options) {
             Effects.push.apply(Effects, Transition.effects);
             Transition.effects = [];
           }
-          completeLoad(v);
+          completeLoad(v, success);
         }, false);
-      } else completeLoad(v);
+      } else completeLoad(v, success);
     }
     return v;
   }
-  function completeLoad(v) {
-    batch(() => {
-      setValue(() => v);
-      setLoading(false);
+  function completeLoad(v, success) {
+    !success && (err = castError(v));
+    runUpdates(() => {
+      setValue(() => success ? v : undefined);
+      setState(success ? "ready" : "error");
       for (const c of contexts.keys()) c.decrement();
       contexts.clear();
-    });
+    }, false);
   }
   function read() {
     const c = SuspenseContext && lookup(Owner, SuspenseContext.id),
@@ -320,46 +318,52 @@ function createResource(source, fetcher, options) {
   function load(refetching = true) {
     if (refetching && scheduled) return;
     scheduled = false;
-    setError(err = undefined);
+    err = undefined;
     const lookup = dynamic ? dynamic() : source;
     loadedUnderTransition = Transition && Transition.running;
     if (lookup == null || lookup === false) {
-      loadEnd(pr, untrack(value));
+      loadEnd(pr, untrack(value), true);
       return;
     }
     if (Transition && pr) Transition.promises.delete(pr);
-    const p = initP || untrack(() => fetcher(lookup, {
+    const p = initP !== NO_INIT ? initP : untrack(() => fetcher(lookup, {
       value: value(),
       refetching
     }));
     if (typeof p !== "object" || !("then" in p)) {
-      loadEnd(pr, p);
+      loadEnd(pr, p, true);
       return p;
     }
     pr = p;
     scheduled = true;
     queueMicrotask(() => scheduled = false);
-    batch(() => {
-      setLoading(true);
+    runUpdates(() => {
+      setState(resolved ? "refreshing" : "pending");
       trigger();
-    });
-    return p.then(v => loadEnd(p, v, undefined, lookup), e => loadEnd(p, e, e));
+    }, false);
+    return p.then(v => loadEnd(p, v, true, lookup), e => loadEnd(p, e, false));
   }
   Object.defineProperties(read, {
+    state: {
+      get() {
+        return state();
+      }
+    },
     loading: {
       get() {
-        return loading();
+        const s = state();
+        return s === "pending" || s === "refreshing";
       }
     },
     error: {
       get() {
-        return error();
+        return state() === "error" ? err : undefined;
       }
     },
     latest: {
       get() {
         if (!resolved) return read();
-        if (err) throw err;
+        if (state() === "error") throw err;
         return value();
       }
     }
@@ -421,14 +425,7 @@ function batch(fn) {
     Pending = null;
   }
   runUpdates(() => {
-    for (let i = 0; i < q.length; i += 1) {
-      const data = q[i];
-      if (data.pending !== NOTPENDING) {
-        const pending = data.pending;
-        data.pending = NOTPENDING;
-        writeSignal(data, pending);
-      }
-    }
+    for (let i = 0; i < q.length; i += 1) notifySignal(q[i]);
   }, false);
   return result;
 }
@@ -513,7 +510,7 @@ function startTransition(fn) {
       t.done || (t.done = new Promise(res => t.resolve = res));
       t.running = true;
     }
-    batch(fn);
+    runUpdates(fn, false);
     Listener = Owner = null;
     return t ? t.done : undefined;
   });
@@ -592,29 +589,26 @@ function readSignal() {
   return this.value;
 }
 function writeSignal(node, value, isComp) {
-  if (Pending) {
-    if (node.pending === NOTPENDING) Pending.push(node);
-    node.pending = value;
-    return value;
-  }
-  if (node.comparator) {
-    if (Transition && Transition.running && Transition.sources.has(node)) {
-      if (node.comparator(node.tValue, value)) return value;
-    } else if (node.comparator(node.value, value)) return value;
+  let current = Transition && Transition.running && Transition.sources.has(node) ? node.tValue : node.value;
+  if (!node.comparator || !node.comparator(current, value)) {
+    if (Transition) {
+      const TransitionRunning = Transition.running;
+      if (TransitionRunning || !isComp && Transition.sources.has(node)) {
+        Transition.sources.add(node);
+        node.tValue = value;
+      }
+      if (!TransitionRunning) node.value = value;
+    } else node.value = value;
+    if (Pending) Pending.push(node);else notifySignal(node);
   }
-  let TransitionRunning = false;
-  if (Transition) {
-    TransitionRunning = Transition.running;
-    if (TransitionRunning || !isComp && Transition.sources.has(node)) {
-      Transition.sources.add(node);
-      node.tValue = value;
-    }
-    if (!TransitionRunning) node.value = value;
-  } else node.value = value;
+  return value;
+}
+function notifySignal(node) {
   if (node.observers && node.observers.length) {
     runUpdates(() => {
       for (let i = 0; i < node.observers.length; i += 1) {
         const o = node.observers[i];
+        const TransitionRunning = Transition && Transition.running;
         if (TransitionRunning && Transition.disposed.has(o)) continue;
         if (TransitionRunning && !o.tState || !TransitionRunning && !o.state) {
           if (o.pure) Updates.push(o);else Effects.push(o);
@@ -629,7 +623,6 @@ function writeSignal(node, value, isComp) {
       }
     }, false);
   }
-  return value;
 }
 function updateComputation(node) {
   if (!node.fn) return;
@@ -658,7 +651,7 @@ function runComputation(node, value, time) {
     handleError(err);
   }
   if (!node.updatedAt || node.updatedAt <= time) {
-    if (node.observers && node.observers.length) {
+    if (node.updatedAt && "observers" in node) {
       writeSignal(node, nextValue, true);
     } else if (Transition && Transition.running && node.pure) {
       Transition.sources.add(node);
@@ -774,7 +767,7 @@ function completeUpdates(wait) {
       delete e.tState;
     }
     Transition = null;
-    batch(() => {
+    runUpdates(() => {
       for (const d of disposed) cleanNode(d);
       for (const v of sources) {
         v.value = v.tValue;
@@ -787,14 +780,11 @@ function completeUpdates(wait) {
         v.tState = 0;
       }
       setTransPending(false);
-    });
-  }
-  if (Effects.length) batch(() => {
-    runEffects(Effects);
-    Effects = null;
-  });else {
-    Effects = null;
+    }, false);
   }
+  const e = Effects;
+  Effects = null;
+  if (e.length) runUpdates(() => runEffects(e), false);
   if (res) res();
 }
 function runQueue(queue) {
@@ -829,9 +819,9 @@ function runUserEffects(queue) {
     if (!e.user) runTop(e);else queue[userLength++] = e;
   }
   if (sharedConfig.context) setHydrateContext();
-  const resume = queue.length;
+  Effects = [];
   for (i = 0; i < userLength; i++) runTop(queue[i]);
-  for (i = resume; i < queue.length; i++) runTop(queue[i]);
+  if (Effects.length) runUserEffects(Effects);
 }
 function lookUpstream(node, ignore) {
   const runningTransition = Transition && Transition.running;
@@ -900,7 +890,12 @@ function reset(node, top) {
     for (let i = 0; i < node.owned.length; i++) reset(node.owned[i]);
   }
 }
+function castError(err) {
+  if (err instanceof Error || typeof err === "string") return err;
+  return new Error("Unknown error");
+}
 function handleError(err) {
+  err = castError(err);
   const fns = ERROR && lookup(Owner, ERROR);
   if (!fns) throw err;
   for (const f of fns) f(err);
@@ -933,31 +928,33 @@ function createProvider(id) {
   };
 }
 
-function getSymbol() {
-  const SymbolCopy = Symbol;
-  return SymbolCopy.observable || "@@observable";
-}
 function observable(input) {
-  const $$observable = getSymbol();
   return {
     subscribe(observer) {
       if (!(observer instanceof Object) || observer == null) {
         throw new TypeError("Expected the observer to be an object.");
       }
-      const handler = "next" in observer ? observer.next.bind(observer) : observer;
-      let complete = false;
-      createComputed(() => {
-        if (complete) return;
-        const v = input();
-        untrack(() => handler(v));
+      const handler = typeof observer === 'function' ? observer : observer.next && observer.next.bind(observer);
+      if (!handler) {
+        return {
+          unsubscribe() {}
+        };
+      }
+      const dispose = createRoot(disposer => {
+        createComputed(() => {
+          const v = input();
+          untrack(() => handler(v));
+        });
+        return disposer;
       });
+      if (getOwner()) onCleanup(dispose);
       return {
         unsubscribe() {
-          complete = true;
+          dispose();
         }
       };
     },
-    [$$observable]() {
+    [Symbol.observable || "@@observable"]() {
       return this;
     }
   };
@@ -1333,24 +1330,22 @@ function Match(props) {
   return props;
 }
 let Errors;
-const NoErrors = {};
 function resetErrorBoundaries() {
-  Errors && [...Errors].forEach(fn => fn(NoErrors));
+  Errors && [...Errors].forEach(fn => fn());
 }
 function ErrorBoundary(props) {
-  let err = NoErrors;
-  if (sharedConfig.context && sharedConfig.load) {
-    err = sharedConfig.load(sharedConfig.context.id + sharedConfig.context.count) || NoErrors;
-  }
+  let err;
+  let v;
+  if (sharedConfig.context && sharedConfig.load && (v = sharedConfig.load(sharedConfig.context.id + sharedConfig.context.count))) err = v[0];
   const [errored, setErrored] = createSignal(err);
   Errors || (Errors = new Set());
   Errors.add(setErrored);
   onCleanup(() => Errors.delete(setErrored));
   return createMemo(() => {
     let e;
-    if ((e = errored()) !== NoErrors) {
+    if (e = errored()) {
       const f = props.fallback;
-      return typeof f === "function" && f.length ? untrack(() => f(e, () => setErrored(NoErrors))) : f;
+      return typeof f === "function" && f.length ? untrack(() => f(e, setErrored)) : f;
     }
     onError(setErrored);
     return props.children;
@@ -1445,21 +1440,27 @@ function Suspense(props) {
         owner = getOwner();
   if (sharedConfig.context && sharedConfig.load) {
     const key = sharedConfig.context.id + sharedConfig.context.count;
-    p = sharedConfig.load(key);
-    if (p) {
-      if (typeof p !== "object" || !("then" in p)) p = Promise.resolve(p);
-      const [s, set] = createSignal(undefined, {
-        equals: false
-      });
-      flicker = s;
-      p.then(err => {
-        if ((error = err) || sharedConfig.done) return set();
-        sharedConfig.gather(key);
-        setHydrateContext(ctx);
-        set();
-        setHydrateContext();
-      });
-    } else if (p === null) sharedConfig.gather(key);
+    let ref = sharedConfig.load(key);
+    if (ref) {
+      p = ref[0];
+      if (p === "$$$") sharedConfig.gather(key);else {
+        if (typeof p !== "object" || !("then" in p)) p = Promise.resolve(p);
+        const [s, set] = createSignal(undefined, {
+          equals: false
+        });
+        flicker = s;
+        p.then(err => {
+          if (err !== "$$$" || sharedConfig.done) {
+            err !== "$$$" && (error = err);
+            return set();
+          }
+          sharedConfig.gather(key);
+          setHydrateContext(ctx);
+          set();
+          setHydrateContext();
+        });
+      }
+    }
   }
   const listContext = useContext(SuspenseListContext);
   if (listContext) [showContent, showFallback] = listContext.register(store.inFallback);
@@ -1475,14 +1476,14 @@ function Suspense(props) {
           flicker();
           return flicker = undefined;
         }
-        if (ctx && p === undefined) setHydrateContext();
+        if (ctx && !p) setHydrateContext();
         const rendered = createMemo(() => props.children);
         return createMemo(() => {
           const inFallback = store.inFallback(),
                 visibleContent = showContent ? showContent() : true,
                 visibleFallback = showFallback ? showFallback() : true;
           dispose && dispose();
-          if ((!inFallback || p !== undefined) && visibleContent) {
+          if ((!inFallback || p) && visibleContent) {
             store.resolved = true;
             ctx = p = undefined;
             resumeEffects(store.effects);