node_modules/@angular/core/schematics/migrations/static-queries/strategies/template_strategy/template_strategy.js

/**
 * @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
 */
(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/template_strategy/template_strategy", ["require", "exports", "@angular/compiler", "@angular/compiler-cli", "path", "typescript", "@angular/core/schematics/migrations/static-queries/angular/query-definition"], factory);
    }
})(function (require, exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    const compiler_1 = require("@angular/compiler");
    const compiler_cli_1 = require("@angular/compiler-cli");
    const path_1 = require("path");
    const ts = require("typescript");
    const query_definition_1 = require("@angular/core/schematics/migrations/static-queries/angular/query-definition");
    const QUERY_NOT_DECLARED_IN_COMPONENT_MESSAGE = 'Timing could not be determined. This happens ' +
        'if the query is not declared in any component.';
    class QueryTemplateStrategy {
        constructor(projectPath, classMetadata, host) {
            this.projectPath = projectPath;
            this.classMetadata = classMetadata;
            this.host = host;
            this.compiler = null;
            this.metadataResolver = null;
            this.analyzedQueries = new Map();
        }
        /**
         * Sets up the template strategy by creating the AngularCompilerProgram. Returns false if
         * the AOT compiler program could not be created due to failure diagnostics.
         */
        setup() {
            const { rootNames, options } = compiler_cli_1.readConfiguration(this.projectPath);
            const aotProgram = compiler_cli_1.createProgram({ rootNames, options, host: this.host });
            // The "AngularCompilerProgram" does not expose the "AotCompiler" instance, nor does it
            // expose the logic that is necessary to analyze the determined modules. We work around
            // this by just accessing the necessary private properties using the bracket notation.
            this.compiler = aotProgram['compiler'];
            this.metadataResolver = this.compiler['_metadataResolver'];
            // Modify the "DirectiveNormalizer" to not normalize any referenced external stylesheets.
            // This is necessary because in CLI projects preprocessor files are commonly referenced
            // and we don't want to parse them in order to extract relative style references. This
            // breaks the analysis of the project because we instantiate a standalone AOT compiler
            // program which does not contain the custom logic by the Angular CLI Webpack compiler plugin.
            const directiveNormalizer = this.metadataResolver['_directiveNormalizer'];
            directiveNormalizer['_normalizeStylesheet'] = function (metadata) {
                return new compiler_1.CompileStylesheetMetadata({ styles: metadata.styles, styleUrls: [], moduleUrl: metadata.moduleUrl });
            };
            // Retrieves the analyzed modules of the current program. This data can be
            // used to determine the timing for registered queries.
            const analyzedModules = aotProgram['analyzedModules'];
            const ngStructuralDiagnostics = aotProgram.getNgStructuralDiagnostics();
            if (ngStructuralDiagnostics.length) {
                throw this._createDiagnosticsError(ngStructuralDiagnostics);
            }
            analyzedModules.files.forEach(file => {
                file.directives.forEach(directive => this._analyzeDirective(directive, analyzedModules));
            });
        }
        /** Analyzes a given directive by determining the timing of all matched view queries. */
        _analyzeDirective(symbol, analyzedModules) {
            const metadata = this.metadataResolver.getDirectiveMetadata(symbol);
            const ngModule = analyzedModules.ngModuleByPipeOrDirective.get(symbol);
            if (!metadata.isComponent || !ngModule) {
                return;
            }
            const parsedTemplate = this._parseTemplate(metadata, ngModule);
            const queryTimingMap = compiler_1.findStaticQueryIds(parsedTemplate);
            const { staticQueryIds } = compiler_1.staticViewQueryIds(queryTimingMap);
            metadata.viewQueries.forEach((query, index) => {
                // Query ids are computed by adding "one" to the index. This is done within
                // the "view_compiler.ts" in order to support using a bloom filter for queries.
                const queryId = index + 1;
                const queryKey = this._getViewQueryUniqueKey(symbol.filePath, symbol.name, query.propertyName);
                this.analyzedQueries.set(queryKey, staticQueryIds.has(queryId) ? query_definition_1.QueryTiming.STATIC : query_definition_1.QueryTiming.DYNAMIC);
            });
        }
        /** Detects the timing of the query definition. */
        detectTiming(query) {
            if (query.type === query_definition_1.QueryType.ContentChild) {
                return { timing: null, message: 'Content queries cannot be migrated automatically.' };
            }
            else if (!query.name) {
                // In case the query property name is not statically analyzable, we mark this
                // query as unresolved. NGC currently skips these view queries as well.
                return { timing: null, message: 'Query is not statically analyzable.' };
            }
            const propertyName = query.name;
            const classMetadata = this.classMetadata.get(query.container);
            // In case there is no class metadata or there are no derived classes that
            // could access the current query, we just look for the query analysis of
            // the class that declares the query. e.g. only the template of the class
            // that declares the view query affects the query timing.
            if (!classMetadata || !classMetadata.derivedClasses.length) {
                const timing = this._getQueryTimingFromClass(query.container, propertyName);
                if (timing === null) {
                    return { timing: null, message: QUERY_NOT_DECLARED_IN_COMPONENT_MESSAGE };
                }
                return { timing };
            }
            let resolvedTiming = null;
            let timingMismatch = false;
            // In case there are multiple components that use the same query (e.g. through inheritance),
            // we need to check if all components use the query with the same timing. If that is not
            // the case, the query timing is ambiguous and the developer needs to fix the query manually.
            [query.container, ...classMetadata.derivedClasses].forEach(classDecl => {
                const classTiming = this._getQueryTimingFromClass(classDecl, propertyName);
                if (classTiming === null) {
                    return;
                }
                // In case there is no resolved timing yet, save the new timing. Timings from other
                // components that use the query with a different timing, cause the timing to be
                // mismatched. In that case we can't detect a working timing for all components.
                if (resolvedTiming === null) {
                    resolvedTiming = classTiming;
                }
                else if (resolvedTiming !== classTiming) {
                    timingMismatch = true;
                }
            });
            if (resolvedTiming === null) {
                return { timing: query_definition_1.QueryTiming.DYNAMIC, message: QUERY_NOT_DECLARED_IN_COMPONENT_MESSAGE };
            }
            else if (timingMismatch) {
                return { timing: null, message: 'Multiple components use the query with different timings.' };
            }
            return { timing: resolvedTiming };
        }
        /**
         * Gets the timing that has been resolved for a given query when it's used within the
         * specified class declaration. e.g. queries from an inherited class can be used.
         */
        _getQueryTimingFromClass(classDecl, queryName) {
            if (!classDecl.name) {
                return null;
            }
            const filePath = classDecl.getSourceFile().fileName;
            const queryKey = this._getViewQueryUniqueKey(filePath, classDecl.name.text, queryName);
            if (this.analyzedQueries.has(queryKey)) {
                return this.analyzedQueries.get(queryKey);
            }
            return null;
        }
        _parseTemplate(component, ngModule) {
            return this
                .compiler['_parseTemplate'](component, ngModule, ngModule.transitiveModule.directives)
                .template;
        }
        _createDiagnosticsError(diagnostics) {
            return new Error(ts.formatDiagnostics(diagnostics, this.host));
        }
        _getViewQueryUniqueKey(filePath, className, propName) {
            return `${path_1.resolve(filePath)}#${className}-${propName}`;
        }
    }
    exports.QueryTemplateStrategy = QueryTemplateStrategy;
});
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"template_strategy.js","sourceRoot":"","sources":["../../../../../../../../../../packages/core/schematics/migrations/static-queries/strategies/template_strategy/template_strategy.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 {AotCompiler, CompileDirectiveMetadata, CompileMetadataResolver, CompileNgModuleMetadata, CompileStylesheetMetadata, NgAnalyzedModules, StaticSymbol, TemplateAst, findStaticQueryIds, staticViewQueryIds} from '@angular/compiler';\nimport {Diagnostic, createProgram, readConfiguration} from '@angular/compiler-cli';\nimport {resolve} from 'path';\nimport * as ts from 'typescript';\n\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\nconst QUERY_NOT_DECLARED_IN_COMPONENT_MESSAGE = 'Timing could not be determined. This happens ' +\n    'if the query is not declared in any component.';\n\nexport class QueryTemplateStrategy implements TimingStrategy {\n  private compiler: AotCompiler|null = null;\n  private metadataResolver: CompileMetadataResolver|null = null;\n  private analyzedQueries = new Map<string, QueryTiming>();\n\n  constructor(\n      private projectPath: string, private classMetadata: ClassMetadataMap,\n      private host: ts.CompilerHost) {}\n\n  /**\n   * Sets up the template strategy by creating the AngularCompilerProgram. Returns false if\n   * the AOT compiler program could not be created due to failure diagnostics.\n   */\n  setup() {\n    const {rootNames, options} = readConfiguration(this.projectPath);\n    const aotProgram = createProgram({rootNames, options, host: this.host});\n\n    // The \"AngularCompilerProgram\" does not expose the \"AotCompiler\" instance, nor does it\n    // expose the logic that is necessary to analyze the determined modules. We work around\n    // this by just accessing the necessary private properties using the bracket notation.\n    this.compiler = (aotProgram as any)['compiler'];\n    this.metadataResolver = this.compiler !['_metadataResolver'];\n\n    // Modify the \"DirectiveNormalizer\" to not normalize any referenced external stylesheets.\n    // This is necessary because in CLI projects preprocessor files are commonly referenced\n    // and we don't want to parse them in order to extract relative style references. This\n    // breaks the analysis of the project because we instantiate a standalone AOT compiler\n    // program which does not contain the custom logic by the Angular CLI Webpack compiler plugin.\n    const directiveNormalizer = this.metadataResolver !['_directiveNormalizer'];\n    directiveNormalizer['_normalizeStylesheet'] = function(metadata: CompileStylesheetMetadata) {\n      return new CompileStylesheetMetadata(\n          {styles: metadata.styles, styleUrls: [], moduleUrl: metadata.moduleUrl !});\n    };\n\n    // Retrieves the analyzed modules of the current program. This data can be\n    // used to determine the timing for registered queries.\n    const analyzedModules = (aotProgram as any)['analyzedModules'] as NgAnalyzedModules;\n\n    const ngStructuralDiagnostics = aotProgram.getNgStructuralDiagnostics();\n    if (ngStructuralDiagnostics.length) {\n      throw this._createDiagnosticsError(ngStructuralDiagnostics);\n    }\n\n    analyzedModules.files.forEach(file => {\n      file.directives.forEach(directive => this._analyzeDirective(directive, analyzedModules));\n    });\n  }\n\n  /** Analyzes a given directive by determining the timing of all matched view queries. */\n  private _analyzeDirective(symbol: StaticSymbol, analyzedModules: NgAnalyzedModules) {\n    const metadata = this.metadataResolver !.getDirectiveMetadata(symbol);\n    const ngModule = analyzedModules.ngModuleByPipeOrDirective.get(symbol);\n\n    if (!metadata.isComponent || !ngModule) {\n      return;\n    }\n\n    const parsedTemplate = this._parseTemplate(metadata, ngModule);\n    const queryTimingMap = findStaticQueryIds(parsedTemplate);\n    const {staticQueryIds} = staticViewQueryIds(queryTimingMap);\n\n    metadata.viewQueries.forEach((query, index) => {\n      // Query ids are computed by adding \"one\" to the index. This is done within\n      // the \"view_compiler.ts\" in order to support using a bloom filter for queries.\n      const queryId = index + 1;\n      const queryKey =\n          this._getViewQueryUniqueKey(symbol.filePath, symbol.name, query.propertyName);\n      this.analyzedQueries.set(\n          queryKey, staticQueryIds.has(queryId) ? QueryTiming.STATIC : QueryTiming.DYNAMIC);\n    });\n  }\n\n  /** Detects the timing of the query definition. */\n  detectTiming(query: NgQueryDefinition): TimingResult {\n    if (query.type === QueryType.ContentChild) {\n      return {timing: null, message: 'Content queries cannot be migrated automatically.'};\n    } else if (!query.name) {\n      // In case the query property name is not statically analyzable, we mark this\n      // query as unresolved. NGC currently skips these view queries as well.\n      return {timing: null, message: 'Query is not statically analyzable.'};\n    }\n\n    const propertyName = query.name;\n    const classMetadata = this.classMetadata.get(query.container);\n\n    // In case there is no class metadata or there are no derived classes that\n    // could access the current query, we just look for the query analysis of\n    // the class that declares the query. e.g. only the template of the class\n    // that declares the view query affects the query timing.\n    if (!classMetadata || !classMetadata.derivedClasses.length) {\n      const timing = this._getQueryTimingFromClass(query.container, propertyName);\n\n      if (timing === null) {\n        return {timing: null, message: QUERY_NOT_DECLARED_IN_COMPONENT_MESSAGE};\n      }\n\n      return {timing};\n    }\n\n    let resolvedTiming: QueryTiming|null = null;\n    let timingMismatch = false;\n\n    // In case there are multiple components that use the same query (e.g. through inheritance),\n    // we need to check if all components use the query with the same timing. If that is not\n    // the case, the query timing is ambiguous and the developer needs to fix the query manually.\n    [query.container, ...classMetadata.derivedClasses].forEach(classDecl => {\n      const classTiming = this._getQueryTimingFromClass(classDecl, propertyName);\n\n      if (classTiming === null) {\n        return;\n      }\n\n      // In case there is no resolved timing yet, save the new timing. Timings from other\n      // components that use the query with a different timing, cause the timing to be\n      // mismatched. In that case we can't detect a working timing for all components.\n      if (resolvedTiming === null) {\n        resolvedTiming = classTiming;\n      } else if (resolvedTiming !== classTiming) {\n        timingMismatch = true;\n      }\n    });\n\n    if (resolvedTiming === null) {\n      return {timing: QueryTiming.DYNAMIC, message: QUERY_NOT_DECLARED_IN_COMPONENT_MESSAGE};\n    } else if (timingMismatch) {\n      return {timing: null, message: 'Multiple components use the query with different timings.'};\n    }\n    return {timing: resolvedTiming};\n  }\n\n  /**\n   * Gets the timing that has been resolved for a given query when it's used within the\n   * specified class declaration. e.g. queries from an inherited class can be used.\n   */\n  private _getQueryTimingFromClass(classDecl: ts.ClassDeclaration, queryName: string): QueryTiming\n      |null {\n    if (!classDecl.name) {\n      return null;\n    }\n    const filePath = classDecl.getSourceFile().fileName;\n    const queryKey = this._getViewQueryUniqueKey(filePath, classDecl.name.text, queryName);\n\n    if (this.analyzedQueries.has(queryKey)) {\n      return this.analyzedQueries.get(queryKey) !;\n    }\n    return null;\n  }\n\n  private _parseTemplate(component: CompileDirectiveMetadata, ngModule: CompileNgModuleMetadata):\n      TemplateAst[] {\n    return this\n        .compiler !['_parseTemplate'](component, ngModule, ngModule.transitiveModule.directives)\n        .template;\n  }\n\n  private _createDiagnosticsError(diagnostics: ReadonlyArray<Diagnostic>) {\n    return new Error(ts.formatDiagnostics(diagnostics as ts.Diagnostic[], this.host));\n  }\n\n  private _getViewQueryUniqueKey(filePath: string, className: string, propName: string) {\n    return `${resolve(filePath)}#${className}-${propName}`;\n  }\n}\n"]}