@solidjs/signals 0.0.2 → 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" } 
   });
@@ -852,15 +873,22 @@ var STORE_NODE = "n";
 var STORE_HAS = "h";
 function wrap(value) {
   let p = value[$PROXY];
-  if (!p)
+  if (!p) {
+    let target;
+    if (Array.isArray(value)) {
+      target = [];
+      target.v = value;
+    } else
+      target = { v: value };
     Object.defineProperty(value, $PROXY, {
-      value: p = new Proxy({ v: value }, proxyTraps),
+      value: p = new Proxy(target, proxyTraps),
       writable: true
     });
+  }
   return p;
 }
 function isWrappable(obj) {
-  return obj != null && typeof obj === "object";
+  return obj != null && typeof obj === "object" && !Object.isFrozen(obj);
 }
 function unwrap(item, deep = true, set) {
   let result, unwrapped, v, prop;
@@ -912,8 +940,10 @@ function getNode(nodes, property, value, equals = isEqual) {
   });
 }
 function proxyDescriptor(target, property) {
+  if (property === $PROXY)
+    return { value: target[$PROXY], writable: true, configurable: true };
   const desc = Reflect.getOwnPropertyDescriptor(target[STORE_VALUE], property);
-  if (!desc || desc.get || !desc.configurable || property === $PROXY)
+  if (!desc || desc.get || !desc.configurable)
     return desc;
   delete desc.value;
   delete desc.writable;
@@ -979,7 +1009,10 @@ var proxyTraps = {
     return true;
   },
   ownKeys,
-  getOwnPropertyDescriptor: proxyDescriptor
+  getOwnPropertyDescriptor: proxyDescriptor,
+  getPrototypeOf(target) {
+    return Object.getPrototypeOf(target[STORE_VALUE]);
+  }
 };
 function setProperty(state, property, value, deleting = false) {
   const prev = state[property];
@@ -1133,6 +1166,7 @@ function reconcile(value, key) {
     if (keyFn(value) !== keyFn(state))
       throw new Error("Cannot reconcile states with different identity");
     applyState(value, state, keyFn);
+    return state;
   };
 }
 
@@ -1287,24 +1321,19 @@ function omit(props, ...keys) {
 // src/map.ts
 function mapArray(list, map, options) {
   const keyFn = typeof options?.keyed === "function" ? options.keyed : void 0;
-  return Computation.prototype.read.bind(
-    new Computation(
-      [],
-      updateKeyedMap.bind({
-        _owner: new Owner(),
-        _len: 0,
-        _list: list,
-        _items: [],
-        _map: map,
-        _mappings: [],
-        _nodes: [],
-        _key: keyFn,
-        _rows: keyFn || options?.keyed === false ? [] : void 0,
-        _indexes: map.length > 1 ? [] : void 0
-      }),
-      options
-    )
-  );
+  return updateKeyedMap.bind({
+    _owner: new Owner(),
+    _len: 0,
+    _list: list,
+    _items: [],
+    _map: map,
+    _mappings: [],
+    _nodes: [],
+    _key: keyFn,
+    _rows: keyFn || options?.keyed === false ? [] : void 0,
+    _indexes: map.length > 1 ? [] : void 0,
+    _fallback: options?.fallback
+  });
 }
 function updateKeyedMap() {
   const newItems = this._list() || [], newLen = newItems.length;
@@ -1335,7 +1364,16 @@ function updateKeyedMap() {
         this._rows && (this._rows = []);
         this._indexes && (this._indexes = []);
       }
+      if (this._fallback && !this._mappings[0]) {
+        this._mappings[0] = compute(
+          this._nodes[0] = new Owner(),
+          this._fallback,
+          null
+        );
+      }
     } else if (this._len === 0) {
+      if (this._nodes[0])
+        this._nodes[0].dispose();
       this._mappings = new Array(newLen);
       for (j = 0; j < newLen; j++) {
         this._items[j] = newItems[j];
@@ -1403,4 +1441,4 @@ function compare(key, a, b) {
   return key ? key(a) === key(b) : true;
 }
 
-export { $PROXY, $RAW, $TARGET, $TRACK, Computation, ContextNotFoundError, NoOwnerError, NotReadyError, Owner, Queue, 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, flushSync, getContext, getObserver, getOwner, hasContext, hasUpdated, isEqual, isPending, isWrappable, latest, mapArray, merge, omit, onCleanup, reconcile, runWithOwner, setContext, untrack, unwrap };