@solidjs/signals 0.0.4 → 0.0.5

package/dist/dev.js

@@ -3,9 +3,7 @@ var NotReadyError = class extends Error {
 };
 var NoOwnerError = class extends Error {
   constructor() {
-    super(
-      "Context can only be accessed under a reactive root." 
-    );
+    super("Context can only be accessed under a reactive root." );
   }
 };
 var ContextNotFoundError = class extends Error {
@@ -16,11 +14,6 @@ var ContextNotFoundError = class extends Error {
   }
 };
 
-// src/utils.ts
-function isUndefined(value) {
-  return typeof value === "undefined";
-}
-
 // src/core/constants.ts
 var STATE_CLEAN = 0;
 var STATE_CHECK = 1;
@@ -32,6 +25,65 @@ var EFFECT_RENDER = 1;
 var EFFECT_USER = 2;
 var SUPPORTS_PROXY = typeof Proxy === "function";
 
+// src/core/utils.ts
+function isUndefined(value) {
+  return typeof value === "undefined";
+}
+function flatten(children, options) {
+  if (typeof children === "function" && !children.length) {
+    if (options?.doNotUnwrap)
+      return children;
+    do {
+      children = children();
+    } while (typeof children === "function" && !children.length);
+  }
+  if (options?.skipNonRendered && (children == null || children === true || children === false || children === ""))
+    return;
+  if (Array.isArray(children)) {
+    let results = [];
+    if (flattenArray(children, results, options)) {
+      return () => {
+        let nested = [];
+        flattenArray(results, nested, { ...options, doNotUnwrap: false });
+        return nested;
+      };
+    }
+    return results;
+  }
+  return children;
+}
+function flattenArray(children, results = [], options) {
+  let notReady = null;
+  let needsUnwrap = false;
+  for (let i = 0; i < children.length; i++) {
+    try {
+      let child = children[i];
+      if (typeof child === "function" && !child.length) {
+        if (options?.doNotUnwrap) {
+          results.push(child);
+          needsUnwrap = true;
+          continue;
+        }
+        do {
+          child = child();
+        } while (typeof child === "function" && !child.length);
+      }
+      if (Array.isArray(child)) {
+        needsUnwrap = flattenArray(child, results, options);
+      } else if (options?.skipNonRendered && (child == null || child === true || child === false || child === "")) {
+      } else
+        results.push(child);
+    } catch (e) {
+      if (!(e instanceof NotReadyError))
+        throw e;
+      notReady = e;
+    }
+  }
+  if (notReady)
+    throw notReady;
+  return needsUnwrap;
+}
+
 // src/core/owner.ts
 var currentOwner = null;
 var defaultContext = {};
