static-injector 6.0.2 → 6.1.0

package/import/change_detection/scheduling/zoneless_scheduling.d.ts

@@ -31,7 +31,7 @@ export declare abstract class ChangeDetectionScheduler {
 }
 /** Token used to indicate if zoneless was enabled via provideZonelessChangeDetection(). */
 export declare const ZONELESS_ENABLED: InjectionToken<boolean>;
-/** Token used to indicate `provideExperimentalZonelessChangeDetection` was used. */
+/** Token used to indicate `provideZonelessChangeDetection` was used. */
 export declare const PROVIDED_ZONELESS: InjectionToken<boolean>;
 export declare const ZONELESS_SCHEDULER_DISABLED: InjectionToken<boolean>;
 export declare const SCHEDULE_IN_ROOT_ZONE: InjectionToken<boolean>;

package/import/core_reactivity_export_internal.d.ts

@@ -5,13 +5,12 @@
  * 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
  */
-export { SIGNAL as ɵSIGNAL } from '@angular/core/primitives/signals';
+export { SIGNAL as ɵSIGNAL } from '../primitives/signals';
 export { isSignal, Signal, ValueEqualityFn } from './render3/reactivity/api';
 export { computed, CreateComputedOptions } from './render3/reactivity/computed';
-export { CreateSignalOptions, signal, WritableSignal, ɵunwrapWritableSignal, } from './render3/reactivity/signal';
+export { CreateSignalOptions, signal, WritableSignal, ɵunwrapWritableSignal } from './render3/reactivity/signal';
 export { linkedSignal } from './render3/reactivity/linked_signal';
 export { untracked } from './render3/reactivity/untracked';
-export { CreateEffectOptions, effect, EffectRef, EffectCleanupFn, EffectCleanupRegisterFn, } from './render3/reactivity/effect';
-export { MicrotaskEffectScheduler as ɵMicrotaskEffectScheduler, microtaskEffect as ɵmicrotaskEffect, } from './render3/reactivity/microtask_effect';
+export { CreateEffectOptions, effect, EffectRef, EffectCleanupFn, EffectCleanupRegisterFn } from './render3/reactivity/effect';
 export { EffectScheduler as ɵEffectScheduler } from './render3/reactivity/root_effect_scheduler';
 export { assertNotInReactiveContext } from './render3/reactivity/asserts';

package/import/di/forward_ref.d.ts

