@solidjs/signals 2.0.0-rc.7 → 2.0.0-rc.9

package/dist/types-cjs/affects.d.cts

@@ -1,47 +0,0 @@
-import type { Accessor } from "./signals.cjs";
-import { type Store } from "./store/store.cjs";
-/**
- * Declares that in-flight work will change the targeted data: the named
- * slot(s) — and everything DERIVED from them — read as pending
- * (`isPending` → `true`) from the declaration until the surrounding
- * transaction settles or reverts. A mark lives on its own channel — a
- * refcount on the marked node plus dep-graph reachability in the verdict
- * layer — so the marked values themselves stay readable (a mark is a promise
- * of change, not an absence of value), no reader ever suspends on one, and
- * completion/settlement accounting never sees one. This is the declaration
- * verb of the pending model — additive only. A mark can turn pending ON for
- * data the graph can't see changing yet; nothing can turn pending OFF while
- * a real change is in flight — a quiet `refresh()` re-ask under a mark still
- * reads pending (declaring the reload is what makes it a real question).
- *
- * Targets:
- * - `affects(store)` — a store proxy (any record, root or nested): every
- *   record reachable from it at declaration time reads pending, including
- *   through captured child proxies (e.g. `<For>` rows). Siblings are
- *   untouched; records added after the declaration are not covered.
- * - `affects(record, key)` — exactly the named slot of the record. One key
- *   per call (keys do NOT form a path — target the owning record directly).
- * - `affects(accessor)` — a source accessor (signal or memo): the source
- *   reads pending.
- *
- * Typically called at the top of an `action` alongside optimistic writes —
- * both are up-front declarations about the same mutation. Outside any
- * transaction the mark is released at the end of the current flush.
- *
- * @example
- * ```ts
- * const send = action(function* (text: string) {
- *   setState(s => { s.messages.push({ text, status: "sending" }); });
- *   affects(state.messages.at(-1)!, "status"); // this slot pends until settle
- *   yield api.send(text);
- * });
- *
- * const reload = action(function* () {
- *   affects(thing);      // the whole store pends…
- *   refresh(thing);      // …over this otherwise-quiet re-ask
- *   yield api.done();
- * });
- * ```
- */
-export declare function affects(target: Accessor<unknown> | Store<object>): void;
-export declare function affects<T extends object>(target: Store<T>, key: keyof T): void;

package/dist/types-cjs/boundaries.d.cts