@@ -226,7 +278,7 @@ var Computation = class extends Owner {
   _read() {
     if (this._compute)
       this._updateIfNecessary();
-    if (!this._sources || this._sources.length)
+    if (!this._compute || this._sources?.length)
       track(this);
     newFlags |= this._stateFlags & ~currentMask;
     if (this._stateFlags & ERROR_BIT) {
@@ -598,14 +650,22 @@ var Queue = class {
   }
 };
 var globalQueue = new Queue();
+var globalTasks = [];
 function flushSync() {
   let count = 0;
   while (scheduled) {
     if (++count === 1e5)
       throw new Error("Potential Infinite Loop Detected.");
     globalQueue.flush();
+    for (let i = 0; i < globalTasks.length; i++)
+      globalTasks[i]();
+    globalTasks.length = 0;
   }
 }
+function queueTask(fn) {
+  globalTasks.push(fn);
+  schedule();
+}
 function createBoundary(fn, queue) {
   const owner = new Owner();
   const parentQueue = owner._queue || globalQueue;
@@ -657,7 +717,7 @@ var Effect = class extends Computation {
   write(value, flags = 0) {
     const currentFlags = this._stateFlags;
     this._stateFlags = flags;
-    if ((flags & LOADING_BIT) !== (currentFlags & LOADING_BIT)) {
+    if (this._type === EFFECT_RENDER && (flags & LOADING_BIT) !== (currentFlags & LOADING_BIT)) {
       this._queue._update?.(this);
     }
     if (value === UNCHANGED)
@@ -722,22 +782,35 @@ var SuspenseQueue = class extends Queue {
       this._nodes.add(node);
       if (!this._fallback) {
         this._fallback = true;
-        queueMicrotask(() => this._signal.write(true));
+        queueTask(() => this._signal.write(true));
       }
     } else {
       this._nodes.delete(node);
       if (this._nodes.size === 0) {
         this._fallback = false;
-        queueMicrotask(() => this._signal.write(false));
+        queueTask(() => this._signal.write(false));
       }
     }
   }
 };
+var LiveComputation = class extends EagerComputation {
+  write(value, flags = 0) {
+    const currentFlags = this._stateFlags;
+    super.write(value, flags);
+    if ((flags & LOADING_BIT) !== (currentFlags & LOADING_BIT)) {
+      this._queue._update?.(this);
+    }
+    return this._value;
+  }
+};
 function createSuspense(fn, fallbackFn) {
   const queue = new SuspenseQueue();
-  const tree = createBoundary(fn, queue);
+  const tree = createBoundary(() => {
+    const child = new Computation(null, fn);
+    return new LiveComputation(null, () => flatten(child.wait()));
+  }, queue);
   const equality = new Computation(null, () => queue._signal.read() || queue._fallback);
-  const comp = new Computation(null, () => equality.read() ? untrack(fallbackFn) : tree);
+  const comp = new Computation(null, () => equality.read() ? untrack(fallbackFn) : tree.read());
   return comp.read.bind(comp);
 }
 
@@ -767,7 +840,7 @@ function createMemo(compute2, value, options) {
   return () => {
     if (node) {
       resolvedValue = node.wait();
-      if (!node._sources?.length) {
+      if (!node._sources?.length && node._nextSibling?._parent !== node) {
         node.dispose();
         node = void 0;
       } else if (!node._parent && !node._observers?.length) {
@@ -801,7 +874,7 @@ function createAsync(compute2, value, options) {
       if (isPromise) {
         source.then(
           (value3) => {
-            signal.write(value3, 0);
+            signal.write(value3, 0, true);
           },
           (error) => {
             signal.write(error, ERROR_BIT);
@@ -815,7 +888,7 @@ function createAsync(compute2, value, options) {
             for await (let value3 of source) {
               if (abort)
                 return;
-              signal.write(value3, 0);
+              signal.write(value3, 0, true);
             }
           } catch (error) {
             signal.write(error, ERROR_BIT);
@@ -857,7 +930,7 @@ function catchError(fn, handler) {
   const owner = new Owner();
   owner._handlers = owner._handlers ? [handler, ...owner._handlers] : [handler];
   try {
-    compute(owner, fn, null);
+    return compute(owner, fn, null);
   } catch (error) {
     owner.handleError(error);
   }
@@ -1441,4 +1514,4 @@ function compare(key, a, b) {
   return key ? key(a) === key(b) : true;
 }
 
-export { $PROXY, $RAW, $TARGET, $TRACK, Computation, ContextNotFoundError, NoOwnerError, NotReadyError, Owner, Queue, SUPPORTS_PROXY, catchError, createAsync, createBoundary, createContext, createEffect, createMemo, createProjection, createRenderEffect, createRoot, createSignal, createStore, createSuspense, flushSync, getContext, getObserver, getOwner, hasContext, hasUpdated, isEqual, isPending, isWrappable, latest, mapArray, merge, omit, onCleanup, reconcile, runWithOwner, setContext, untrack, unwrap };
+export { $PROXY, $RAW, $TARGET, $TRACK, Computation, ContextNotFoundError, NoOwnerError, NotReadyError, Owner, Queue, SUPPORTS_PROXY, catchError, createAsync, createBoundary, createContext, createEffect, createMemo, createProjection, createRenderEffect, createRoot, createSignal, createStore, createSuspense, flatten, flushSync, getContext, getObserver, getOwner, hasContext, hasUpdated, isEqual, isPending, isWrappable, latest, mapArray, merge, omit, onCleanup, reconcile, runWithOwner, setContext, untrack, unwrap };