@angular/core 16.2.0-next.4 → 16.2.0

package/esm2022/src/render3/debug/framework_injector_profiler.mjs

@@ -0,0 +1,212 @@
+/**
+ * @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.io/license
+ */
+import { EnvironmentInjector } from '../../di/r3_injector';
+import { throwError } from '../../util/assert';
+import { getComponentDef } from '../definition';
+import { getNodeInjectorLView, NodeInjector } from '../di';
+import { setInjectorProfiler } from './injector_profiler';
+/**
+ * These are the data structures that our framework injector profiler will fill with data in order
+ * to support DI debugging APIs.
+ *
+ * resolverToTokenToDependencies: Maps an injector to a Map of tokens to an Array of
+ * dependencies. Injector -> Token -> Dependencies This is used to support the
+ * getDependenciesFromInjectable API, which takes in an injector and a token and returns it's
+ * dependencies.
+ *
+ * resolverToProviders: Maps a DI resolver (an Injector or an LView) to the providers configured
+ * within it This is used to support the getInjectorProviders API, which takes in an injector and
+ * returns the providers that it was configured with.
+ *
+ * standaloneInjectorToComponent: Maps the injector of a standalone component to the standalone
+ * component that it is associated with. Used in the getInjectorProviders API, specificially in the
+ * discovery of import paths for each provider. This is necessary because the imports array of a
+ * standalone component is processed and configured in its standalone injector, but exists within
+ * the component's definition. Because getInjectorProviders takes in an injector, if that injector
+ * is the injector of a standalone component, we need to be able to discover the place where the
+ * imports array is located (the component) in order to flatten the imports array within it to
+ * discover all of it's providers.
+ *
+ *
+ * All of these data structures are instantiated with WeakMaps. This will ensure that the presence
+ * of any object in the keys of these maps does not prevent the garbage collector from collecting
+ * those objects. Because of this property of WeakMaps, these data structures will never be the
+ * source of a memory leak.
+ *
+ * An example of this advantage: When components are destroyed, we don't need to do
+ * any additional work to remove that component from our mappings.
+ *
+ */
+class DIDebugData {
+    constructor() {
+        this.resolverToTokenToDependencies = new WeakMap();
+        this.resolverToProviders = new WeakMap();
+        this.standaloneInjectorToComponent = new WeakMap();
+    }
+    reset() {
+        this.resolverToTokenToDependencies =
+            new WeakMap();
+        this.resolverToProviders = new WeakMap();
+        this.standaloneInjectorToComponent = new WeakMap();
+    }
+}
+let frameworkDIDebugData = new DIDebugData();
+export function getFrameworkDIDebugData() {
+    return frameworkDIDebugData;
+}
+/**
+ * Initalize default handling of injector events. This handling parses events
+ * as they are emitted and constructs the data structures necessary to support
+ * some of debug APIs.
+ *
+ * See handleInjectEvent, handleCreateEvent and handleProviderConfiguredEvent
+ * for descriptions of each handler
+ *
+ * Supported APIs:
+ *               - getDependenciesFromInjectable
+ *               - getInjectorProviders
+ */
+export function setupFrameworkInjectorProfiler() {
+    frameworkDIDebugData.reset();
+    setInjectorProfiler((injectorProfilerEvent) => handleInjectorProfilerEvent(injectorProfilerEvent));
+}
+function handleInjectorProfilerEvent(injectorProfilerEvent) {
+    const { context, type } = injectorProfilerEvent;
+    if (type === 0 /* InjectorProfilerEventType.Inject */) {
+        handleInjectEvent(context, injectorProfilerEvent.service);
+    }
+    else if (type === 1 /* InjectorProfilerEventType.InstanceCreatedByInjector */) {
+        handleInstanceCreatedByInjectorEvent(context, injectorProfilerEvent.instance);
+    }
+    else if (type === 2 /* InjectorProfilerEventType.ProviderConfigured */) {
+        handleProviderConfiguredEvent(context, injectorProfilerEvent.providerRecord);
+    }
+}
+/**
+ *
+ * Stores the injected service in frameworkDIDebugData.resolverToTokenToDependencies
+ * based on it's injector and token.
+ *
+ * @param context InjectorProfilerContext the injection context that this event occurred in.
+ * @param data InjectedService the service associated with this inject event.
+ *
+ */
+function handleInjectEvent(context, data) {
+    const diResolver = getDIResolver(context.injector);
+    if (diResolver === null) {
+        throwError('An Inject event must be run within an injection context.');
+    }
+    const diResolverToInstantiatedToken = frameworkDIDebugData.resolverToTokenToDependencies;
+    if (!diResolverToInstantiatedToken.has(diResolver)) {
+        diResolverToInstantiatedToken.set(diResolver, new WeakMap());
+    }
+    // if token is a primitive type, ignore this event. We do this because we cannot keep track of
+    // non-primitive tokens in WeakMaps since they are not garbage collectable.
+    if (!canBeHeldWeakly(context.token)) {
+        return;
+    }
+    const instantiatedTokenToDependencies = diResolverToInstantiatedToken.get(diResolver);
+    if (!instantiatedTokenToDependencies.has(context.token)) {
+        instantiatedTokenToDependencies.set(context.token, []);
+    }
+    const { token, value, flags } = data;
+    instantiatedTokenToDependencies.get(context.token).push({ token, value, flags });
+}
+/**
+ *
+ * If the created instance is an instance of a standalone component, maps the injector to that
+ * standalone component in frameworkDIDebugData.standaloneInjectorToComponent
+ *
+ * @param context InjectorProfilerContext the injection context that this event occurred in.
+ * @param data InjectorCreatedInstance an object containing the instance that was just created
+ *
+ */
+function handleInstanceCreatedByInjectorEvent(context, data) {
+    const { value } = data;
+    if (getDIResolver(context.injector) === null) {
+        throwError('An InjectorCreatedInstance event must be run within an injection context.');
+    }
+    // if our value is an instance of a standalone component, map the injector of that standalone
+    // component to the component class. Otherwise, this event is a noop.
+    let standaloneComponent = undefined;
+    if (typeof value === 'object') {
+        standaloneComponent = value?.constructor;
+    }
+    if (standaloneComponent === undefined || !isStandaloneComponent(standaloneComponent)) {
+        return;
+    }
+    const environmentInjector = context.injector.get(EnvironmentInjector, null, { optional: true });
+    // Standalone components should have an environment injector. If one cannot be
+    // found we may be in a test case for low level functionality that did not explictly
+    // setup this injector. In those cases, we simply ignore this event.
+    if (environmentInjector === null) {
+        return;
+    }
+    const { standaloneInjectorToComponent } = frameworkDIDebugData;
+    // If our injector has already been mapped, as is the case
+    // when a standalone component imports another standalone component,
+    // we consider the original component (the component doing the importing)
+    // as the component connected to our injector.
+    if (standaloneInjectorToComponent.has(environmentInjector)) {
+        return;
+    }
+    // If our injector hasn't been mapped, then we map it to the standalone component
+    standaloneInjectorToComponent.set(environmentInjector, standaloneComponent);
+}
+function isStandaloneComponent(value) {
+    const def = getComponentDef(value);
+    return !!def?.standalone;
+}
+/**
+ *
+ * Stores the emitted ProviderRecords from the InjectorProfilerEventType.ProviderConfigured
+ * event in frameworkDIDebugData.resolverToProviders
+ *
+ * @param context InjectorProfilerContext the injection context that this event occurred in.
+ * @param data ProviderRecord an object containing the instance that was just created
+ *
+ */
+function handleProviderConfiguredEvent(context, data) {
+    const { resolverToProviders } = frameworkDIDebugData;
+    const diResolver = getDIResolver(context?.injector);
+    if (diResolver === null) {
+        throwError('A ProviderConfigured event must be run within an injection context.');
+    }
+    if (!resolverToProviders.has(diResolver)) {
+        resolverToProviders.set(diResolver, []);
+    }
+    resolverToProviders.get(diResolver).push(data);
+}
+function getDIResolver(injector) {
+    let diResolver = null;
+    if (injector === undefined) {
+        return diResolver;
+    }
+    // We use the LView as the diResolver for NodeInjectors because they
+    // do not persist anywhere in the framework. They are simply wrappers around an LView and a TNode
+    // that do persist. Because of this, we rely on the LView of the NodeInjector in order to use
+    // as a concrete key to represent this injector. If we get the same LView back later, we know
+    // we're looking at the same injector.
+    if (injector instanceof NodeInjector) {
+        diResolver = getNodeInjectorLView(injector);
+    }
+    // Other injectors can be used a keys for a map because their instances
+    // persist
+    else {
+        diResolver = injector;
+    }
+    return diResolver;
+}
+// inspired by
+// https://tc39.es/ecma262/multipage/executable-code-and-execution-contexts.html#sec-canbeheldweakly
+function canBeHeldWeakly(value) {
+    // we check for value !== null here because typeof null === 'object
+    return value !== null &&
+        (typeof value === 'object' || typeof value === 'function' || typeof value === 'symbol');
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"framework_injector_profiler.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/debug/framework_injector_profiler.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {Injector} from '../../di/injector';\nimport {EnvironmentInjector} from '../../di/r3_injector';\nimport {Type} from '../../interface/type';\nimport {throwError} from '../../util/assert';\nimport {getComponentDef} from '../definition';\nimport {getNodeInjectorLView, NodeInjector} from '../di';\nimport {LView} from '../interfaces/view';\n\nimport {InjectedService, InjectorCreatedInstance, InjectorProfilerContext, InjectorProfilerEvent, InjectorProfilerEventType, ProviderRecord, setInjectorProfiler} from './injector_profiler';\n\n/**\n * These are the data structures that our framework injector profiler will fill with data in order\n * to support DI debugging APIs.\n *\n * resolverToTokenToDependencies: Maps an injector to a Map of tokens to an Array of\n * dependencies. Injector -> Token -> Dependencies This is used to support the\n * getDependenciesFromInjectable API, which takes in an injector and a token and returns it's\n * dependencies.\n *\n * resolverToProviders: Maps a DI resolver (an Injector or an LView) to the providers configured\n * within it This is used to support the getInjectorProviders API, which takes in an injector and\n * returns the providers that it was configured with.\n *\n * standaloneInjectorToComponent: Maps the injector of a standalone component to the standalone\n * component that it is associated with. Used in the getInjectorProviders API, specificially in the\n * discovery of import paths for each provider. This is necessary because the imports array of a\n * standalone component is processed and configured in its standalone injector, but exists within\n * the component's definition. Because getInjectorProviders takes in an injector, if that injector\n * is the injector of a standalone component, we need to be able to discover the place where the\n * imports array is located (the component) in order to flatten the imports array within it to\n * discover all of it's providers.\n *\n *\n * All of these data structures are instantiated with WeakMaps. This will ensure that the presence\n * of any object in the keys of these maps does not prevent the garbage collector from collecting\n * those objects. Because of this property of WeakMaps, these data structures will never be the\n * source of a memory leak.\n *\n * An example of this advantage: When components are destroyed, we don't need to do\n * any additional work to remove that component from our mappings.\n *\n */\nclass DIDebugData {\n  resolverToTokenToDependencies =\n      new WeakMap<Injector|LView, WeakMap<Type<unknown>, InjectedService[]>>();\n  resolverToProviders = new WeakMap<Injector|LView, ProviderRecord[]>();\n  standaloneInjectorToComponent = new WeakMap<Injector, Type<unknown>>();\n\n  reset() {\n    this.resolverToTokenToDependencies =\n        new WeakMap<Injector|LView, WeakMap<Type<unknown>, InjectedService[]>>();\n    this.resolverToProviders = new WeakMap<Injector|LView, ProviderRecord[]>();\n    this.standaloneInjectorToComponent = new WeakMap<Injector, Type<unknown>>();\n  }\n}\n\nlet frameworkDIDebugData = new DIDebugData();\n\nexport function getFrameworkDIDebugData(): DIDebugData {\n  return frameworkDIDebugData;\n}\n\n/**\n * Initalize default handling of injector events. This handling parses events\n * as they are emitted and constructs the data structures necessary to support\n * some of debug APIs.\n *\n * See handleInjectEvent, handleCreateEvent and handleProviderConfiguredEvent\n * for descriptions of each handler\n *\n * Supported APIs:\n *               - getDependenciesFromInjectable\n *               - getInjectorProviders\n */\nexport function setupFrameworkInjectorProfiler(): void {\n  frameworkDIDebugData.reset();\n  setInjectorProfiler(\n      (injectorProfilerEvent) => handleInjectorProfilerEvent(injectorProfilerEvent));\n}\n\nfunction handleInjectorProfilerEvent(injectorProfilerEvent: InjectorProfilerEvent): void {\n  const {context, type} = injectorProfilerEvent;\n\n  if (type === InjectorProfilerEventType.Inject) {\n    handleInjectEvent(context, injectorProfilerEvent.service);\n  } else if (type === InjectorProfilerEventType.InstanceCreatedByInjector) {\n    handleInstanceCreatedByInjectorEvent(context, injectorProfilerEvent.instance);\n  } else if (type === InjectorProfilerEventType.ProviderConfigured) {\n    handleProviderConfiguredEvent(context, injectorProfilerEvent.providerRecord);\n  }\n}\n\n/**\n *\n * Stores the injected service in frameworkDIDebugData.resolverToTokenToDependencies\n * based on it's injector and token.\n *\n * @param context InjectorProfilerContext the injection context that this event occurred in.\n * @param data InjectedService the service associated with this inject event.\n *\n */\nfunction handleInjectEvent(context: InjectorProfilerContext, data: InjectedService) {\n  const diResolver = getDIResolver(context.injector);\n  if (diResolver === null) {\n    throwError('An Inject event must be run within an injection context.');\n  }\n\n  const diResolverToInstantiatedToken = frameworkDIDebugData.resolverToTokenToDependencies;\n\n  if (!diResolverToInstantiatedToken.has(diResolver)) {\n    diResolverToInstantiatedToken.set(diResolver, new WeakMap<Type<unknown>, InjectedService[]>());\n  }\n\n  // if token is a primitive type, ignore this event. We do this because we cannot keep track of\n  // non-primitive tokens in WeakMaps since they are not garbage collectable.\n  if (!canBeHeldWeakly(context.token)) {\n    return;\n  }\n\n  const instantiatedTokenToDependencies = diResolverToInstantiatedToken.get(diResolver)!;\n  if (!instantiatedTokenToDependencies.has(context.token!)) {\n    instantiatedTokenToDependencies.set(context.token!, []);\n  }\n\n  const {token, value, flags} = data;\n  instantiatedTokenToDependencies.get(context.token!)!.push({token, value, flags});\n}\n\n/**\n *\n * If the created instance is an instance of a standalone component, maps the injector to that\n * standalone component in frameworkDIDebugData.standaloneInjectorToComponent\n *\n * @param context InjectorProfilerContext the injection context that this event occurred in.\n * @param data InjectorCreatedInstance an object containing the instance that was just created\n *\n */\nfunction handleInstanceCreatedByInjectorEvent(\n    context: InjectorProfilerContext, data: InjectorCreatedInstance): void {\n  const {value} = data;\n\n  if (getDIResolver(context.injector) === null) {\n    throwError('An InjectorCreatedInstance event must be run within an injection context.');\n  }\n\n  // if our value is an instance of a standalone component, map the injector of that standalone\n  // component to the component class. Otherwise, this event is a noop.\n  let standaloneComponent: Type<unknown>|undefined = undefined;\n  if (typeof value === 'object') {\n    standaloneComponent = value?.constructor as Type<unknown>;\n  }\n  if (standaloneComponent === undefined || !isStandaloneComponent(standaloneComponent)) {\n    return;\n  }\n\n  const environmentInjector: EnvironmentInjector|null =\n      context.injector.get(EnvironmentInjector, null, {optional: true});\n  // Standalone components should have an environment injector. If one cannot be\n  // found we may be in a test case for low level functionality that did not explictly\n  // setup this injector. In those cases, we simply ignore this event.\n  if (environmentInjector === null) {\n    return;\n  }\n\n  const {standaloneInjectorToComponent} = frameworkDIDebugData;\n\n  // If our injector has already been mapped, as is the case\n  // when a standalone component imports another standalone component,\n  // we consider the original component (the component doing the importing)\n  // as the component connected to our injector.\n  if (standaloneInjectorToComponent.has(environmentInjector)) {\n    return;\n  }\n  // If our injector hasn't been mapped, then we map it to the standalone component\n  standaloneInjectorToComponent.set(environmentInjector, standaloneComponent);\n}\n\nfunction isStandaloneComponent(value: Type<unknown>): boolean {\n  const def = getComponentDef(value);\n  return !!def?.standalone;\n}\n\n/**\n *\n * Stores the emitted ProviderRecords from the InjectorProfilerEventType.ProviderConfigured\n * event in frameworkDIDebugData.resolverToProviders\n *\n * @param context InjectorProfilerContext the injection context that this event occurred in.\n * @param data ProviderRecord an object containing the instance that was just created\n *\n */\nfunction handleProviderConfiguredEvent(\n    context: InjectorProfilerContext, data: ProviderRecord): void {\n  const {resolverToProviders} = frameworkDIDebugData;\n\n  const diResolver = getDIResolver(context?.injector);\n  if (diResolver === null) {\n    throwError('A ProviderConfigured event must be run within an injection context.');\n  }\n\n  if (!resolverToProviders.has(diResolver)) {\n    resolverToProviders.set(diResolver, []);\n  }\n\n  resolverToProviders.get(diResolver)!.push(data);\n}\n\nfunction getDIResolver(injector: Injector|undefined): Injector|LView|null {\n  let diResolver: Injector|LView|null = null;\n\n  if (injector === undefined) {\n    return diResolver;\n  }\n\n  // We use the LView as the diResolver for NodeInjectors because they\n  // do not persist anywhere in the framework. They are simply wrappers around an LView and a TNode\n  // that do persist. Because of this, we rely on the LView of the NodeInjector in order to use\n  // as a concrete key to represent this injector. If we get the same LView back later, we know\n  // we're looking at the same injector.\n  if (injector instanceof NodeInjector) {\n    diResolver = getNodeInjectorLView(injector);\n  }\n  // Other injectors can be used a keys for a map because their instances\n  // persist\n  else {\n    diResolver = injector;\n  }\n\n  return diResolver;\n}\n\n// inspired by\n// https://tc39.es/ecma262/multipage/executable-code-and-execution-contexts.html#sec-canbeheldweakly\nfunction canBeHeldWeakly(value: any): boolean {\n  // we check for value !== null here because typeof null === 'object\n  return value !== null &&\n      (typeof value === 'object' || typeof value === 'function' || typeof value === 'symbol');\n}\n"]}

