@solidjs/signals 0.4.11 → 0.5.0

package/dist/dev.js

@@ -1387,7 +1387,22 @@ 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;
@@ -1951,48 +1966,33 @@ function tryCatch(fn) {
     return [e];
   }
 }
-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 createOptimistic(initial) {
+  const node = new Computation(initial, null);
+  const reset = () => node.write(initial);
+  function write(v) {
+    if (!ActiveTransition)
+      throw new Error("createOptimistic can only be updated inside a transition");
+    ActiveTransition.addOptimistic(reset);
+    queueMicrotask(() => reset._transition && node.write(v));
   }
+  return [node.read.bind(node), write];
+}
+function createOptimisticStore(first, second) {
   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;
+    }, {});
   } else
-    [store, setStore] = createStore({ value: initial });
-  const reset = () => setStore(
-    (s) => reconcile(
-      { value: typeof initial === "function" ? initial() : initial },
-      key
-    )(s)
-  );
-  let lastChange = void 0;
+    [store, setStore] = createStore(first);
+  const reset = () => setStore(() => typeof first === "function" ? first(second) : first);
   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];
 }
@@ -2404,4 +2404,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, createOptimisticStore, 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 };

package/dist/node.cjs

@@ -1385,7 +1385,22 @@ 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;
@@ -1954,48 +1969,33 @@ function tryCatch(fn) {
     return [e];
   }
 }
-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.j && node.write(v));
-    };
-    var write = write2;
-    const node = new Computation(initial, null);
-    const reset2 = () => node.write(initial);
-    return [node.read.bind(node), write2];
+function createOptimistic(initial) {
+  const node = new Computation(initial, null);
+  const reset = () => node.write(initial);
+  function write(v) {
+    if (!ActiveTransition)
+      throw new Error("createOptimistic can only be updated inside a transition");
+    ActiveTransition.addOptimistic(reset);
+    queueMicrotask(() => reset.j && node.write(v));
   }
+  return [node.read.bind(node), write];
+}
+function createOptimisticStore(first, second) {
   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;
+    }, {});
   } else
-    [store, setStore] = createStore({ value: initial });
-  const reset = () => setStore(
-    (s) => reconcile(
-      { value: typeof initial === "function" ? initial() : initial },
-      key
-    )(s)
-  );
-  let lastChange = void 0;
+    [store, setStore] = createStore(first);
+  const reset = () => setStore(() => typeof first === "function" ? first(second) : first);
   function write(v) {
     if (!ActiveTransition)
       throw new Error("createOptimistic can only be updated inside a transition");
     ActiveTransition.addOptimistic(reset);
-    queueMicrotask(
-      () => reset.j && setStore((s) => {
-        lastChange = typeof v === "function" ? v(lastChange) : v;
-        compute2(s.value, lastChange);
-      })
-    );
+    queueMicrotask(() => reset.j && setStore(v));
   }
   return [() => store.value, write];
 }
@@ -2426,6 +2426,7 @@ exports.createEffect = createEffect;
 exports.createErrorBoundary = createErrorBoundary;
 exports.createMemo = createMemo;
 exports.createOptimistic = createOptimistic;
+exports.createOptimisticStore = createOptimisticStore;
 exports.createProjection = createProjection;
 exports.createRenderEffect = createRenderEffect;
 exports.createRoot = createRoot;

package/dist/prod.js

@@ -1375,7 +1375,22 @@ 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;
@@ -1939,48 +1954,33 @@ function tryCatch(fn) {
     return [e];
   }
 }
-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.j && node.write(v));
-    };
-    var write = write2;
-    const node = new Computation(initial, null);
-    const reset2 = () => node.write(initial);
-    return [node.read.bind(node), write2];
+function createOptimistic(initial) {
+  const node = new Computation(initial, null);
+  const reset = () => node.write(initial);
+  function write(v) {
+    if (!ActiveTransition)
+      throw new Error("createOptimistic can only be updated inside a transition");
+    ActiveTransition.addOptimistic(reset);
+    queueMicrotask(() => reset.j && node.write(v));
   }
+  return [node.read.bind(node), write];
+}
+function createOptimisticStore(first, second) {
   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;
+    }, {});
   } else
