@tstdl/base 0.93.181 → 0.93.183

package/signals/implementation/primitive/linked_signal.d.ts

@@ -0,0 +1,46 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { type ValueEqualityFn } from './equality.js';
+import { type ReactiveNode, SIGNAL } from './graph.js';
+export type ComputationFn<S, D> = (source: S, previous?: PreviousValue<S, D>) => D;
+export type PreviousValue<S, D> = {
+    source: S;
+    value: D;
+};
+export interface LinkedSignalNode<S, D> extends ReactiveNode {
+    /**
+     * Value of the source signal that was used to derive the computed value.
+     */
+    sourceValue: S;
+    /**
+     * Current state value, or one of the sentinel values (`UNSET`, `COMPUTING`,
+     * `ERROR`).
+     */
+    value: D;
+    /**
+     * If `value` is `ERRORED`, the error caught from the last computation attempt which will
+     * be re-thrown.
+     */
+    error: unknown;
+    /**
+     * The source function represents reactive dependency based on which the linked state is reset.
+     */
+    source: () => S;
+    /**
+     * The computation function which will produce a new value based on the source and, optionally - previous values.
+     */
+    computation: ComputationFn<S, D>;
+    equal: ValueEqualityFn<D>;
+}
+export type LinkedSignalGetter<S, D> = (() => D) & {
+    [SIGNAL]: LinkedSignalNode<S, D>;
+};
+export declare function createLinkedSignal<S, D>(sourceFn: () => S, computationFn: ComputationFn<S, D>, equalityFn?: ValueEqualityFn<D>): LinkedSignalGetter<S, D>;
+export declare function linkedSignalSetFn<S, D>(node: LinkedSignalNode<S, D>, newValue: D): void;
+export declare function linkedSignalUpdateFn<S, D>(node: LinkedSignalNode<S, D>, updater: (value: D) => D): void;
+export declare const LINKED_SIGNAL_NODE: Omit<LinkedSignalNode<unknown, unknown>, 'computation' | 'source' | 'sourceValue'>;

package/signals/implementation/primitive/linked_signal.js

@@ -0,0 +1,110 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { isDevMode } from '../../../core.js';
+import { COMPUTING, ERRORED, UNSET } from './computed.js';
+import { defaultEquals } from './equality.js';
+import { consumerAfterComputation, consumerBeforeComputation, producerAccessed, producerMarkClean, producerUpdateValueVersion, REACTIVE_NODE, runPostProducerCreatedFn, setActiveConsumer, SIGNAL, } from './graph.js';
+import { signalSetFn, signalUpdateFn } from './signal.js';
+export function createLinkedSignal(sourceFn, computationFn, equalityFn) {
+    const node = Object.create(LINKED_SIGNAL_NODE);
+    node.source = sourceFn;
+    node.computation = computationFn;
+    if (equalityFn != undefined) {
+        node.equal = equalityFn;
+    }
+    const linkedSignalGetter = () => {
+        // Check if the value needs updating before returning it.
+        producerUpdateValueVersion(node);
+        // Record that someone looked at this signal.
+        producerAccessed(node);
+        if (node.value === ERRORED) {
+            throw node.error;
+        }
+        return node.value;
+    };
+    const getter = linkedSignalGetter;
+    getter[SIGNAL] = node;
+    if (isDevMode()) {
+        getter.toString = () => `[LinkedSignal${node.debugName ? ' (' + node.debugName + ')' : ''}: ${String(node.value)}]`;
+    }
+    runPostProducerCreatedFn(node);
+    return getter;
+}
+export function linkedSignalSetFn(node, newValue) {
+    producerUpdateValueVersion(node);
+    signalSetFn(node, newValue);
+    producerMarkClean(node);
+}
+export function linkedSignalUpdateFn(node, updater) {
+    producerUpdateValueVersion(node);
+    // update() on a linked signal can't work if the current state is ERRORED, as there's no value.
+    if (node.value === ERRORED) {
+        throw node.error;
+    }
+    signalUpdateFn(node, updater);
+    producerMarkClean(node);
+}
+// Note: Using an IIFE here to ensure that the spread assignment is not considered
+// a side-effect, ending up preserving `LINKED_SIGNAL_NODE` and `REACTIVE_NODE`.
+export const LINKED_SIGNAL_NODE = /* @__PURE__ */ (() => {
+    return {
+        ...REACTIVE_NODE,
+        value: UNSET,
+        dirty: true,
+        error: null,
+        equal: defaultEquals,
+        kind: 'linkedSignal',
+        producerMustRecompute(node) {
+            // Force a recomputation if there's no current value, or if the current value is in the
+            // process of being calculated (which should throw an error).
+            return node.value === UNSET || node.value === COMPUTING;
+        },
+        producerRecomputeValue(node) {
+            if (node.value === COMPUTING) {
+                // Our computation somehow led to a cyclic read of itself.
+                throw new Error(isDevMode() ? 'Detected cycle in computations.' : '');
+            }
+            const oldValue = node.value;
+            node.value = COMPUTING;
+            const prevConsumer = consumerBeforeComputation(node);
+            let newValue;
+            let wasEqual = false;
+            try {
+                const newSourceValue = node.source();
+                const oldValueValid = oldValue !== UNSET && oldValue !== ERRORED;
+                const prev = oldValueValid
+                    ? {
+                        source: node.sourceValue,
+                        value: oldValue,
+                    }
+                    : undefined;
+                newValue = node.computation(newSourceValue, prev);
+                node.sourceValue = newSourceValue;
+                // We want to mark this node as errored if calling `equal` throws; however, we don't want
+                // to track any reactive reads inside `equal`.
+                setActiveConsumer(null);
+                wasEqual = oldValueValid && newValue !== ERRORED && node.equal(oldValue, newValue);
+            }
+            catch (err) {
+                newValue = ERRORED;
+                node.error = err;
+            }
+            finally {
+                consumerAfterComputation(node, prevConsumer);
+            }
+            if (wasEqual) {
+                // No change to `valueVersion` - old and new values are
+                // semantically equivalent.
+                node.value = oldValue;
+                return;
+            }
+            node.value = newValue;
+            node.version++;
+        },
+    };
+})();

