@angular/core
Version:
Angular - the core framework
241 lines • 28.6 kB
JavaScript
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @license
* Copyright Google Inc. 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 { fillProperties } from '../../util/property';
import { EMPTY_ARRAY, EMPTY_OBJ } from '../empty';
import { adjustActiveDirectiveSuperClassDepthPosition } from '../state';
import { isComponentDef } from '../util/view_utils';
import { ɵɵNgOnChangesFeature } from './ng_onchanges_feature';
/**
* @param {?} type
* @return {?}
*/
function getSuperType(type) {
return Object.getPrototypeOf(type.prototype).constructor;
}
/**
* Merges the definition from a super class to a sub class.
* \@codeGenApi
* @param {?} definition The definition that is a SubClass of another directive of component
*
* @return {?}
*/
export function ɵɵInheritDefinitionFeature(definition) {
/** @type {?} */
let superType = getSuperType(definition.type);
while (superType) {
/** @type {?} */
let superDef = undefined;
if (isComponentDef(definition)) {
// Don't use getComponentDef/getDirectiveDef. This logic relies on inheritance.
superDef = superType.ngComponentDef || superType.ngDirectiveDef;
}
else {
if (superType.ngComponentDef) {
throw new Error('Directives cannot inherit Components');
}
// Don't use getComponentDef/getDirectiveDef. This logic relies on inheritance.
superDef = superType.ngDirectiveDef;
}
/** @nocollapse @type {?} */
const baseDef = ((/** @type {?} */ (superType))).ngBaseDef;
// Some fields in the definition may be empty, if there were no values to put in them that
// would've justified object creation. Unwrap them if necessary.
if (baseDef || superDef) {
/** @type {?} */
const writeableDef = (/** @type {?} */ (definition));
writeableDef.inputs = maybeUnwrapEmpty(definition.inputs);
writeableDef.declaredInputs = maybeUnwrapEmpty(definition.declaredInputs);
writeableDef.outputs = maybeUnwrapEmpty(definition.outputs);
}
if (baseDef) {
/** @type {?} */
const baseViewQuery = baseDef.viewQuery;
/** @type {?} */
const baseContentQueries = baseDef.contentQueries;
/** @type {?} */
const baseHostBindings = baseDef.hostBindings;
baseHostBindings && inheritHostBindings(definition, baseHostBindings);
baseViewQuery && inheritViewQuery(definition, baseViewQuery);
baseContentQueries && inheritContentQueries(definition, baseContentQueries);
fillProperties(definition.inputs, baseDef.inputs);
fillProperties(definition.declaredInputs, baseDef.declaredInputs);
fillProperties(definition.outputs, baseDef.outputs);
}
if (superDef) {
// Merge hostBindings
/** @type {?} */
const superHostBindings = superDef.hostBindings;
superHostBindings && inheritHostBindings(definition, superHostBindings);
// Merge queries
/** @type {?} */
const superViewQuery = superDef.viewQuery;
/** @type {?} */
const superContentQueries = superDef.contentQueries;
superViewQuery && inheritViewQuery(definition, superViewQuery);
superContentQueries && inheritContentQueries(definition, superContentQueries);
// Merge inputs and outputs
fillProperties(definition.inputs, superDef.inputs);
fillProperties(definition.declaredInputs, superDef.declaredInputs);
fillProperties(definition.outputs, superDef.outputs);
// Inherit hooks
// Assume super class inheritance feature has already run.
definition.afterContentChecked =
definition.afterContentChecked || superDef.afterContentChecked;
definition.afterContentInit = definition.afterContentInit || superDef.afterContentInit;
definition.afterViewChecked = definition.afterViewChecked || superDef.afterViewChecked;
definition.afterViewInit = definition.afterViewInit || superDef.afterViewInit;
definition.doCheck = definition.doCheck || superDef.doCheck;
definition.onDestroy = definition.onDestroy || superDef.onDestroy;
definition.onInit = definition.onInit || superDef.onInit;
// Run parent features
/** @type {?} */
const features = superDef.features;
if (features) {
for (const feature of features) {
if (feature && feature.ngInherit) {
((/** @type {?} */ (feature)))(definition);
}
}
}
}
else {
// Even if we don't have a definition, check the type for the hooks and use those if need be
/** @type {?} */
const superPrototype = superType.prototype;
if (superPrototype) {
definition.afterContentChecked =
definition.afterContentChecked || superPrototype.ngAfterContentChecked;
definition.afterContentInit =
definition.afterContentInit || superPrototype.ngAfterContentInit;
definition.afterViewChecked =
definition.afterViewChecked || superPrototype.ngAfterViewChecked;
definition.afterViewInit = definition.afterViewInit || superPrototype.ngAfterViewInit;
definition.doCheck = definition.doCheck || superPrototype.ngDoCheck;
definition.onDestroy = definition.onDestroy || superPrototype.ngOnDestroy;
definition.onInit = definition.onInit || superPrototype.ngOnInit;
if (superPrototype.ngOnChanges) {
ɵɵNgOnChangesFeature()(definition);
}
}
}
superType = Object.getPrototypeOf(superType);
}
}
/**
* @param {?} value
* @return {?}
*/
function maybeUnwrapEmpty(value) {
if (value === EMPTY_OBJ) {
return {};
}
else if (value === EMPTY_ARRAY) {
return [];
}
else {
return value;
}
}
/**
* @param {?} definition
* @param {?} superViewQuery
* @return {?}
*/
function inheritViewQuery(definition, superViewQuery) {
/** @type {?} */
const prevViewQuery = definition.viewQuery;
if (prevViewQuery) {
definition.viewQuery = (/**
* @param {?} rf
* @param {?} ctx
* @return {?}
*/
(rf, ctx) => {
superViewQuery(rf, ctx);
prevViewQuery(rf, ctx);
});
}
else {
definition.viewQuery = superViewQuery;
}
}
/**
* @param {?} definition
* @param {?} superContentQueries
* @return {?}
*/
function inheritContentQueries(definition, superContentQueries) {
/** @type {?} */
const prevContentQueries = definition.contentQueries;
if (prevContentQueries) {
definition.contentQueries = (/**
* @param {?} rf
* @param {?} ctx
* @param {?} directiveIndex
* @return {?}
*/
(rf, ctx, directiveIndex) => {
superContentQueries(rf, ctx, directiveIndex);
prevContentQueries(rf, ctx, directiveIndex);
});
}
else {
definition.contentQueries = superContentQueries;
}
}
/**
* @param {?} definition
* @param {?} superHostBindings
* @return {?}
*/
function inheritHostBindings(definition, superHostBindings) {
/** @type {?} */
const prevHostBindings = definition.hostBindings;
// If the subclass does not have a host bindings function, we set the subclass host binding
// function to be the superclass's (in this feature). We should check if they're the same here
// to ensure we don't inherit it twice.
if (superHostBindings !== prevHostBindings) {
if (prevHostBindings) {
// because inheritance is unknown during compile time, the runtime code
// needs to be informed of the super-class depth so that instruction code
// can distinguish one host bindings function from another. The reason why
// relying on the directive uniqueId exclusively is not enough is because the
// uniqueId value and the directive instance stay the same between hostBindings
// calls throughout the directive inheritance chain. This means that without
// a super-class depth value, there is no way to know whether a parent or
// sub-class host bindings function is currently being executed.
definition.hostBindings = (/**
* @param {?} rf
* @param {?} ctx
* @param {?} elementIndex
* @return {?}
*/
(rf, ctx, elementIndex) => {
// The reason why we increment first and then decrement is so that parent
// hostBindings calls have a higher id value compared to sub-class hostBindings
// calls (this way the leaf directive is always at a super-class depth of 0).
adjustActiveDirectiveSuperClassDepthPosition(1);
try {
superHostBindings(rf, ctx, elementIndex);
}
finally {
adjustActiveDirectiveSuperClassDepthPosition(-1);
}
prevHostBindings(rf, ctx, elementIndex);
});
}
else {
definition.hostBindings = superHostBindings;
}
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"inherit_definition_feature.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/features/inherit_definition_feature.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google Inc. 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 {Type} from '../../interface/type';\nimport {fillProperties} from '../../util/property';\nimport {EMPTY_ARRAY, EMPTY_OBJ} from '../empty';\nimport {ComponentDef, ContentQueriesFunction, DirectiveDef, DirectiveDefFeature, HostBindingsFunction, RenderFlags, ViewQueriesFunction} from '../interfaces/definition';\nimport {adjustActiveDirectiveSuperClassDepthPosition} from '../state';\nimport {isComponentDef} from '../util/view_utils';\n\nimport {ɵɵNgOnChangesFeature} from './ng_onchanges_feature';\n\nfunction getSuperType(type: Type<any>): Type<any>&\n    {ngComponentDef?: ComponentDef<any>, ngDirectiveDef?: DirectiveDef<any>} {\n  return Object.getPrototypeOf(type.prototype).constructor;\n}\n\n/**\n * Merges the definition from a super class to a sub class.\n * @param definition The definition that is a SubClass of another directive of component\n *\n * @codeGenApi\n */\nexport function ɵɵInheritDefinitionFeature(definition: DirectiveDef<any>| ComponentDef<any>): void {\n  let superType = getSuperType(definition.type);\n\n  while (superType) {\n    let superDef: DirectiveDef<any>|ComponentDef<any>|undefined = undefined;\n    if (isComponentDef(definition)) {\n      // Don't use getComponentDef/getDirectiveDef. This logic relies on inheritance.\n      superDef = superType.ngComponentDef || superType.ngDirectiveDef;\n    } else {\n      if (superType.ngComponentDef) {\n        throw new Error('Directives cannot inherit Components');\n      }\n      // Don't use getComponentDef/getDirectiveDef. This logic relies on inheritance.\n      superDef = superType.ngDirectiveDef;\n    }\n\n    const baseDef = (superType as any).ngBaseDef;\n\n    // Some fields in the definition may be empty, if there were no values to put in them that\n    // would've justified object creation. Unwrap them if necessary.\n    if (baseDef || superDef) {\n      const writeableDef = definition as any;\n      writeableDef.inputs = maybeUnwrapEmpty(definition.inputs);\n      writeableDef.declaredInputs = maybeUnwrapEmpty(definition.declaredInputs);\n      writeableDef.outputs = maybeUnwrapEmpty(definition.outputs);\n    }\n\n    if (baseDef) {\n      const baseViewQuery = baseDef.viewQuery;\n      const baseContentQueries = baseDef.contentQueries;\n      const baseHostBindings = baseDef.hostBindings;\n      baseHostBindings && inheritHostBindings(definition, baseHostBindings);\n      baseViewQuery && inheritViewQuery(definition, baseViewQuery);\n      baseContentQueries && inheritContentQueries(definition, baseContentQueries);\n      fillProperties(definition.inputs, baseDef.inputs);\n      fillProperties(definition.declaredInputs, baseDef.declaredInputs);\n      fillProperties(definition.outputs, baseDef.outputs);\n    }\n\n    if (superDef) {\n      // Merge hostBindings\n      const superHostBindings = superDef.hostBindings;\n      superHostBindings && inheritHostBindings(definition, superHostBindings);\n\n      // Merge queries\n      const superViewQuery = superDef.viewQuery;\n      const superContentQueries = superDef.contentQueries;\n      superViewQuery && inheritViewQuery(definition, superViewQuery);\n      superContentQueries && inheritContentQueries(definition, superContentQueries);\n\n      // Merge inputs and outputs\n      fillProperties(definition.inputs, superDef.inputs);\n      fillProperties(definition.declaredInputs, superDef.declaredInputs);\n      fillProperties(definition.outputs, superDef.outputs);\n\n      // Inherit hooks\n      // Assume super class inheritance feature has already run.\n      definition.afterContentChecked =\n          definition.afterContentChecked || superDef.afterContentChecked;\n      definition.afterContentInit = definition.afterContentInit || superDef.afterContentInit;\n      definition.afterViewChecked = definition.afterViewChecked || superDef.afterViewChecked;\n      definition.afterViewInit = definition.afterViewInit || superDef.afterViewInit;\n      definition.doCheck = definition.doCheck || superDef.doCheck;\n      definition.onDestroy = definition.onDestroy || superDef.onDestroy;\n      definition.onInit = definition.onInit || superDef.onInit;\n\n      // Run parent features\n      const features = superDef.features;\n      if (features) {\n        for (const feature of features) {\n          if (feature && feature.ngInherit) {\n            (feature as DirectiveDefFeature)(definition);\n          }\n        }\n      }\n    } else {\n      // Even if we don't have a definition, check the type for the hooks and use those if need be\n      const superPrototype = superType.prototype;\n      if (superPrototype) {\n        definition.afterContentChecked =\n            definition.afterContentChecked || superPrototype.ngAfterContentChecked;\n        definition.afterContentInit =\n            definition.afterContentInit || superPrototype.ngAfterContentInit;\n        definition.afterViewChecked =\n            definition.afterViewChecked || superPrototype.ngAfterViewChecked;\n        definition.afterViewInit = definition.afterViewInit || superPrototype.ngAfterViewInit;\n        definition.doCheck = definition.doCheck || superPrototype.ngDoCheck;\n        definition.onDestroy = definition.onDestroy || superPrototype.ngOnDestroy;\n        definition.onInit = definition.onInit || superPrototype.ngOnInit;\n\n        if (superPrototype.ngOnChanges) {\n          ɵɵNgOnChangesFeature()(definition);\n        }\n      }\n    }\n\n    superType = Object.getPrototypeOf(superType);\n  }\n}\n\nfunction maybeUnwrapEmpty<T>(value: T[]): T[];\nfunction maybeUnwrapEmpty<T>(value: T): T;\nfunction maybeUnwrapEmpty(value: any): any {\n  if (value === EMPTY_OBJ) {\n    return {};\n  } else if (value === EMPTY_ARRAY) {\n    return [];\n  } else {\n    return value;\n  }\n}\n\nfunction inheritViewQuery(\n    definition: DirectiveDef<any>| ComponentDef<any>, superViewQuery: ViewQueriesFunction<any>) {\n  const prevViewQuery = definition.viewQuery;\n\n  if (prevViewQuery) {\n    definition.viewQuery = (rf, ctx) => {\n      superViewQuery(rf, ctx);\n      prevViewQuery(rf, ctx);\n    };\n  } else {\n    definition.viewQuery = superViewQuery;\n  }\n}\n\nfunction inheritContentQueries(\n    definition: DirectiveDef<any>| ComponentDef<any>,\n    superContentQueries: ContentQueriesFunction<any>) {\n  const prevContentQueries = definition.contentQueries;\n\n  if (prevContentQueries) {\n    definition.contentQueries = (rf, ctx, directiveIndex) => {\n      superContentQueries(rf, ctx, directiveIndex);\n      prevContentQueries(rf, ctx, directiveIndex);\n    };\n  } else {\n    definition.contentQueries = superContentQueries;\n  }\n}\n\nfunction inheritHostBindings(\n    definition: DirectiveDef<any>| ComponentDef<any>,\n    superHostBindings: HostBindingsFunction<any>) {\n  const prevHostBindings = definition.hostBindings;\n  // If the subclass does not have a host bindings function, we set the subclass host binding\n  // function to be the superclass's (in this feature). We should check if they're the same here\n  // to ensure we don't inherit it twice.\n  if (superHostBindings !== prevHostBindings) {\n    if (prevHostBindings) {\n      // because inheritance is unknown during compile time, the runtime code\n      // needs to be informed of the super-class depth so that instruction code\n      // can distinguish one host bindings function from another. The reason why\n      // relying on the directive uniqueId exclusively is not enough is because the\n      // uniqueId value and the directive instance stay the same between hostBindings\n      // calls throughout the directive inheritance chain. This means that without\n      // a super-class depth value, there is no way to know whether a parent or\n      // sub-class host bindings function is currently being executed.\n      definition.hostBindings = (rf: RenderFlags, ctx: any, elementIndex: number) => {\n        // The reason why we increment first and then decrement is so that parent\n        // hostBindings calls have a higher id value compared to sub-class hostBindings\n        // calls (this way the leaf directive is always at a super-class depth of 0).\n        adjustActiveDirectiveSuperClassDepthPosition(1);\n        try {\n          superHostBindings(rf, ctx, elementIndex);\n        } finally {\n          adjustActiveDirectiveSuperClassDepthPosition(-1);\n        }\n        prevHostBindings(rf, ctx, elementIndex);\n      };\n    } else {\n      definition.hostBindings = superHostBindings;\n    }\n  }\n}\n"]}