@@ -1,175 +0,0 @@
-import { Queue, type Computed, type Effect } from "./core/index.cjs";
-import type { Signal } from "./core/index.cjs";
-import { type Accessor } from "./signals.cjs";
-export interface BoundaryComputed<T> extends Computed<T> {
-    _propagationMask: number;
-}
-type RevealSlot = CollectionQueue | RevealController;
-type BoolAccessor = () => boolean;
-export type RevealOrder = "sequential" | "together" | "natural";
-type OrderAccessor = () => RevealOrder;
-export declare class RevealController {
-    _orderAccessor: OrderAccessor;
-    _collapsedAccessor: BoolAccessor;
-    _slots: RevealSlot[];
-    _parentController?: RevealController;
-    _disabled: Signal<boolean>;
-    _collapsed: Signal<boolean>;
-    _ready: boolean;
-    _minimallyReady: boolean;
-    _evaluating: boolean;
-    constructor(order: OrderAccessor, collapsed: BoolAccessor);
-    _forEachOwnedSlot(fn: (slot: RevealSlot) => boolean | void): boolean;
-    _isReady(): boolean;
-    /**
-     * "Minimally ready" = this group has something visible to show under its own policy.
-     * Used by an enclosing `together` group to decide when it can release.
-     * - `together`: every direct slot is minimally ready.
-     * - `sequential`: the first owned slot is minimally ready (frontier can advance).
-     * - `natural`: any owned slot is minimally ready.
-     */
-    _isMinimallyReady(): boolean;
-    _register(slot: RevealSlot): void;
-    _unregister(slot: RevealSlot): void;
-    _evaluate(disabledOverride?: boolean, collapsedOverride?: boolean): void;
-}
-export declare class CollectionQueue extends Queue {
-    _collectionType: number;
-    _sources: Set<Computed<any>>;
-    _tree?: BoundaryComputed<any>;
-    _pending: boolean;
-    _disabled: Signal<boolean>;
-    _error?: Signal<unknown>;
-    _collapsed: Signal<boolean>;
-    _revealController?: RevealController;
-    _initialized: boolean;
-    _onFn: (() => any) | undefined;
-    _prevOn: any;
-    constructor(type: number);
-    run(type: number): void;
-    notify(node: Effect<any>, type: number, flags: number, error?: any): boolean;
-    _checkSources(): void;
-}
-/**
- * Lower-level primitive that backs the `<Loading>` flow control. Catches
- * pending async reads inside `fn` and renders `fallback` until they settle.
- *
- * App code should use `<Loading fallback={...}>` instead — reach for this only
- * when authoring custom boundary components.
- *
- * @param fn the tracked subtree
- * @param fallback the fallback shown while async reads in `fn` are unresolved
- * @param options `on` — accessor whose value scopes the boundary; when set,
- *   transitions caused by writes to other reactive sources are *not* caught
- *
- * @example
- * ```tsx
- * // Custom boundary component built on top of the primitive.
- * function MyLoading(props: { fallback: JSX.Element; children: JSX.Element }) {
- *   return createLoadingBoundary(
- *     () => props.children,
- *     () => props.fallback
- *   ) as unknown as JSX.Element;
- * }
- * ```
- */
-export declare function createLoadingBoundary<T, U>(fn: () => T, fallback: () => U, options?: {
-    on?: () => any;
-}): Accessor<T | U>;
-/**
- * Lower-level primitive that backs the `<Errored>` flow control. Catches
- * thrown errors inside `fn` and invokes `fallback(error, reset)` instead.
- * `error` is an accessor for the latest captured error; `reset()` recomputes
- * the failing sources so the boundary can attempt to recover.
- *
- * App code should use `<Errored fallback={...}>` instead — reach for this only
- * when authoring custom boundary components.
- *
- * @example
- * ```tsx
- * // Custom boundary that wraps the primitive and adds telemetry.
- * function TracedErrored(props: { fallback: (e: () => unknown) => JSX.Element; children: JSX.Element }) {
- *   return createErrorBoundary(
- *     () => props.children,
- *     (err, reset) => {
- *       reportError(err());
- *       return props.fallback(err);
- *     }
- *   ) as unknown as JSX.Element;
- * }
- * ```
- */
-export declare function createErrorBoundary<T, U>(fn: () => T, fallback: (error: Accessor<unknown>, reset: () => void) => U): Accessor<T | U>;
-/**
- * Coordinate the reveal timing of sibling loading boundaries.
- *
- * Accepts reactive accessors:
- * - `order`: `"sequential"` (default) | `"together"` | `"natural"`.
- *   - `"sequential"` — classic frontier reveal: siblings reveal in registration order
- *     as each resolves; later siblings stay hidden until earlier ones complete.
- *   - `"together"` — every direct slot stays on its fallback until the whole group
- *     is "minimally ready" (each direct slot has produced its own first visible
- *     content under its own order), then the whole group releases at once.
- *   - `"natural"` — children reveal independently (as each resolves). At the top
- *     level this is a no-op compared to not using `createRevealOrder`; the mode
- *     exists for nesting, where the group registers as a single composite slot to
- *     any enclosing `createRevealOrder`.
- * - `collapsed`: only meaningful when `order === "sequential"`. When set, tail siblings
- *   past the frontier suppress their own fallback output. Ignored under `"together"`
- *   and `"natural"` — those orders have no frontier.
- *
- * Nested `createRevealOrder` groups compose: the inner controller registers as a
- * single slot in the outer controller and is held on its fallbacks until the outer
- * releases that slot. Once released, the inner controller runs its own order locally
- * over anything still pending. There is no opt-out from an outer hold.
- *
- * "Minimally ready" is what an order considers its first visible content:
- * - `sequential` — frontier-0 is minimally ready (leaf: on resolve; nested: via its
- *   own minimal signal).
- * - `together` — every direct slot is minimally ready.
- * - `natural` — any direct slot has visible content (leaves on resolve; nested
- *   composites via their own minimal signal).
- *
- * @example
- * ```ts
- * // Primitive form of `<Reveal>` — coordinate sibling loading boundaries
- * // programmatically. App code uses the JSX `<Reveal>` component instead.
- * // Both options are accessors so they can react to state changes.
- * createRevealOrder(
- *   () => renderSiblings(),
- *   { order: () => mode(), collapsed: () => true }
- * );
- * ```
- */
-export declare function createRevealOrder<T>(fn: () => T, options?: {
-    order?: OrderAccessor;
-    collapsed?: BoolAccessor;
-}): T;
-/**
- * Resolves a children value to its renderable form: unwraps zero-arg functions
- * (accessors), recursively flattens arrays, and optionally skips
- * non-rendering values (`null`, `undefined`, `true`, `false`, `""`).
- *
- * Used internally by flow components and by the renderer to walk a children
- * tree. App code rarely needs this directly — see `children()` in `solid-js`
- * for the user-facing helper that memoizes the result.
- *
- * @param children value or array of values to flatten
- * @param options
- *   - `skipNonRendered` — drop values that won't render
- *   - `doNotUnwrap` — leave function children as-is (caller will resolve)
- *
- * @example
- * ```ts
- * // Custom renderer walking a children tree manually. Most authors should
- * // use `children()` from solid-js, which memoizes the resolved value.
- * function renderChildren(value: unknown): unknown {
- *   return flatten(value, { skipNonRendered: true });
- * }
- * ```
- */
-export declare function flatten(children: any, options?: {
-    skipNonRendered?: boolean;
-    doNotUnwrap?: boolean;
-}): any;
-export {};