@@ -34,24 +34,26 @@ export interface ForwardRefFn {
  * ### Circular standalone reference import example
  * ```angular-ts
  * @Component({
- *   standalone: true,
  *   imports: [ChildComponent],
  *   selector: 'app-parent',
- *   template: `<app-child [hideParent]="hideParent"></app-child>`,
+ *   template: `<app-child [hideParent]="hideParent()"></app-child>`,
  * })
  * export class ParentComponent {
- *   @Input() hideParent: boolean;
+ *    hideParent = input.required<boolean>();
  * }
  *
  *
  * @Component({
- *   standalone: true,
- *   imports: [CommonModule, forwardRef(() => ParentComponent)],
+ *   imports: [forwardRef(() => ParentComponent)],
  *   selector: 'app-child',
- *   template: `<app-parent *ngIf="!hideParent"></app-parent>`,
+ *   template: `
+ *    @if(!hideParent() {
+ *       <app-parent/>
+ *    }
+ *  `,
  * })
  * export class ChildComponent {
- *   @Input() hideParent: boolean;
+ *    hideParent = input.required<boolean>();
  * }
  * ```
  *

package/import/di/inject_switch.d.ts

@@ -5,13 +5,13 @@
  * 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 { InjectFlags } from './interface/injector';
+import { InternalInjectFlags } from './interface/injector';
 import { ProviderToken } from './provider_token';
-export declare function getInjectImplementation(): (<T>(token: ProviderToken<T>, flags?: InjectFlags) => T | null) | undefined;
+export declare function getInjectImplementation(): (<T>(token: ProviderToken<T>, flags?: InternalInjectFlags) => T | null) | undefined;
 /**
  * Sets the current inject implementation.
  */
-export declare function setInjectImplementation(impl: (<T>(token: ProviderToken<T>, flags?: InjectFlags) => T | null) | undefined): (<T>(token: ProviderToken<T>, flags?: InjectFlags) => T | null) | undefined;
+export declare function setInjectImplementation(impl: (<T>(token: ProviderToken<T>, flags?: InternalInjectFlags) => T | null) | undefined): (<T>(token: ProviderToken<T>, flags?: InternalInjectFlags) => T | null) | undefined;
 /**
  * Injects `root` tokens in limp mode.
  *
@@ -19,4 +19,4 @@ export declare function setInjectImplementation(impl: (<T>(token: ProviderToken<
  * `"root"`. This is known as the limp mode injection. In such case the value is stored in the
  * injectable definition.
  */
-export declare function injectRootLimpMode<T>(token: ProviderToken<T>, notFoundValue: T | undefined, flags: InjectFlags): T | null;
+export declare function injectRootLimpMode<T>(token: ProviderToken<T>, notFoundValue: T | undefined, flags: InternalInjectFlags): T | null;

package/import/di/injector.d.ts

@@ -6,7 +6,7 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 import { InjectorMarkers } from './injector_marker';
-import { InjectFlags, InjectOptions } from './interface/injector';
+import { InjectOptions } from './interface/injector';
 import { Provider, StaticProvider } from './interface/provider';
 import { ProviderToken } from './provider_token';
 /**
@@ -36,12 +36,6 @@ import { ProviderToken } from './provider_token';
 export declare abstract class Injector {
     static THROW_IF_NOT_FOUND: {};
     static NULL: Injector;
-    /**
-     * Internal note on the `options?: InjectOptions|InjectFlags` override of the `get`
-     * method: consider dropping the `InjectFlags` part in one of the major versions.
-     * It can **not** be done in minor/patch, since it's breaking for custom injectors
-     * that only implement the old `InjectorFlags` interface.
-     */
     /**
      * Retrieves an instance from the injector based on the provided token.
      * @returns The instance from the injector if defined, otherwise the `notFoundValue`.
@@ -61,19 +55,12 @@ export declare abstract class Injector {
      * @returns The instance from the injector if defined, otherwise the `notFoundValue`.
      * @throws When the `notFoundValue` is `undefined` or `Injector.THROW_IF_NOT_FOUND`.
      */
-    abstract get<T>(token: ProviderToken<T>, notFoundValue?: T, options?: InjectOptions | InjectFlags): T;
-    /**
-     * Retrieves an instance from the injector based on the provided token.
-     * @returns The instance from the injector if defined, otherwise the `notFoundValue`.
-     * @throws When the `notFoundValue` is `undefined` or `Injector.THROW_IF_NOT_FOUND`.
-     * @deprecated use object-based flags (`InjectOptions`) instead.
-     */
-    abstract get<T>(token: ProviderToken<T>, notFoundValue?: T, flags?: InjectFlags): T;
+    abstract get<T>(token: ProviderToken<T>, notFoundValue?: T, options?: InjectOptions): T;
     /**
      * @deprecated from v4.0.0 use ProviderToken<T>
      * @suppress {duplicate}
      */
-    abstract get(token: any, notFoundValue?: any): any;
+    abstract get<T>(token: string | ProviderToken<T>, notFoundValue?: any): any;
     /**
      * @deprecated from v5 use the new signature Injector.create(options)
      */
@@ -94,7 +81,7 @@ export declare abstract class Injector {
         providers: Array<Provider | StaticProvider>;
         parent?: Injector;
         name?: string;
-    }): Injector;
+    }): DestroyableInjector;
     /** @nocollapse */
     static ɵprov: unknown;
     /**
@@ -103,3 +90,11 @@ export declare abstract class Injector {
      */
     static __NG_ELEMENT_ID__: InjectorMarkers;
 }
+/**
+ * An Injector that the owner can destroy and trigger the DestroyRef.destroy hooks.
+ *
+ * @publicApi
+ */
+export interface DestroyableInjector extends Injector {
+    destroy(): void;
+}

