@solidjs/signals 0.9.1 → 0.9.3

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;
@@ -16,6 +16,7 @@ export interface SignalOptions<T> {
     equals?: ((prev: T, next: T) => boolean) | false;
     pureWrite?: boolean;
     unobserved?: () => void;
+    lazy?: boolean;
 }
 export interface RawSignal<T> {
     id?: string;
@@ -117,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

@@ -1,5 +1,6 @@
 import type { Computed, Signal } from "./core.js";
 import { type Heap } from "./heap.js";
+export declare let optimisticRun: boolean;
 export declare const dirtyQueue: Heap;
 export declare const zombieQueue: Heap;
 export declare let clock: number;
@@ -13,7 +14,10 @@ export interface Transition {
     time: number;
     asyncNodes: Computed<any>[];
     pendingNodes: Signal<any>[];
+    optimisticNodes: Signal<any>[];
+    actions: Array<Generator<any, any, any> | AsyncGenerator<any, any, any>>;
     queueStash: QueueStub;
+    done: boolean | Transition;
 }
 export declare function schedule(): void;
 export interface IQueue {
@@ -43,17 +47,21 @@ export declare class Queue implements IQueue {
 export declare class GlobalQueue extends Queue {
     _running: boolean;
     _pendingNodes: Signal<any>[];
+    _optimisticNodes: Signal<any>[];
     static _update: (el: Computed<unknown>) => void;
     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;
 export declare const globalQueue: GlobalQueue;
 /**
  * By default, changes are batched on the microtask queue which is an async process. You can flush
  * 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.1",
+  "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"
   },