@angular/core 15.0.0-next.4 → 15.0.0-next.6

package/fesm2020/testing.mjs

@@ -1,10 +1,10 @@
 /**
- * @license Angular v15.0.0-next.4
+ * @license Angular v15.0.0-next.6
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */
 
-import { getDebugNode as getDebugNode$1, RendererFactory2 as RendererFactory2$1, InjectionToken as InjectionToken$1, ɵstringify, ɵReflectionCapabilities, Directive, Component, Pipe, NgModule, ɵgetInjectableDef, resolveForwardRef as resolveForwardRef$1, ɵNG_COMP_DEF, ɵRender3NgModuleRef, ApplicationInitStatus, LOCALE_ID as LOCALE_ID$1, ɵDEFAULT_LOCALE_ID, ɵsetLocaleId, ɵRender3ComponentFactory, ɵcompileComponent, ɵNG_DIR_DEF, ɵcompileDirective, ɵNG_PIPE_DEF, ɵcompilePipe, ɵNG_MOD_DEF, ɵtransitiveScopesFor, ɵpatchComponentDefWithScope, ɵNG_INJ_DEF, ɵcompileNgModuleDefs, NgZone, Compiler, COMPILER_OPTIONS, ɵNgModuleFactory, ModuleWithComponentFactories, ɵconvertToBitFlags, Injector as Injector$1, InjectFlags as InjectFlags$1, ɵsetAllowDuplicateNgModuleIdsForTest, ɵresetCompiledComponents, ɵsetUnknownElementStrictMode as ɵsetUnknownElementStrictMode$1, ɵsetUnknownPropertyStrictMode as ɵsetUnknownPropertyStrictMode$1, ɵgetUnknownElementStrictMode as ɵgetUnknownElementStrictMode$1, ɵgetUnknownPropertyStrictMode as ɵgetUnknownPropertyStrictMode$1, ɵflushModuleScopingQueueAsMuchAsPossible } from '@angular/core';
+import { getDebugNode as getDebugNode$1, RendererFactory2 as RendererFactory2$1, InjectionToken as InjectionToken$1, ɵstringify, ɵReflectionCapabilities, Directive, Component, Pipe, NgModule, ɵgetInjectableDef, resolveForwardRef as resolveForwardRef$1, ɵNG_COMP_DEF, ɵRender3NgModuleRef, ApplicationInitStatus, LOCALE_ID as LOCALE_ID$1, ɵDEFAULT_LOCALE_ID, ɵsetLocaleId, ɵRender3ComponentFactory, ɵcompileComponent, ɵNG_DIR_DEF, ɵcompileDirective, ɵNG_PIPE_DEF, ɵcompilePipe, ɵNG_MOD_DEF, ɵtransitiveScopesFor, ɵpatchComponentDefWithScope, ɵNG_INJ_DEF, ɵcompileNgModuleDefs, NgZone, Compiler, COMPILER_OPTIONS, ɵNgModuleFactory, ɵisEnvironmentProviders, ModuleWithComponentFactories, ɵconvertToBitFlags, Injector as Injector$1, InjectFlags as InjectFlags$1, ɵsetAllowDuplicateNgModuleIdsForTest, ɵresetCompiledComponents, ɵsetUnknownElementStrictMode as ɵsetUnknownElementStrictMode$1, ɵsetUnknownPropertyStrictMode as ɵsetUnknownPropertyStrictMode$1, ɵgetUnknownElementStrictMode as ɵgetUnknownElementStrictMode$1, ɵgetUnknownPropertyStrictMode as ɵgetUnknownPropertyStrictMode$1, ɵflushModuleScopingQueueAsMuchAsPossible } from '@angular/core';
 import { ResourceLoader } from '@angular/compiler';
 import { Subject, Subscription } from 'rxjs';
 
@@ -1886,6 +1886,17 @@ function initNgDevMode() {
     return false;
 }
 
