@angular/material 9.2.0 → 9.2.4

package/schematics/ng-update/migrations/misc-ripples-v7/ripple-speed-factor-migration.js

@@ -0,0 +1,147 @@
+/**
+ * @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/material/schematics/ng-update/migrations/misc-ripples-v7/ripple-speed-factor-migration", ["require", "exports", "@angular/cdk/schematics", "typescript", "@angular/material/schematics/ng-update/migrations/misc-ripples-v7/ripple-speed-factor"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    const schematics_1 = require("@angular/cdk/schematics");
+    const ts = require("typescript");
+    const ripple_speed_factor_1 = require("@angular/material/schematics/ng-update/migrations/misc-ripples-v7/ripple-speed-factor");
+    /** Regular expression that matches [matRippleSpeedFactor]="$NUMBER" in templates. */
+    const speedFactorNumberRegex = /\[matRippleSpeedFactor]="(\d+(?:\.\d+)?)"/g;
+    /** Regular expression that matches [matRippleSpeedFactor]="$NOT_A_NUMBER" in templates. */
+    const speedFactorNotParseable = /\[matRippleSpeedFactor]="(?!\d+(?:\.\d+)?")(.*)"/g;
+    /**
+     * Note that will be added whenever a speed factor expression has been converted to calculate
+     * the according duration. This note should encourage people to clean up their code by switching
+     * away from the speed factors to explicit durations.
+     */
+    const removeNote = `TODO: Cleanup duration calculation.`;
+    /**
+     * Migration that walks through every property assignment and switches the global `baseSpeedFactor`
+     * ripple option to the new global animation config. Also updates every class member assignment
+     * that refers to MatRipple#speedFactor.
+     */
+    class RippleSpeedFactorMigration extends schematics_1.Migration {
+        constructor() {
+            super(...arguments);
+            // Only enable this rule if the migration targets version 7 as the ripple
+            // speed factor has been removed in that version.
+            this.enabled = this.targetVersion === schematics_1.TargetVersion.V7;
+        }
+        visitNode(node) {
+            if (ts.isBinaryExpression(node)) {
+                this._visitBinaryExpression(node);
+            }
+            else if (ts.isPropertyAssignment(node)) {
+                this._visitPropertyAssignment(node);
+            }
+        }
+        visitTemplate(template) {
+            let match;
+            while ((match = speedFactorNumberRegex.exec(template.content)) !== null) {
+                const newEnterDuration = ripple_speed_factor_1.convertSpeedFactorToDuration(parseFloat(match[1]));
+                this._replaceText(template.filePath, template.start + match.index, match[0].length, `[matRippleAnimation]="{enterDuration: ${newEnterDuration}}"`);
+            }
+            while ((match = speedFactorNotParseable.exec(template.content)) !== null) {
+                const newDurationExpression = ripple_speed_factor_1.createSpeedFactorConvertExpression(match[1]);
+                this._replaceText(template.filePath, template.start + match.index, match[0].length, `[matRippleAnimation]="{enterDuration: (${newDurationExpression})}"`);
+            }
+        }
+        /** Switches binary expressions (e.g. myRipple.speedFactor = 0.5) to the new animation config. */
+        _visitBinaryExpression(expression) {
+            if (!ts.isPropertyAccessExpression(expression.left)) {
+                return;
+            }
+            // Left side expression consists of target object and property name (e.g. myInstance.val)
+            const leftExpression = expression.left;
+            const targetTypeNode = this.typeChecker.getTypeAtLocation(leftExpression.expression);
+            if (!targetTypeNode.symbol) {
+                return;
+            }
+            const targetTypeName = targetTypeNode.symbol.getName();
+            const propertyName = leftExpression.name.getText();
+            const filePath = leftExpression.getSourceFile().fileName;
+            if (targetTypeName === 'MatRipple' && propertyName === 'speedFactor') {
+                if (ts.isNumericLiteral(expression.right)) {
+                    const numericValue = parseFloat(expression.right.text);
+                    const newEnterDurationValue = ripple_speed_factor_1.convertSpeedFactorToDuration(numericValue);
+                    // Replace the `speedFactor` property name with `animation`.
+                    this._replaceText(filePath, leftExpression.name.getStart(), leftExpression.name.getWidth(), 'animation');
+                    // Replace the value assignment with the new animation config.
+                    this._replaceText(filePath, expression.right.getStart(), expression.right.getWidth(), `{enterDuration: ${newEnterDurationValue}}`);
+                }
+                else {
+                    // Handle the right expression differently if the previous speed factor value can't
+                    // be resolved statically. In that case, we just create a TypeScript expression that
+                    // calculates the explicit duration based on the non-static speed factor expression.
+                    const newExpression = ripple_speed_factor_1.createSpeedFactorConvertExpression(expression.right.getText());
+                    // Replace the `speedFactor` property name with `animation`.
+                    this._replaceText(filePath, leftExpression.name.getStart(), leftExpression.name.getWidth(), 'animation');
+                    // Replace the value assignment with the new animation config and remove TODO.
+                    this._replaceText(filePath, expression.right.getStart(), expression.right.getWidth(), `/** ${removeNote} */ {enterDuration: ${newExpression}}`);
+                }
+            }
+        }
+        /**
+         * Switches the global option `baseSpeedFactor` to the new animation config. For this
+         * we assume that the `baseSpeedFactor` is not used in combination with individual
+         * speed factors.
+         */
+        _visitPropertyAssignment(assignment) {
+            // For switching the `baseSpeedFactor` global option we expect the property assignment
+            // to be inside of a normal object literal. Custom ripple global options cannot be
+            // witched automatically.
+            if (!ts.isObjectLiteralExpression(assignment.parent)) {
+                return;
+            }
+            // The assignment consists of a name (key) and initializer (value).
+            if (assignment.name.getText() !== 'baseSpeedFactor') {
+                return;
+            }
+            // We could technically lazily check for the MAT_RIPPLE_GLOBAL_OPTIONS injection token to
+            // be present, but it's not right to assume that everyone sets the ripple global options
+            // immediately in the provider object (e.g. it can happen that someone just imports the
+            // config from a separate file).
+            const { initializer, name } = assignment;
+            const filePath = assignment.getSourceFile().fileName;
+            if (ts.isNumericLiteral(initializer)) {
+                const numericValue = parseFloat(initializer.text);
+                const newEnterDurationValue = ripple_speed_factor_1.convertSpeedFactorToDuration(numericValue);
+                // Replace the `baseSpeedFactor` property name with `animation`.
+                this._replaceText(filePath, name.getStart(), name.getWidth(), 'animation');
+                // Replace the value assignment initializer with the new animation config.
+                this._replaceText(filePath, initializer.getStart(), initializer.getWidth(), `{enterDuration: ${newEnterDurationValue}}`);
+            }
+            else {
+                // Handle the right expression differently if the previous speed factor value can't
+                // be resolved statically. In that case, we just create a TypeScript expression that
+                // calculates the explicit duration based on the non-static speed factor expression.
+                const newExpression = ripple_speed_factor_1.createSpeedFactorConvertExpression(initializer.getText());
+                // Replace the `baseSpeedFactor` property name with `animation`.
+                this._replaceText(filePath, name.getStart(), name.getWidth(), 'animation');
+                // Replace the value assignment with the new animation config and remove TODO.
+                this._replaceText(filePath, initializer.getStart(), initializer.getWidth(), `/** ${removeNote} */ {enterDuration: ${newExpression}}`);
+            }
+        }
+        _replaceText(filePath, start, width, newText) {
+            const recorder = this.fileSystem.edit(filePath);
+            recorder.remove(start, width);
+            recorder.insertRight(start, newText);
+        }
+    }
+    exports.RippleSpeedFactorMigration = RippleSpeedFactorMigration;
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ripple-speed-factor-migration.js","sourceRoot":"","sources":["../../../../../../../../../src/material/schematics/ng-update/migrations/misc-ripples-v7/ripple-speed-factor-migration.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 {Migration, ResolvedResource, TargetVersion} from '@angular/cdk/schematics';\nimport * as ts from 'typescript';\nimport {\n  convertSpeedFactorToDuration,\n  createSpeedFactorConvertExpression,\n} from './ripple-speed-factor';\n\n/** Regular expression that matches [matRippleSpeedFactor]=\"$NUMBER\" in templates. */\nconst speedFactorNumberRegex = /\\[matRippleSpeedFactor]=\"(\\d+(?:\\.\\d+)?)\"/g;\n\n/** Regular expression that matches [matRippleSpeedFactor]=\"$NOT_A_NUMBER\" in templates. */\nconst speedFactorNotParseable = /\\[matRippleSpeedFactor]=\"(?!\\d+(?:\\.\\d+)?\")(.*)\"/g;\n\n/**\n * Note that will be added whenever a speed factor expression has been converted to calculate\n * the according duration. This note should encourage people to clean up their code by switching\n * away from the speed factors to explicit durations.\n */\nconst removeNote = `TODO: Cleanup duration calculation.`;\n\n/**\n * Migration that walks through every property assignment and switches the global `baseSpeedFactor`\n * ripple option to the new global animation config. Also updates every class member assignment\n * that refers to MatRipple#speedFactor.\n */\nexport class RippleSpeedFactorMigration extends Migration<null> {\n\n  // Only enable this rule if the migration targets version 7 as the ripple\n  // speed factor has been removed in that version.\n  enabled = this.targetVersion === TargetVersion.V7;\n\n  visitNode(node: ts.Node): void {\n    if (ts.isBinaryExpression(node)) {\n      this._visitBinaryExpression(node);\n    } else if (ts.isPropertyAssignment(node)) {\n      this._visitPropertyAssignment(node);\n    }\n  }\n\n  visitTemplate(template: ResolvedResource): void {\n    let match: RegExpMatchArray|null;\n\n    while ((match = speedFactorNumberRegex.exec(template.content)) !== null) {\n      const newEnterDuration = convertSpeedFactorToDuration(parseFloat(match[1]));\n\n      this._replaceText(\n          template.filePath, template.start + match.index!, match[0].length,\n          `[matRippleAnimation]=\"{enterDuration: ${newEnterDuration}}\"`);\n    }\n\n    while ((match = speedFactorNotParseable.exec(template.content)) !== null) {\n      const newDurationExpression = createSpeedFactorConvertExpression(match[1]);\n      this._replaceText(\n          template.filePath, template.start + match.index!, match[0].length,\n          `[matRippleAnimation]=\"{enterDuration: (${newDurationExpression})}\"`);\n    }\n  }\n\n  /** Switches binary expressions (e.g. myRipple.speedFactor = 0.5) to the new animation config. */\n  private _visitBinaryExpression(expression: ts.BinaryExpression) {\n    if (!ts.isPropertyAccessExpression(expression.left)) {\n      return;\n    }\n\n    // Left side expression consists of target object and property name (e.g. myInstance.val)\n    const leftExpression = expression.left as ts.PropertyAccessExpression;\n    const targetTypeNode = this.typeChecker.getTypeAtLocation(leftExpression.expression);\n\n    if (!targetTypeNode.symbol) {\n      return;\n    }\n\n    const targetTypeName = targetTypeNode.symbol.getName();\n    const propertyName = leftExpression.name.getText();\n    const filePath = leftExpression.getSourceFile().fileName;\n\n    if (targetTypeName === 'MatRipple' && propertyName === 'speedFactor') {\n      if (ts.isNumericLiteral(expression.right)) {\n        const numericValue = parseFloat(expression.right.text);\n        const newEnterDurationValue = convertSpeedFactorToDuration(numericValue);\n\n        // Replace the `speedFactor` property name with `animation`.\n        this._replaceText(\n            filePath, leftExpression.name.getStart(), leftExpression.name.getWidth(), 'animation');\n\n        // Replace the value assignment with the new animation config.\n        this._replaceText(\n            filePath, expression.right.getStart(), expression.right.getWidth(),\n            `{enterDuration: ${newEnterDurationValue}}`);\n      } else {\n        // Handle the right expression differently if the previous speed factor value can't\n        // be resolved statically. In that case, we just create a TypeScript expression that\n        // calculates the explicit duration based on the non-static speed factor expression.\n        const newExpression = createSpeedFactorConvertExpression(expression.right.getText());\n\n        // Replace the `speedFactor` property name with `animation`.\n        this._replaceText(\n            filePath, leftExpression.name.getStart(), leftExpression.name.getWidth(), 'animation');\n\n        // Replace the value assignment with the new animation config and remove TODO.\n        this._replaceText(\n            filePath, expression.right.getStart(), expression.right.getWidth(),\n            `/** ${removeNote} */ {enterDuration: ${newExpression}}`);\n      }\n    }\n  }\n\n  /**\n   * Switches the global option `baseSpeedFactor` to the new animation config. For this\n   * we assume that the `baseSpeedFactor` is not used in combination with individual\n   * speed factors.\n   */\n  private _visitPropertyAssignment(assignment: ts.PropertyAssignment) {\n    // For switching the `baseSpeedFactor` global option we expect the property assignment\n    // to be inside of a normal object literal. Custom ripple global options cannot be\n    // witched automatically.\n    if (!ts.isObjectLiteralExpression(assignment.parent)) {\n      return;\n    }\n\n    // The assignment consists of a name (key) and initializer (value).\n    if (assignment.name.getText() !== 'baseSpeedFactor') {\n      return;\n    }\n\n    // We could technically lazily check for the MAT_RIPPLE_GLOBAL_OPTIONS injection token to\n    // be present, but it's not right to assume that everyone sets the ripple global options\n    // immediately in the provider object (e.g. it can happen that someone just imports the\n    // config from a separate file).\n\n    const {initializer, name} = assignment;\n    const filePath = assignment.getSourceFile().fileName;\n\n    if (ts.isNumericLiteral(initializer)) {\n      const numericValue = parseFloat(initializer.text);\n      const newEnterDurationValue = convertSpeedFactorToDuration(numericValue);\n\n      // Replace the `baseSpeedFactor` property name with `animation`.\n      this._replaceText(filePath, name.getStart(), name.getWidth(), 'animation');\n      // Replace the value assignment initializer with the new animation config.\n      this._replaceText(\n          filePath, initializer.getStart(), initializer.getWidth(),\n          `{enterDuration: ${newEnterDurationValue}}`);\n    } else {\n      // Handle the right expression differently if the previous speed factor value can't\n      // be resolved statically. In that case, we just create a TypeScript expression that\n      // calculates the explicit duration based on the non-static speed factor expression.\n      const newExpression = createSpeedFactorConvertExpression(initializer.getText());\n\n      // Replace the `baseSpeedFactor` property name with `animation`.\n      this._replaceText(filePath, name.getStart(), name.getWidth(), 'animation');\n\n      // Replace the value assignment with the new animation config and remove TODO.\n      this._replaceText(\n          filePath, initializer.getStart(), initializer.getWidth(),\n          `/** ${removeNote} */ {enterDuration: ${newExpression}}`);\n    }\n  }\n\n  private _replaceText(filePath: string, start: number, width: number, newText: string) {\n    const recorder = this.fileSystem.edit(filePath);\n    recorder.remove(start, width);\n    recorder.insertRight(start, newText);\n  }\n}\n"]}