package/signals/implementation/primitive/signal.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { type ValueEqualityFn } from './equality.js';
+import { type ReactiveHookFn, type ReactiveNode, SIGNAL } from './graph.js';
+export interface SignalNode<T> extends ReactiveNode {
+    value: T;
+    equal: ValueEqualityFn<T>;
+}
+export type SignalBaseGetter<T> = (() => T) & {
+    readonly [SIGNAL]: unknown;
+};
+export type SignalSetter<T> = (newValue: T) => void;
+export type SignalUpdater<T> = (updateFn: (value: T) => T) => void;
+export interface SignalGetter<T> extends SignalBaseGetter<T> {
+    readonly [SIGNAL]: SignalNode<T>;
+}
+/**
+ * Creates a `Signal` getter, setter, and updater function.
+ */
+export declare function createSignal<T>(initialValue: T, equal?: ValueEqualityFn<T>): [SignalGetter<T>, SignalSetter<T>, SignalUpdater<T>];
+export declare function setPostSignalSetFn(fn: ReactiveHookFn | null): ReactiveHookFn | null;
+export declare function signalGetFn<T>(node: SignalNode<T>): T;
+export declare function signalSetFn<T>(node: SignalNode<T>, newValue: T): void;
+export declare function signalUpdateFn<T>(node: SignalNode<T>, updater: (value: T) => T): void;
+export declare function runPostSignalSetFn<T>(node: SignalNode<T>): void;
+export declare const SIGNAL_NODE: SignalNode<unknown>;

package/signals/implementation/primitive/signal.js