package/dist/types-cjs/core/action.d.cts

@@ -1,64 +0,0 @@
-/**
- * The primitive for mutations: imperative async workflows whose *writes span
- * an async gap* — optimistic write, server round-trip, reconciling write —
- * where intermediate state must not leak and failure must revert cleanly
- * (pair with `createOptimistic` / `createOptimisticStore`).
- *
- * Navigation-shaped updates do not need an action. A plain setter call is
- * enough: reads pull the async, and downstream async computeds hold their
- * previous values per-node until the new ones are ready (`isPending` /
- * `latest` expose the in-flight state). Reach for `action` only when writes
- * happen *after* async work, not merely upstream of it.
- *
- * Framework-level actions (router form actions, server actions) are
- * specializations of this primitive: they are actions in exactly this sense —
- * the same transactional semantics — with form binding, serialization, and
- * submission tracking layered on top. The shared name is deliberate.
- *
- * Wraps a generator function so each invocation runs as a single transaction
- * (a "transition") that batches every signal/store write between yields. The
- * surrounding UI sees one atomic update per yielded step; nothing is committed
- * until the action either completes or the next `yield` resolves.
- *
- * `yield` is the transaction-safe suspension point: the action waits for a
- * yielded promise and re-enters the transaction before running the code after
- * it. A plain `await` does NOT — the runtime has no hook into an async
- * generator's internal await continuations, so writes to fresh signals
- * between an `await` and the next `yield` escape the transaction and commit
- * immediately. `await` is still the ergonomic choice for typed results; just
- * put a bare `yield` before any writes that follow it:
- *
- * ```ts
- * const saved = await api.createTodo(text); // typed result
- * yield; // re-enter the transaction before writing
- * setTodos(t => { ... });
- * ```
- *
- * (For the same reason, don't call `flush()` inside an action body — it
- * drains the transaction mid-step.)
- *
- * Each call returns a `Promise` that resolves with the generator's return
- * value, or rejects if it throws. Pair with `createOptimistic` /
- * `createOptimisticStore` to apply tentative writes that auto-revert if the
- * action fails.
- *
- * @example
- * ```ts
- * const [todos, setTodos] = createOptimisticStore<Todo[]>([]);
- *
- * const addTodo = action(async function* (text: string) {
- *   const tempId = crypto.randomUUID();
- *   setTodos(t => { t.push({ id: tempId, text, pending: true }); }); // optimistic
- *   const saved = await api.createTodo(text); // network round-trip, typed
- *   yield; // re-enter the transaction
- *   setTodos(t => {
- *     const i = t.findIndex(x => x.id === tempId);
- *     if (i >= 0) t[i] = saved;
- *   });
- *   return saved;
- * });
- *
- * await addTodo("buy milk");
- * ```
- */
-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-cjs/core/async.d.cts

