@solidjs/signals 0.9.10 → 0.10.0

package/dist/types/boundaries.d.ts

@@ -13,11 +13,6 @@ export declare class CollectionQueue extends Queue {
     notify(node: Effect<any>, type: number, flags: number, error?: any): boolean;
     checkSources(): void;
 }
-export declare const enum BoundaryMode {
-    VISIBLE = "visible",
-    HIDDEN = "hidden"
-}
-export declare function createBoundary<T>(fn: () => T, condition: () => BoundaryMode): () => T | undefined;
 export declare function createLoadBoundary(fn: () => any, fallback: () => any): () => unknown;
 export declare function createErrorBoundary<U>(fn: () => any, fallback: (error: unknown, reset: () => void) => U): () => unknown;
 export declare function flatten(children: any, options?: {

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

@@ -0,0 +1 @@
+export declare function action<Args extends any[], Y, R>(genFn: (...args: Args) => Generator<Y, R, any> | AsyncGenerator<Y, R, any>): (...args: Args) => Promise<R>;

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

@@ -0,0 +1,5 @@
+import { type OptimisticLane } from "./lanes.js";
+import type { Computed } from "./types.js";
+export declare function handleAsync<T>(el: Computed<T>, result: T | PromiseLike<T> | AsyncIterable<T>, setter?: (value: T) => void): T;
+export declare function clearStatus(el: Computed<any>): void;
+export declare function notifyStatus(el: Computed<any>, status: number, error: any, blockStatus?: boolean, lane?: OptimisticLane): void;

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

@@ -1,4 +1,4 @@
-import { type Owner } from "./core.js";
+import type { Owner } from "./types.js";
 export interface Context<T> {
     readonly id: symbol;
     readonly defaultValue: T | undefined;

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

@@ -1,88 +1,26 @@
-import { $REFRESH, NOT_PENDING } from "./constants.js";
-import { type IQueue, type OptimisticLane, type Transition } from "./scheduler.js";
-export interface Disposable {
-    (): void;
-}
-export interface Link {
-    _dep: Signal<unknown> | Computed<unknown>;
-    _sub: Computed<unknown>;
-    _nextDep: Link | null;
-    _prevSub: Link | null;
-    _nextSub: Link | null;
-}
-export interface SignalOptions<T> {
-    id?: string;
-    name?: string;
-    equals?: ((prev: T, next: T) => boolean) | false;
-    pureWrite?: boolean;
-    unobserved?: () => void;
-    lazy?: boolean;
-}
-export interface RawSignal<T> {
-    _subs: Link | null;
-    _subsTail: Link | null;
-    _value: T;
-    _name?: string;
-    _equals: false | ((a: T, b: T) => boolean);
-    _pureWrite?: boolean;
-    _unobserved?: () => void;
-    _time: number;
-    _transition: Transition | null;
-    _pendingValue: T | typeof NOT_PENDING;
-    _optimistic?: boolean;
-    _optimisticLane?: OptimisticLane;
-    _pendingSignal?: Signal<boolean>;
-    _pendingValueComputed?: Computed<T>;
-    _parentSource?: Signal<any> | Computed<any>;
-}
-export interface FirewallSignal<T> extends RawSignal<T> {
-    _firewall: Computed<any>;
-    _nextChild: FirewallSignal<unknown> | null;
-}
-export type Signal<T> = RawSignal<T> | FirewallSignal<T>;
-export interface Owner {
-    id?: string;
-    _disposal: Disposable | Disposable[] | null;
-    _parent: Owner | null;
-    _context: Record<symbol | string, unknown>;
-    _childCount: number;
-    _queue: IQueue;
-    _firstChild: Owner | null;
-    _nextSibling: Owner | null;
-    _pendingDisposal: Disposable | Disposable[] | null;
-    _pendingFirstChild: Owner | null;
-}
-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: PromiseLike<T> | AsyncIterable<T> | null;
-    _child: FirewallSignal<any> | null;
-    _notifyStatus?: (status?: number, error?: any) => void;
-}
-export interface Root extends Owner {
-    _root: true;
-    _parentComputed: Computed<any> | null;
-    dispose(self?: boolean): void;
-}
+import { handleAsync } from "./async.js";
+import { $REFRESH } from "./constants.js";
+import { type OptimisticLane } from "./lanes.js";
+import { createOwner, createRoot, dispose, getNextChildId, getObserver, getOwner, onCleanup } from "./owner.js";
+import type { Computed, Disposable, FirewallSignal, Link, NodeOptions, Owner, Root, Signal } from "./types.js";
+export { handleAsync };
+export type { Computed, Disposable, FirewallSignal, Link, Owner, Root, Signal, NodeOptions };
+export { createOwner, createRoot, dispose, getNextChildId, getObserver, getOwner, onCleanup };
+export declare let tracking: boolean;
+export declare let stale: boolean;
+export declare let refreshing: boolean;
+export declare let pendingCheckActive: boolean;
+export declare let foundPending: boolean;
+export declare let pendingReadActive: boolean;
 export declare let context: Owner | null;
-export declare function setLeafEffectActive(v: boolean): void;
+export declare let currentOptimisticLane: OptimisticLane | null;
 export declare function recompute(el: Computed<any>, create?: boolean): void;
-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 | 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 computed<T>(fn: (prev: T) => T | PromiseLike<T> | AsyncIterable<T>, initialValue?: T, options?: NodeOptions<T>): Computed<T>;
+export declare function signal<T>(v: T, options?: NodeOptions<T>): Signal<T>;
+export declare function signal<T>(v: T, options?: NodeOptions<T>, firewall?: Computed<any>): FirewallSignal<T>;
+export declare function optimisticSignal<T>(v: T, options?: NodeOptions<T>): Signal<T>;
+export declare function optimisticComputed<T>(fn: (prev?: T) => T | PromiseLike<T> | AsyncIterable<T>, initialValue?: T, options?: NodeOptions<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
@@ -91,30 +29,13 @@ export declare function isEqual<T>(a: T, b: T): boolean;
 export declare function untrack<T>(fn: () => T): T;
 export declare function read<T>(el: Signal<T> | Computed<T>): T;
 export declare function setSignal<T>(el: Signal<T> | Computed<T>, v: T | ((prev: T) => T)): T;
-export declare function getObserver(): Owner | null;
-export declare function getOwner(): Owner | null;
-export declare function onCleanup(fn: Disposable): Disposable;
-export declare function createOwner(options?: {
-    id: string;
-}): Root;
-/**
- * Creates a new non-tracked reactive context with manual disposal
- *
- * @param fn a function in which the reactive state is scoped
- * @returns the output of `fn`.
- *
- * @description https://docs.solidjs.com/reference/reactive-utilities/create-root
- */
-export declare function createRoot<T>(init: ((dispose: () => void) => T) | (() => T), options?: {
-    id: string;
-}): T;
+export declare function runWithOwner<T>(owner: Owner | null, fn: () => T): T;
 /**
- * Runs the given function in the given owner to move ownership of nested primitives and cleanups.
- * This method untracks the current scope.
- *
- * Warning: Usually there are simpler ways of modeling a problem that avoid using this function
+ * Update _pendingSignal when pending state changes. When the override clears
+ * (pending -> not pending), merge the sub-lane into the source's lane so
+ * isPending effects are blocked until the full scope resolves.
  */
-export declare function runWithOwner<T>(owner: Owner | null, fn: () => T): T;
+export declare function updatePendingSignal(el: Signal<any> | Computed<any>): void;
 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;

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

@@ -1,4 +1,5 @@
-import { type Computed, type Owner, type SignalOptions } from "./core.js";
+import type { Computed, NodeOptions, Owner } from "./types.js";
+export declare let leafEffectActive: boolean;
 export interface Effect<T> extends Computed<T>, Owner {
     _effectFn: (val: T, prev: T | undefined) => void | (() => void);
     _errorFn?: (err: unknown, cleanup: () => void) => void;
@@ -12,7 +13,7 @@ export interface Effect<T> extends Computed<T>, Owner {
  * automatically added to the queue of effects to re-execute, which will cause them to fetch their
  * sources and recompute
  */
-export declare function effect<T>(compute: (prev: T | undefined) => T, effect: (val: T, prev: T | undefined) => void | (() => void), error?: (err: unknown, cleanup: () => void) => void | (() => void), initialValue?: T, options?: SignalOptions<any> & {
+export declare function effect<T>(compute: (prev: T | undefined) => T, effect: (val: T, prev: T | undefined) => void | (() => void), error?: (err: unknown, cleanup: () => void) => void | (() => void), initialValue?: T, options?: NodeOptions<any> & {
     render?: boolean;
     defer?: boolean;
 }): void;
@@ -26,4 +27,4 @@ export interface TrackedEffect extends Computed<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;
+export declare function trackedEffect(fn: () => void | (() => void), options?: NodeOptions<any>): void;

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

@@ -0,0 +1,3 @@
+import type { Computed, Link, Signal } from "./types.js";
+export declare function unlinkSubs(link: Link): Link | null;
+export declare function link(dep: Signal<any> | Computed<any>, sub: Computed<any>): void;

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

@@ -1,4 +1,4 @@
-import type { Computed } from "./core.js";
+import type { Computed } from "./types.js";
 export interface Heap {
     _heap: (Computed<unknown> | undefined)[];
     _marked: boolean;

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

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

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

@@ -0,0 +1,52 @@
+import { type QueueCallback, type Transition } from "./scheduler.js";
+import type { Computed, Signal } from "./types.js";
+/**
+ * OptimisticLane represents the context for a single optimistic write.
+ * Each optimistic signal creates its own lane. Lanes merge when their
+ * dependency graphs overlap.
+ */
+export interface OptimisticLane {
+    _source: Signal<any>;
+    _pendingAsync: Set<Computed<any>>;
+    _effectQueues: [QueueCallback[], QueueCallback[]];
+    _mergedInto: OptimisticLane | null;
+    _transition: Transition | null;
+    _parentLane: OptimisticLane | null;
+}
+export declare const signalLanes: WeakMap<Signal<any>, OptimisticLane>;
+export declare const activeLanes: Set<OptimisticLane>;
+/**
+ * Get an existing lane for a signal or create a new one.
+ * Reuses lane for multiple writes to the same signal.
+ */
+export declare function getOrCreateLane(signal: Signal<any>): OptimisticLane;
+/**
+ * Union-find: find the root lane.
+ */
+export declare function findLane(lane: OptimisticLane): OptimisticLane;
+/**
+ * Merge two lanes when their dependency graphs overlap.
+ */
+export declare function mergeLanes(lane1: OptimisticLane, lane2: OptimisticLane): OptimisticLane;
+/**
+ * Resolve a node's lane: follow union-find chain, verify active, clear if stale.
+ */
+export declare function resolveLane(el: {
+    _optimisticLane?: OptimisticLane;
+}): OptimisticLane | undefined;
+/**
+ * Check if a node has an active optimistic override (pending value differs from base).
+ */
+export declare function hasActiveOverride(el: {
+    _optimistic?: boolean;
+    _pendingValue?: any;
+}): boolean;
+/**
+ * Assign or merge a lane onto a node. At convergence points (node already has
+ * a different active lane), merge unless the node has an active override.
+ */
+export declare function assignOrMergeLane(el: {
+    _optimisticLane?: OptimisticLane;
+    _optimistic?: boolean;
+    _pendingValue?: any;
+}, sourceLane: OptimisticLane): void;

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

@@ -0,0 +1,22 @@
+import type { Computed, Disposable, Owner, Root } from "./types.js";
+export declare function markDisposal(el: Owner): void;
+export declare function dispose(node: Computed<unknown>): void;
+export declare function disposeChildren(node: Owner, self?: boolean, zombie?: boolean): void;
+export declare function getNextChildId(owner: Owner): string;
+export declare function getObserver(): Owner | null;
+export declare function getOwner(): Owner | null;
+export declare function onCleanup(fn: Disposable): Disposable;
+export declare function createOwner(options?: {
+    id: string;
+}): Root;
+/**
+ * Creates a new non-tracked reactive context with manual disposal
+ *
+ * @param fn a function in which the reactive state is scoped
+ * @returns the output of `fn`.
+ *
+ * @description https://docs.solidjs.com/reference/reactive-utilities/create-root
+ */
+export declare function createRoot<T>(init: ((dispose: () => void) => T) | (() => T), options?: {
+    id: string;
+}): T;

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

@@ -1,66 +1,13 @@
-import type { Computed, Signal } from "./core.js";
 import { type Heap } from "./heap.js";
+import { activeLanes, assignOrMergeLane, findLane } from "./lanes.js";
+import type { Computed, Signal } from "./types.js";
+export { activeLanes, assignOrMergeLane, findLane };
+export { getOrCreateLane, hasActiveOverride, mergeLanes, resolveLane, type OptimisticLane } from "./lanes.js";
 export declare const dirtyQueue: Heap;
 export declare const zombieQueue: Heap;
 export declare let clock: number;
 export declare let activeTransition: Transition | null;
 export declare let projectionWriteActive: boolean;
-/**
- * OptimisticLane represents the context for a single optimistic write.
- * Each optimistic signal creates its own lane. Lanes merge when their
- * dependency graphs overlap.
- */
-export interface OptimisticLane {
-    _source: Signal<any>;
-    _pendingAsync: Set<Computed<any>>;
-    _effectQueues: [QueueCallback[], QueueCallback[]];
-    _mergedInto: OptimisticLane | null;
-    _transition: Transition | null;
-    _parentLane: OptimisticLane | null;
-}
-export declare const activeLanes: Set<OptimisticLane>;
-export declare let currentOptimisticLane: OptimisticLane | null;
-export declare function setCurrentOptimisticLane(lane: OptimisticLane | null): void;
-/**
- * Get an existing lane for a signal or create a new one.
- * Reuses lane for multiple writes to the same signal.
- */
-export declare function getOrCreateLane(signal: Signal<any>): OptimisticLane;
-/**
- * Union-find: find the root lane.
- */
-export declare function findLane(lane: OptimisticLane): OptimisticLane;
-/**
- * Merge two lanes when their dependency graphs overlap.
- */
-export declare function mergeLanes(lane1: OptimisticLane, lane2: OptimisticLane): OptimisticLane;
-/**
- * Clear a signal's lane entry so the next getOrCreateLane creates a fresh lane.
- * Used after merging a sub-lane (e.g., _pendingSignal) into a parent lane.
- */
-export declare function clearLaneEntry(signal: Signal<any>): void;
-/**
- * Resolve a node's lane: follow union-find chain, verify active, clear if stale.
- */
-export declare function resolveLane(el: {
-    _optimisticLane?: OptimisticLane;
-}): OptimisticLane | undefined;
-/**
- * Check if a node has an active optimistic override (pending value differs from base).
- */
-export declare function hasActiveOverride(el: {
-    _optimistic?: boolean;
-    _pendingValue?: any;
-}): boolean;
-/**
- * Assign or merge a lane onto a node. At convergence points (node already has
- * a different active lane), merge unless the node has an active override.
- */
-export declare function assignOrMergeLane(el: {
-    _optimisticLane?: OptimisticLane;
-    _optimistic?: boolean;
-    _pendingValue?: any;
-}, sourceLane: OptimisticLane): void;
 export declare function setProjectionWriteActive(value: boolean): void;
 export type QueueCallback = (type: number) => void;
 type QueueStub = {
@@ -123,6 +70,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 currentTransition(transition: Transition): Transition;
+export declare function setActiveTransition(transition: Transition | null): 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) => Promise<R>;
-export {};

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

@@ -0,0 +1,74 @@
+import type { NOT_PENDING } from "./constants.js";
+import type { OptimisticLane } from "./lanes.js";
+import type { IQueue, Transition } from "./scheduler.js";
+export interface Disposable {
+    (): void;
+}
+export interface Link {
+    _dep: Signal<unknown> | Computed<unknown>;
+    _sub: Computed<unknown>;
+    _nextDep: Link | null;
+    _prevSub: Link | null;
+    _nextSub: Link | null;
+}
+export interface NodeOptions<T> {
+    id?: string;
+    name?: string;
+    equals?: ((prev: T, next: T) => boolean) | false;
+    pureWrite?: boolean;
+    unobserved?: () => void;
+    lazy?: boolean;
+}
+export interface RawSignal<T> {
+    _subs: Link | null;
+    _subsTail: Link | null;
+    _value: T;
+    _name?: string;
+    _equals: false | ((a: T, b: T) => boolean);
+    _pureWrite?: boolean;
+    _unobserved?: () => void;
+    _time: number;
+    _transition: Transition | null;
+    _pendingValue: T | typeof NOT_PENDING;
+    _optimistic?: boolean;
+    _optimisticLane?: OptimisticLane;
+    _pendingSignal?: Signal<boolean>;
+    _pendingValueComputed?: Computed<T>;
+    _parentSource?: Signal<any> | Computed<any>;
+}
+export interface FirewallSignal<T> extends RawSignal<T> {
+    _firewall: Computed<any>;
+    _nextChild: FirewallSignal<unknown> | null;
+}
+export type Signal<T> = RawSignal<T> | FirewallSignal<T>;
+export interface Owner {
+    id?: string;
+    _disposal: Disposable | Disposable[] | null;
+    _parent: Owner | null;
+    _context: Record<symbol | string, unknown>;
+    _childCount: number;
+    _queue: IQueue;
+    _firstChild: Owner | null;
+    _nextSibling: Owner | null;
+    _pendingDisposal: Disposable | Disposable[] | null;
+    _pendingFirstChild: Owner | null;
+}
+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: PromiseLike<T> | AsyncIterable<T> | null;
+    _child: FirewallSignal<any> | null;
+    _notifyStatus?: (status?: number, error?: any) => void;
+}
+export interface Root extends Owner {
+    _root: true;
+    _parentComputed: Computed<any> | null;
+    dispose(self?: boolean): void;
+}

package/dist/types/index.d.ts

@@ -1,6 +1,6 @@
-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 { ContextNotFoundError, NoOwnerError, NotReadyError, action, createContext, createOwner, createRoot, runWithOwner, flush, getNextChildId, getContext, setContext, getOwner, onCleanup, getObserver, isEqual, untrack, isPending, pending, isRefreshing, refresh, SUPPORTS_PROXY } from "./core/index.js";
+export type { Owner, Context, ContextRecord, IQueue } from "./core/index.js";
 export * from "./signals.js";
 export { mapArray, repeat, type Maybe } from "./map.js";
 export * from "./store/index.js";
-export { createLoadBoundary, createErrorBoundary, createBoundary, flatten, type BoundaryMode } from "./boundaries.js";
+export { createLoadBoundary, createErrorBoundary, flatten } from "./boundaries.js";