@solidjs/signals 0.13.13 → 2.0.0-beta.11

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

@@ -9,7 +9,16 @@ 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;
@@ -29,6 +38,7 @@ export interface Transition {
     _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 {
@@ -57,25 +67,56 @@ export declare class Queue implements IQueue {
 }
 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;
 /**
- * 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()`.
+ * 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/core/types.d.ts

@@ -16,11 +16,12 @@ export interface NodeOptions<T> {
     name?: string;
     transparent?: boolean;
     equals?: ((prev: T, next: T) => boolean) | false;
-    pureWrite?: boolean;
+    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;
@@ -29,8 +30,7 @@ export interface RawSignal<T> {
     _snapshotValue?: any;
     _name?: string;
     _equals: false | ((a: T, b: T) => boolean);
-    _pureWrite?: boolean;
-    _noSnapshot?: boolean;
+    _config: number;
     _unobserved?: () => void;
     _time: number;
     _transition: Transition | null;
@@ -48,8 +48,7 @@ export interface FirewallSignal<T> extends RawSignal<T> {
 export type Signal<T> = RawSignal<T> | FirewallSignal<T>;
 export interface Owner {
     id?: string;
-    _transparent?: boolean;
-    _childrenForbidden?: boolean;
+    _config: number;
     _snapshotScope?: boolean;
     _disposal: Disposable | Disposable[] | null;
     _parent: Owner | null;
@@ -58,6 +57,7 @@ export interface Owner {
     _queue: IQueue;
     _firstChild: Owner | null;
     _nextSibling: Owner | null;
+    _prevSibling: Owner | null;
     _pendingDisposal: Disposable | Disposable[] | null;
     _pendingFirstChild: Owner | null;
 }
@@ -65,7 +65,6 @@ export interface Computed<T> extends RawSignal<T>, Owner {
     _deps: Link | null;
     _depsTail: Link | null;
     _flags: number;
-    _inSnapshotScope?: boolean;
     _blocked?: boolean;
     _pendingSource?: Computed<any>;
     _pendingSources?: Set<Computed<any>>;

package/dist/types/index.d.ts

@@ -1,9 +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, Dev, DevHooks, DiagnosticCapture, DiagnosticCode, DiagnosticEvent, DiagnosticKind, Diagnostics, DiagnosticSeverity } from "./core/index.js";
+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, Setter, Signal, ComputeFunction, EffectFunction, EffectBundle, EffectOptions, SignalOptions, MemoOptions, NoInfer } 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 } from "./boundaries.js";
+export { createLoadingBoundary, createErrorBoundary, createRevealOrder, flatten, type RevealOrder } from "./boundaries.js";

package/dist/types/map.d.ts

@@ -1,9 +1,28 @@
 import { type Accessor } from "./signals.js";
 export type Maybe<T> = T | void | null | undefined | false;
 /**
- * Reactively transforms an array with a callback function - underlying helper for the `<For>` control flow
+ * 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.
  *
- * similar to `Array.prototype.map`, but gets the value and index as accessors, transforms only values that changed and returns an accessor and reactively tracks changes to the list.
+ * 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
  */
@@ -13,7 +32,17 @@ export declare function mapArray<Item, MappedItem>(list: Accessor<Maybe<readonly
     name?: string;
 }): Accessor<MappedItem[]>;
 /**
- * Reactively repeats a callback function the count provided - underlying helper for the `<Repeat>` control flow
+ * 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
  */