package/schematics/ng-update/{upgrade-rules → migrations}/misc-ripples-v7/ripple-speed-factor.d.ts

@@ -5,7 +5,7 @@
  * 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/material/schematics/ng-update/upgrade-rules/misc-ripples-v7/ripple-speed-factor" />
+/// <amd-module name="@angular/material/schematics/ng-update/migrations/misc-ripples-v7/ripple-speed-factor" />
 /** Converts the specified speed factor into the exact static enter duration. */
 export declare function convertSpeedFactorToDuration(factor: number): number;
 /**

package/schematics/ng-update/migrations/misc-ripples-v7/ripple-speed-factor.js

@@ -0,0 +1,39 @@
+/**
+ * @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/material/schematics/ng-update/migrations/misc-ripples-v7/ripple-speed-factor", ["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    /** Converts the specified speed factor into the exact static enter duration. */
+    function convertSpeedFactorToDuration(factor) {
+        // Based on the numeric speed factor value that only affected the `enterDuration` we can
+        // now calculate the exact `enterDuration`. 450ms is the enter duration without factor.
+        return 450 / (factor || 1);
+    }
+    exports.convertSpeedFactorToDuration = convertSpeedFactorToDuration;
+    /**
+     * Creates a runtime TypeScript expression that can be used in order to calculate the duration
+     * from the speed factor expression that couldn't be statically analyzed.
+     *
+     * @param speedFactorValue Speed factor expression that couldn't be statically analyzed.
+     */
+    function createSpeedFactorConvertExpression(speedFactorValue) {
+        // To be sure that the speed factor value expression is calculated properly, we need to add
+        // the according parenthesis.
+        return `450 / (${speedFactorValue})`;
+    }
+    exports.createSpeedFactorConvertExpression = createSpeedFactorConvertExpression;
+});
+//# sourceMappingURL=data:application/json;base64,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

