@angular/cdk 9.2.1 → 9.2.2

package/schematics/ng-update/devkit-file-system.js

@@ -0,0 +1,67 @@
+/**
+ * @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/cdk/schematics/ng-update/devkit-file-system", ["require", "exports", "@angular-devkit/core", "path"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    const core_1 = require("@angular-devkit/core");
+    const path_1 = require("path");
+    /**
+     * File system that leverages the virtual tree from the CLI devkit. This file
+     * system is commonly used by `ng update` migrations that run as part of the
+     * Angular CLI.
+     */
+    class DevkitFileSystem {
+        constructor(_tree, _workspaceFsPath) {
+            this._tree = _tree;
+            this._workspaceFsPath = _workspaceFsPath;
+            this._updateRecorderCache = new Map();
+        }
+        resolve(fsFilePath) {
+            return core_1.normalize(path_1.relative(this._workspaceFsPath, fsFilePath));
+        }
+        edit(fsFilePath) {
+            const treeFilePath = this.resolve(fsFilePath);
+            if (this._updateRecorderCache.has(treeFilePath)) {
+                return this._updateRecorderCache.get(treeFilePath);
+            }
+            const recorder = this._tree.beginUpdate(treeFilePath);
+            this._updateRecorderCache.set(treeFilePath, recorder);
+            return recorder;
+        }
+        commitEdits() {
+            this._updateRecorderCache.forEach(r => this._tree.commitUpdate(r));
+            this._updateRecorderCache.clear();
+        }
+        exists(fsFilePath) {
+            return this._tree.exists(this.resolve(fsFilePath));
+        }
+        overwrite(fsFilePath, content) {
+            this._tree.overwrite(this.resolve(fsFilePath), content);
+        }
+        create(fsFilePath, content) {
+            this._tree.create(this.resolve(fsFilePath), content);
+        }
+        delete(fsFilePath) {
+            this._tree.delete(this.resolve(fsFilePath));
+        }
+        read(fsFilePath) {
+            const buffer = this._tree.read(this.resolve(fsFilePath));
+            return buffer !== null ? buffer.toString() : null;
+        }
+    }
+    exports.DevkitFileSystem = DevkitFileSystem;
+});
+//# sourceMappingURL=data:application/json;base64,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

package/schematics/ng-update/devkit-migration-rule.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @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
+ */
+/// <amd-module name="@angular/cdk/schematics/ng-update/devkit-migration-rule" />
+import { Rule, SchematicContext } from '@angular-devkit/schematics';
+import { MigrationCtor } from '../update-tool/migration';
+import { TargetVersion } from '../update-tool/target-version';
+import { DevkitContext, DevkitMigrationCtor } from './devkit-migration';
+import { UpgradeData } from './upgrade-data';
+/** List of migrations which run for the CDK update. */
+export declare const cdkMigrations: MigrationCtor<UpgradeData>[];
+export declare type NullableDevkitMigration = MigrationCtor<UpgradeData | null, DevkitContext>;
+declare type PostMigrationFn = (context: SchematicContext, targetVersion: TargetVersion, hasFailure: boolean) => void;
+/**
+ * Creates a Angular schematic rule that runs the upgrade for the
+ * specified target version.
+ */
+export declare function createMigrationSchematicRule(targetVersion: TargetVersion, extraMigrations: NullableDevkitMigration[], upgradeData: UpgradeData, onMigrationCompleteFn?: PostMigrationFn): Rule;
+/** Whether the given migration type refers to a devkit migration */
+export declare function isDevkitMigration(value: MigrationCtor<any, any>): value is DevkitMigrationCtor<any>;
+export {};

package/schematics/ng-update/devkit-migration-rule.js

