static-injector 6.3.0 → 6.4.0

package/import/di/index.d.ts

@@ -1,3 +1,4 @@
 export { ProviderToken } from './provider_token';
 export { assertInInjectionContext, runInInjectionContext } from './contextual';
 export { EnvironmentInjector } from './r3_injector';
+export { FactoryProvider } from './interface/provider';

package/import/render3/debug/injector_profiler.d.ts

@@ -0,0 +1,133 @@
+/**
+ * @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 { ProviderToken } from '../../di';
+import type { Injector } from '../../di/injector';
+import { InternalInjectFlags } from '../../di/interface/injector';
+import type { SingleProvider } from '../../di/provider_collection';
+import { Type } from '../../interface/type';
+import type { EffectRef } from '../reactivity/effect';
+/**
+ * An enum describing the types of events that can be emitted from the injector profiler
+ */
+export declare const enum InjectorProfilerEventType {
+    /**
+     * Emits when a service is injected.
+     */
+    Inject = 0,
+    /**
+     * Emits when an Angular class instance is created by an injector.
+     */
+    InstanceCreatedByInjector = 1,
+    /**
+     * Emits when an injector configures a provider.
+     */
+    ProviderConfigured = 2,
+    /**
+     * Emits when an effect is created.
+     */
+    EffectCreated = 3,
+    /**
+     * Emits when an Angular DI system is about to create an instance corresponding to a given token.
+     */
+    InjectorToCreateInstanceEvent = 4
+}
+/**
+ * An object that defines an injection context for the injector profiler.
+ */
+export interface InjectorProfilerContext {
+}
+export interface InjectedServiceEvent {
+}
+export interface InjectorToCreateInstanceEvent {
+}
+export interface InjectorCreatedInstanceEvent {
+}
+export interface ProviderConfiguredEvent {
+}
+export interface EffectCreatedEvent {
+}
+/**
+ * An object representing an event that is emitted through the injector profiler
+ */
+export type InjectorProfilerEvent = InjectedServiceEvent | InjectorToCreateInstanceEvent | InjectorCreatedInstanceEvent | ProviderConfiguredEvent | EffectCreatedEvent;
+/**
+ * An object that contains information about a provider that has been configured
+ *
+ * TODO: rename to indicate that it is a debug structure eg. ProviderDebugInfo.
+ */
+export interface ProviderRecord {
+}
+/**
+ * An object that contains information about a value that has been constructed within an injector
+ */
+export interface InjectorCreatedInstance {
+}
+/**
+ * An object that contains information a service that has been injected within an
+ * InjectorProfilerContext
+ */
+export interface InjectedService {
+    /**
+     * In NodeInjectors, the LView and TNode that serviced this injection.
+     */
+    injectedIn?: {};
+}
+export interface InjectorProfiler {
+    (event: InjectorProfilerEvent): void;
+}
+export declare function getInjectorProfilerContext(): InjectorProfilerContext;
+export declare function setInjectorProfilerContext(context: InjectorProfilerContext): InjectorProfilerContext;
+/**
+ * Adds a callback function which will be invoked during certain DI events within the
+ * runtime (for example: injecting services, creating injectable instances, configuring providers).
+ * Multiple profiler callbacks can be set: in this case profiling events are
+ * reported to every registered callback.
+ *
+ * Warning: this function is *INTERNAL* and should not be relied upon in application's code.
+ * The contract of the function might be changed in any release and/or the function can be removed
+ * completely.
+ *
+ * @param profiler function provided by the caller or null value to disable profiling.
+ * @returns a cleanup function that, when invoked, removes a given profiler callback.
+ */
+export declare function setInjectorProfiler(injectorProfiler: InjectorProfiler | null): () => void;
+/**
+ * Injector profiler function which emits on DI events executed by the runtime.
+ *
+ * @param event InjectorProfilerEvent corresponding to the DI event being emitted
+ */
+export declare function injectorProfiler(event: InjectorProfilerEvent): void;
+/**
+ * Emits an InjectorProfilerEventType.ProviderConfigured to the injector profiler. The data in the
+ * emitted event includes the raw provider, as well as the token that provider is providing.
+ *
+ * @param eventProvider A provider object
+ */
+export declare function emitProviderConfiguredEvent(eventProvider: SingleProvider, isViewProvider?: boolean): void;
+/**
+ * Emits an event to the injector profiler when an instance corresponding to a given token is about to be created be an injector. Note that
+ * the injector associated with this emission can be accessed by using getDebugInjectContext()
+ *
+ * @param instance an object created by an injector
+ */
+export declare function emitInjectorToCreateInstanceEvent(token: ProviderToken<unknown>): void;
+/**
+ * Emits an event to the injector profiler with the instance that was created. Note that
+ * the injector associated with this emission can be accessed by using getDebugInjectContext()
+ *
+ * @param instance an object created by an injector
+ */
+export declare function emitInstanceCreatedByInjectorEvent(instance: unknown): void;
+/**
+ * @param token DI token associated with injected service
+ * @param value the instance of the injected service (i.e the result of `inject(token)`)
+ * @param flags the flags that the token was injected with
+ */
+export declare function emitInjectEvent(token: Type<unknown>, value: unknown, flags: InternalInjectFlags): void;
+export declare function emitEffectCreatedEvent(effect: EffectRef): void;
+export declare function runInInjectorProfilerContext(injector: Injector, token: Type<unknown>, callback: () => void): void;

