@solidjs/signals 0.13.13 → 2.0.0-beta.11

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

@@ -0,0 +1,12 @@
+export { ContextNotFoundError, NoOwnerError, NotReadyError } from "./error.js";
+export { isEqual, untrack, runWithOwner, computed, signal, read, setSignal, setMemo, suppressComputedRecompute, optimisticSignal, optimisticComputed, isPending, latest, refresh, isRefreshing, staleValues, setSnapshotCapture, markSnapshotScope, releaseSnapshotScope, clearSnapshots } from "./core.js";
+export { enableExternalSource, _resetExternalSourceConfig, type ExternalSourceFactory, type ExternalSource, type ExternalSourceConfig } from "./external.js";
+export { createOwner, createRoot, dispose, getNextChildId, getObserver, getOwner, isDisposed, cleanup, peekNextChildId } from "./owner.js";
+export { createContext, getContext, setContext, type Context, type ContextRecord } from "./context.js";
+export { handleAsync } from "./async.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 } from "./action.js";
+export { flush, Queue, GlobalQueue, trackOptimisticStore, enforceLoadingBoundary, type IQueue, type QueueCallback } from "./scheduler.js";
+export { DEV, type Dev, type DevHooks, type DiagnosticCapture, type DiagnosticCode, type DiagnosticEvent, type DiagnosticKind, type Diagnostics, type DiagnosticSeverity } from "./dev.js";
+export * from "./constants.js";

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

@@ -0,0 +1,54 @@
+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;
+export declare function resolveTransition(el: {
+    _optimisticLane?: OptimisticLane;
+    _transition?: Transition | null;
+}): Transition | null | undefined;
+/**
+ * Check if a node has an active optimistic override.
+ */
+export declare function hasActiveOverride(el: {
+    _overrideValue?: 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;
+    _overrideValue?: any;
+}, sourceLane: OptimisticLane): void;

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

@@ -0,0 +1,116 @@
+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;
+/**
+ * Allocates and returns the next stable child id for `owner`. Used by
+ * hydration plumbing and `createUniqueId`. Not part of the user-facing API.
+ *
+ * @internal
+ */
+export declare function getNextChildId(owner: Owner): string;
+/**
+ * Returns the *next* child id for `owner` without consuming it. Used by
+ * hydration plumbing to peek at the id a future child will receive.
+ *
+ * @internal
+ */
+export declare function peekNextChildId(owner: Owner): string;
+/**
+ * Returns the currently-tracking observer (the computation that subscribes to
+ * reactive reads at this point), or `null` if reads here would be untracked.
+ * Used by reactive primitives that need to know whether they're inside a
+ * tracking scope. App code rarely needs this — see `getOwner()` for the
+ * lifecycle owner instead.
+ *
+ * @example
+ * ```ts
+ * // Library predicate: only register a hot-path subscription when the
+ * // caller is inside a tracking scope (memo / effect compute / JSX).
+ * function trackIfTracked(source: () => unknown) {
+ *   if (getObserver()) source();
+ * }
+ * ```
+ */
+export declare function getObserver(): Owner | null;
+/**
+ * Returns the current reactive **owner** — the lifecycle node that the next
+ * `cleanup()` / `onCleanup()` / `createSignal()` etc. will be attached to.
+ *
+ * Returns `null` if called outside any owner. Capture the owner with
+ * `getOwner()` and re-enter it later with `runWithOwner(owner, fn)` to attach
+ * disposables created from a callback (event handler, async resolution, etc.)
+ * back to a component's lifecycle.
+ *
+ * @example
+ * ```ts
+ * function defer<T>(fn: () => T) {
+ *   const owner = getOwner();
+ *   queueMicrotask(() => runWithOwner(owner, fn));
+ * }
+ * ```
+ */
+export declare function getOwner(): Owner | null;
+/**
+ * Low-level: registers `fn` as a disposal callback on the current owner.
+ * Most code should use `onCleanup()` from `solid-js`, which adds dev-mode
+ * checks. `cleanup()` is the unchecked primitive used by internals.
+ */
+export declare function cleanup(fn: Disposable): Disposable;
+/**
+ * Returns `true` if the owner has been disposed (or marked zombie pending
+ * disposal). Pair with a captured owner to bail out of late callbacks whose
+ * surrounding component already unmounted.
+ *
+ * @example
+ * ```ts
+ * function onSettleSafe(fn: () => void) {
+ *   const owner = getOwner();
+ *   queueMicrotask(() => {
+ *     if (owner && isDisposed(owner)) return; // component unmounted; skip
+ *     runWithOwner(owner, fn);
+ *   });
+ * }
+ * ```
+ */
+export declare function isDisposed(node: Owner): boolean;
+/**
+ * Creates a fresh owner attached as a child of the current owner (or as a
+ * detached root if there is none). Used by framework internals to group
+ * cleanups; app code should use `createRoot()` (host a reactive scope outside
+ * a component) or `runWithOwner()` (re-enter a captured owner).
+ *
+ * @internal
+ */
+export declare function createOwner(options?: {
+    id?: string;
+    transparent?: boolean;
+}): Root;
+/**
+ * Creates a detached reactive root. The callback receives a `dispose()`
+ * function which, when called, tears down every signal, memo, effect, and
+ * `onCleanup` registered inside the root.
+ *
+ * Use this to host long-lived reactive scopes outside of a component (custom
+ * controllers, app bootstrapping, tests). Inside a component, prefer
+ * letting Solid's component lifecycle own things.
+ *
+ * @example
+ * ```ts
+ * const dispose = createRoot(dispose => {
+ *   const [n, setN] = createSignal(0);
+ *   createEffect(() => n(), value => console.log(value));
+ *   setInterval(() => setN(x => x + 1), 1000);
+ *   return dispose;
+ * });
+ *
+ * // Later, to tear everything down:
+ * dispose();
+ * ```
+ *
+ * @description https://docs.solidjs.com/reference/reactive-utilities/create-root
+ */
+export declare function createRoot<T>(init: ((dispose: () => void) => T) | (() => T), options?: {
+    id?: string;
+    transparent?: boolean;
+}): T;

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