+/**
+ * @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
+ */
+function isEnvironmentProviders(value) {
+    return value && !!value.ɵproviders;
+}
+
 /**
  * @license
  * Copyright Google LLC All Rights Reserved.
@@ -1942,8 +1953,13 @@ function throwInvalidProviderError(ngModuleType, providers, provider) {
         const providerDetail = providers.map(v => v == provider ? '?' + provider + '?' : '...');
         throw new Error(`Invalid provider for the NgModule '${stringify(ngModuleType)}' - only instances of Provider and Type are allowed, got: [${providerDetail.join(', ')}]`);
     }
-    else if (provider.ɵproviders) {
-        throw new RuntimeError(207 /* RuntimeErrorCode.PROVIDER_IN_WRONG_CONTEXT */, `Invalid providers from 'importProvidersFrom' present in a non-environment injector. 'importProvidersFrom' can't be used for component providers.`);
+    else if (isEnvironmentProviders(provider)) {
+        if (provider.ɵfromNgModule) {
+            throw new RuntimeError(207 /* RuntimeErrorCode.PROVIDER_IN_WRONG_CONTEXT */, `Invalid providers from 'importProvidersFrom' present in a non-environment injector. 'importProvidersFrom' can't be used for component providers.`);
+        }
+        else {
+            throw new RuntimeError(207 /* RuntimeErrorCode.PROVIDER_IN_WRONG_CONTEXT */, `Invalid providers present in a non-environment injector. 'EnvironmentProviders' can't be used for component providers.`);
+        }
     }
     else {
         throw new Error('Invalid provider');
@@ -3170,11 +3186,12 @@ function rememberChangeHistoryAndInvokeOnChangesHook() {
     }
 }
 function ngOnChangesSetInput(instance, value, publicName, privateName) {
+    const declaredName = this.declaredInputs[publicName];
+    ngDevMode && assertString(declaredName, 'Name of input in ngOnChanges has to be a string');
     const simpleChangesStore = getSimpleChangesStore(instance) ||
         setSimpleChangesStore(instance, { previous: EMPTY_OBJ, current: null });
     const current = simpleChangesStore.current || (simpleChangesStore.current = {});
     const previous = simpleChangesStore.previous;
-    const declaredName = this.declaredInputs[publicName];
     const previousChange = previous[declaredName];
     current[declaredName] = new SimpleChange(previousChange && previousChange.currentValue, value, previous === EMPTY_OBJ);
     instance[privateName] = value;
@@ -6639,8 +6656,11 @@ function getSanitizer() {
  * 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
- * overrides the above behavior and marks the token as belonging to a particular `@NgModule`. As
- * mentioned above, `'root'` is the default value for `providedIn`.
+ * overrides the above behavior and marks the token as belonging to a particular `@NgModule` (note:
+ * this option is now deprecated). As mentioned above, `'root'` is the default value for
+ * `providedIn`.
+ *
+ * The `providedIn: NgModule` and `providedIn: 'any'` options are deprecated.
  *
  * @usageNotes
  * ### Basic Examples
@@ -6771,6 +6791,15 @@ class NullInjector {
  * 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
  */
+/**
+ * Wrap an array of `Provider`s into `EnvironmentProviders`, preventing them from being accidentally
+ * referenced in `@Component in a component injector.
+ */
+function makeEnvironmentProviders(providers) {
+    return {
+        ɵproviders: providers,
+    };
+}
 /**
  * Collects providers from all NgModules and standalone components, including transitively imported
  * ones.
@@ -6813,7 +6842,10 @@ class NullInjector {
  * @developerPreview
  */
 function importProvidersFrom(...sources) {
-    return { ɵproviders: internalImportProvidersFrom(true, sources) };
+    return {
+        ɵproviders: internalImportProvidersFrom(true, sources),
+        ɵfromNgModule: true,
+    };
 }
 function internalImportProvidersFrom(checkForStandaloneCmp, ...sources) {
     const providersOut = [];
@@ -6846,7 +6878,7 @@ function internalImportProvidersFrom(checkForStandaloneCmp, ...sources) {
 function processInjectorTypesWithProviders(typesWithProviders, providersOut) {
     for (let i = 0; i < typesWithProviders.length; i++) {
         const { ngModule, providers } = typesWithProviders[i];
-        deepForEach(providers, provider => {
+        deepForEachProvider(providers, provider => {
             ngDevMode && validateProvider(provider, providers || EMPTY_ARRAY, ngModule);
             providersOut.push(provider);
         });
@@ -6963,7 +6995,7 @@ function walkProviderTree(container, providersOut, parents, dedup) {
         const defProviders = injDef.providers;
         if (defProviders != null && !isDuplicate) {
             const injectorType = container;
-            deepForEach(defProviders, provider => {
+            deepForEachProvider(defProviders, provider => {
                 ngDevMode && validateProvider(provider, defProviders, injectorType);
                 providersOut.push(provider);
             });
@@ -6987,6 +7019,19 @@ function validateProvider(provider, providers, containerType) {
         throwInvalidProviderError(containerType, providers, provider);
     }
 }
+function deepForEachProvider(providers, fn) {
+    for (let provider of providers) {
+        if (isEnvironmentProviders(provider)) {
+            provider = provider.ɵproviders;
+        }
+        if (Array.isArray(provider)) {
+            deepForEachProvider(provider, fn);
+        }
+        else {
+            fn(provider);
+        }
+    }
+}
 const USE_VALUE$1 = getClosureSafeProperty({ provide: String, useValue: getClosureSafeProperty });
 function isValueProvider(value) {
     return value !== null && typeof value == 'object' && USE_VALUE$1 in value;
@@ -7352,7 +7397,7 @@ function providerToRecord(provider) {
  */
 function providerToFactory(provider, ngModuleType, providers) {
     let factory = undefined;
-    if (ngDevMode && isImportedNgModuleProviders(provider)) {
+    if (ngDevMode && isEnvironmentProviders(provider)) {
         throwInvalidProviderError(undefined, providers, provider);
     }
     if (isTypeProvider(provider)) {
@@ -7403,15 +7448,12 @@ function couldBeInjectableType(value) {
     return (typeof value === 'function') ||
         (typeof value === 'object' && value instanceof InjectionToken);
 }
-function isImportedNgModuleProviders(provider) {
-    return !!provider.ɵproviders;
-}
 function forEachSingleProvider(providers, fn) {
     for (const provider of providers) {
         if (Array.isArray(provider)) {
             forEachSingleProvider(provider, fn);
         }
-        else if (isImportedNgModuleProviders(provider)) {
+        else if (provider && isEnvironmentProviders(provider)) {
             forEachSingleProvider(provider.ɵproviders, fn);
         }
         else {
@@ -7642,7 +7684,7 @@ class Version {
 /**
  * @publicApi
  */
-const VERSION = new Version('15.0.0-next.4');
+const VERSION = new Version('15.0.0-next.6');
 
 /**
  * @license
@@ -12610,9 +12652,6 @@ function createViewBlueprint(bindingStartIndex, initialViewLength) {
     }
     return blueprint;
 }
-function createError(text, token) {
-    return new Error(`Renderer: ${text} [${stringifyForError(token)}]`);
-}
 /**
  * Locates the host native element, used for bootstrapping existing nodes into rendering pipeline.
  *
@@ -12736,26 +12775,49 @@ function createTNode(tView, tParent, type, index, value, attrs) {
     }
     return tNode;
 }
-function generatePropertyAliases(inputAliasMap, directiveDefIdx, propStore) {
-    for (let publicName in inputAliasMap) {
-        if (inputAliasMap.hasOwnProperty(publicName)) {
-            propStore = propStore === null ? {} : propStore;
-            const internalName = inputAliasMap[publicName];
-            if (propStore.hasOwnProperty(publicName)) {
-                propStore[publicName].push(directiveDefIdx, internalName);
+/**
+ * Generates the `PropertyAliases` data structure from the provided input/output mapping.
+ * @param aliasMap Input/output mapping from the directive definition.
+ * @param directiveIndex Index of the directive.
+ * @param propertyAliases Object in which to store the results.
+ * @param hostDirectiveAliasMap Object used to alias or filter out properties for host directives.
+ * If the mapping is provided, it'll act as an allowlist, as well as a mapping of what public
+ * name inputs/outputs should be exposed under.
+ */
+function generatePropertyAliases(aliasMap, directiveIndex, propertyAliases, hostDirectiveAliasMap) {
+    for (let publicName in aliasMap) {
+        if (aliasMap.hasOwnProperty(publicName)) {
+            propertyAliases = propertyAliases === null ? {} : propertyAliases;
+            const internalName = aliasMap[publicName];
+            // If there are no host directive mappings, we want to remap using the alias map from the
+            // definition itself. If there is an alias map, it has two functions:
+            // 1. It serves as an allowlist of bindings that are exposed by the host directives. Only the
+            // ones inside the host directive map will be exposed on the host.
+            // 2. The public name of the property is aliased using the host directive alias map, rather
+            // than the alias map from the definition.
+            if (hostDirectiveAliasMap === null) {
+                addPropertyAlias(propertyAliases, directiveIndex, publicName, internalName);
             }
-            else {
-                (propStore[publicName] = [directiveDefIdx, internalName]);
+            else if (hostDirectiveAliasMap.hasOwnProperty(publicName)) {
+                addPropertyAlias(propertyAliases, directiveIndex, hostDirectiveAliasMap[publicName], internalName);
             }
         }
     }
-    return propStore;
+    return propertyAliases;
+}
+function addPropertyAlias(propertyAliases, directiveIndex, publicName, internalName) {
+    if (propertyAliases.hasOwnProperty(publicName)) {
+        propertyAliases[publicName].push(directiveIndex, internalName);
+    }
+    else {
+        propertyAliases[publicName] = [directiveIndex, internalName];
+    }
 }
 /**
  * Initializes data structures required to work with directive inputs and outputs.
  * Initialization is done for all directives matched on a given TNode.
  */
-function initializeInputAndOutputAliases(tView, tNode) {
+function initializeInputAndOutputAliases(tView, tNode, hostDirectiveDefinitionMap) {
     ngDevMode && assertFirstCreatePass(tView);
     const start = tNode.directiveStart;
     const end = tNode.directiveEnd;
@@ -12764,16 +12826,21 @@ function initializeInputAndOutputAliases(tView, tNode) {
     const inputsFromAttrs = ngDevMode ? new TNodeInitialInputs() : [];
     let inputsStore = null;
     let outputsStore = null;
-    for (let i = start; i < end; i++) {
-        const directiveDef = tViewData[i];
-        inputsStore = generatePropertyAliases(directiveDef.inputs, i, inputsStore);
-        outputsStore = generatePropertyAliases(directiveDef.outputs, i, outputsStore);
+    for (let directiveIndex = start; directiveIndex < end; directiveIndex++) {
+        const directiveDef = tViewData[directiveIndex];
+        const aliasData = hostDirectiveDefinitionMap ? hostDirectiveDefinitionMap.get(directiveDef) : null;
+        const aliasedInputs = aliasData ? aliasData.inputs : null;
+        const aliasedOutputs = aliasData ? aliasData.outputs : null;
+        inputsStore =
+            generatePropertyAliases(directiveDef.inputs, directiveIndex, inputsStore, aliasedInputs);
+        outputsStore =
+            generatePropertyAliases(directiveDef.outputs, directiveIndex, outputsStore, aliasedOutputs);
         // Do not use unbound attributes as inputs to structural directives, since structural
         // directive inputs can only be set using microsyntax (e.g. `<div *dir="exp">`).
         // TODO(FW-1930): microsyntax expressions may also contain unbound/static attributes, which
         // should be set for inline templates.
         const initialInputs = (inputsStore !== null && tNodeAttrs !== null && !isInlineTemplate(tNode)) ?
-            generateInitialInputs(inputsStore, i, tNodeAttrs) :
+            generateInitialInputs(inputsStore, directiveIndex, tNodeAttrs) :
             null;
         inputsFromAttrs.push(initialInputs);
     }
@@ -12898,16 +12965,19 @@ function resolveDirectives(tView, lView, tNode, localRefs) {
     ngDevMode && assertFirstCreatePass(tView);
     let hasDirectives = false;
     if (getBindingsEnabled()) {
-        const directiveDefs = findDirectiveDefMatches(tView, lView, tNode);
         const exportsMap = localRefs === null ? null : { '': -1 };
+        const matchResult = findDirectiveDefMatches(tView, tNode);
+        let directiveDefs;
+        let hostDirectiveDefs;
+        if (matchResult === null) {
+            directiveDefs = hostDirectiveDefs = null;
+        }
+        else {
+            [directiveDefs, hostDirectiveDefs] = matchResult;
+        }
         if (directiveDefs !== null) {
-            // Publishes the directive types to DI so they can be injected. Needs to
-            // happen in a separate pass before the TNode flags have been initialized.
-            for (let i = 0; i < directiveDefs.length; i++) {
-                diPublicInInjector(getOrCreateNodeInjectorForNode(tNode, lView), tView, directiveDefs[i].type);
-            }
             hasDirectives = true;
-            initializeDirectives(tView, lView, tNode, directiveDefs, exportsMap);
+            initializeDirectives(tView, lView, tNode, directiveDefs, exportsMap, hostDirectiveDefs);
         }
         if (exportsMap)
             cacheMatchingLocalNames(tNode, localRefs, exportsMap);
@@ -12917,8 +12987,13 @@ function resolveDirectives(tView, lView, tNode, localRefs) {
     return hasDirectives;
 }
 /** Initializes the data structures necessary for a list of directives to be instantiated. */
-function initializeDirectives(tView, lView, tNode, directives, exportsMap) {
+function initializeDirectives(tView, lView, tNode, directives, exportsMap, hostDirectiveDefs) {
     ngDevMode && assertFirstCreatePass(tView);
+    // Publishes the directive types to DI so they can be injected. Needs to
+    // happen in a separate pass before the TNode flags have been initialized.
+    for (let i = 0; i < directives.length; i++) {
+        diPublicInInjector(getOrCreateNodeInjectorForNode(tNode, lView), tView, directives[i].type);
+    }
     initTNodeFlags(tNode, tView.data.length, directives.length);
     // When the same token is provided by several directives on the same node, some rules apply in
     // the viewEngine:
@@ -12964,7 +13039,7 @@ function initializeDirectives(tView, lView, tNode, directives, exportsMap) {
         }
         directiveIdx++;
     }
-    initializeInputAndOutputAliases(tView, tNode);
+    initializeInputAndOutputAliases(tView, tNode, hostDirectiveDefs);
 }
 /**
  * Add `hostBindings` to the `TView.hostBindingOpCodes`.
@@ -13076,11 +13151,12 @@ function invokeHostBindingsInCreationMode(def, directive) {
  * Matches the current node against all available selectors.
  * If a component is matched (at most one), it is returned in first position in the array.
  */
-function findDirectiveDefMatches(tView, lView, tNode) {
+function findDirectiveDefMatches(tView, tNode) {
     ngDevMode && assertFirstCreatePass(tView);
     ngDevMode && assertTNodeType(tNode, 3 /* TNodeType.AnyRNode */ | 12 /* TNodeType.AnyContainer */);
     const registry = tView.directiveRegistry;
     let matches = null;
+    let hostDirectiveDefs = null;
     if (registry) {
         for (let i = 0; i < registry.length; i++) {
             const def = registry[i];
@@ -13106,7 +13182,8 @@ function findDirectiveDefMatches(tView, lView, tNode) {
                     // 4. Selector-matched directives.
                     if (def.findHostDirectiveDefs !== null) {
                         const hostDirectiveMatches = [];
-                        def.findHostDirectiveDefs(hostDirectiveMatches, def, tView, lView, tNode);
+                        hostDirectiveDefs = hostDirectiveDefs || new Map();
+                        def.findHostDirectiveDefs(def, hostDirectiveMatches, hostDirectiveDefs);
                         // Add all host directives declared on this component, followed by the component itself.
                         // Host directives should execute first so the host has a chance to override changes
                         // to the DOM made by them.
@@ -13124,13 +13201,14 @@ function findDirectiveDefMatches(tView, lView, tNode) {
                 }
                 else {
                     // Append any host directives to the matches first.
-                    def.findHostDirectiveDefs?.(matches, def, tView, lView, tNode);
+                    hostDirectiveDefs = hostDirectiveDefs || new Map();
+                    def.findHostDirectiveDefs?.(def, matches, hostDirectiveDefs);
                     matches.push(def);
                 }
             }
         }
     }
-    return matches;
+    return matches === null ? null : [matches, hostDirectiveDefs];
 }
 /**
  * Marks a given TNode as a component's host. This consists of:
@@ -14211,15 +14289,26 @@ class ComponentFactory extends ComponentFactory$1 {
         let component;
         let tElementNode;
         try {
-            const rootDirectives = [this.componentDef];
+            const rootComponentDef = this.componentDef;
+            let rootDirectives;
+            let hostDirectiveDefs = null;
+            if (rootComponentDef.findHostDirectiveDefs) {
+                rootDirectives = [];
+                hostDirectiveDefs = new Map();
+                rootComponentDef.findHostDirectiveDefs(rootComponentDef, rootDirectives, hostDirectiveDefs);
+                rootDirectives.push(rootComponentDef);
+            }
+            else {
+                rootDirectives = [rootComponentDef];
+            }
             const hostTNode = createRootComponentTNode(rootLView, hostRNode);
-            const componentView = createRootComponentView(hostTNode, hostRNode, this.componentDef, rootDirectives, rootLView, rendererFactory, hostRenderer);
+            const componentView = createRootComponentView(hostTNode, hostRNode, rootComponentDef, rootDirectives, rootLView, rendererFactory, hostRenderer);
             tElementNode = getTNode(rootTView, HEADER_OFFSET);
             // TODO(crisbeto): in practice `hostRNode` should always be defined, but there are some tests
             // where the renderer is mocked out and `undefined` is returned. We should update the tests so
             // that this check can be removed.
             if (hostRNode) {
-                setRootNodeAttributes(hostRenderer, this.componentDef, hostRNode, rootSelectorOrNode);
+                setRootNodeAttributes(hostRenderer, rootComponentDef, hostRNode, rootSelectorOrNode);
             }
             if (projectableNodes !== undefined) {
                 projectNodes(tElementNode, this.ngContentSelectors, projectableNodes);
@@ -14227,7 +14316,7 @@ class ComponentFactory extends ComponentFactory$1 {
             // TODO: should LifecycleHooksFeature and other host features be generated by the compiler and
             // executed here?
             // Angular 5 reference: https://stackblitz.com/edit/lifecycle-hooks-vcref
-            component = createRootComponent(componentView, this.componentDef, rootDirectives, rootLView, [LifecycleHooksFeature]);
+            component = createRootComponent(componentView, rootComponentDef, rootDirectives, hostDirectiveDefs, rootLView, [LifecycleHooksFeature]);
             renderView(rootTView, rootLView, null);
         }
         finally {
@@ -14327,8 +14416,7 @@ function createRootComponentView(tNode, rNode, rootComponentDef, rootDirectives,
     const viewRenderer = rendererFactory.createRenderer(rNode, rootComponentDef);
     const componentView = createLView(rootView, getOrCreateComponentTView(rootComponentDef), null, rootComponentDef.onPush ? 32 /* LViewFlags.Dirty */ : 16 /* LViewFlags.CheckAlways */, rootView[tNode.index], tNode, rendererFactory, viewRenderer, sanitizer || null, null, null);
     if (tView.firstCreatePass) {
-        diPublicInInjector(getOrCreateNodeInjectorForNode(tNode, rootView), tView, rootComponentDef.type);
-        markAsComponentHost(tView, tNode, 0);
+        markAsComponentHost(tView, tNode, rootDirectives.length - 1);
     }
     addToViewTree(rootView, componentView);
     // Store component view at node index, with node as the HOST
@@ -14350,12 +14438,12 @@ function applyRootComponentStyling(rootDirectives, tNode, rNode, hostRenderer) {
  * Creates a root component and sets it up with features and host bindings.Shared by
  * renderComponent() and ViewContainerRef.createComponent().
  */
-function createRootComponent(componentView, rootComponentDef, rootDirectives, rootLView, hostFeatures) {
+function createRootComponent(componentView, rootComponentDef, rootDirectives, hostDirectiveDefs, rootLView, hostFeatures) {
     const rootTNode = getCurrentTNode();
     ngDevMode && assertDefined(rootTNode, 'tNode should have been already created');
     const tView = rootLView[TVIEW];
     const native = getNativeByTNode(rootTNode, rootLView);
-    initializeDirectives(tView, rootLView, rootTNode, rootDirectives, null);
+    initializeDirectives(tView, rootLView, rootTNode, rootDirectives, null, hostDirectiveDefs);
     for (let i = 0; i < rootDirectives.length; i++) {
         const directiveIndex = rootTNode.directiveStart + i;
         const directiveInstance = getNodeInjectable(rootLView, tView, directiveIndex, rootTNode);
@@ -14676,7 +14764,7 @@ function ɵɵCopyDefinitionFeature(definition) {
  * found in the LICENSE file at https://angular.io/license
  */
 /**
- * This feature add the host directives behavior to a directive definition by patching a
+ * This feature adds the host directives behavior to a directive definition by patching a
  * function onto it. The expectation is that the runtime will invoke the function during
  * directive matching.
  *
@@ -14710,14 +14798,20 @@ function ɵɵHostDirectivesFeature(rawHostDirectives) {
             });
     };
 }
-function findHostDirectiveDefs(matches, def, tView, lView, tNode) {
-    if (def.hostDirectives !== null) {
-        for (const hostDirectiveConfig of def.hostDirectives) {
+function findHostDirectiveDefs(currentDef, matchedDefs, hostDirectiveDefs) {
+    if (currentDef.hostDirectives !== null) {
+        for (const hostDirectiveConfig of currentDef.hostDirectives) {
             const hostDirectiveDef = getDirectiveDef(hostDirectiveConfig.directive);
-            // TODO(crisbeto): assert that the def exists.
+            if (typeof ngDevMode === 'undefined' || ngDevMode) {
+                validateHostDirective(hostDirectiveConfig, hostDirectiveDef, matchedDefs);
+            }
+            // We need to patch the `declaredInputs` so that
+            // `ngOnChanges` can map the properties correctly.
+            patchDeclaredInputs(hostDirectiveDef.declaredInputs, hostDirectiveConfig.inputs);
             // Host directives execute before the host so that its host bindings can be overwritten.
-            findHostDirectiveDefs(matches, hostDirectiveDef, tView, lView, tNode);
-            matches.push(hostDirectiveDef);
+            findHostDirectiveDefs(hostDirectiveDef, matchedDefs, hostDirectiveDefs);
+            hostDirectiveDefs.set(hostDirectiveDef, hostDirectiveConfig);
+            matchedDefs.push(hostDirectiveDef);
         }
     }
 }
@@ -14735,6 +14829,90 @@ function bindingArrayToMap(bindings) {
     }
     return result;
 }
+/**
+ * `ngOnChanges` has some leftover legacy ViewEngine behavior where the keys inside the
+ * `SimpleChanges` event refer to the *declared* name of the input, not its public name or its
+ * minified name. E.g. in `@Input('alias') foo: string`, the name in the `SimpleChanges` object
+ * will always be `foo`, and not `alias` or the minified name of `foo` in apps using property
+ * minification.
+ *
+ * This is achieved through the `DirectiveDef.declaredInputs` map that is constructed when the
+ * definition is declared. When a property is written to the directive instance, the
+ * `NgOnChangesFeature` will try to remap the property name being written to using the
+ * `declaredInputs`.
+ *
+ * Since the host directive input remapping happens during directive matching, `declaredInputs`
+ * won't contain the new alias that the input is available under. This function addresses the
+ * issue by patching the host directive aliases to the `declaredInputs`. There is *not* a risk of
+ * this patching accidentally introducing new inputs to the host directive, because `declaredInputs`
+ * is used *only* by the `NgOnChangesFeature` when determining what name is used in the
+ * `SimpleChanges` object which won't be reached if an input doesn't exist.
+ */
+function patchDeclaredInputs(declaredInputs, exposedInputs) {
+    for (const publicName in exposedInputs) {
+        if (exposedInputs.hasOwnProperty(publicName)) {
+            const remappedPublicName = exposedInputs[publicName];
+            const privateName = declaredInputs[publicName];
+            // We *technically* shouldn't be able to hit this case because we can't have multiple
+            // inputs on the same property and we have validations against conflicting aliases in
+            // `validateMappings`. If we somehow did, it would lead to `ngOnChanges` being invoked
+            // with the wrong name so we have a non-user-friendly assertion here just in case.
+            if ((typeof ngDevMode === 'undefined' || ngDevMode) &&
+                declaredInputs.hasOwnProperty(remappedPublicName)) {
+                assertEqual(declaredInputs[remappedPublicName], declaredInputs[publicName], `Conflicting host directive input alias ${publicName}.`);
+            }
+            declaredInputs[remappedPublicName] = privateName;
+        }
+    }
+}
+/**
+ * Verifies that the host directive has been configured correctly.
+ * @param hostDirectiveConfig Host directive configuration object.
+ * @param directiveDef Directive definition of the host directive.
+ * @param matchedDefs Directives that have been matched so far.
+ */
+function validateHostDirective(hostDirectiveConfig, directiveDef, matchedDefs) {
+    // TODO(crisbeto): implement more of these checks in the compiler.
+    const type = hostDirectiveConfig.directive;
+    if (directiveDef === null) {
+        if (getComponentDef$1(type) !== null) {
+            throw new RuntimeError(310 /* RuntimeErrorCode.HOST_DIRECTIVE_COMPONENT */, `Host directive ${type.name} cannot be a component.`);
+        }
+        throw new RuntimeError(307 /* RuntimeErrorCode.HOST_DIRECTIVE_UNRESOLVABLE */, `Could not resolve metadata for host directive ${type.name}. ` +
+            `Make sure that the ${type.name} class is annotated with an @Directive decorator.`);
+    }
+    if (!directiveDef.standalone) {
+        throw new RuntimeError(308 /* RuntimeErrorCode.HOST_DIRECTIVE_NOT_STANDALONE */, `Host directive ${directiveDef.type.name} must be standalone.`);
+    }
+    if (matchedDefs.indexOf(directiveDef) > -1) {
+        throw new RuntimeError(309 /* RuntimeErrorCode.DUPLICATE_DIRECTITVE */, `Directive ${directiveDef.type.name} matches multiple times on the same element. ` +
+            `Directives can only match an element once.`);
+    }
+    validateMappings('input', directiveDef, hostDirectiveConfig.inputs);
+    validateMappings('output', directiveDef, hostDirectiveConfig.outputs);
+}
+/**
+ * Checks that the host directive inputs/outputs configuration is valid.
+ * @param bindingType Kind of binding that is being validated. Used in the error message.
+ * @param def Definition of the host directive that is being validated against.
+ * @param hostDirectiveDefs Host directive mapping object that shold be validated.
+ */
+function validateMappings(bindingType, def, hostDirectiveDefs) {
+    const className = def.type.name;
+    const bindings = bindingType === 'input' ? def.inputs : def.outputs;
+    for (const publicName in hostDirectiveDefs) {
+        if (hostDirectiveDefs.hasOwnProperty(publicName)) {
+            if (!bindings.hasOwnProperty(publicName)) {
+                throw new RuntimeError(311 /* RuntimeErrorCode.HOST_DIRECTIVE_UNDEFINED_BINDING */, `Directive ${className} does not have an ${bindingType} with a public name of ${publicName}.`);
+            }
+            const remappedPublicName = hostDirectiveDefs[publicName];
+            if (bindings.hasOwnProperty(remappedPublicName) &&
+                bindings[remappedPublicName] !== publicName) {
+                throw new RuntimeError(312 /* RuntimeErrorCode.HOST_DIRECTIVE_CONFLICTING_ALIAS */, `Cannot alias ${bindingType} ${publicName} of host directive ${className} to ${remappedPublicName}, because it already has a different ${bindingType} with the same public name.`);
+            }
+        }
+    }
+}
 
 /**
  * @license
@@ -24637,7 +24815,7 @@ function generateStandaloneInDeclarationsError(type, location) {
 function verifySemanticsOfNgModuleDef(moduleType, allowDuplicateDeclarationsInRoot, importingModule) {
     if (verifiedNgModule.get(moduleType))
         return;
-    // skip verifications of standalone components, directives and pipes
+    // skip verifications of standalone components, directives, and pipes
     if (isStandalone(moduleType))
         return;
     verifiedNgModule.set(moduleType, true);
@@ -25899,17 +26077,17 @@ class TestBedCompiler {
     getProviderOverrides(providers) {
         if (!providers || !providers.length || this.providerOverridesByToken.size === 0)
             return [];
-        // There are two flattening operations here. The inner flatten() operates on the metadata's
-        // providers and applies a mapping function which retrieves overrides for each incoming
-        // provider. The outer flatten() then flattens the produced overrides array. If this is not
-        // done, the array can contain other empty arrays (e.g. `[[], []]`) which leak into the
+        // There are two flattening operations here. The inner flattenProviders() operates on the
+        // metadata's providers and applies a mapping function which retrieves overrides for each
+        // incoming provider. The outer flatten() then flattens the produced overrides array. If this is
+        // not done, the array can contain other empty arrays (e.g. `[[], []]`) which leak into the
         // providers array and contaminate any error messages that might be generated.
-        return flatten(flatten(providers, (provider) => this.getSingleProviderOverrides(provider) || []));
+        return flatten(flattenProviders(providers, (provider) => this.getSingleProviderOverrides(provider) || []));
     }
     getOverriddenProviders(providers) {
         if (!providers || !providers.length || this.providerOverridesByToken.size === 0)
             return [];
-        const flattenedProviders = flatten(providers);
+        const flattenedProviders = flattenProviders(providers);
         const overrides = this.getProviderOverrides(flattenedProviders);
         const overriddenProviders = [...flattenedProviders, ...overrides];
         const final = [];
@@ -25973,18 +26151,36 @@ function isNgModule(value) {
 function maybeUnwrapFn(maybeFn) {
     return maybeFn instanceof Function ? maybeFn() : maybeFn;
 }
-function flatten(values, mapFn) {
+function flatten(values) {
     const out = [];
     values.forEach(value => {
         if (Array.isArray(value)) {
-            out.push(...flatten(value, mapFn));
+            out.push(...flatten(value));
         }
         else {
-            out.push(mapFn ? mapFn(value) : value);
+            out.push(value);
         }
     });
     return out;
 }
+function identityFn(value) {
+    return value;
+}
+function flattenProviders(providers, mapFn = identityFn) {
+    const out = [];
+    for (let provider of providers) {
+        if (ɵisEnvironmentProviders(provider)) {
+            provider = provider.ɵproviders;
+        }
+        if (Array.isArray(provider)) {
+            out.push(...flattenProviders(provider, mapFn));
+        }
+        else {
+            out.push(mapFn(provider));
+        }
+    }
+    return out;
+}
 function getProviderField(provider, field) {
     return provider && typeof provider === 'object' && provider[field];
 }