@solidjs/signals 0.9.2 → 0.9.3

package/dist/prod.js

@@ -32,6 +32,7 @@ const EFFECT_USER = 2;
 const NOT_PENDING = {};
 const SUPPORTS_PROXY = typeof Proxy === "function";
 const defaultContext = {};
+const $REFRESH = Symbol("refresh");
 function actualInsertIntoHeap(e, t) {
   const n = (e.i?.t ? e.i.u?.o : e.i?.o) ?? -1;
   if (n >= e.o) e.o = n + 1;
@@ -138,7 +139,7 @@ let scheduled = false;
 function schedule() {
   if (scheduled) return;
   scheduled = true;
-  if (!globalQueue.k) queueMicrotask(flush);
+  if (!globalQueue.k) Promise.resolve().then(() => queueMicrotask(flush));
 }
 class Queue {
   i = null;
@@ -223,6 +224,8 @@ class GlobalQueue extends Queue {
           return;
         }
         this.$.push(...activeTransition.pendingNodes);
+        this.L !== activeTransition.optimisticNodes &&
+          this.L.push(...activeTransition.optimisticNodes);
         this.restoreQueues(activeTransition.queueStash);
         transitions.delete(activeTransition);
         activeTransition = null;
@@ -252,11 +255,12 @@ class GlobalQueue extends Queue {
   initTransition(e) {
     if (activeTransition && activeTransition.time === clock) return;
     if (!activeTransition) {
-      activeTransition = e.K ?? {
+      activeTransition = e?.K ?? {
         time: clock,
         pendingNodes: [],
         asyncNodes: [],
         optimisticNodes: [],
+        actions: [],
         queueStash: { G: [[], []], H: [] },
         done: false
       };
@@ -336,6 +340,7 @@ function runQueue(e, t) {
 }
 function transitionComplete(e) {
   if (e.done) return true;
+  if (e.actions.length) return false;
   let t = true;
   for (let n = 0; n < e.asyncNodes.length; n++) {
     if (e.asyncNodes[n].J & STATUS_PENDING) {
@@ -348,9 +353,38 @@ function transitionComplete(e) {
 }
 function runInTransition(e, t) {
   const n = activeTransition;
-  activeTransition = e.K;
-  t(e);
-  activeTransition = n;
+  try {
+    activeTransition = e;
+    return t();
+  } finally {
+    activeTransition = n;
+  }
+}
+function action(e) {
+  return (...t) => {
+    const n = e(...t);
+    globalQueue.initTransition();
+    let i = activeTransition;
+    i.actions.push(n);
+    const step = e => {
+      let t = n.next(e);
+      if (t instanceof Promise) return t.then(process);
+      process(t);
+    };
+    const process = e => {
+      if (e.done) {
+        i.actions.splice(i.actions.indexOf(n), 1);
+        activeTransition = i;
+        schedule();
+        flush();
+        return;
+      }
+      const t = e.value;
+      if (t instanceof Promise) return t.then(step);
+      runInTransition(i, () => step(t));
+    };
+    runInTransition(i, () => step());
+  };
 }
 GlobalQueue.F = recompute;
 GlobalQueue.W = disposeChildren;
@@ -410,7 +444,7 @@ function recompute(e, t = false) {
       else e.D = null;
     }
   }
-  const c = !e.ue || !e.ue(e.M === NOT_PENDING || e.oe || n ? e.Y : e.M, r);
+  const c = !e.ue || !e.ue(e.M === NOT_PENDING || (e.oe && e.K) || n ? e.Y : e.M, r);
   const a = e.J !== o || e.j !== u;
   e.le?.(a, o);
   if (c || a) {
@@ -427,7 +461,7 @@ function recompute(e, t = false) {
   }
   e.oe && !optimisticRun && globalQueue.L.push(e);
   (!t || e.J & STATUS_PENDING) && !e.K && globalQueue.$.push(e);
-  e.K && n && runInTransition(e, recompute);
+  e.K && n && runInTransition(e.K, () => recompute(e));
 }
 function handleAsync(e, t, n) {
   const i = typeof t === "object" && t !== null;
@@ -725,17 +759,6 @@ function read(e) {
       }
     }
   }
-  if (pendingCheck) {
-    if (!e.q) {
-      e.q = signal(false);
-      e.q.oe = true;
-      e.q.Z = t => setSignal(e.q, t);
-    }
-    const t = pendingCheck;
-    pendingCheck = null;
-    t.Y = read(e.q) || t.Y;
-    pendingCheck = t;
-  }
   if (pendingValueCheck) {
     if (!e.ce) {
       e.ce = signal(e.Y);
@@ -748,10 +771,22 @@ function read(e) {
       pendingValueCheck = true;
     }
   }
-  if (e.J & STATUS_PENDING && !pendingCheck) {
-    if ((t && !stale) || e.J & STATUS_UNINITIALIZED) throw e.j;
+  const n = e.m || e;
+  if (pendingCheck) {
+    if (!n.q) {
+      n.q = signal(false);
+      n.q.oe = true;
+      n.q.Z = e => setSignal(n.q, e);
+    }
+    const e = pendingCheck;
+    pendingCheck = null;
+    e.Y = read(n.q) || e.Y;
+    pendingCheck = e;
+  }
+  if (!pendingCheck && n.J & STATUS_PENDING) {
+    if ((t && !stale) || n.J & STATUS_UNINITIALIZED || e.m) throw n.j;
     else if (t && stale) {
-      setStatusFlags(t, t.J | 1, e.j);
+      setStatusFlags(t, t.J | STATUS_PENDING, n.j);
     }
   }
   if (e.J & STATUS_ERROR) {
@@ -773,7 +808,7 @@ function setSignal(e, t) {
   if (typeof t === "function") {
     t = t(e.M === NOT_PENDING || (e.oe && e.K) ? e.Y : e.M);
   }
-  const n = !e.ue || !e.ue(e.M === NOT_PENDING || e.oe ? e.Y : e.M, t);
+  const n = !e.ue || !e.ue(e.M === NOT_PENDING || (e.oe && e.K) ? e.Y : e.M, t);
   if (!n && !e.J) return t;
   if (n) {
     if (e.oe) e.Y = t;
@@ -885,6 +920,10 @@ function refresh(e) {
   let t = refreshing;
   refreshing = true;
   try {
+    if (typeof e !== "function") {
+      recompute(e[$REFRESH]);
+      return e;
+    }
     return untrack(e);
   } finally {
     refreshing = t;
@@ -1076,7 +1115,7 @@ function unwrap(e) {
   return e?.[$TARGET]?.[STORE_NODE] ?? e;
 }
 function getOverrideValue(e, t, n, i) {
-  return n && i in n ? read(n[i]) : t && i in t ? t[i] : e[i];
+  return t && i in t ? t[i] : e[i];
 }
 function getAllKeys(e, t, n) {
   const i = getKeys(e, t);
@@ -1157,10 +1196,12 @@ function applyState(e, t, n, i) {
         } else r[STORE_NODE][a] && setSignal(r[STORE_NODE][a], wrap(e[a], r));
       }
       if (f < e.length) t = true;
-    } else if (l && e.length) {
+    } else if (e.length) {
       for (let t = 0, l = e.length; t < l; t++) {
         const l = getOverrideValue(s, o, u, t);
-        isWrappable(l) && applyState(e[t], wrap(l, r), n, i);
+        isWrappable(l)
+          ? applyState(e[t], wrap(l, r), n, i)
+          : r[STORE_NODE][t] && setSignal(r[STORE_NODE][t], e[t]);
       }
     }
     if (l !== e.length) {
@@ -1206,34 +1247,70 @@ function reconcile(e, t, n = false) {
 function createProjectionInternal(e, t = {}, n) {
   let i;
   const r = new WeakMap();
+  const wrapper = e => {
+    e[STORE_WRAP] = wrapProjection;
+    e[STORE_LOOKUP] = r;
+    Object.defineProperty(e, STORE_FIREWALL, {
+      get() {
+        return i;
+      },
+      configurable: true
+    });
+  };
   const wrapProjection = e => {
     if (r.has(e)) return r.get(e);
     if (e[$TARGET]?.[STORE_WRAP] === wrapProjection) return e;
-    const t = createStoreProxy(e, storeTraps, {
-      [STORE_WRAP]: wrapProjection,
-      [STORE_LOOKUP]: r,
-      [STORE_FIREWALL]() {
-        return i;
-      }
-    });
+    const t = createStoreProxy(e, storeTraps, wrapper);
     r.set(e, t);
     return t;
   };
   const s = wrapProjection(t);
   i = computed(() => {
     const t = i || getOwner();
-    storeSetter(s, i => {
-      const r = handleAsync(t, e(i), e => {
-        e !== i && e !== undefined && storeSetter(s, reconcile(e, n?.key || "id", n?.all));
+    storeSetter(new Proxy(s, writeTraps), r => {
+      const o = handleAsync(t, e(r), e => {
+        e !== s && e !== undefined && storeSetter(s, reconcile(e, n?.key || "id", n?.all));
+        setSignal(i, undefined);
       });
-      r !== i && r !== undefined && reconcile(r, n?.key || "id", n?.all)(i);
+      o !== s && o !== undefined && reconcile(o, n?.key || "id", n?.all)(s);
     });
   });
+  i.Te = true;
   return { store: s, node: i };
 }
 function createProjection(e, t = {}, n) {
   return createProjectionInternal(e, t, n).store;
 }
+const writeTraps = {
+  get(e, t) {
+    let n;
+    setWriteOverride(true);
+    try {
+      n = e[t];
+    } finally {
+      setWriteOverride(false);
+    }
+    return typeof n === "object" && n !== null ? new Proxy(n, writeTraps) : n;
+  },
+  set(e, t, n) {
+    setWriteOverride(true);
+    try {
+      e[t] = n;
+    } finally {
+      setWriteOverride(false);
+    }
+    return true;
+  },
+  deleteProperty(e, t) {
+    setWriteOverride(true);
+    try {
+      delete e[t];
+    } finally {
+      setWriteOverride(false);
+    }
+    return true;
+  }
+};
 const $TRACK = Symbol(0),
   $DEEP = Symbol(0),
   $TARGET = Symbol(0),
@@ -1253,7 +1330,7 @@ function createStoreProxy(e, t = storeTraps, n) {
     i = [];
     i.v = e;
   } else i = { v: e };
-  n && Object.assign(i, n);
+  n && n(i);
   return (i[$PROXY] = new Proxy(i, t));
 }
 const storeLookup = new WeakMap();
@@ -1266,6 +1343,13 @@ function wrap(e, t) {
 function isWrappable(e) {
   return e != null && typeof e === "object" && !Object.isFrozen(e);
 }
+let writeOverride = false;
+function setWriteOverride(e) {
+  writeOverride = e;
+}
+function writeOnly(e) {
+  return writeOverride || !!Writing?.has(e);
+}
 function getNodes(e, t) {
   let n = e[t];
   if (!n) e[t] = n = Object.create(null);
@@ -1285,8 +1369,7 @@ function getNode(e, t, n, i, r = isEqual) {
   ));
 }
 function trackSelf(e, t = $TRACK) {
-  getObserver() &&
-    read(getNode(getNodes(e, STORE_NODE), t, undefined, e[STORE_FIREWALL]?.(), false));
+  getObserver() && read(getNode(getNodes(e, STORE_NODE), t, undefined, e[STORE_FIREWALL], false));
 }
 function getKeys(e, t, n = true) {
   const i = untrack(() => (n ? Object.keys(e) : Reflect.ownKeys(e)));
@@ -1312,6 +1395,7 @@ const storeTraps = {
   get(e, t, n) {
     if (t === $TARGET) return e;
     if (t === $PROXY) return n;
+    if (t === $REFRESH) return e[STORE_FIREWALL];
     if (t === $TRACK || t === $DEEP) {
       trackSelf(e, t);
       return n;
@@ -1325,12 +1409,12 @@ const storeTraps = {
       const e = Object.getOwnPropertyDescriptor(u, t);
       if (e && e.get) return e.get.call(n);
     }
-    if (Writing?.has(n)) {
+    if (writeOnly(n)) {
       let n = r && (s || !o) ? (r.M !== NOT_PENDING ? r.M : r.Y) : u[t];
       n === $DELETED && (n = undefined);
       if (!isWrappable(n)) return n;
       const i = wrap(n, e);
-      Writing.add(i);
+      Writing?.add(i);
       return i;
     }
     let l = r ? (s || !o ? read(i[t]) : (read(i[t]), u[t])) : u[t];
@@ -1344,7 +1428,7 @@ const storeTraps = {
           ? l.bind(u)
           : l;
       } else if (getObserver()) {
-        return read(getNode(i, t, isWrappable(l) ? wrap(l, e) : l, e[STORE_FIREWALL]?.()));
+        return read(getNode(i, t, isWrappable(l) ? wrap(l, e) : l, e[STORE_FIREWALL]));
       }
     }
     return isWrappable(l) ? wrap(l, e) : l;
@@ -1355,12 +1439,12 @@ const storeTraps = {
       e[STORE_OVERRIDE] && t in e[STORE_OVERRIDE]
         ? e[STORE_OVERRIDE][t] !== $DELETED
         : t in e[STORE_VALUE];
-    getObserver() && read(getNode(getNodes(e, STORE_HAS), t, n, e[STORE_FIREWALL]?.()));
+    getObserver() && read(getNode(getNodes(e, STORE_HAS), t, n, e[STORE_FIREWALL]));
     return n;
   },
   set(e, t, n) {
     const i = e[$PROXY];
-    if (Writing?.has(e[$PROXY])) {
+    if (writeOnly(i)) {
       untrack(() => {
         const r = e[STORE_VALUE];
         const s = r[t];
@@ -1389,7 +1473,7 @@ const storeTraps = {
     return true;
   },
   deleteProperty(e, t) {
-    if (Writing?.has(e[$PROXY]) && e[STORE_OVERRIDE]?.[t] !== $DELETED) {
+    if (writeOnly(e[$PROXY]) && e[STORE_OVERRIDE]?.[t] !== $DELETED) {
       untrack(() => {
         const n =
           e[STORE_OVERRIDE] && t in e[STORE_OVERRIDE] ? e[STORE_OVERRIDE][t] : e[STORE_VALUE][t];
@@ -2088,6 +2172,7 @@ export {
   NoOwnerError,
   NotReadyError,
   SUPPORTS_PROXY,
+  action,
   createBoundary,
   createContext,
   createEffect,

package/dist/types/core/constants.d.ts

@@ -16,3 +16,4 @@ export declare const EFFECT_USER = 2;
 export declare const NOT_PENDING: {};
 export declare const SUPPORTS_PROXY: boolean;
 export declare const defaultContext: {};
+export declare const $REFRESH: unique symbol;

package/dist/types/core/core.d.ts

@@ -1,4 +1,4 @@
-import { NOT_PENDING } from "./constants.js";
+import { $REFRESH, NOT_PENDING } from "./constants.js";
 import { type IQueue, type Transition } from "./scheduler.js";
 export interface Disposable {
     (): void;
@@ -118,5 +118,7 @@ export declare function runWithOwner<T>(owner: Owner | null, fn: () => T): T;
 export declare function staleValues<T>(fn: () => T, set?: boolean): T;
 export declare function pending<T>(fn: () => T): T;
 export declare function isPending(fn: () => any): boolean;
-export declare function refresh<T>(fn: () => T): T;
+export declare function refresh<T>(fn: (() => T) | (T & {
+    [$REFRESH]: any;
+})): T;
 export declare function isRefreshing(): boolean;

package/dist/types/core/index.d.ts

@@ -2,5 +2,5 @@ export { ContextNotFoundError, NoOwnerError, NotReadyError } from "./error.js";
 export { createContext, getContext, setContext, type Context, type ContextRecord } from "./context.js";
 export { getObserver, isEqual, untrack, getOwner, runWithOwner, createOwner, createRoot, computed, dispose, signal, read, setSignal, onCleanup, getNextChildId, isPending, pending, refresh, isRefreshing, staleValues, handleAsync, type Owner, type Computed, type Root, type Signal, type SignalOptions } from "./core.js";
 export { effect, type Effect } from "./effect.js";
-export { flush, Queue, type IQueue, type QueueCallback } from "./scheduler.js";
+export { action, flush, Queue, type IQueue, type QueueCallback } from "./scheduler.js";
 export * from "./constants.js";

package/dist/types/core/scheduler.d.ts

@@ -15,8 +15,9 @@ export interface Transition {
     asyncNodes: Computed<any>[];
     pendingNodes: Signal<any>[];
     optimisticNodes: Signal<any>[];
+    actions: Array<Generator<any, any, any> | AsyncGenerator<any, any, any>>;
     queueStash: QueueStub;
-    done: boolean;
+    done: boolean | Transition;
 }
 export declare function schedule(): void;
 export interface IQueue {
@@ -51,7 +52,7 @@ export declare class GlobalQueue extends Queue {
     static _dispose: (el: Computed<unknown>, self: boolean, zombie: boolean) => void;
     flush(): void;
     notify(node: Computed<any>, mask: number, flags: number): boolean;
-    initTransition(node: Computed<any>): void;
+    initTransition(node?: Computed<any>): void;
 }
 export declare function notifySubs(node: Signal<any> | Computed<any>): void;
 export declare function runOptimistic(activeTransition?: Transition | null): void;
@@ -61,5 +62,6 @@ export declare const globalQueue: GlobalQueue;
  * the queue synchronously to get the latest updates by calling `flush()`.
  */
 export declare function flush(): void;
-export declare function runInTransition(el: Computed<unknown>, recompute: (el: Computed<unknown>) => void): void;
+export declare function runInTransition<T>(transition: Transition, fn: () => T): T;
+export declare function action<Args extends any[], Y, R>(genFn: (...args: Args) => Generator<Y, R, any> | AsyncGenerator<Y, R, any>): (...args: Args) => void;
 export {};

package/dist/types/index.d.ts

@@ -1,4 +1,4 @@
-export { ContextNotFoundError, NoOwnerError, NotReadyError, createContext, createRoot, runWithOwner, flush, getNextChildId, getContext, setContext, getOwner, onCleanup, getObserver, isEqual, untrack, isPending, pending, isRefreshing, refresh, SUPPORTS_PROXY } from "./core/index.js";
+export { ContextNotFoundError, NoOwnerError, NotReadyError, action, createContext, createRoot, runWithOwner, flush, getNextChildId, getContext, setContext, getOwner, onCleanup, getObserver, isEqual, untrack, isPending, pending, isRefreshing, refresh, SUPPORTS_PROXY } from "./core/index.js";
 export type { Owner, SignalOptions, Context, ContextRecord, IQueue } from "./core/index.js";
 export * from "./signals.js";
 export { mapArray, repeat, type Maybe } from "./map.js";

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

@@ -1,11 +1,16 @@
+import { $REFRESH, type Computed } from "../core/index.js";
 import { type Store, type StoreOptions } from "./store.js";
 export declare function createProjectionInternal<T extends object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, initialValue?: T, options?: StoreOptions): {
-    store: Readonly<T>;
-    node: any;
+    store: Store<T> & {
+        [$REFRESH]: any;
+    };
+    node: Computed<void | T>;
 };
 /**
  * Creates a mutable derived value
  *
  * @see {@link https://github.com/solidjs/x-reactivity#createprojection}
  */
-export declare function createProjection<T extends Object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, initialValue?: T, options?: StoreOptions): Store<T>;
+export declare function createProjection<T extends object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, initialValue?: T, options?: StoreOptions): Store<T> & {
+    [$REFRESH]: any;
+};

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

@@ -1,4 +1,4 @@
-import { type Computed, type Signal } from "../core/index.js";
+import { $REFRESH, type Computed, type Signal } from "../core/index.js";
 export type Store<T> = Readonly<T>;
 export type StoreSetter<T> = (fn: (state: T) => T | void) => void;
 export type StoreOptions = {
@@ -17,22 +17,26 @@ export type StoreNode = {
     [STORE_HAS]?: DataNodes;
     [STORE_WRAP]?: (value: any, target?: StoreNode) => any;
     [STORE_LOOKUP]?: WeakMap<any, any>;
-    [STORE_FIREWALL]?: () => Computed<any>;
+    [STORE_FIREWALL]?: Computed<any>;
 };
 export declare namespace SolidStore {
     interface Unwrappable {
     }
 }
 export type NotWrappable = string | number | bigint | symbol | boolean | Function | null | undefined | SolidStore.Unwrappable[keyof SolidStore.Unwrappable];
-export declare function createStoreProxy<T extends object>(value: T, traps?: ProxyHandler<StoreNode>, extend?: Record<PropertyKey, any>): any;
-export declare const storeLookup: WeakMap<object, any>;
+export declare function createStoreProxy<T extends object>(value: T, traps?: ProxyHandler<StoreNode>, extend?: (target: StoreNode) => void): any;
+export declare const storeLookup: WeakMap<WeakKey, any>;
 export declare function wrap<T extends Record<PropertyKey, any>>(value: T, target?: StoreNode): T;
 export declare function isWrappable<T>(obj: T | NotWrappable): obj is T;
+export declare function setWriteOverride(value: boolean): void;
 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) => 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 | T | Promise<void | T> | AsyncIterable<void | T>, store: T | Store<T>, options?: StoreOptions): [get: Store<T>, set: StoreSetter<T>];
+type NoFn<T> = T extends Function ? never : T;
+export declare function createStore<T extends object = {}>(store: NoFn<T> | Store<NoFn<T>>): [get: Store<T>, set: StoreSetter<T>];
+export declare function createStore<T extends object = {}>(fn: (store: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, store?: NoFn<T> | Store<NoFn<T>>, options?: StoreOptions): [get: Store<T> & {
+    [$REFRESH]: any;
+}, set: StoreSetter<T>];
 export declare function deep<T extends object>(store: Store<T>): Store<T>;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidjs/signals",
-  "version": "0.9.2",
+  "version": "0.9.3",
   "description": "",
   "author": "Ryan Carniato",
   "license": "MIT",
@@ -23,12 +23,12 @@
     "@rollup/plugin-replace": "^6.0.3",
     "@rollup/plugin-terser": "^0.4.4",
     "@rollup/plugin-typescript": "^12.3.0",
-    "@types/node": "^20.5.1",
+    "@types/node": "^25.0.8",
     "rimraf": "^5.0.1",
     "rollup": "^4.53.4",
     "rollup-plugin-prettier": "^4.1.2",
     "tslib": "^2.8.1",
-    "typescript": "5.1.6",
+    "typescript": "5.9.3",
     "vite": "^5.4.10",
     "vitest": "^2.0.0"
   },