@solidjs/signals 0.0.3 → 0.0.4

package/dist/dev.js

@@ -4,14 +4,14 @@ 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`." 
+      "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." 
     );
   }
 };
@@ -25,7 +25,8 @@ function isUndefined(value) {
 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;
@@ -156,17 +157,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 +215,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)
@@ -279,7 +281,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 +366,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 +546,8 @@ function schedule() {
   if (scheduled)
     return;
   scheduled = true;
-  queueMicrotask(flushSync);
+  if (!globalQueue._running)
+    queueMicrotask(flushSync);
 }
 var Queue = class {
   _running = false;
@@ -578,6 +581,7 @@ var Queue = class {
     try {
       this.run(EFFECT_PURE);
       incrementClock();
+      scheduled = false;
       this.run(EFFECT_RENDER);
       this.run(EFFECT_USER);
     } finally {
@@ -595,8 +599,12 @@ var Queue = class {
 };
 var globalQueue = new Queue();
 function flushSync() {
-  globalQueue.flush();
-  scheduled = false;
+  let count = 0;
+  while (scheduled) {
+    if (++count === 1e5)
+      throw new Error("Potential Infinite Loop Detected.");
+    globalQueue.flush();
+  }
 }
 function createBoundary(fn, queue) {
   const owner = new Owner();
@@ -643,6 +651,8 @@ 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;
@@ -685,6 +695,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)
@@ -745,14 +757,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.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 +796,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);
           },
           (error) => {
             signal.write(error, ERROR_BIT);
@@ -779,10 +812,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);
             }
           } catch (error) {
             signal.write(error, ERROR_BIT);
@@ -794,28 +827,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" } 
   });
@@ -1344,7 +1365,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])