@angular/core 16.2.0-next.1 → 16.2.0-next.2

package/fesm2022/core.mjs

@@ -1,5 +1,5 @@
 /**
- * @license Angular v16.2.0-next.1
+ * @license Angular v16.2.0-next.2
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -358,7 +358,8 @@ function assertOneOf(value, ...validValues) {
  *   with an `@NgModule` or other `InjectorType`, or by specifying that this injectable should be
  *   provided in the `'root'` injector, which will be the application-level injector in most apps.
  * * `factory` gives the zero argument function which will create an instance of the injectable.
- *   The factory can call `inject` to access the `Injector` and request injection of dependencies.
+ *   The factory can call [`inject`](api/core/inject) to access the `Injector` and request injection
+ * of dependencies.
  *
  * @codeGenApi
  * @publicApi This instruction has been emitted by ViewEngine for some time and is deployed to npm.
@@ -456,7 +457,7 @@ const NG_INJECTOR_DEF = getClosureSafeProperty({ ngInjectorDef: getClosureSafePr
  * Injection flags for DI.
  *
  * @publicApi
- * @deprecated use an options object for `inject` instead.
+ * @deprecated use an options object for [`inject`](api/core/inject) instead.
  */
 var InjectFlags;
 (function (InjectFlags) {
@@ -672,13 +673,14 @@ Please check that 1) the type for the parameter at index ${index} is correct and
 }
 /**
  * Injects a token from the currently active injector.
- * `inject` is only supported during instantiation of a dependency by the DI system. It can be used
- * during:
+ * `inject` is only supported in a [injection context](/guide/dependency-injection-context). It can
+ * be used during:
  * - Construction (via the `constructor`) of a class being instantiated by the DI system, such
  * as an `@Injectable` or `@Component`.
  * - In the initializer for fields of such classes.
  * - In the factory function specified for `useFactory` of a `Provider` or an `@Injectable`.
  * - In the `factory` function specified for an `InjectionToken`.
+ * - In a stackframe of a function call in a DI context
  *
  * @param token A token that represents a dependency that should be injected.
  * @param flags Optional flags that control how injection is executed.
@@ -2086,8 +2088,13 @@ function assertTNodeForLView(tNode, lView) {
 }
 function assertTNodeForTView(tNode, tView) {
     assertTNode(tNode);
-    tNode.hasOwnProperty('tView_') &&
-        assertEqual(tNode.tView_, tView, 'This TNode does not belong to this TView.');
+    const tData = tView.data;
+    for (let i = HEADER_OFFSET; i < tData.length; i++) {
+        if (tData[i] === tNode) {
+            return;
+        }
+    }
+    throwError('This TNode does not belong to this TView.');
 }
 function assertTNode(tNode) {
     assertDefined(tNode, 'TNode must be defined');
@@ -2348,7 +2355,9 @@ class ReactiveNode {
     consumerPollProducersForChange() {
         for (const [producerId, edge] of this.producers) {
             const producer = edge.producerNode.deref();
-            if (producer === undefined || edge.atTrackingVersion !== this.trackingVersion) {
+            // On Safari < 16.1 deref can return null, we need to check for null also.
+            // See https://github.com/WebKit/WebKit/commit/44c15ba58912faab38b534fef909dd9e13e095e0
+            if (producer == null || edge.atTrackingVersion !== this.trackingVersion) {
                 // This dependency edge is stale, so remove it.
                 this.producers.delete(producerId);
                 producer?.consumers.delete(this.id);
@@ -2373,7 +2382,9 @@ class ReactiveNode {
         try {
             for (const [consumerId, edge] of this.consumers) {
                 const consumer = edge.consumerNode.deref();
-                if (consumer === undefined || consumer.trackingVersion !== edge.atTrackingVersion) {
+                // On Safari < 16.1 deref can return null, we need to check for null also.
+                // See https://github.com/WebKit/WebKit/commit/44c15ba58912faab38b534fef909dd9e13e095e0
+                if (consumer == null || consumer.trackingVersion !== edge.atTrackingVersion) {
                     this.consumers.delete(consumerId);
                     consumer?.producers.delete(this.id);
                     continue;
@@ -8669,7 +8680,7 @@ function getSanitizer() {
  * (possibly by creating) a default value of the parameterized type `T`. This sets up the
  * `InjectionToken` using this factory as a provider as if it was defined explicitly in the
  * application's root injector. If the factory function, which takes zero arguments, needs to inject
- * dependencies, it can do so using the `inject` function.
+ * dependencies, it can do so using the [`inject`](api/core/inject) function.
  * As you can see in the Tree-shakable InjectionToken example below.
  *
  * Additionally, if a `factory` is specified you can also specify the `providedIn` option, which
@@ -8767,7 +8778,7 @@ class NullInjector {
 
 /**
  * Wrap an array of `Provider`s into `EnvironmentProviders`, preventing them from being accidentally
- * referenced in `@Component in a component injector.
+ * referenced in `@Component` in a component injector.
  */
 function makeEnvironmentProviders(providers) {
     return {
@@ -10089,7 +10100,7 @@ class Version {
 /**
  * @publicApi
  */
-const VERSION = new Version('16.2.0-next.1');
+const VERSION = new Version('16.2.0-next.2');
 
 // This default value is when checking the hierarchy for a token.
 //
@@ -10513,13 +10524,15 @@ function selectIndexInternal(tView, lView, index, checkNoChangesMode) {
 }
 
 /**
- * Runs the given function in the context of the given `Injector`.
+ * Runs the given function in the [context](guide/dependency-injection-context) of the given
+ * `Injector`.
  *
- * Within the function's stack frame, `inject` can be used to inject dependencies from the given
- * `Injector`. Note that `inject` is only usable synchronously, and cannot be used in any
- * asynchronous callbacks or after any `await` points.
+ * Within the function's stack frame, [`inject`](api/core/inject) can be used to inject dependencies
+ * from the given `Injector`. Note that `inject` is only usable synchronously, and cannot be used in
+ * any asynchronous callbacks or after any `await` points.
  *
- * @param injector the injector which will satisfy calls to `inject` while `fn` is executing
+ * @param injector the injector which will satisfy calls to [`inject`](api/core/inject) while `fn`
+ *     is executing
  * @param fn the closure to be run in the context of `injector`
  * @returns the return value of the function, if any
  * @publicApi
@@ -10539,7 +10552,8 @@ function runInInjectionContext(injector, fn) {
     }
 }
 /**
- * Asserts that the current stack frame is within an injection context and has access to `inject`.
+ * Asserts that the current stack frame is within an [injection
+ * context](guide/dependency-injection-context) and has access to `inject`.
  *
  * @param debugFn a reference to the function making the assertion (used for the error message).
  *
@@ -21740,14 +21754,14 @@ class StandaloneService {
         if (!componentDef.standalone) {
             return null;
         }
-        if (!this.cachedInjectors.has(componentDef.id)) {
+        if (!this.cachedInjectors.has(componentDef)) {
             const providers = internalImportProvidersFrom(false, componentDef.type);
             const standaloneInjector = providers.length > 0 ?
                 createEnvironmentInjector([providers], this._injector, `Standalone[${componentDef.type.name}]`) :
                 null;
-            this.cachedInjectors.set(componentDef.id, standaloneInjector);
+            this.cachedInjectors.set(componentDef, standaloneInjector);
         }
-        return this.cachedInjectors.get(componentDef.id);
+        return this.cachedInjectors.get(componentDef);
     }
     ngOnDestroy() {
         try {
@@ -22596,6 +22610,13 @@ function ɵɵpipe(index, pipeName) {
  */
 function getPipeDef(name, registry) {
     if (registry) {
+        if (ngDevMode) {
+            const pipes = registry.filter(pipe => pipe.name === name);
+            // TODO: Throw an error in the next major
+            if (pipes.length > 1) {
+                console.warn(formatRuntimeError(313 /* RuntimeErrorCode.MULTIPLE_MATCHING_PIPES */, getMultipleMatchingPipesMessage(name)));
+            }
+        }
         for (let i = registry.length - 1; i >= 0; i--) {
             const pipeDef = registry[i];
             if (name === pipeDef.name) {
@@ -22607,6 +22628,23 @@ function getPipeDef(name, registry) {
         throw new RuntimeError(-302 /* RuntimeErrorCode.PIPE_NOT_FOUND */, getPipeNotFoundErrorMessage(name));
     }
 }
+/**
+ * Generates a helpful error message for the user when multiple pipes match the name.
+ *
+ * @param name Name of the pipe
+ * @returns The error message
+ */
+function getMultipleMatchingPipesMessage(name) {
+    const lView = getLView();
+    const declarationLView = lView[DECLARATION_COMPONENT_VIEW];
+    const context = declarationLView[CONTEXT];
+    const hostIsStandalone = isHostComponentStandalone(lView);
+    const componentInfoMessage = context ? ` in the '${context.constructor.name}' component` : '';
+    const verifyMessage = `check ${hostIsStandalone ? '\'@Component.imports\' of this component' :
+        'the imports of this module'}`;
+    const errorMessage = `Multiple pipes match the name \`${name}\`${componentInfoMessage}. ${verifyMessage}`;
+    return errorMessage;
+}
 /**
  * Generates a helpful error message for the user when a pipe is not found.
  *
@@ -25913,11 +25951,26 @@ function noop(...args) {
 }
 
 function getNativeRequestAnimationFrame() {
-    let nativeRequestAnimationFrame = _global['requestAnimationFrame'];
-    let nativeCancelAnimationFrame = _global['cancelAnimationFrame'];
+    // Note: the `getNativeRequestAnimationFrame` is used in the `NgZone` class, but we cannot use the
+    // `inject` function. The `NgZone` instance may be created manually, and thus the injection
+    // context will be unavailable. This might be enough to check whether `requestAnimationFrame` is
+    // available because otherwise, we'll fall back to `setTimeout`.
+    const isBrowser = typeof _global['requestAnimationFrame'] === 'function';
+    // Note: `requestAnimationFrame` is unavailable when the code runs in the Node.js environment. We
+    // use `setTimeout` because no changes are required other than checking if the current platform is
+    // the browser. `setTimeout` is a well-established API that is available in both environments.
+    // `requestAnimationFrame` is used in the browser to coalesce event tasks since event tasks are
+    // usually executed within the same rendering frame (but this is more implementation details of
+    // browsers).
+    let nativeRequestAnimationFrame = _global[isBrowser ? 'requestAnimationFrame' : 'setTimeout'];
+    let nativeCancelAnimationFrame = _global[isBrowser ? 'cancelAnimationFrame' : 'clearTimeout'];
     if (typeof Zone !== 'undefined' && nativeRequestAnimationFrame && nativeCancelAnimationFrame) {
-        // use unpatched version of requestAnimationFrame(native delegate) if possible
-        // to avoid another Change detection
+        // Note: zone.js sets original implementations on patched APIs behind the
+        // `__zone_symbol__OriginalDelegate` key (see `attachOriginToPatched`). Given the following
+        // example: `window.requestAnimationFrame.__zone_symbol__OriginalDelegate`; this would return an
+        // unpatched implementation of the `requestAnimationFrame`, which isn't intercepted by the
+        // Angular zone. We use the unpatched implementation to avoid another change detection when
+        // coalescing tasks.
         const unpatchedRequestAnimationFrame = nativeRequestAnimationFrame[Zone.__symbol__('OriginalDelegate')];
         if (unpatchedRequestAnimationFrame) {
             nativeRequestAnimationFrame = unpatchedRequestAnimationFrame;
@@ -26083,15 +26136,24 @@ class NgZone {
         self.nativeRequestAnimationFrame = getNativeRequestAnimationFrame().nativeRequestAnimationFrame;
         forkInnerZoneWithAngularBehavior(self);
     }
+    /**
+      This method checks whether the method call happens within an Angular Zone instance.
+    */
     static isInAngularZone() {
         // Zone needs to be checked, because this method might be called even when NoopNgZone is used.
         return typeof Zone !== 'undefined' && Zone.current.get('isAngularZone') === true;
     }
+    /**
+      Assures that the method is called within the Angular Zone, otherwise throws an error.
+    */
     static assertInAngularZone() {
         if (!NgZone.isInAngularZone()) {
             throw new RuntimeError(909 /* RuntimeErrorCode.UNEXPECTED_ZONE_STATE */, ngDevMode && 'Expected to be in Angular Zone, but it is not!');
         }
     }
+    /**
+      Assures that the method is called outside of the Angular Zone, otherwise throws an error.
+    */
     static assertNotInAngularZone() {
         if (NgZone.isInAngularZone()) {
             throw new RuntimeError(909 /* RuntimeErrorCode.UNEXPECTED_ZONE_STATE */, ngDevMode && 'Expected to not be in Angular Zone, but it is!');