@solidjs/signals 0.9.4 → 0.9.6

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

@@ -6,6 +6,7 @@ export declare const REACTIVE_IN_HEAP: number;
 export declare const REACTIVE_IN_HEAP_HEIGHT: number;
 export declare const REACTIVE_ZOMBIE: number;
 export declare const REACTIVE_DISPOSED: number;
+export declare const REACTIVE_OPTIMISTIC_DIRTY: number;
 export declare const STATUS_NONE = 0;
 export declare const STATUS_PENDING: number;
 export declare const STATUS_ERROR: number;
@@ -13,6 +14,7 @@ export declare const STATUS_UNINITIALIZED: number;
 export declare const EFFECT_PURE = 0;
 export declare const EFFECT_RENDER = 1;
 export declare const EFFECT_USER = 2;
+export declare const EFFECT_TRACKED = 3;
 export declare const NOT_PENDING: {};
 export declare const SUPPORTS_PROXY: boolean;
 export declare const defaultContext: {};

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

@@ -19,12 +19,9 @@ export interface SignalOptions<T> {
     lazy?: boolean;
 }
 export interface RawSignal<T> {
-    id?: string;
     _subs: Link | null;
     _subsTail: Link | null;
     _value: T;
-    _error?: unknown;
-    _statusFlags: number;
     _name?: string;
     _equals: false | ((a: T, b: T) => boolean);
     _pureWrite?: boolean;
@@ -32,13 +29,9 @@ export interface RawSignal<T> {
     _time: number;
     _transition: Transition | null;
     _pendingValue: T | typeof NOT_PENDING;
-    _pendingCheck?: Signal<boolean> & {
-        _set: (v: boolean) => void;
-    };
-    _pendingSignal?: Signal<T> & {
-        _set: (v: T) => void;
-    };
     _optimistic?: boolean;
+    _pendingSignal?: Signal<boolean>;
+    _pendingValueComputed?: Computed<T>;
 }
 export interface FirewallSignal<T> extends RawSignal<T> {
     _firewall: Computed<any>;
@@ -61,13 +54,15 @@ export interface Computed<T> extends RawSignal<T>, Owner {
     _deps: Link | null;
     _depsTail: Link | null;
     _flags: number;
+    _error?: unknown;
+    _statusFlags: number;
     _height: number;
     _nextHeap: Computed<any> | undefined;
     _prevHeap: Computed<any>;
     _fn: (prev?: T) => T;
-    _inFlight: Promise<T> | AsyncIterable<T> | null;
+    _inFlight: PromiseLike<T> | AsyncIterable<T> | null;
     _child: FirewallSignal<any> | null;
-    _notifyQueue?: (statusFlagsChanged: boolean, prevStatusFlags: number) => void;
+    _notifyStatus?: () => void;
 }
 export interface Root extends Owner {
     _root: true;
@@ -75,14 +70,17 @@ export interface Root extends Owner {
     dispose(self?: boolean): void;
 }
 export declare let context: Owner | null;
+export declare function setLeafEffectActive(v: boolean): void;
 export declare function recompute(el: Computed<any>, create?: boolean): void;
-export declare function handleAsync<T>(el: Computed<T>, result: T | Promise<T> | AsyncIterable<T>, setter?: (value: T) => void): T;
+export declare function handleAsync<T>(el: Computed<T>, result: T | PromiseLike<T> | AsyncIterable<T>, setter?: (value: T) => void): T;
 export declare function dispose(node: Computed<unknown>): void;
 export declare function getNextChildId(owner: Owner): string;
-export declare function computed<T>(fn: (prev?: T) => T | Promise<T> | AsyncIterable<T>): Computed<T>;
-export declare function computed<T>(fn: (prev: T) => T | Promise<T> | AsyncIterable<T>, initialValue?: T, options?: SignalOptions<T>): Computed<T>;
+export declare function computed<T>(fn: (prev?: T) => T | PromiseLike<T> | AsyncIterable<T>): Computed<T>;
+export declare function computed<T>(fn: (prev: T) => T | PromiseLike<T> | AsyncIterable<T>, initialValue?: T, options?: SignalOptions<T>): Computed<T>;
 export declare function signal<T>(v: T, options?: SignalOptions<T>): Signal<T>;
 export declare function signal<T>(v: T, options?: SignalOptions<T>, firewall?: Computed<any>): FirewallSignal<T>;
+export declare function optimisticSignal<T>(v: T, options?: SignalOptions<T>): Signal<T>;
+export declare function optimisticComputed<T>(fn: (prev?: T) => T | PromiseLike<T> | AsyncIterable<T>, initialValue?: T, options?: SignalOptions<T>): Computed<T>;
 export declare function isEqual<T>(a: T, b: T): boolean;
 /**
  * Returns the current value stored inside the given compute function without triggering any

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

@@ -16,3 +16,14 @@ export declare function effect<T>(compute: (prev: T | undefined) => T, effect: (
     render?: boolean;
     defer?: boolean;
 }): void;
+export interface TrackedEffect extends Computed<void> {
+    _cleanup?: () => void;
+    _modified: boolean;
+    _type: number;
+    _run: () => void;
+}
+/**
+ * Internal tracked effect - bypasses heap, goes directly to effect queue.
+ * Children forbidden (__DEV__ throws). Uses stale reads.
+ */
+export declare function trackedEffect(fn: () => void | (() => void), options?: SignalOptions<any>): void;

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

@@ -1,6 +1,6 @@
 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 { action, flush, Queue, type IQueue, type QueueCallback } from "./scheduler.js";
+export { getObserver, isEqual, untrack, getOwner, runWithOwner, createOwner, createRoot, computed, dispose, signal, read, setSignal, onCleanup, optimisticSignal, optimisticComputed, getNextChildId, isPending, pending, refresh, isRefreshing, staleValues, handleAsync, type Owner, type Computed, type Root, type Signal, type SignalOptions } from "./core.js";
+export { effect, trackedEffect, type Effect, type TrackedEffect } from "./effect.js";
+export { action, flush, Queue, GlobalQueue, trackOptimisticStore, type IQueue, type QueueCallback } from "./scheduler.js";
 export * from "./constants.js";

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

@@ -1,10 +1,13 @@
 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;
 export declare let activeTransition: Transition | null;
+export declare let optimisticReadActive: boolean;
+export declare let projectionWriteActive: boolean;
+export declare function setOptimisticReadActive(value: boolean): void;
+export declare function setProjectionWriteActive(value: boolean): void;
 export type QueueCallback = (type: number) => void;
 type QueueStub = {
     _queues: [QueueCallback[], QueueCallback[]];
@@ -15,6 +18,7 @@ export interface Transition {
     asyncNodes: Computed<any>[];
     pendingNodes: Signal<any>[];
     optimisticNodes: Signal<any>[];
+    optimisticStores: Set<any>;
     actions: Array<Generator<any, any, any> | AsyncGenerator<any, any, any>>;
     queueStash: QueueStub;
     done: boolean | Transition;
@@ -34,12 +38,15 @@ export interface IQueue {
 export declare class Queue implements IQueue {
     _parent: IQueue | null;
     _queues: [QueueCallback[], QueueCallback[]];
+    _optimisticQueues: [QueueCallback[], QueueCallback[]];
     _children: IQueue[];
     created: number;
     addChild(child: IQueue): void;
     removeChild(child: IQueue): void;
     notify(node: Computed<any>, mask: number, flags: number): boolean;
+    private _runQueue;
     run(type: number): void;
+    runOptimistic(type: number): void;
     enqueue(type: number, fn: QueueCallback): void;
     stashQueues(stub: QueueStub): void;
     restoreQueues(stub: QueueStub): void;
@@ -48,14 +55,17 @@ export declare class GlobalQueue extends Queue {
     _running: boolean;
     _pendingNodes: Signal<any>[];
     _optimisticNodes: Signal<any>[];
+    _optimisticStores: Set<any>;
     static _update: (el: Computed<unknown>) => void;
     static _dispose: (el: Computed<unknown>, self: boolean, zombie: boolean) => void;
+    static _clearOptimisticStore: ((store: any) => void) | null;
     flush(): void;
     notify(node: Computed<any>, mask: number, flags: number): boolean;
-    initTransition(node?: Computed<any>): void;
+    initTransition(transition?: Transition | null): void;
 }
-export declare function notifySubs(node: Signal<any> | Computed<any>): void;
-export declare function runOptimistic(activeTransition?: Transition | null): void;
+export declare function insertSubs(node: Signal<any> | Computed<any>, optimistic?: boolean): void;
+export declare function finalizePureQueue(completingTransition?: Transition | null, incomplete?: boolean): void;
+export declare function trackOptimisticStore(store: any): void;
 export declare const globalQueue: GlobalQueue;
 /**
  * By default, changes are batched on the microtask queue which is an async process. You can flush
@@ -63,5 +73,5 @@ export declare const globalQueue: GlobalQueue;
  */
 export declare function flush(): 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 declare function action<Args extends any[], Y, R>(genFn: (...args: Args) => Generator<Y, R, any> | AsyncGenerator<Y, R, any>): (...args: Args) => Promise<R>;
 export {};

package/dist/types/signals.d.ts

@@ -7,7 +7,7 @@ export type Setter<in out T> = {
     <U extends T>(value: Exclude<U, Function> | ((prev: T) => U)): U;
 };
 export type Signal<T> = [get: Accessor<T>, set: Setter<T>];
-export type ComputeFunction<Prev, Next extends Prev = Prev> = (v: Prev) => Promise<Next> | AsyncIterable<Next> | Next;
+export type ComputeFunction<Prev, Next extends Prev = Prev> = (v: Prev) => PromiseLike<Next> | AsyncIterable<Next> | Next;
 export type EffectFunction<Prev, Next extends Prev = Prev> = (v: Next, p?: Prev) => (() => void) | void;
 export type EffectBundle<Prev, Next extends Prev = Prev> = {
     effect: EffectFunction<Prev, Next>;
@@ -105,11 +105,17 @@ export declare function createEffect<Next, Init = Next>(compute: ComputeFunction
 export declare function createRenderEffect<Next>(compute: ComputeFunction<undefined | NoInfer<Next>, Next>, effectFn: EffectFunction<NoInfer<Next>, Next>): void;
 export declare function createRenderEffect<Next, Init = Next>(compute: ComputeFunction<Init | Next, Next>, effectFn: EffectFunction<Next, Next>, value: Init, options?: EffectOptions): void;
 /**
- * Creates a tracked reactive effect that only tracks dependencies inside the effect itself
+ * Creates a tracked reactive effect where dependency tracking and side effects happen
+ * in the same scope.
+ *
+ * WARNING: Because tracking and effects happen in the same scope, this primitive
+ * may run multiple times for a single change or show tearing (reading inconsistent
+ * state). Use only when dynamic subscription patterns require same-scope tracking.
+ *
  * ```typescript
  * export function createTrackedEffect(
  *   compute: () => (() => void) | void,
- *   options?: { name?: string, defer?: boolean }
+ *   options?: { name?: string }
  * ): void;
  * ```
  * @param compute a function that contains reactive reads to track and returns an optional cleanup function to run on disposal or before next execution
@@ -137,7 +143,48 @@ export declare function createReaction(effectFn: EffectFunction<undefined> | Eff
  * @param fn a reactive expression to resolve
  */
 export declare function resolve<T>(fn: () => T): Promise<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.
+ * ```typescript
+ * export function createOptimistic<T>(): Signal<T | undefined>;
+ * export function createOptimistic<T>(
+ *   value: Exclude<T, Function>,
+ *   options?: SignalOptions<T>
+ * ): Signal<T>;
+ * export function createOptimistic<T>(
+ *   fn: ComputeFunction<T>,
+ *   initialValue?: T,
+ *   options?: SignalOptions<T>
+ * ): Signal<T>;
+ * ```
+ * @param value initial value of the signal; if empty, the signal's type will automatically extended with undefined; otherwise you need to extend the type manually if you want setting to undefined not be an error
+ * @param options optional object with a name for debugging purposes and equals, a comparator function for the previous and next value to allow fine-grained control over the reactivity
+ *
+ * @returns ```typescript
+ * [state: Accessor<T>, setState: Setter<T>]
+ * ```
+ * * the Accessor is a function that returns the current value and registers each call to the reactive root
+ * * the Setter is a function that allows directly setting or mutating the value:
+ * ```typescript
+ * const [count, setCount] = createOptimistic(0);
+ * setCount(count => count + 1);
+ * ```
+ *
+ * @description https://docs.solidjs.com/reference/basic-reactivity/create-optimistic-signal
+ */
 export declare function createOptimistic<T>(): Signal<T | undefined>;
 export declare function createOptimistic<T>(value: Exclude<T, Function>, options?: SignalOptions<T>): Signal<T>;
 export declare function createOptimistic<T>(fn: ComputeFunction<T>, initialValue?: T, options?: SignalOptions<T>): Signal<T>;
+/**
+ * Runs a callback after the current flush cycle completes.
+ *
+ * When called within a reactive context (owner), uses a tracked effect with untracked
+ * reads - this means normal signal reads won't create subscriptions, but uninitialized
+ * async values will throw NotReadyError, causing the callback to re-run when they settle.
+ *
+ * When called without an owner, runs once and immediately calls any returned cleanup.
+ *
+ * @param callback Function to run, may return a cleanup function
+ */
 export declare function onSettled(callback: () => void | (() => void)): void;

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

@@ -1,9 +1,10 @@
-import { type Store, type StoreSetter } from "./store.js";
+import { $REFRESH } from "../core/index.js";
+import { type NoFn, type Store, type StoreOptions, type StoreSetter } from "./store.js";
 /**
  * Creates an optimistic store that can be used to optimistically update a value
  * and then revert it back to the previous value at end of transition.
  * ```typescript
- * export function createOptimistic<T>(
+ * export function createOptimisticStore<T>(
  *   fn: (store: T) => void,
  *   initial: T,
  *   options?: { key?: string | ((item: NonNullable<any>) => any); all?: boolean }
@@ -15,8 +16,7 @@ import { type Store, type StoreSetter } from "./store.js";
  *
  * @returns A tuple containing an accessor for the current value and a setter function to apply changes.
  */
-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) => T | void, initial: T | Store<T>, options?: {
-    key?: string | ((item: NonNullable<any>) => any);
-    all?: boolean;
-}): [get: Store<T>, set: StoreSetter<T>];
+export declare function createOptimisticStore<T extends object = {}>(store: NoFn<T> | Store<NoFn<T>>): [get: Store<T>, set: StoreSetter<T>];
+export declare function createOptimisticStore<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>];

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

@@ -14,3 +14,4 @@ export declare function createProjectionInternal<T extends object = {}>(fn: (dra
 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;
 };
+export declare const writeTraps: ProxyHandler<any>;

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

@@ -5,19 +5,22 @@ export type StoreOptions = {
     key?: string | ((item: NonNullable<any>) => any);
     all?: boolean;
 };
+export type NoFn<T> = T extends Function ? never : T;
 type DataNode = Signal<any>;
 type DataNodes = Record<PropertyKey, DataNode>;
 export declare const $TRACK: unique symbol, $DEEP: unique symbol, $TARGET: unique symbol, $PROXY: unique symbol, $DELETED: unique symbol;
-export declare const STORE_VALUE = "v", STORE_OVERRIDE = "o", STORE_NODE = "n", STORE_HAS = "h", STORE_WRAP = "w", STORE_LOOKUP = "l", STORE_FIREWALL = "f";
+export declare const STORE_VALUE = "v", STORE_OVERRIDE = "o", STORE_OPTIMISTIC_OVERRIDE = "x", STORE_NODE = "n", STORE_HAS = "h", STORE_WRAP = "w", STORE_LOOKUP = "l", STORE_FIREWALL = "f", STORE_OPTIMISTIC = "p";
 export type StoreNode = {
     [$PROXY]: any;
     [STORE_VALUE]: Record<PropertyKey, any>;
     [STORE_OVERRIDE]?: Record<PropertyKey, any>;
+    [STORE_OPTIMISTIC_OVERRIDE]?: Record<PropertyKey, any>;
     [STORE_NODE]?: DataNodes;
     [STORE_HAS]?: DataNodes;
     [STORE_WRAP]?: (value: any, target?: StoreNode) => any;
     [STORE_LOOKUP]?: WeakMap<any, any>;
     [STORE_FIREWALL]?: Computed<any>;
+    [STORE_OPTIMISTIC]?: boolean;
 };
 export declare namespace SolidStore {
     interface Unwrappable {
@@ -33,7 +36,6 @@ export declare function getKeys(source: Record<PropertyKey, any>, override: Reco
 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;
-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;

package/package.json

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