solid-js 1.4.8 → 1.5.0-beta.2

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,13 +146,13 @@ const UNOWNED = {
   context: null,
   owner: null
 };
+const NO_INIT = {};
 const [transPending, setTransPending] = /*@__PURE__*/createSignal(false);
 var Owner = null;
 let Transition = null;
 let Scheduler = null;
 let ExternalSourceFactory = null;
 let Listener = null;
-let Pending = null;
 let Updates = null;
 let Effects = null;
 let ExecCount = 0;
@@ -183,12 +182,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 +225,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;
@@ -237,46 +234,46 @@ function createMemo(fn, value, options) {
   } else updateComputation(c);
   return readSignal.bind(c);
 }
-function createResource(source, fetcher, options) {
-  if (arguments.length === 2) {
-    if (typeof fetcher === "object") {
-      options = fetcher;
-      fetcher = source;
-      source = true;
-    }
-  } else if (arguments.length === 1) {
-    fetcher = source;
+function createResource(pSource, pFetcher, pOptions) {
+  let source;
+  let fetcher;
+  let options;
+  if (arguments.length === 2 && typeof pFetcher === "object" || arguments.length === 1) {
     source = true;
+    fetcher = pSource;
+    options = pFetcher || {};
+  } else {
+    source = pSource;
+    fetcher = pFetcher;
+    options = pOptions || {};
   }
-  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(() => {
+  function completeLoad(v, success) {
+    !success && (err = castError(v));
+    runUpdates(() => {
       setValue(() => v);
-      setLoading(false);
+      setState(success ? "ready" : "error");
       for (const c of contexts.keys()) c.decrement();
       contexts.clear();
-    });
+    }, false);
   }
   function read() {
     const c = SuspenseContext && lookup(Owner, SuspenseContext.id),
@@ -318,48 +316,54 @@ function createResource(source, fetcher, options) {
     return v;
   }
   function load(refetching = true) {
-    if (refetching && scheduled) return;
+    if (refetching !== false && 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();
       }
     }
@@ -412,25 +416,7 @@ function createSelector(source, fn = equalFn, options) {
   };
 }
 function batch(fn) {
-  if (Pending) return fn();
-  let result;
-  const q = Pending = [];
-  try {
-    result = fn();
-  } finally {
-    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);
-      }
-    }
-  }, false);
-  return result;
+  return runUpdates(fn, false);
 }
 function untrack(fn) {
   let result,
@@ -513,7 +499,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;
   });
@@ -566,10 +552,12 @@ function enableExternalSource(factory) {
 function readSignal() {
   const runningTransition = Transition && Transition.running;
   if (this.sources && (!runningTransition && this.state || runningTransition && this.tState)) {
-    const updates = Updates;
-    Updates = null;
-    !runningTransition && this.state === STALE || runningTransition && this.tState === STALE ? updateComputation(this) : lookUpstream(this);
-    Updates = updates;
+    if (!runningTransition && this.state === STALE || runningTransition && this.tState === STALE) updateComputation(this);else {
+      const updates = Updates;
+      Updates = null;
+      runUpdates(() => lookUpstream(this), false);
+      Updates = updates;
+    }
   }
   if (Listener) {
     const sSlot = this.observers ? this.observers.length : 0;
@@ -592,42 +580,35 @@ 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 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;
-  if (node.observers && node.observers.length) {
-    runUpdates(() => {
-      for (let i = 0; i < node.observers.length; i += 1) {
-        const o = node.observers[i];
-        if (TransitionRunning && Transition.disposed.has(o)) continue;
-        if (TransitionRunning && !o.tState || !TransitionRunning && !o.state) {
-          if (o.pure) Updates.push(o);else Effects.push(o);
-          if (o.observers) markDownstream(o);
-        }
-        if (TransitionRunning) o.tState = STALE;else o.state = STALE;
-      }
-      if (Updates.length > 10e5) {
-        Updates = [];
-        if (false) ;
-        throw new Error();
+  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;
       }
-    }, false);
+      if (!TransitionRunning) node.value = value;
+    } else node.value = value;
+    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);
+            if (o.observers) markDownstream(o);
+          }
+          if (TransitionRunning) o.tState = STALE;else o.state = STALE;
+        }
+        if (Updates.length > 10e5) {
+          Updates = [];
+          if (false) ;
+          throw new Error();
+        }
+      }, false);
+    }
   }
   return value;
 }
@@ -655,10 +636,11 @@ function runComputation(node, value, time) {
   try {
     nextValue = node.fn(value);
   } catch (err) {
+    if (node.pure) Transition && Transition.running ? node.tState = STALE : node.state = STALE;
     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);
@@ -731,7 +713,7 @@ function runTop(node) {
     } else if (!runningTransition && node.state === PENDING || runningTransition && node.tState === PENDING) {
       const updates = Updates;
       Updates = null;
-      lookUpstream(node, ancestors[0]);
+      runUpdates(() => lookUpstream(node, ancestors[0]), false);
       Updates = updates;
     }
   }
@@ -774,7 +756,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 +769,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 +808,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 +879,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);
@@ -946,7 +930,7 @@ function observable(input) {
         };
       }
       const dispose = createRoot(disposer => {
-        createComputed(() => {
+        createEffect(() => {
           const v = input();
           untrack(() => handler(v));
         });
@@ -1335,24 +1319,24 @@ 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;
+      const res = typeof f === "function" && f.length ? untrack(() => f(e, () => setErrored())) : f;
+      onError(setErrored);
+      return res;
     }
     onError(setErrored);
     return props.children;
@@ -1447,21 +1431,24 @@ function Suspense(props) {
         owner = getOwner();
   if (sharedConfig.context && sharedConfig.load) {
     const key = sharedConfig.context.id + sharedConfig.context.count;
-    p = sharedConfig.load(key);
-    if (p) {
+    let ref = sharedConfig.load(key);
+    if (ref && (p = ref[0]) && p !== "$$f") {
       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();
+        if (err || sharedConfig.done) {
+          err && (error = err);
+          return set();
+        }
         sharedConfig.gather(key);
         setHydrateContext(ctx);
         set();
         setHydrateContext();
       });
-    } else if (p === null) sharedConfig.gather(key);
+    }
   }
   const listContext = useContext(SuspenseListContext);
   if (listContext) [showContent, showFallback] = listContext.register(store.inFallback);
@@ -1477,14 +1464,14 @@ function Suspense(props) {
           flicker();
           return flicker = undefined;
         }
-        if (ctx && p === undefined) setHydrateContext();
+        if (ctx && p === "$$f") 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 && p !== "$$f") && visibleContent) {
             store.resolved = true;
             ctx = p = undefined;
             resumeEffects(store.effects);