"use strict";
/**
 * @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
 */
Object.defineProperty(exports, "__esModule", { value: true });
exports.UpdateProject = void 0;
const ts = require("typescript");
const component_resource_collector_1 = require("./component-resource-collector");
const logger_1 = require("./logger");
const parse_tsconfig_1 = require("./utils/parse-tsconfig");
const virtual_host_1 = require("./utils/virtual-host");
/**
 * An update project that can be run against individual migrations. An update project
 * accepts a TypeScript program and a context that is provided to all migrations. The
 * context is usually not used by migrations, but in some cases migrations rely on
 * specifics from the tool that performs the update (e.g. the Angular CLI). In those cases,
 * the context can provide the necessary specifics to the migrations in a type-safe way.
 */
class UpdateProject {
    constructor(/** Context provided to all migrations. */ _context, 
    /** TypeScript program using workspace paths. */
    _program, 
    /** File system used for reading, writing and editing files. */
    _fileSystem, 
    /**
     * Set of analyzed files. Used for avoiding multiple migration runs if
     * files overlap between targets.
     */
    _analyzedFiles = new Set(), 
    /** Logger used for printing messages. */
    _logger = logger_1.defaultLogger) {
        this._context = _context;
        this._program = _program;
        this._fileSystem = _fileSystem;
        this._analyzedFiles = _analyzedFiles;
        this._logger = _logger;
        this._typeChecker = this._program.getTypeChecker();
    }
    /**
     * Migrates the project to the specified target version.
     * @param migrationTypes Migrations that should be run.
     * @param target Version the project should be updated to.
     * @param data Upgrade data that is passed to all migration rules.
     * @param additionalStylesheetPaths Additional stylesheets that should be migrated, if not
     *   referenced in an Angular component. This is helpful for global stylesheets in a project.
     */
    migrate(migrationTypes, target, data, additionalStylesheetPaths) {
        // Create instances of the specified migrations.
        const migrations = this._createMigrations(migrationTypes, target, data);
        // Creates the component resource collector. The collector can visit arbitrary
        // TypeScript nodes and will find Angular component resources. Resources include
        // templates and stylesheets. It also captures inline stylesheets and templates.
        const resourceCollector = new component_resource_collector_1.ComponentResourceCollector(this._typeChecker, this._fileSystem);
        // Collect all of the TypeScript source files we want to migrate. We don't
        // migrate type definition files, or source files from external libraries.
        const sourceFiles = this._program.getSourceFiles().filter(f => !f.isDeclarationFile && !this._program.isSourceFileFromExternalLibrary(f));
        // Helper function that visits a given TypeScript node and collects all referenced
        // component resources (i.e. stylesheets or templates). Additionally, the helper
        // visits the node in each instantiated migration.
        const visitNodeAndCollectResources = (node) => {
            migrations.forEach(r => r.visitNode(node));
            ts.forEachChild(node, visitNodeAndCollectResources);
            resourceCollector.visitNode(node);
        };
        // Walk through all source file, if it has not been visited before, and
        // visit found nodes while collecting potential resources.
        sourceFiles.forEach(sourceFile => {
            const resolvedPath = this._fileSystem.resolve(sourceFile.fileName);
            // Do not visit source files which have been checked as part of a
            // previously migrated TypeScript project.
            if (!this._analyzedFiles.has(resolvedPath)) {
                visitNodeAndCollectResources(sourceFile);
                this._analyzedFiles.add(resolvedPath);
            }
        });
        // Walk through all resolved templates and visit them in each instantiated
        // migration. Note that this can only happen after source files have been
        // visited because we find templates through the TypeScript source files.
        resourceCollector.resolvedTemplates.forEach(template => {
            // Do not visit the template if it has been checked before. Inline
            // templates cannot be referenced multiple times.
            if (template.inline || !this._analyzedFiles.has(template.filePath)) {
                migrations.forEach(m => m.visitTemplate(template));
                this._analyzedFiles.add(template.filePath);
            }
        });
        // Walk through all resolved stylesheets and visit them in each instantiated
        // migration. Note that this can only happen after source files have been
        // visited because we find stylesheets through the TypeScript source files.
        resourceCollector.resolvedStylesheets.forEach(stylesheet => {
            // Do not visit the stylesheet if it has been checked before. Inline
            // stylesheets cannot be referenced multiple times.
            if (stylesheet.inline || !this._analyzedFiles.has(stylesheet.filePath)) {
                migrations.forEach(r => r.visitStylesheet(stylesheet));
                this._analyzedFiles.add(stylesheet.filePath);
            }
        });
        // In some applications, developers will have global stylesheets which are not
        // specified in any Angular component. Therefore we allow for additional stylesheets
        // being specified. We visit them in each migration unless they have been already
        // discovered before as actual component resource.
        if (additionalStylesheetPaths) {
            additionalStylesheetPaths.forEach(filePath => {
                const resolvedPath = this._fileSystem.resolve(filePath);
                const stylesheet = resourceCollector.resolveExternalStylesheet(resolvedPath, null);
                // Do not visit stylesheets which have been referenced from a component.
                if (!this._analyzedFiles.has(resolvedPath) && stylesheet) {
                    migrations.forEach(r => r.visitStylesheet(stylesheet));
                    this._analyzedFiles.add(resolvedPath);
                }
            });
        }
        // Call the "postAnalysis" method for each migration.
        migrations.forEach(r => r.postAnalysis());
        // Collect all failures reported by individual migrations.
        const failures = migrations.reduce((res, m) => res.concat(m.failures), []);
        // In case there are failures, print these to the CLI logger as warnings.
        if (failures.length) {
            failures.forEach(({ filePath, message, position }) => {
                const lineAndCharacter = position ? `@${position.line + 1}:${position.character + 1}` : '';
                this._logger.warn(`${filePath}${lineAndCharacter} - ${message}`);
            });
        }
        return {
            hasFailures: !!failures.length,
        };
    }
    /**
     * Creates instances of the given migrations with the specified target
     * version and data.
     */
    _createMigrations(types, target, data) {
        const result = [];
        for (const ctor of types) {
            const instance = new ctor(this._program, this._typeChecker, target, this._context, data, this._fileSystem, this._logger);
            instance.init();
            if (instance.enabled) {
                result.push(instance);
            }
        }
        return result;
    }
    /**
     * Creates a program form the specified tsconfig and patches the host
     * to read files and directories through the given file system.
     */
    static createProgramFromTsconfig(tsconfigPath, fs) {
        const parsed = parse_tsconfig_1.parseTsconfigFile(fs.resolve(tsconfigPath), fs);
        const host = virtual_host_1.createFileSystemCompilerHost(parsed.options, fs);
        return ts.createProgram(parsed.fileNames, parsed.options, host);
    }
}
exports.UpdateProject = UpdateProject;
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../../../src/cdk/schematics/update-tool/index.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 {ComponentResourceCollector} from './component-resource-collector';\nimport {FileSystem, WorkspacePath} from './file-system';\nimport {defaultLogger, UpdateLogger} from './logger';\nimport {Migration, MigrationCtor, MigrationFailure} from './migration';\nimport {TargetVersion} from './target-version';\nimport {parseTsconfigFile} from './utils/parse-tsconfig';\nimport {createFileSystemCompilerHost} from './utils/virtual-host';\n\n/**\n * An update project that can be run against individual migrations. An update project\n * accepts a TypeScript program and a context that is provided to all migrations. The\n * context is usually not used by migrations, but in some cases migrations rely on\n * specifics from the tool that performs the update (e.g. the Angular CLI). In those cases,\n * the context can provide the necessary specifics to the migrations in a type-safe way.\n */\nexport class UpdateProject<Context> {\n  private readonly _typeChecker: ts.TypeChecker = this._program.getTypeChecker();\n\n  constructor(/** Context provided to all migrations. */\n              private _context: Context,\n              /** TypeScript program using workspace paths. */\n              private _program: ts.Program,\n              /** File system used for reading, writing and editing files. */\n              private _fileSystem: FileSystem,\n              /**\n               * Set of analyzed files. Used for avoiding multiple migration runs if\n               * files overlap between targets.\n               */\n              private _analyzedFiles: Set<WorkspacePath> = new Set(),\n              /** Logger used for printing messages. */\n              private _logger: UpdateLogger = defaultLogger) {}\n\n  /**\n   * Migrates the project to the specified target version.\n   * @param migrationTypes Migrations that should be run.\n   * @param target Version the project should be updated to.\n   * @param data Upgrade data that is passed to all migration rules.\n   * @param additionalStylesheetPaths Additional stylesheets that should be migrated, if not\n   *   referenced in an Angular component. This is helpful for global stylesheets in a project.\n   */\n  migrate<Data>(migrationTypes: MigrationCtor<Data, Context>[], target: TargetVersion, data: Data,\n      additionalStylesheetPaths?: string[]): {hasFailures: boolean} {\n    // Create instances of the specified migrations.\n    const migrations = this._createMigrations(migrationTypes, target, data);\n    // Creates the component resource collector. The collector can visit arbitrary\n    // TypeScript nodes and will find Angular component resources. Resources include\n    // templates and stylesheets. It also captures inline stylesheets and templates.\n    const resourceCollector = new ComponentResourceCollector(this._typeChecker, this._fileSystem);\n    // Collect all of the TypeScript source files we want to migrate. We don't\n    // migrate type definition files, or source files from external libraries.\n    const sourceFiles = this._program.getSourceFiles().filter(\n      f => !f.isDeclarationFile && !this._program.isSourceFileFromExternalLibrary(f));\n\n    // Helper function that visits a given TypeScript node and collects all referenced\n    // component resources (i.e. stylesheets or templates). Additionally, the helper\n    // visits the node in each instantiated migration.\n    const visitNodeAndCollectResources = (node: ts.Node) => {\n      migrations.forEach(r => r.visitNode(node));\n      ts.forEachChild(node, visitNodeAndCollectResources);\n      resourceCollector.visitNode(node);\n    };\n\n    // Walk through all source file, if it has not been visited before, and\n    // visit found nodes while collecting potential resources.\n    sourceFiles.forEach(sourceFile => {\n      const resolvedPath = this._fileSystem.resolve(sourceFile.fileName);\n      // Do not visit source files which have been checked as part of a\n      // previously migrated TypeScript project.\n      if (!this._analyzedFiles.has(resolvedPath)) {\n        visitNodeAndCollectResources(sourceFile);\n        this._analyzedFiles.add(resolvedPath);\n      }\n    });\n\n    // Walk through all resolved templates and visit them in each instantiated\n    // migration. Note that this can only happen after source files have been\n    // visited because we find templates through the TypeScript source files.\n    resourceCollector.resolvedTemplates.forEach(template => {\n      // Do not visit the template if it has been checked before. Inline\n      // templates cannot be referenced multiple times.\n      if (template.inline || !this._analyzedFiles.has(template.filePath)) {\n        migrations.forEach(m => m.visitTemplate(template));\n        this._analyzedFiles.add(template.filePath);\n      }\n    });\n\n    // Walk through all resolved stylesheets and visit them in each instantiated\n    // migration. Note that this can only happen after source files have been\n    // visited because we find stylesheets through the TypeScript source files.\n    resourceCollector.resolvedStylesheets.forEach(stylesheet => {\n      // Do not visit the stylesheet if it has been checked before. Inline\n      // stylesheets cannot be referenced multiple times.\n      if (stylesheet.inline || !this._analyzedFiles.has(stylesheet.filePath)) {\n        migrations.forEach(r => r.visitStylesheet(stylesheet));\n        this._analyzedFiles.add(stylesheet.filePath);\n      }\n    });\n\n    // In some applications, developers will have global stylesheets which are not\n    // specified in any Angular component. Therefore we allow for additional stylesheets\n    // being specified. We visit them in each migration unless they have been already\n    // discovered before as actual component resource.\n    if (additionalStylesheetPaths) {\n      additionalStylesheetPaths.forEach(filePath => {\n        const resolvedPath = this._fileSystem.resolve(filePath);\n        const stylesheet = resourceCollector.resolveExternalStylesheet(resolvedPath, null);\n        // Do not visit stylesheets which have been referenced from a component.\n        if (!this._analyzedFiles.has(resolvedPath) && stylesheet) {\n          migrations.forEach(r => r.visitStylesheet(stylesheet));\n          this._analyzedFiles.add(resolvedPath);\n        }\n      });\n    }\n\n    // Call the \"postAnalysis\" method for each migration.\n    migrations.forEach(r => r.postAnalysis());\n\n    // Collect all failures reported by individual migrations.\n    const failures = migrations.reduce((res, m) =>\n        res.concat(m.failures), [] as MigrationFailure[]);\n\n    // In case there are failures, print these to the CLI logger as warnings.\n    if (failures.length) {\n      failures.forEach(({filePath, message, position}) => {\n        const lineAndCharacter = position ? `@${position.line + 1}:${position.character + 1}` : '';\n        this._logger.warn(`${filePath}${lineAndCharacter} - ${message}`);\n      });\n    }\n\n    return {\n      hasFailures: !!failures.length,\n    };\n  }\n\n  /**\n   * Creates instances of the given migrations with the specified target\n   * version and data.\n   */\n  private _createMigrations<Data>(types: MigrationCtor<Data, Context>[], target: TargetVersion,\n                                  data: Data): Migration<Data, Context>[] {\n    const result: Migration<Data, Context>[] = [];\n    for (const ctor of types) {\n      const instance = new ctor(this._program, this._typeChecker, target, this._context,\n        data, this._fileSystem, this._logger);\n      instance.init();\n      if (instance.enabled) {\n        result.push(instance);\n      }\n    }\n    return result;\n  }\n\n  /**\n   * Creates a program form the specified tsconfig and patches the host\n   * to read files and directories through the given file system.\n   */\n  static createProgramFromTsconfig(tsconfigPath: WorkspacePath, fs: FileSystem): ts.Program {\n    const parsed = parseTsconfigFile(fs.resolve(tsconfigPath), fs);\n    const host = createFileSystemCompilerHost(parsed.options, fs);\n    return ts.createProgram(parsed.fileNames, parsed.options, host);\n  }\n}\n"]}