@angular/core
Version:
Angular - the core framework
162 lines • 26.4 kB
JavaScript
/**
* @license
* Copyright Google LLC All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
import { resolveForwardRef } from '../../di';
import { RuntimeError } from '../../errors';
import { assertEqual } from '../../util/assert';
import { EMPTY_OBJ } from '../../util/empty';
import { getComponentDef, getDirectiveDef } from '../definition';
/**
* 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.
*
* For example:
* ```ts
* class ComponentWithHostDirective {
* static ɵcmp = defineComponent({
* type: ComponentWithHostDirective,
* features: [ɵɵHostDirectivesFeature([
* SimpleHostDirective,
* {directive: AdvancedHostDirective, inputs: ['foo: alias'], outputs: ['bar']},
* ])]
* });
* }
* ```
*
* @codeGenApi
*/
export function ɵɵHostDirectivesFeature(rawHostDirectives) {
return (definition) => {
definition.findHostDirectiveDefs = findHostDirectiveDefs;
definition.hostDirectives =
(Array.isArray(rawHostDirectives) ? rawHostDirectives : rawHostDirectives()).map(dir => {
return typeof dir === 'function' ?
{ directive: resolveForwardRef(dir), inputs: EMPTY_OBJ, outputs: EMPTY_OBJ } :
{
directive: resolveForwardRef(dir.directive),
inputs: bindingArrayToMap(dir.inputs),
outputs: bindingArrayToMap(dir.outputs)
};
});
};
}
function findHostDirectiveDefs(currentDef, matchedDefs, hostDirectiveDefs) {
if (currentDef.hostDirectives !== null) {
for (const hostDirectiveConfig of currentDef.hostDirectives) {
const hostDirectiveDef = getDirectiveDef(hostDirectiveConfig.directive);
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(hostDirectiveDef, matchedDefs, hostDirectiveDefs);
hostDirectiveDefs.set(hostDirectiveDef, hostDirectiveConfig);
matchedDefs.push(hostDirectiveDef);
}
}
}
/**
* Converts an array in the form of `['publicName', 'alias', 'otherPublicName', 'otherAlias']` into
* a map in the form of `{publicName: 'alias', otherPublicName: 'otherAlias'}`.
*/
function bindingArrayToMap(bindings) {
if (bindings === undefined || bindings.length === 0) {
return EMPTY_OBJ;
}
const result = {};
for (let i = 0; i < bindings.length; i += 2) {
result[bindings[i]] = bindings[i + 1];
}
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) {
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 hostDirectiveBindings Host directive mapping object that shold be validated.
*/
function validateMappings(bindingType, def, hostDirectiveBindings) {
const className = def.type.name;
const bindings = bindingType === 'input' ? def.inputs : def.outputs;
for (const publicName in hostDirectiveBindings) {
if (hostDirectiveBindings.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 = hostDirectiveBindings[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  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 hostDirectiveBindings Host directive mapping object that shold be validated.\n */\nfunction validateMappings(\n    bindingType: 'input'|'output', def: DirectiveDef<unknown>,\n    hostDirectiveBindings: 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 hostDirectiveBindings) {\n    if (hostDirectiveBindings.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 = hostDirectiveBindings[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"]}