package/schematics/ng-update/{upgrade-rules/package-imports-v8/secondary-entry-points-rule.d.ts → migrations/package-imports-v8/secondary-entry-points-migration.d.ts}

@@ -5,15 +5,15 @@
  * 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/material/schematics/ng-update/upgrade-rules/package-imports-v8/secondary-entry-points-rule" />
-import { MigrationRule } from '@angular/cdk/schematics';
+/// <amd-module name="@angular/material/schematics/ng-update/migrations/package-imports-v8/secondary-entry-points-migration" />
+import { Migration } from '@angular/cdk/schematics';
 import * as ts from 'typescript';
 /**
- * A migration rule that updates imports which refer to the primary Angular Material
+ * Migration that updates imports which refer to the primary Angular Material
  * entry-point to use the appropriate secondary entry points (e.g. @angular/material/button).
  */
-export declare class SecondaryEntryPointsRule extends MigrationRule<null> {
+export declare class SecondaryEntryPointsMigration extends Migration<null> {
     printer: ts.Printer;
-    ruleEnabled: boolean;
+    enabled: boolean;
     visitNode(declaration: ts.Node): void;
 }

package/schematics/ng-update/migrations/package-imports-v8/secondary-entry-points-migration.js

@@ -0,0 +1,177 @@
+/**
+ * @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/material/schematics/ng-update/migrations/package-imports-v8/secondary-entry-points-migration", ["require", "exports", "@angular/cdk/schematics", "typescript", "@angular/material/schematics/ng-update/typescript/module-specifiers"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    const schematics_1 = require("@angular/cdk/schematics");
+    const ts = require("typescript");
+    const module_specifiers_1 = require("@angular/material/schematics/ng-update/typescript/module-specifiers");
+    const ONLY_SUBPACKAGE_FAILURE_STR = `Importing from "@angular/material" is deprecated. ` +
+        `Instead import from the entry-point the symbol belongs to.`;
+    const NO_IMPORT_NAMED_SYMBOLS_FAILURE_STR = `Imports from Angular Material should import ` +
+        `specific symbols rather than importing the entire library.`;
+    /**
+     * Regex for testing file paths against to determine if the file is from the
+     * Angular Material library.
+     */
+    const ANGULAR_MATERIAL_FILEPATH_REGEX = new RegExp(`${module_specifiers_1.materialModuleSpecifier}/(.*?)/`);
+    /**
+     * Mapping of Material symbol names to their module names. Used as a fallback if
+     * we didn't manage to resolve the module name of a symbol using the type checker.
+     */
+    const ENTRY_POINT_MAPPINGS = require('./material-symbols.json');
+    /**
+     * Migration that updates imports which refer to the primary Angular Material
+     * entry-point to use the appropriate secondary entry points (e.g. @angular/material/button).
+     */
+    class SecondaryEntryPointsMigration extends schematics_1.Migration {
+        constructor() {
+            super(...arguments);
+            this.printer = ts.createPrinter();
+            // Only enable this rule if the migration targets version 8. The primary
+            // entry-point of Material has been marked as deprecated in version 8.
+            this.enabled = this.targetVersion === schematics_1.TargetVersion.V8 || this.targetVersion === schematics_1.TargetVersion.V9;
+        }
+        visitNode(declaration) {
+            // Only look at import declarations.
+            if (!ts.isImportDeclaration(declaration) ||
+                !ts.isStringLiteralLike(declaration.moduleSpecifier)) {
+                return;
+            }
+            const importLocation = declaration.moduleSpecifier.text;
+            // If the import module is not @angular/material, skip the check.
+            if (importLocation !== module_specifiers_1.materialModuleSpecifier) {
+                return;
+            }
+            // If no import clause is found, or nothing is named as a binding in the
+            // import, add failure saying to import symbols in clause.
+            if (!declaration.importClause || !declaration.importClause.namedBindings) {
+                this.createFailureAtNode(declaration, NO_IMPORT_NAMED_SYMBOLS_FAILURE_STR);
+                return;
+            }
+            // All named bindings in import clauses must be named symbols, otherwise add
+            // failure saying to import symbols in clause.
+            if (!ts.isNamedImports(declaration.importClause.namedBindings)) {
+                this.createFailureAtNode(declaration, NO_IMPORT_NAMED_SYMBOLS_FAILURE_STR);
+                return;
+            }
+            // If no symbols are in the named bindings then add failure saying to
+            // import symbols in clause.
+            if (!declaration.importClause.namedBindings.elements.length) {
+                this.createFailureAtNode(declaration, NO_IMPORT_NAMED_SYMBOLS_FAILURE_STR);
+                return;
+            }
+            // Whether the existing import declaration is using a single quote module specifier.
+            const singleQuoteImport = declaration.moduleSpecifier.getText()[0] === `'`;
+            // Map which consists of secondary entry-points and import specifiers which are used
+            // within the current import declaration.
+            const importMap = new Map();
+            // Determine the subpackage each symbol in the namedBinding comes from.
+            for (const element of declaration.importClause.namedBindings.elements) {
+                const elementName = element.propertyName ? element.propertyName : element.name;
+                // Try to resolve the module name via the type checker, and if it fails, fall back to
+                // resolving it from our list of symbol to entry point mappings. Using the type checker is
+                // more accurate and doesn't require us to keep a list of symbols, but it won't work if
+                // the symbols don't exist anymore (e.g. after we remove the top-level @angular/material).
+                const moduleName = resolveModuleName(elementName, this.typeChecker) ||
+                    ENTRY_POINT_MAPPINGS[elementName.text] || null;
+                if (!moduleName) {
+                    this.createFailureAtNode(element, `"${element.getText()}" was not found in the Material library.`);
+                    return;
+                }
+                // The module name where the symbol is defined e.g. card, dialog. The
+                // first capture group is contains the module name.
+                if (importMap.has(moduleName)) {
+                    importMap.get(moduleName).push(element);
+                }
+                else {
+                    importMap.set(moduleName, [element]);
+                }
+            }
+            // Transforms the import declaration into multiple import declarations that import
+            // the given symbols from the individual secondary entry-points. For example:
+            // import {MatCardModule, MatCardTitle} from '@angular/material/card';
+            // import {MatRadioModule} from '@angular/material/radio';
+            const newImportStatements = Array.from(importMap.entries())
+                .sort()
+                .map(([name, elements]) => {
+                const newImport = ts.createImportDeclaration(undefined, undefined, ts.createImportClause(undefined, ts.createNamedImports(elements)), createStringLiteral(`${module_specifiers_1.materialModuleSpecifier}/${name}`, singleQuoteImport));
+                return this.printer.printNode(ts.EmitHint.Unspecified, newImport, declaration.getSourceFile());
+            })
+                .join('\n');
+            // Without any import statements that were generated, we can assume that this was an empty
+            // import declaration. We still want to add a failure in order to make developers aware that
+            // importing from "@angular/material" is deprecated.
+            if (!newImportStatements) {
+                this.createFailureAtNode(declaration.moduleSpecifier, ONLY_SUBPACKAGE_FAILURE_STR);
+                return;
+            }
+            const recorder = this.fileSystem.edit(declaration.moduleSpecifier.getSourceFile().fileName);
+            // Perform the replacement that switches the primary entry-point import to
+            // the individual secondary entry-point imports.
+            recorder.remove(declaration.getStart(), declaration.getWidth());
+            recorder.insertRight(declaration.getStart(), newImportStatements);
+        }
+    }
+    exports.SecondaryEntryPointsMigration = SecondaryEntryPointsMigration;
+    /**
+     * Creates a string literal from the specified text.
+     * @param text Text of the string literal.
+     * @param singleQuotes Whether single quotes should be used when printing the literal node.
+     */
+    function createStringLiteral(text, singleQuotes) {
+        const literal = ts.createStringLiteral(text);
+        // See: https://github.com/microsoft/TypeScript/blob/master/src/compiler/utilities.ts#L584-L590
+        literal['singleQuote'] = singleQuotes;
+        return literal;
+    }
+    /** Gets the symbol that contains the value declaration of the given node. */
+    function getDeclarationSymbolOfNode(node, checker) {
+        const symbol = checker.getSymbolAtLocation(node);
+        // Symbols can be aliases of the declaration symbol. e.g. in named import specifiers.
+        // We need to resolve the aliased symbol back to the declaration symbol.
+        // tslint:disable-next-line:no-bitwise
+        if (symbol && (symbol.flags & ts.SymbolFlags.Alias) !== 0) {
+            return checker.getAliasedSymbol(symbol);
+        }
+        return symbol;
+    }
+    /** Tries to resolve the name of the Material module that a node is imported from. */
+    function resolveModuleName(node, typeChecker) {
+        // Get the symbol for the named binding element. Note that we cannot determine the
+        // value declaration based on the type of the element as types are not necessarily
+        // specific to a given secondary entry-point (e.g. exports with the type of "string")
+        // would resolve to the module types provided by TypeScript itself.
+        const symbol = getDeclarationSymbolOfNode(node, typeChecker);
+        // If the symbol can't be found, or no declaration could be found within
+        // the symbol, add failure to report that the given symbol can't be found.
+        if (!symbol ||
+            !(symbol.valueDeclaration || (symbol.declarations && symbol.declarations.length !== 0))) {
+            return null;
+        }
+        // The filename for the source file of the node that contains the
+        // first declaration of the symbol. All symbol declarations must be
+        // part of a defining node, so parent can be asserted to be defined.
+        const resolvedNode = symbol.valueDeclaration || symbol.declarations[0];
+        const sourceFile = resolvedNode.getSourceFile().fileName;
+        // File the module the symbol belongs to from a regex match of the
+        // filename. This will always match since only "@angular/material"
+        // elements are analyzed.
+        const matches = sourceFile.match(ANGULAR_MATERIAL_FILEPATH_REGEX);
+        return matches ? matches[1] : null;
+    }
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"secondary-entry-points-migration.js","sourceRoot":"","sources":["../../../../../../../../../src/material/schematics/ng-update/migrations/package-imports-v8/secondary-entry-points-migration.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 {Migration, TargetVersion} from '@angular/cdk/schematics';\nimport * as ts from 'typescript';\nimport {materialModuleSpecifier} from '../../../ng-update/typescript/module-specifiers';\n\nconst ONLY_SUBPACKAGE_FAILURE_STR = `Importing from \"@angular/material\" is deprecated. ` +\n    `Instead import from the entry-point the symbol belongs to.`;\n\nconst NO_IMPORT_NAMED_SYMBOLS_FAILURE_STR = `Imports from Angular Material should import ` +\n    `specific symbols rather than importing the entire library.`;\n\n/**\n * Regex for testing file paths against to determine if the file is from the\n * Angular Material library.\n */\nconst ANGULAR_MATERIAL_FILEPATH_REGEX = new RegExp(`${materialModuleSpecifier}/(.*?)/`);\n\n/**\n * Mapping of Material symbol names to their module names. Used as a fallback if\n * we didn't manage to resolve the module name of a symbol using the type checker.\n */\nconst ENTRY_POINT_MAPPINGS: {[name: string]: string} = require('./material-symbols.json');\n\n/**\n * Migration that updates imports which refer to the primary Angular Material\n * entry-point to use the appropriate secondary entry points (e.g. @angular/material/button).\n */\nexport class SecondaryEntryPointsMigration extends Migration<null> {\n  printer = ts.createPrinter();\n\n  // Only enable this rule if the migration targets version 8. The primary\n  // entry-point of Material has been marked as deprecated in version 8.\n  enabled = this.targetVersion === TargetVersion.V8 || this.targetVersion === TargetVersion.V9;\n\n  visitNode(declaration: ts.Node): void {\n    // Only look at import declarations.\n    if (!ts.isImportDeclaration(declaration) ||\n        !ts.isStringLiteralLike(declaration.moduleSpecifier)) {\n      return;\n    }\n\n    const importLocation = declaration.moduleSpecifier.text;\n    // If the import module is not @angular/material, skip the check.\n    if (importLocation !== materialModuleSpecifier) {\n      return;\n    }\n\n    // If no import clause is found, or nothing is named as a binding in the\n    // import, add failure saying to import symbols in clause.\n    if (!declaration.importClause || !declaration.importClause.namedBindings) {\n      this.createFailureAtNode(declaration, NO_IMPORT_NAMED_SYMBOLS_FAILURE_STR);\n      return;\n    }\n\n    // All named bindings in import clauses must be named symbols, otherwise add\n    // failure saying to import symbols in clause.\n    if (!ts.isNamedImports(declaration.importClause.namedBindings)) {\n      this.createFailureAtNode(declaration, NO_IMPORT_NAMED_SYMBOLS_FAILURE_STR);\n      return;\n    }\n\n    // If no symbols are in the named bindings then add failure saying to\n    // import symbols in clause.\n    if (!declaration.importClause.namedBindings.elements.length) {\n      this.createFailureAtNode(declaration, NO_IMPORT_NAMED_SYMBOLS_FAILURE_STR);\n      return;\n    }\n\n    // Whether the existing import declaration is using a single quote module specifier.\n    const singleQuoteImport = declaration.moduleSpecifier.getText()[0] === `'`;\n\n    // Map which consists of secondary entry-points and import specifiers which are used\n    // within the current import declaration.\n    const importMap = new Map<string, ts.ImportSpecifier[]>();\n\n    // Determine the subpackage each symbol in the namedBinding comes from.\n    for (const element of declaration.importClause.namedBindings.elements) {\n      const elementName = element.propertyName ? element.propertyName : element.name;\n\n      // Try to resolve the module name via the type checker, and if it fails, fall back to\n      // resolving it from our list of symbol to entry point mappings. Using the type checker is\n      // more accurate and doesn't require us to keep a list of symbols, but it won't work if\n      // the symbols don't exist anymore (e.g. after we remove the top-level @angular/material).\n      const moduleName = resolveModuleName(elementName, this.typeChecker) ||\n          ENTRY_POINT_MAPPINGS[elementName.text] || null;\n\n      if (!moduleName) {\n        this.createFailureAtNode(\n          element, `\"${element.getText()}\" was not found in the Material library.`);\n        return;\n      }\n\n        // The module name where the symbol is defined e.g. card, dialog. The\n        // first capture group is contains the module name.\n        if (importMap.has(moduleName)) {\n          importMap.get(moduleName)!.push(element);\n        } else {\n          importMap.set(moduleName, [element]);\n        }\n    }\n\n    // Transforms the import declaration into multiple import declarations that import\n    // the given symbols from the individual secondary entry-points. For example:\n    // import {MatCardModule, MatCardTitle} from '@angular/material/card';\n    // import {MatRadioModule} from '@angular/material/radio';\n    const newImportStatements =\n        Array.from(importMap.entries())\n            .sort()\n            .map(([name, elements]) => {\n              const newImport = ts.createImportDeclaration(\n                  undefined, undefined,\n                  ts.createImportClause(undefined, ts.createNamedImports(elements)),\n                  createStringLiteral(`${materialModuleSpecifier}/${name}`, singleQuoteImport));\n              return this.printer.printNode(\n                  ts.EmitHint.Unspecified, newImport, declaration.getSourceFile());\n            })\n            .join('\\n');\n\n    // Without any import statements that were generated, we can assume that this was an empty\n    // import declaration. We still want to add a failure in order to make developers aware that\n    // importing from \"@angular/material\" is deprecated.\n    if (!newImportStatements) {\n      this.createFailureAtNode(declaration.moduleSpecifier, ONLY_SUBPACKAGE_FAILURE_STR);\n      return;\n    }\n\n    const recorder = this.fileSystem.edit(declaration.moduleSpecifier.getSourceFile().fileName);\n\n    // Perform the replacement that switches the primary entry-point import to\n    // the individual secondary entry-point imports.\n    recorder.remove(declaration.getStart(), declaration.getWidth());\n    recorder.insertRight(declaration.getStart(), newImportStatements);\n  }\n}\n\n/**\n * Creates a string literal from the specified text.\n * @param text Text of the string literal.\n * @param singleQuotes Whether single quotes should be used when printing the literal node.\n */\nfunction createStringLiteral(text: string, singleQuotes: boolean): ts.StringLiteral {\n  const literal = ts.createStringLiteral(text);\n  // See: https://github.com/microsoft/TypeScript/blob/master/src/compiler/utilities.ts#L584-L590\n  literal['singleQuote'] = singleQuotes;\n  return literal;\n}\n\n/** Gets the symbol that contains the value declaration of the given node. */\nfunction getDeclarationSymbolOfNode(node: ts.Node, checker: ts.TypeChecker): ts.Symbol|undefined {\n  const symbol = checker.getSymbolAtLocation(node);\n\n  // Symbols can be aliases of the declaration symbol. e.g. in named import specifiers.\n  // We need to resolve the aliased symbol back to the declaration symbol.\n  // tslint:disable-next-line:no-bitwise\n  if (symbol && (symbol.flags & ts.SymbolFlags.Alias) !== 0) {\n    return checker.getAliasedSymbol(symbol);\n  }\n  return symbol;\n}\n\n\n/** Tries to resolve the name of the Material module that a node is imported from. */\nfunction resolveModuleName(node: ts.Identifier, typeChecker: ts.TypeChecker) {\n  // Get the symbol for the named binding element. Note that we cannot determine the\n  // value declaration based on the type of the element as types are not necessarily\n  // specific to a given secondary entry-point (e.g. exports with the type of \"string\")\n  // would resolve to the module types provided by TypeScript itself.\n  const symbol = getDeclarationSymbolOfNode(node, typeChecker);\n\n  // If the symbol can't be found, or no declaration could be found within\n  // the symbol, add failure to report that the given symbol can't be found.\n  if (!symbol ||\n      !(symbol.valueDeclaration || (symbol.declarations && symbol.declarations.length !== 0))) {\n    return null;\n  }\n\n  // The filename for the source file of the node that contains the\n  // first declaration of the symbol. All symbol declarations must be\n  // part of a defining node, so parent can be asserted to be defined.\n  const resolvedNode = symbol.valueDeclaration || symbol.declarations[0];\n  const sourceFile = resolvedNode.getSourceFile().fileName;\n\n  // File the module the symbol belongs to from a regex match of the\n  // filename. This will always match since only \"@angular/material\"\n  // elements are analyzed.\n  const matches = sourceFile.match(ANGULAR_MATERIAL_FILEPATH_REGEX);\n  return matches ? matches[1] : null;\n}\n"]}