@@ -0,0 +1,80 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { isDevMode } from '../../../core.js';
+import { defaultEquals } from './equality.js';
+import { throwInvalidWriteToSignalError } from './errors.js';
+import { producerAccessed, producerIncrementEpoch, producerNotifyConsumers, producerUpdatesAllowed, REACTIVE_NODE, runPostProducerCreatedFn, SIGNAL, } from './graph.js';
+/**
+ * If set, called after `WritableSignal`s are updated.
+ *
+ * This hook can be used to achieve various effects, such as running effects synchronously as part
+ * of setting a signal.
+ */
+let postSignalSetFn = null;
+/**
+ * Creates a `Signal` getter, setter, and updater function.
+ */
+export function createSignal(initialValue, equal) {
+    const node = Object.create(SIGNAL_NODE);
+    node.value = initialValue;
+    if (equal !== undefined) {
+        node.equal = equal;
+    }
+    const getter = (() => signalGetFn(node));
+    getter[SIGNAL] = node;
+    if (isDevMode()) {
+        getter.toString = () => `[Signal${node.debugName ? ' (' + node.debugName + ')' : ''}: ${String(node.value)}]`;
+    }
+    runPostProducerCreatedFn(node);
+    const set = (newValue) => signalSetFn(node, newValue);
+    const update = (updateFn) => signalUpdateFn(node, updateFn);
+    return [getter, set, update];
+}
+export function setPostSignalSetFn(fn) {
+    const prev = postSignalSetFn;
+    postSignalSetFn = fn;
+    return prev;
+}
+export function signalGetFn(node) {
+    producerAccessed(node);
+    return node.value;
+}
+export function signalSetFn(node, newValue) {
+    if (!producerUpdatesAllowed()) {
+        throwInvalidWriteToSignalError(node);
+    }
+    if (!node.equal(node.value, newValue)) {
+        node.value = newValue;
+        signalValueChanged(node);
+    }
+}
+export function signalUpdateFn(node, updater) {
+    if (!producerUpdatesAllowed()) {
+        throwInvalidWriteToSignalError(node);
+    }
+    signalSetFn(node, updater(node.value));
+}
+export function runPostSignalSetFn(node) {
+    postSignalSetFn?.(node);
+}
+// Note: Using an IIFE here to ensure that the spread assignment is not considered
+// a side-effect, ending up preserving `COMPUTED_NODE` and `REACTIVE_NODE`.
+export const SIGNAL_NODE = /* @__PURE__ */ (() => {
+    return {
+        ...REACTIVE_NODE,
+        equal: defaultEquals,
+        value: undefined,
+        kind: 'signal',
+    };
+})();
+function signalValueChanged(node) {
+    node.version++;
+    producerIncrementEpoch();
+    producerNotifyConsumers(node);
+    postSignalSetFn?.(node);
+}

package/signals/implementation/primitive/untracked.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+/**
+ * Execute an arbitrary function in a non-reactive (non-tracking) context. The executed function
+ * can, optionally, return a value.
+ */
+export declare function untracked<T>(nonReactiveReadsFn: () => T): T;

package/signals/implementation/primitive/untracked.js

@@ -0,0 +1,23 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { setActiveConsumer } from './graph.js';
+/**
+ * Execute an arbitrary function in a non-reactive (non-tracking) context. The executed function
+ * can, optionally, return a value.
+ */
+export function untracked(nonReactiveReadsFn) {
+    const prevConsumer = setActiveConsumer(null);
+    // We are not trying to catch any particular errors here, just making sure that the consumers
+    // stack is restored in case of errors.
+    try {
+        return nonReactiveReadsFn();
+    }
+    finally {
+        setActiveConsumer(prevConsumer);
+    }
+}

package/signals/implementation/{watch.d.ts → primitive/watch.d.ts}

@@ -3,7 +3,7 @@
  * Copyright Google LLC All Rights Reserved.
  *
  * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
+ * found in the LICENSE file at https://angular.dev/license
  */
 import { type ReactiveNode, SIGNAL } from './graph.js';
 /**
@@ -34,7 +34,6 @@ export interface Watch {
     [SIGNAL]: WatchNode;
 }
 export interface WatchNode extends ReactiveNode {
-    hasRun: boolean;
     fn: ((onCleanup: WatchCleanupRegisterFn) => void) | null;
     schedule: ((watch: Watch) => void) | null;
     cleanupFn: WatchCleanupFn;

package/signals/implementation/{watch.js → primitive/watch.js}

@@ -3,8 +3,9 @@
  * Copyright Google LLC All Rights Reserved.
  *
  * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
+ * found in the LICENSE file at https://angular.dev/license
  */
