@solidjs/signals 0.0.3 → 0.0.5

package/dist/dev.js

@@ -3,34 +3,87 @@ var NotReadyError = class extends Error {
 };
 var NoOwnerError = class extends Error {
   constructor() {
-    super(
-      "No root owner exists at time of call. Make sure `getContext` is called within an owner or create one first via `createRoot`." 
-    );
+    super("Context can only be accessed under a reactive root." );
   }
 };
 var ContextNotFoundError = class extends Error {
   constructor() {
     super(
-      "Must provide either a default context value or set one via `setContext` before getting." 
+      "Context must either be created with a default value or a value must be provided before accessing it." 
     );
   }
 };
 
-// src/utils.ts
-function isUndefined(value) {
-  return typeof value === "undefined";
-}
-
 // src/core/constants.ts
 var STATE_CLEAN = 0;
 var STATE_CHECK = 1;
 var STATE_DIRTY = 2;
-var STATE_DISPOSED = 3;
+var STATE_UNINITIALIZED = 3;
+var STATE_DISPOSED = 4;
 var EFFECT_PURE = 0;
 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 = {};
@@ -156,17 +209,18 @@ function setContext(context, value, owner = currentOwner) {
 function hasContext(context, owner = currentOwner) {
   return !isUndefined(owner?._context[context.id]);
 }
-function onCleanup(disposable) {
+function onCleanup(fn) {
   if (!currentOwner)
-    return;
+    return fn;
   const node = currentOwner;
   if (!node._disposal) {
-    node._disposal = disposable;
+    node._disposal = fn;
   } else if (Array.isArray(node._disposal)) {
-    node._disposal.push(disposable);
+    node._disposal.push(fn);
   } else {
-    node._disposal = [node._disposal, disposable];
+    node._disposal = [node._disposal, fn];
   }
+  return fn;
 }
 
 // src/core/flags.ts
@@ -213,7 +267,7 @@ var Computation = class extends Owner {
   constructor(initialValue, compute2, options) {
     super(compute2 === null);
     this._compute = compute2;
-    this._state = compute2 ? STATE_DIRTY : STATE_CLEAN;
+    this._state = compute2 ? STATE_UNINITIALIZED : STATE_CLEAN;
     this._value = initialValue;
     this._name = options?.name ?? (this._compute ? "computed" : "signal");
     if (options?.equals !== void 0)
@@ -224,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) {
@@ -279,7 +333,7 @@ var Computation = class extends Owner {
   /** Update the computation with a new value. */
   write(value, flags = 0, raw = false) {
     const newValue = !raw && typeof value === "function" ? value(this._value) : value;
-    const valueChanged = newValue !== UNCHANGED && (!!(flags & ERROR_BIT) || this._equals === false || !this._equals(this._value, newValue));
+    const valueChanged = newValue !== UNCHANGED && (!!(flags & ERROR_BIT) || this._state === STATE_UNINITIALIZED || this._equals === false || !this._equals(this._value, newValue));
     if (valueChanged)
       this._value = newValue;
     const changedFlagsMask = this._stateFlags ^ flags, changedFlags = changedFlagsMask & flags;
@@ -364,7 +418,7 @@ var Computation = class extends Owner {
         }
       }
     }
-    if (this._state === STATE_DIRTY) {
+    if (this._state === STATE_DIRTY || this._state === STATE_UNINITIALIZED) {
       update(this);
     } else {
       this.write(UNCHANGED, observerFlags);
@@ -544,7 +598,8 @@ function schedule() {
   if (scheduled)
     return;
   scheduled = true;
-  queueMicrotask(flushSync);
+  if (!globalQueue._running)
+    queueMicrotask(flushSync);
 }
 var Queue = class {
   _running = false;
@@ -578,6 +633,7 @@ var Queue = class {
     try {
       this.run(EFFECT_PURE);
       incrementClock();
+      scheduled = false;
       this.run(EFFECT_RENDER);
       this.run(EFFECT_USER);
     } finally {
@@ -594,9 +650,21 @@ var Queue = class {
   }
 };
 var globalQueue = new Queue();
+var globalTasks = [];
 function flushSync() {
-  globalQueue.flush();
-  scheduled = false;
+  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();
@@ -643,11 +711,13 @@ var Effect = class extends Computation {
     this._queue = getOwner()?._queue || globalQueue;
     this._updateIfNecessary();
     this._type === EFFECT_USER ? this._queue.enqueue(this._type, this) : this._runEffect();
+    if (!this._parent)
+      console.warn("Effects created outside a reactive context will never be disposed");
   }
   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)
@@ -685,6 +755,8 @@ var EagerComputation = class extends Computation {
     super(initialValue, compute2, options);
     this._queue = getOwner()?._queue || globalQueue;
     this._updateIfNecessary();
+    if (!this._parent)
+      console.warn("Eager Computations created outside a reactive context will never be disposed");
   }
   _notify(state) {
     if (this._state >= state)
@@ -710,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);
 }
 
@@ -745,14 +830,35 @@ function createSignal(first, second, third) {
   const node = new Computation(first, null, second);
   return [node.read.bind(node), node.write.bind(node)];
 }
-function createAsync(fn, initial, options) {
+function createMemo(compute2, value, options) {
+  let node = new Computation(
+    value,
+    compute2,
+    options
+  );
+  let resolvedValue;
+  return () => {
+    if (node) {
+      resolvedValue = node.wait();
+      if (!node._sources?.length && node._nextSibling?._parent !== node) {
+        node.dispose();
+        node = void 0;
+      } else if (!node._parent && !node._observers?.length) {
+        node.dispose();
+        node._state = STATE_UNINITIALIZED;
+      }
+    }
+    return resolvedValue;
+  };
+}
+function createAsync(compute2, value, options) {
   const lhs = new EagerComputation(
     {
-      _value: initial
+      _value: value
     },
     (p) => {
-      const value = p?._value;
-      const source = fn(value);
+      const value2 = p?._value;
+      const source = compute2(value2);
       const isPromise = source instanceof Promise;
       const iterator = source[Symbol.asyncIterator];
       if (!isPromise && !iterator) {
@@ -763,12 +869,12 @@ function createAsync(fn, initial, options) {
           _value: source
         };
       }
-      const signal = new Computation(value, null, options);
+      const signal = new Computation(value2, null, options);
       signal.write(UNCHANGED, LOADING_BIT);
       if (isPromise) {
         source.then(
-          (value2) => {
-            signal.write(value2, 0);
+          (value3) => {
+            signal.write(value3, 0, true);
           },
           (error) => {
             signal.write(error, ERROR_BIT);
@@ -779,10 +885,10 @@ function createAsync(fn, initial, options) {
         onCleanup(() => abort = true);
         (async () => {
           try {
-            for await (let value2 of source) {
+            for await (let value3 of source) {
               if (abort)
                 return;
-              signal.write(value2, 0);
+              signal.write(value3, 0, true);
             }
           } catch (error) {
             signal.write(error, ERROR_BIT);
@@ -794,28 +900,16 @@ function createAsync(fn, initial, options) {
   );
   return () => lhs.wait().wait();
 }
-function createMemo(compute2, initialValue, options) {
-  let node = new Computation(initialValue, compute2, options);
-  let value;
-  return () => {
-    if (node) {
-      value = node.wait();
-      if (!node._sources?.length)
-        node = void 0;
-    }
-    return value;
-  };
-}
-function createEffect(compute2, effect, initialValue, options) {
+function createEffect(compute2, effect, value, options) {
   void new Effect(
-    initialValue,
+    value,
     compute2,
     effect,
     { name: options?.name ?? "effect" } 
   );
 }
-function createRenderEffect(compute2, effect, initialValue, options) {
-  void new Effect(initialValue, compute2, effect, {
+function createRenderEffect(compute2, effect, value, options) {
+  void new Effect(value, compute2, effect, {
     render: true,
     ...{ name: options?.name ?? "effect" } 
   });
@@ -836,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);
   }
@@ -1344,7 +1438,11 @@ function updateKeyedMap() {
         this._indexes && (this._indexes = []);
       }
       if (this._fallback && !this._mappings[0]) {
-        this._mappings[0] = compute(this._nodes[0] = new Owner(), this._fallback, null);
+        this._mappings[0] = compute(
+          this._nodes[0] = new Owner(),
+          this._fallback,
+          null
+        );
       }
     } else if (this._len === 0) {
       if (this._nodes[0])
@@ -1416,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 };