package/import/di/injector_compatibility.d.ts

@@ -6,15 +6,32 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 import type { Injector } from './injector';
-import { DecoratorFlags, InjectFlags, InjectOptions, InternalInjectFlags } from './interface/injector';
+import { DecoratorFlags, InternalInjectFlags, InjectOptions } from './interface/injector';
 import { ProviderToken } from './provider_token';
+import { Injector as PrimitivesInjector, NotFound, InjectionToken as PrimitivesInjectionToken } from '../../primitives/di';
 export declare const THROW_IF_NOT_FOUND: {};
+export { getCurrentInjector, setCurrentInjector } from '../../primitives/di';
+/**
+ * A wrapper around an `Injector` that implements the `PrimitivesInjector` interface.
+ *
+ * This is used to allow the `inject` function to be used with the new primitives-based DI system.
+ */
+export declare class RetrievingInjector implements PrimitivesInjector {
+    readonly injector: Injector;
+    constructor(injector: Injector);
+    retrieve<T>(token: PrimitivesInjectionToken<T>, options: unknown): T | NotFound;
+}
 export declare const NG_TEMP_TOKEN_PATH = "ngTempTokenPath";
 export declare const SOURCE = "__source";
-export declare function getCurrentInjector(): Injector | undefined | null;
-export declare function setCurrentInjector(injector: Injector | null | undefined): Injector | undefined | null;
+/**
+ * Temporary type to allow internal symbols to use inject flags. This should be
+ * removed once we consolidate the flags and the object literal approach.
+ */
+export type BackwardsCompatibleInjector = Injector & {
+    get<T>(token: ProviderToken<T>, notFoundValue?: T, options?: InternalInjectFlags | InjectOptions): T;
+};
 export declare function injectInjectorOnly<T>(token: ProviderToken<T>): T;
-export declare function injectInjectorOnly<T>(token: ProviderToken<T>, flags?: InjectFlags): T | null;
+export declare function injectInjectorOnly<T>(token: ProviderToken<T>, flags?: InternalInjectFlags): T | null;
 /**
  * Generated instruction: injects a token from the currently active injector.
  *
@@ -26,8 +43,8 @@ export declare function injectInjectorOnly<T>(token: ProviderToken<T>, flags?: I
  * @publicApi This instruction has been emitted by ViewEngine for some time and is deployed to npm.
  */
 export declare function ɵɵinject<T>(token: ProviderToken<T>): T;
-export declare function ɵɵinject<T>(token: ProviderToken<T>, flags?: InjectFlags): T | null;
-export declare function ɵɵinject<T>(token: ProviderToken<T>, flags?: InjectFlags): string | null;
+export declare function ɵɵinject<T>(token: ProviderToken<T>, flags?: InternalInjectFlags): T | null;
+export declare function ɵɵinject<T>(token: ProviderToken<T>, flags?: InternalInjectFlags): string | null;
 /**
  * Throws an error indicating that a factory function could not be generated by the compiler for a
  * particular class.
@@ -46,17 +63,6 @@ export declare function ɵɵinvalidFactoryDep(index: number): void;
  * @publicApi
  */
 export declare function inject<T>(token: ProviderToken<T>): T;
-/**
- * @param token A token that represents a dependency that should be injected.
- * @param flags Control how injection is executed. The flags correspond to injection strategies that
- *     can be specified with parameter decorators `@Host`, `@Self`, `@SkipSelf`, and `@Optional`.
- * @returns the injected value if operation is successful, `null` otherwise.
- * @throws if called outside of a supported context.
- *
- * @publicApi
- * @deprecated prefer an options object instead of `InjectFlags`
- */
-export declare function inject<T>(token: ProviderToken<T>, flags?: InjectFlags): T | null;
 /**
  * @param token A token that represents a dependency that should be injected.
  * @param options Control how injection is executed. Options correspond to injection strategies
@@ -83,7 +89,7 @@ export declare function inject<T>(token: ProviderToken<T>, options: InjectOption
  * @publicApi
  */
 export declare function inject<T>(token: ProviderToken<T>, options: InjectOptions): T | null;
