@angular/material 9.1.3 → 9.2.2

package/schematics/ng-update/migrations/hammer-gestures-v9/remove-array-element.js

@@ -0,0 +1,75 @@
+/**
+ * @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/hammer-gestures-v9/remove-array-element", ["require", "exports", "typescript"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    const ts = require("typescript");
+    /**
+     * Retrieves the parent syntax list of the given node. A syntax list node is usually
+     * hidden from the default AST node hierarchy because it only contains information that
+     * is need when printing a node. e.g. it contains information about comma positions in
+     * an array literal expression.
+     */
+    function getParentSyntaxList(node) {
+        if (!node.parent) {
+            return null;
+        }
+        const parent = node.parent;
+        const { pos, end } = node;
+        for (const child of parent.getChildren()) {
+            if (child.pos > end || child === node) {
+                return null;
+            }
+            if (child.kind === ts.SyntaxKind.SyntaxList && child.pos <= pos && child.end >= end) {
+                return child;
+            }
+        }
+        return null;
+    }
+    exports.getParentSyntaxList = getParentSyntaxList;
+    /** Looks for the trailing comma of the given element within the syntax list. */
+    function findTrailingCommaToken(list, element) {
+        let foundElement = false;
+        for (let child of list.getChildren()) {
+            if (!foundElement && child === element) {
+                foundElement = true;
+            }
+            else if (foundElement) {
+                if (child.kind === ts.SyntaxKind.CommaToken) {
+                    return child;
+                }
+                break;
+            }
+        }
+        return null;
+    }
+    /** Removes a given element from its parent array literal expression. */
+    function removeElementFromArrayExpression(element, recorder) {
+        recorder.remove(element.getFullStart(), element.getFullWidth());
+        const syntaxList = getParentSyntaxList(element);
+        if (!syntaxList) {
+            return;
+        }
+        // if there is a trailing comma token for the element, we need to remove it
+        // because otherwise the array literal expression will have syntax failures.
+        const trailingComma = findTrailingCommaToken(syntaxList, element);
+        if (trailingComma !== null) {
+            recorder.remove(trailingComma.getFullStart(), trailingComma.getFullWidth());
+        }
+    }
+    exports.removeElementFromArrayExpression = removeElementFromArrayExpression;
+});
+//# sourceMappingURL=data:application/json;base64,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

package/schematics/ng-update/{upgrade-rules → migrations}/hammer-gestures-v9/remove-element-from-html.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/hammer-gestures-v9/remove-element-from-html" />
+/// <amd-module name="@angular/material/schematics/ng-update/migrations/hammer-gestures-v9/remove-element-from-html" />
 import { UpdateRecorder } from '@angular-devkit/schematics';
 import { parse5 } from '@angular/cdk/schematics';
 /**

package/schematics/ng-update/migrations/hammer-gestures-v9/remove-element-from-html.js

@@ -0,0 +1,37 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+(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/hammer-gestures-v9/remove-element-from-html", ["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    /**
+     * Removes the specified element. Additionally, preceding whitespace will be removed
+     * to not leave empty lines in the resulting HTML.
+     */
+    function removeElementFromHtml(element, recorder) {
+        // sourceCodeLocation is always set since we parse with location info enabled.
+        const { startOffset, endOffset } = element.sourceCodeLocation;
+        const parentIndex = element.parentNode.childNodes.indexOf(element);
+        const precedingTextSibling = element.parentNode.childNodes.find((f, i) => f.nodeName === '#text' && i === parentIndex - 1);
+        recorder.remove(startOffset, endOffset - startOffset);
+        // If we found a preceding text node which just consists of whitespace, remove it.
+        if (precedingTextSibling && /^\s+$/.test(precedingTextSibling.value)) {
+            const textSiblingLocation = precedingTextSibling.sourceCodeLocation;
+            recorder.remove(textSiblingLocation.startOffset, textSiblingLocation.endOffset - textSiblingLocation.startOffset);
+        }
+    }
+    exports.removeElementFromHtml = removeElementFromHtml;
+});
+//# sourceMappingURL=data:application/json;base64,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