package/import/render3/errors_di.d.ts

@@ -6,10 +6,35 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 import type { ProviderToken } from '../di';
+import { Type } from '../interface/type';
 /** Creates a circular dependency runtime error. */
 export declare function cyclicDependencyError(token: string, path?: string[]): Error;
+/** Creates a circular dependency runtime error including a dependency path in the error message. */
+export declare function cyclicDependencyErrorWithDetails(token: string, path: string[]): Error;
+export declare function throwMixedMultiProviderError(): void;
+export declare function throwInvalidProviderError(ngModuleType?: Type<unknown>, providers?: any[], provider?: any): never;
 /** Throws an error when a token is not found in DI. */
 export declare function throwProviderNotFoundError(token: ProviderToken<unknown>, injectorName?: string): never;
+/**
+ * Given an Error instance and the current token - update the monkey-patched
+ * dependency path info to include that token.
+ *
+ * @param error Current instance of the Error class.
+ * @param token Extra token that should be appended.
+ */
+export declare function prependTokenToDependencyPath(error: any, token: ProviderToken<unknown> | {
+    multi: true;
+    provide: ProviderToken<unknown>;
+}): void;
+/**
+ * Modifies an Error instance with an updated error message
+ * based on the accumulated dependency path.
+ *
+ * @param error Current instance of the Error class.
+ * @param source Extra info about the injector which started
+ *    the resolution process, which eventually failed.
+ */
+export declare function augmentRuntimeError(error: any, source: string | null): Error;
 /**
  * Creates an initial RuntimeError instance when a problem is detected.
  * Monkey-patches extra info in the RuntimeError instance, so that it can

package/import/render3/util/stringify_utils.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
+ */
+/**
+ * Used for stringify render output in Ivy.
+ * Important! This function is very performance-sensitive and we should
+ * be extra careful not to introduce megamorphic reads in it.
+ * Check `core/test/render3/perf/render_stringify` for benchmarks and alternate implementations.
+ */
+export declare function renderStringify(value: any): string;
+/**
+ * Used to stringify a value so that it can be displayed in an error message.
+ *
+ * Important! This function contains a megamorphic read and should only be
+ * used for error messages.
+ */
+export declare function stringifyForError(value: any): string;

package/import/util/array_utils.d.ts

