static-injector 5.0.2 → 6.0.0

package/{typings → import}/interface/type.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
  */
 /**
  * @description
@@ -31,28 +31,23 @@ export interface AbstractType<T> extends Function {
 export interface Type<T> extends Function {
     new (...args: any[]): T;
 }
-export type Mutable<T extends {
-    [x: string]: any;
-}, K extends string> = {
-    [P in K]: T[P];
-};
 /**
  * Returns a writable type version of type.
  *
  * USAGE:
  * Given:
- * ```
+ * ```ts
  * interface Person {readonly name: string}
  * ```
  *
  * We would like to get a read/write version of `Person`.
- * ```
+ * ```ts
  * const WritablePerson = Writable<Person>;
  * ```
  *
  * The result is that you can do:
  *
- * ```
+ * ```ts
  * const readonlyPerson: Person = {name: 'Marry'};
  * readonlyPerson.name = 'John'; // TypeError
  * (readonlyPerson as WritablePerson).name = 'John'; // OK

package/import/linker/destroy_ref.d.ts

@@ -0,0 +1,44 @@
+/**
+ * @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 { EnvironmentInjector } from '../di';
+/**
+ * `DestroyRef` lets you set callbacks to run for any cleanup or destruction behavior.
+ * The scope of this destruction depends on where `DestroyRef` is injected. If `DestroyRef`
+ * is injected in a component or directive, the callbacks run when that component or
+ * directive is destroyed. Otherwise the callbacks run when a corresponding injector is destroyed.
+ *
+ * @publicApi
+ */
+export declare abstract class DestroyRef {
+    /**
+     * Registers a destroy callback in a given lifecycle scope.  Returns a cleanup function that can
+     * be invoked to unregister the callback.
+     *
+     * @usageNotes
+     * ### Example
+     * ```ts
+     * const destroyRef = inject(DestroyRef);
+     *
+     * // register a destroy callback
+     * const unregisterFn = destroyRef.onDestroy(() => doSomethingOnDestroy());
+     *
+     * // stop the destroy callback from executing if needed
+     * unregisterFn();
+     * ```
+     */
+    abstract onDestroy(callback: () => void): () => void;
+    /**
+     * @internal
+     * @nocollapse
+     */
+    /**
+     * @internal
+     * @nocollapse
+     */
+    static __NG_ENV_ID__: (injector: EnvironmentInjector) => DestroyRef;
+}

package/import/pending_tasks.d.ts

@@ -0,0 +1,78 @@
+/**
+ * @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 { BehaviorSubject } from 'rxjs';
+import { OnDestroy } from './interface/lifecycle_hooks';
+/**
+ * Internal implementation of the pending tasks service.
+ */
+export declare class PendingTasksInternal implements OnDestroy {
+    private taskId;
+    private pendingTasks;
+    private get _hasPendingTasks();
+    hasPendingTasks: BehaviorSubject<boolean>;
+    add(): number;
+    has(taskId: number): boolean;
+    remove(taskId: number): void;
+    ngOnDestroy(): void;
+    /** @nocollapse */
+    static ɵprov: unknown;
+}
+/**
+ * Service that keeps track of pending tasks contributing to the stableness of Angular
+ * application. While several existing Angular services (ex.: `HttpClient`) will internally manage
+ * tasks influencing stability, this API gives control over stability to library and application
+ * developers for specific cases not covered by Angular internals.
+ *
+ * The concept of stability comes into play in several important scenarios:
+ * - SSR process needs to wait for the application stability before serializing and sending rendered
+ * HTML;
+ * - tests might want to delay assertions until the application becomes stable;
+ *
+ * @usageNotes
+ * ```ts
+ * const pendingTasks = inject(PendingTasks);
+ * const taskCleanup = pendingTasks.add();
+ * // do work that should block application's stability and then:
+ * taskCleanup();
+ * ```
+ *
+ * @publicApi
+ * @developerPreview
+ */
+export declare class PendingTasks {
+    private internalPendingTasks;
+    private scheduler;
+    /**
+     * Adds a new task that should block application's stability.
+     * @returns A cleanup function that removes a task when called.
+     */
+    add(): () => void;
+    /**
+     * Runs an asynchronous function and blocks the application's stability until the function completes.
+     *
+     * ```ts
+     * pendingTasks.run(async () => {
+     *   const userData = await fetch('/api/user');
+     *   this.userData.set(userData);
+     * });
+     * ```
+     *
+     * Application stability is at least delayed until the next tick after the `run` method resolves
+     * so it is safe to make additional updates to application state that would require UI synchronization:
+     *
+     * ```ts
+     * const userData = await pendingTasks.run(() => fetch('/api/user'));
+     * this.userData.set(userData);
+     * ```
+     *
+     * @param fn The asynchronous function to execute
+     */
+    run<T>(fn: () => Promise<T>): Promise<T>;
+    /** @nocollapse */
+    static ɵprov: unknown;
+}