package/schematics/ng-update/upgrade-data.d.ts

@@ -6,6 +6,6 @@
  * found in the LICENSE file at https://angular.io/license
  */
 /// <amd-module name="@angular/material/schematics/ng-update/upgrade-data" />
-import { RuleUpgradeData } from '@angular/cdk/schematics';
+import { UpgradeData } from '@angular/cdk/schematics';
 /** Upgrade data that will be used for the Angular Material ng-update schematic. */
-export declare const materialUpgradeData: RuleUpgradeData;
+export declare const materialUpgradeData: UpgradeData;

package/schematics/ng-update/upgrade-data.js

@@ -30,4 +30,4 @@
         propertyNames: data_1.propertyNames,
     };
 });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXBncmFkZS1kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vc3JjL21hdGVyaWFsL3NjaGVtYXRpY3MvbmctdXBkYXRlL3VwZ3JhZGUtZGF0YS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7Ozs7Ozs7Ozs7OztJQUdILDRFQVVnQjtJQUVoQixtRkFBbUY7SUFDdEUsUUFBQSxtQkFBbUIsR0FBb0I7UUFDbEQsa0JBQWtCLEVBQWxCLHlCQUFrQjtRQUNsQixVQUFVLEVBQVYsaUJBQVU7UUFDVixpQkFBaUIsRUFBakIsd0JBQWlCO1FBQ2pCLFlBQVksRUFBWixtQkFBWTtRQUNaLGdCQUFnQixFQUFoQix1QkFBZ0I7UUFDaEIsVUFBVSxFQUFWLGlCQUFVO1FBQ1YsZ0JBQWdCLEVBQWhCLHVCQUFnQjtRQUNoQixXQUFXLEVBQVgsa0JBQVc7UUFDWCxhQUFhLEVBQWIsb0JBQWE7S0FDZCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBMTEMgQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbmltcG9ydCB7UnVsZVVwZ3JhZGVEYXRhfSBmcm9tICdAYW5ndWxhci9jZGsvc2NoZW1hdGljcyc7XG5pbXBvcnQge1xuICBhdHRyaWJ1dGVTZWxlY3RvcnMsXG4gIGNsYXNzTmFtZXMsXG4gIGNvbnN0cnVjdG9yQ2hlY2tzLFxuICBjc3NTZWxlY3RvcnMsXG4gIGVsZW1lbnRTZWxlY3RvcnMsXG4gIGlucHV0TmFtZXMsXG4gIG1ldGhvZENhbGxDaGVja3MsXG4gIG91dHB1dE5hbWVzLFxuICBwcm9wZXJ0eU5hbWVzLFxufSBmcm9tICcuL2RhdGEnO1xuXG4vKiogVXBncmFkZSBkYXRhIHRoYXQgd2lsbCBiZSB1c2VkIGZvciB0aGUgQW5ndWxhciBNYXRlcmlhbCBuZy11cGRhdGUgc2NoZW1hdGljLiAqL1xuZXhwb3J0IGNvbnN0IG1hdGVyaWFsVXBncmFkZURhdGE6IFJ1bGVVcGdyYWRlRGF0YSA9IHtcbiAgYXR0cmlidXRlU2VsZWN0b3JzLFxuICBjbGFzc05hbWVzLFxuICBjb25zdHJ1Y3RvckNoZWNrcyxcbiAgY3NzU2VsZWN0b3JzLFxuICBlbGVtZW50U2VsZWN0b3JzLFxuICBpbnB1dE5hbWVzLFxuICBtZXRob2RDYWxsQ2hlY2tzLFxuICBvdXRwdXROYW1lcyxcbiAgcHJvcGVydHlOYW1lcyxcbn07XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXBncmFkZS1kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vc3JjL21hdGVyaWFsL3NjaGVtYXRpY3MvbmctdXBkYXRlL3VwZ3JhZGUtZGF0YS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7Ozs7Ozs7Ozs7OztJQUdILDRFQVVnQjtJQUVoQixtRkFBbUY7SUFDdEUsUUFBQSxtQkFBbUIsR0FBZ0I7UUFDOUMsa0JBQWtCLEVBQWxCLHlCQUFrQjtRQUNsQixVQUFVLEVBQVYsaUJBQVU7UUFDVixpQkFBaUIsRUFBakIsd0JBQWlCO1FBQ2pCLFlBQVksRUFBWixtQkFBWTtRQUNaLGdCQUFnQixFQUFoQix1QkFBZ0I7UUFDaEIsVUFBVSxFQUFWLGlCQUFVO1FBQ1YsZ0JBQWdCLEVBQWhCLHVCQUFnQjtRQUNoQixXQUFXLEVBQVgsa0JBQVc7UUFDWCxhQUFhLEVBQWIsb0JBQWE7S0FDZCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBMTEMgQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbmltcG9ydCB7VXBncmFkZURhdGF9IGZyb20gJ0Bhbmd1bGFyL2Nkay9zY2hlbWF0aWNzJztcbmltcG9ydCB7XG4gIGF0dHJpYnV0ZVNlbGVjdG9ycyxcbiAgY2xhc3NOYW1lcyxcbiAgY29uc3RydWN0b3JDaGVja3MsXG4gIGNzc1NlbGVjdG9ycyxcbiAgZWxlbWVudFNlbGVjdG9ycyxcbiAgaW5wdXROYW1lcyxcbiAgbWV0aG9kQ2FsbENoZWNrcyxcbiAgb3V0cHV0TmFtZXMsXG4gIHByb3BlcnR5TmFtZXMsXG59IGZyb20gJy4vZGF0YSc7XG5cbi8qKiBVcGdyYWRlIGRhdGEgdGhhdCB3aWxsIGJlIHVzZWQgZm9yIHRoZSBBbmd1bGFyIE1hdGVyaWFsIG5nLXVwZGF0ZSBzY2hlbWF0aWMuICovXG5leHBvcnQgY29uc3QgbWF0ZXJpYWxVcGdyYWRlRGF0YTogVXBncmFkZURhdGEgPSB7XG4gIGF0dHJpYnV0ZVNlbGVjdG9ycyxcbiAgY2xhc3NOYW1lcyxcbiAgY29uc3RydWN0b3JDaGVja3MsXG4gIGNzc1NlbGVjdG9ycyxcbiAgZWxlbWVudFNlbGVjdG9ycyxcbiAgaW5wdXROYW1lcyxcbiAgbWV0aG9kQ2FsbENoZWNrcyxcbiAgb3V0cHV0TmFtZXMsXG4gIHByb3BlcnR5TmFtZXMsXG59O1xuIl19