@solidjs/signals 0.4.11 → 0.6.0

package/dist/dev.js

@@ -269,11 +269,33 @@ var Transition = class _Transition {
     }
     ActiveTransition = this;
     try {
-      const result = fn();
-      const transition2 = ActiveTransition;
+      let result = fn();
+      let transition2 = ActiveTransition;
+      if (result?.next) {
+        (async function() {
+          let temp, value;
+          while (!(temp = result.next(value)).done) {
+            if (temp.value instanceof Promise) {
+              transition2._promises.add(temp.value);
+              try {
+                value = await temp.value;
+              } finally {
+                while (transition2._done instanceof _Transition)
+                  transition2 = transition2._done;
+                transition2._promises.delete(temp.value);
+              }
+              ActiveTransition = transition2;
+            } else
+              value = temp.value;
+          }
+          finishTransition(transition2);
+        })();
+      }
       if (result instanceof Promise) {
         transition2._promises.add(result);
         result.finally(() => {
+          while (transition2._done instanceof _Transition)
+            transition2 = transition2._done;
           transition2._promises.delete(result);
           finishTransition(transition2);
         });
@@ -1155,18 +1177,152 @@ function runTop(node) {
   }
 }
 
+// src/store/reconcile.ts
+function unwrap(value) {
+  return value?.[$TARGET]?.[STORE_NODE] ?? value;
+}
+function getOverrideValue(value, override, key) {
+  return override && key in override ? override[key] : value[key];
+}
+function getAllKeys(value, override, next) {
+  const keys = getKeys(value, override);
+  const nextKeys = Object.keys(next);
+  return Array.from(/* @__PURE__ */ new Set([...keys, ...nextKeys]));
+}
+function applyState(next, state, keyFn, all) {
+  const target = state?.[$TARGET];
+  if (!target)
+    return;
+  const previous = target[STORE_VALUE];
+  const override = target[STORE_OVERRIDE];
+  if (next === previous && !override)
+    return;
+  (target[STORE_LOOKUP] || storeLookup).set(next, target[$PROXY]);
+  target[STORE_VALUE] = next;
+  target[STORE_OVERRIDE] = void 0;
+  if (Array.isArray(previous)) {
+    let changed = false;
+    const prevLength = getOverrideValue(previous, override, "length");
+    if (next.length && prevLength && next[0] && keyFn(next[0]) != null) {
+      let i, j, start, end, newEnd, item, newIndicesNext, keyVal;
+      for (start = 0, end = Math.min(prevLength, next.length); start < end && ((item = getOverrideValue(previous, override, start)) === next[start] || item && next[start] && keyFn(item) === keyFn(next[start])); start++) {
+        applyState(next[start], wrap(item, target), keyFn, all);
+      }
+      const temp = new Array(next.length), newIndices = /* @__PURE__ */ new Map();
+      for (end = prevLength - 1, newEnd = next.length - 1; end >= start && newEnd >= start && ((item = getOverrideValue(previous, override, end)) === next[newEnd] || item && next[newEnd] && keyFn(item) === keyFn(next[newEnd])); end--, newEnd--) {
+        temp[newEnd] = item;
+      }
+      if (start > newEnd || start > end) {
+        for (j = start; j <= newEnd; j++) {
+          changed = true;
+          target[STORE_NODE][j]?.write(wrap(next[j], target));
+        }
+        for (; j < next.length; j++) {
+          changed = true;
+          const wrapped = wrap(temp[j], target);
+          target[STORE_NODE][j]?.write(wrapped);
+          applyState(next[j], wrapped, keyFn, all);
+        }
+        changed && target[STORE_NODE][$TRACK]?.write(void 0);
+        prevLength !== next.length && target[STORE_NODE].length?.write(next.length);
+        return;
+      }
+      newIndicesNext = new Array(newEnd + 1);
+      for (j = newEnd; j >= start; j--) {
+        item = next[j];
+        keyVal = item ? keyFn(item) : item;
+        i = newIndices.get(keyVal);
+        newIndicesNext[j] = i === void 0 ? -1 : i;
+        newIndices.set(keyVal, j);
+      }
+      for (i = start; i <= end; i++) {
+        item = getOverrideValue(previous, override, i);
+        keyVal = item ? keyFn(item) : item;
+        j = newIndices.get(keyVal);
+        if (j !== void 0 && j !== -1) {
+          temp[j] = item;
+          j = newIndicesNext[j];
+          newIndices.set(keyVal, j);
+        }
+      }
+      for (j = start; j < next.length; j++) {
+        if (j in temp) {
+          const wrapped = wrap(temp[j], target);
+          target[STORE_NODE][j]?.write(wrapped);
+          applyState(next[j], wrapped, keyFn, all);
+        } else
+          target[STORE_NODE][j]?.write(wrap(next[j], target));
+      }
+      if (start < next.length)
+        changed = true;
+    } else if (prevLength && next.length) {
+      for (let i = 0, len = next.length; i < len; i++) {
+        const item = getOverrideValue(previous, override, i);
+        isWrappable(item) && applyState(next[i], wrap(item, target), keyFn, all);
+      }
+    }
+    if (prevLength !== next.length) {
+      changed = true;
+      target[STORE_NODE].length?.write(next.length);
+    }
+    changed && target[STORE_NODE][$TRACK]?.write(void 0);
+    return;
+  }
+  let nodes = target[STORE_NODE];
+  if (nodes) {
+    const tracked = nodes[$TRACK];
+    const keys = tracked || all ? getAllKeys(previous, override, next) : Object.keys(nodes);
+    for (let i = 0, len = keys.length; i < len; i++) {
+      const key = keys[i];
+      const node = nodes[key];
+      const previousValue = unwrap(getOverrideValue(previous, override, key));
+      let nextValue = unwrap(next[key]);
+      if (previousValue === nextValue)
+        continue;
+      if (!previousValue || !isWrappable(previousValue) || keyFn(previousValue) != null && keyFn(previousValue) !== keyFn(nextValue)) {
+        tracked?.write(void 0);
+        node?.write(isWrappable(nextValue) ? wrap(nextValue, target) : nextValue);
+      } else
+        applyState(nextValue, wrap(previousValue, target), keyFn, all);
+    }
+  }
+  if (nodes = target[STORE_HAS]) {
+    const keys = Object.keys(nodes);
+    for (let i = 0, len = keys.length; i < len; i++) {
+      nodes[keys[i]].write(keys[i] in next);
+    }
+  }
+}
+function reconcile(value, key, all = false) {
+  return (state) => {
+    if (state == null)
+      throw new Error("Cannot reconcile null or undefined state");
+    const keyFn = typeof key === "string" ? (item) => item[key] : key;
+    const eq = keyFn(state);
+    if (eq !== void 0 && keyFn(value) !== keyFn(state))
+      throw new Error("Cannot reconcile states with different identity");
+    applyState(value, state, keyFn, all);
+  };
+}
+
 // src/store/projection.ts
-function createProjection(fn, initialValue = {}) {
+function createProjection(fn, initialValue = {}, options) {
   let wrappedStore;
   const node = new FirewallComputation(() => {
-    storeSetter(wrappedStore, fn);
+    storeSetter(wrappedStore, (s) => {
+      const value = fn(s);
+      if (value !== s && value !== void 0) {
+        reconcile(value, options?.key || "id", options?.all)(s);
+      }
+    });
   });
   const wrappedMap = /* @__PURE__ */ new WeakMap();
   const traps = {
     ...storeTraps,
     get(target, property, receiver) {
       const o = getOwner();
-      (!o || o !== node) && node.wait();
+      const n = getTransitionSource(node);
+      (!o || o !== n) && n.wait();
       return storeTraps.get(target, property, receiver);
     }
   };
@@ -1387,14 +1543,29 @@ function storeSetter(store, fn) {
   Writing = /* @__PURE__ */ new Set();
   Writing.add(store);
   try {
-    fn(store);
+    const value = fn(store);
+    if (value !== store && value !== void 0) {
+      if (Array.isArray(value)) {
+        for (let i = 0, len = value.length; i < len; i++)
+          store[i] = value[i];
+        store.length = value.length;
+      } else {
+        const keys = /* @__PURE__ */ new Set([...Object.keys(store), ...Object.keys(value)]);
+        keys.forEach((key) => {
+          if (key in value)
+            store[key] = value[key];
+          else
+            delete store[key];
+        });
+      }
+    }
   } finally {
     Writing.clear();
     Writing = prevWriting;
   }
 }
-function createStore(first, second) {
-  const derived = typeof first === "function", wrappedStore = derived ? createProjection(first, second) : wrap(first);
+function createStore(first, second, options) {
+  const derived = typeof first === "function", wrappedStore = derived ? createProjection(first, second, options) : wrap(first);
   return [wrappedStore, (fn) => storeSetter(wrappedStore, fn)];
 }
 function recursivelyNotify(state, lookup) {
@@ -1458,134 +1629,6 @@ function deep(store) {
   return store[$DEEP];
 }
 
-// src/store/reconcile.ts
-function unwrap(value) {
-  return value?.[$TARGET]?.[STORE_NODE] ?? value;
-}
-function getOverrideValue(value, override, key) {
-  return override && key in override ? override[key] : value[key];
-}
-function getAllKeys(value, override, next) {
-  const keys = getKeys(value, override);
-  const nextKeys = Object.keys(next);
-  return Array.from(/* @__PURE__ */ new Set([...keys, ...nextKeys]));
-}
-function applyState(next, state, keyFn, all) {
-  const target = state?.[$TARGET];
-  if (!target)
-    return;
-  const previous = target[STORE_VALUE];
-  const override = target[STORE_OVERRIDE];
-  if (next === previous && !override)
-    return;
-  (target[STORE_LOOKUP] || storeLookup).set(next, target[$PROXY]);
-  target[STORE_VALUE] = next;
-  target[STORE_OVERRIDE] = void 0;
-  if (Array.isArray(previous)) {
-    let changed = false;
-    const prevLength = getOverrideValue(previous, override, "length");
-    if (next.length && prevLength && next[0] && keyFn(next[0]) != null) {
-      let i, j, start, end, newEnd, item, newIndicesNext, keyVal;
-      for (start = 0, end = Math.min(prevLength, next.length); start < end && ((item = getOverrideValue(previous, override, start)) === next[start] || item && next[start] && keyFn(item) === keyFn(next[start])); start++) {
-        applyState(next[start], wrap(item, target), keyFn, all);
-      }
-      const temp = new Array(next.length), newIndices = /* @__PURE__ */ new Map();
-      for (end = prevLength - 1, newEnd = next.length - 1; end >= start && newEnd >= start && ((item = getOverrideValue(previous, override, end)) === next[newEnd] || item && next[newEnd] && keyFn(item) === keyFn(next[newEnd])); end--, newEnd--) {
-        temp[newEnd] = item;
-      }
-      if (start > newEnd || start > end) {
-        for (j = start; j <= newEnd; j++) {
-          changed = true;
-          target[STORE_NODE][j]?.write(wrap(next[j], target));
-        }
-        for (; j < next.length; j++) {
-          changed = true;
-          const wrapped = wrap(temp[j], target);
-          target[STORE_NODE][j]?.write(wrapped);
-          applyState(next[j], wrapped, keyFn, all);
-        }
-        changed && target[STORE_NODE][$TRACK]?.write(void 0);
-        prevLength !== next.length && target[STORE_NODE].length?.write(next.length);
-        return;
-      }
-      newIndicesNext = new Array(newEnd + 1);
-      for (j = newEnd; j >= start; j--) {
-        item = next[j];
-        keyVal = item ? keyFn(item) : item;
-        i = newIndices.get(keyVal);
-        newIndicesNext[j] = i === void 0 ? -1 : i;
-        newIndices.set(keyVal, j);
-      }
-      for (i = start; i <= end; i++) {
-        item = getOverrideValue(previous, override, i);
-        keyVal = item ? keyFn(item) : item;
-        j = newIndices.get(keyVal);
-        if (j !== void 0 && j !== -1) {
-          temp[j] = item;
-          j = newIndicesNext[j];
-          newIndices.set(keyVal, j);
-        }
-      }
-      for (j = start; j < next.length; j++) {
-        if (j in temp) {
-          const wrapped = wrap(temp[j], target);
-          target[STORE_NODE][j]?.write(wrapped);
-          applyState(next[j], wrapped, keyFn, all);
-        } else
-          target[STORE_NODE][j]?.write(wrap(next[j], target));
-      }
-      if (start < next.length)
-        changed = true;
-    } else if (prevLength && next.length) {
-      for (let i = 0, len = next.length; i < len; i++) {
-        const item = getOverrideValue(previous, override, i);
-        isWrappable(item) && applyState(next[i], wrap(item, target), keyFn, all);
-      }
-    }
-    if (prevLength !== next.length) {
-      changed = true;
-      target[STORE_NODE].length?.write(next.length);
-    }
-    changed && target[STORE_NODE][$TRACK]?.write(void 0);
-    return;
-  }
-  let nodes = target[STORE_NODE];
-  if (nodes) {
-    const tracked = nodes[$TRACK];
-    const keys = tracked || all ? getAllKeys(previous, override, next) : Object.keys(nodes);
-    for (let i = 0, len = keys.length; i < len; i++) {
-      const key = keys[i];
-      const node = nodes[key];
-      const previousValue = unwrap(getOverrideValue(previous, override, key));
-      let nextValue = unwrap(next[key]);
-      if (previousValue === nextValue)
-        continue;
-      if (!previousValue || !isWrappable(previousValue) || keyFn(previousValue) != null && keyFn(previousValue) !== keyFn(nextValue)) {
-        tracked?.write(void 0);
-        node?.write(isWrappable(nextValue) ? wrap(nextValue, target) : nextValue);
-      } else
-        applyState(nextValue, wrap(previousValue, target), keyFn, all);
-    }
-  }
-  if (nodes = target[STORE_HAS]) {
-    const keys = Object.keys(nodes);
-    for (let i = 0, len = keys.length; i < len; i++) {
-      nodes[keys[i]].write(keys[i] in next);
-    }
-  }
-}
-function reconcile(value, key, all = false) {
-  return (state) => {
-    if (state == null)
-      throw new Error("Cannot reconcile null or undefined state");
-    const keyFn = typeof key === "string" ? (item) => item[key] : key;
-    const eq = keyFn(state);
-    if (eq !== void 0 && keyFn(value) !== keyFn(state))
-      throw new Error("Cannot reconcile states with different identity");
-    applyState(value, state, keyFn, all);
-  };
-}
-
 // src/store/utils.ts
 function snapshot(item, map, lookup) {
   let target, isArray, override, result, unwrapped, v;
@@ -1844,14 +1887,16 @@ function createAsync(compute2, value, options) {
       }
       let abort = false;
       onCleanup(() => abort = true);
-      const transition2 = ActiveTransition;
+      let transition2 = ActiveTransition;
       if (isPromise) {
         source.then(
           (value3) => {
             if (abort)
               return;
             if (transition2)
-              return transition2.runTransition(() => node.write(value3, 0, true), true);
+              return transition2.runTransition(() => {
+                node.write(value3, 0, true);
+              }, true);
             node.write(value3, 0, true);
           },
           (error) => {
@@ -1868,12 +1913,22 @@ function createAsync(compute2, value, options) {
             for await (let value3 of source) {
               if (abort)
                 return;
+              if (transition2)
+                return transition2.runTransition(() => {
+                  node.write(value3, 0, true);
+                  transition2 = null;
+                }, true);
               node.write(value3, 0, true);
             }
           } catch (error) {
             if (abort)
               return;
-            node.write(error, ERROR_BIT);
+            if (transition2)
+              return transition2.runTransition(() => {
+                node._setError(error);
+                transition2 = null;
+              }, true);
+            node._setError(error);
           }
         })();
       }
@@ -1931,70 +1986,56 @@ function resolve(fn) {
     });
   });
 }
-function tryCatch(fn) {
-  try {
-    const v = fn();
-    if (v instanceof Promise) {
-      return v.then(
-        (v2) => [void 0, v2],
-        (e) => {
-          if (e instanceof NotReadyError)
-            throw e;
-          return [e];
-        }
-      );
-    }
-    return [void 0, v];
-  } catch (e) {
-    if (e instanceof NotReadyError)
-      throw e;
-    return [e];
+function createPending() {
+  const node = new Computation(false, null);
+  const reset = () => node.write(false);
+  function write(v) {
+    if (!ActiveTransition)
+      return v;
+    ActiveTransition.addOptimistic(reset);
+    queueMicrotask(() => reset._transition && node.write(v));
+  }
+  function read() {
+    node.read();
+    return !ActiveTransition;
   }
+  return [read, write];
 }
-function createOptimistic(initial, compute2, key) {
-  if (!compute2) {
-    let write2 = function(v) {
-      if (!ActiveTransition)
-        throw new Error("createOptimistic can only be updated inside a transition");
-      ActiveTransition.addOptimistic(reset2);
-      queueMicrotask(() => reset2._transition && node.write(v));
-    };
-    var write = write2;
-    const node = new Computation(initial, null);
-    const reset2 = () => node.write(initial);
-    return [node.read.bind(node), write2];
+function useTransition() {
+  const [pending, setPending] = createPending();
+  function start(fn) {
+    transition((resume) => {
+      setPending(true);
+      return fn(resume);
+    });
   }
+  return [pending, start];
+}
+function createOptimistic(first, second, options) {
   let store, setStore;
-  if (typeof initial === "function") {
-    [store, setStore] = createStore(
-      (s) => {
-        const value = initial();
-        if (!ActiveTransition)
-          reconcile({ value }, key)(s);
-      },
-      { value: void 0 }
-    );
+  if (typeof first === "function") {
+    [store, setStore] = createStore((s) => {
+      const value = first(s);
+      if (!ActiveTransition)
+        return value;
+      ActiveTransition.addOptimistic(reset);
+    }, {});
   } else
-    [store, setStore] = createStore({ value: initial });
+    [store, setStore] = createStore(first);
   const reset = () => setStore(
     (s) => reconcile(
-      { value: typeof initial === "function" ? initial() : initial },
-      key
+      { value: typeof first === "function" ? first(second) : first },
+      options?.key || "id",
+      options?.all
     )(s)
   );
-  let lastChange = void 0;
   function write(v) {
     if (!ActiveTransition)
       throw new Error("createOptimistic can only be updated inside a transition");
     ActiveTransition.addOptimistic(reset);
-    queueMicrotask(
-      () => reset._transition && setStore((s) => {
-        lastChange = typeof v === "function" ? v(lastChange) : v;
-        compute2(s.value, lastChange);
-      })
-    );
+    queueMicrotask(() => reset._transition && setStore(v));
   }
-  return [() => store.value, write];
+  return [store, write];
 }
 
 // src/map.ts
@@ -2404,4 +2445,4 @@ function flattenArray(children, results = [], options) {
   return needsUnwrap;
 }
 
-export { $PROXY, $TARGET, $TRACK, Computation, ContextNotFoundError, NoOwnerError, NotReadyError, Owner, Queue, SUPPORTS_PROXY, createAsync, createBoundary, createContext, createEffect, createErrorBoundary, createMemo, createOptimistic, createProjection, createRenderEffect, createRoot, createSignal, createStore, createSuspense, deep, flatten, flush, getContext, getObserver, getOwner, hasContext, hasUpdated, isEqual, isPending, isWrappable, latest, mapArray, merge, omit, onCleanup, reconcile, repeat, resolve, runWithObserver, runWithOwner, setContext, snapshot, transition, tryCatch, untrack };
+export { $PROXY, $TARGET, $TRACK, Computation, ContextNotFoundError, NoOwnerError, NotReadyError, Owner, Queue, SUPPORTS_PROXY, createAsync, createBoundary, createContext, createEffect, createErrorBoundary, createMemo, createOptimistic, createProjection, createRenderEffect, createRoot, createSignal, createStore, createSuspense, deep, flatten, flush, getContext, getObserver, getOwner, hasContext, hasUpdated, isEqual, isPending, isWrappable, latest, mapArray, merge, omit, onCleanup, reconcile, repeat, resolve, runWithObserver, runWithOwner, setContext, snapshot, transition, untrack, useTransition };