| /** |
| * @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 (factory) { |
| if (typeof module === "object" && typeof module.exports === "object") { |
| var v = factory(require, exports); |
| if (v !== undefined) module.exports = v; |
| } |
| else if (typeof define === "function" && define.amd) { |
| define("@angular/core/schematics/migrations/static-queries/strategies/usage_strategy/usage_strategy", ["require", "exports", "typescript", "@angular/core/schematics/utils/parse_html", "@angular/core/schematics/utils/typescript/property_name", "@angular/core/schematics/migrations/static-queries/angular/query-definition", "@angular/core/schematics/migrations/static-queries/strategies/usage_strategy/declaration_usage_visitor", "@angular/core/schematics/migrations/static-queries/strategies/usage_strategy/super_class_context", "@angular/core/schematics/migrations/static-queries/strategies/usage_strategy/template_usage_visitor"], factory); |
| } |
| })(function (require, exports) { |
| "use strict"; |
| Object.defineProperty(exports, "__esModule", { value: true }); |
| exports.QueryUsageStrategy = void 0; |
| const ts = require("typescript"); |
| const parse_html_1 = require("@angular/core/schematics/utils/parse_html"); |
| const property_name_1 = require("@angular/core/schematics/utils/typescript/property_name"); |
| const query_definition_1 = require("@angular/core/schematics/migrations/static-queries/angular/query-definition"); |
| const declaration_usage_visitor_1 = require("@angular/core/schematics/migrations/static-queries/strategies/usage_strategy/declaration_usage_visitor"); |
| const super_class_context_1 = require("@angular/core/schematics/migrations/static-queries/strategies/usage_strategy/super_class_context"); |
| const template_usage_visitor_1 = require("@angular/core/schematics/migrations/static-queries/strategies/usage_strategy/template_usage_visitor"); |
| /** |
| * Object that maps a given type of query to a list of lifecycle hooks that |
| * could be used to access such a query statically. |
| */ |
| const STATIC_QUERY_LIFECYCLE_HOOKS = { |
| [query_definition_1.QueryType.ViewChild]: ['ngOnChanges', 'ngOnInit', 'ngDoCheck', 'ngAfterContentInit', 'ngAfterContentChecked'], |
| [query_definition_1.QueryType.ContentChild]: ['ngOnChanges', 'ngOnInit', 'ngDoCheck'], |
| }; |
| /** |
| * Query timing strategy that determines the timing of a given query by inspecting how |
| * the query is accessed within the project's TypeScript source files. Read more about |
| * this strategy here: https://hackmd.io/s/Hymvc2OKE |
| */ |
| class QueryUsageStrategy { |
| constructor(classMetadata, typeChecker) { |
| this.classMetadata = classMetadata; |
| this.typeChecker = typeChecker; |
| } |
| setup() { } |
| /** |
| * Analyzes the usage of the given query and determines the query timing based |
| * on the current usage of the query. |
| */ |
| detectTiming(query) { |
| if (query.property === null) { |
| return { timing: null, message: 'Queries defined on accessors cannot be analyzed.' }; |
| } |
| const usage = this.analyzeQueryUsage(query.container, query, []); |
| if (usage === declaration_usage_visitor_1.ResolvedUsage.AMBIGUOUS) { |
| return { |
| timing: query_definition_1.QueryTiming.STATIC, |
| message: 'Query timing is ambiguous. Please check if the query can be marked as dynamic.' |
| }; |
| } |
| else if (usage === declaration_usage_visitor_1.ResolvedUsage.SYNCHRONOUS) { |
| return { timing: query_definition_1.QueryTiming.STATIC }; |
| } |
| else { |
| return { timing: query_definition_1.QueryTiming.DYNAMIC }; |
| } |
| } |
| /** |
| * Checks whether a given query is used statically within the given class, its super |
| * class or derived classes. |
| */ |
| analyzeQueryUsage(classDecl, query, knownInputNames, functionCtx = new Map(), visitInheritedClasses = true) { |
| const usageVisitor = new declaration_usage_visitor_1.DeclarationUsageVisitor(query.property, this.typeChecker, functionCtx); |
| const classMetadata = this.classMetadata.get(classDecl); |
| let usage = declaration_usage_visitor_1.ResolvedUsage.ASYNCHRONOUS; |
| // In case there is metadata for the current class, we collect all resolved Angular input |
| // names and add them to the list of known inputs that need to be checked for usages of |
| // the current query. e.g. queries used in an @Input() *setter* are always static. |
| if (classMetadata) { |
| knownInputNames.push(...classMetadata.ngInputNames); |
| } |
| // Array of TypeScript nodes which can contain usages of the given query in |
| // order to access it statically. |
| const possibleStaticQueryNodes = filterQueryClassMemberNodes(classDecl, query, knownInputNames); |
| // In case nodes that can possibly access a query statically have been found, check |
| // if the query declaration is synchronously used within any of these nodes. |
| if (possibleStaticQueryNodes.length) { |
| possibleStaticQueryNodes.forEach(n => usage = combineResolvedUsage(usage, usageVisitor.getResolvedNodeUsage(n))); |
| } |
| if (!classMetadata) { |
| return usage; |
| } |
| // In case there is a component template for the current class, we check if the |
| // template statically accesses the current query. In case that's true, the query |
| // can be marked as static. |
| if (classMetadata.template && property_name_1.hasPropertyNameText(query.property.name)) { |
| const template = classMetadata.template; |
| const parsedHtml = parse_html_1.parseHtmlGracefully(template.content, template.filePath); |
| const htmlVisitor = new template_usage_visitor_1.TemplateUsageVisitor(query.property.name.text); |
| if (parsedHtml && htmlVisitor.isQueryUsedStatically(parsedHtml)) { |
| return declaration_usage_visitor_1.ResolvedUsage.SYNCHRONOUS; |
| } |
| } |
| // In case derived classes should also be analyzed, we determine the classes that derive |
| // from the current class and check if these have input setters or lifecycle hooks that |
| // use the query statically. |
| if (visitInheritedClasses) { |
| classMetadata.derivedClasses.forEach(derivedClass => { |
| usage = combineResolvedUsage(usage, this.analyzeQueryUsage(derivedClass, query, knownInputNames)); |
| }); |
| } |
| // In case the current class has a super class, we determine declared abstract function-like |
| // declarations in the super-class that are implemented in the current class. The super class |
| // will then be analyzed with the abstract declarations mapped to the implemented TypeScript |
| // nodes. This allows us to handle queries which are used in super classes through derived |
| // abstract method declarations. |
| if (classMetadata.superClass) { |
| const superClassDecl = classMetadata.superClass; |
| // Update the function context to map abstract declaration nodes to their implementation |
| // node in the base class. This ensures that the declaration usage visitor can analyze |
| // abstract class member declarations. |
| super_class_context_1.updateSuperClassAbstractMembersContext(classDecl, functionCtx, this.classMetadata); |
| usage = combineResolvedUsage(usage, this.analyzeQueryUsage(superClassDecl, query, [], functionCtx, false)); |
| } |
| return usage; |
| } |
| } |
| exports.QueryUsageStrategy = QueryUsageStrategy; |
| /** |
| * Combines two resolved usages based on a fixed priority. "Synchronous" takes |
| * precedence over "Ambiguous" whereas ambiguous takes precedence over "Asynchronous". |
| */ |
| function combineResolvedUsage(base, target) { |
| if (base === declaration_usage_visitor_1.ResolvedUsage.SYNCHRONOUS) { |
| return base; |
| } |
| else if (target !== declaration_usage_visitor_1.ResolvedUsage.ASYNCHRONOUS) { |
| return target; |
| } |
| else { |
| return declaration_usage_visitor_1.ResolvedUsage.ASYNCHRONOUS; |
| } |
| } |
| /** |
| * Filters all class members from the class declaration that can access the |
| * given query statically (e.g. ngOnInit lifecycle hook or @Input setters) |
| */ |
| function filterQueryClassMemberNodes(classDecl, query, knownInputNames) { |
| // Returns an array of TypeScript nodes which can contain usages of the given query |
| // in order to access it statically. e.g. |
| // (1) queries used in the "ngOnInit" lifecycle hook are static. |
| // (2) inputs with setters can access queries statically. |
| return classDecl.members |
| .filter((m) => { |
| if (ts.isMethodDeclaration(m) && m.body && property_name_1.hasPropertyNameText(m.name) && |
| STATIC_QUERY_LIFECYCLE_HOOKS[query.type].indexOf(m.name.text) !== -1) { |
| return true; |
| } |
| else if (knownInputNames && ts.isSetAccessor(m) && m.body && |
| property_name_1.hasPropertyNameText(m.name) && knownInputNames.indexOf(m.name.text) !== -1) { |
| return true; |
| } |
| return false; |
| }) |
| .map(member => member.body); |
| } |
| }); |
| //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"usage_strategy.js","sourceRoot":"","sources":["../../../../../../../../../../packages/core/schematics/migrations/static-queries/strategies/usage_strategy/usage_strategy.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 * as ts from 'typescript';\n\nimport {parseHtmlGracefully} from '../../../../utils/parse_html';\nimport {hasPropertyNameText} from '../../../../utils/typescript/property_name';\nimport {ClassMetadataMap} from '../../angular/ng_query_visitor';\nimport {NgQueryDefinition, QueryTiming, QueryType} from '../../angular/query-definition';\nimport {TimingResult, TimingStrategy} from '../timing-strategy';\n\nimport {DeclarationUsageVisitor, FunctionContext, ResolvedUsage} from './declaration_usage_visitor';\nimport {updateSuperClassAbstractMembersContext} from './super_class_context';\nimport {TemplateUsageVisitor} from './template_usage_visitor';\n\n\n/**\n * Object that maps a given type of query to a list of lifecycle hooks that\n * could be used to access such a query statically.\n */\nconst STATIC_QUERY_LIFECYCLE_HOOKS = {\n  [QueryType.ViewChild]:\n      ['ngOnChanges', 'ngOnInit', 'ngDoCheck', 'ngAfterContentInit', 'ngAfterContentChecked'],\n  [QueryType.ContentChild]: ['ngOnChanges', 'ngOnInit', 'ngDoCheck'],\n};\n\n/**\n * Query timing strategy that determines the timing of a given query by inspecting how\n * the query is accessed within the project's TypeScript source files. Read more about\n * this strategy here: https://hackmd.io/s/Hymvc2OKE\n */\nexport class QueryUsageStrategy implements TimingStrategy {\n  constructor(private classMetadata: ClassMetadataMap, private typeChecker: ts.TypeChecker) {}\n\n  setup() {}\n\n  /**\n   * Analyzes the usage of the given query and determines the query timing based\n   * on the current usage of the query.\n   */\n  detectTiming(query: NgQueryDefinition): TimingResult {\n    if (query.property === null) {\n      return {timing: null, message: 'Queries defined on accessors cannot be analyzed.'};\n    }\n\n    const usage = this.analyzeQueryUsage(query.container, query, []);\n\n    if (usage === ResolvedUsage.AMBIGUOUS) {\n      return {\n        timing: QueryTiming.STATIC,\n        message: 'Query timing is ambiguous. Please check if the query can be marked as dynamic.'\n      };\n    } else if (usage === ResolvedUsage.SYNCHRONOUS) {\n      return {timing: QueryTiming.STATIC};\n    } else {\n      return {timing: QueryTiming.DYNAMIC};\n    }\n  }\n\n  /**\n   * Checks whether a given query is used statically within the given class, its super\n   * class or derived classes.\n   */\n  private analyzeQueryUsage(\n      classDecl: ts.ClassDeclaration, query: NgQueryDefinition, knownInputNames: string[],\n      functionCtx: FunctionContext = new Map(), visitInheritedClasses = true): ResolvedUsage {\n    const usageVisitor =\n        new DeclarationUsageVisitor(query.property!, this.typeChecker, functionCtx);\n    const classMetadata = this.classMetadata.get(classDecl);\n    let usage: ResolvedUsage = ResolvedUsage.ASYNCHRONOUS;\n\n    // In case there is metadata for the current class, we collect all resolved Angular input\n    // names and add them to the list of known inputs that need to be checked for usages of\n    // the current query. e.g. queries used in an @Input() *setter* are always static.\n    if (classMetadata) {\n      knownInputNames.push(...classMetadata.ngInputNames);\n    }\n\n    // Array of TypeScript nodes which can contain usages of the given query in\n    // order to access it statically.\n    const possibleStaticQueryNodes = filterQueryClassMemberNodes(classDecl, query, knownInputNames);\n\n    // In case nodes that can possibly access a query statically have been found, check\n    // if the query declaration is synchronously used within any of these nodes.\n    if (possibleStaticQueryNodes.length) {\n      possibleStaticQueryNodes.forEach(\n          n => usage = combineResolvedUsage(usage, usageVisitor.getResolvedNodeUsage(n)));\n    }\n\n    if (!classMetadata) {\n      return usage;\n    }\n\n    // In case there is a component template for the current class, we check if the\n    // template statically accesses the current query. In case that's true, the query\n    // can be marked as static.\n    if (classMetadata.template && hasPropertyNameText(query.property!.name)) {\n      const template = classMetadata.template;\n      const parsedHtml = parseHtmlGracefully(template.content, template.filePath);\n      const htmlVisitor = new TemplateUsageVisitor(query.property!.name.text);\n\n      if (parsedHtml && htmlVisitor.isQueryUsedStatically(parsedHtml)) {\n        return ResolvedUsage.SYNCHRONOUS;\n      }\n    }\n\n    // In case derived classes should also be analyzed, we determine the classes that derive\n    // from the current class and check if these have input setters or lifecycle hooks that\n    // use the query statically.\n    if (visitInheritedClasses) {\n      classMetadata.derivedClasses.forEach(derivedClass => {\n        usage = combineResolvedUsage(\n            usage, this.analyzeQueryUsage(derivedClass, query, knownInputNames));\n      });\n    }\n\n    // In case the current class has a super class, we determine declared abstract function-like\n    // declarations in the super-class that are implemented in the current class. The super class\n    // will then be analyzed with the abstract declarations mapped to the implemented TypeScript\n    // nodes. This allows us to handle queries which are used in super classes through derived\n    // abstract method declarations.\n    if (classMetadata.superClass) {\n      const superClassDecl = classMetadata.superClass;\n\n      // Update the function context to map abstract declaration nodes to their implementation\n      // node in the base class. This ensures that the declaration usage visitor can analyze\n      // abstract class member declarations.\n      updateSuperClassAbstractMembersContext(classDecl, functionCtx, this.classMetadata);\n\n      usage = combineResolvedUsage(\n          usage, this.analyzeQueryUsage(superClassDecl, query, [], functionCtx, false));\n    }\n\n    return usage;\n  }\n}\n\n/**\n * Combines two resolved usages based on a fixed priority. \"Synchronous\" takes\n * precedence over \"Ambiguous\" whereas ambiguous takes precedence over \"Asynchronous\".\n */\nfunction combineResolvedUsage(base: ResolvedUsage, target: ResolvedUsage): ResolvedUsage {\n  if (base === ResolvedUsage.SYNCHRONOUS) {\n    return base;\n  } else if (target !== ResolvedUsage.ASYNCHRONOUS) {\n    return target;\n  } else {\n    return ResolvedUsage.ASYNCHRONOUS;\n  }\n}\n\n/**\n * Filters all class members from the class declaration that can access the\n * given query statically (e.g. ngOnInit lifecycle hook or @Input setters)\n */\nfunction filterQueryClassMemberNodes(\n    classDecl: ts.ClassDeclaration, query: NgQueryDefinition,\n    knownInputNames: string[]): ts.Block[] {\n  // Returns an array of TypeScript nodes which can contain usages of the given query\n  // in order to access it statically. e.g.\n  //  (1) queries used in the \"ngOnInit\" lifecycle hook are static.\n  //  (2) inputs with setters can access queries statically.\n  return classDecl.members\n      .filter(\n          (m):\n              m is(ts.SetAccessorDeclaration | ts.MethodDeclaration) => {\n                if (ts.isMethodDeclaration(m) && m.body && hasPropertyNameText(m.name) &&\n                    STATIC_QUERY_LIFECYCLE_HOOKS[query.type].indexOf(m.name.text) !== -1) {\n                  return true;\n                } else if (\n                    knownInputNames && ts.isSetAccessor(m) && m.body &&\n                    hasPropertyNameText(m.name) && knownInputNames.indexOf(m.name.text) !== -1) {\n                  return true;\n                }\n                return false;\n              })\n      .map(member => member.body!);\n}\n"]} |