-export declare function convertToBitFlags(flags: InjectOptions | InjectFlags | undefined): InjectFlags | undefined;
+export declare function convertToBitFlags(flags: InjectOptions | InternalInjectFlags | undefined): InternalInjectFlags | undefined;
 export declare function injectArgs(types: (ProviderToken<any> | any[])[]): any[];
 /**
  * Attaches a given InjectFlag to a given decorator using monkey-patching.

package/import/di/interface/injector.d.ts

@@ -13,22 +13,6 @@
 export declare const enum DecoratorFlags {
     Inject = -1
 }
-/**
- * Injection flags for DI.
- *
- * @publicApi
- * @deprecated use an options object for [`inject`](api/core/inject) instead.
- */
-export declare enum InjectFlags {
-    /** Check self and check parent injector if needed */
-    Default = 0,
-    /** Don't ascend to ancestors of the node requesting injection. */
-    Self = 2,
-    /** Skip the node that is requesting injection. */
-    SkipSelf = 4,
-    /** Inject `defaultValue` instead if token not found. */
-    Optional = 8
-}
 /**
  * This enum is an exact copy of the `InjectFlags` enum above, but the difference is that this is a
  * const enum, so actual enum values would be inlined in generated code. The `InjectFlags` enum can
@@ -40,12 +24,24 @@ export declare enum InjectFlags {
 export declare const enum InternalInjectFlags {
     /** Check self and check parent injector if needed */
     Default = 0,
+    /**
+     * Specifies that an injector should retrieve a dependency from any injector until reaching the
+     * host element of the current component. (Only used with Element Injector)
+     */
+    Host = 1,
     /** Don't ascend to ancestors of the node requesting injection. */
     Self = 2,
     /** Skip the node that is requesting injection. */
     SkipSelf = 4,
     /** Inject `defaultValue` instead if token not found. */
