@angular/core 20.0.0-next.4 → 20.0.0-next.6

package/api.d-DQLNOR5l.d.ts

@@ -0,0 +1,297 @@
+/**
+ * @license Angular v20.0.0-next.6
+ * (c) 2010-2025 Google LLC. https://angular.io/
+ * License: MIT
+ */
+
+import { OutputRef, OutputRefSubscription, DestroyRef, Signal, WritableSignal, ValueEqualityFn, Injector } from './ng_i18n_closure_mode.d-C9d2CaSt.js';
+
+/**
+ * An `OutputEmitterRef` is created by the `output()` function and can be
+ * used to emit values to consumers of your directive or component.
+ *
+ * Consumers of your directive/component can bind to the output and
+ * subscribe to changes via the bound event syntax. For example:
+ *
+ * ```html
+ * <my-comp (valueChange)="processNewValue($event)" />
+ * ```
+ *
+ * @publicAPI
+ */
+declare class OutputEmitterRef<T> implements OutputRef<T> {
+    private destroyed;
+    private listeners;
+    private errorHandler;
+    constructor();
+    subscribe(callback: (value: T) => void): OutputRefSubscription;
+    /** Emits a new value to the output. */
+    emit(value: T): void;
+}
+/** Gets the owning `DestroyRef` for the given output. */
+declare function getOutputDestroyRef(ref: OutputRef<unknown>): DestroyRef | undefined;
+
+/**
+ * Options for declaring an output.
+ *
+ * @publicAPI
+ */
+interface OutputOptions {
+    alias?: string;
+}
+/**
+ * The `output` function allows declaration of Angular outputs in
+ * directives and components.
+ *
+ * You can use outputs to emit values to parent directives and component.
+ * Parents can subscribe to changes via:
+ *
+ * - template event bindings. For example, `(myOutput)="doSomething($event)"`
+ * - programmatic subscription by using `OutputRef#subscribe`.
+ *
+ * @usageNotes
+ *
+ * To use `output()`, import the function from `@angular/core`.
+ *
+ * ```ts
+ * import {output} from '@angular/core';
+ * ```
+ *
+ * Inside your component, introduce a new class member and initialize
+ * it with a call to `output`.
+ *
+ * ```ts
+ * @Directive({
+ *   ...
+ * })
+ * export class MyDir {
+ *   nameChange = output<string>();    // OutputEmitterRef<string>
+ *   onClick    = output();            // OutputEmitterRef<void>
+ * }
+ * ```
+ *
+ * You can emit values to consumers of your directive, by using
+ * the `emit` method from `OutputEmitterRef`.
+ *
+ * ```ts
+ * updateName(newName: string): void {
+ *   this.nameChange.emit(newName);
+ * }
+ * ```
+ * @initializerApiFunction {"showTypesInSignaturePreview": true}
+ * @publicAPI
+ */
+declare function output<T = void>(opts?: OutputOptions): OutputEmitterRef<T>;
+
+/**
+ * Status of a `Resource`.
+ *
+ * @experimental
+ */
+declare enum ResourceStatus {
+    /**
+     * The resource has no valid request and will not perform any loading.
+     *
+     * `value()` will be `undefined`.
+     */
+    Idle = 0,
+    /**
+     * Loading failed with an error.
+     *
+     * `value()` will be `undefined`.
+     */
+    Error = 1,
+    /**
+     * The resource is currently loading a new value as a result of a change in its `request`.
+     *
+     * `value()` will be `undefined`.
+     */
+    Loading = 2,
+    /**
+     * The resource is currently reloading a fresh value for the same request.
+     *
+     * `value()` will continue to return the previously fetched value during the reloading operation.
+     */
+    Reloading = 3,
+    /**
+     * Loading has completed and the resource has the value returned from the loader.
+     */
+    Resolved = 4,
+    /**
+     * The resource's value was set locally via `.set()` or `.update()`.
+     */
+    Local = 5
+}
+/**
+ * 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
+ */
+interface Resource<T> {
+    /**
+     * The current value of the `Resource`, or `undefined` if there is no current value.
+     */
+    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<unknown>;
+    /**
+     * Whether this resource is loading a new value (or reloading the existing one).
+     */
+    readonly isLoading: Signal<boolean>;
+    /**
+     * Whether this resource has a valid current value.
+     *
+     * This function is reactive.
+     */
+    hasValue(): this is Resource<Exclude<T, undefined>>;
+    /**
+     * 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 `Resource` with a mutable value.
+ *
+ * Overwriting the value of a resource sets it to the 'local' state.
+ *
+ * @experimental
+ */
+interface WritableResource<T> extends Resource<T> {
+    readonly value: WritableSignal<T>;
+    hasValue(): this is WritableResource<Exclude<T, undefined>>;
+    /**
+     * Convenience wrapper for `value.set`.
+     */
+    set(value: T): void;
+    /**
+     * Convenience wrapper for `value.update`.
+     */
+    update(updater: (value: T) => T): void;
+    asReadonly(): Resource<T>;
+}
+/**
+ * A `WritableResource` created through the `resource` function.
+ *
+ * @experimental
+ */
+interface ResourceRef<T> extends WritableResource<T> {
+    hasValue(): this is ResourceRef<Exclude<T, undefined>>;
+    /**
+     * 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
+ */
+interface ResourceLoaderParams<R> {
+    request: Exclude<NoInfer<R>, undefined>;
+    abortSignal: AbortSignal;
+    previous: {
+        status: ResourceStatus;
+    };
+}
+/**
+ * Loading function for a `Resource`.
+ *
+ * @experimental
+ */
+type ResourceLoader<T, R> = (param: ResourceLoaderParams<R>) => PromiseLike<T>;
+/**
+ * Streaming loader for a `Resource`.
+ *
+ * @experimental
+ */
+type ResourceStreamingLoader<T, R> = (param: ResourceLoaderParams<R>) => PromiseLike<Signal<ResourceStreamItem<T>>>;
+/**
+ * Options to the `resource` function, for creating a resource.
+ *
+ * @experimental
+ */
+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 request function isn't provided, the loader won't rerun unless the resource is reloaded.
+     */
+    request?: () => R;
+    /**
+     * The value which will be returned from the resource when a server value is unavailable, such as
+     * when the resource is still loading, or in an error state.
+     */
+    defaultValue?: NoInfer<T>;
+    /**
+     * Equality function used to compare the return value of the loader.
+     */
+    equal?: ValueEqualityFn<T>;
+    /**
+     * Overrides the `Injector` used by `resource`.
+     */
+    injector?: Injector;
+}
+/**
+ * Options to the `resource` function, for creating a resource.
+ *
+ * @experimental
+ */
+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
+ */
+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
+ */
+type ResourceOptions<T, R> = PromiseResourceOptions<T, R> | StreamingResourceOptions<T, R>;
+/**
+ * @experimental
+ */
+type ResourceStreamItem<T> = {
+    value: T;
+} | {
+    error: unknown;
+};
+
+export { OutputEmitterRef, ResourceStatus, getOutputDestroyRef, output };
+export type { BaseResourceOptions, OutputOptions, PromiseResourceOptions, Resource, ResourceLoader, ResourceLoaderParams, ResourceOptions, ResourceRef, ResourceStreamItem, ResourceStreamingLoader, StreamingResourceOptions, WritableResource };