+import { isDevMode } from '../../../core.js';
 import { consumerAfterComputation, consumerBeforeComputation, consumerDestroy, consumerMarkDirty, consumerPollProducersForChange, isInNotificationPhase, REACTIVE_NODE, SIGNAL, } from './graph.js';
 export function createWatch(fn, schedule, allowSignalWrites) {
     const node = Object.create(WATCH_NODE);
@@ -35,13 +36,15 @@ export function createWatch(fn, schedule, allowSignalWrites) {
             return;
         }
         if (isInNotificationPhase()) {
-            throw new Error(`Schedulers cannot synchronously execute watches while scheduling.`);
+            throw new Error(isDevMode()
+                ? 'Schedulers cannot synchronously execute watches while scheduling.'
+                : '');
         }
         node.dirty = false;
-        if (node.hasRun && !consumerPollProducersForChange(node)) {
+        if (node.version > 0 && !consumerPollProducersForChange(node)) {
             return;
         }
-        node.hasRun = true;
+        node.version++;
         const prevConsumer = consumerBeforeComputation(node);
         try {
             node.cleanupFn();
@@ -62,15 +65,18 @@ export function createWatch(fn, schedule, allowSignalWrites) {
     return node.ref;
 }
 const NOOP_CLEANUP_FN = () => { };
-const WATCH_NODE = {
-    ...REACTIVE_NODE,
-    consumerIsAlwaysLive: true,
-    consumerAllowSignalWrites: false,
-    consumerMarkedDirty: (node) => {
-        if (node.schedule !== null) {
-            node.schedule(node.ref);
-        }
-    },
-    hasRun: false,
-    cleanupFn: NOOP_CLEANUP_FN,
-};
+// Note: Using an IIFE here to ensure that the spread assignment is not considered
+// a side-effect, ending up preserving `COMPUTED_NODE` and `REACTIVE_NODE`.
+const WATCH_NODE = /* @__PURE__ */ (() => {
+    return {
+        ...REACTIVE_NODE,
+        consumerIsAlwaysLive: true,
+        consumerAllowSignalWrites: false,
+        consumerMarkedDirty: (node) => {
+            if (node.schedule !== null) {
+                node.schedule(node.ref);
+            }
+        },
+        cleanupFn: NOOP_CLEANUP_FN,
+    };
+})();

package/signals/implementation/resource/api.d.ts

@@ -0,0 +1,275 @@
+/** biome-ignore-all lint: <explanation> */
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import type { SignalsInjector } from '../../../signals/api.js';
+import type { Signal, ValueEqualityFn } from '../api.js';
+import type { WritableSignal } from '../signal.js';
+/** Error thrown when a `Resource` dependency of another resource errors. */
+export declare class ResourceDependencyError extends Error {
+    /** The dependency that errored. */
+    readonly dependency: Resource<unknown>;
+    constructor(dependency: Resource<unknown>);
+}
+/**
+ * Special status codes that can be thrown from a resource's `params` or `request` function to
+ * indicate that the resource should transition to that status.
+ */
+export declare class ResourceParamsStatus extends Error {
+    private readonly _brand;
+    private constructor();
+    /** Status code that transitions the resource to `idle` status. */
+    static readonly IDLE: ResourceParamsStatus;
+    /** Status code that transitions the resource to `loading` status. */
+    static readonly LOADING: ResourceParamsStatus;
+}
+/** Context received by a resource's `params` or `request` function. */
+export interface ResourceParamsContext {
+    /**
+     * Chains the current params off of the value of another resource, returning the value
+     * of the other resource if it is available, or propagating the status to the current resource by
+     * throwing the appropriate status code if the value is not available.
+     */
+    readonly chain: <T>(resource: Resource<T>) => T;
+}
+/**
+ * String value capturing the status of a `Resource`.
+ *
+ * Possible statuses are:
+ *
+ * `idle` - The resource has no valid request and will not perform any loading. `value()` will be
+ * `undefined`.
+ *
+ * `loading` - The resource is currently loading a new value as a result of a change in its reactive
+ * dependencies. `value()` will be `undefined`.
+ *
+ * `reloading` - The resource is currently reloading a fresh value for the same reactive
+ * dependencies. `value()` will continue to return the previously fetched value during the reloading
+ * operation.
+ *
+ * `error` - Loading failed with an error. `value()` will be `undefined`.
+ *
+ * `resolved` - Loading has completed and the resource has the value returned from the loader.
+ *
+ * `local` - The resource's value was set locally via `.set()` or `.update()`.
+ *
+ * @experimental
+ */
+export type ResourceStatus = 'idle' | 'error' | 'loading' | 'reloading' | 'resolved' | 'local';
+/**
+ * A Resource is an asynchronous dependency (for example, the results of an API call) that is
+ * managed and delivered through signals.
+ *
+ * The usual way of creating a `Resource` is through the `resource` function, but various other APIs
+ * may present `Resource` instances to describe their own concepts.
+ *
+ * @experimental
+ */
+export interface Resource<T> {
+    /**
+     * The current value of the `Resource`, or throws an error if the resource is in an error state.
+     */
+    readonly value: Signal<T>;
+    /**
+     * The current status of the `Resource`, which describes what the resource is currently doing and
+     * what can be expected of its `value`.
+     */
+    readonly status: Signal<ResourceStatus>;
+    /**
+     * When in the `error` state, this returns the last known error from the `Resource`.
+     */
+    readonly error: Signal<Error | undefined>;
+    /**
+     * Whether this resource is loading a new value (or reloading the existing one).
+     */
+    readonly isLoading: Signal<boolean>;
+    /**
+     * The current state of this resource, represented as a `ResourceSnapshot`.
+     */
+    readonly snapshot: Signal<ResourceSnapshot<T>>;
+    /**
+     * Whether this resource has a valid current value.
+     *
+     * This function is reactive.
+     */
+    hasValue(this: T extends undefined ? this : never): this is Resource<Exclude<T, undefined>>;
+    hasValue(): boolean;
+}
+/**
+ * A `Resource` with a mutable value.
+ *
+ * Overwriting the value of a resource sets it to the 'local' state.
+ *
+ * @experimental
+ */
+export interface WritableResource<T> extends Resource<T> {
+    readonly value: WritableSignal<T>;
+    hasValue(this: T extends undefined ? this : never): this is WritableResource<Exclude<T, undefined>>;
+    hasValue(): boolean;
+    /**
+     * Convenience wrapper for `value.set`.
+     */
+    set(value: T): void;
+    /**
+     * Convenience wrapper for `value.update`.
+     */
+    update(updater: (value: T) => T): void;
+    asReadonly(): Resource<T>;
+    /**
+     * Instructs the resource to re-load any asynchronous dependency it may have.
+     *
+     * Note that the resource will not enter its reloading state until the actual backend request is
+     * made.
+     *
+     * @returns true if a reload was initiated, false if a reload was unnecessary or unsupported
+     */
+    reload(): boolean;
+}
+/**
+ * A `WritableResource` created through the `resource` function.
+ *
+ * @experimental
+ */
+export interface ResourceRef<T> extends WritableResource<T> {
+    hasValue(this: T extends undefined ? this : never): this is ResourceRef<Exclude<T, undefined>>;
+    hasValue(): boolean;
+    /**
+     * Manually destroy the resource, which cancels pending requests and returns it to `idle` state.
+     */
+    destroy(): void;
+}
+/**
+ * Parameter to a `ResourceLoader` which gives the request and other options for the current loading
+ * operation.
+ *
+ * @experimental
+ */
+export interface ResourceLoaderParams<R> {
+    params: NoInfer<Exclude<R, undefined>>;
+    abortSignal: AbortSignal;
+    previous: {
+        status: ResourceStatus;
+    };
+}
+/**
+ * Loading function for a `Resource`.
+ *
+ * @experimental
+ */
+export type ResourceLoader<T, R> = (param: ResourceLoaderParams<R>) => PromiseLike<T>;
+/**
+ * Streaming loader for a `Resource`.
+ *
+ * @experimental
+ */
+export type ResourceStreamingLoader<T, R> = (param: ResourceLoaderParams<R>) => PromiseLike<Signal<ResourceStreamItem<T>>>;
+/**
+ * Options to the `resource` function, for creating a resource.
+ *
+ * @experimental
+ */
+export interface BaseResourceOptions<T, R> {
+    /**
+     * A reactive function which determines the request to be made. Whenever the request changes, the
+     * loader will be triggered to fetch a new value for the resource.
+     *
+     * If a params function isn't provided, the loader won't rerun unless the resource is reloaded.
+     */
+    params?: (ctx: ResourceParamsContext) => R;
+    /**
+     * The value which will be returned from the resource when a server value is unavailable, such as
+     * when the resource is still loading.
+     */
+    defaultValue?: NoInfer<T>;
+    /**
+     * Equality function used to compare the return value of the loader.
+     */
+    equal?: ValueEqualityFn<T>;
+    /**
+     * Overrides the `Injector` used by `resource`.
+     */
+    injector?: SignalsInjector;
+}
+/**
+ * Options to the `resource` function, for creating a resource.
+ *
+ * @experimental
+ */
+export interface PromiseResourceOptions<T, R> extends BaseResourceOptions<T, R> {
+    /**
+     * Loading function which returns a `Promise` of the resource's value for a given request.
+     */
+    loader: ResourceLoader<T, R>;
+    /**
+     * Cannot specify `stream` and `loader` at the same time.
+     */
+    stream?: never;
+}
+/**
+ * Options to the `resource` function, for creating a resource.
+ *
+ * @experimental
+ */
+export interface StreamingResourceOptions<T, R> extends BaseResourceOptions<T, R> {
+    /**
+     * Loading function which returns a `Promise` of a signal of the resource's value for a given
+     * request, which can change over time as new values are received from a stream.
+     */
+    stream: ResourceStreamingLoader<T, R>;
+    /**
+     * Cannot specify `stream` and `loader` at the same time.
+     */
+    loader?: never;
+}
+/**
+ * @experimental
+ */
+export type ResourceOptions<T, R> = (PromiseResourceOptions<T, R> | StreamingResourceOptions<T, R>) & {
+    /**
+     * A debug name for the reactive node. Used in Angular DevTools to identify the node.
+     */
+    debugName?: string;
+};
+/**
+ * @experimental
+ */
+export type ResourceStreamItem<T> = {
+    value: T;
+} | {
+    error: Error;
+};
+/**
+ * An explicit representation of a resource's state.
+ *
+ * @experimental
+ * @see [Resource composition with snapshots](guide/signals/resource#resource-composition-with-snapshots)
+ */
+export type ResourceSnapshot<T> = {
+    readonly status: 'idle';
+    readonly value: T;
+} | {
+    readonly status: 'loading' | 'reloading';
+    readonly value: T;
+} | {
+    readonly status: 'resolved' | 'local';
+    readonly value: T;
+} | {
+    readonly status: 'error';
+    readonly error: Error;
+};
+/** Options for `debounced`. */
+export interface DebouncedOptions<T> {
+    /** The `Injector` to use for the debounced resource. */
+    injector?: SignalsInjector;
+    /** The equality function to use for comparing values. */
+    equal?: ValueEqualityFn<T>;
+}
+/**
+ * Represents the wait condition for item debouncing.
+ * Can be a number of milliseconds or a function that returns a Promise.
+ */
+export type DebounceTimer<T> = number | ((value: T, lastValue: ResourceSnapshot<T>) => Promise<void> | void);

package/signals/implementation/resource/api.js

@@ -0,0 +1,26 @@
+/* eslint-disable */
+/** biome-ignore-all lint: <explanation> */
+/** Error thrown when a `Resource` dependency of another resource errors. */
+export class ResourceDependencyError extends Error {
+    /** The dependency that errored. */
+    dependency;
+    constructor(dependency) {
+        super('Dependency error', { cause: dependency.error() });
+        this.name = 'ResourceDependencyError';
+        this.dependency = dependency;
+    }
+}
+/**
+ * Special status codes that can be thrown from a resource's `params` or `request` function to
+ * indicate that the resource should transition to that status.
+ */
+export class ResourceParamsStatus extends Error {
+    _brand;
+    constructor(msg) {
+        super(msg);
+    }
+    /** Status code that transitions the resource to `idle` status. */
+    static IDLE = new ResourceParamsStatus('IDLE');
+    /** Status code that transitions the resource to `loading` status. */
+    static LOADING = new ResourceParamsStatus('LOADING');
+}