@solidjs/signals 2.0.0-beta.15 → 2.0.0-beta.16

package/dist/types-cjs/src/core/scheduler.d.cts

@@ -1,122 +0,0 @@
-import { type Heap } from "./heap.cjs";
-import { activeLanes, assignOrMergeLane, findLane } from "./lanes.cjs";
-import type { Computed, Signal } from "./types.cjs";
-export { activeLanes, assignOrMergeLane, findLane };
-export { getOrCreateLane, hasActiveOverride, mergeLanes, resolveLane } from "./lanes.cjs";
-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-cjs/src/core/types.d.cts

@@ -1,85 +0,0 @@
-import type { NOT_PENDING } from "./constants.cjs";
-import type { OptimisticLane } from "./lanes.cjs";
-import type { IQueue, Transition } from "./scheduler.cjs";
-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-cjs/src/index.d.cts

@@ -1,9 +0,0 @@
-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.cjs";
-import { type Dev } from "./core/index.cjs";
-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.cjs";
-export { createSignal, createMemo, createEffect, createRenderEffect, createTrackedEffect, createReaction, createOptimistic, resolve, onSettled, onCleanup } from "./signals.cjs";
-export type { Accessor, SourceAccessor, Setter, Signal, ComputeFunction, EffectFunction, EffectBundle, EffectOptions, SignalOptions, MemoOptions, NoInfer } from "./signals.cjs";
-export { mapArray, repeat, type Maybe } from "./map.cjs";
-export * from "./store/index.cjs";
-export { createLoadingBoundary, createErrorBoundary, createRevealOrder, flatten, type RevealOrder } from "./boundaries.cjs";

package/dist/types-cjs/src/map.d.cts

@@ -1,53 +0,0 @@
-import { type Accessor } from "./signals.cjs";
-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[]>;