@@ -0,0 +1,152 @@
+/**
+ * @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 __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+(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/cdk/schematics/ng-update/devkit-migration-rule", ["require", "exports", "@angular-devkit/schematics/tasks", "glob", "path", "@angular/cdk/schematics/update-tool", "@angular/cdk/schematics/utils/project-tsconfig-paths", "@angular/cdk/schematics/ng-update/devkit-file-system", "@angular/cdk/schematics/ng-update/devkit-migration", "@angular/cdk/schematics/ng-update/migrations/attribute-selectors", "@angular/cdk/schematics/ng-update/migrations/class-inheritance", "@angular/cdk/schematics/ng-update/migrations/class-names", "@angular/cdk/schematics/ng-update/migrations/constructor-signature", "@angular/cdk/schematics/ng-update/migrations/css-selectors", "@angular/cdk/schematics/ng-update/migrations/element-selectors", "@angular/cdk/schematics/ng-update/migrations/input-names", "@angular/cdk/schematics/ng-update/migrations/method-call-arguments", "@angular/cdk/schematics/ng-update/migrations/misc-template", "@angular/cdk/schematics/ng-update/migrations/output-names", "@angular/cdk/schematics/ng-update/migrations/property-names"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    const tasks_1 = require("@angular-devkit/schematics/tasks");
+    const glob_1 = require("glob");
+    const path_1 = require("path");
+    const update_tool_1 = require("@angular/cdk/schematics/update-tool");
+    const project_tsconfig_paths_1 = require("@angular/cdk/schematics/utils/project-tsconfig-paths");
+    const devkit_file_system_1 = require("@angular/cdk/schematics/ng-update/devkit-file-system");
+    const devkit_migration_1 = require("@angular/cdk/schematics/ng-update/devkit-migration");
+    const attribute_selectors_1 = require("@angular/cdk/schematics/ng-update/migrations/attribute-selectors");
+    const class_inheritance_1 = require("@angular/cdk/schematics/ng-update/migrations/class-inheritance");
+    const class_names_1 = require("@angular/cdk/schematics/ng-update/migrations/class-names");
+    const constructor_signature_1 = require("@angular/cdk/schematics/ng-update/migrations/constructor-signature");
+    const css_selectors_1 = require("@angular/cdk/schematics/ng-update/migrations/css-selectors");
+    const element_selectors_1 = require("@angular/cdk/schematics/ng-update/migrations/element-selectors");
+    const input_names_1 = require("@angular/cdk/schematics/ng-update/migrations/input-names");
+    const method_call_arguments_1 = require("@angular/cdk/schematics/ng-update/migrations/method-call-arguments");
+    const misc_template_1 = require("@angular/cdk/schematics/ng-update/migrations/misc-template");
+    const output_names_1 = require("@angular/cdk/schematics/ng-update/migrations/output-names");
+    const property_names_1 = require("@angular/cdk/schematics/ng-update/migrations/property-names");
+    /** List of migrations which run for the CDK update. */
+    exports.cdkMigrations = [
+        attribute_selectors_1.AttributeSelectorsMigration,
+        class_inheritance_1.ClassInheritanceMigration,
+        class_names_1.ClassNamesMigration,
+        constructor_signature_1.ConstructorSignatureMigration,
+        css_selectors_1.CssSelectorsMigration,
+        element_selectors_1.ElementSelectorsMigration,
+        input_names_1.InputNamesMigration,
+        method_call_arguments_1.MethodCallArgumentsMigration,
+        misc_template_1.MiscTemplateMigration,
+        output_names_1.OutputNamesMigration,
+        property_names_1.PropertyNamesMigration,
+    ];
+    /**
+     * Creates a Angular schematic rule that runs the upgrade for the
+     * specified target version.
+     */
+    function createMigrationSchematicRule(targetVersion, extraMigrations, upgradeData, onMigrationCompleteFn) {
+        return (tree, context) => __awaiter(this, void 0, void 0, function* () {
+            const logger = context.logger;
+            const workspace = project_tsconfig_paths_1.getWorkspaceConfigGracefully(tree);
+            if (workspace === null) {
+                logger.error('Could not find workspace configuration file.');
+                return;
+            }
+            // Keep track of all project source files which have been checked/migrated. This is
+            // necessary because multiple TypeScript projects can contain the same source file and
+            // we don't want to check these again, as this would result in duplicated failure messages.
+            const analyzedFiles = new Set();
+            // The CLI uses the working directory as the base directory for the virtual file system tree.
+            const workspaceFsPath = process.cwd();
+            const fileSystem = new devkit_file_system_1.DevkitFileSystem(tree, workspaceFsPath);
+            const projectNames = Object.keys(workspace.projects);
+            const migrations = [...exports.cdkMigrations, ...extraMigrations];
+            let hasFailures = false;
+            for (const projectName of projectNames) {
+                const project = workspace.projects[projectName];
+                const buildTsconfigPath = project_tsconfig_paths_1.getTargetTsconfigPath(project, 'build');
+                const testTsconfigPath = project_tsconfig_paths_1.getTargetTsconfigPath(project, 'test');
+                if (!buildTsconfigPath && !testTsconfigPath) {
+                    logger.warn(`Could not find TypeScript project for project: ${projectName}`);
+                    continue;
+                }
+                if (buildTsconfigPath !== null) {
+                    runMigrations(project, projectName, buildTsconfigPath, false);
+                }
+                if (testTsconfigPath !== null) {
+                    runMigrations(project, projectName, testTsconfigPath, true);
+                }
+            }
+            let runPackageManager = false;
+            // Run the global post migration static members for all
+            // registered devkit migrations.
+            migrations.forEach(m => {
+                const actionResult = isDevkitMigration(m) && m.globalPostMigration !== undefined ?
+                    m.globalPostMigration(tree, context) : null;
+                if (actionResult) {
+                    runPackageManager = runPackageManager || actionResult.runPackageManager;
+                }
+            });
+            // If a migration requested the package manager to run, we run it as an
+            // asynchronous post migration task. We cannot run it synchronously,
+            // as file changes from the current migration task are not applied to
+            // the file system yet.
+            if (runPackageManager) {
+                context.addTask(new tasks_1.NodePackageInstallTask({ quiet: false }));
+            }
+            if (onMigrationCompleteFn) {
+                onMigrationCompleteFn(context, targetVersion, hasFailures);
+            }
+            /** Runs the migrations for the specified workspace project. */
+            function runMigrations(project, projectName, tsconfigPath, isTestTarget) {
+                const projectRootFsPath = path_1.join(workspaceFsPath, project.root);
+                const tsconfigFsPath = path_1.join(workspaceFsPath, tsconfigPath);
+                const program = update_tool_1.UpdateProject.createProgramFromTsconfig(tsconfigFsPath, fileSystem);
+                const updateContext = {
+                    workspaceFsPath,
+                    isTestTarget,
+                    projectName,
+                    project,
+                    tree,
+                };
+                const updateProject = new update_tool_1.UpdateProject(updateContext, program, fileSystem, analyzedFiles, context.logger);
+                // In some applications, developers will have global stylesheets which are not
+                // specified in any Angular component. Therefore we glob up all CSS and SCSS files
+                // outside of node_modules and dist. The files will be read by the individual
+                // stylesheet rules and checked.
+                // TODO: rework this to collect global stylesheets from the workspace config. COMP-280.
+                const additionalStylesheets = glob_1.sync('!(node_modules|dist)/**/*.+(css|scss)', { absolute: true, cwd: projectRootFsPath, nodir: true });
+                const result = updateProject.migrate(migrations, targetVersion, upgradeData, additionalStylesheets);
+                // Commit all recorded edits in the update recorder. We apply the edits after all
+                // migrations ran because otherwise offsets in the TypeScript program would be
+                // shifted and individual migrations could no longer update the same source file.
+                fileSystem.commitEdits();
+                hasFailures = hasFailures || result.hasFailures;
+            }
+        });
+    }
+    exports.createMigrationSchematicRule = createMigrationSchematicRule;
+    /** Whether the given migration type refers to a devkit migration */
+    function isDevkitMigration(value) {
+        return devkit_migration_1.DevkitMigration.isPrototypeOf(value);
+    }
+    exports.isDevkitMigration = isDevkitMigration;
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"devkit-migration-rule.js","sourceRoot":"","sources":["../../../../../../../src/cdk/schematics/ng-update/devkit-migration-rule.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 {Rule, SchematicContext, Tree} from '@angular-devkit/schematics';\nimport {NodePackageInstallTask} from '@angular-devkit/schematics/tasks';\nimport {WorkspaceProject} from '@schematics/angular/utility/workspace-models';\nimport {sync as globSync} from 'glob';\nimport {join} from 'path';\n\nimport {UpdateProject} from '../update-tool';\nimport {MigrationCtor} from '../update-tool/migration';\nimport {TargetVersion} from '../update-tool/target-version';\nimport {getTargetTsconfigPath, getWorkspaceConfigGracefully} from '../utils/project-tsconfig-paths';\n\nimport {DevkitFileSystem} from './devkit-file-system';\nimport {DevkitContext, DevkitMigration, DevkitMigrationCtor} from './devkit-migration';\nimport {AttributeSelectorsMigration} from './migrations/attribute-selectors';\nimport {ClassInheritanceMigration} from './migrations/class-inheritance';\nimport {ClassNamesMigration} from './migrations/class-names';\nimport {ConstructorSignatureMigration} from './migrations/constructor-signature';\nimport {CssSelectorsMigration} from './migrations/css-selectors';\nimport {ElementSelectorsMigration} from './migrations/element-selectors';\nimport {InputNamesMigration} from './migrations/input-names';\nimport {MethodCallArgumentsMigration} from './migrations/method-call-arguments';\nimport {MiscTemplateMigration} from './migrations/misc-template';\nimport {OutputNamesMigration} from './migrations/output-names';\nimport {PropertyNamesMigration} from './migrations/property-names';\nimport {UpgradeData} from './upgrade-data';\n\n\n/** List of migrations which run for the CDK update. */\nexport const cdkMigrations: MigrationCtor<UpgradeData>[] = [\n  AttributeSelectorsMigration,\n  ClassInheritanceMigration,\n  ClassNamesMigration,\n  ConstructorSignatureMigration,\n  CssSelectorsMigration,\n  ElementSelectorsMigration,\n  InputNamesMigration,\n  MethodCallArgumentsMigration,\n  MiscTemplateMigration,\n  OutputNamesMigration,\n  PropertyNamesMigration,\n];\n\nexport type NullableDevkitMigration = MigrationCtor<UpgradeData|null, DevkitContext>;\n\ntype PostMigrationFn =\n    (context: SchematicContext, targetVersion: TargetVersion, hasFailure: boolean) => void;\n\n/**\n * Creates a Angular schematic rule that runs the upgrade for the\n * specified target version.\n */\nexport function createMigrationSchematicRule(\n    targetVersion: TargetVersion, extraMigrations: NullableDevkitMigration[],\n    upgradeData: UpgradeData, onMigrationCompleteFn?: PostMigrationFn): Rule {\n  return async (tree: Tree, context: SchematicContext) => {\n    const logger = context.logger;\n    const workspace = getWorkspaceConfigGracefully(tree);\n\n    if (workspace === null) {\n      logger.error('Could not find workspace configuration file.');\n      return;\n    }\n\n    // Keep track of all project source files which have been checked/migrated. This is\n    // necessary because multiple TypeScript projects can contain the same source file and\n    // we don't want to check these again, as this would result in duplicated failure messages.\n    const analyzedFiles = new Set<string>();\n    // The CLI uses the working directory as the base directory for the virtual file system tree.\n    const workspaceFsPath = process.cwd();\n    const fileSystem = new DevkitFileSystem(tree, workspaceFsPath);\n    const projectNames = Object.keys(workspace.projects);\n    const migrations: NullableDevkitMigration[] = [...cdkMigrations, ...extraMigrations];\n    let hasFailures = false;\n\n    for (const projectName of projectNames) {\n      const project = workspace.projects[projectName];\n      const buildTsconfigPath = getTargetTsconfigPath(project, 'build');\n      const testTsconfigPath = getTargetTsconfigPath(project, 'test');\n\n      if (!buildTsconfigPath && !testTsconfigPath) {\n        logger.warn(`Could not find TypeScript project for project: ${projectName}`);\n        continue;\n      }\n      if (buildTsconfigPath !== null) {\n        runMigrations(project, projectName, buildTsconfigPath, false);\n      }\n      if (testTsconfigPath !== null) {\n        runMigrations(project, projectName, testTsconfigPath, true);\n      }\n    }\n\n    let runPackageManager = false;\n    // Run the global post migration static members for all\n    // registered devkit migrations.\n    migrations.forEach(m => {\n      const actionResult = isDevkitMigration(m) && m.globalPostMigration !== undefined ?\n          m.globalPostMigration(tree, context) : null;\n      if (actionResult) {\n        runPackageManager = runPackageManager || actionResult.runPackageManager;\n      }\n    });\n\n    // If a migration requested the package manager to run, we run it as an\n    // asynchronous post migration task. We cannot run it synchronously,\n    // as file changes from the current migration task are not applied to\n    // the file system yet.\n    if (runPackageManager) {\n      context.addTask(new NodePackageInstallTask({quiet: false}));\n    }\n\n    if (onMigrationCompleteFn) {\n      onMigrationCompleteFn(context, targetVersion, hasFailures);\n    }\n\n    /** Runs the migrations for the specified workspace project. */\n    function runMigrations(project: WorkspaceProject, projectName: string,\n                           tsconfigPath: string, isTestTarget: boolean) {\n      const projectRootFsPath = join(workspaceFsPath, project.root);\n      const tsconfigFsPath = join(workspaceFsPath, tsconfigPath);\n      const program = UpdateProject.createProgramFromTsconfig(tsconfigFsPath, fileSystem);\n      const updateContext: DevkitContext = {\n        workspaceFsPath,\n        isTestTarget,\n        projectName,\n        project,\n        tree,\n      };\n\n      const updateProject = new UpdateProject(\n        updateContext,\n        program,\n        fileSystem,\n        analyzedFiles,\n        context.logger,\n      );\n\n      // In some applications, developers will have global stylesheets which are not\n      // specified in any Angular component. Therefore we glob up all CSS and SCSS files\n      // outside of node_modules and dist. The files will be read by the individual\n      // stylesheet rules and checked.\n      // TODO: rework this to collect global stylesheets from the workspace config. COMP-280.\n      const additionalStylesheets = globSync(\n        '!(node_modules|dist)/**/*.+(css|scss)',\n        {absolute: true, cwd: projectRootFsPath, nodir: true});\n\n      const result =\n        updateProject.migrate(migrations, targetVersion, upgradeData, additionalStylesheets);\n\n      // Commit all recorded edits in the update recorder. We apply the edits after all\n      // migrations ran because otherwise offsets in the TypeScript program would be\n      // shifted and individual migrations could no longer update the same source file.\n      fileSystem.commitEdits();\n\n      hasFailures = hasFailures || result.hasFailures;\n    }\n  };\n}\n\n/** Whether the given migration type refers to a devkit migration */\nexport function isDevkitMigration(value: MigrationCtor<any, any>)\n    : value is DevkitMigrationCtor<any> {\n  return DevkitMigration.isPrototypeOf(value);\n}\n"]}

package/schematics/ng-update/devkit-migration.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @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
+ */
+/// <amd-module name="@angular/cdk/schematics/ng-update/devkit-migration" />
+import { SchematicContext, Tree } from '@angular-devkit/schematics';
+import { WorkspaceProject } from '@schematics/angular/utility/workspace-models';
+import { Constructor, Migration, PostMigrationAction } from '../update-tool/migration';
+export declare type DevkitContext = {
+    /** Devkit tree for the current migrations. Can be used to insert/remove files. */
+    tree: Tree;
+    /** Name of the project the migrations run against. */
+    projectName: string;
+    /** Workspace project the migrations run against. */
+    project: WorkspaceProject;
+    /** Absolute file system path to the workspace */
+    workspaceFsPath: string;
+    /** Whether the migrations run for a test target. */
+    isTestTarget: boolean;
+};
+export declare abstract class DevkitMigration<Data> extends Migration<Data, DevkitContext> {
+    /** Prints an informative message with context on the current target. */
+    protected printInfo(text: string): void;
+    /**
+     * Optional static method that will be called once the migration of all project
+     * targets has been performed. This method can be used to make changes respecting the
+     * migration result of all individual targets. e.g. removing HammerJS if it
+     * is not needed in any project target.
+     */
+    static globalPostMigration?(tree: Tree, context: SchematicContext): PostMigrationAction;
+}
+export declare type DevkitMigrationCtor<Data> = Constructor<DevkitMigration<Data>> & {
+    [m in keyof typeof DevkitMigration]: (typeof DevkitMigration)[m];
+};

package/schematics/ng-update/devkit-migration.js

@@ -0,0 +1,29 @@
+/**
+ * @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/cdk/schematics/ng-update/devkit-migration", ["require", "exports", "@angular/cdk/schematics/update-tool/migration"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    const migration_1 = require("@angular/cdk/schematics/update-tool/migration");
+    class DevkitMigration extends migration_1.Migration {
+        /** Prints an informative message with context on the current target. */
+        printInfo(text) {
+            const targetName = this.context.isTestTarget ? 'test' : 'build';
+            this.logger.info(`- ${this.context.projectName}@${targetName}: ${text}`);
+        }
+    }
+    exports.DevkitMigration = DevkitMigration;
+});
+//# sourceMappingURL=data:application/json;base64,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

package/schematics/ng-update/index.js

@@ -11,32 +11,32 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define("@angular/cdk/schematics/ng-update/index", ["require", "exports", "@angular/cdk/schematics/update-tool/target-version", "@angular/cdk/schematics/ng-update/upgrade-data", "@angular/cdk/schematics/ng-update/upgrade-rules/index"], factory);
+        define("@angular/cdk/schematics/ng-update/index", ["require", "exports", "@angular/cdk/schematics/update-tool/target-version", "@angular/cdk/schematics/ng-update/upgrade-data", "@angular/cdk/schematics/ng-update/devkit-migration-rule"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     const target_version_1 = require("@angular/cdk/schematics/update-tool/target-version");
     const upgrade_data_1 = require("@angular/cdk/schematics/ng-update/upgrade-data");
-    const upgrade_rules_1 = require("@angular/cdk/schematics/ng-update/upgrade-rules/index");
+    const devkit_migration_rule_1 = require("@angular/cdk/schematics/ng-update/devkit-migration-rule");
     /** Entry point for the migration schematics with target of Angular CDK 6.0.0 */
     function updateToV6() {
-        return upgrade_rules_1.createUpgradeRule(target_version_1.TargetVersion.V6, [], upgrade_data_1.cdkUpgradeData, onMigrationComplete);
+        return devkit_migration_rule_1.createMigrationSchematicRule(target_version_1.TargetVersion.V6, [], upgrade_data_1.cdkUpgradeData, onMigrationComplete);
     }
     exports.updateToV6 = updateToV6;
     /** Entry point for the migration schematics with target of Angular CDK 7.0.0 */
     function updateToV7() {
-        return upgrade_rules_1.createUpgradeRule(target_version_1.TargetVersion.V7, [], upgrade_data_1.cdkUpgradeData, onMigrationComplete);
+        return devkit_migration_rule_1.createMigrationSchematicRule(target_version_1.TargetVersion.V7, [], upgrade_data_1.cdkUpgradeData, onMigrationComplete);
     }
     exports.updateToV7 = updateToV7;
     /** Entry point for the migration schematics with target of Angular CDK 8.0.0 */
     function updateToV8() {
-        return upgrade_rules_1.createUpgradeRule(target_version_1.TargetVersion.V8, [], upgrade_data_1.cdkUpgradeData, onMigrationComplete);
+        return devkit_migration_rule_1.createMigrationSchematicRule(target_version_1.TargetVersion.V8, [], upgrade_data_1.cdkUpgradeData, onMigrationComplete);
     }
     exports.updateToV8 = updateToV8;
     /** Entry point for the migration schematics with target of Angular CDK 9.0.0 */
     function updateToV9() {
-        return upgrade_rules_1.createUpgradeRule(target_version_1.TargetVersion.V9, [], upgrade_data_1.cdkUpgradeData, onMigrationComplete);
+        return devkit_migration_rule_1.createMigrationSchematicRule(target_version_1.TargetVersion.V9, [], upgrade_data_1.cdkUpgradeData, onMigrationComplete);
     }
     exports.updateToV9 = updateToV9;
     /** Function that will be called when the migration completed. */
@@ -50,4 +50,4 @@
         }
     }
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/schematics/ng-update/{upgrade-rules/attribute-selectors-rule.d.ts → migrations/attribute-selectors.d.ts}

@@ -5,19 +5,19 @@
  * 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
  */
-/// <amd-module name="@angular/cdk/schematics/ng-update/upgrade-rules/attribute-selectors-rule" />
+/// <amd-module name="@angular/cdk/schematics/ng-update/migrations/attribute-selectors" />
 import * as ts from 'typescript';
 import { ResolvedResource } from '../../update-tool/component-resource-collector';
-import { MigrationRule } from '../../update-tool/migration-rule';
-import { RuleUpgradeData } from '../upgrade-data';
+import { Migration } from '../../update-tool/migration';
+import { UpgradeData } from '../upgrade-data';
 /**
- * Migration rule that walks through every string literal, template and stylesheet
+ * Migration that walks through every string literal, template and stylesheet
  * in order to switch deprecated attribute selectors to the updated selector.
  */
-export declare class AttributeSelectorsRule extends MigrationRule<RuleUpgradeData> {
+export declare class AttributeSelectorsMigration extends Migration<UpgradeData> {
     /** Required upgrade changes for specified target version. */
     data: any;
-    ruleEnabled: any;
+    enabled: any;
     visitNode(node: ts.Node): void;
     visitTemplate(template: ResolvedResource): void;
     visitStylesheet(stylesheet: ResolvedResource): void;

package/schematics/ng-update/migrations/attribute-selectors.js

@@ -0,0 +1,76 @@
+/**
+ * @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/cdk/schematics/ng-update/migrations/attribute-selectors", ["require", "exports", "typescript", "@angular/cdk/schematics/update-tool/migration", "@angular/cdk/schematics/ng-update/typescript/literal", "@angular/cdk/schematics/ng-update/upgrade-data"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    const ts = require("typescript");
+    const migration_1 = require("@angular/cdk/schematics/update-tool/migration");
+    const literal_1 = require("@angular/cdk/schematics/ng-update/typescript/literal");
+    const upgrade_data_1 = require("@angular/cdk/schematics/ng-update/upgrade-data");
+    /**
+     * Migration that walks through every string literal, template and stylesheet
+     * in order to switch deprecated attribute selectors to the updated selector.
+     */
+    class AttributeSelectorsMigration extends migration_1.Migration {
+        constructor() {
+            super(...arguments);
+            /** Required upgrade changes for specified target version. */
+            this.data = upgrade_data_1.getVersionUpgradeData(this, 'attributeSelectors');
+            // Only enable the migration rule if there is upgrade data.
+            this.enabled = this.data.length !== 0;
+        }
+        visitNode(node) {
+            if (ts.isStringLiteralLike(node)) {
+                this._visitStringLiteralLike(node);
+            }
+        }
+        visitTemplate(template) {
+            this.data.forEach(selector => {
+                literal_1.findAllSubstringIndices(template.content, selector.replace)
+                    .map(offset => template.start + offset)
+                    .forEach(start => this._replaceSelector(template.filePath, start, selector));
+            });
+        }
+        visitStylesheet(stylesheet) {
+            this.data.forEach(selector => {
+                const currentSelector = `[${selector.replace}]`;
+                const updatedSelector = `[${selector.replaceWith}]`;
+                literal_1.findAllSubstringIndices(stylesheet.content, currentSelector)
+                    .map(offset => stylesheet.start + offset)
+                    .forEach(start => this._replaceSelector(stylesheet.filePath, start, { replace: currentSelector, replaceWith: updatedSelector }));
+            });
+        }
+        _visitStringLiteralLike(literal) {
+            if (literal.parent && literal.parent.kind !== ts.SyntaxKind.CallExpression) {
+                return;
+            }
+            const literalText = literal.getText();
+            const filePath = literal.getSourceFile().fileName;
+            this.data.forEach(selector => {
+                literal_1.findAllSubstringIndices(literalText, selector.replace)
+                    .map(offset => literal.getStart() + offset)
+                    .forEach(start => this._replaceSelector(filePath, start, selector));
+            });
+        }
+        _replaceSelector(filePath, start, data) {
+            this.fileSystem.edit(filePath)
+                .remove(start, data.replace.length)
+                .insertRight(start, data.replaceWith);
+        }
+    }
+    exports.AttributeSelectorsMigration = AttributeSelectorsMigration;
+});
+//# sourceMappingURL=data:application/json;base64,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

package/schematics/ng-update/{upgrade-rules/class-inheritance-rule.d.ts → migrations/class-inheritance.d.ts}

@@ -5,22 +5,22 @@
  * 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
  */
-/// <amd-module name="@angular/cdk/schematics/ng-update/upgrade-rules/class-inheritance-rule" />
+/// <amd-module name="@angular/cdk/schematics/ng-update/migrations/class-inheritance" />
 import * as ts from 'typescript';
-import { MigrationRule } from '../../update-tool/migration-rule';
+import { Migration } from '../../update-tool/migration';
 import { PropertyNameUpgradeData } from '../data/property-names';
-import { RuleUpgradeData } from '../upgrade-data';
+import { UpgradeData } from '../upgrade-data';
 /**
- * Rule that identifies class declarations that extend CDK or Material classes
+ * Migration that identifies class declarations that extend CDK or Material classes
  * which had a public property change.
  */
-export declare class ClassInheritanceRule extends MigrationRule<RuleUpgradeData> {
+export declare class ClassInheritanceMigration extends Migration<UpgradeData> {
     /**
      * Map of classes that have been updated. Each class name maps to the according property
      * change data.
      */
     propertyNames: Map<string, PropertyNameUpgradeData>;
-    ruleEnabled: boolean;
+    enabled: boolean;
     init(): void;
     visitNode(node: ts.Node): void;
     private _visitClassDeclaration;