jqwidgets-ng 23.0.7 → 23.1.0

package/schematics/cdk2/schematics/update-tool/index.mjs

@@ -0,0 +1,178 @@
+"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 {
+    _context;
+    _program;
+    _fileSystem;
+    _analyzedFiles;
+    _logger;
+    _typeChecker;
+    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. Can be `null` if the set of
+     *   specified migrations runs regardless of a target version.
+     * @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.
+     * @param limitToDirectory If specified, changes will be limited to the given directory.
+     */
+    migrate(migrationTypes, target, data, additionalStylesheetPaths, limitToDirectory) {
+        limitToDirectory &&= this._fileSystem.resolve(limitToDirectory);
+        // 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 => {
+            return (!f.isDeclarationFile &&
+                (limitToDirectory == null ||
+                    this._fileSystem.resolve(f.fileName).startsWith(limitToDirectory)) &&
+                !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);
+                if (limitToDirectory == null || resolvedPath.startsWith(limitToDirectory)) {
+                    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.
+     *
+     * @throws {TsconfigParseError} If the tsconfig could not be parsed.
+     */
+    static createProgramFromTsconfig(tsconfigPath, fs) {
+        const parsed = (0, parse_tsconfig_1.parseTsconfigFile)(fs.resolve(tsconfigPath), fs);
+        const host = (0, 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;\n\n  constructor(\n    /** 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    this._typeChecker = this._program.getTypeChecker();\n  }\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. Can be `null` if the set of\n   *   specified migrations runs regardless of a target version.\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   * @param limitToDirectory If specified, changes will be limited to the given directory.\n   */\n  migrate<Data>(\n    migrationTypes: MigrationCtor<Data, Context>[],\n    target: TargetVersion | null,\n    data: Data,\n    additionalStylesheetPaths?: string[],\n    limitToDirectory?: string,\n  ): {hasFailures: boolean} {\n    limitToDirectory &&= this._fileSystem.resolve(limitToDirectory);\n\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(f => {\n      return (\n        !f.isDeclarationFile &&\n        (limitToDirectory == null ||\n          this._fileSystem.resolve(f.fileName).startsWith(limitToDirectory)) &&\n        !this._program.isSourceFileFromExternalLibrary(f)\n      );\n    });\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        if (limitToDirectory == null || resolvedPath.startsWith(limitToDirectory)) {\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\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(\n      (res, m) => res.concat(m.failures),\n      [] as MigrationFailure[],\n    );\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>(\n    types: MigrationCtor<Data, Context>[],\n    target: TargetVersion | null,\n    data: Data,\n  ): Migration<Data, Context>[] {\n    const result: Migration<Data, Context>[] = [];\n    for (const ctor of types) {\n      const instance = new ctor(\n        this._program,\n        this._typeChecker,\n        target,\n        this._context,\n        data,\n        this._fileSystem,\n        this._logger,\n      );\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   * @throws {TsconfigParseError} If the tsconfig could not be parsed.\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"]}

package/schematics/cdk2/schematics/update-tool/logger.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @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
+ */
+export interface UpdateLogger {
+    debug(message: string): void;
+    error(message: string): void;
+    fatal(message: string): void;
+    info(message: string): void;
+    warn(message: string): void;
+}
+export declare const defaultLogger: UpdateLogger;

package/schematics/cdk2/schematics/update-tool/logger.mjs

@@ -0,0 +1,18 @@
+"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.defaultLogger = void 0;
+exports.defaultLogger = {
+    debug: m => console.debug(m),
+    error: m => console.error(m),
+    fatal: m => console.error(m),
+    info: m => console.info(m),
+    warn: m => console.warn(m),
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9nZ2VyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vc3JjL2Nkay9zY2hlbWF0aWNzL3VwZGF0ZS10b29sL2xvZ2dlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUE7Ozs7OztHQU1HOzs7QUFVVSxRQUFBLGFBQWEsR0FBaUI7SUFDekMsS0FBSyxFQUFFLENBQUMsQ0FBQyxFQUFFLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUM7SUFDNUIsS0FBSyxFQUFFLENBQUMsQ0FBQyxFQUFFLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUM7SUFDNUIsS0FBSyxFQUFFLENBQUMsQ0FBQyxFQUFFLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUM7SUFDNUIsSUFBSSxFQUFFLENBQUMsQ0FBQyxFQUFFLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUM7SUFDMUIsSUFBSSxFQUFFLENBQUMsQ0FBQyxFQUFFLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUM7Q0FDM0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5leHBvcnQgaW50ZXJmYWNlIFVwZGF0ZUxvZ2dlciB7XG4gIGRlYnVnKG1lc3NhZ2U6IHN0cmluZyk6IHZvaWQ7XG4gIGVycm9yKG1lc3NhZ2U6IHN0cmluZyk6IHZvaWQ7XG4gIGZhdGFsKG1lc3NhZ2U6IHN0cmluZyk6IHZvaWQ7XG4gIGluZm8obWVzc2FnZTogc3RyaW5nKTogdm9pZDtcbiAgd2FybihtZXNzYWdlOiBzdHJpbmcpOiB2b2lkO1xufVxuXG5leHBvcnQgY29uc3QgZGVmYXVsdExvZ2dlcjogVXBkYXRlTG9nZ2VyID0ge1xuICBkZWJ1ZzogbSA9PiBjb25zb2xlLmRlYnVnKG0pLFxuICBlcnJvcjogbSA9PiBjb25zb2xlLmVycm9yKG0pLFxuICBmYXRhbDogbSA9PiBjb25zb2xlLmVycm9yKG0pLFxuICBpbmZvOiBtID0+IGNvbnNvbGUuaW5mbyhtKSxcbiAgd2FybjogbSA9PiBjb25zb2xlLndhcm4obSksXG59O1xuIl19

package/schematics/cdk2/schematics/update-tool/migration.d.ts

@@ -0,0 +1,87 @@
+/**
+ * @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 * as ts from 'typescript';
+import { ResolvedResource } from './component-resource-collector';
+import { FileSystem, WorkspacePath } from './file-system';
+import { UpdateLogger } from './logger';
+import { TargetVersion } from './target-version';
+import { LineAndCharacter } from './utils/line-mappings';
+export interface MigrationFailure {
+    filePath: WorkspacePath;
+    message: string;
+    position?: LineAndCharacter;
+}
+export type PostMigrationAction = void | {
+    /** Whether the package manager should run upon migration completion. */
+    runPackageManager: boolean;
+};
+/** Creates a constructor type for the specified type. */
+export type Constructor<T> = new (...args: any[]) => T;
+/** Gets a constructor type for the passed migration data. */
+export type MigrationCtor<Data, Context = any> = Constructor<Migration<Data, Context>>;
+export declare abstract class Migration<Data, Context = any> {
+    /** TypeScript program for the migration. */
+    program: ts.Program;
+    /** TypeChecker instance for the analysis program. */
+    typeChecker: ts.TypeChecker;
+    /**
+     * Version for which the migration rule should run. Null if the migration
+     * is invoked manually.
+     */
+    targetVersion: TargetVersion | null;
+    /** Context data for the migration. */
+    context: Context;
+    /** Upgrade data passed to the migration. */
+    upgradeData: Data;
+    /** File system that can be used for modifying files. */
+    fileSystem: FileSystem;
+    /** Logger that can be used to print messages as part of the migration. */
+    logger: UpdateLogger;
+    /** List of migration failures that need to be reported. */
+    failures: MigrationFailure[];
+    /** Whether the migration is enabled or not. */
+    abstract enabled: boolean;
+    constructor(
+    /** TypeScript program for the migration. */
+    program: ts.Program, 
+    /** TypeChecker instance for the analysis program. */
+    typeChecker: ts.TypeChecker, 
+    /**
+     * Version for which the migration rule should run. Null if the migration
+     * is invoked manually.
+     */
+    targetVersion: TargetVersion | null, 
+    /** Context data for the migration. */
+    context: Context, 
+    /** Upgrade data passed to the migration. */
+    upgradeData: Data, 
+    /** File system that can be used for modifying files. */
+    fileSystem: FileSystem, 
+    /** Logger that can be used to print messages as part of the migration. */
+    logger: UpdateLogger);
+    /** Method can be used to perform global analysis of the program. */
+    init(): void;
+    /**
+     * Method that will be called once all nodes, templates and stylesheets
+     * have been visited.
+     */
+    postAnalysis(): void;
+    /**
+     * Method that will be called for each node in a given source file. Unlike tslint, this
+     * function will only retrieve TypeScript nodes that need to be casted manually. This
+     * allows us to only walk the program source files once per program and not per
+     * migration rule (significant performance boost).
+     */
+    visitNode(node: ts.Node): void;
+    /** Method that will be called for each Angular template in the program. */
+    visitTemplate(template: ResolvedResource): void;
+    /** Method that will be called for each stylesheet in the program. */
+    visitStylesheet(stylesheet: ResolvedResource): void;
+    /** Creates a failure with a specified message at the given node location. */
+    protected createFailureAtNode(node: ts.Node, message: string): void;
+}

package/schematics/cdk2/schematics/update-tool/migration.mjs

@@ -0,0 +1,77 @@
+"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.Migration = void 0;
+const ts = require("typescript");
+class Migration {
+    program;
+    typeChecker;
+    targetVersion;
+    context;
+    upgradeData;
+    fileSystem;
+    logger;
+    /** List of migration failures that need to be reported. */
+    failures = [];
+    constructor(
+    /** TypeScript program for the migration. */
+    program, 
+    /** TypeChecker instance for the analysis program. */
+    typeChecker, 
+    /**
+     * Version for which the migration rule should run. Null if the migration
+     * is invoked manually.
+     */
+    targetVersion, 
+    /** Context data for the migration. */
+    context, 
+    /** Upgrade data passed to the migration. */
+    upgradeData, 
+    /** File system that can be used for modifying files. */
+    fileSystem, 
+    /** Logger that can be used to print messages as part of the migration. */
+    logger) {
+        this.program = program;
+        this.typeChecker = typeChecker;
+        this.targetVersion = targetVersion;
+        this.context = context;
+        this.upgradeData = upgradeData;
+        this.fileSystem = fileSystem;
+        this.logger = logger;
+    }
+    /** Method can be used to perform global analysis of the program. */
+    init() { }
+    /**
+     * Method that will be called once all nodes, templates and stylesheets
+     * have been visited.
+     */
+    postAnalysis() { }
+    /**
+     * Method that will be called for each node in a given source file. Unlike tslint, this
+     * function will only retrieve TypeScript nodes that need to be casted manually. This
+     * allows us to only walk the program source files once per program and not per
+     * migration rule (significant performance boost).
+     */
+    visitNode(node) { }
+    /** Method that will be called for each Angular template in the program. */
+    visitTemplate(template) { }
+    /** Method that will be called for each stylesheet in the program. */
+    visitStylesheet(stylesheet) { }
+    /** Creates a failure with a specified message at the given node location. */
+    createFailureAtNode(node, message) {
+        const sourceFile = node.getSourceFile();
+        this.failures.push({
+            filePath: this.fileSystem.resolve(sourceFile.fileName),
+            position: ts.getLineAndCharacterOfPosition(sourceFile, node.getStart()),
+            message: message,
+        });
+    }
+}
+exports.Migration = Migration;
+//# sourceMappingURL=data:application/json;base64,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

package/schematics/cdk2/schematics/update-tool/public-api.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @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
+ */
+export * from './component-resource-collector';
+export * from './file-system';
+export * from './index';
+export * from './migration';
+export * from './target-version';
+export * from './utils/decorators';
+export * from './utils/imports';
+export * from './utils/property-name';
+export * from './version-changes';

package/schematics/cdk2/schematics/update-tool/public-api.mjs

@@ -0,0 +1,33 @@
+"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
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./component-resource-collector"), exports);
+__exportStar(require("./file-system"), exports);
+__exportStar(require("./index"), exports);
+__exportStar(require("./migration"), exports);
+__exportStar(require("./target-version"), exports);
+__exportStar(require("./utils/decorators"), exports);
+__exportStar(require("./utils/imports"), exports);
+__exportStar(require("./utils/property-name"), exports);
+__exportStar(require("./version-changes"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYy9jZGsvc2NoZW1hdGljcy91cGRhdGUtdG9vbC9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQTs7Ozs7O0dBTUc7Ozs7Ozs7Ozs7Ozs7Ozs7QUFFSCxpRUFBK0M7QUFDL0MsZ0RBQThCO0FBQzlCLDBDQUF3QjtBQUN4Qiw4Q0FBNEI7QUFDNUIsbURBQWlDO0FBQ2pDLHFEQUFtQztBQUNuQyxrREFBZ0M7QUFDaEMsd0RBQXNDO0FBQ3RDLG9EQUFrQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2NvbXBvbmVudC1yZXNvdXJjZS1jb2xsZWN0b3InO1xuZXhwb3J0ICogZnJvbSAnLi9maWxlLXN5c3RlbSc7XG5leHBvcnQgKiBmcm9tICcuL2luZGV4JztcbmV4cG9ydCAqIGZyb20gJy4vbWlncmF0aW9uJztcbmV4cG9ydCAqIGZyb20gJy4vdGFyZ2V0LXZlcnNpb24nO1xuZXhwb3J0ICogZnJvbSAnLi91dGlscy9kZWNvcmF0b3JzJztcbmV4cG9ydCAqIGZyb20gJy4vdXRpbHMvaW1wb3J0cyc7XG5leHBvcnQgKiBmcm9tICcuL3V0aWxzL3Byb3BlcnR5LW5hbWUnO1xuZXhwb3J0ICogZnJvbSAnLi92ZXJzaW9uLWNoYW5nZXMnO1xuIl19

package/schematics/cdk2/schematics/update-tool/target-version.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @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
+ */
+/** Possible versions that can be automatically migrated by `ng update`. */
+export declare enum TargetVersion {
+    V17 = "version 17"
+}
+/**
+ * Returns all versions that are supported by "ng update". The versions are determined
+ * based on the "TargetVersion" enum.
+ */
+export declare function getAllVersionNames(): string[];

package/schematics/cdk2/schematics/update-tool/target-version.mjs

@@ -0,0 +1,28 @@
+"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.getAllVersionNames = exports.TargetVersion = void 0;
+/** Possible versions that can be automatically migrated by `ng update`. */
+// Used in an `Object.keys` call below so it can't be `const enum`.
+// tslint:disable-next-line:prefer-const-enum
+var TargetVersion;
+(function (TargetVersion) {
+    TargetVersion["V17"] = "version 17";
+})(TargetVersion || (exports.TargetVersion = TargetVersion = {}));
+/**
+ * Returns all versions that are supported by "ng update". The versions are determined
+ * based on the "TargetVersion" enum.
+ */
+function getAllVersionNames() {
+    return Object.keys(TargetVersion).filter(enumValue => {
+        return typeof TargetVersion[enumValue] === 'string';
+    });
+}
+exports.getAllVersionNames = getAllVersionNames;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFyZ2V0LXZlcnNpb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMvY2RrL3NjaGVtYXRpY3MvdXBkYXRlLXRvb2wvdGFyZ2V0LXZlcnNpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOzs7Ozs7R0FNRzs7O0FBRUgsMkVBQTJFO0FBQzNFLG1FQUFtRTtBQUNuRSw2Q0FBNkM7QUFDN0MsSUFBWSxhQUVYO0FBRkQsV0FBWSxhQUFhO0lBQ3ZCLG1DQUFrQixDQUFBO0FBQ3BCLENBQUMsRUFGVyxhQUFhLDZCQUFiLGFBQWEsUUFFeEI7QUFFRDs7O0dBR0c7QUFDSCxTQUFnQixrQkFBa0I7SUFDaEMsT0FBTyxNQUFNLENBQUMsSUFBSSxDQUFDLGFBQWEsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxTQUFTLENBQUMsRUFBRTtRQUNuRCxPQUFPLE9BQVEsYUFBb0QsQ0FBQyxTQUFTLENBQUMsS0FBSyxRQUFRLENBQUM7SUFDOUYsQ0FBQyxDQUFDLENBQUM7QUFDTCxDQUFDO0FBSkQsZ0RBSUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuLyoqIFBvc3NpYmxlIHZlcnNpb25zIHRoYXQgY2FuIGJlIGF1dG9tYXRpY2FsbHkgbWlncmF0ZWQgYnkgYG5nIHVwZGF0ZWAuICovXG4vLyBVc2VkIGluIGFuIGBPYmplY3Qua2V5c2AgY2FsbCBiZWxvdyBzbyBpdCBjYW4ndCBiZSBgY29uc3QgZW51bWAuXG4vLyB0c2xpbnQ6ZGlzYWJsZS1uZXh0LWxpbmU6cHJlZmVyLWNvbnN0LWVudW1cbmV4cG9ydCBlbnVtIFRhcmdldFZlcnNpb24ge1xuICBWMTcgPSAndmVyc2lvbiAxNycsXG59XG5cbi8qKlxuICogUmV0dXJucyBhbGwgdmVyc2lvbnMgdGhhdCBhcmUgc3VwcG9ydGVkIGJ5IFwibmcgdXBkYXRlXCIuIFRoZSB2ZXJzaW9ucyBhcmUgZGV0ZXJtaW5lZFxuICogYmFzZWQgb24gdGhlIFwiVGFyZ2V0VmVyc2lvblwiIGVudW0uXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBnZXRBbGxWZXJzaW9uTmFtZXMoKTogc3RyaW5nW10ge1xuICByZXR1cm4gT2JqZWN0LmtleXMoVGFyZ2V0VmVyc2lvbikuZmlsdGVyKGVudW1WYWx1ZSA9PiB7XG4gICAgcmV0dXJuIHR5cGVvZiAoVGFyZ2V0VmVyc2lvbiBhcyBSZWNvcmQ8c3RyaW5nLCBzdHJpbmcgfCB1bmRlZmluZWQ+KVtlbnVtVmFsdWVdID09PSAnc3RyaW5nJztcbiAgfSk7XG59XG4iXX0=

package/schematics/cdk2/schematics/update-tool/update-recorder.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @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
+ */
+/** Update recorder that can be used to apply changes to a source file. */
+export interface UpdateRecorder {
+    insertLeft(index: number, content: string): UpdateRecorder;
+    insertRight(index: number, content: string): UpdateRecorder;
+    remove(index: number, length: number): UpdateRecorder;
+}

package/schematics/cdk2/schematics/update-tool/update-recorder.mjs

@@ -0,0 +1,10 @@
+"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 });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXBkYXRlLXJlY29yZGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vc3JjL2Nkay9zY2hlbWF0aWNzL3VwZGF0ZS10b29sL3VwZGF0ZS1yZWNvcmRlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUE7Ozs7OztHQU1HIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBMTEMgQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbi8qKiBVcGRhdGUgcmVjb3JkZXIgdGhhdCBjYW4gYmUgdXNlZCB0byBhcHBseSBjaGFuZ2VzIHRvIGEgc291cmNlIGZpbGUuICovXG5leHBvcnQgaW50ZXJmYWNlIFVwZGF0ZVJlY29yZGVyIHtcbiAgaW5zZXJ0TGVmdChpbmRleDogbnVtYmVyLCBjb250ZW50OiBzdHJpbmcpOiBVcGRhdGVSZWNvcmRlcjtcbiAgaW5zZXJ0UmlnaHQoaW5kZXg6IG51bWJlciwgY29udGVudDogc3RyaW5nKTogVXBkYXRlUmVjb3JkZXI7XG4gIHJlbW92ZShpbmRleDogbnVtYmVyLCBsZW5ndGg6IG51bWJlcik6IFVwZGF0ZVJlY29yZGVyO1xufVxuIl19

package/schematics/cdk2/schematics/update-tool/utils/decorators.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @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 * as ts from 'typescript';
+import { Import } from './imports';
+export type CallExpressionDecorator = ts.Decorator & {
+    expression: ts.CallExpression;
+};
+export interface NgDecorator {
+    name: string;
+    node: CallExpressionDecorator;
+}
+/**
+ * Gets all decorators which are imported from an Angular package
+ * (e.g. "@angular/core") from a list of decorators.
+ */
+export declare function getAngularDecorators(typeChecker: ts.TypeChecker, decorators: readonly ts.Decorator[]): readonly NgDecorator[];
+export declare function getCallDecoratorImport(typeChecker: ts.TypeChecker, decorator: ts.Decorator): Import | null;

package/schematics/cdk2/schematics/update-tool/utils/decorators.mjs

@@ -0,0 +1,42 @@
+"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.getCallDecoratorImport = exports.getAngularDecorators = void 0;
+const ts = require("typescript");
+const imports_1 = require("./imports");
+/**
+ * Gets all decorators which are imported from an Angular package
+ * (e.g. "@angular/core") from a list of decorators.
+ */
+function getAngularDecorators(typeChecker, decorators) {
+    return decorators
+        .map(node => ({ node, importData: getCallDecoratorImport(typeChecker, node) }))
+        .filter(({ importData }) => importData && importData.moduleName.startsWith('@angular/'))
+        .map(({ node, importData }) => ({
+        node: node,
+        name: importData.symbolName,
+    }));
+}
+exports.getAngularDecorators = getAngularDecorators;
+function getCallDecoratorImport(typeChecker, decorator) {
+    if (!ts.isCallExpression(decorator.expression)) {
+        return null;
+    }
+    const valueExpr = decorator.expression.expression;
+    let identifier = null;
+    if (ts.isIdentifier(valueExpr)) {
+        identifier = valueExpr;
+    }
+    else if (ts.isPropertyAccessExpression(valueExpr) && ts.isIdentifier(valueExpr.name)) {
+        identifier = valueExpr.name;
+    }
+    return identifier ? (0, imports_1.getImportOfIdentifier)(identifier, typeChecker) : null;
+}
+exports.getCallDecoratorImport = getCallDecoratorImport;
+//# sourceMappingURL=data:application/json;base64,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

package/schematics/cdk2/schematics/update-tool/utils/diagnostics.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @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 * as ts from 'typescript';
+import { FileSystem } from '../file-system';
+/** Formats the specified diagnostics with respect to the given file system. */
+export declare function formatDiagnostics(diagnostics: ts.Diagnostic[], fileSystem: FileSystem): string;