@angular/core 17.0.7 → 17.0.9

package/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * @license Angular v17.0.7
+ * @license Angular v17.0.9
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -642,7 +642,7 @@ export declare class ApplicationRef {
     private _destroyed;
     private _destroyListeners;
     private readonly internalErrorHandler;
-    private readonly zoneIsStable;
+    private readonly afterRenderEffectManager;
     /**
      * Indicates whether this instance was destroyed.
      */
@@ -788,6 +788,18 @@ export declare class ApplicationRef {
     static ɵprov: i0.ɵɵInjectableDeclaration<ApplicationRef>;
 }
 
+
+/**
+ * Marks a component for check (in case of OnPush components) and synchronously
+ * performs change detection on the application this component belongs to.
+ *
+ * @param component Component to {@link ChangeDetectorRef#markForCheck mark for check}.
+ *
+ * @publicApi
+ * @globalApi ng
+ */
+declare function applyChanges(component: {}): void;
+
 /**
  * @publicApi
  */
@@ -3041,6 +3053,18 @@ export declare interface Directive {
  */
 export declare const Directive: DirectiveDecorator;
 
+/**
+ * Partial metadata for a given directive instance.
+ * This information might be useful for debugging purposes or tooling.
+ * Currently only `inputs` and `outputs` metadata is available.
+ *
+ * @publicApi
+ */
+declare interface DirectiveDebugMetadata {
+    inputs: Record<string, string>;
+    outputs: Record<string, string>;
+}
+
 /**
  * Type of the Directive decorator / constructor function.
  * @publicApi
@@ -3911,6 +3935,49 @@ export declare interface ForwardRefFn {
     (): any;
 }
 
+/**
+ * Retrieves the component instance associated with a given DOM element.
+ *
+ * @usageNotes
+ * Given the following DOM structure:
+ *
+ * ```html
+ * <app-root>
+ *   <div>
+ *     <child-comp></child-comp>
+ *   </div>
+ * </app-root>
+ * ```
+ *
+ * Calling `getComponent` on `<child-comp>` will return the instance of `ChildComponent`
+ * associated with this DOM element.
+ *
+ * Calling the function on `<app-root>` will return the `MyApp` instance.
+ *
+ *
+ * @param element DOM element from which the component should be retrieved.
+ * @returns Component instance associated with the element or `null` if there
+ *    is no component associated with it.
+ *
+ * @publicApi
+ * @globalApi ng
+ */
+declare function getComponent<T>(element: Element): T | null;
+
+/**
+ * If inside an embedded view (e.g. `*ngIf` or `*ngFor`), retrieves the context of the embedded
+ * view that the element is part of. Otherwise retrieves the instance of the component whose view
+ * owns the element (in this case, the result is the same as calling `getOwningComponent`).
+ *
+ * @param element Element for which to get the surrounding component instance.
+ * @returns Instance of the component that is around the element or null if the element isn't
+ *    inside any component.
+ *
+ * @publicApi
+ * @globalApi ng
+ */
+declare function getContext<T extends {}>(element: Element): T | null;
+
 /**
  * @publicApi
  */
@@ -3918,6 +3985,115 @@ declare function getDebugNode(nativeNode: any): DebugNode | null;
 export { getDebugNode }
 export { getDebugNode as ɵgetDebugNode }
 
+/**
+ * Discovers the dependencies of an injectable instance. Provides DI information about each
+ * dependency that the injectable was instantiated with, including where they were provided from.
+ *
+ * @param injector An injector instance
+ * @param token a DI token that was constructed by the given injector instance
+ * @returns an object that contains the created instance of token as well as all of the dependencies
+ * that it was instantiated with OR undefined if the token was not created within the given
+ * injector.
+ */
+declare function getDependenciesFromInjectable<T>(injector: Injector, token: Type<T> | InjectionToken<T>): {
+    instance: T;
+    dependencies: Omit<InjectedService, 'injectedIn'>[];
+} | undefined;
+
+/**
+ * Returns the debug (partial) metadata for a particular directive or component instance.
+ * The function accepts an instance of a directive or component and returns the corresponding
+ * metadata.
+ *
+ * @param directiveOrComponentInstance Instance of a directive or component
+ * @returns metadata of the passed directive or component
+ *
+ * @publicApi
+ * @globalApi ng
+ */
+declare function getDirectiveMetadata(directiveOrComponentInstance: any): ɵComponentDebugMetadata | DirectiveDebugMetadata | null;
+
+/**
+ * Retrieves an `Injector` associated with an element, component or directive instance.
+ *
+ * @param elementOrDir DOM element, component or directive instance for which to
+ *    retrieve the injector.
+ * @returns Injector associated with the element, component or directive instance.
+ *
+ * @publicApi
+ * @globalApi ng
+ */
+declare function getInjector(elementOrDir: Element | {}): Injector;
+
+/**
+ *
+ * Given an injector, this function will return
+ * an object containing the type and source of the injector.
+ *
+ * |              | type        | source                                                      |
+ * |--------------|-------------|-------------------------------------------------------------|
+ * | NodeInjector | element     | DOM element that created this injector                      |
+ * | R3Injector   | environment | `injector.source`                                           |
+ * | NullInjector | null        | null                                                        |
+ *
+ * @param injector the Injector to get metadata for
+ * @returns an object containing the type and source of the given injector. If the injector metadata
+ *     cannot be determined, returns null.
+ */
+declare function getInjectorMetadata(injector: Injector): {
+    type: 'element';
+    source: RElement;
+} | {
+    type: 'environment';
+    source: string | null;
+} | {
+    type: 'null';
+    source: null;
+} | null;
+
+/**
+ * Gets the providers configured on an injector.
+ *
+ * @param injector the injector to lookup the providers of
+ * @returns ProviderRecord[] an array of objects representing the providers of the given injector
+ */
+declare function getInjectorProviders(injector: Injector): ɵProviderRecord[];
+
+declare function getInjectorResolutionPath(injector: Injector): Injector[];
+
+/**
+ * Retrieves a list of event listeners associated with a DOM element. The list does include host
+ * listeners, but it does not include event listeners defined outside of the Angular context
+ * (e.g. through `addEventListener`).
+ *
+ * @usageNotes
+ * Given the following DOM structure:
+ *
+ * ```html
+ * <app-root>
+ *   <div (click)="doSomething()"></div>
+ * </app-root>
+ * ```
+ *
+ * Calling `getListeners` on `<div>` will return an object that looks as follows:
+ *
+ * ```ts
+ * {
+ *   name: 'click',
+ *   element: <div>,
+ *   callback: () => doSomething(),
+ *   useCapture: false
+ * }
+ * ```
+ *
+ * @param element Element for which the DOM listeners should be retrieved.
+ * @returns Array of event listeners on the DOM element.
+ *
+ * @publicApi
+ * @globalApi ng
+ */
+declare function getListeners(element: Element): Listener[];
+
 /**
  * Returns the NgModuleFactory with the given id (specified using [@NgModule.id
  * field](api/core/NgModule#id)), if it exists and has been loaded. Factories for NgModules that do
@@ -3935,6 +4111,23 @@ export declare function getModuleFactory(id: string): NgModuleFactory<any>;
  */
 export declare function getNgModuleById<T>(id: string): Type<T>;
 
+/**
+ * Retrieves the component instance whose view contains the DOM element.
+ *
+ * For example, if `<child-comp>` is used in the template of `<app-comp>`
+ * (i.e. a `ViewChild` of `<app-comp>`), calling `getOwningComponent` on `<child-comp>`
+ * would return `<app-comp>`.
+ *
+ * @param elementOrDir DOM element, component or directive instance
+ *    for which to retrieve the root components.
+ * @returns Component instance whose view owns the DOM element or null if the element is not
+ *    part of a component view.
+ *
+ * @publicApi
+ * @globalApi ng
+ */
+declare function getOwningComponent<T>(elementOrDir: Element | {}): T | null;
+
 /**
  * Returns the current platform.
  *
@@ -3942,6 +4135,19 @@ export declare function getNgModuleById<T>(id: string): Type<T>;
  */
 export declare function getPlatform(): PlatformRef | null;
 
+/**
+ * Retrieves all root components associated with a DOM element, directive or component instance.
+ * Root components are those which have been bootstrapped by Angular.
+ *
+ * @param elementOrDir DOM element, component or directive instance
+ *    for which to retrieve the root components.
+ * @returns Root components associated with the target object.
+ *
+ * @publicApi
+ * @globalApi ng
+ */
+declare function getRootComponents(elementOrDir: Element | {}): {}[];
+
 /**
  * Adapter interface for retrieving the `Testability` service associated for a
  * particular context.
@@ -3953,6 +4159,12 @@ export declare interface GetTestability {
     findTestabilityInTree(registry: TestabilityRegistry, elem: any, findInAncestors: boolean): Testability | null;
 }
 
+/**
+ * This value reflects the property on the window where the dev
+ * tools are patched (window.ng).
+ * */
+declare const GLOBAL_PUBLISH_EXPANDO_KEY = "ng";
+
 /**
  * The goal here is to make sure that the browser DOM API is the Renderer.
  * We do this by defining a subset of DOM API to be the renderer and then
@@ -3965,6 +4177,29 @@ declare type GlobalTargetName = 'document' | 'window' | 'body';
 
 declare type GlobalTargetResolver = (element: any) => EventTarget;
 
+declare const globalUtilsFunctions: {
+    /**
+     * Warning: functions that start with `ɵ` are considered *INTERNAL* and should not be relied upon
+     * in application's code. The contract of those functions might be changed in any release and/or a
+     * function can be removed completely.
+     */
+    ɵgetDependenciesFromInjectable: typeof getDependenciesFromInjectable;
+    ɵgetInjectorProviders: typeof getInjectorProviders;
+    ɵgetInjectorResolutionPath: typeof getInjectorResolutionPath;
+    ɵgetInjectorMetadata: typeof getInjectorMetadata;
+    ɵsetProfiler: (profiler: ɵProfiler | null) => void;
+    getDirectiveMetadata: typeof getDirectiveMetadata;
+    getComponent: typeof getComponent;
+    getContext: typeof getContext;
+    getListeners: typeof getListeners;
+    getOwningComponent: typeof getOwningComponent;
+    getHostElement: typeof ɵgetHostElement;
+    getInjector: typeof getInjector;
+    getRootComponents: typeof getRootComponents;
+    getDirectives: typeof ɵgetDirectives;
+    applyChanges: typeof applyChanges;
+};
+
 /**
  * Array of hooks that should be executed for a view and their directive indices.
  *
@@ -4817,6 +5052,36 @@ export declare interface InjectDecorator {
     new (token: any): Inject;
 }
 
+/**
+ * An object that contains information a service that has been injected within an
+ * InjectorProfilerContext
+ */
+declare interface InjectedService {
+    /**
+     * DI token of the Service that is injected
+     */
+    token?: Type<unknown> | InjectionToken<unknown>;
+    /**
+     * Value of the injected service
+     */
+    value: unknown;
+    /**
+     * Flags that this service was injected with
+     */
+    flags?: InternalInjectFlags | InjectFlags | InjectOptions;
+    /**
+     * Injector that this service was provided in.
+     */
+    providedIn?: Injector;
+    /**
+     * In NodeInjectors, the LView and TNode that serviced this injection.
+     */
+    injectedIn?: {
+        lView: LView;
+        tNode: TNode;
+    };
+}
+
 /**
  * Injection flags for DI.
  *
@@ -5169,6 +5434,37 @@ declare interface InternalAfterNextRenderOptions {
     injector?: Injector;
 }
 
+/**
+ * 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
+ * be turned into a const enum when ViewEngine is removed (see TODO at the `InjectFlags` enum
+ * above). The benefit of inlining is that we can use these flags at the top level without affecting
+ * tree-shaking (see "no-toplevel-property-access" tslint rule for more info).
+ * Keep this enum in sync with `InjectFlags` enum above.
+ */
+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,
+    /**
+     * 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
+}
+
 declare interface InternalNgModuleRef<T> extends NgModuleRef<T> {
     _bootstrapComponents: Type<any>[];
 }
@@ -5562,12 +5858,26 @@ declare enum LContainerFlags {
      *
      * This flag, once set, is never unset for the `LContainer`.
      */
-    HasTransplantedViews = 2,
+    HasTransplantedViews = 2
+}
+
+/**
+ * Event listener configuration returned from `getListeners`.
+ * @publicApi
+ */
+declare interface Listener {
+    /** Name of the event listener. */
+    name: string;
+    /** Element that the listener is bound to. */
+    element: Element;
+    /** Callback that is invoked when the event is triggered. */
+    callback: (value: any) => any;
+    /** Whether the listener is using event capturing. */
+    useCapture: boolean;
     /**
-     * Indicates that this LContainer has a view underneath it that needs to be refreshed during
-     * change detection.
+     * Type of the listener (e.g. a native DOM event or a custom @Output).
      */
-    HasChildViewsToRefresh = 4
+    type: 'dom' | 'output';
 }
 
 /**
@@ -5924,6 +6234,8 @@ declare interface LViewEnvironment {
     inlineEffectRunner: FlushableEffectRunner | null;
     /** Container for after render hooks */
     afterRenderEventManager: ɵAfterRenderEventManager | null;