package/schematics/ng-update/migrations/misc-checks/misc-class-inheritance.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+/// <amd-module name="@angular/material/schematics/ng-update/migrations/misc-checks/misc-class-inheritance" />
+import { Migration } from '@angular/cdk/schematics';
+import * as ts from 'typescript';
+/**
+ * Migration that checks for classes that extend Angular Material classes which
+ * have changed their API.
+ */
+export declare class MiscClassInheritanceMigration extends Migration<null> {
+    enabled: boolean;
+    visitNode(node: ts.Node): void;
+    private _visitClassDeclaration;
+}

package/schematics/ng-update/migrations/misc-checks/misc-class-inheritance.js

@@ -0,0 +1,57 @@
+/**
+ * @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-checks/misc-class-inheritance", ["require", "exports", "@angular/cdk/schematics", "typescript"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    const schematics_1 = require("@angular/cdk/schematics");
+    const ts = require("typescript");
+    /**
+     * Migration that checks for classes that extend Angular Material classes which
+     * have changed their API.
+     */
+    class MiscClassInheritanceMigration extends schematics_1.Migration {
+        constructor() {
+            super(...arguments);
+            // Only enable this rule if the migration targets version 6. The rule
+            // currently only includes migrations for V6 deprecations.
+            this.enabled = this.targetVersion === schematics_1.TargetVersion.V6;
+        }
+        visitNode(node) {
+            if (ts.isClassDeclaration(node)) {
+                this._visitClassDeclaration(node);
+            }
+        }
+        _visitClassDeclaration(node) {
+            const baseTypes = schematics_1.determineBaseTypes(node);
+            const className = node.name ? node.name.text : '{unknown-name}';
+            if (!baseTypes) {
+                return;
+            }
+            // Migration for: https://github.com/angular/components/pull/10293 (v6)
+            if (baseTypes.includes('MatFormFieldControl')) {
+                const hasFloatLabelMember = node.members.filter(member => member.name)
+                    .find(member => member.name.getText() === 'shouldLabelFloat');
+                if (!hasFloatLabelMember) {
+                    this.createFailureAtNode(node, `Found class "${className}" which extends ` +
+                        `"${'MatFormFieldControl'}". This class must define ` +
+                        `"${'shouldLabelFloat'}" which is now a required property.`);
+                }
+            }
+        }
+    }
+    exports.MiscClassInheritanceMigration = MiscClassInheritanceMigration;
+});
+//# sourceMappingURL=data:application/json;base64,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

package/schematics/ng-update/{upgrade-rules/misc-checks/misc-class-names-rule.d.ts → migrations/misc-checks/misc-class-names.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/misc-checks/misc-class-names-rule" />
-import { MigrationRule } from '@angular/cdk/schematics';
+/// <amd-module name="@angular/material/schematics/ng-update/migrations/misc-checks/misc-class-names" />
+import { Migration } from '@angular/cdk/schematics';
 import * as ts from 'typescript';
 /**
- * Rule that looks for class name identifiers that have been removed but
+ * Migration that looks for class name identifiers that have been removed but
  * cannot be automatically migrated.
  */
-export declare class MiscClassNamesRule extends MigrationRule<null> {
-    ruleEnabled: boolean;
+export declare class MiscClassNamesMigration extends Migration<null> {
+    enabled: boolean;
     visitNode(node: ts.Node): void;
     private _visitIdentifier;
 }

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

@@ -0,0 +1,52 @@
+/**
+ * @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-checks/misc-class-names", ["require", "exports", "@angular/cdk/schematics", "typescript"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    const schematics_1 = require("@angular/cdk/schematics");
+    const ts = require("typescript");
+    /**
+     * Migration that looks for class name identifiers that have been removed but
+     * cannot be automatically migrated.
+     */
+    class MiscClassNamesMigration extends schematics_1.Migration {
+        constructor() {
+            super(...arguments);
+            // Only enable this rule if the migration targets version 6. The rule
+            // currently only includes migrations for V6 deprecations.
+            this.enabled = this.targetVersion === schematics_1.TargetVersion.V6;
+        }
+        visitNode(node) {
+            if (ts.isIdentifier(node)) {
+                this._visitIdentifier(node);
+            }
+        }
+        _visitIdentifier(identifier) {
+            // Migration for: https://github.com/angular/components/pull/10279 (v6)
+            if (identifier.getText() === 'MatDrawerToggleResult') {
+                this.createFailureAtNode(identifier, `Found "MatDrawerToggleResult" which has changed from a class type to a string ` +
+                    `literal type. Your code may need to be updated.`);
+            }
+            // Migration for: https://github.com/angular/components/pull/10398 (v6)
+            if (identifier.getText() === 'MatListOptionChange') {
+                this.createFailureAtNode(identifier, `Found usage of "MatListOptionChange" which has been removed. Please listen for ` +
+                    `"selectionChange" on "MatSelectionList" instead.`);
+            }
+        }
+    }
+    exports.MiscClassNamesMigration = MiscClassNamesMigration;
+});
+//# sourceMappingURL=data:application/json;base64,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