@@ -1,23 +0,0 @@
-import { NotReadyError } from "./error.cjs";
-import { type OptimisticLane } from "./lanes.cjs";
-import type { Computed, Link } from "./types.cjs";
-export declare function addPendingSource(el: Computed<any>, source: Computed<any>): boolean;
-/**
- * A loading-window node hit an unready source (sync throw in recompute, or a
- * NotReadyError-rejected flight): register for the source's settle — the
- * settlePendingSource walk runs off `_pendingSources` + `_blocked` alone —
- * with NO read-visible pending status, no downstream propagation, no
- * transition, no lane registration. Commit #0 keeps serving.
- */
-export declare function parkLoadingWindow(el: Computed<any>, e: NotReadyError): void;
-export declare function setPendingError(el: Computed<any>, source?: Computed<any>, error?: any): void;
-export declare function forEachDependent(el: Computed<any>, fn: (node: Computed<any>, link: Link) => void): void;
-export declare function releaseSettledDependents(el: Computed<any>): void;
-export declare function settleErroredDependents(el: Computed<any>, error: any): void;
-export declare function settlePendingSource(el: Computed<any>): void;
-export declare function isThenable<T>(value: T | PromiseLike<T>): value is PromiseLike<T>;
-/** Fire and clear a node's iterator-flight cancellation hook (#3122). */
-export declare function releaseFlightTeardown(el: Computed<any>): void;
-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>, clearUninitialized?: boolean): void;
-export declare function notifyStatus(el: Computed<any>, status: number, error: any, blockStatus?: boolean, lane?: OptimisticLane): void;

package/dist/types-cjs/core/attribution-hooks.d.cts

