@angular/core
Version:
Angular - the core framework
268 lines • 36.7 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 { flatten } from '../../util/array_utils';
import { getComponentDef, getNgModuleDef, isStandalone } from '../definition';
import { isComponent, isDirective, isNgModule, isPipe, verifyStandaloneImport } from '../jit/util';
import { maybeUnwrapFn } from '../util/misc_utils';
/**
* Indicates whether to use the runtime dependency tracker for scope calculation in JIT compilation.
* The value "false" means the old code path based on patching scope info into the types will be
* used.
*
* @deprecated For migration purposes only, to be removed soon.
*/
export const USE_RUNTIME_DEPS_TRACKER_FOR_JIT = true;
/**
* An implementation of DepsTrackerApi which will be used for JIT and local compilation.
*/
class DepsTracker {
constructor() {
this.ownerNgModule = new Map();
this.ngModulesWithSomeUnresolvedDecls = new Set();
this.ngModulesScopeCache = new Map();
this.standaloneComponentsScopeCache = new Map();
}
/**
* Attempts to resolve ng module's forward ref declarations as much as possible and add them to
* the `ownerNgModule` map. This method normally should be called after the initial parsing when
* all the forward refs are resolved (e.g., when trying to render a component)
*/
resolveNgModulesDecls() {
if (this.ngModulesWithSomeUnresolvedDecls.size === 0) {
return;
}
for (const moduleType of this.ngModulesWithSomeUnresolvedDecls) {
const def = getNgModuleDef(moduleType);
if (def?.declarations) {
for (const decl of maybeUnwrapFn(def.declarations)) {
if (isComponent(decl)) {
this.ownerNgModule.set(decl, moduleType);
}
}
}
}
this.ngModulesWithSomeUnresolvedDecls.clear();
}
/** @override */
getComponentDependencies(type, rawImports) {
this.resolveNgModulesDecls();
const def = getComponentDef(type);
if (def === null) {
throw new Error(`Attempting to get component dependencies for a type that is not a component: ${type}`);
}
if (def.standalone) {
const scope = this.getStandaloneComponentScope(type, rawImports);
if (scope.compilation.isPoisoned) {
return { dependencies: [] };
}
return {
dependencies: [
...scope.compilation.directives,
...scope.compilation.pipes,
...scope.compilation.ngModules,
]
};
}
else {
if (!this.ownerNgModule.has(type)) {
// This component is orphan! No need to handle the error since the component rendering
// pipeline (e.g., view_container_ref) will check for this error based on configs.
return { dependencies: [] };
}
const scope = this.getNgModuleScope(this.ownerNgModule.get(type));
if (scope.compilation.isPoisoned) {
return { dependencies: [] };
}
return {
dependencies: [
...scope.compilation.directives,
...scope.compilation.pipes,
],
};
}
}
/**
* @override
* This implementation does not make use of param scopeInfo since it assumes the scope info is
* already added to the type itself through methods like {@link ɵɵsetNgModuleScope}
*/
registerNgModule(type, scopeInfo) {
if (!isNgModule(type)) {
throw new Error(`Attempting to register a Type which is not NgModule as NgModule: ${type}`);
}
// Lazily process the NgModules later when needed.
this.ngModulesWithSomeUnresolvedDecls.add(type);
}
/** @override */
clearScopeCacheFor(type) {
this.ngModulesScopeCache.delete(type);
this.standaloneComponentsScopeCache.delete(type);
}
/** @override */
getNgModuleScope(type) {
if (this.ngModulesScopeCache.has(type)) {
return this.ngModulesScopeCache.get(type);
}
const scope = this.computeNgModuleScope(type);
this.ngModulesScopeCache.set(type, scope);
return scope;
}
/** Compute NgModule scope afresh. */
computeNgModuleScope(type) {
const def = getNgModuleDef(type, true);
const scope = {
exported: { directives: new Set(), pipes: new Set() },
compilation: { directives: new Set(), pipes: new Set() },
};
// Analyzing imports
for (const imported of maybeUnwrapFn(def.imports)) {
if (isNgModule(imported)) {
const importedScope = this.getNgModuleScope(imported);
// When this module imports another, the imported module's exported directives and pipes
// are added to the compilation scope of this module.
addSet(importedScope.exported.directives, scope.compilation.directives);
addSet(importedScope.exported.pipes, scope.compilation.pipes);
}
else if (isStandalone(imported)) {
if (isDirective(imported) || isComponent(imported)) {
scope.compilation.directives.add(imported);
}
else if (isPipe(imported)) {
scope.compilation.pipes.add(imported);
}
else {
// The standalone thing is neither a component nor a directive nor a pipe ... (what?)
throw new RuntimeError(1000 /* RuntimeErrorCode.RUNTIME_DEPS_INVALID_IMPORTED_TYPE */, 'The standalone imported type is neither a component nor a directive nor a pipe');
}
}
else {
// The import is neither a module nor a module-with-providers nor a standalone thing. This
// is going to be an error. So we short circuit.
scope.compilation.isPoisoned = true;
break;
}
}
// Analyzing declarations
if (!scope.compilation.isPoisoned) {
for (const decl of maybeUnwrapFn(def.declarations)) {
// Cannot declare another NgModule or a standalone thing
if (isNgModule(decl) || isStandalone(decl)) {
scope.compilation.isPoisoned = true;
break;
}
if (isPipe(decl)) {
scope.compilation.pipes.add(decl);
}
else {
// decl is either a directive or a component. The component may not yet have the ɵcmp due
// to async compilation.
scope.compilation.directives.add(decl);
}
}
}
// Analyzing exports
for (const exported of maybeUnwrapFn(def.exports)) {
if (isNgModule(exported)) {
// When this module exports another, the exported module's exported directives and pipes
// are added to both the compilation and exported scopes of this module.
const exportedScope = this.getNgModuleScope(exported);
// Based on the current logic there is no way to have poisoned exported scope. So no need to
// check for it.
addSet(exportedScope.exported.directives, scope.exported.directives);
addSet(exportedScope.exported.pipes, scope.exported.pipes);
// Some test toolings which run in JIT mode depend on this behavior that the exported scope
// should also be present in the compilation scope, even though AoT does not support this
// and it is also in odds with NgModule metadata definitions. Without this some tests in
// Google will fail.
addSet(exportedScope.exported.directives, scope.compilation.directives);
addSet(exportedScope.exported.pipes, scope.compilation.pipes);
}
else if (isPipe(exported)) {
scope.exported.pipes.add(exported);
}
else {
scope.exported.directives.add(exported);
}
}
return scope;
}
/** @override */
getStandaloneComponentScope(type, rawImports) {
if (this.standaloneComponentsScopeCache.has(type)) {
return this.standaloneComponentsScopeCache.get(type);
}
const ans = this.computeStandaloneComponentScope(type, rawImports);
this.standaloneComponentsScopeCache.set(type, ans);
return ans;
}
computeStandaloneComponentScope(type, rawImports) {
const ans = {
compilation: {
// Standalone components are always able to self-reference.
directives: new Set([type]),
pipes: new Set(),
ngModules: new Set(),
},
};
for (const rawImport of flatten(rawImports ?? [])) {
const imported = resolveForwardRef(rawImport);
try {
verifyStandaloneImport(imported, type);
}
catch (e) {
// Short-circuit if an import is not valid
ans.compilation.isPoisoned = true;
return ans;
}
if (isNgModule(imported)) {
ans.compilation.ngModules.add(imported);
const importedScope = this.getNgModuleScope(imported);
// Short-circuit if an imported NgModule has corrupted exported scope.
if (importedScope.exported.isPoisoned) {
ans.compilation.isPoisoned = true;
return ans;
}
addSet(importedScope.exported.directives, ans.compilation.directives);
addSet(importedScope.exported.pipes, ans.compilation.pipes);
}
else if (isPipe(imported)) {
ans.compilation.pipes.add(imported);
}
else if (isDirective(imported) || isComponent(imported)) {
ans.compilation.directives.add(imported);
}
else {
// The imported thing is not module/pipe/directive/component, so we error and short-circuit
// here
ans.compilation.isPoisoned = true;
return ans;
}
}
return ans;
}
/** @override */
isOrphanComponent(cmp) {
const def = getComponentDef(cmp);
if (!def || def.standalone) {
return false;
}
this.resolveNgModulesDecls();
return !this.ownerNgModule.has(cmp);
}
}
function addSet(sourceSet, targetSet) {
for (const m of sourceSet) {
targetSet.add(m);
}
}
/** The deps tracker to be used in the current Angular app in dev mode. */
export const depsTracker = new DepsTracker();
export const TEST_ONLY = { DepsTracker };
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"deps_tracker.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/deps_tracker/deps_tracker.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 */\n\nimport {resolveForwardRef} from '../../di';\nimport {RuntimeError, RuntimeErrorCode} from '../../errors';\nimport {Type} from '../../interface/type';\nimport {NgModuleType} from '../../metadata/ng_module_def';\nimport {flatten} from '../../util/array_utils';\nimport {getComponentDef, getNgModuleDef, isStandalone} from '../definition';\nimport {ComponentType, NgModuleScopeInfoFromDecorator, RawScopeInfoFromDecorator} from '../interfaces/definition';\nimport {isComponent, isDirective, isNgModule, isPipe, verifyStandaloneImport} from '../jit/util';\nimport {maybeUnwrapFn} from '../util/misc_utils';\n\nimport {ComponentDependencies, DepsTrackerApi, NgModuleScope, StandaloneComponentScope} from './api';\n\n/**\n * Indicates whether to use the runtime dependency tracker for scope calculation in JIT compilation.\n * The value \"false\" means the old code path based on patching scope info into the types will be\n * used.\n *\n * @deprecated For migration purposes only, to be removed soon.\n */\nexport const USE_RUNTIME_DEPS_TRACKER_FOR_JIT = true;\n\n/**\n * An implementation of DepsTrackerApi which will be used for JIT and local compilation.\n */\nclass DepsTracker implements DepsTrackerApi {\n  private ownerNgModule = new Map<ComponentType<any>, NgModuleType<any>>();\n  private ngModulesWithSomeUnresolvedDecls = new Set<NgModuleType<any>>();\n  private ngModulesScopeCache = new Map<NgModuleType<any>, NgModuleScope>();\n  private standaloneComponentsScopeCache = new Map<ComponentType<any>, StandaloneComponentScope>();\n\n  /**\n   * Attempts to resolve ng module's forward ref declarations as much as possible and add them to\n   * the `ownerNgModule` map. This method normally should be called after the initial parsing when\n   * all the forward refs are resolved (e.g., when trying to render a component)\n   */\n  private resolveNgModulesDecls(): void {\n    if (this.ngModulesWithSomeUnresolvedDecls.size === 0) {\n      return;\n    }\n\n    for (const moduleType of this.ngModulesWithSomeUnresolvedDecls) {\n      const def = getNgModuleDef(moduleType);\n      if (def?.declarations) {\n        for (const decl of maybeUnwrapFn(def.declarations)) {\n          if (isComponent(decl)) {\n            this.ownerNgModule.set(decl, moduleType);\n          }\n        }\n      }\n    }\n\n    this.ngModulesWithSomeUnresolvedDecls.clear();\n  }\n\n  /** @override */\n  getComponentDependencies(type: ComponentType<any>, rawImports?: RawScopeInfoFromDecorator[]):\n      ComponentDependencies {\n    this.resolveNgModulesDecls();\n\n    const def = getComponentDef(type);\n    if (def === null) {\n      throw new Error(\n          `Attempting to get component dependencies for a type that is not a component: ${type}`);\n    }\n\n    if (def.standalone) {\n      const scope = this.getStandaloneComponentScope(type, rawImports);\n\n      if (scope.compilation.isPoisoned) {\n        return {dependencies: []};\n      }\n\n      return {\n        dependencies: [\n          ...scope.compilation.directives,\n          ...scope.compilation.pipes,\n          ...scope.compilation.ngModules,\n        ]\n      };\n    } else {\n      if (!this.ownerNgModule.has(type)) {\n        // This component is orphan! No need to handle the error since the component rendering\n        // pipeline (e.g., view_container_ref) will check for this error based on configs.\n        return {dependencies: []};\n      }\n\n      const scope = this.getNgModuleScope(this.ownerNgModule.get(type)!);\n\n      if (scope.compilation.isPoisoned) {\n        return {dependencies: []};\n      }\n\n      return {\n        dependencies: [\n          ...scope.compilation.directives,\n          ...scope.compilation.pipes,\n        ],\n      };\n    }\n  }\n\n  /**\n   * @override\n   * This implementation does not make use of param scopeInfo since it assumes the scope info is\n   * already added to the type itself through methods like {@link ɵɵsetNgModuleScope}\n   */\n  registerNgModule(type: Type<any>, scopeInfo: NgModuleScopeInfoFromDecorator): void {\n    if (!isNgModule(type)) {\n      throw new Error(`Attempting to register a Type which is not NgModule as NgModule: ${type}`);\n    }\n\n    // Lazily process the NgModules later when needed.\n    this.ngModulesWithSomeUnresolvedDecls.add(type);\n  }\n\n  /** @override */\n  clearScopeCacheFor(type: Type<any>): void {\n    this.ngModulesScopeCache.delete(type as NgModuleType);\n    this.standaloneComponentsScopeCache.delete(type as ComponentType<any>);\n  }\n\n  /** @override */\n  getNgModuleScope(type: NgModuleType<any>): NgModuleScope {\n    if (this.ngModulesScopeCache.has(type)) {\n      return this.ngModulesScopeCache.get(type)!;\n    }\n\n    const scope = this.computeNgModuleScope(type);\n    this.ngModulesScopeCache.set(type, scope);\n\n    return scope;\n  }\n\n  /** Compute NgModule scope afresh. */\n  private computeNgModuleScope(type: NgModuleType<any>): NgModuleScope {\n    const def = getNgModuleDef(type, true);\n    const scope: NgModuleScope = {\n      exported: {directives: new Set(), pipes: new Set()},\n      compilation: {directives: new Set(), pipes: new Set()},\n    };\n\n    // Analyzing imports\n    for (const imported of maybeUnwrapFn(def.imports)) {\n      if (isNgModule(imported)) {\n        const importedScope = this.getNgModuleScope(imported);\n\n        // When this module imports another, the imported module's exported directives and pipes\n        // are added to the compilation scope of this module.\n        addSet(importedScope.exported.directives, scope.compilation.directives);\n        addSet(importedScope.exported.pipes, scope.compilation.pipes);\n      } else if (isStandalone(imported)) {\n        if (isDirective(imported) || isComponent(imported)) {\n          scope.compilation.directives.add(imported);\n        } else if (isPipe(imported)) {\n          scope.compilation.pipes.add(imported);\n        } else {\n          // The standalone thing is neither a component nor a directive nor a pipe ... (what?)\n          throw new RuntimeError(\n              RuntimeErrorCode.RUNTIME_DEPS_INVALID_IMPORTED_TYPE,\n              'The standalone imported type is neither a component nor a directive nor a pipe');\n        }\n      } else {\n        // The import is neither a module nor a module-with-providers nor a standalone thing. This\n        // is going to be an error. So we short circuit.\n        scope.compilation.isPoisoned = true;\n        break;\n      }\n    }\n\n    // Analyzing declarations\n    if (!scope.compilation.isPoisoned) {\n      for (const decl of maybeUnwrapFn(def.declarations)) {\n        // Cannot declare another NgModule or a standalone thing\n        if (isNgModule(decl) || isStandalone(decl)) {\n          scope.compilation.isPoisoned = true;\n          break;\n        }\n\n        if (isPipe(decl)) {\n          scope.compilation.pipes.add(decl);\n        } else {\n          // decl is either a directive or a component. The component may not yet have the ɵcmp due\n          // to async compilation.\n          scope.compilation.directives.add(decl);\n        }\n      }\n    }\n\n    // Analyzing exports\n    for (const exported of maybeUnwrapFn(def.exports)) {\n      if (isNgModule(exported)) {\n        // When this module exports another, the exported module's exported directives and pipes\n        // are added to both the compilation and exported scopes of this module.\n        const exportedScope = this.getNgModuleScope(exported);\n\n        // Based on the current logic there is no way to have poisoned exported scope. So no need to\n        // check for it.\n        addSet(exportedScope.exported.directives, scope.exported.directives);\n        addSet(exportedScope.exported.pipes, scope.exported.pipes);\n\n        // Some test toolings which run in JIT mode depend on this behavior that the exported scope\n        // should also be present in the compilation scope, even though AoT does not support this\n        // and it is also in odds with NgModule metadata definitions. Without this some tests in\n        // Google will fail.\n        addSet(exportedScope.exported.directives, scope.compilation.directives);\n        addSet(exportedScope.exported.pipes, scope.compilation.pipes);\n      } else if (isPipe(exported)) {\n        scope.exported.pipes.add(exported);\n      } else {\n        scope.exported.directives.add(exported);\n      }\n    }\n\n    return scope;\n  }\n\n  /** @override */\n  getStandaloneComponentScope(type: ComponentType<any>, rawImports?: RawScopeInfoFromDecorator[]):\n      StandaloneComponentScope {\n    if (this.standaloneComponentsScopeCache.has(type)) {\n      return this.standaloneComponentsScopeCache.get(type)!;\n    }\n\n    const ans = this.computeStandaloneComponentScope(type, rawImports);\n    this.standaloneComponentsScopeCache.set(type, ans);\n\n    return ans;\n  }\n\n  private computeStandaloneComponentScope(\n      type: ComponentType<any>,\n      rawImports?: RawScopeInfoFromDecorator[]): StandaloneComponentScope {\n    const ans: StandaloneComponentScope = {\n      compilation: {\n        // Standalone components are always able to self-reference.\n        directives: new Set([type]),\n        pipes: new Set(),\n        ngModules: new Set(),\n      },\n    };\n\n    for (const rawImport of flatten(rawImports ?? [])) {\n      const imported = resolveForwardRef(rawImport) as Type<any>;\n\n      try {\n        verifyStandaloneImport(imported, type);\n      } catch (e) {\n        // Short-circuit if an import is not valid\n        ans.compilation.isPoisoned = true;\n        return ans;\n      }\n\n      if (isNgModule(imported)) {\n        ans.compilation.ngModules.add(imported);\n        const importedScope = this.getNgModuleScope(imported);\n\n        // Short-circuit if an imported NgModule has corrupted exported scope.\n        if (importedScope.exported.isPoisoned) {\n          ans.compilation.isPoisoned = true;\n          return ans;\n        }\n\n        addSet(importedScope.exported.directives, ans.compilation.directives);\n        addSet(importedScope.exported.pipes, ans.compilation.pipes);\n      } else if (isPipe(imported)) {\n        ans.compilation.pipes.add(imported);\n      } else if (isDirective(imported) || isComponent(imported)) {\n        ans.compilation.directives.add(imported);\n      } else {\n        // The imported thing is not module/pipe/directive/component, so we error and short-circuit\n        // here\n        ans.compilation.isPoisoned = true;\n        return ans;\n      }\n    }\n\n    return ans;\n  }\n\n  /** @override */\n  isOrphanComponent(cmp: Type<any>): boolean {\n    const def = getComponentDef(cmp);\n\n    if (!def || def.standalone) {\n      return false;\n    }\n\n    this.resolveNgModulesDecls();\n\n    return !this.ownerNgModule.has(cmp as ComponentType<any>);\n  }\n}\n\nfunction addSet<T>(sourceSet: Set<T>, targetSet: Set<T>): void {\n  for (const m of sourceSet) {\n    targetSet.add(m);\n  }\n}\n\n/** The deps tracker to be used in the current Angular app in dev mode. */\nexport const depsTracker = new DepsTracker();\n\nexport const TEST_ONLY = {DepsTracker};\n"]}