-    Optional = 8
+    Optional = 8,
+    /**
+     * This token is being injected into a pipe.
+     *
+     * This flag is intentionally not in the public facing `InjectFlags` because it is only added by
+     * the compiler and is not a developer applicable flag.
+     */
+    ForPipe = 16
 }
 /**
  * Type of the options argument to [`inject`](api/core/inject).

package/import/di/metadata.d.ts

@@ -11,6 +11,13 @@
  * @publicApi
  */
 export interface InjectDecorator {
+    /**
+     * Warning: String tokens are not recommended.
+     *
+     * Use an InjectionToken or a class as a token instead.
+     */
+    (token: string): any;
+    new (token: string): Inject;
     /**
      * Parameter decorator on a dependency parameter of a class constructor
      * that specifies a custom provider of the dependency.

package/import/di/provider_collection.d.ts

@@ -10,6 +10,8 @@ import { ClassProvider, ConstructorProvider, EnvironmentProviders, ExistingProvi
 /**
  * Wrap an array of `Provider`s into `EnvironmentProviders`, preventing them from being accidentally
  * referenced in `@Component` in a component injector.
+ *
+ * @publicApi
  */
 export declare function makeEnvironmentProviders(providers: (Provider | EnvironmentProviders)[]): EnvironmentProviders;
 /**
@@ -46,48 +48,6 @@ export declare function provideEnvironmentInitializer(initializerFn: () => void)
  * @publicApi
  */
 export type ImportProvidersSource = Type<unknown> | ModuleWithProviders<unknown> | Array<ImportProvidersSource>;
-/**
- * Collects providers from all NgModules and standalone components, including transitively imported
- * ones.
- *
- * Providers extracted via `importProvidersFrom` are only usable in an application injector or
- * another environment injector (such as a route injector). They should not be used in component
- * providers.
- *
- * More information about standalone components can be found in [this
- * guide](guide/components/importing).
- *
- * @usageNotes
- * The results of the `importProvidersFrom` call can be used in the `bootstrapApplication` call:
- *
- * ```ts
- * await bootstrapApplication(RootComponent, {
- *   providers: [
- *     importProvidersFrom(NgModuleOne, NgModuleTwo)
- *   ]
- * });
- * ```
- *
- * You can also use the `importProvidersFrom` results in the `providers` field of a route, when a
- * standalone component is used:
- *
- * ```ts
- * export const ROUTES: Route[] = [
- *   {
- *     path: 'foo',
- *     providers: [
- *       importProvidersFrom(NgModuleOne, NgModuleTwo)
- *     ],
- *     component: YourStandaloneComponent
- *   }
- * ];
- * ```
- *
- * @returns Collected providers from the specified list of types.
- * @publicApi
- */
-export declare function importProvidersFrom(...sources: ImportProvidersSource[]): EnvironmentProviders;
-export declare function internalImportProvidersFrom(checkForStandaloneCmp: boolean, ...sources: ImportProvidersSource[]): Provider[];
 /**
  * Internal type for a single provider in a deep provider array.
  */

package/import/di/r3_injector.d.ts

@@ -7,15 +7,18 @@
  */
 import type { Injector } from './injector';
 import { InjectorType } from './interface/defs';
-import { InjectFlags, InjectOptions } from './interface/injector';
+import { InjectOptions } from './interface/injector';
 import { EnvironmentProviders, Provider } from './interface/provider';
 import { SingleProvider } from './provider_collection';
 import { ProviderToken } from './provider_token';
 import { InjectorScope } from './scope';
+import { Injector as PrimitivesInjector, InjectionToken as PrimitivesInjectionToken, NotFound } from '@angular/core/primitives/di';
 export declare function getNullInjector(): Injector;
 /**
  * An `Injector` that's part of the environment injector hierarchy, which exists outside of the
  * component tree.
+ *
+ * @publicApi
  */
 export declare abstract class EnvironmentInjector implements Injector {
     /**
@@ -38,18 +41,11 @@ export declare abstract class EnvironmentInjector implements Injector {
      * @throws When the `notFoundValue` is `undefined` or `Injector.THROW_IF_NOT_FOUND`.
      */
     abstract get<T>(token: ProviderToken<T>, notFoundValue?: T, options?: InjectOptions): T;
-    /**
-     * Retrieves an instance from the injector based on the provided token.
-     * @returns The instance from the injector if defined, otherwise the `notFoundValue`.
-     * @throws When the `notFoundValue` is `undefined` or `Injector.THROW_IF_NOT_FOUND`.
-     * @deprecated use object-based flags (`InjectOptions`) instead.
-     */
-    abstract get<T>(token: ProviderToken<T>, notFoundValue?: T, flags?: InjectFlags): T;
     /**
      * @deprecated from v4.0.0 use ProviderToken<T>
      * @suppress {duplicate}
      */
-    abstract get(token: any, notFoundValue?: any): any;
+    abstract get<T>(token: string | ProviderToken<T>, notFoundValue?: any): any;
     /**
      * Runs the given function in the context of this `EnvironmentInjector`.
      *
@@ -63,12 +59,14 @@ export declare abstract class EnvironmentInjector implements Injector {
      */
     abstract runInContext<ReturnT>(fn: () => ReturnT): ReturnT;
     abstract destroy(): void;
+    /** @internal */
+    abstract get destroyed(): boolean;
     /**
      * @internal
      */
     abstract onDestroy(callback: () => void): () => void;
 }
-export declare class R3Injector extends EnvironmentInjector {
+export declare class R3Injector extends EnvironmentInjector implements PrimitivesInjector {
     readonly parent: Injector;
     readonly source: string | null;
     readonly scopes: Set<InjectorScope>;
@@ -90,6 +88,7 @@ export declare class R3Injector extends EnvironmentInjector {
     private _destroyed;
     private injectorDefTypes;
     constructor(providers: Array<Provider | EnvironmentProviders>, parent: Injector, source: string | null, scopes: Set<InjectorScope>);
+    retrieve<T>(token: PrimitivesInjectionToken<T>, options?: unknown): T | NotFound;
     /**
      * Destroy the injector and release references to every instance or provider associated with it.
      *
@@ -99,7 +98,7 @@ export declare class R3Injector extends EnvironmentInjector {
     destroy(): void;
     onDestroy(callback: () => void): () => void;
     runInContext<ReturnT>(fn: () => ReturnT): ReturnT;
-    get<T>(token: ProviderToken<T>, notFoundValue?: any, flags?: InjectFlags | InjectOptions): T;
+    get<T>(token: ProviderToken<T>, notFoundValue?: any, options?: InjectOptions): T;
     /** @internal */
     resolveInjectorInitializers(): void;
     toString(): string;

package/import/error_handler.d.ts

@@ -5,6 +5,7 @@
  * 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 { InjectionToken } from './di/injection_token';
 /**
  * Provides a hook for centralized exception handling.
  *
@@ -43,3 +44,7 @@ export declare class ErrorHandler {
     _console: Console;
     handleError(error: any): void;
 }
+/**
+ * `InjectionToken` used to configure how to call the `ErrorHandler`.
+ */
+export declare const INTERNAL_APPLICATION_ERROR_HANDLER: InjectionToken<(e: any) => void>;

package/import/errors.d.ts

@@ -52,6 +52,9 @@ export declare const enum RuntimeErrorCode {
     HOST_DIRECTIVE_CONFLICTING_ALIAS = 312,
     MULTIPLE_MATCHING_PIPES = 313,
     UNINITIALIZED_LET_ACCESS = 314,
+    NO_BINDING_TARGET = 315,
+    INVALID_BINDING_TARGET = 316,
+    INVALID_SET_INPUT_CALL = 317,
     MULTIPLE_PLATFORMS = 400,
     PLATFORM_NOT_FOUND = 401,
     MISSING_REQUIRED_INJECTABLE_IN_BOOTSTRAP = 402,
@@ -76,6 +79,7 @@ export declare const enum RuntimeErrorCode {
     INVALID_I18N_STRUCTURE = 700,
     MISSING_LOCALE_DATA = 701,
     DEFER_LOADING_FAILED = -750,
+    DEFER_IN_HMR_MODE = -751,
     IMPORT_PROVIDERS_FROM_STANDALONE = 800,
     INVALID_DIFFER_INPUT = 900,
     NO_SUPPORTING_DIFFER_FACTORY = 901,
@@ -92,6 +96,9 @@ export declare const enum RuntimeErrorCode {
     COMPONENT_ID_COLLISION = -912,
     IMAGE_PERFORMANCE_WARNING = -913,
     UNEXPECTED_ZONEJS_PRESENT_IN_ZONELESS_MODE = 914,
+    MISSING_NG_MODULE_DEFINITION = 915,
+    MISSING_DIRECTIVE_DEFINITION = 916,
+    NO_COMPONENT_FACTORY_FOUND = 917,
     REQUIRED_INPUT_NO_VALUE = -950,
     REQUIRED_QUERY_NO_VALUE = -951,
     REQUIRED_MODEL_NO_VALUE = 952,
@@ -99,7 +106,9 @@ export declare const enum RuntimeErrorCode {
     LOOP_TRACK_DUPLICATE_KEYS = -955,
     LOOP_TRACK_RECREATE = -956,
     RUNTIME_DEPS_INVALID_IMPORTED_TYPE = 980,
-    RUNTIME_DEPS_ORPHAN_COMPONENT = 981
+    RUNTIME_DEPS_ORPHAN_COMPONENT = 981,
+    MUST_PROVIDE_STREAM_OPTION = 990,
+    RESOURCE_COMPLETED_BEFORE_PRODUCING_VALUE = 991
 }
 /**
  * Class that represents a runtime error.
@@ -121,6 +130,7 @@ export declare class RuntimeError<T extends number = RuntimeErrorCode> extends E
     code: T;
     constructor(code: T, message: null | false | string);
 }
+export declare function formatRuntimeErrorCode<T extends number = RuntimeErrorCode>(code: T): string;
 /**
  * Called to format a runtime error.
  * See additional info on the `message` argument type in the `RuntimeError` class description.

package/import/index.d.ts

@@ -19,6 +19,10 @@ export * from './core_reactivity_export_internal';
 export * from './change_detection/scheduling/zoneless_scheduling';
 export * from './change_detection/scheduling/zoneless_scheduling_impl';
 export * from './resource';
+export * from './di/provider_token';
+export * from './error_handler';
+export * from './pending_tasks';
+export declare function Injectable(args?: any): (constructor: Function) => void;
 export declare class StaticInjectOptions {
     static injectOptions: Parameters<InjectableDecorator>[0];
 }

package/import/linker/destroy_ref.d.ts

@@ -32,6 +32,8 @@ export declare abstract class DestroyRef {
      * ```
      */
     abstract onDestroy(callback: () => void): () => void;
+    /** @internal */
+    abstract get destroyed(): boolean;
     /**
      * @internal
      * @nocollapse

package/import/pending_tasks.d.ts

@@ -5,7 +5,7 @@
  * 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 { Observable } from 'rxjs';
 import { OnDestroy } from './interface/lifecycle_hooks';
 /**
  * Internal implementation of the pending tasks service.
@@ -13,8 +13,14 @@ import { OnDestroy } from './interface/lifecycle_hooks';
 export declare class PendingTasksInternal implements OnDestroy {
     private taskId;
     private pendingTasks;
-    private get _hasPendingTasks();
-    hasPendingTasks: BehaviorSubject<boolean>;
+    private destroyed;
+    private pendingTask;
+    get hasPendingTasks(): boolean;
+    /**
+     * In case the service is about to be destroyed, return a self-completing observable.
+     * Otherwise, return the observable that emits the current state of pending tasks.
+     */
+    get hasPendingTasksObservable(): Observable<boolean>;
     add(): number;
     has(taskId: number): boolean;
     remove(taskId: number): void;
@@ -41,12 +47,12 @@ export declare class PendingTasksInternal implements OnDestroy {
  * taskCleanup();
  * ```
  *
- * @publicApi
- * @developerPreview
+ * @publicApi 20.0
  */
 export declare class PendingTasks {
-    private internalPendingTasks;
-    private scheduler;
+    private readonly internalPendingTasks;
+    private readonly scheduler;
+    private readonly errorHandler;
     /**
      * Adds a new task that should block application's stability.
      * @returns A cleanup function that removes a task when called.
@@ -62,17 +68,10 @@ export declare class PendingTasks {
      * });
      * ```
      *
-     * 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
+     * @developerPreview 19.0
      */
-    run<T>(fn: () => Promise<T>): Promise<T>;
+    run(fn: () => Promise<unknown>): void;
     /** @nocollapse */
     static ɵprov: unknown;
 }

package/import/render3/errors_di.d.ts

@@ -6,5 +6,7 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 import type { ProviderToken } from '../di';
+/** Called when directives inject each other (creating a circular dependency) */
+export declare function throwCyclicDependencyError(token: string, path?: string[]): never;
 /** Throws an error when a token is not found in DI. */
 export declare function throwProviderNotFoundError(token: ProviderToken<unknown>, injectorName?: string): never;

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

@@ -5,7 +5,7 @@
  * 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';
+import { SIGNAL } from '../../../primitives/signals';
 /**
  * A reactive value which notifies consumers of any changes.
  *
@@ -13,12 +13,16 @@ import { SIGNAL } from '@angular/core/primitives/signals';
  * call it.
  *
  * Ordinary values can be turned into `Signal`s with the `signal` function.
+ *
+ * @publicApi 17.0
  */
 export type Signal<T> = (() => T) & {
     [SIGNAL]: unknown;
 };
 /**
  * Checks if the given `value` is a reactive `Signal`.
+ *
+ * @publicApi 17.0
  */
 export declare function isSignal(value: unknown): value is Signal<unknown>;
 /**

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

@@ -7,7 +7,7 @@
  */
 /**
  * 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}).
+ * to disallow certain code from running inside a reactive context (see {@link /api/core/rxjs/toSignal toSignal})
  *
  * @param debugFn a reference to the function making the assertion (used for the error message).
  *