package/{typings → import}/render3/definition_factory.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 } from '../interface/type';
 /**

package/{typings → import}/render3/errors_di.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 { ProviderToken } from '../di';
 /** Throws an error when a token is not found in DI. */

package/{typings → import}/render3/fields.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
  */
 export declare const NG_FACTORY_DEF: string;
 /**

package/{typings → import}/render3/instructions/di.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
  */
 /**
  * Throws an error indicating that a factory function could not be generated by the compiler for a

package/import/render3/reactivity/api.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @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 { SIGNAL } from '@angular/core/primitives/signals';
+/**
+ * A reactive value which notifies consumers of any changes.
+ *
+ * Signals are functions which returns their current value. To access the current value of a signal,
+ * call it.
+ *
+ * Ordinary values can be turned into `Signal`s with the `signal` function.
+ */
+export type Signal<T> = (() => T) & {
+    [SIGNAL]: unknown;
+};
+/**
+ * Checks if the given `value` is a reactive `Signal`.
+ */
+export declare function isSignal(value: unknown): value is Signal<unknown>;
+/**
+ * A comparison function which can determine if two values are equal.
+ */
+export type ValueEqualityFn<T> = (a: T, b: T) => boolean;

package/import/render3/reactivity/asserts.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @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
+ */
+/**
+ * Asserts that the current stack frame is not within a reactive context. Useful
+ * to disallow certain code from running inside a reactive context (see {@link toSignal}).
+ *
+ * @param debugFn a reference to the function making the assertion (used for the error message).
+ *
+ * @publicApi
+ */
+export declare function assertNotInReactiveContext(debugFn: Function, extraContext?: string): void;

package/import/render3/reactivity/computed.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @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 { Signal, ValueEqualityFn } from './api';
+/**
+ * Options passed to the `computed` creation function.
+ */
+export interface CreateComputedOptions<T> {
+    /**
+     * A comparison function which defines equality for computed values.
+     */
+    equal?: ValueEqualityFn<T>;
+    /**
+     * A debug name for the computed signal. Used in Angular DevTools to identify the signal.
+     */
+    debugName?: string;
+}
+/**
+ * Create a computed `Signal` which derives a reactive value from an expression.
+ */
+export declare function computed<T>(computation: () => T, options?: CreateComputedOptions<T>): Signal<T>;

package/import/render3/reactivity/effect.d.ts