package/schematics/ng-update/{upgrade-rules/misc-checks/misc-imports-rule.d.ts → migrations/misc-checks/misc-imports.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/misc-checks/misc-imports-rule" />
-import { MigrationRule } from '@angular/cdk/schematics';
+/// <amd-module name="@angular/material/schematics/ng-update/migrations/misc-checks/misc-imports" />
+import { Migration } from '@angular/cdk/schematics';
 import * as ts from 'typescript';
 /**
- * Rule that detects import declarations that refer to outdated identifiers from
+ * Migration that detects import declarations that refer to outdated identifiers from
  * Angular Material which cannot be updated automatically.
  */
-export declare class MiscImportsRule extends MigrationRule<null> {
-    ruleEnabled: boolean;
+export declare class MiscImportsMigration extends Migration<null> {
+    enabled: boolean;
     visitNode(node: ts.Node): void;
     private _visitImportDeclaration;
     /**

package/schematics/ng-update/migrations/misc-checks/misc-imports.js

@@ -0,0 +1,63 @@
+/**
+ * @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-checks/misc-imports", ["require", "exports", "@angular/cdk/schematics", "typescript"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    const schematics_1 = require("@angular/cdk/schematics");
+    const ts = require("typescript");
+    /**
+     * Migration that detects import declarations that refer to outdated identifiers from
+     * Angular Material which cannot be updated automatically.
+     */
+    class MiscImportsMigration extends schematics_1.Migration {
+        constructor() {
+            super(...arguments);
+            // Only enable this rule if the migration targets version 6. The rule
+            // currently only includes migrations for V6 deprecations.
+            this.enabled = this.targetVersion === schematics_1.TargetVersion.V6;
+        }
+        visitNode(node) {
+            if (ts.isImportDeclaration(node)) {
+                this._visitImportDeclaration(node);
+            }
+        }
+        _visitImportDeclaration(node) {
+            if (!schematics_1.isMaterialImportDeclaration(node) || !node.importClause ||
+                !node.importClause.namedBindings) {
+                return;
+            }
+            const namedBindings = node.importClause.namedBindings;
+            if (ts.isNamedImports(namedBindings)) {
+                // Migration for: https://github.com/angular/components/pull/10405 (v6)
+                this._checkAnimationConstants(namedBindings);
+            }
+        }
+        /**
+         * Checks for named imports that refer to the deleted animation constants.
+         * https://github.com/angular/components/commit/9f3bf274c4f15f0b0fbd8ab7dbf1a453076e66d9
+         */
+        _checkAnimationConstants(namedImports) {
+            namedImports.elements.filter(element => ts.isIdentifier(element.name)).forEach(element => {
+                const importName = element.name.text;
+                if (importName === 'SHOW_ANIMATION' || importName === 'HIDE_ANIMATION') {
+                    this.createFailureAtNode(element, `Found deprecated symbol "${importName}" which has been removed`);
+                }
+            });
+        }
+    }
+    exports.MiscImportsMigration = MiscImportsMigration;
+});
+//# sourceMappingURL=data:application/json;base64,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

package/schematics/ng-update/{upgrade-rules/misc-checks/misc-property-names-rule.d.ts → migrations/misc-checks/misc-property-names.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/misc-checks/misc-property-names-rule" />
-import { MigrationRule } from '@angular/cdk/schematics';
+/// <amd-module name="@angular/material/schematics/ng-update/migrations/misc-checks/misc-property-names" />
+import { Migration } from '@angular/cdk/schematics';
 import * as ts from 'typescript';
 /**
- * Rule that walks through every property access expression and and reports a failure if
+ * Migration that walks through every property access expression and and reports a failure if
  * a given property name no longer exists but cannot be automatically migrated.
  */
-export declare class MiscPropertyNamesRule extends MigrationRule<null> {
-    ruleEnabled: boolean;
+export declare class MiscPropertyNamesMigration extends Migration<null> {
+    enabled: boolean;
     visitNode(node: ts.Node): void;
     private _visitPropertyAccessExpression;
 }

package/schematics/ng-update/migrations/misc-checks/misc-property-names.js

@@ -0,0 +1,56 @@
+/**
+ * @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-checks/misc-property-names", ["require", "exports", "@angular/cdk/schematics", "typescript"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    const schematics_1 = require("@angular/cdk/schematics");
+    const ts = require("typescript");
+    /**
+     * Migration that walks through every property access expression and and reports a failure if
+     * a given property name no longer exists but cannot be automatically migrated.
+     */
+    class MiscPropertyNamesMigration extends schematics_1.Migration {
+        constructor() {
+            super(...arguments);
+            // Only enable this rule if the migration targets version 6. The rule
+            // currently only includes migrations for V6 deprecations.
+            this.enabled = this.targetVersion === schematics_1.TargetVersion.V6;
+        }
+        visitNode(node) {
+            if (ts.isPropertyAccessExpression(node)) {
+                this._visitPropertyAccessExpression(node);
+            }
+        }
+        _visitPropertyAccessExpression(node) {
+            const hostType = this.typeChecker.getTypeAtLocation(node.expression);
+            const typeName = hostType && hostType.symbol && hostType.symbol.getName();
+            // Migration for: https://github.com/angular/components/pull/10398 (v6)
+            if (typeName === 'MatListOption' && node.name.text === 'selectionChange') {
+                this.createFailureAtNode(node, `Found deprecated property "selectionChange" of ` +
+                    `class "MatListOption". Use the "selectionChange" property on the ` +
+                    `parent "MatSelectionList" instead.`);
+            }
+            // Migration for: https://github.com/angular/components/pull/10413 (v6)
+            if (typeName === 'MatDatepicker' && node.name.text === 'selectedChanged') {
+                this.createFailureAtNode(node, `Found deprecated property "selectedChanged" of ` +
+                    `class "MatDatepicker". Use the "dateChange" or "dateInput" methods ` +
+                    `on "MatDatepickerInput" instead.`);
+            }
+        }
+    }
+    exports.MiscPropertyNamesMigration = MiscPropertyNamesMigration;
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWlzYy1wcm9wZXJ0eS1uYW1lcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYy9tYXRlcmlhbC9zY2hlbWF0aWNzL25nLXVwZGF0ZS9taWdyYXRpb25zL21pc2MtY2hlY2tzL21pc2MtcHJvcGVydHktbmFtZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HOzs7Ozs7Ozs7Ozs7SUFFSCx3REFBaUU7SUFDakUsaUNBQWlDO0lBRWpDOzs7T0FHRztJQUNILE1BQWEsMEJBQTJCLFNBQVEsc0JBQWU7UUFBL0Q7O1lBRUUscUVBQXFFO1lBQ3JFLDBEQUEwRDtZQUMxRCxZQUFPLEdBQUcsSUFBSSxDQUFDLGFBQWEsS0FBSywwQkFBYSxDQUFDLEVBQUUsQ0FBQztRQThCcEQsQ0FBQztRQTVCQyxTQUFTLENBQUMsSUFBYTtZQUNyQixJQUFJLEVBQUUsQ0FBQywwQkFBMEIsQ0FBQyxJQUFJLENBQUMsRUFBRTtnQkFDdkMsSUFBSSxDQUFDLDhCQUE4QixDQUFDLElBQUksQ0FBQyxDQUFDO2FBQzNDO1FBQ0gsQ0FBQztRQUVPLDhCQUE4QixDQUFDLElBQWlDO1lBQ3RFLE1BQU0sUUFBUSxHQUFHLElBQUksQ0FBQyxXQUFXLENBQUMsaUJBQWlCLENBQUMsSUFBSSxDQUFDLFVBQVUsQ0FBQyxDQUFDO1lBQ3JFLE1BQU0sUUFBUSxHQUFHLFFBQVEsSUFBSSxRQUFRLENBQUMsTUFBTSxJQUFJLFFBQVEsQ0FBQyxNQUFNLENBQUMsT0FBTyxFQUFFLENBQUM7WUFFMUUsdUVBQXVFO1lBQ3ZFLElBQUksUUFBUSxLQUFLLGVBQWUsSUFBSSxJQUFJLENBQUMsSUFBSSxDQUFDLElBQUksS0FBSyxpQkFBaUIsRUFBRTtnQkFDeEUsSUFBSSxDQUFDLG1CQUFtQixDQUNwQixJQUFJLEVBQ0osaURBQWlEO29CQUM3QyxtRUFBbUU7b0JBQ25FLG9DQUFvQyxDQUFDLENBQUM7YUFDL0M7WUFFRCx1RUFBdUU7WUFDdkUsSUFBSSxRQUFRLEtBQUssZUFBZSxJQUFJLElBQUksQ0FBQyxJQUFJLENBQUMsSUFBSSxLQUFLLGlCQUFpQixFQUFFO2dCQUN4RSxJQUFJLENBQUMsbUJBQW1CLENBQ3BCLElBQUksRUFDSixpREFBaUQ7b0JBQzdDLHFFQUFxRTtvQkFDckUsa0NBQWtDLENBQUMsQ0FBQzthQUM3QztRQUNILENBQUM7S0FDRjtJQWxDRCxnRUFrQ0MiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuaW1wb3J0IHtNaWdyYXRpb24sIFRhcmdldFZlcnNpb259IGZyb20gJ0Bhbmd1bGFyL2Nkay9zY2hlbWF0aWNzJztcbmltcG9ydCAqIGFzIHRzIGZyb20gJ3R5cGVzY3JpcHQnO1xuXG4vKipcbiAqIE1pZ3JhdGlvbiB0aGF0IHdhbGtzIHRocm91Z2ggZXZlcnkgcHJvcGVydHkgYWNjZXNzIGV4cHJlc3Npb24gYW5kIGFuZCByZXBvcnRzIGEgZmFpbHVyZSBpZlxuICogYSBnaXZlbiBwcm9wZXJ0eSBuYW1lIG5vIGxvbmdlciBleGlzdHMgYnV0IGNhbm5vdCBiZSBhdXRvbWF0aWNhbGx5IG1pZ3JhdGVkLlxuICovXG5leHBvcnQgY2xhc3MgTWlzY1Byb3BlcnR5TmFtZXNNaWdyYXRpb24gZXh0ZW5kcyBNaWdyYXRpb248bnVsbD4ge1xuXG4gIC8vIE9ubHkgZW5hYmxlIHRoaXMgcnVsZSBpZiB0aGUgbWlncmF0aW9uIHRhcmdldHMgdmVyc2lvbiA2LiBUaGUgcnVsZVxuICAvLyBjdXJyZW50bHkgb25seSBpbmNsdWRlcyBtaWdyYXRpb25zIGZvciBWNiBkZXByZWNhdGlvbnMuXG4gIGVuYWJsZWQgPSB0aGlzLnRhcmdldFZlcnNpb24gPT09IFRhcmdldFZlcnNpb24uVjY7XG5cbiAgdmlzaXROb2RlKG5vZGU6IHRzLk5vZGUpOiB2b2lkIHtcbiAgICBpZiAodHMuaXNQcm9wZXJ0eUFjY2Vzc0V4cHJlc3Npb24obm9kZSkpIHtcbiAgICAgIHRoaXMuX3Zpc2l0UHJvcGVydHlBY2Nlc3NFeHByZXNzaW9uKG5vZGUpO1xuICAgIH1cbiAgfVxuXG4gIHByaXZhdGUgX3Zpc2l0UHJvcGVydHlBY2Nlc3NFeHByZXNzaW9uKG5vZGU6IHRzLlByb3BlcnR5QWNjZXNzRXhwcmVzc2lvbikge1xuICAgIGNvbnN0IGhvc3RUeXBlID0gdGhpcy50eXBlQ2hlY2tlci5nZXRUeXBlQXRMb2NhdGlvbihub2RlLmV4cHJlc3Npb24pO1xuICAgIGNvbnN0IHR5cGVOYW1lID0gaG9zdFR5cGUgJiYgaG9zdFR5cGUuc3ltYm9sICYmIGhvc3RUeXBlLnN5bWJvbC5nZXROYW1lKCk7XG5cbiAgICAvLyBNaWdyYXRpb24gZm9yOiBodHRwczovL2dpdGh1Yi5jb20vYW5ndWxhci9jb21wb25lbnRzL3B1bGwvMTAzOTggKHY2KVxuICAgIGlmICh0eXBlTmFtZSA9PT0gJ01hdExpc3RPcHRpb24nICYmIG5vZGUubmFtZS50ZXh0ID09PSAnc2VsZWN0aW9uQ2hhbmdlJykge1xuICAgICAgdGhpcy5jcmVhdGVGYWlsdXJlQXROb2RlKFxuICAgICAgICAgIG5vZGUsXG4gICAgICAgICAgYEZvdW5kIGRlcHJlY2F0ZWQgcHJvcGVydHkgXCJzZWxlY3Rpb25DaGFuZ2VcIiBvZiBgICtcbiAgICAgICAgICAgICAgYGNsYXNzIFwiTWF0TGlzdE9wdGlvblwiLiBVc2UgdGhlIFwic2VsZWN0aW9uQ2hhbmdlXCIgcHJvcGVydHkgb24gdGhlIGAgK1xuICAgICAgICAgICAgICBgcGFyZW50IFwiTWF0U2VsZWN0aW9uTGlzdFwiIGluc3RlYWQuYCk7XG4gICAgfVxuXG4gICAgLy8gTWlncmF0aW9uIGZvcjogaHR0cHM6Ly9naXRodWIuY29tL2FuZ3VsYXIvY29tcG9uZW50cy9wdWxsLzEwNDEzICh2NilcbiAgICBpZiAodHlwZU5hbWUgPT09ICdNYXREYXRlcGlja2VyJyAmJiBub2RlLm5hbWUudGV4dCA9PT0gJ3NlbGVjdGVkQ2hhbmdlZCcpIHtcbiAgICAgIHRoaXMuY3JlYXRlRmFpbHVyZUF0Tm9kZShcbiAgICAgICAgICBub2RlLFxuICAgICAgICAgIGBGb3VuZCBkZXByZWNhdGVkIHByb3BlcnR5IFwic2VsZWN0ZWRDaGFuZ2VkXCIgb2YgYCArXG4gICAgICAgICAgICAgIGBjbGFzcyBcIk1hdERhdGVwaWNrZXJcIi4gVXNlIHRoZSBcImRhdGVDaGFuZ2VcIiBvciBcImRhdGVJbnB1dFwiIG1ldGhvZHMgYCArXG4gICAgICAgICAgICAgIGBvbiBcIk1hdERhdGVwaWNrZXJJbnB1dFwiIGluc3RlYWQuYCk7XG4gICAgfVxuICB9XG59XG4iXX0=

package/schematics/ng-update/migrations/misc-checks/misc-template.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+/// <amd-module name="@angular/material/schematics/ng-update/migrations/misc-checks/misc-template" />
+import { Migration, ResolvedResource } from '@angular/cdk/schematics';
+/**
+ * Migration that walks through every inline or external template and reports if there
+ * are outdated usages of the Angular Material API that needs to be updated manually.
+ */
+export declare class MiscTemplateMigration extends Migration<null> {
+    enabled: boolean;
+    visitTemplate(template: ResolvedResource): void;
+}

package/schematics/ng-update/migrations/misc-checks/misc-template.js

@@ -0,0 +1,69 @@
+/**
+ * @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-checks/misc-template", ["require", "exports", "@angular/cdk/schematics"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    const schematics_1 = require("@angular/cdk/schematics");
+    /**
+     * Migration that walks through every inline or external template and reports if there
+     * are outdated usages of the Angular Material API that needs to be updated manually.
+     */
+    class MiscTemplateMigration extends schematics_1.Migration {
+        constructor() {
+            super(...arguments);
+            // Only enable this rule if the migration targets version 6. The rule
+            // currently only includes migrations for V6 deprecations.
+            this.enabled = this.targetVersion === schematics_1.TargetVersion.V6;
+        }
+        visitTemplate(template) {
+            // Migration for: https://github.com/angular/components/pull/10398 (v6)
+            schematics_1.findOutputsOnElementWithTag(template.content, 'selectionChange', [
+                'mat-list-option'
+            ]).forEach(offset => {
+                this.failures.push({
+                    filePath: template.filePath,
+                    position: template.getCharacterAndLineOfPosition(template.start + offset),
+                    message: `Found deprecated "selectionChange" output binding on "mat-list-option". ` +
+                        `Use "selectionChange" on "mat-selection-list" instead.`
+                });
+            });
+            // Migration for: https://github.com/angular/components/pull/10413 (v6)
+            schematics_1.findOutputsOnElementWithTag(template.content, 'selectedChanged', [
+                'mat-datepicker'
+            ]).forEach(offset => {
+                this.failures.push({
+                    filePath: template.filePath,
+                    position: template.getCharacterAndLineOfPosition(template.start + offset),
+                    message: `Found deprecated "selectedChanged" output binding on "mat-datepicker". ` +
+                        `Use "dateChange" or "dateInput" on "<input [matDatepicker]>" instead.`
+                });
+            });
+            // Migration for: https://github.com/angular/components/commit/f0bf6e7 (v6)
+            schematics_1.findInputsOnElementWithTag(template.content, 'selected', [
+                'mat-button-toggle-group'
+            ]).forEach(offset => {
+                this.failures.push({
+                    filePath: template.filePath,
+                    position: template.getCharacterAndLineOfPosition(template.start + offset),
+                    message: `Found deprecated "selected" input binding on "mat-radio-button-group". ` +
+                        `Use "value" instead.`
+                });
+            });
+        }
+    }
+    exports.MiscTemplateMigration = MiscTemplateMigration;
+});
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -5,16 +5,16 @@
  * 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-rule" />
-import { MigrationRule, ResolvedResource } from '@angular/cdk/schematics';
+/// <amd-module name="@angular/material/schematics/ng-update/migrations/misc-ripples-v7/ripple-speed-factor-migration" />
+import { Migration, ResolvedResource } from '@angular/cdk/schematics';
 import * as ts from 'typescript';
 /**
- * Rule that walks through every property assignment and switches the global `baseSpeedFactor`
+ * 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.
  */
-export declare class RippleSpeedFactorRule extends MigrationRule<null> {
-    ruleEnabled: boolean;
+export declare class RippleSpeedFactorMigration extends Migration<null> {
+    enabled: boolean;
     visitNode(node: ts.Node): void;
     visitTemplate(template: ResolvedResource): void;
     /** Switches binary expressions (e.g. myRipple.speedFactor = 0.5) to the new animation config. */