+    /** Scheduler for change detection to notify when application state changes. */
+    changeDetectionScheduler: ɵChangeDetectionScheduler | null;
 }
 
 /** Flags associated with an LView (saved in LView[FLAGS]) */
@@ -8234,6 +8546,11 @@ export declare interface SimpleChanges {
     [propName: string]: SimpleChange;
 }
 
+/**
+ * Internal type for a single provider in a deep provider array.
+ */
+declare type SingleProvider = TypeProvider | ValueProvider | ClassProvider | ConstructorProvider | ExistingProvider | FactoryProvider | StaticClassProvider;
+
 /**
  * Type of the `SkipSelf` metadata.
  *
@@ -10607,17 +10924,10 @@ export declare function ɵ_sanitizeUrl(url: string): string;
  * Delegates to an optional `AfterRenderCallbackHandler` for implementation.
  */
 export declare class ɵAfterRenderEventManager {
-    private renderDepth;
-    /**
-     * Mark the beginning of a render operation (i.e. CD cycle).
-     * Throws if called while executing callbacks.
-     */
-    begin(): void;
     /**
-     * Mark the end of a render operation. Callbacks will be
-     * executed if there are no more pending operations.
+     * Executes callbacks. Returns `true` if any callbacks executed.
      */
-    end(): void;
+    execute(): boolean;
     ngOnDestroy(): void;
     /** @nocollapse */
     static ɵprov: unknown;
@@ -10853,6 +11163,14 @@ export declare const enum ɵBypassType {
     Style = "Style"
 }
 
+
+/**
+ * Injectable that is notified when an `LView` is made aware of changes to application state.
+ */
+export declare abstract class ɵChangeDetectionScheduler {
+    abstract notify(): void;
+}
+
 export declare function ɵclearResolutionOfComponentResourcesQueue(): Map<Type<any>, Component>;
 
 /**
@@ -10894,6 +11212,22 @@ export declare function ɵcompileNgModuleFactory<M>(injector: Injector, options:
 
 export declare function ɵcompilePipe(type: Type<any>, meta: Pipe): void;
 
+/**
+ * Partial metadata for a given component instance.
+ * This information might be useful for debugging purposes or tooling.
+ * Currently the following fields are available:
+ *  - inputs
+ *  - outputs
+ *  - encapsulation
+ *  - changeDetection
+ *
+ * @publicApi
+ */
+export declare interface ɵComponentDebugMetadata extends DirectiveDebugMetadata {
+    encapsulation: ViewEncapsulation;
+    changeDetection: ChangeDetectionStrategy;
+}
+
 /**
  * Runtime link information for Components.
  *
@@ -11403,6 +11737,9 @@ export declare function ɵgetDeferBlocks(lView: LView, deferBlocks: ɵDeferBlock
  */
 export declare function ɵgetDirectives(node: Node): {}[];
 
+
+export declare function ɵgetEnsureDirtyViewsAreAlwaysReachable(): boolean;
+
 /**
  * Retrieves the host element of a component or directive instance.
  * The host element is the DOM element that matched the selector of the directive.
@@ -11482,6 +11819,13 @@ export declare function ɵgetUnknownPropertyStrictMode(): boolean;
 
 export declare const ɵglobal: any;
 
+/**
+ * Default debug tools available under `window.ng`.
+ */
+export declare type ɵGlobalDevModeUtils = {
+    [GLOBAL_PUBLISH_EXPANDO_KEY]: typeof globalUtilsFunctions;
+};
+
 /**
  * Injection token that configures the image optimized image functionality.
  * See {@link ImageConfig} for additional information about parameters that
@@ -11514,26 +11858,6 @@ export declare type ɵImageConfig = {
     disableImageLazyLoadWarning?: boolean;
 };
 
-/**
- * *Internal* service that keeps track of pending tasks happening in the system
- * during the initial rendering. No tasks are tracked after an initial
- * rendering.
- *
- * This information is needed to make sure that the serialization on the server
- * is delayed until all tasks in the queue (such as an initial navigation or a
- * pending HTTP request) are completed.
- */
-export declare class ɵInitialRenderPendingTasks implements OnDestroy {
-    private taskId;
-    private pendingTasks;
-    hasPendingTasks: BehaviorSubject<boolean>;
-    add(): number;
-    remove(taskId: number): void;
-    ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ɵInitialRenderPendingTasks, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<ɵInitialRenderPendingTasks>;
-}
-
 /** Returns a ChangeDetectorRef (a.k.a. a ViewRef) */
 export declare function ɵinjectChangeDetectorRef(flags: InjectFlags): ChangeDetectorRef;
 
@@ -11870,6 +12194,28 @@ export declare const ɵNOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR: {};
  */
 export declare function ɵpatchComponentDefWithScope<C>(componentDef: ɵComponentDef<C>, transitiveScopes: ɵNgModuleTransitiveScopes): void;
 
+/**
+ * *Internal* service that keeps track of pending tasks happening in the system.
+ *
+ * This information is needed to make sure that the serialization on the server
+ * is delayed until all tasks in the queue (such as an initial navigation or a
+ * pending HTTP request) are completed.
+ *
+ * Pending tasks continue to contribute to the stableness of `ApplicationRef`
+ * throughout the lifetime of the application.
+ */
+export declare class ɵPendingTasks implements OnDestroy {
+    private taskId;
+    private pendingTasks;
+    private get _hasPendingTasks();
+    hasPendingTasks: BehaviorSubject<boolean>;
+    add(): number;
+    remove(taskId: number): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ɵPendingTasks, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ɵPendingTasks>;
+}
+
 
 /**
  * A guarded `performance.mark` for feature marking.
@@ -11976,18 +12322,30 @@ export declare const enum ɵProfilerEvent {
 }
 
 /**
- * Publishes a collection of default debug tools onto`window.ng`.
+ * An object that contains information about a provider that has been configured
  *
- * These functions are available globally when Angular is in development
- * mode and are automatically stripped away from prod mode is on.
+ * TODO: rename to indicate that it is a debug structure eg. ProviderDebugInfo.
  */
-export declare function ɵpublishDefaultGlobalUtils(): void;
+export declare interface ɵProviderRecord {
+    /**
+     * DI token that this provider is configuring
+     */
+    token: Type<unknown> | InjectionToken<unknown>;
+    /**
+     * Determines if provider is configured as view provider.
+     */
+    isViewProvider: boolean;
+    /**
+     * The raw provider associated with this ProviderRecord.
+     */
+    provider: SingleProvider;
+    /**
+     * The path of DI containers that were followed to import this provider
+     */
+    importPath?: Type<unknown>[];
+}
 
-/**
- * Publishes the given function to `window.ng` so that it can be
- * used from the browser console when an application is not in production.
- */
-export declare function ɵpublishGlobalUtil(name: string, fn: Function): void;
+export declare function ɵprovideZonelessChangeDetection(): EnvironmentProviders;
 
 export declare class ɵReflectionCapabilities implements PlatformReflectionCapabilities {
     private _reflect;
@@ -12192,7 +12550,6 @@ export declare class ɵRuntimeError<T extends number = ɵRuntimeErrorCode> exten
 export declare const enum ɵRuntimeErrorCode {
     EXPRESSION_CHANGED_AFTER_CHECKED = -100,
     RECURSIVE_APPLICATION_REF_TICK = 101,
-    RECURSIVE_APPLICATION_RENDER = 102,
     INFINITE_CHANGE_DETECTION = 103,
     CYCLIC_DI_DEPENDENCY = -200,
     PROVIDER_NOT_FOUND = -201,
@@ -12361,6 +12718,8 @@ export declare function ɵsetCurrentInjector(injector: Injector | null | undefin
  */
 export declare function ɵsetDocument(document: Document | undefined): void;
 
+export declare function ɵsetEnsureDirtyViewsAreAlwaysReachable(v: boolean): void;
+
 export declare function ɵsetInjectorProfilerContext(context: ɵInjectorProfilerContext): ɵInjectorProfilerContext;
 
 
@@ -12769,7 +13128,7 @@ export declare class ɵZoneAwareQueueingScheduler implements ɵEffectScheduler,
  *
  * @codeGenApi
  */
-export declare function ɵɵadvance(delta: number): void;
+export declare function ɵɵadvance(delta?: number): void;
 
 /**
  * Updates the value of or removes a bound attribute on an Element.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular/core",
-  "version": "17.0.7",
+  "version": "17.0.9",
   "description": "Angular - the core framework",
   "author": "angular",
   "license": "MIT",

package/primitives/signals/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * @license Angular v17.0.7
+ * @license Angular v17.0.9
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */

package/rxjs-interop/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * @license Angular v17.0.7
+ * @license Angular v17.0.9
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */