@angular/cdk 9.1.3 → 9.2.2

package/schematics/ng-update/migrations/class-names.js

@@ -0,0 +1,98 @@
+/**
+ * @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/class-names", ["require", "exports", "typescript", "@angular/cdk/schematics/update-tool/migration", "@angular/cdk/schematics/ng-update/typescript/imports", "@angular/cdk/schematics/ng-update/typescript/module-specifiers", "@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 imports_1 = require("@angular/cdk/schematics/ng-update/typescript/imports");
+    const module_specifiers_1 = require("@angular/cdk/schematics/ng-update/typescript/module-specifiers");
+    const upgrade_data_1 = require("@angular/cdk/schematics/ng-update/upgrade-data");
+    /**
+     * Migration that walks through every identifier that is part of Angular Material or thr CDK
+     * and replaces the outdated name with the new one if specified in the upgrade data.
+     */
+    // TODO: rework this rule to identify symbols using the import identifier resolver. This
+    // makes it more robust, less AST convoluted and is more TypeScript AST idiomatic. COMP-300.
+    class ClassNamesMigration extends migration_1.Migration {
+        constructor() {
+            super(...arguments);
+            /** Change data that upgrades to the specified target version. */
+            this.data = upgrade_data_1.getVersionUpgradeData(this, 'classNames');
+            /**
+             * List of identifier names that have been imported from `@angular/material` or `@angular/cdk`
+             * in the current source file and therefore can be considered trusted.
+             */
+            this.trustedIdentifiers = new Set();
+            /** List of namespaces that have been imported from `@angular/material` or `@angular/cdk`. */
+            this.trustedNamespaces = new Set();
+            // Only enable the migration rule if there is upgrade data.
+            this.enabled = this.data.length !== 0;
+        }
+        visitNode(node) {
+            if (ts.isIdentifier(node)) {
+                this._visitIdentifier(node);
+            }
+        }
+        /** Method that is called for every identifier inside of the specified project. */
+        _visitIdentifier(identifier) {
+            // For identifiers that aren't listed in the className data, the whole check can be
+            // skipped safely.
+            if (!this.data.some(data => data.replace === identifier.text)) {
+                return;
+            }
+            // For namespace imports that are referring to Angular Material or the CDK, we store the
+            // namespace name in order to be able to safely find identifiers that don't belong to the
+            // developer's application.
+            if (imports_1.isNamespaceImportNode(identifier) && module_specifiers_1.isMaterialImportDeclaration(identifier)) {
+                this.trustedNamespaces.add(identifier.text);
+                return this._createFailureWithReplacement(identifier);
+            }
+            // For export declarations that are referring to Angular Material or the CDK, the identifier
+            // can be immediately updated to the new name.
+            if (imports_1.isExportSpecifierNode(identifier) && module_specifiers_1.isMaterialExportDeclaration(identifier)) {
+                return this._createFailureWithReplacement(identifier);
+            }
+            // For import declarations that are referring to Angular Material or the CDK, the name of
+            // the import identifiers. This allows us to identify identifiers that belong to Material and
+            // the CDK, and we won't accidentally touch a developer's identifier.
+            if (imports_1.isImportSpecifierNode(identifier) && module_specifiers_1.isMaterialImportDeclaration(identifier)) {
+                this.trustedIdentifiers.add(identifier.text);
+                return this._createFailureWithReplacement(identifier);
+            }
+            // In case the identifier is part of a property access expression, we need to verify that the
+            // property access originates from a namespace that has been imported from Material or the CDK.
+            if (ts.isPropertyAccessExpression(identifier.parent)) {
+                const expression = identifier.parent.expression;
+                if (ts.isIdentifier(expression) && this.trustedNamespaces.has(expression.text)) {
+                    return this._createFailureWithReplacement(identifier);
+                }
+            }
+            else if (this.trustedIdentifiers.has(identifier.text)) {
+                return this._createFailureWithReplacement(identifier);
+            }
+        }
+        /** Creates a failure and replacement for the specified identifier. */
+        _createFailureWithReplacement(identifier) {
+            const classData = this.data.find(data => data.replace === identifier.text);
+            this.fileSystem.edit(identifier.getSourceFile().fileName)
+                .remove(identifier.getStart(), identifier.getWidth())
+                .insertRight(identifier.getStart(), classData.replaceWith);
+        }
+    }
+    exports.ClassNamesMigration = ClassNamesMigration;
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"class-names.js","sourceRoot":"","sources":["../../../../../../../../src/cdk/schematics/ng-update/migrations/class-names.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;;;;;;;;;;;;IAEH,iCAAiC;IACjC,6EAAsD;IAGtD,kFAI+B;IAC/B,sGAGyC;IACzC,iFAAmE;IAEnE;;;OAGG;IACH,wFAAwF;IACxF,4FAA4F;IAC5F,MAAa,mBAAoB,SAAQ,qBAAsB;QAA/D;;YACE,iEAAiE;YACjE,SAAI,GAA2B,oCAAqB,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC;YAEzE;;;eAGG;YACH,uBAAkB,GAAgB,IAAI,GAAG,EAAE,CAAC;YAE5C,6FAA6F;YAC7F,sBAAiB,GAAgB,IAAI,GAAG,EAAE,CAAC;YAE3C,2DAA2D;YAC3D,YAAO,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,KAAK,CAAC,CAAC;QA6DnC,CAAC;QA3DC,SAAS,CAAC,IAAa;YACrB,IAAI,EAAE,CAAC,YAAY,CAAC,IAAI,CAAC,EAAE;gBACzB,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC;aAC7B;QACH,CAAC;QAED,kFAAkF;QAC1E,gBAAgB,CAAC,UAAyB;YAChD,mFAAmF;YACnF,kBAAkB;YAClB,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,OAAO,KAAK,UAAU,CAAC,IAAI,CAAC,EAAE;gBAC7D,OAAO;aACR;YAED,wFAAwF;YACxF,yFAAyF;YACzF,2BAA2B;YAC3B,IAAI,+BAAqB,CAAC,UAAU,CAAC,IAAI,+CAA2B,CAAC,UAAU,CAAC,EAAE;gBAChF,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;gBAE5C,OAAO,IAAI,CAAC,6BAA6B,CAAC,UAAU,CAAC,CAAC;aACvD;YAED,4FAA4F;YAC5F,8CAA8C;YAC9C,IAAI,+BAAqB,CAAC,UAAU,CAAC,IAAI,+CAA2B,CAAC,UAAU,CAAC,EAAE;gBAChF,OAAO,IAAI,CAAC,6BAA6B,CAAC,UAAU,CAAC,CAAC;aACvD;YAED,yFAAyF;YACzF,6FAA6F;YAC7F,qEAAqE;YACrE,IAAI,+BAAqB,CAAC,UAAU,CAAC,IAAI,+CAA2B,CAAC,UAAU,CAAC,EAAE;gBAChF,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;gBAE7C,OAAO,IAAI,CAAC,6BAA6B,CAAC,UAAU,CAAC,CAAC;aACvD;YAED,6FAA6F;YAC7F,+FAA+F;YAC/F,IAAI,EAAE,CAAC,0BAA0B,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE;gBACpD,MAAM,UAAU,GAAG,UAAU,CAAC,MAAM,CAAC,UAAU,CAAC;gBAEhD,IAAI,EAAE,CAAC,YAAY,CAAC,UAAU,CAAC,IAAI,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE;oBAC9E,OAAO,IAAI,CAAC,6BAA6B,CAAC,UAAU,CAAC,CAAC;iBACvD;aACF;iBAAM,IAAI,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE;gBACvD,OAAO,IAAI,CAAC,6BAA6B,CAAC,UAAU,CAAC,CAAC;aACvD;QACH,CAAC;QAED,sEAAsE;QAC9D,6BAA6B,CAAC,UAAyB;YAC7D,MAAM,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,OAAO,KAAK,UAAU,CAAC,IAAI,CAAE,CAAC;YAE5E,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,UAAU,CAAC,aAAa,EAAE,CAAC,QAAQ,CAAC;iBACtD,MAAM,CAAC,UAAU,CAAC,QAAQ,EAAE,EAAE,UAAU,CAAC,QAAQ,EAAE,CAAC;iBACpD,WAAW,CAAC,UAAU,CAAC,QAAQ,EAAE,EAAE,SAAS,CAAC,WAAW,CAAC,CAAC;QAC/D,CAAC;KACF;IA3ED,kDA2EC","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';\nimport {Migration} from '../../update-tool/migration';\n\nimport {ClassNameUpgradeData} from '../data';\nimport {\n  isExportSpecifierNode,\n  isImportSpecifierNode,\n  isNamespaceImportNode,\n} from '../typescript/imports';\nimport {\n  isMaterialExportDeclaration,\n  isMaterialImportDeclaration,\n} from '../typescript/module-specifiers';\nimport {getVersionUpgradeData, UpgradeData} from '../upgrade-data';\n\n/**\n * Migration that walks through every identifier that is part of Angular Material or thr CDK\n * and replaces the outdated name with the new one if specified in the upgrade data.\n */\n// TODO: rework this rule to identify symbols using the import identifier resolver. This\n// makes it more robust, less AST convoluted and is more TypeScript AST idiomatic. COMP-300.\nexport class ClassNamesMigration extends Migration<UpgradeData> {\n  /** Change data that upgrades to the specified target version. */\n  data: ClassNameUpgradeData[] = getVersionUpgradeData(this, 'classNames');\n\n  /**\n   * List of identifier names that have been imported from `@angular/material` or `@angular/cdk`\n   * in the current source file and therefore can be considered trusted.\n   */\n  trustedIdentifiers: Set<string> = new Set();\n\n  /** List of namespaces that have been imported from `@angular/material` or `@angular/cdk`. */\n  trustedNamespaces: Set<string> = new Set();\n\n  // Only enable the migration rule if there is upgrade data.\n  enabled = this.data.length !== 0;\n\n  visitNode(node: ts.Node): void {\n    if (ts.isIdentifier(node)) {\n      this._visitIdentifier(node);\n    }\n  }\n\n  /** Method that is called for every identifier inside of the specified project. */\n  private _visitIdentifier(identifier: ts.Identifier) {\n    // For identifiers that aren't listed in the className data, the whole check can be\n    // skipped safely.\n    if (!this.data.some(data => data.replace === identifier.text)) {\n      return;\n    }\n\n    // For namespace imports that are referring to Angular Material or the CDK, we store the\n    // namespace name in order to be able to safely find identifiers that don't belong to the\n    // developer's application.\n    if (isNamespaceImportNode(identifier) && isMaterialImportDeclaration(identifier)) {\n      this.trustedNamespaces.add(identifier.text);\n\n      return this._createFailureWithReplacement(identifier);\n    }\n\n    // For export declarations that are referring to Angular Material or the CDK, the identifier\n    // can be immediately updated to the new name.\n    if (isExportSpecifierNode(identifier) && isMaterialExportDeclaration(identifier)) {\n      return this._createFailureWithReplacement(identifier);\n    }\n\n    // For import declarations that are referring to Angular Material or the CDK, the name of\n    // the import identifiers. This allows us to identify identifiers that belong to Material and\n    // the CDK, and we won't accidentally touch a developer's identifier.\n    if (isImportSpecifierNode(identifier) && isMaterialImportDeclaration(identifier)) {\n      this.trustedIdentifiers.add(identifier.text);\n\n      return this._createFailureWithReplacement(identifier);\n    }\n\n    // In case the identifier is part of a property access expression, we need to verify that the\n    // property access originates from a namespace that has been imported from Material or the CDK.\n    if (ts.isPropertyAccessExpression(identifier.parent)) {\n      const expression = identifier.parent.expression;\n\n      if (ts.isIdentifier(expression) && this.trustedNamespaces.has(expression.text)) {\n        return this._createFailureWithReplacement(identifier);\n      }\n    } else if (this.trustedIdentifiers.has(identifier.text)) {\n      return this._createFailureWithReplacement(identifier);\n    }\n  }\n\n  /** Creates a failure and replacement for the specified identifier. */\n  private _createFailureWithReplacement(identifier: ts.Identifier) {\n    const classData = this.data.find(data => data.replace === identifier.text)!;\n\n    this.fileSystem.edit(identifier.getSourceFile().fileName)\n      .remove(identifier.getStart(), identifier.getWidth())\n      .insertRight(identifier.getStart(), classData.replaceWith);\n  }\n}\n"]}

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

@@ -5,17 +5,17 @@
  * 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/constructor-signature-rule" />
+/// <amd-module name="@angular/cdk/schematics/ng-update/migrations/constructor-signature" />
 import * as ts from 'typescript';
-import { MigrationRule } from '../../update-tool/migration-rule';
-import { RuleUpgradeData } from '../upgrade-data';
+import { Migration } from '../../update-tool/migration';
+import { UpgradeData } from '../upgrade-data';
 /**
- * Rule that visits every TypeScript new expression or super call and checks if
+ * Migration that visits every TypeScript new expression or super call and checks if
  * the parameter type signature is invalid and needs to be updated manually.
  */
-export declare class ConstructorSignatureRule extends MigrationRule<RuleUpgradeData> {
+export declare class ConstructorSignatureMigration extends Migration<UpgradeData> {
     data: string[];
-    ruleEnabled: boolean;
+    enabled: boolean;
     visitNode(node: ts.Node): void;
     /**
      * Method that will be called for each source file of the upgrade project. In order to

package/schematics/ng-update/migrations/constructor-signature.js

@@ -0,0 +1,144 @@
+/**
+ * @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/constructor-signature", ["require", "exports", "typescript", "@angular/cdk/schematics/update-tool/migration", "@angular/cdk/schematics/update-tool/version-changes"], 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 version_changes_1 = require("@angular/cdk/schematics/update-tool/version-changes");
+    /**
+     * List of diagnostic codes that refer to pre-emit diagnostics which indicate invalid
+     * new expression or super call signatures. See the list of diagnostics here:
+     *
+     * https://github.com/Microsoft/TypeScript/blob/master/src/compiler/diagnosticMessages.json
+     */
+    const signatureErrorDiagnostics = [
+        // Type not assignable error diagnostic.
+        2345,
+        // Constructor argument length invalid diagnostics
+        2554,
+        2555,
+        2556,
+        2557,
+    ];
+    /**
+     * Migration that visits every TypeScript new expression or super call and checks if
+     * the parameter type signature is invalid and needs to be updated manually.
+     */
+    class ConstructorSignatureMigration extends migration_1.Migration {
+        constructor() {
+            super(...arguments);
+            // Note that the data for this rule is not distinguished based on the target version because
+            // we don't keep track of the new signature and don't want to update incrementally.
+            // See: https://github.com/angular/components/pull/12970#issuecomment-418337566
+            this.data = version_changes_1.getAllChanges(this.upgradeData.constructorChecks);
+            // Only enable the migration rule if there is upgrade data.
+            this.enabled = this.data.length !== 0;
+        }
+        visitNode(node) {
+            if (ts.isSourceFile(node)) {
+                this._visitSourceFile(node);
+            }
+        }
+        /**
+         * Method that will be called for each source file of the upgrade project. In order to
+         * properly determine invalid constructor signatures, we take advantage of the pre-emit
+         * diagnostics from TypeScript.
+         *
+         * By using the diagnostics, the migration can handle type assignability. Not using
+         * diagnostics would mean that we need to use simple type equality checking which is
+         * too strict. See related issue: https://github.com/Microsoft/TypeScript/issues/9879
+         */
+        _visitSourceFile(sourceFile) {
+            // List of classes of which the constructor signature has changed.
+            const diagnostics = ts.getPreEmitDiagnostics(this.program, sourceFile)
+                .filter(diagnostic => signatureErrorDiagnostics.includes(diagnostic.code))
+                .filter(diagnostic => diagnostic.start !== undefined);
+            for (const diagnostic of diagnostics) {
+                const node = findConstructorNode(diagnostic, sourceFile);
+                if (!node) {
+                    continue;
+                }
+                const classType = this.typeChecker.getTypeAtLocation(node.expression);
+                const className = classType.symbol && classType.symbol.name;
+                const isNewExpression = ts.isNewExpression(node);
+                // Determine the class names of the actual construct signatures because we cannot assume that
+                // the diagnostic refers to a constructor of the actual expression. In case the constructor
+                // is inherited, we need to detect that the owner-class of the constructor is added to the
+                // constructor checks upgrade data. e.g. `class CustomCalendar extends MatCalendar {}`.
+                const signatureClassNames = classType.getConstructSignatures()
+                    .map(signature => getClassDeclarationOfSignature(signature))
+                    .map(declaration => declaration && declaration.name ? declaration.name.text : null)
+                    .filter(Boolean);
+                // Besides checking the signature class names, we need to check the actual class name because
+                // there can be classes without an explicit constructor.
+                if (!this.data.includes(className) &&
+                    !signatureClassNames.some(name => this.data.includes(name))) {
+                    continue;
+                }
+                const classSignatures = classType.getConstructSignatures().map(signature => getParameterTypesFromSignature(signature, this.typeChecker));
+                const expressionName = isNewExpression ? `new ${className}` : 'super';
+                const signatures = classSignatures.map(signature => signature.map(t => this.typeChecker.typeToString(t)))
+                    .map(signature => `${expressionName}(${signature.join(', ')})`)
+                    .join(' or ');
+                this.createFailureAtNode(node, `Found "${className}" constructed with ` +
+                    `an invalid signature. Please manually update the ${expressionName} expression to ` +
+                    `match the new signature${classSignatures.length > 1 ? 's' : ''}: ${signatures}`);
+            }
+        }
+    }
+    exports.ConstructorSignatureMigration = ConstructorSignatureMigration;
+    /** Resolves the type for each parameter in the specified signature. */
+    function getParameterTypesFromSignature(signature, typeChecker) {
+        return signature.getParameters().map(param => typeChecker.getTypeAtLocation(param.declarations[0]));
+    }
+    /**
+     * Walks through each node of a source file in order to find a new-expression node or super-call
+     * expression node that is captured by the specified diagnostic.
+     */
+    function findConstructorNode(diagnostic, sourceFile) {
+        let resolvedNode = null;
+        const _visitNode = (node) => {
+            // Check whether the current node contains the diagnostic. If the node contains the diagnostic,
+            // walk deeper in order to find all constructor expression nodes.
+            if (node.getStart() <= diagnostic.start && node.getEnd() >= diagnostic.start) {
+                if (ts.isNewExpression(node) ||
+                    (ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.SuperKeyword)) {
+                    resolvedNode = node;
+                }
+                ts.forEachChild(node, _visitNode);
+            }
+        };
+        ts.forEachChild(sourceFile, _visitNode);
+        return resolvedNode;
+    }
+    /** Determines the class declaration of the specified construct signature. */
+    function getClassDeclarationOfSignature(signature) {
+        let node = signature.getDeclaration();
+        // Handle signatures which don't have an actual declaration. This happens if a class
+        // does not have an explicitly written constructor.
+        if (!node) {
+            return null;
+        }
+        while (!ts.isSourceFile(node = node.parent)) {
+            if (ts.isClassDeclaration(node)) {
+                return node;
+            }
+        }
+        return null;
+    }
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"constructor-signature.js","sourceRoot":"","sources":["../../../../../../../../src/cdk/schematics/ng-update/migrations/constructor-signature.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';\nimport {Migration} from '../../update-tool/migration';\nimport {getAllChanges} from '../../update-tool/version-changes';\nimport {UpgradeData} from '../upgrade-data';\n\n/**\n * List of diagnostic codes that refer to pre-emit diagnostics which indicate invalid\n * new expression or super call signatures. See the list of diagnostics here:\n *\n * https://github.com/Microsoft/TypeScript/blob/master/src/compiler/diagnosticMessages.json\n */\nconst signatureErrorDiagnostics = [\n  // Type not assignable error diagnostic.\n  2345,\n  // Constructor argument length invalid diagnostics\n  2554,\n  2555,\n  2556,\n  2557,\n];\n\n/**\n * Migration that visits every TypeScript new expression or super call and checks if\n * the parameter type signature is invalid and needs to be updated manually.\n */\nexport class ConstructorSignatureMigration extends Migration<UpgradeData> {\n  // Note that the data for this rule is not distinguished based on the target version because\n  // we don't keep track of the new signature and don't want to update incrementally.\n  // See: https://github.com/angular/components/pull/12970#issuecomment-418337566\n  data = getAllChanges(this.upgradeData.constructorChecks);\n\n  // Only enable the migration rule if there is upgrade data.\n  enabled = this.data.length !== 0;\n\n  visitNode(node: ts.Node): void {\n    if (ts.isSourceFile(node)) {\n      this._visitSourceFile(node);\n    }\n  }\n\n  /**\n   * Method that will be called for each source file of the upgrade project. In order to\n   * properly determine invalid constructor signatures, we take advantage of the pre-emit\n   * diagnostics from TypeScript.\n   *\n   * By using the diagnostics, the migration can handle type assignability. Not using\n   * diagnostics would mean that we need to use simple type equality checking which is\n   * too strict. See related issue: https://github.com/Microsoft/TypeScript/issues/9879\n   */\n  private _visitSourceFile(sourceFile: ts.SourceFile) {\n    // List of classes of which the constructor signature has changed.\n    const diagnostics =\n        ts.getPreEmitDiagnostics(this.program, sourceFile)\n            .filter(diagnostic => signatureErrorDiagnostics.includes(diagnostic.code))\n            .filter(diagnostic => diagnostic.start !== undefined);\n\n    for (const diagnostic of diagnostics) {\n      const node = findConstructorNode(diagnostic, sourceFile);\n\n      if (!node) {\n        continue;\n      }\n\n      const classType = this.typeChecker.getTypeAtLocation(node.expression);\n      const className = classType.symbol && classType.symbol.name;\n      const isNewExpression = ts.isNewExpression(node);\n\n      // Determine the class names of the actual construct signatures because we cannot assume that\n      // the diagnostic refers to a constructor of the actual expression. In case the constructor\n      // is inherited, we need to detect that the owner-class of the constructor is added to the\n      // constructor checks upgrade data. e.g. `class CustomCalendar extends MatCalendar {}`.\n      const signatureClassNames =\n          classType.getConstructSignatures()\n              .map(signature => getClassDeclarationOfSignature(signature))\n              .map(declaration => declaration && declaration.name ? declaration.name.text : null)\n              .filter(Boolean);\n\n      // Besides checking the signature class names, we need to check the actual class name because\n      // there can be classes without an explicit constructor.\n      if (!this.data.includes(className) &&\n          !signatureClassNames.some(name => this.data.includes(name!))) {\n        continue;\n      }\n\n      const classSignatures = classType.getConstructSignatures().map(\n          signature => getParameterTypesFromSignature(signature, this.typeChecker));\n\n      const expressionName = isNewExpression ? `new ${className}` : 'super';\n      const signatures =\n          classSignatures.map(signature => signature.map(t => this.typeChecker.typeToString(t)))\n              .map(signature => `${expressionName}(${signature.join(', ')})`)\n              .join(' or ');\n\n      this.createFailureAtNode(\n          node,\n          `Found \"${className}\" constructed with ` +\n              `an invalid signature. Please manually update the ${expressionName} expression to ` +\n              `match the new signature${classSignatures.length > 1 ? 's' : ''}: ${signatures}`);\n    }\n  }\n}\n\n\n/** Resolves the type for each parameter in the specified signature. */\nfunction getParameterTypesFromSignature(\n    signature: ts.Signature, typeChecker: ts.TypeChecker): ts.Type[] {\n  return signature.getParameters().map(\n      param => typeChecker.getTypeAtLocation(param.declarations[0]));\n}\n\n/**\n * Walks through each node of a source file in order to find a new-expression node or super-call\n * expression node that is captured by the specified diagnostic.\n */\nfunction findConstructorNode(\n    diagnostic: ts.Diagnostic, sourceFile: ts.SourceFile): ts.CallExpression|ts.NewExpression|null {\n  let resolvedNode: ts.Node|null = null;\n\n  const _visitNode = (node: ts.Node) => {\n    // Check whether the current node contains the diagnostic. If the node contains the diagnostic,\n    // walk deeper in order to find all constructor expression nodes.\n    if (node.getStart() <= diagnostic.start! && node.getEnd() >= diagnostic.start!) {\n      if (ts.isNewExpression(node) ||\n          (ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.SuperKeyword)) {\n        resolvedNode = node;\n      }\n\n      ts.forEachChild(node, _visitNode);\n    }\n  };\n\n  ts.forEachChild(sourceFile, _visitNode);\n\n  return resolvedNode;\n}\n\n/** Determines the class declaration of the specified construct signature. */\nfunction getClassDeclarationOfSignature(signature: ts.Signature): ts.ClassDeclaration|null {\n  let node: ts.Node = signature.getDeclaration();\n  // Handle signatures which don't have an actual declaration. This happens if a class\n  // does not have an explicitly written constructor.\n  if (!node) {\n    return null;\n  }\n  while (!ts.isSourceFile(node = node.parent)) {\n    if (ts.isClassDeclaration(node)) {\n      return node;\n    }\n  }\n  return null;\n}\n"]}

package/schematics/ng-update/{upgrade-rules/css-selectors-rule.d.ts → migrations/css-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/css-selectors-rule" />
+/// <amd-module name="@angular/cdk/schematics/ng-update/migrations/css-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';
 /**
- * Rule that walks through every string literal, template and stylesheet in
+ * Migration that walks through every string literal, template and stylesheet in
  * order to migrate outdated CSS selectors to the new selector.
  */
-export declare class CssSelectorsRule extends MigrationRule<RuleUpgradeData> {
+export declare class CssSelectorsMigration extends Migration<UpgradeData> {
     /** Change data that upgrades to the 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/css-selectors.js

@@ -0,0 +1,83 @@
+/**
+ * @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/css-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 migrate outdated CSS selectors to the new selector.
+     */
+    class CssSelectorsMigration extends migration_1.Migration {
+        constructor() {
+            super(...arguments);
+            /** Change data that upgrades to the specified target version. */
+            this.data = upgrade_data_1.getVersionUpgradeData(this, 'cssSelectors');
+            // 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(data => {
+                if (data.whitelist && !data.whitelist.html) {
+                    return;
+                }
+                literal_1.findAllSubstringIndices(template.content, data.replace)
+                    .map(offset => template.start + offset)
+                    .forEach(start => this._replaceSelector(template.filePath, start, data));
+            });
+        }
+        visitStylesheet(stylesheet) {
+            this.data.forEach(data => {
+                if (data.whitelist && !data.whitelist.stylesheet) {
+                    return;
+                }
+                literal_1.findAllSubstringIndices(stylesheet.content, data.replace)
+                    .map(offset => stylesheet.start + offset)
+                    .forEach(start => this._replaceSelector(stylesheet.filePath, start, data));
+            });
+        }
+        _visitStringLiteralLike(node) {
+            if (node.parent && node.parent.kind !== ts.SyntaxKind.CallExpression) {
+                return;
+            }
+            const textContent = node.getText();
+            const filePath = node.getSourceFile().fileName;
+            this.data.forEach(data => {
+                if (data.whitelist && !data.whitelist.strings) {
+                    return;
+                }
+                literal_1.findAllSubstringIndices(textContent, data.replace)
+                    .map(offset => node.getStart() + offset)
+                    .forEach(start => this._replaceSelector(filePath, start, data));
+            });
+        }
+        _replaceSelector(filePath, start, data) {
+            this.fileSystem.edit(filePath)
+                .remove(start, data.replace.length)
+                .insertRight(start, data.replaceWith);
+        }
+    }
+    exports.CssSelectorsMigration = CssSelectorsMigration;
+});
+//# sourceMappingURL=data:application/json;base64,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

package/schematics/ng-update/{upgrade-rules/element-selectors-rule.d.ts → migrations/element-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/element-selectors-rule" />
+/// <amd-module name="@angular/cdk/schematics/ng-update/migrations/element-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';
 /**
- * Rule that walks through every string literal, template and stylesheet in order
+ * Migration that walks through every string literal, template and stylesheet in order
  * to migrate outdated element selectors to the new one.
  */
-export declare class ElementSelectorsRule extends MigrationRule<RuleUpgradeData> {
+export declare class ElementSelectorsMigration extends Migration<UpgradeData> {
     /** Change data that upgrades to the 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/element-selectors.js

@@ -0,0 +1,74 @@
+/**
+ * @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/element-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 migrate outdated element selectors to the new one.
+     */
+    class ElementSelectorsMigration extends migration_1.Migration {
+        constructor() {
+            super(...arguments);
+            /** Change data that upgrades to the specified target version. */
+            this.data = upgrade_data_1.getVersionUpgradeData(this, 'elementSelectors');
+            // 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 => {
+                literal_1.findAllSubstringIndices(stylesheet.content, selector.replace)
+                    .map(offset => stylesheet.start + offset)
+                    .forEach(start => this._replaceSelector(stylesheet.filePath, start, selector));
+            });
+        }
+        _visitStringLiteralLike(node) {
+            if (node.parent && node.parent.kind !== ts.SyntaxKind.CallExpression) {
+                return;
+            }
+            const textContent = node.getText();
+            const filePath = node.getSourceFile().fileName;
+            this.data.forEach(selector => {
+                literal_1.findAllSubstringIndices(textContent, selector.replace)
+                    .map(offset => node.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.ElementSelectorsMigration = ElementSelectorsMigration;
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZWxlbWVudC1zZWxlY3RvcnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMvY2RrL3NjaGVtYXRpY3MvbmctdXBkYXRlL21pZ3JhdGlvbnMvZWxlbWVudC1zZWxlY3RvcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HOzs7Ozs7Ozs7Ozs7SUFFSCxpQ0FBaUM7SUFFakMsNkVBQXNEO0lBRXRELGtGQUE4RDtJQUM5RCxpRkFBbUU7SUFFbkU7OztPQUdHO0lBQ0gsTUFBYSx5QkFBMEIsU0FBUSxxQkFBc0I7UUFBckU7O1lBQ0UsaUVBQWlFO1lBQ2pFLFNBQUksR0FBRyxvQ0FBcUIsQ0FBQyxJQUFJLEVBQUUsa0JBQWtCLENBQUMsQ0FBQztZQUV2RCwyREFBMkQ7WUFDM0QsWUFBTyxHQUFHLElBQUksQ0FBQyxJQUFJLENBQUMsTUFBTSxLQUFLLENBQUMsQ0FBQztRQTRDbkMsQ0FBQztRQTFDQyxTQUFTLENBQUMsSUFBYTtZQUNyQixJQUFJLEVBQUUsQ0FBQyxtQkFBbUIsQ0FBQyxJQUFJLENBQUMsRUFBRTtnQkFDaEMsSUFBSSxDQUFDLHVCQUF1QixDQUFDLElBQUksQ0FBQyxDQUFDO2FBQ3BDO1FBQ0gsQ0FBQztRQUVELGFBQWEsQ0FBQyxRQUEwQjtZQUN0QyxJQUFJLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxRQUFRLENBQUMsRUFBRTtnQkFDM0IsaUNBQXVCLENBQUMsUUFBUSxDQUFDLE9BQU8sRUFBRSxRQUFRLENBQUMsT0FBTyxDQUFDO3FCQUN0RCxHQUFHLENBQUMsTUFBTSxDQUFDLEVBQUUsQ0FBQyxRQUFRLENBQUMsS0FBSyxHQUFHLE1BQU0sQ0FBQztxQkFDdEMsT0FBTyxDQUFDLEtBQUssQ0FBQyxFQUFFLENBQUMsSUFBSSxDQUFDLGdCQUFnQixDQUFDLFFBQVEsQ0FBQyxRQUFRLEVBQUUsS0FBSyxFQUFFLFFBQVEsQ0FBQyxDQUFDLENBQUM7WUFDbkYsQ0FBQyxDQUFDLENBQUM7UUFDTCxDQUFDO1FBRUQsZUFBZSxDQUFDLFVBQTRCO1lBQzFDLElBQUksQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLFFBQVEsQ0FBQyxFQUFFO2dCQUMzQixpQ0FBdUIsQ0FBQyxVQUFVLENBQUMsT0FBTyxFQUFFLFFBQVEsQ0FBQyxPQUFPLENBQUM7cUJBQ3hELEdBQUcsQ0FBQyxNQUFNLENBQUMsRUFBRSxDQUFDLFVBQVUsQ0FBQyxLQUFLLEdBQUcsTUFBTSxDQUFDO3FCQUN4QyxPQUFPLENBQUMsS0FBSyxDQUFDLEVBQUUsQ0FBQyxJQUFJLENBQUMsZ0JBQWdCLENBQUMsVUFBVSxDQUFDLFFBQVEsRUFBRSxLQUFLLEVBQUUsUUFBUSxDQUFDLENBQUMsQ0FBQztZQUNyRixDQUFDLENBQUMsQ0FBQztRQUNMLENBQUM7UUFFTyx1QkFBdUIsQ0FBQyxJQUEwQjtZQUN4RCxJQUFJLElBQUksQ0FBQyxNQUFNLElBQUksSUFBSSxDQUFDLE1BQU0sQ0FBQyxJQUFJLEtBQUssRUFBRSxDQUFDLFVBQVUsQ0FBQyxjQUFjLEVBQUU7Z0JBQ3BFLE9BQU87YUFDUjtZQUVELE1BQU0sV0FBVyxHQUFHLElBQUksQ0FBQyxPQUFPLEVBQUUsQ0FBQztZQUNuQyxNQUFNLFFBQVEsR0FBRyxJQUFJLENBQUMsYUFBYSxFQUFFLENBQUMsUUFBUSxDQUFDO1lBRS9DLElBQUksQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLFFBQVEsQ0FBQyxFQUFFO2dCQUMzQixpQ0FBdUIsQ0FBQyxXQUFXLEVBQUUsUUFBUSxDQUFDLE9BQU8sQ0FBQztxQkFDakQsR0FBRyxDQUFDLE1BQU0sQ0FBQyxFQUFFLENBQUMsSUFBSSxDQUFDLFFBQVEsRUFBRSxHQUFHLE1BQU0sQ0FBQztxQkFDdkMsT0FBTyxDQUFDLEtBQUssQ0FBQyxFQUFFLENBQUMsSUFBSSxDQUFDLGdCQUFnQixDQUFDLFFBQVEsRUFBRSxLQUFLLEVBQUUsUUFBUSxDQUFDLENBQUMsQ0FBQztZQUMxRSxDQUFDLENBQUMsQ0FBQztRQUNMLENBQUM7UUFFTyxnQkFBZ0IsQ0FBQyxRQUFnQixFQUFFLEtBQWEsRUFBRSxJQUFnQztZQUN4RixJQUFJLENBQUMsVUFBVSxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUM7aUJBQzNCLE1BQU0sQ0FBQyxLQUFLLEVBQUUsSUFBSSxDQUFDLE9BQU8sQ0FBQyxNQUFNLENBQUM7aUJBQ2xDLFdBQVcsQ0FBQyxLQUFLLEVBQUUsSUFBSSxDQUFDLFdBQVcsQ0FBQyxDQUFDO1FBQzFDLENBQUM7S0FDRjtJQWpERCw4REFpREMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuaW1wb3J0ICogYXMgdHMgZnJvbSAndHlwZXNjcmlwdCc7XG5pbXBvcnQge1Jlc29sdmVkUmVzb3VyY2V9IGZyb20gJy4uLy4uL3VwZGF0ZS10b29sL2NvbXBvbmVudC1yZXNvdXJjZS1jb2xsZWN0b3InO1xuaW1wb3J0IHtNaWdyYXRpb259IGZyb20gJy4uLy4uL3VwZGF0ZS10b29sL21pZ3JhdGlvbic7XG5pbXBvcnQge0VsZW1lbnRTZWxlY3RvclVwZ3JhZGVEYXRhfSBmcm9tICcuLi9kYXRhL2VsZW1lbnQtc2VsZWN0b3JzJztcbmltcG9ydCB7ZmluZEFsbFN1YnN0cmluZ0luZGljZXN9IGZyb20gJy4uL3R5cGVzY3JpcHQvbGl0ZXJhbCc7XG5pbXBvcnQge2dldFZlcnNpb25VcGdyYWRlRGF0YSwgVXBncmFkZURhdGF9IGZyb20gJy4uL3VwZ3JhZGUtZGF0YSc7XG5cbi8qKlxuICogTWlncmF0aW9uIHRoYXQgd2Fsa3MgdGhyb3VnaCBldmVyeSBzdHJpbmcgbGl0ZXJhbCwgdGVtcGxhdGUgYW5kIHN0eWxlc2hlZXQgaW4gb3JkZXJcbiAqIHRvIG1pZ3JhdGUgb3V0ZGF0ZWQgZWxlbWVudCBzZWxlY3RvcnMgdG8gdGhlIG5ldyBvbmUuXG4gKi9cbmV4cG9ydCBjbGFzcyBFbGVtZW50U2VsZWN0b3JzTWlncmF0aW9uIGV4dGVuZHMgTWlncmF0aW9uPFVwZ3JhZGVEYXRhPiB7XG4gIC8qKiBDaGFuZ2UgZGF0YSB0aGF0IHVwZ3JhZGVzIHRvIHRoZSBzcGVjaWZpZWQgdGFyZ2V0IHZlcnNpb24uICovXG4gIGRhdGEgPSBnZXRWZXJzaW9uVXBncmFkZURhdGEodGhpcywgJ2VsZW1lbnRTZWxlY3RvcnMnKTtcblxuICAvLyBPbmx5IGVuYWJsZSB0aGUgbWlncmF0aW9uIHJ1bGUgaWYgdGhlcmUgaXMgdXBncmFkZSBkYXRhLlxuICBlbmFibGVkID0gdGhpcy5kYXRhLmxlbmd0aCAhPT0gMDtcblxuICB2aXNpdE5vZGUobm9kZTogdHMuTm9kZSk6IHZvaWQge1xuICAgIGlmICh0cy5pc1N0cmluZ0xpdGVyYWxMaWtlKG5vZGUpKSB7XG4gICAgICB0aGlzLl92aXNpdFN0cmluZ0xpdGVyYWxMaWtlKG5vZGUpO1xuICAgIH1cbiAgfVxuXG4gIHZpc2l0VGVtcGxhdGUodGVtcGxhdGU6IFJlc29sdmVkUmVzb3VyY2UpOiB2b2lkIHtcbiAgICB0aGlzLmRhdGEuZm9yRWFjaChzZWxlY3RvciA9PiB7XG4gICAgICBmaW5kQWxsU3Vic3RyaW5nSW5kaWNlcyh0ZW1wbGF0ZS5jb250ZW50LCBzZWxlY3Rvci5yZXBsYWNlKVxuICAgICAgICAgIC5tYXAob2Zmc2V0ID0+IHRlbXBsYXRlLnN0YXJ0ICsgb2Zmc2V0KVxuICAgICAgICAgIC5mb3JFYWNoKHN0YXJ0ID0+IHRoaXMuX3JlcGxhY2VTZWxlY3Rvcih0ZW1wbGF0ZS5maWxlUGF0aCwgc3RhcnQsIHNlbGVjdG9yKSk7XG4gICAgfSk7XG4gIH1cblxuICB2aXNpdFN0eWxlc2hlZXQoc3R5bGVzaGVldDogUmVzb2x2ZWRSZXNvdXJjZSk6IHZvaWQge1xuICAgIHRoaXMuZGF0YS5mb3JFYWNoKHNlbGVjdG9yID0+IHtcbiAgICAgIGZpbmRBbGxTdWJzdHJpbmdJbmRpY2VzKHN0eWxlc2hlZXQuY29udGVudCwgc2VsZWN0b3IucmVwbGFjZSlcbiAgICAgICAgICAubWFwKG9mZnNldCA9PiBzdHlsZXNoZWV0LnN0YXJ0ICsgb2Zmc2V0KVxuICAgICAgICAgIC5mb3JFYWNoKHN0YXJ0ID0+IHRoaXMuX3JlcGxhY2VTZWxlY3RvcihzdHlsZXNoZWV0LmZpbGVQYXRoLCBzdGFydCwgc2VsZWN0b3IpKTtcbiAgICB9KTtcbiAgfVxuXG4gIHByaXZhdGUgX3Zpc2l0U3RyaW5nTGl0ZXJhbExpa2Uobm9kZTogdHMuU3RyaW5nTGl0ZXJhbExpa2UpIHtcbiAgICBpZiAobm9kZS5wYXJlbnQgJiYgbm9kZS5wYXJlbnQua2luZCAhPT0gdHMuU3ludGF4S2luZC5DYWxsRXhwcmVzc2lvbikge1xuICAgICAgcmV0dXJuO1xuICAgIH1cblxuICAgIGNvbnN0IHRleHRDb250ZW50ID0gbm9kZS5nZXRUZXh0KCk7XG4gICAgY29uc3QgZmlsZVBhdGggPSBub2RlLmdldFNvdXJjZUZpbGUoKS5maWxlTmFtZTtcblxuICAgIHRoaXMuZGF0YS5mb3JFYWNoKHNlbGVjdG9yID0+IHtcbiAgICAgIGZpbmRBbGxTdWJzdHJpbmdJbmRpY2VzKHRleHRDb250ZW50LCBzZWxlY3Rvci5yZXBsYWNlKVxuICAgICAgICAgIC5tYXAob2Zmc2V0ID0+IG5vZGUuZ2V0U3RhcnQoKSArIG9mZnNldClcbiAgICAgICAgICAuZm9yRWFjaChzdGFydCA9PiB0aGlzLl9yZXBsYWNlU2VsZWN0b3IoZmlsZVBhdGgsIHN0YXJ0LCBzZWxlY3RvcikpO1xuICAgIH0pO1xuICB9XG5cbiAgcHJpdmF0ZSBfcmVwbGFjZVNlbGVjdG9yKGZpbGVQYXRoOiBzdHJpbmcsIHN0YXJ0OiBudW1iZXIsIGRhdGE6IEVsZW1lbnRTZWxlY3RvclVwZ3JhZGVEYXRhKSB7XG4gICAgdGhpcy5maWxlU3lzdGVtLmVkaXQoZmlsZVBhdGgpXG4gICAgICAucmVtb3ZlKHN0YXJ0LCBkYXRhLnJlcGxhY2UubGVuZ3RoKVxuICAgICAgLmluc2VydFJpZ2h0KHN0YXJ0LCBkYXRhLnJlcGxhY2VXaXRoKTtcbiAgfVxufVxuIl19

package/schematics/ng-update/{upgrade-rules/input-names-rule.d.ts → migrations/input-names.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/input-names-rule" />
+/// <amd-module name="@angular/cdk/schematics/ng-update/migrations/input-names" />
 import { ResolvedResource } from '../../update-tool/component-resource-collector';
-import { MigrationRule } from '../../update-tool/migration-rule';
+import { Migration } from '../../update-tool/migration';
 import { InputNameUpgradeData } from '../data';
-import { RuleUpgradeData } from '../upgrade-data';
+import { UpgradeData } from '../upgrade-data';
 /**
- * Rule that walks through every template or stylesheet and replaces outdated input
+ * Migration that walks through every template or stylesheet and replaces outdated input
  * names to the new input name. Selectors in stylesheets could also target input
  * bindings declared as static attribute. See for example:
  *
  * e.g. `<my-component color="primary">` becomes `my-component[color]`
  */
-export declare class InputNamesRule extends MigrationRule<RuleUpgradeData> {
+export declare class InputNamesMigration extends Migration<UpgradeData> {
     /** Change data that upgrades to the specified target version. */
     data: InputNameUpgradeData[];
-    ruleEnabled: boolean;
+    enabled: boolean;
     visitStylesheet(stylesheet: ResolvedResource): void;
     visitTemplate(template: ResolvedResource): void;
     private _replaceInputName;