package/esm2022/src/render3/debug/injector_profiler.mjs

@@ -0,0 +1,103 @@
+/**
+ * @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.io/license
+ */
+import { resolveForwardRef } from '../../di/forward_ref';
+import { throwError } from '../../util/assert';
+let _injectorProfilerContext;
+export function getInjectorProfilerContext() {
+    !ngDevMode && throwError('getInjectorProfilerContext should never be called in production mode');
+    return _injectorProfilerContext;
+}
+export function setInjectorProfilerContext(context) {
+    !ngDevMode && throwError('setInjectorProfilerContext should never be called in production mode');
+    const previous = _injectorProfilerContext;
+    _injectorProfilerContext = context;
+    return previous;
+}
+let injectorProfilerCallback = null;
+/**
+ * Sets the callback function which will be invoked during certain DI events within the
+ * runtime (for example: injecting services, creating injectable instances, configuring providers)
+ *
+ * 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.
+ */
+export const setInjectorProfiler = (injectorProfiler) => {
+    !ngDevMode && throwError('setInjectorProfiler should never be called in production mode');
+    injectorProfilerCallback = injectorProfiler;
+};
+/**
+ * Injector profiler function which emits on DI events executed by the runtime.
+ *
+ * @param event InjectorProfilerEvent corresponding to the DI event being emitted
+ */
+function injectorProfiler(event) {
+    !ngDevMode && throwError('Injector profiler should never be called in production mode');
+    if (injectorProfilerCallback != null /* both `null` and `undefined` */) {
+        injectorProfilerCallback(event);
+    }
+}
+/**
+ * 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 provider A provider object
+ */
+export function emitProviderConfiguredEvent(provider, isViewProvider = false) {
+    !ngDevMode && throwError('Injector profiler should never be called in production mode');
+    injectorProfiler({
+        type: 2 /* InjectorProfilerEventType.ProviderConfigured */,
+        context: getInjectorProfilerContext(),
+        providerRecord: {
+            token: typeof provider === 'function' ? provider : resolveForwardRef(provider.provide),
+            provider,
+            isViewProvider
+        }
+    });
+}
+/**
+ * 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 function emitInstanceCreatedByInjectorEvent(instance) {
+    !ngDevMode && throwError('Injector profiler should never be called in production mode');
+    injectorProfiler({
+        type: 1 /* InjectorProfilerEventType.InstanceCreatedByInjector */,
+        context: getInjectorProfilerContext(),
+        instance: { value: instance }
+    });
+}
+/**
+ * @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 function emitInjectEvent(token, value, flags) {
+    !ngDevMode && throwError('Injector profiler should never be called in production mode');
+    injectorProfiler({
+        type: 0 /* InjectorProfilerEventType.Inject */,
+        context: getInjectorProfilerContext(),
+        service: { token, value, flags }
+    });
+}
+export function runInInjectorProfilerContext(injector, token, callback) {
+    !ngDevMode &&
+        throwError('runInInjectorProfilerContext should never be called in production mode');
+    const prevInjectContext = setInjectorProfilerContext({ injector, token });
+    try {
+        callback();
+    }
+    finally {
+        setInjectorProfilerContext(prevInjectContext);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"injector_profiler.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/debug/injector_profiler.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAC,iBAAiB,EAAC,MAAM,sBAAsB,CAAC;AAMvD,OAAO,EAAC,UAAU,EAAC,MAAM,mBAAmB,CAAC;AAoI7C,IAAI,wBAAiD,CAAC;AACtD,MAAM,UAAU,0BAA0B;IACxC,CAAC,SAAS,IAAI,UAAU,CAAC,sEAAsE,CAAC,CAAC;IACjG,OAAO,wBAAwB,CAAC;AAClC,CAAC;AAED,MAAM,UAAU,0BAA0B,CAAC,OAAgC;IACzE,CAAC,SAAS,IAAI,UAAU,CAAC,sEAAsE,CAAC,CAAC;IAEjG,MAAM,QAAQ,GAAG,wBAAwB,CAAC;IAC1C,wBAAwB,GAAG,OAAO,CAAC;IACnC,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED,IAAI,wBAAwB,GAA0B,IAAI,CAAC;AAE3D;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,gBAAuC,EAAE,EAAE;IAC7E,CAAC,SAAS,IAAI,UAAU,CAAC,+DAA+D,CAAC,CAAC;IAC1F,wBAAwB,GAAG,gBAAgB,CAAC;AAC9C,CAAC,CAAC;AAEF;;;;GAIG;AACH,SAAS,gBAAgB,CAAC,KAA4B;IACpD,CAAC,SAAS,IAAI,UAAU,CAAC,6DAA6D,CAAC,CAAC;IAExF,IAAI,wBAAwB,IAAI,IAAI,CAAC,iCAAiC,EAAE;QACtE,wBAAyB,CAAC,KAAK,CAAC,CAAC;KAClC;AACH,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,2BAA2B,CACvC,QAAwB,EAAE,iBAA0B,KAAK;IAC3D,CAAC,SAAS,IAAI,UAAU,CAAC,6DAA6D,CAAC,CAAC;IAExF,gBAAgB,CAAC;QACf,IAAI,sDAA8C;QAClD,OAAO,EAAE,0BAA0B,EAAE;QACrC,cAAc,EAAE;YACd,KAAK,EAAE,OAAO,QAAQ,KAAK,UAAU,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,iBAAiB,CAAC,QAAQ,CAAC,OAAO,CAAC;YACtF,QAAQ;YACR,cAAc;SACf;KACF,CAAC,CAAC;AACL,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,kCAAkC,CAAC,QAAiB;IAClE,CAAC,SAAS,IAAI,UAAU,CAAC,6DAA6D,CAAC,CAAC;IAExF,gBAAgB,CAAC;QACf,IAAI,6DAAqD;QACzD,OAAO,EAAE,0BAA0B,EAAE;QACrC,QAAQ,EAAE,EAAC,KAAK,EAAE,QAAQ,EAAC;KAC5B,CAAC,CAAC;AACL,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,eAAe,CAAC,KAAoB,EAAE,KAAc,EAAE,KAAkB;IACtF,CAAC,SAAS,IAAI,UAAU,CAAC,6DAA6D,CAAC,CAAC;IAExF,gBAAgB,CAAC;QACf,IAAI,0CAAkC;QACtC,OAAO,EAAE,0BAA0B,EAAE;QACrC,OAAO,EAAE,EAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAC;KAC/B,CAAC,CAAC;AACL,CAAC;AAED,MAAM,UAAU,4BAA4B,CACxC,QAAkB,EAAE,KAAoB,EAAE,QAAoB;IAChE,CAAC,SAAS;QACN,UAAU,CAAC,wEAAwE,CAAC,CAAC;IAEzF,MAAM,iBAAiB,GAAG,0BAA0B,CAAC,EAAC,QAAQ,EAAE,KAAK,EAAC,CAAC,CAAC;IACxE,IAAI;QACF,QAAQ,EAAE,CAAC;KACZ;YAAS;QACR,0BAA0B,CAAC,iBAAiB,CAAC,CAAC;KAC/C;AACH,CAAC","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {resolveForwardRef} from '../../di/forward_ref';\nimport {InjectionToken} from '../../di/injection_token';\nimport type {Injector} from '../../di/injector';\nimport {InjectFlags, InjectOptions, InternalInjectFlags} from '../../di/interface/injector';\nimport type {SingleProvider} from '../../di/provider_collection';\nimport {Type} from '../../interface/type';\nimport {throwError} from '../../util/assert';\n\n/**\n * An enum describing the types of events that can be emitted from the injector profiler\n */\nexport const enum InjectorProfilerEventType {\n  /**\n   * Emits when a service is injected.\n   */\n  Inject,\n\n  /**\n   * Emits when an Angular class instance is created by an injector.\n   */\n  InstanceCreatedByInjector,\n\n  /**\n   * Emits when an injector configures a provider.\n   */\n  ProviderConfigured\n}\n\n/**\n * An object that defines an injection context for the injector profiler.\n */\nexport interface InjectorProfilerContext {\n  /**\n   *  The Injector that service is being injected into.\n   *      - Example: if ModuleA --provides--> ServiceA --injects--> ServiceB\n   *                 then inject(ServiceB) in ServiceA has ModuleA as an injector context\n   */\n  injector: Injector;\n\n  /**\n   *  The class where the constructor that is calling `inject` is located\n   *      - Example: if ModuleA --provides--> ServiceA --injects--> ServiceB\n   *                 then inject(ServiceB) in ServiceA has ServiceA as a construction context\n   */\n  token: Type<unknown>|null;\n}\n\n\nexport interface InjectedServiceEvent {\n  type: InjectorProfilerEventType.Inject;\n  context: InjectorProfilerContext;\n  service: InjectedService;\n}\n\nexport interface InjectorCreatedInstanceEvent {\n  type: InjectorProfilerEventType.InstanceCreatedByInjector;\n  context: InjectorProfilerContext;\n  instance: InjectorCreatedInstance;\n}\n\nexport interface ProviderConfiguredEvent {\n  type: InjectorProfilerEventType.ProviderConfigured;\n  context: InjectorProfilerContext;\n  providerRecord: ProviderRecord;\n}\n\n/**\n * An object representing an event that is emitted through the injector profiler\n */\n\nexport type InjectorProfilerEvent =\n    InjectedServiceEvent|InjectorCreatedInstanceEvent|ProviderConfiguredEvent;\n\n/**\n * An object that contains information about a provider that has been configured\n */\nexport interface ProviderRecord {\n  /**\n   * DI token that this provider is configuring\n   */\n  token: Type<unknown>;\n\n  /**\n   * Determines if provider is configured as view provider.\n   */\n  isViewProvider: boolean;\n\n  /**\n   * The raw provider associated with this ProviderRecord.\n   */\n  provider: SingleProvider;\n\n  /**\n   * The path of DI containers that were followed to import this provider\n   */\n  importPath?: Type<unknown>[];\n}\n\n/**\n * An object that contains information about a value that has been constructed within an injector\n */\nexport interface InjectorCreatedInstance {\n  /**\n   * Value of the created instance\n   */\n  value: unknown;\n}\n\n/**\n * An object that contains information a service that has been injected within an\n * InjectorProfilerContext\n */\nexport interface InjectedService {\n  /**\n   * DI token of the Service that is injected\n   */\n  token?: Type<unknown>|InjectionToken<unknown>;\n\n  /**\n   * Value of the injected service\n   */\n  value: unknown;\n\n  /**\n   * Flags that this service was injected with\n   */\n  flags?: InternalInjectFlags|InjectFlags|InjectOptions;\n\n  /**\n   * Injector that this service was provided in.\n   */\n  providedIn?: Injector;\n}\n\nexport interface InjectorProfiler {\n  (event: InjectorProfilerEvent): void;\n}\n\nlet _injectorProfilerContext: InjectorProfilerContext;\nexport function getInjectorProfilerContext() {\n  !ngDevMode && throwError('getInjectorProfilerContext should never be called in production mode');\n  return _injectorProfilerContext;\n}\n\nexport function setInjectorProfilerContext(context: InjectorProfilerContext) {\n  !ngDevMode && throwError('setInjectorProfilerContext should never be called in production mode');\n\n  const previous = _injectorProfilerContext;\n  _injectorProfilerContext = context;\n  return previous;\n}\n\nlet injectorProfilerCallback: InjectorProfiler|null = null;\n\n/**\n * Sets the callback function which will be invoked during certain DI events within the\n * runtime (for example: injecting services, creating injectable instances, configuring providers)\n *\n * Warning: this function is *INTERNAL* and should not be relied upon in application's code.\n * The contract of the function might be changed in any release and/or the function can be removed\n * completely.\n *\n * @param profiler function provided by the caller or null value to disable profiling.\n */\nexport const setInjectorProfiler = (injectorProfiler: InjectorProfiler|null) => {\n  !ngDevMode && throwError('setInjectorProfiler should never be called in production mode');\n  injectorProfilerCallback = injectorProfiler;\n};\n\n/**\n * Injector profiler function which emits on DI events executed by the runtime.\n *\n * @param event InjectorProfilerEvent corresponding to the DI event being emitted\n */\nfunction injectorProfiler(event: InjectorProfilerEvent): void {\n  !ngDevMode && throwError('Injector profiler should never be called in production mode');\n\n  if (injectorProfilerCallback != null /* both `null` and `undefined` */) {\n    injectorProfilerCallback!(event);\n  }\n}\n\n/**\n * Emits an InjectorProfilerEventType.ProviderConfigured to the injector profiler. The data in the\n * emitted event includes the raw provider, as well as the token that provider is providing.\n *\n * @param provider A provider object\n */\nexport function emitProviderConfiguredEvent(\n    provider: SingleProvider, isViewProvider: boolean = false): void {\n  !ngDevMode && throwError('Injector profiler should never be called in production mode');\n\n  injectorProfiler({\n    type: InjectorProfilerEventType.ProviderConfigured,\n    context: getInjectorProfilerContext(),\n    providerRecord: {\n      token: typeof provider === 'function' ? provider : resolveForwardRef(provider.provide),\n      provider,\n      isViewProvider\n    }\n  });\n}\n\n/**\n * Emits an event to the injector profiler with the instance that was created. Note that\n * the injector associated with this emission can be accessed by using getDebugInjectContext()\n *\n * @param instance an object created by an injector\n */\nexport function emitInstanceCreatedByInjectorEvent(instance: unknown): void {\n  !ngDevMode && throwError('Injector profiler should never be called in production mode');\n\n  injectorProfiler({\n    type: InjectorProfilerEventType.InstanceCreatedByInjector,\n    context: getInjectorProfilerContext(),\n    instance: {value: instance}\n  });\n}\n\n/**\n * @param token DI token associated with injected service\n * @param value the instance of the injected service (i.e the result of `inject(token)`)\n * @param flags the flags that the token was injected with\n */\nexport function emitInjectEvent(token: Type<unknown>, value: unknown, flags: InjectFlags): void {\n  !ngDevMode && throwError('Injector profiler should never be called in production mode');\n\n  injectorProfiler({\n    type: InjectorProfilerEventType.Inject,\n    context: getInjectorProfilerContext(),\n    service: {token, value, flags}\n  });\n}\n\nexport function runInInjectorProfilerContext(\n    injector: Injector, token: Type<unknown>, callback: () => void): void {\n  !ngDevMode &&\n      throwError('runInInjectorProfilerContext should never be called in production mode');\n\n  const prevInjectContext = setInjectorProfilerContext({injector, token});\n  try {\n    callback();\n  } finally {\n    setInjectorProfilerContext(prevInjectContext);\n  }\n}\n"]}