@@ -0,0 +1,122 @@
+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 } 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;
+export declare let _hitUnhandledAsync: boolean;
+export declare function registerTransientStoreNode(node: Signal<any>): void;
+export declare function resetUnhandledAsync(): void;
+/**
+ * Toggles the dev-mode "must be inside a `<Loading>` boundary" enforcement
+ * window. Only `render()` calls this — wrapping the initial mount so that a
+ * top-level uncaught async read surfaces the diagnostic. Not part of the
+ * user-facing API.
+ *
+ * @internal
+ */
+export declare function enforceLoadingBoundary(enabled: boolean): void;
+export declare function shouldReadStashedOptimisticValue(node: Signal<any>): boolean;
+export declare function setProjectionWriteActive(value: boolean): void;
+export declare function setTrackedQueueCallback(value: boolean): void;
+export type QueueCallback = (type: number) => void;
+type QueueStub = {
+    _queues: [QueueCallback[], QueueCallback[]];
+    _children: QueueStub[];
+};
+type OptimisticNode = Signal<any> | Computed<any>;
+export interface Transition {
+    _time: number;
+    _asyncReporters: Map<Computed<any>, Set<Computed<any>>>;
+    _pendingNodes: Signal<any>[];
+    _optimisticNodes: OptimisticNode[];
+    _optimisticStores: Set<any>;
+    _actions: Array<Generator<any, any, any> | AsyncGenerator<any, any, any>>;
+    _queueStash: QueueStub;
+    _done: boolean | Transition;
+    _gatedSubs: Set<Computed<any>>;
+}
+export declare function schedule(): void;
+export interface IQueue {
+    enqueue(type: number, fn: QueueCallback): void;
+    run(type: number): boolean | void;
+    addChild(child: IQueue): void;
+    removeChild(child: IQueue): void;
+    created: number;
+    notify(node: Computed<any>, mask: number, flags: number, error?: any): boolean;
+    stashQueues(stub: QueueStub): void;
+    restoreQueues(stub: QueueStub): void;
+    _parent: IQueue | null;
+}
+export declare class Queue implements IQueue {
+    _parent: IQueue | null;
+    _queues: [QueueCallback[], QueueCallback[]];
+    _children: IQueue[];
+    created: number;
+    addChild(child: IQueue): void;
+    removeChild(child: IQueue): void;
+    notify(node: Computed<any>, mask: number, flags: number, error?: any): boolean;
+    run(type: number): void;
+    enqueue(type: number, fn: QueueCallback): void;
+    stashQueues(stub: QueueStub): void;
+    restoreQueues(stub: QueueStub): void;
+}
+export declare class GlobalQueue extends Queue {
+    _running: boolean;
+    _pendingNode: Signal<any> | null;
+    _pendingNodes: Signal<any>[];
+    _optimisticNodes: OptimisticNode[];
+    _optimisticStores: Set<any>;
+    static _update: (el: Computed<unknown>) => void;
+    static _dispose: (el: Computed<unknown>, self: boolean, zombie: boolean) => void;
+    static _runEffect: (el: Computed<unknown>) => void;
+    static _clearOptimisticStore: ((store: any) => void) | null;
+    flush(): void;
+    notify(node: Computed<any>, mask: number, flags: number, error?: any): boolean;
+    initTransition(transition?: Transition | null): void;
+}
+export declare function queuePendingNode(node: Signal<any>): 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;
+/**
+ * Synchronously processes the pending reactive queue, or runs `fn` in a synchronous
+ * flush scope before draining the queue.
+ *
+ * Reactive updates are normally batched onto the microtask queue, so multiple
+ * writes in a row collapse into a single update pass. Call `flush()` when you
+ * need to *observe* the result of those writes synchronously — most commonly
+ * in tests, but also at the boundary of imperative integration code. Pass a
+ * callback when the writes themselves should bypass microtask scheduling and
+ * drain synchronously when the callback returns.
+ *
+ * @example
+ * ```ts
+ * const [count, setCount] = createSignal(0);
+ * const doubled = createMemo(() => count() * 2);
+ *
+ * setCount(5);
+ * flush();
+ * expect(doubled()).toBe(10);
+ *
+ * flush(() => setCount(6));
+ * expect(doubled()).toBe(12);
+ *
+ * // Nested flushes drain at each level:
+ * flush(() => {
+ *   setCount(7);
+ *   flush(() => setCount(8)); // inner drain — effects fire here
+ *   // outer continues with up-to-date state
+ * });
+ * ```
+ */
+export declare function flush(): void;
+export declare function flush<T>(fn: () => T): T;
+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;

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