@@ -1,127 +0,0 @@
-import type { Transition } from "./scheduler.cjs";
-import type { Computed, Signal } from "./types.cjs";
-/**
- * Dev-only observability hook points for the reactive core.
- *
- * Core's obligation is to call these with true facts at the moments they
- * happen; ALL attribution semantics (stamps, cause chains, timings, warnings)
- * live in the engine that installs them (attribution.ts — same pattern as the
- * GlobalQueue._* feature slots). `attrHooks` is null unless an engine is
- * installed, so the disabled cost is one null check per site, and prod builds
- * fold every site out behind __DEV__.
- *
- * IMPORTANT for implementers of call sites: a hook call must never sit inside
- * a `try` block — rollup's tryCatchDeoptimization retains functions referenced
- * inside `try` even behind a folded __DEV__ guard, which re-couples the dev
- * engine into prod bundles (#2883 harness). Set a local flag inside the try
- * and call the hook after the catch.
- */
-export interface AttributionHooks {
-    /**
-     * A recompute is starting; `el._deps` still holds the previous run's links.
-     * Always paired with `recomputeEnd` (recompute has no early returns).
-     */
-    recomputeStart(el: Computed<any>, create: boolean): void;
-    /**
-     * The recompute finished. `changed` = committed a changed value (false for
-     * errored runs); `optimistic` = ran under an optimistic lane / lane-dirty
-     * posture; `transition` = a transition was active or owns this node;
-     * `held` = the value went to `_pendingValue` (a transition hold) rather
-     * than committing directly — its reveal happens later on the transition's
-     * own schedule.
-     */
-    recomputeEnd(el: Computed<any>, create: boolean, changed: boolean, optimistic: boolean, transition: boolean, held: boolean): void;
-    /** A non-effect computed committed a changed value during a re-run. */
-    derivedChanged(el: Computed<any>): void;
-    /** A signal write committed (value passed the equality gate). */
-    write(el: Signal<any> | Computed<any>, prev: unknown, value: unknown): void;
-    /** refresh() invalidated this node (self-invalidation, no dep changed). */
-    refreshed(el: Computed<any>): void;
-    /**
-     * A new async flight entered the system (`_inFlight` was just assigned
-     * during a recompute of `el`). Always fired inside the owning recompute —
-     * both call paths (core's recompute and the projection self-registration)
-     * run within one — so the engine can read the current frame stack to link
-     * the flight to the change that caused it (waterfall chaining). `flight`
-     * is the registered thenable/iterable itself: the engine keys a first-seen
-     * origin registry on its identity, so shared and preloader-marked promises
-     * carry their true start time instead of the moment the graph saw them.
-     */
-    flightStart(el: Computed<any>, flight: object): void;
-    /** An async landing is about to apply its value (before any branch). */
-    asyncStart(el: Computed<any>): void;
-    /**
-     * The async landing finished. `direct` = the landing applies the value
-     * itself (lane/override paths); false = it went through setSignal, whose
-     * own `write` hook already saw any committed change. Fired whether or not
-     * the landing committed — call sites cannot carry that fact out of their
-     * try blocks (see the try rule above), so the engine derives committed-ness
-     * from the node's state against its asyncStart snapshot.
-     */
-    asyncEnd(el: Computed<any>, prev: unknown, value: unknown, direct: boolean): void;
-    /**
-     * An effect's imperative half (its effect callback) is about to run /
-     * has run. Both fire outside the run's try; `effectRunEnd` fires whether
-     * or not the callback threw. Writes between the two are the effect's.
-     */
-    effectRunStart(el: Computed<any>): void;
-    effectRunEnd(el: Computed<any>): void;
-    /**
-     * One synchronous step of an `action()` generator is about to run / has
-     * run (`it.next()`/`it.throw()` up to the next yield). `it` is the
-     * invocation's iterator — stable identity across its steps; `name` the
-     * generator function's name. Writes between the two are the action's.
-     */
-    actionStepStart(it: object, name: string | undefined): void;
-    actionStepEnd(it: object): void;
-    /**
-     * A flush found `t` incomplete (transitionComplete's false verdict): its
-     * writes stay staged and its queues are about to be parked. Fired BEFORE
-     * this flush's lane effects (the visible acknowledgers — isPending
-     * companions, optimistic values) run; `holdEnd` fires from the root
-     * stashQueues call after them, so effect runs between the two are runs that
-     * painted *during* the hold.
-     */
-    holdStart(t: Transition): void;
-    holdEnd(): void;
-    /**
-     * `t` was judged complete (transitionComplete's true verdict, before `_done`
-     * flips). Fired before its held writes commit, so `t._pendingNodes` still
-     * lists what was staged.
-     */
-    transitionSettled(t: Transition): void;
-    /** `outgoing` was folded into `target` (`outgoing._done = target`). */
-    transitionMerged(target: Transition, outgoing: Transition): void;
-    /**
-     * A store setter batch replaced the container at `path` (e.g. `store.user`)
-     * with a different one (both non-null, same array-ness, not the same
-     * logical slot), and this is the leaf census of the new container against
-     * the old: `total` leaves (own keys, or items) in the new one, `unchanged`
-     * of which are the same value as before (identity, judged on unwrapped
-     * values — object keys compared by key, array items by membership), and
-     * `prevTotal` leaves in the old one. Containers above 64 leaves are not
-     * announced. Fired per written key from the write channel's notify. The
-     * engine decides whether the replacement was a spread-copy worth a
-     * diagnostic.
-     */
-    storeReplaced(path: string, isArray: boolean, total: number, unchanged: number, prevTotal: number): void;
-    /**
-     * A `mapArray` update both disposed and created rows: `removed` are the
-     * items whose rows were disposed, `created` the items that got new rows,
-     * `newLen` the list's new length, `keyed` whether a key function is in use
-     * (false = identity or by-index). Fired after commit. The engine judges
-     * whether the churn replaced equivalent records (unstable identity).
-     */
-    listChurn(el: Computed<any>, removed: unknown[], created: unknown[], newLen: number, keyed: boolean): void;
-    /**
-     * A loading boundary started (`shown` true) or stopped showing its
-     * fallback. `boundary` is the boundary's queue (stable identity); `tree`
-     * its bound subtree computed when already constructed — the first show can
-     * fire while the subtree is still being built — whose owner chain names
-     * the boundary. Fired at the source-set transitions (first pending source
-     * registers / last one clears), not per flush.
-     */
-    boundaryFallback(boundary: object, tree: Computed<any> | undefined, shown: boolean): void;
-}
-export declare let attrHooks: AttributionHooks | null;
-export declare function setAttributionHooks(hooks: AttributionHooks | null): void;