@@ -0,0 +1,132 @@
+/**
+ * @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
+ */
+/**
+ * Determines if the contents of two arrays is identical
+ *
+ * @param a first array
+ * @param b second array
+ * @param identityAccessor Optional function for extracting stable object identity from a value in
+ *     the array.
+ */
+export declare function arrayEquals<T>(a: T[], b: T[], identityAccessor?: (value: T) => unknown): boolean;
+/**
+ * Flattens an array.
+ */
+export declare function flatten(list: any[]): any[];
+export declare function deepForEach<T>(input: (T | any[])[], fn: (value: T) => void): void;
+export declare function addToArray(arr: any[], index: number, value: any): void;
+export declare function removeFromArray(arr: any[], index: number): any;
+export declare function newArray<T = any>(size: number): T[];
+export declare function newArray<T>(size: number, value: T): T[];
+/**
+ * Remove item from array (Same as `Array.splice()` but faster.)
+ *
+ * `Array.splice()` is not as fast because it has to allocate an array for the elements which were
+ * removed. This causes memory pressure and slows down code when most of the time we don't
+ * care about the deleted items array.
+ *
+ * https://jsperf.com/fast-array-splice (About 20x faster)
+ *
+ * @param array Array to splice
+ * @param index Index of element in array to remove.
+ * @param count Number of items to remove.
+ */
+export declare function arraySplice(array: any[], index: number, count: number): void;
+/**
+ * Same as `Array.splice(index, 0, value)` but faster.
+ *
+ * `Array.splice()` is not fast because it has to allocate an array for the elements which were
+ * removed. This causes memory pressure and slows down code when most of the time we don't
+ * care about the deleted items array.
+ *
+ * @param array Array to splice.
+ * @param index Index in array where the `value` should be added.
+ * @param value Value to add to array.
+ */
+export declare function arrayInsert(array: any[], index: number, value: any): void;
+/**
+ * Same as `Array.splice2(index, 0, value1, value2)` but faster.
+ *
+ * `Array.splice()` is not fast because it has to allocate an array for the elements which were
+ * removed. This causes memory pressure and slows down code when most of the time we don't
+ * care about the deleted items array.
+ *
+ * @param array Array to splice.
+ * @param index Index in array where the `value` should be added.
+ * @param value1 Value to add to array.
+ * @param value2 Value to add to array.
+ */
+export declare function arrayInsert2(array: any[], index: number, value1: any, value2: any): void;
+/**
+ * Get an index of an `value` in a sorted `array`.
+ *
+ * NOTE:
+ * - This uses binary search algorithm for fast removals.
+ *
+ * @param array A sorted array to binary search.
+ * @param value The value to look for.
+ * @returns index of the value.
+ *   - positive index if value found.
+ *   - negative index if value not found. (`~index` to get the value where it should have been
+ *     located)
+ */
+export declare function arrayIndexOfSorted(array: string[], value: string): number;
+/**
+ * `KeyValueArray` is an array where even positions contain keys and odd positions contain values.
+ *
+ * `KeyValueArray` provides a very efficient way of iterating over its contents. For small
+ * sets (~10) the cost of binary searching an `KeyValueArray` has about the same performance
+ * characteristics that of a `Map` with significantly better memory footprint.
+ *
+ * If used as a `Map` the keys are stored in alphabetical order so that they can be binary searched
+ * for retrieval.
+ *
+ * See: `keyValueArraySet`, `keyValueArrayGet`, `keyValueArrayIndexOf`, `keyValueArrayDelete`.
+ */
+export interface KeyValueArray<VALUE> extends Array<VALUE | string> {
+    __brand__: 'array-map';
+}
+/**
+ * Set a `value` for a `key`.
+ *
+ * @param keyValueArray to modify.
+ * @param key The key to locate or create.
+ * @param value The value to set for a `key`.
+ * @returns index (always even) of where the value vas set.
+ */
+export declare function keyValueArraySet<V>(keyValueArray: KeyValueArray<V>, key: string, value: V): number;
+/**
+ * Retrieve a `value` for a `key` (on `undefined` if not found.)
+ *
+ * @param keyValueArray to search.
+ * @param key The key to locate.
+ * @return The `value` stored at the `key` location or `undefined if not found.
+ */
+export declare function keyValueArrayGet<V>(keyValueArray: KeyValueArray<V>, key: string): V | undefined;
+/**
+ * Retrieve a `key` index value in the array or `-1` if not found.
+ *
+ * @param keyValueArray to search.
+ * @param key The key to locate.
+ * @returns index of where the key is (or should have been.)
+ *   - positive (even) index if key found.
+ *   - negative index if key not found. (`~index` (even) to get the index where it should have
+ *     been inserted.)
+ */
+export declare function keyValueArrayIndexOf<V>(keyValueArray: KeyValueArray<V>, key: string): number;
+/**
+ * Delete a `key` (and `value`) from the `KeyValueArray`.
+ *
+ * @param keyValueArray to modify.
+ * @param key The key to locate or delete (if exist).
+ * @returns index of where the key was (or should have been.)
+ *   - positive (even) index if key found and deleted.
+ *   - negative index if key not found. (`~index` (even) to get the index where it should have
+ *     been.)
+ */
+export declare function keyValueArrayDelete<V>(keyValueArray: KeyValueArray<V>, key: string): number;

package/import/util/assert.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @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
+ */
+export declare function assertNumber(actual: any, msg: string): asserts actual is number;
+export declare function assertNumberInRange(actual: any, minInclusive: number, maxInclusive: number): asserts actual is number;
+export declare function assertString(actual: any, msg: string): asserts actual is string;
+export declare function assertFunction(actual: any, msg: string): asserts actual is Function;
+export declare function assertEqual<T>(actual: T, expected: T, msg: string): void;
+export declare function assertNotEqual<T>(actual: T, expected: T, msg: string): asserts actual is T;
+export declare function assertSame<T>(actual: T, expected: T, msg: string): asserts actual is T;
+export declare function assertNotSame<T>(actual: T, expected: T, msg: string): void;
+export declare function assertLessThan<T>(actual: T, expected: T, msg: string): asserts actual is T;
+export declare function assertLessThanOrEqual<T>(actual: T, expected: T, msg: string): asserts actual is T;
+export declare function assertGreaterThan<T>(actual: T, expected: T, msg: string): asserts actual is T;
+export declare function assertGreaterThanOrEqual<T>(actual: T, expected: T, msg: string): asserts actual is T;
+export declare function assertNotDefined<T>(actual: T, msg: string): void;
+export declare function assertDefined<T>(actual: T | null | undefined, msg: string): asserts actual is T;
+export declare function throwError(msg: string): never;
+export declare function throwError(msg: string, actual: any, expected: any, comparison: string): never;
+export declare function assertDomNode(node: any): asserts node is Node;
+export declare function assertElement(node: any): asserts node is Element;
+export declare function assertIndexInRange(arr: any[], index: number): void;
+export declare function assertOneOf(value: any, ...validValues: any[]): boolean;
+export declare function assertNotReactive(fn: string): void;