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

package/esm2020/src/render3/errors_di.mjs

@@ -5,6 +5,7 @@
  * 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 { isEnvironmentProviders } from '../di/interface/provider';
 import { RuntimeError } from '../errors';
 import { stringify } from '../util/stringify';
 import { stringifyForError } from './util/stringify_utils';
@@ -21,8 +22,13 @@ export 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');
@@ -33,4 +39,4 @@ export function throwProviderNotFoundError(token, injectorName) {
     const injectorDetails = injectorName ? ` in ${injectorName}` : '';
     throw new RuntimeError(-201 /* RuntimeErrorCode.PROVIDER_NOT_FOUND */, ngDevMode && `No provider for ${stringifyForError(token)} found${injectorDetails}`);
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/render3/features/host_directives_feature.mjs

@@ -6,10 +6,12 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import { resolveForwardRef } from '../../di';
+import { RuntimeError } from '../../errors';
+import { assertEqual } from '../../util/assert';
 import { EMPTY_OBJ } from '../../util/empty';
-import { getDirectiveDef } from '../definition';
+import { getComponentDef, getDirectiveDef } from '../definition';
 /**
- * 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.
  *
@@ -43,14 +45,20 @@ export 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);
         }
     }
 }
@@ -68,4 +76,88 @@ function bindingArrayToMap(bindings) {
     }
     return result;
 }
-//# sourceMappingURL=data:application/json;base64,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
+/**
+ * `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(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.`);
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"host_directives_feature.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/features/host_directives_feature.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 */\nimport {resolveForwardRef} from '../../di';\nimport {RuntimeError, RuntimeErrorCode} from '../../errors';\nimport {Type} from '../../interface/type';\nimport {assertEqual} from '../../util/assert';\nimport {EMPTY_OBJ} from '../../util/empty';\nimport {getComponentDef, getDirectiveDef} from '../definition';\nimport {DirectiveDef, HostDirectiveBindingMap, HostDirectiveDef, HostDirectiveDefs} from '../interfaces/definition';\n\n/** Values that can be used to define a host directive through the `HostDirectivesFeature`. */\ntype HostDirectiveConfig = Type<unknown>|{\n  directive: Type<unknown>;\n  inputs?: string[];\n  outputs?: string[];\n};\n\n/**\n * This feature adds the host directives behavior to a directive definition by patching a\n * function onto it. The expectation is that the runtime will invoke the function during\n * directive matching.\n *\n * For example:\n * ```ts\n * class ComponentWithHostDirective {\n *   static ɵcmp = defineComponent({\n *    type: ComponentWithHostDirective,\n *    features: [ɵɵHostDirectivesFeature([\n *      SimpleHostDirective,\n *      {directive: AdvancedHostDirective, inputs: ['foo: alias'], outputs: ['bar']},\n *    ])]\n *  });\n * }\n * ```\n *\n * @codeGenApi\n */\nexport function ɵɵHostDirectivesFeature(rawHostDirectives: HostDirectiveConfig[]|\n                                        (() => HostDirectiveConfig[])) {\n  return (definition: DirectiveDef<unknown>) => {\n    definition.findHostDirectiveDefs = findHostDirectiveDefs;\n    definition.hostDirectives =\n        (Array.isArray(rawHostDirectives) ? rawHostDirectives : rawHostDirectives()).map(dir => {\n          return typeof dir === 'function' ?\n              {directive: resolveForwardRef(dir), inputs: EMPTY_OBJ, outputs: EMPTY_OBJ} :\n              {\n                directive: resolveForwardRef(dir.directive),\n                inputs: bindingArrayToMap(dir.inputs),\n                outputs: bindingArrayToMap(dir.outputs)\n              };\n        });\n  };\n}\n\nfunction findHostDirectiveDefs(\n    currentDef: DirectiveDef<unknown>, matchedDefs: DirectiveDef<unknown>[],\n    hostDirectiveDefs: HostDirectiveDefs): void {\n  if (currentDef.hostDirectives !== null) {\n    for (const hostDirectiveConfig of currentDef.hostDirectives) {\n      const hostDirectiveDef = getDirectiveDef(hostDirectiveConfig.directive)!;\n\n      if (typeof ngDevMode === 'undefined' || ngDevMode) {\n        validateHostDirective(hostDirectiveConfig, hostDirectiveDef, matchedDefs);\n      }\n\n      // We need to patch the `declaredInputs` so that\n      // `ngOnChanges` can map the properties correctly.\n      patchDeclaredInputs(hostDirectiveDef.declaredInputs, hostDirectiveConfig.inputs);\n\n      // Host directives execute before the host so that its host bindings can be overwritten.\n      findHostDirectiveDefs(hostDirectiveDef, matchedDefs, hostDirectiveDefs);\n      hostDirectiveDefs.set(hostDirectiveDef, hostDirectiveConfig);\n      matchedDefs.push(hostDirectiveDef);\n    }\n  }\n}\n\n/**\n * Converts an array in the form of `['publicName', 'alias', 'otherPublicName', 'otherAlias']` into\n * a map in the form of `{publicName: 'alias', otherPublicName: 'otherAlias'}`.\n */\nfunction bindingArrayToMap(bindings: string[]|undefined): HostDirectiveBindingMap {\n  if (bindings === undefined || bindings.length === 0) {\n    return EMPTY_OBJ;\n  }\n\n  const result: HostDirectiveBindingMap = {};\n\n  for (let i = 0; i < bindings.length; i += 2) {\n    result[bindings[i]] = bindings[i + 1];\n  }\n\n  return result;\n}\n\n/**\n * `ngOnChanges` has some leftover legacy ViewEngine behavior where the keys inside the\n * `SimpleChanges` event refer to the *declared* name of the input, not its public name or its\n * minified name. E.g. in `@Input('alias') foo: string`, the name in the `SimpleChanges` object\n * will always be `foo`, and not `alias` or the minified name of `foo` in apps using property\n * minification.\n *\n * This is achieved through the `DirectiveDef.declaredInputs` map that is constructed when the\n * definition is declared. When a property is written to the directive instance, the\n * `NgOnChangesFeature` will try to remap the property name being written to using the\n * `declaredInputs`.\n *\n * Since the host directive input remapping happens during directive matching, `declaredInputs`\n * won't contain the new alias that the input is available under. This function addresses the\n * issue by patching the host directive aliases to the `declaredInputs`. There is *not* a risk of\n * this patching accidentally introducing new inputs to the host directive, because `declaredInputs`\n * is used *only* by the `NgOnChangesFeature` when determining what name is used in the\n * `SimpleChanges` object which won't be reached if an input doesn't exist.\n */\nfunction patchDeclaredInputs(\n    declaredInputs: Record<string, string>, exposedInputs: HostDirectiveBindingMap): void {\n  for (const publicName in exposedInputs) {\n    if (exposedInputs.hasOwnProperty(publicName)) {\n      const remappedPublicName = exposedInputs[publicName];\n      const privateName = declaredInputs[publicName];\n\n      // We *technically* shouldn't be able to hit this case because we can't have multiple\n      // inputs on the same property and we have validations against conflicting aliases in\n      // `validateMappings`. If we somehow did, it would lead to `ngOnChanges` being invoked\n      // with the wrong name so we have a non-user-friendly assertion here just in case.\n      if ((typeof ngDevMode === 'undefined' || ngDevMode) &&\n          declaredInputs.hasOwnProperty(remappedPublicName)) {\n        assertEqual(\n            declaredInputs[remappedPublicName], declaredInputs[publicName],\n            `Conflicting host directive input alias ${publicName}.`);\n      }\n\n      declaredInputs[remappedPublicName] = privateName;\n    }\n  }\n}\n\n/**\n * Verifies that the host directive has been configured correctly.\n * @param hostDirectiveConfig Host directive configuration object.\n * @param directiveDef Directive definition of the host directive.\n * @param matchedDefs Directives that have been matched so far.\n */\nfunction validateHostDirective(\n    hostDirectiveConfig: HostDirectiveDef<unknown>, directiveDef: DirectiveDef<any>|null,\n    matchedDefs: DirectiveDef<unknown>[]): asserts directiveDef is DirectiveDef<unknown> {\n  // TODO(crisbeto): implement more of these checks in the compiler.\n  const type = hostDirectiveConfig.directive;\n\n  if (directiveDef === null) {\n    if (getComponentDef(type) !== null) {\n      throw new RuntimeError(\n          RuntimeErrorCode.HOST_DIRECTIVE_COMPONENT,\n          `Host directive ${type.name} cannot be a component.`);\n    }\n\n    throw new RuntimeError(\n        RuntimeErrorCode.HOST_DIRECTIVE_UNRESOLVABLE,\n        `Could not resolve metadata for host directive ${type.name}. ` +\n            `Make sure that the ${type.name} class is annotated with an @Directive decorator.`);\n  }\n\n  if (!directiveDef.standalone) {\n    throw new RuntimeError(\n        RuntimeErrorCode.HOST_DIRECTIVE_NOT_STANDALONE,\n        `Host directive ${directiveDef.type.name} must be standalone.`);\n  }\n\n  if (matchedDefs.indexOf(directiveDef) > -1) {\n    throw new RuntimeError(\n        RuntimeErrorCode.DUPLICATE_DIRECTITVE,\n        `Directive ${directiveDef.type.name} matches multiple times on the same element. ` +\n            `Directives can only match an element once.`);\n  }\n\n  validateMappings('input', directiveDef, hostDirectiveConfig.inputs);\n  validateMappings('output', directiveDef, hostDirectiveConfig.outputs);\n}\n\n/**\n * Checks that the host directive inputs/outputs configuration is valid.\n * @param bindingType Kind of binding that is being validated. Used in the error message.\n * @param def Definition of the host directive that is being validated against.\n * @param hostDirectiveDefs Host directive mapping object that shold be validated.\n */\nfunction validateMappings(\n    bindingType: 'input'|'output', def: DirectiveDef<unknown>,\n    hostDirectiveDefs: HostDirectiveBindingMap) {\n  const className = def.type.name;\n  const bindings: Record<string, string> = bindingType === 'input' ? def.inputs : def.outputs;\n\n  for (const publicName in hostDirectiveDefs) {\n    if (hostDirectiveDefs.hasOwnProperty(publicName)) {\n      if (!bindings.hasOwnProperty(publicName)) {\n        throw new RuntimeError(\n            RuntimeErrorCode.HOST_DIRECTIVE_UNDEFINED_BINDING,\n            `Directive ${className} does not have an ${bindingType} with a public name of ${\n                publicName}.`);\n      }\n\n      const remappedPublicName = hostDirectiveDefs[publicName];\n\n      if (bindings.hasOwnProperty(remappedPublicName) &&\n          bindings[remappedPublicName] !== publicName) {\n        throw new RuntimeError(\n            RuntimeErrorCode.HOST_DIRECTIVE_CONFLICTING_ALIAS,\n            `Cannot alias ${bindingType} ${publicName} of host directive ${className} to ${\n                remappedPublicName}, because it already has a different ${\n                bindingType} with the same public name.`);\n      }\n    }\n  }\n}\n"]}

package/esm2020/src/render3/features/ng_onchanges_feature.mjs

@@ -6,6 +6,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import { SimpleChange } from '../../interface/simple_change';
+import { assertString } from '../../util/assert';
 import { EMPTY_OBJ } from '../../util/empty';
 /**
  * The NgOnChangesFeature decorates a component with support for the ngOnChanges
@@ -73,11 +74,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;
@@ -89,4 +91,4 @@ function getSimpleChangesStore(instance) {
 function setSimpleChangesStore(instance, store) {
     return instance[SIMPLE_CHANGES_STORE] = store;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ng_onchanges_feature.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/features/ng_onchanges_feature.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,EAAC,YAAY,EAAgB,MAAM,+BAA+B,CAAC;AAC1E,OAAO,EAAC,SAAS,EAAC,MAAM,kBAAkB,CAAC;AAG3C;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,UAAU,oBAAoB;IAClC,OAAO,sBAAsB,CAAC;AAChC,CAAC;AAED,MAAM,UAAU,sBAAsB,CAAI,UAA2B;IACnE,IAAI,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,WAAW,EAAE;QACzC,UAAU,CAAC,QAAQ,GAAG,mBAAmB,CAAC;KAC3C;IACD,OAAO,2CAA2C,CAAC;AACrD,CAAC;AAED,4EAA4E;AAC5E,mDAAmD;AACnD,kBAAkB;AAClB,uDAAuD;AACtD,oBAA4C,CAAC,SAAS,GAAG,IAAI,CAAC;AAE/D;;;;;;;;;GASG;AACH,SAAS,2CAA2C;IAClD,MAAM,kBAAkB,GAAG,qBAAqB,CAAC,IAAI,CAAC,CAAC;IACvD,MAAM,OAAO,GAAG,kBAAkB,EAAE,OAAO,CAAC;IAE5C,IAAI,OAAO,EAAE;QACX,MAAM,QAAQ,GAAG,kBAAmB,CAAC,QAAQ,CAAC;QAC9C,IAAI,QAAQ,KAAK,SAAS,EAAE;YAC1B,kBAAmB,CAAC,QAAQ,GAAG,OAAO,CAAC;SACxC;aAAM;YACL,yFAAyF;YACzF,mCAAmC;YACnC,KAAK,IAAI,GAAG,IAAI,OAAO,EAAE;gBACvB,QAAQ,CAAC,GAAG,CAAC,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;aAC9B;SACF;QACD,kBAAmB,CAAC,OAAO,GAAG,IAAI,CAAC;QACnC,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;KAC3B;AACH,CAAC;AAGD,SAAS,mBAAmB,CACD,QAAW,EAAE,KAAU,EAAE,UAAkB,EAAE,WAAmB;IACzF,MAAM,kBAAkB,GAAG,qBAAqB,CAAC,QAAQ,CAAC;QACtD,qBAAqB,CAAC,QAAQ,EAAE,EAAC,QAAQ,EAAE,SAAS,EAAE,OAAO,EAAE,IAAI,EAAC,CAAC,CAAC;IAC1E,MAAM,OAAO,GAAG,kBAAkB,CAAC,OAAO,IAAI,CAAC,kBAAkB,CAAC,OAAO,GAAG,EAAE,CAAC,CAAC;IAChF,MAAM,QAAQ,GAAG,kBAAkB,CAAC,QAAQ,CAAC;IAE7C,MAAM,YAAY,GAAI,IAAI,CAAC,cAA0C,CAAC,UAAU,CAAC,CAAC;IAClF,MAAM,cAAc,GAAG,QAAQ,CAAC,YAAY,CAAC,CAAC;IAC9C,OAAO,CAAC,YAAY,CAAC,GAAG,IAAI,YAAY,CACpC,cAAc,IAAI,cAAc,CAAC,YAAY,EAAE,KAAK,EAAE,QAAQ,KAAK,SAAS,CAAC,CAAC;IAEjF,QAAgB,CAAC,WAAW,CAAC,GAAG,KAAK,CAAC;AACzC,CAAC;AAED,MAAM,oBAAoB,GAAG,qBAAqB,CAAC;AAEnD,SAAS,qBAAqB,CAAC,QAAa;IAC1C,OAAO,QAAQ,CAAC,oBAAoB,CAAC,IAAI,IAAI,CAAC;AAChD,CAAC;AAED,SAAS,qBAAqB,CAAC,QAAa,EAAE,KAA2B;IACvE,OAAO,QAAQ,CAAC,oBAAoB,CAAC,GAAG,KAAK,CAAC;AAChD,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 {OnChanges} from '../../interface/lifecycle_hooks';\nimport {SimpleChange, SimpleChanges} from '../../interface/simple_change';\nimport {EMPTY_OBJ} from '../../util/empty';\nimport {DirectiveDef, DirectiveDefFeature} from '../interfaces/definition';\n\n/**\n * The NgOnChangesFeature decorates a component with support for the ngOnChanges\n * lifecycle hook, so it should be included in any component that implements\n * that hook.\n *\n * If the component or directive uses inheritance, the NgOnChangesFeature MUST\n * be included as a feature AFTER {@link InheritDefinitionFeature}, otherwise\n * inherited properties will not be propagated to the ngOnChanges lifecycle\n * hook.\n *\n * Example usage:\n *\n * ```\n * static ɵcmp = defineComponent({\n *   ...\n *   inputs: {name: 'publicName'},\n *   features: [NgOnChangesFeature]\n * });\n * ```\n *\n * @codeGenApi\n */\nexport function ɵɵNgOnChangesFeature<T>(): DirectiveDefFeature {\n  return NgOnChangesFeatureImpl;\n}\n\nexport function NgOnChangesFeatureImpl<T>(definition: DirectiveDef<T>) {\n  if (definition.type.prototype.ngOnChanges) {\n    definition.setInput = ngOnChangesSetInput;\n  }\n  return rememberChangeHistoryAndInvokeOnChangesHook;\n}\n\n// This option ensures that the ngOnChanges lifecycle hook will be inherited\n// from superclasses (in InheritDefinitionFeature).\n/** @nocollapse */\n// tslint:disable-next-line:no-toplevel-property-access\n(ɵɵNgOnChangesFeature as DirectiveDefFeature).ngInherit = true;\n\n/**\n * This is a synthetic lifecycle hook which gets inserted into `TView.preOrderHooks` to simulate\n * `ngOnChanges`.\n *\n * The hook reads the `NgSimpleChangesStore` data from the component instance and if changes are\n * found it invokes `ngOnChanges` on the component instance.\n *\n * @param this Component instance. Because this function gets inserted into `TView.preOrderHooks`,\n *     it is guaranteed to be called with component instance.\n */\nfunction rememberChangeHistoryAndInvokeOnChangesHook(this: OnChanges) {\n  const simpleChangesStore = getSimpleChangesStore(this);\n  const current = simpleChangesStore?.current;\n\n  if (current) {\n    const previous = simpleChangesStore!.previous;\n    if (previous === EMPTY_OBJ) {\n      simpleChangesStore!.previous = current;\n    } else {\n      // New changes are copied to the previous store, so that we don't lose history for inputs\n      // which were not changed this time\n      for (let key in current) {\n        previous[key] = current[key];\n      }\n    }\n    simpleChangesStore!.current = null;\n    this.ngOnChanges(current);\n  }\n}\n\n\nfunction ngOnChangesSetInput<T>(\n    this: DirectiveDef<T>, instance: T, value: any, publicName: string, privateName: string): void {\n  const simpleChangesStore = getSimpleChangesStore(instance) ||\n      setSimpleChangesStore(instance, {previous: EMPTY_OBJ, current: null});\n  const current = simpleChangesStore.current || (simpleChangesStore.current = {});\n  const previous = simpleChangesStore.previous;\n\n  const declaredName = (this.declaredInputs as {[key: string]: string})[publicName];\n  const previousChange = previous[declaredName];\n  current[declaredName] = new SimpleChange(\n      previousChange && previousChange.currentValue, value, previous === EMPTY_OBJ);\n\n  (instance as any)[privateName] = value;\n}\n\nconst SIMPLE_CHANGES_STORE = '__ngSimpleChanges__';\n\nfunction getSimpleChangesStore(instance: any): null|NgSimpleChangesStore {\n  return instance[SIMPLE_CHANGES_STORE] || null;\n}\n\nfunction setSimpleChangesStore(instance: any, store: NgSimpleChangesStore): NgSimpleChangesStore {\n  return instance[SIMPLE_CHANGES_STORE] = store;\n}\n\n/**\n * Data structure which is monkey-patched on the component instance and used by `ngOnChanges`\n * life-cycle hook to track previous input values.\n */\ninterface NgSimpleChangesStore {\n  previous: SimpleChanges;\n  current: SimpleChanges|null;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ng_onchanges_feature.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/features/ng_onchanges_feature.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,EAAC,YAAY,EAAgB,MAAM,+BAA+B,CAAC;AAC1E,OAAO,EAAC,YAAY,EAAC,MAAM,mBAAmB,CAAC;AAC/C,OAAO,EAAC,SAAS,EAAC,MAAM,kBAAkB,CAAC;AAG3C;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,UAAU,oBAAoB;IAClC,OAAO,sBAAsB,CAAC;AAChC,CAAC;AAED,MAAM,UAAU,sBAAsB,CAAI,UAA2B;IACnE,IAAI,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,WAAW,EAAE;QACzC,UAAU,CAAC,QAAQ,GAAG,mBAAmB,CAAC;KAC3C;IACD,OAAO,2CAA2C,CAAC;AACrD,CAAC;AAED,4EAA4E;AAC5E,mDAAmD;AACnD,kBAAkB;AAClB,uDAAuD;AACtD,oBAA4C,CAAC,SAAS,GAAG,IAAI,CAAC;AAE/D;;;;;;;;;GASG;AACH,SAAS,2CAA2C;IAClD,MAAM,kBAAkB,GAAG,qBAAqB,CAAC,IAAI,CAAC,CAAC;IACvD,MAAM,OAAO,GAAG,kBAAkB,EAAE,OAAO,CAAC;IAE5C,IAAI,OAAO,EAAE;QACX,MAAM,QAAQ,GAAG,kBAAmB,CAAC,QAAQ,CAAC;QAC9C,IAAI,QAAQ,KAAK,SAAS,EAAE;YAC1B,kBAAmB,CAAC,QAAQ,GAAG,OAAO,CAAC;SACxC;aAAM;YACL,yFAAyF;YACzF,mCAAmC;YACnC,KAAK,IAAI,GAAG,IAAI,OAAO,EAAE;gBACvB,QAAQ,CAAC,GAAG,CAAC,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;aAC9B;SACF;QACD,kBAAmB,CAAC,OAAO,GAAG,IAAI,CAAC;QACnC,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;KAC3B;AACH,CAAC;AAGD,SAAS,mBAAmB,CACD,QAAW,EAAE,KAAU,EAAE,UAAkB,EAAE,WAAmB;IACzF,MAAM,YAAY,GAAI,IAAI,CAAC,cAA0C,CAAC,UAAU,CAAC,CAAC;IAClF,SAAS,IAAI,YAAY,CAAC,YAAY,EAAE,iDAAiD,CAAC,CAAC;IAC3F,MAAM,kBAAkB,GAAG,qBAAqB,CAAC,QAAQ,CAAC;QACtD,qBAAqB,CAAC,QAAQ,EAAE,EAAC,QAAQ,EAAE,SAAS,EAAE,OAAO,EAAE,IAAI,EAAC,CAAC,CAAC;IAC1E,MAAM,OAAO,GAAG,kBAAkB,CAAC,OAAO,IAAI,CAAC,kBAAkB,CAAC,OAAO,GAAG,EAAE,CAAC,CAAC;IAChF,MAAM,QAAQ,GAAG,kBAAkB,CAAC,QAAQ,CAAC;IAC7C,MAAM,cAAc,GAAG,QAAQ,CAAC,YAAY,CAAC,CAAC;IAC9C,OAAO,CAAC,YAAY,CAAC,GAAG,IAAI,YAAY,CACpC,cAAc,IAAI,cAAc,CAAC,YAAY,EAAE,KAAK,EAAE,QAAQ,KAAK,SAAS,CAAC,CAAC;IAEjF,QAAgB,CAAC,WAAW,CAAC,GAAG,KAAK,CAAC;AACzC,CAAC;AAED,MAAM,oBAAoB,GAAG,qBAAqB,CAAC;AAEnD,SAAS,qBAAqB,CAAC,QAAa;IAC1C,OAAO,QAAQ,CAAC,oBAAoB,CAAC,IAAI,IAAI,CAAC;AAChD,CAAC;AAED,SAAS,qBAAqB,CAAC,QAAa,EAAE,KAA2B;IACvE,OAAO,QAAQ,CAAC,oBAAoB,CAAC,GAAG,KAAK,CAAC;AAChD,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 {OnChanges} from '../../interface/lifecycle_hooks';\nimport {SimpleChange, SimpleChanges} from '../../interface/simple_change';\nimport {assertString} from '../../util/assert';\nimport {EMPTY_OBJ} from '../../util/empty';\nimport {DirectiveDef, DirectiveDefFeature} from '../interfaces/definition';\n\n/**\n * The NgOnChangesFeature decorates a component with support for the ngOnChanges\n * lifecycle hook, so it should be included in any component that implements\n * that hook.\n *\n * If the component or directive uses inheritance, the NgOnChangesFeature MUST\n * be included as a feature AFTER {@link InheritDefinitionFeature}, otherwise\n * inherited properties will not be propagated to the ngOnChanges lifecycle\n * hook.\n *\n * Example usage:\n *\n * ```\n * static ɵcmp = defineComponent({\n *   ...\n *   inputs: {name: 'publicName'},\n *   features: [NgOnChangesFeature]\n * });\n * ```\n *\n * @codeGenApi\n */\nexport function ɵɵNgOnChangesFeature<T>(): DirectiveDefFeature {\n  return NgOnChangesFeatureImpl;\n}\n\nexport function NgOnChangesFeatureImpl<T>(definition: DirectiveDef<T>) {\n  if (definition.type.prototype.ngOnChanges) {\n    definition.setInput = ngOnChangesSetInput;\n  }\n  return rememberChangeHistoryAndInvokeOnChangesHook;\n}\n\n// This option ensures that the ngOnChanges lifecycle hook will be inherited\n// from superclasses (in InheritDefinitionFeature).\n/** @nocollapse */\n// tslint:disable-next-line:no-toplevel-property-access\n(ɵɵNgOnChangesFeature as DirectiveDefFeature).ngInherit = true;\n\n/**\n * This is a synthetic lifecycle hook which gets inserted into `TView.preOrderHooks` to simulate\n * `ngOnChanges`.\n *\n * The hook reads the `NgSimpleChangesStore` data from the component instance and if changes are\n * found it invokes `ngOnChanges` on the component instance.\n *\n * @param this Component instance. Because this function gets inserted into `TView.preOrderHooks`,\n *     it is guaranteed to be called with component instance.\n */\nfunction rememberChangeHistoryAndInvokeOnChangesHook(this: OnChanges) {\n  const simpleChangesStore = getSimpleChangesStore(this);\n  const current = simpleChangesStore?.current;\n\n  if (current) {\n    const previous = simpleChangesStore!.previous;\n    if (previous === EMPTY_OBJ) {\n      simpleChangesStore!.previous = current;\n    } else {\n      // New changes are copied to the previous store, so that we don't lose history for inputs\n      // which were not changed this time\n      for (let key in current) {\n        previous[key] = current[key];\n      }\n    }\n    simpleChangesStore!.current = null;\n    this.ngOnChanges(current);\n  }\n}\n\n\nfunction ngOnChangesSetInput<T>(\n    this: DirectiveDef<T>, instance: T, value: any, publicName: string, privateName: string): void {\n  const declaredName = (this.declaredInputs as {[key: string]: string})[publicName];\n  ngDevMode && assertString(declaredName, 'Name of input in ngOnChanges has to be a string');\n  const simpleChangesStore = getSimpleChangesStore(instance) ||\n      setSimpleChangesStore(instance, {previous: EMPTY_OBJ, current: null});\n  const current = simpleChangesStore.current || (simpleChangesStore.current = {});\n  const previous = simpleChangesStore.previous;\n  const previousChange = previous[declaredName];\n  current[declaredName] = new SimpleChange(\n      previousChange && previousChange.currentValue, value, previous === EMPTY_OBJ);\n\n  (instance as any)[privateName] = value;\n}\n\nconst SIMPLE_CHANGES_STORE = '__ngSimpleChanges__';\n\nfunction getSimpleChangesStore(instance: any): null|NgSimpleChangesStore {\n  return instance[SIMPLE_CHANGES_STORE] || null;\n}\n\nfunction setSimpleChangesStore(instance: any, store: NgSimpleChangesStore): NgSimpleChangesStore {\n  return instance[SIMPLE_CHANGES_STORE] = store;\n}\n\n/**\n * Data structure which is monkey-patched on the component instance and used by `ngOnChanges`\n * life-cycle hook to track previous input values.\n */\ninterface NgSimpleChangesStore {\n  previous: SimpleChanges;\n  current: SimpleChanges|null;\n}\n"]}