@@ -0,0 +1,121 @@
+/**
+ * @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 { ReactiveNode, SIGNAL } from '@angular/core/primitives/signals';
+import { InjectionToken } from '../../di/injection_token';
+import { Injector } from '../../di/injector';
+import { ChangeDetectionScheduler } from '../../change_detection/scheduling/zoneless_scheduling';
+import { EffectScheduler, SchedulableEffect } from './root_effect_scheduler';
+/**
+ * Toggle the flag on whether to use microtask effects (for testing).
+ */
+export declare function setUseMicrotaskEffectsByDefault(value: boolean): boolean;
+/**
+ * A global reactive effect, which can be manually destroyed.
+ *
+ * @developerPreview
+ */
+export interface EffectRef {
+    /**
+     * Shut down the effect, removing it from any upcoming scheduled executions.
+     */
+    destroy(): void;
+}
+export declare class EffectRefImpl implements EffectRef {
+    [SIGNAL]: EffectNode;
+    constructor(node: EffectNode);
+    destroy(): void;
+}
+/**
+ * Options passed to the `effect` function.
+ *
+ * @developerPreview
+ */
+export interface CreateEffectOptions {
+    /**
+     * The `Injector` in which to create the effect.
+     *
+     * If this is not provided, the current [injection context](guide/di/dependency-injection-context)
+     * will be used instead (via `inject`).
+     */
+    injector?: Injector;
+    /**
+     * Whether the `effect` should require manual cleanup.
+     *
+     * If this is `false` (the default) the effect will automatically register itself to be cleaned up
+     * with the current `DestroyRef`.
+     */
+    manualCleanup?: boolean;
+    /**
+     * Always create a root effect (which is scheduled as a microtask) regardless of whether `effect`
+     * is called within a component.
+     */
+    forceRoot?: true;
+    /**
+     * @deprecated no longer required, signal writes are allowed by default.
+     */
+    allowSignalWrites?: boolean;
+    /**
+     * A debug name for the effect. Used in Angular DevTools to identify the effect.
+     */
+    debugName?: string;
+}
+/**
+ * An effect can, optionally, register a cleanup function. If registered, the cleanup is executed
+ * before the next effect run. The cleanup function makes it possible to "cancel" any work that the
+ * previous effect run might have started.
+ *
+ * @developerPreview
+ */
+export type EffectCleanupFn = () => void;
+/**
+ * A callback passed to the effect function that makes it possible to register cleanup logic.
+ *
+ * @developerPreview
+ */
+export type EffectCleanupRegisterFn = (cleanupFn: EffectCleanupFn) => void;
+/**
+ * Registers an "effect" that will be scheduled & executed whenever the signals that it reads
+ * changes.
+ *
+ * Angular has two different kinds of effect: component effects and root effects. Component effects
+ * are created when `effect()` is called from a component, directive, or within a service of a
+ * component/directive. Root effects are created when `effect()` is called from outside the
+ * component tree, such as in a root service, or when the `forceRoot` option is provided.
+ *
+ * The two effect types differ in their timing. Component effects run as a component lifecycle
+ * event during Angular's synchronization (change detection) process, and can safely read input
+ * signals or create/destroy views that depend on component state. Root effects run as microtasks
+ * and have no connection to the component tree or change detection.
+ *
+ * `effect()` must be run in injection context, unless the `injector` option is manually specified.
+ *
+ * @developerPreview
+ */
+export declare function effect(effectFn: (onCleanup: EffectCleanupRegisterFn) => void, options?: CreateEffectOptions): EffectRef;
+export interface EffectNode extends ReactiveNode, SchedulableEffect {
+    hasRun: boolean;
+    cleanupFns: EffectCleanupFn[] | undefined;
+    injector: Injector;
+    notifier: ChangeDetectionScheduler;
+    onDestroyFn: () => void;
+    fn: (cleanupFn: EffectCleanupRegisterFn) => void;
+    run(): void;
+    destroy(): void;
+    maybeCleanup(): void;
+}
+export interface RootEffectNode extends EffectNode {
+    scheduler: EffectScheduler;
+}
+/**
+ * Not public API, which guarantees `EffectScheduler` only ever comes from the application root
+ * injector.
+ */
+export declare const APP_EFFECT_SCHEDULER: InjectionToken<EffectScheduler>;
+export declare const BASE_EFFECT_NODE: Omit<EffectNode, 'fn' | 'destroy' | 'injector' | 'notifier'>;
+export declare const ROOT_EFFECT_NODE: Omit<RootEffectNode, 'fn' | 'scheduler' | 'notifier' | 'injector'>;
+export declare function createRootEffect(fn: (onCleanup: EffectCleanupRegisterFn) => void, scheduler: EffectScheduler, notifier: ChangeDetectionScheduler): RootEffectNode;

package/import/render3/reactivity/linked_signal.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @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 { WritableSignal } from './signal';
+import { ValueEqualityFn } from './api';
+/**
+ * Creates a writable signal whose value is initialized and reset by the linked, reactive computation.
+ *
+ * @developerPreview
+ */
+export declare function linkedSignal<D>(computation: () => D, options?: {
+    equal?: ValueEqualityFn<NoInfer<D>>;
+}): WritableSignal<D>;
+/**
+ * Creates a writable signal whose value is initialized and reset by the linked, reactive computation.
+ * This is an advanced API form where the computation has access to the previous value of the signal and the computation result.
+ *
+ * Note: The computation is reactive, meaning the linked signal will automatically update whenever any of the signals used within the computation change.
+ *
+ * @developerPreview
+ */
+export declare function linkedSignal<S, D>(options: {
+    source: () => S;
+    computation: (source: NoInfer<S>, previous?: {
+        source: NoInfer<S>;
+        value: NoInfer<D>;
+    }) => D;
+    equal?: ValueEqualityFn<NoInfer<D>>;
+}): WritableSignal<D>;