-    [store, setStore] = createStore({ value: initial });
-  const reset = () => setStore(
-    (s) => reconcile(
-      { value: typeof initial === "function" ? initial() : initial },
-      key
-    )(s)
-  );
-  let lastChange = void 0;
+    [store, setStore] = createStore(first);
+  const reset = () => setStore(() => typeof first === "function" ? first(second) : first);
   function write(v) {
     if (!ActiveTransition)
       throw new Error("createOptimistic can only be updated inside a transition");
     ActiveTransition.addOptimistic(reset);
-    queueMicrotask(
-      () => reset.j && setStore((s) => {
-        lastChange = typeof v === "function" ? v(lastChange) : v;
-        compute2(s.value, lastChange);
-      })
-    );
+    queueMicrotask(() => reset.j && setStore(v));
   }
   return [() => store.value, write];
 }
@@ -2392,4 +2392,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, createOptimisticStore, 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 };

package/dist/types/signals.d.ts

@@ -1,5 +1,6 @@
 import type { SignalOptions } from "./core/index.js";
 import { Owner } from "./core/index.js";
+import { type Store, type StoreSetter } from "./store/index.js";
 export type Accessor<T> = () => T;
 export type Setter<in out T> = {
     <U extends T>(...args: undefined extends T ? [] : [value: Exclude<U, Function> | ((prev: T) => U)]): undefined extends T ? undefined : U;
@@ -164,10 +165,18 @@ export declare function tryCatch<T, E = Error>(fn: () => T): TryCatchResult<T, E
  * and then revert it back to the previous value at end of transition.
  *
  * @param initial The initial value of the signal.
- * @param compute An optional function to compute the next value based on the previous value and change.
+ *
+ * @returns A tuple containing an accessor for the current value and a setter function to apply changes.
+ */
+export declare function createOptimistic<T>(initial: Exclude<T, Function>): Signal<T>;
+/**
+ * Creates an optimistic signal that can be used to optimistically update a value
+ * and then revert it back to the previous value at end of transition.
+ *
+ * @param initial The initial value of the signal.
  * @param options Optional signal options.
  *
  * @returns A tuple containing an accessor for the current value and a setter function to apply changes.
  */
-export declare function createOptimistic<T>(initial: Exclude<T, Function>, compute?: never): [Accessor<T>, (value: T | ((v?: T) => T)) => void];
-export declare function createOptimistic<T extends object, U>(initial: T | Accessor<T>, compute: (prev: T, change: U) => void, key: string | ((item: any) => any)): [Accessor<T>, (value: U | ((v?: U) => U)) => void];
+export declare function createOptimisticStore<T extends object = {}>(initial: T | Store<T>): [get: Store<T>, set: StoreSetter<T>];
+export declare function createOptimisticStore<T extends object = {}>(fn: (store: T) => void, initial: T | Store<T>): [get: Store<T>, set: StoreSetter<T>];

package/dist/types/store/store.d.ts

@@ -1,6 +1,6 @@
 import { Computation } from "../core/index.js";
 export type Store<T> = Readonly<T>;
-export type StoreSetter<T> = (fn: (state: T) => void) => void;
+export type StoreSetter<T> = (fn: (state: T) => T | void) => void;
 type DataNode = Computation<any>;
 type DataNodes = Record<PropertyKey, DataNode>;
 export declare const $TRACK: unique symbol, $DEEP: unique symbol, $TARGET: unique symbol, $PROXY: unique symbol, $DELETED: unique symbol;
@@ -26,7 +26,7 @@ export declare function isWrappable<T>(obj: T | NotWrappable): obj is T;
 export declare function getKeys(source: Record<PropertyKey, any>, override: Record<PropertyKey, any> | undefined, enumerable?: boolean): PropertyKey[];
 export declare function getPropertyDescriptor(source: Record<PropertyKey, any>, override: Record<PropertyKey, any> | undefined, property: PropertyKey): PropertyDescriptor | undefined;
 export declare const storeTraps: ProxyHandler<StoreNode>;
-export declare function storeSetter<T extends object>(store: Store<T>, fn: (draft: T) => void): void;
+export declare function storeSetter<T extends object>(store: Store<T>, fn: (draft: T) => T | void): void;
 export declare function createStore<T extends object = {}>(store: T | Store<T>): [get: Store<T>, set: StoreSetter<T>];
 export declare function createStore<T extends object = {}>(fn: (store: T) => void, store: T | Store<T>): [get: Store<T>, set: StoreSetter<T>];
 export declare function deep<T extends object>(store: Store<T>): Store<any>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidjs/signals",
-  "version": "0.4.11",
+  "version": "0.5.0",
   "description": "",
   "author": "Ryan Carniato",
   "license": "MIT",