@@ -0,0 +1,85 @@
+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;
+    transparent?: boolean;
+    equals?: ((prev: T, next: T) => boolean) | false;
+    ownedWrite?: boolean;
+    /** Exclude this signal from snapshot capture (internal — not part of public API) */
+    _noSnapshot?: boolean;
+    unobserved?: () => void;
+    lazy?: boolean;
+    sync?: boolean;
+}
+export interface RawSignal<T> {
+    _subs: Link | null;
+    _subsTail: Link | null;
+    _value: T;
+    _snapshotValue?: any;
+    _name?: string;
+    _equals: false | ((a: T, b: T) => boolean);
+    _config: number;
+    _unobserved?: () => void;
+    _time: number;
+    _transition: Transition | null;
+    _pendingValue: T | typeof NOT_PENDING;
+    _overrideValue?: T | typeof NOT_PENDING;
+    _optimisticLane?: OptimisticLane;
+    _pendingSignal?: Signal<boolean>;
+    _latestValueComputed?: 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;
+    _config: number;
+    _snapshotScope?: boolean;
+    _disposal: Disposable | Disposable[] | null;
+    _parent: Owner | null;
+    _context: Record<symbol | string, unknown>;
+    _childCount: number;
+    _queue: IQueue;
+    _firstChild: Owner | null;
+    _nextSibling: Owner | null;
+    _prevSibling: 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;
+    _blocked?: boolean;
+    _pendingSource?: Computed<any>;
+    _pendingSources?: Set<Computed<any>>;
+    _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/src/index.d.ts

@@ -0,0 +1,9 @@
+export { $REFRESH, ContextNotFoundError, NoOwnerError, NotReadyError, action, createContext, createOwner, createRoot, runWithOwner, flush, getNextChildId, peekNextChildId, getContext, setContext, getOwner, isDisposed, getObserver, isEqual, untrack, isPending, latest, isRefreshing, refresh, SUPPORTS_PROXY, setSnapshotCapture, markSnapshotScope, releaseSnapshotScope, clearSnapshots, enforceLoadingBoundary, enableExternalSource } from "./core/index.js";
+import { type Dev } from "./core/index.js";
+export declare const DEV: Dev | undefined;
+export type { Owner, Context, ContextRecord, IQueue, ExternalSourceFactory, ExternalSource, ExternalSourceConfig, Refreshable, Dev, DevHooks, DiagnosticCapture, DiagnosticCode, DiagnosticEvent, DiagnosticKind, Diagnostics, DiagnosticSeverity } from "./core/index.js";
+export { createSignal, createMemo, createEffect, createRenderEffect, createTrackedEffect, createReaction, createOptimistic, resolve, onSettled, onCleanup } from "./signals.js";
+export type { Accessor, SourceAccessor, Setter, Signal, ComputeFunction, EffectFunction, EffectBundle, EffectOptions, SignalOptions, MemoOptions, NoInfer } from "./signals.js";
+export { mapArray, repeat, type Maybe } from "./map.js";
+export * from "./store/index.js";
+export { createLoadingBoundary, createErrorBoundary, createRevealOrder, flatten, type RevealOrder } from "./boundaries.js";

package/dist/types/src/map.d.ts

@@ -0,0 +1,53 @@
+import { type Accessor } from "./signals.js";
+export type Maybe<T> = T | void | null | undefined | false;
+/**
+ * Reactively maps an array, reusing the previously-mapped value for unchanged
+ * items. The callback receives `(value, index)` as accessors so individual
+ * items and indexes can be subscribed to without re-running the mapper.
+ *
+ * This is the underlying helper that powers `<For>`. App code should use
+ * `<For>` directly; reach for `mapArray` when implementing custom list
+ * components.
+ *
+ * - `options.keyed` — `true` (default for primitives) compares by identity;
+ *   `false` falls back to index-only mapping; pass a function `(item) => key`
+ *   for stable identity by extracted key.
+ * - `options.fallback` — accessor returning a value to show when the input is
+ *   empty.
+ *
+ * @example
+ * ```ts
+ * const view = mapArray(
+ *   items,
+ *   (item, index) => `${index()}: ${item().label}`,
+ *   { fallback: () => "no items" }
+ * );
+ * ```
+ *
+ * @description https://docs.solidjs.com/reference/reactive-utilities/map-array
+ */
+export declare function mapArray<Item, MappedItem>(list: Accessor<Maybe<readonly Item[]>>, map: (value: Accessor<Item>, index: Accessor<number>) => MappedItem, options?: {
+    keyed?: boolean | ((item: Item) => any);
+    fallback?: Accessor<any>;
+    name?: string;
+}): Accessor<MappedItem[]>;
+/**
+ * Reactively renders a callback `count` times, reusing previously-rendered
+ * entries when only the count changes. Underlying helper for `<Repeat>`.
+ *
+ * - `options.from` — start index (default `0`); useful for offset/windowed
+ *   rendering.
+ * - `options.fallback` — accessor returning a value to show when count is `0`.
+ *
+ * @example
+ * ```ts
+ * const view = repeat(count, i => `Item ${i}`, { fallback: () => "empty" });
+ * ```
+ *
+ * @description https://docs.solidjs.com/reference/reactive-utilities/repeat
+ */
+export declare function repeat(count: Accessor<number>, map: (index: number) => any, options?: {
+    from?: Accessor<number | undefined>;
+    fallback?: Accessor<any>;
+    name?: string;
+}): Accessor<any[]>;