package/import/render3/reactivity/microtask_effect.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @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 { CreateEffectOptions, EffectCleanupRegisterFn, EffectRef } from './effect';
+import { type SchedulableEffect, ZoneAwareEffectScheduler } from './root_effect_scheduler';
+export declare class MicrotaskEffectScheduler extends ZoneAwareEffectScheduler {
+    private readonly pendingTasks;
+    private taskId;
+    schedule(effect: SchedulableEffect): void;
+    flush(): void;
+    /** @nocollapse */
+    static ɵprov: unknown;
+}
+/**
+ * Create a global `Effect` for the given reactive function.
+ */
+export declare function microtaskEffect(effectFn: (onCleanup: EffectCleanupRegisterFn) => void, options?: CreateEffectOptions): EffectRef;

package/import/render3/reactivity/patch.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @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
+ */
+/**
+ * Controls whether effects use the legacy `microtaskEffect` by default.
+ */
+export declare const USE_MICROTASK_EFFECT_BY_DEFAULT = false;

package/import/render3/reactivity/root_effect_scheduler.d.ts

@@ -0,0 +1,54 @@
+/**
+ * @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
+ */
+/**
+ * Abstraction that encompasses any kind of effect that can be scheduled.
+ */
+export interface SchedulableEffect {
+    run(): void;
+    zone: {
+        run<T>(fn: () => T): T;
+    } | null;
+}
+/**
+ * A scheduler which manages the execution of effects.
+ */
+export declare abstract class EffectScheduler {
+    /**
+     * Schedule the given effect to be executed at a later time.
+     *
+     * It is an error to attempt to execute any effects synchronously during a scheduling operation.
+     */
+    abstract schedule(e: SchedulableEffect): void;
+    /**
+     * Run any scheduled effects.
+     */
+    abstract flush(): void;
+    /** Remove a scheduled effect */
+    abstract remove(e: SchedulableEffect): void;
+    /** @nocollapse */
+    static ɵprov: unknown;
+}
+/**
+ * A wrapper around `ZoneAwareQueueingScheduler` that schedules flushing via the microtask queue
+ * when.
+ */
+export declare class ZoneAwareEffectScheduler implements EffectScheduler {
+    private queuedEffectCount;
+    private queues;
+    schedule(handle: SchedulableEffect): void;
+    remove(handle: SchedulableEffect): void;
+    private enqueue;
+    /**
+     * Run all scheduled effects.
+     *
+     * Execution order of effects within the same zone is guaranteed to be FIFO, but there is no
+     * ordering guarantee between effects scheduled in different zones.
+     */
+    flush(): void;
+    private flushQueue;
+}

package/import/render3/reactivity/signal.d.ts

@@ -0,0 +1,61 @@
+/**
+ * @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 { SignalGetter } from '@angular/core/primitives/signals';
+import { Signal, ValueEqualityFn } from './api';
+/** Symbol used distinguish `WritableSignal` from other non-writable signals and functions. */
+export declare const ɵWRITABLE_SIGNAL: unique symbol;
+/**
+ * A `Signal` with a value that can be mutated via a setter interface.
+ */
+export interface WritableSignal<T> extends Signal<T> {
+    [ɵWRITABLE_SIGNAL]: T;
+    /**
+     * Directly set the signal to a new value, and notify any dependents.
+     */
+    set(value: T): void;
+    /**
+     * Update the value of the signal based on its current value, and
+     * notify any dependents.
+     */
+    update(updateFn: (value: T) => T): void;
+    /**
+     * Returns a readonly version of this signal. Readonly signals can be accessed to read their value
+     * but can't be changed using set or update methods. The readonly signals do _not_ have
+     * any built-in mechanism that would prevent deep-mutation of their value.
+     */
+    asReadonly(): Signal<T>;
+}
+/**
+ * Utility function used during template type checking to extract the value from a `WritableSignal`.
+ * @codeGenApi
+ */
+export declare function ɵunwrapWritableSignal<T>(value: T | {
+    [ɵWRITABLE_SIGNAL]: T;
+}): T;
+/**
+ * Options passed to the `signal` creation function.
+ */
+export interface CreateSignalOptions<T> {
+    /**
+     * A comparison function which defines equality for signal values.
+     */
+    equal?: ValueEqualityFn<T>;
+    /**
+     * A debug name for the signal. Used in Angular DevTools to identify the signal.
+     */
+    debugName?: string;
+}
+/**
+ * Create a `Signal` that can be set or updated directly.
+ */
+export declare function signal<T>(initialValue: T, options?: CreateSignalOptions<T>): WritableSignal<T>;
+export declare function signalAsReadonlyFn<T>(this: SignalGetter<T>): Signal<T>;
+/**
+ * Checks if the given `value` is a writeable signal.
+ */
+export declare function isWritableSignal(value: unknown): value is WritableSignal<unknown>;

package/import/render3/reactivity/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;