@angular/core 13.3.1 → 13.3.4

package/fesm2015/core.mjs

@@ -1,5 +1,5 @@
 /**
- * @license Angular v13.3.1
+ * @license Angular v13.3.4
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -6718,8 +6718,10 @@ function maybeUnwrapFn(value) {
  * found in the LICENSE file at https://angular.io/license
  */
 /** Called when there are multiple component selectors that match a given node */
-function throwMultipleComponentError(tNode) {
-    throw new RuntimeError(-300 /* MULTIPLE_COMPONENTS_MATCH */, `Multiple components match node with tagname ${tNode.value}`);
+function throwMultipleComponentError(tNode, first, second) {
+    throw new RuntimeError(-300 /* MULTIPLE_COMPONENTS_MATCH */, `Multiple components match node with tagname ${tNode.value}: ` +
+        `${stringifyForError(first)} and ` +
+        `${stringifyForError(second)}`);
 }
 /** Throws an ExpressionChangedAfterChecked error if checkNoChanges mode is on. */
 function throwErrorIfNoChangesMode(creationMode, oldValue, currValue, propName) {
@@ -10031,9 +10033,9 @@ function elementPropertyInternal(tView, tNode, lView, propName, value, renderer,
         propName = mapPropName(propName);
         if (ngDevMode) {
             validateAgainstEventProperties(propName);
-            if (!validateProperty(tView, element, propName, tNode)) {
+            if (!validateProperty(element, tNode.value, propName, tView.schemas)) {
                 // Return here since we only log warnings for unknown properties.
-                logUnknownPropertyError(propName, tNode);
+                logUnknownPropertyError(propName, tNode.value);
                 return;
             }
             ngDevMode.rendererSetProperty++;
@@ -10052,8 +10054,8 @@ function elementPropertyInternal(tView, tNode, lView, propName, value, renderer,
     else if (tNode.type & 12 /* AnyContainer */) {
         // If the node is a container and the property didn't
         // match any of the inputs or schemas we should throw.
-        if (ngDevMode && !matchingSchemas(tView, tNode.value)) {
-            logUnknownPropertyError(propName, tNode);
+        if (ngDevMode && !matchingSchemas(tView.schemas, tNode.value)) {
+            logUnknownPropertyError(propName, tNode.value);
         }
     }
 }
@@ -10105,24 +10107,44 @@ function setNgReflectProperties(lView, element, type, dataValue, value) {
         }
     }
 }
-function validateProperty(tView, element, propName, tNode) {
+/**
+ * Validates that the property of the element is known at runtime and returns
+ * false if it's not the case.
+ * This check is relevant for JIT-compiled components (for AOT-compiled
+ * ones this check happens at build time).
+ *
+ * The property is considered known if either:
+ * - it's a known property of the element
+ * - the element is allowed by one of the schemas
+ * - the property is used for animations
+ *
+ * @param element Element to validate
+ * @param tagName Name of the tag to check
+ * @param propName Name of the property to check
+ * @param schemas Array of schemas
+ */
+function validateProperty(element, tagName, propName, schemas) {
     // If `schemas` is set to `null`, that's an indication that this Component was compiled in AOT
     // mode where this check happens at compile time. In JIT mode, `schemas` is always present and
     // defined as an array (as an empty array in case `schemas` field is not defined) and we should
     // execute the check below.
-    if (tView.schemas === null)
+    if (schemas === null)
         return true;
-    // The property is considered valid if the element matches the schema, it exists on the element
+    // The property is considered valid if the element matches the schema, it exists on the element,
     // or it is synthetic, and we are in a browser context (web worker nodes should be skipped).
-    if (matchingSchemas(tView, tNode.value) || propName in element || isAnimationProp(propName)) {
+    if (matchingSchemas(schemas, tagName) || propName in element || isAnimationProp(propName)) {
         return true;
     }
     // Note: `typeof Node` returns 'function' in most browsers, but on IE it is 'object' so we
-    // need to account for both here, while being careful for `typeof null` also returning 'object'.
+    // need to account for both here, while being careful with `typeof null` also returning 'object'.
     return typeof Node === 'undefined' || Node === null || !(element instanceof Node);
 }
-function matchingSchemas(tView, tagName) {
-    const schemas = tView.schemas;
+/**
+ * Returns true if the tag name is allowed by specified schemas.
+ * @param schemas Array of schemas
+ * @param tagName Name of the tag
+ */
+function matchingSchemas(schemas, tagName) {
     if (schemas !== null) {
         for (let i = 0; i < schemas.length; i++) {
             const schema = schemas[i];
@@ -10137,10 +10159,10 @@ function matchingSchemas(tView, tagName) {
 /**
  * Logs an error that a property is not supported on an element.
  * @param propName Name of the invalid property.
- * @param tNode Node on which we encountered the property.
+ * @param tagName Name of the node on which we encountered the property.
  */
-function logUnknownPropertyError(propName, tNode) {
-    let message = `Can't bind to '${propName}' since it isn't a known property of '${tNode.value}'.`;
+function logUnknownPropertyError(propName, tagName) {
+    const message = `Can't bind to '${propName}' since it isn't a known property of '${tagName}'.`;
     console.error(formatRuntimeError(303 /* UNKNOWN_BINDING */, message));
 }
 /**
@@ -10358,8 +10380,11 @@ function findDirectiveDefMatches(tView, viewData, tNode) {
                     if (ngDevMode) {
                         assertTNodeType(tNode, 2 /* Element */, `"${tNode.value}" tags cannot be used as component hosts. ` +
                             `Please use a different tag to activate the ${stringify(def.type)} component.`);
-                        if (tNode.flags & 2 /* isComponentHost */)
-                            throwMultipleComponentError(tNode);
+                        if (tNode.flags & 2 /* isComponentHost */) {
+                            // If another component has been matched previously, it's the first element in the
+                            // `matches` array, see how we store components/directives in `matches` below.
+                            throwMultipleComponentError(tNode, matches[0].type, def.type);
+                        }
                     }
                     markAsComponentHost(tView, tNode);
                     // The component is always stored first with directives after.
@@ -12358,7 +12383,7 @@ function ɵɵInheritDefinitionFeature(definition) {
         else {
             if (superType.ɵcmp) {
                 const errorMessage = (typeof ngDevMode === 'undefined' || ngDevMode) ?
-                    'Directives cannot inherit Components' :
+                    `Directives cannot inherit Components. Directive ${stringifyForError(definition.type)} is attempting to extend component ${stringifyForError(superType)}` :
                     '';
                 throw new RuntimeError(903 /* INVALID_INHERITANCE */, errorMessage);
             }
@@ -14473,7 +14498,7 @@ function elementStartFirstCreatePass(index, tView, lView, native, name, attrsInd
     const attrs = getConstant(tViewConsts, attrsIndex);
     const tNode = getOrCreateTNode(tView, index, 2 /* Element */, name, attrs);
     const hasDirectives = resolveDirectives(tView, lView, tNode, getConstant(tViewConsts, localRefsIndex));
-    ngDevMode && logUnknownElementError(tView, native, tNode, hasDirectives);
+    ngDevMode && validateElementIsKnown(native, tNode.value, tView.schemas, hasDirectives);
     if (tNode.attrs !== null) {
         computeStaticStyling(tNode, tNode.attrs, false);
     }
@@ -14597,18 +14622,33 @@ function ɵɵelement(index, name, attrsIndex, localRefsIndex) {
     ɵɵelementEnd();
     return ɵɵelement;
 }
-function logUnknownElementError(tView, element, tNode, hasDirectives) {
-    const schemas = tView.schemas;
+/**
+ * Validates that the element is known at runtime and produces
+ * an error if it's not the case.
+ * This check is relevant for JIT-compiled components (for AOT-compiled
+ * ones this check happens at build time).
+ *
+ * The element is considered known if either:
+ * - it's a known HTML element
+ * - it's a known custom element
+ * - the element matches any directive
+ * - the element is allowed by one of the schemas
+ *
+ * @param element Element to validate
+ * @param tagName Name of the tag to check
+ * @param schemas Array of schemas
+ * @param hasDirectives Boolean indicating that the element matches any directive
+ */
+function validateElementIsKnown(element, tagName, schemas, hasDirectives) {
     // If `schemas` is set to `null`, that's an indication that this Component was compiled in AOT
     // mode where this check happens at compile time. In JIT mode, `schemas` is always present and
     // defined as an array (as an empty array in case `schemas` field is not defined) and we should
     // execute the check below.
     if (schemas === null)
         return;
-    const tagName = tNode.value;
     // If the element matches any directive, it's considered as valid.
     if (!hasDirectives && tagName !== null) {
-        // The element is unknown if it's an instance of HTMLUnknownElement or it isn't registered
+        // The element is unknown if it's an instance of HTMLUnknownElement, or it isn't registered
         // as a custom element. Note that unknown elements with a dash in their name won't be instances
         // of HTMLUnknownElement in browsers that support web components.
         const isUnknown = 
@@ -14618,7 +14658,7 @@ function logUnknownElementError(tView, element, tNode, hasDirectives) {
             element instanceof HTMLUnknownElement) ||
             (typeof customElements !== 'undefined' && tagName.indexOf('-') > -1 &&
                 !customElements.get(tagName));
-        if (isUnknown && !matchingSchemas(tView, tagName)) {
+        if (isUnknown && !matchingSchemas(schemas, tagName)) {
             let message = `'${tagName}' is not a known element:\n`;
             message += `1. If '${tagName}' is an Angular component, then verify that it is part of this module.\n`;
             if (tagName && tagName.indexOf('-') > -1) {
@@ -21088,7 +21128,7 @@ class Version {
 /**
  * @publicApi
  */
-const VERSION = new Version('13.3.1');
+const VERSION = new Version('13.3.4');
 
 /**
  * @license
@@ -24857,7 +24897,10 @@ const PLATFORM_INITIALIZER = new InjectionToken('Platform Initializer');
  * A token that indicates an opaque platform ID.
  * @publicApi
  */
-const PLATFORM_ID = new InjectionToken('Platform ID');
+const PLATFORM_ID = new InjectionToken('Platform ID', {
+    providedIn: 'platform',
+    factory: () => 'unknown', // set a default platform name, when none set explicitly
+});
 /**
  * A [DI token](guide/glossary#di-token "DI token definition") that provides a set of callbacks to
  * be called for every component that is bootstrapped.
@@ -24895,10 +24938,11 @@ class Console {
     }
 }
 Console.ɵfac = function Console_Factory(t) { return new (t || Console)(); };
-Console.ɵprov = /*@__PURE__*/ ɵɵdefineInjectable({ token: Console, factory: Console.ɵfac });
+Console.ɵprov = /*@__PURE__*/ ɵɵdefineInjectable({ token: Console, factory: Console.ɵfac, providedIn: 'platform' });
 (function () {
     (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(Console, [{
-            type: Injectable
+            type: Injectable,
+            args: [{ providedIn: 'platform' }]
         }], null, null);
 })();
 
@@ -25861,10 +25905,11 @@ class TestabilityRegistry {
     }
 }
 TestabilityRegistry.ɵfac = function TestabilityRegistry_Factory(t) { return new (t || TestabilityRegistry)(); };
-TestabilityRegistry.ɵprov = /*@__PURE__*/ ɵɵdefineInjectable({ token: TestabilityRegistry, factory: TestabilityRegistry.ɵfac });
+TestabilityRegistry.ɵprov = /*@__PURE__*/ ɵɵdefineInjectable({ token: TestabilityRegistry, factory: TestabilityRegistry.ɵfac, providedIn: 'platform' });
 (function () {
     (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(TestabilityRegistry, [{
-            type: Injectable
+            type: Injectable,
+            args: [{ providedIn: 'platform' }]
         }], function () { return []; }, null);
 })();
 class _NoopGetTestability {
@@ -25889,7 +25934,19 @@ let _testabilityGetter = new _NoopGetTestability();
  * 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
  */
-let _platform;
+let _platformInjector = null;
+/**
+ * Internal token to indicate whether having multiple bootstrapped platform should be allowed (only
+ * one bootstrapped platform is allowed by default). This token helps to support SSR scenarios.
+ */
+const ALLOW_MULTIPLE_PLATFORMS = new InjectionToken('AllowMultipleToken');
+/**
+ * Internal token that allows to register extra callbacks that should be invoked during the
+ * `PlatformRef.destroy` operation. This token is needed to avoid a direct reference to the
+ * `PlatformRef` class (i.e. register the callback via `PlatformRef.onDestroy`), thus making the
+ * entire class tree-shakeable.
+ */
+const PLATFORM_ON_DESTROY = new InjectionToken('PlatformOnDestroy');
 function compileNgModuleFactory(injector, options, moduleType) {
     ngDevMode && assertNgModuleType(moduleType);
     const moduleFactory = new NgModuleFactory(moduleType);
@@ -25934,7 +25991,6 @@ function publishDefaultGlobalUtils() {
 function isBoundToModule(cf) {
     return cf.isBoundToModule;
 }
-const ALLOW_MULTIPLE_PLATFORMS = new InjectionToken('AllowMultipleToken');
 /**
  * A token for third-party components that can register themselves with NgProbe.
  *
@@ -25953,19 +26009,19 @@ class NgProbeToken {
  * @publicApi
  */
 function createPlatform(injector) {
-    if (_platform && !_platform.destroyed &&
-        !_platform.injector.get(ALLOW_MULTIPLE_PLATFORMS, false)) {
+    if (_platformInjector && !_platformInjector.get(ALLOW_MULTIPLE_PLATFORMS, false)) {
         const errorMessage = (typeof ngDevMode === 'undefined' || ngDevMode) ?
             'There can be only one platform. Destroy the previous one to create a new one.' :
             '';
         throw new RuntimeError(400 /* MULTIPLE_PLATFORMS */, errorMessage);
     }
     publishDefaultGlobalUtils();
-    _platform = injector.get(PlatformRef);
+    _platformInjector = injector;
+    const platform = injector.get(PlatformRef);
     const inits = injector.get(PLATFORM_INITIALIZER, null);
     if (inits)
-        inits.forEach((init) => init());
-    return _platform;
+        inits.forEach(initFn => initFn());
+    return platform;
 }
 /**
  * Creates a factory for a platform. Can be used to provide or override `Providers` specific to
@@ -25984,15 +26040,16 @@ function createPlatformFactory(parentPlatformFactory, name, providers = []) {
     return (extraProviders = []) => {
         let platform = getPlatform();
         if (!platform || platform.injector.get(ALLOW_MULTIPLE_PLATFORMS, false)) {
+            const platformProviders = [
+                ...providers,
+                ...extraProviders,
+                { provide: marker, useValue: true }
+            ];
             if (parentPlatformFactory) {
-                parentPlatformFactory(providers.concat(extraProviders).concat({ provide: marker, useValue: true }));
+                parentPlatformFactory(platformProviders);
             }
             else {
-                const injectedProviders = providers.concat(extraProviders).concat({ provide: marker, useValue: true }, {
-                    provide: INJECTOR_SCOPE,
-                    useValue: 'platform'
-                });
-                createPlatform(Injector.create({ providers: injectedProviders, name: desc }));
+                createPlatform(createPlatformInjector(platformProviders, desc));
             }
         }
         return assertPlatform(marker);
@@ -26015,6 +26072,20 @@ function assertPlatform(requiredToken) {
     }
     return platform;
 }
+/**
+ * Helper function to create an instance of a platform injector (that maintains the 'platform'
+ * scope).
+ */
+function createPlatformInjector(providers = [], name) {
+    return Injector.create({
+        name,
+        providers: [
+            { provide: INJECTOR_SCOPE, useValue: 'platform' },
+            { provide: PLATFORM_ON_DESTROY, useValue: () => _platformInjector = null },
+            ...providers
+        ],
+    });
+}
 /**
  * Destroys the current Angular platform and all Angular applications on the page.
  * Destroys all modules and listeners registered with the platform.
@@ -26022,9 +26093,8 @@ function assertPlatform(requiredToken) {
  * @publicApi
  */
 function destroyPlatform() {
-    if (_platform && !_platform.destroyed) {
-        _platform.destroy();
-    }
+    var _a;
+    (_a = getPlatform()) === null || _a === void 0 ? void 0 : _a.destroy();
 }
 /**
  * Returns the current platform.
@@ -26032,7 +26102,8 @@ function destroyPlatform() {
  * @publicApi
  */
 function getPlatform() {
-    return _platform && !_platform.destroyed ? _platform : null;
+    var _a;
+    return (_a = _platformInjector === null || _platformInjector === void 0 ? void 0 : _platformInjector.get(PlatformRef)) !== null && _a !== void 0 ? _a : null;
 }
 /**
  * The Angular platform is the entry point for Angular on a web page.
@@ -26170,6 +26241,8 @@ class PlatformRef {
         }
         this._modules.slice().forEach(module => module.destroy());
         this._destroyListeners.forEach(listener => listener());
+        const destroyListener = this._injector.get(PLATFORM_ON_DESTROY, null);
+        destroyListener === null || destroyListener === void 0 ? void 0 : destroyListener();
         this._destroyed = true;
     }
     get destroyed() {
@@ -26177,10 +26250,11 @@ class PlatformRef {
     }
 }
 PlatformRef.ɵfac = function PlatformRef_Factory(t) { return new (t || PlatformRef)(ɵɵinject(Injector)); };
-PlatformRef.ɵprov = /*@__PURE__*/ ɵɵdefineInjectable({ token: PlatformRef, factory: PlatformRef.ɵfac });
+PlatformRef.ɵprov = /*@__PURE__*/ ɵɵdefineInjectable({ token: PlatformRef, factory: PlatformRef.ɵfac, providedIn: 'platform' });
 (function () {
     (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(PlatformRef, [{
-            type: Injectable
+            type: Injectable,
+            args: [{ providedIn: 'platform' }]
         }], function () { return [{ type: Injector }]; }, null);
 })();
 function getNgZone(ngZoneOption, extra) {
@@ -26319,11 +26393,10 @@ function optionsReducer(dst, objs) {
  */
 class ApplicationRef {
     /** @internal */
-    constructor(_zone, _injector, _exceptionHandler, _componentFactoryResolver, _initStatus) {
+    constructor(_zone, _injector, _exceptionHandler, _initStatus) {
         this._zone = _zone;
         this._injector = _injector;
         this._exceptionHandler = _exceptionHandler;
-        this._componentFactoryResolver = _componentFactoryResolver;
         this._initStatus = _initStatus;
         /** @internal */
         this._bootstrapListeners = [];
@@ -26439,8 +26512,8 @@ class ApplicationRef {
             componentFactory = componentOrFactory;
         }
         else {
-            componentFactory =
-                this._componentFactoryResolver.resolveComponentFactory(componentOrFactory);
+            const resolver = this._injector.get(ComponentFactoryResolver$1);
+            componentFactory = resolver.resolveComponentFactory(componentOrFactory);
         }
         this.componentTypes.push(componentFactory.componentType);
         // Create a factory associated with the current module if it's not bound to some other
@@ -26541,13 +26614,13 @@ class ApplicationRef {
         return this._views.length;
     }
 }
-ApplicationRef.ɵfac = function ApplicationRef_Factory(t) { return new (t || ApplicationRef)(ɵɵinject(NgZone), ɵɵinject(Injector), ɵɵinject(ErrorHandler), ɵɵinject(ComponentFactoryResolver$1), ɵɵinject(ApplicationInitStatus)); };
+ApplicationRef.ɵfac = function ApplicationRef_Factory(t) { return new (t || ApplicationRef)(ɵɵinject(NgZone), ɵɵinject(Injector), ɵɵinject(ErrorHandler), ɵɵinject(ApplicationInitStatus)); };
 ApplicationRef.ɵprov = /*@__PURE__*/ ɵɵdefineInjectable({ token: ApplicationRef, factory: ApplicationRef.ɵfac, providedIn: 'root' });
 (function () {
     (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(ApplicationRef, [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
-        }], function () { return [{ type: NgZone }, { type: Injector }, { type: ErrorHandler }, { type: ComponentFactoryResolver$1 }, { type: ApplicationInitStatus }]; }, null);
+        }], function () { return [{ type: NgZone }, { type: Injector }, { type: ErrorHandler }, { type: ApplicationInitStatus }]; }, null);
 })();
 function remove(list, el) {
     const index = list.indexOf(el);
@@ -28530,19 +28603,12 @@ const defaultKeyValueDiffers = new KeyValueDiffers(keyValDiff);
  * 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
  */
-const _CORE_PLATFORM_PROVIDERS = [
-    // Set a default platform name for platforms that don't set it explicitly.
-    { provide: PLATFORM_ID, useValue: 'unknown' },
-    { provide: PlatformRef, deps: [Injector] },
-    { provide: TestabilityRegistry, deps: [] },
-    { provide: Console, deps: [] },
-];
 /**
  * This platform has to be included in any other platform
  *
  * @publicApi
  */
-const platformCore = createPlatformFactory(null, 'core', _CORE_PLATFORM_PROVIDERS);
+const platformCore = createPlatformFactory(null, 'core', []);
 
 /**
  * Re-exported by `BrowserModule`, which is included automatically in the root