@angular/cdk 9.2.0 → 9.2.4

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,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

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;

package/schematics/ng-update/migrations/input-names.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/cdk/schematics/ng-update/migrations/input-names", ["require", "exports", "@angular/cdk/schematics/ng-update/html-parsing/angular", "@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 angular_1 = require("@angular/cdk/schematics/ng-update/html-parsing/angular");
+    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 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]`
+     */
+    class InputNamesMigration extends migration_1.Migration {
+        constructor() {
+            super(...arguments);
+            /** Change data that upgrades to the specified target version. */
+            this.data = upgrade_data_1.getVersionUpgradeData(this, 'inputNames');
+            // Only enable the migration rule if there is upgrade data.
+            this.enabled = this.data.length !== 0;
+        }
+        visitStylesheet(stylesheet) {
+            this.data.forEach(name => {
+                const currentSelector = `[${name.replace}]`;
+                const updatedSelector = `[${name.replaceWith}]`;
+                literal_1.findAllSubstringIndices(stylesheet.content, currentSelector)
+                    .map(offset => stylesheet.start + offset)
+                    .forEach(start => this._replaceInputName(stylesheet.filePath, start, currentSelector.length, updatedSelector));
+            });
+        }
+        visitTemplate(template) {
+            this.data.forEach(name => {
+                const whitelist = name.whitelist;
+                const relativeOffsets = [];
+                if (whitelist.attributes) {
+                    relativeOffsets.push(...angular_1.findInputsOnElementWithAttr(template.content, name.replace, whitelist.attributes));
+                }
+                if (whitelist.elements) {
+                    relativeOffsets.push(...angular_1.findInputsOnElementWithTag(template.content, name.replace, whitelist.elements));
+                }
+                relativeOffsets.map(offset => template.start + offset)
+                    .forEach(start => this._replaceInputName(template.filePath, start, name.replace.length, name.replaceWith));
+            });
+        }
+        _replaceInputName(filePath, start, width, newName) {
+            this.fileSystem.edit(filePath)
+                .remove(start, width)
+                .insertRight(start, newName);
+        }
+    }
+    exports.InputNamesMigration = InputNamesMigration;
+});
+//# sourceMappingURL=data:application/json;base64,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

package/schematics/ng-update/{upgrade-rules/method-call-arguments-rule.d.ts → migrations/method-call-arguments.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/method-call-arguments-rule" />
+/// <amd-module name="@angular/cdk/schematics/ng-update/migrations/method-call-arguments" />
 import * as ts from 'typescript';
-import { MigrationRule } from '../../update-tool/migration-rule';
+import { Migration } from '../../update-tool/migration';
 import { MethodCallUpgradeData } from '../data';
-import { RuleUpgradeData } from '../upgrade-data';
+import { UpgradeData } from '../upgrade-data';
 /**
- * Rule that visits every TypeScript method call expression and checks if the
+ * Migration that visits every TypeScript method call expression and checks if the
  * argument count is invalid and needs to be *manually* updated.
  */
-export declare class MethodCallArgumentsRule extends MigrationRule<RuleUpgradeData> {
+export declare class MethodCallArgumentsMigration extends Migration<UpgradeData> {
     /** Change data that upgrades to the specified target version. */
     data: MethodCallUpgradeData[];
-    ruleEnabled: boolean;
+    enabled: boolean;
     visitNode(node: ts.Node): void;
     private _checkPropertyAccessMethodCall;
 }

package/schematics/ng-update/migrations/method-call-arguments.js

@@ -0,0 +1,70 @@
+/**
+ * @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/method-call-arguments", ["require", "exports", "typescript", "@angular/cdk/schematics/update-tool/migration", "@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 upgrade_data_1 = require("@angular/cdk/schematics/ng-update/upgrade-data");
+    /**
+     * Migration that visits every TypeScript method call expression and checks if the
+     * argument count is invalid and needs to be *manually* updated.
+     */
+    class MethodCallArgumentsMigration extends migration_1.Migration {
+        constructor() {
+            super(...arguments);
+            /** Change data that upgrades to the specified target version. */
+            this.data = upgrade_data_1.getVersionUpgradeData(this, 'methodCallChecks');
+            // Only enable the migration rule if there is upgrade data.
+            this.enabled = this.data.length !== 0;
+        }
+        visitNode(node) {
+            if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression)) {
+                this._checkPropertyAccessMethodCall(node);
+            }
+        }
+        _checkPropertyAccessMethodCall(node) {
+            const propertyAccess = node.expression;
+            if (!ts.isIdentifier(propertyAccess.name)) {
+                return;
+            }
+            const hostType = this.typeChecker.getTypeAtLocation(propertyAccess.expression);
+            const hostTypeName = hostType.symbol && hostType.symbol.name;
+            const methodName = propertyAccess.name.text;
+            if (!hostTypeName) {
+                return;
+            }
+            // TODO(devversion): Revisit the implementation of this upgrade rule. It seems difficult
+            // and ambiguous to maintain the data for this rule. e.g. consider a method which has the
+            // same amount of arguments but just had a type change. In that case we could still add
+            // new entries to the upgrade data that match the current argument length to just show
+            // a failure message, but adding that data becomes painful if the method has optional
+            // parameters and it would mean that the error message would always show up, even if the
+            // argument is in some cases still assignable to the new parameter type. We could re-use
+            // the logic we have in the constructor-signature checks to check for assignability and
+            // to make the upgrade data less verbose.
+            const failure = this.data.filter(data => data.method === methodName && data.className === hostTypeName)
+                .map(data => data.invalidArgCounts.find(f => f.count === node.arguments.length))[0];
+            if (!failure) {
+                return;
+            }
+            this.createFailureAtNode(node, `Found call to "${hostTypeName + '.' + methodName}" ` +
+                `with ${failure.count} arguments. Message: ${failure.message}`);
+        }
+    }
+    exports.MethodCallArgumentsMigration = MethodCallArgumentsMigration;
+});
+//# sourceMappingURL=data:application/json;base64,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

package/schematics/ng-update/{upgrade-rules/misc-template-rule.d.ts → migrations/misc-template.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/cdk/schematics/ng-update/upgrade-rules/misc-template-rule" />
+/// <amd-module name="@angular/cdk/schematics/ng-update/migrations/misc-template" />
 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 template and reports if there are
+ * Migration that walks through every template and reports if there are
  * instances of outdated Angular CDK API that can't be migrated automatically.
  */
-export declare class MiscTemplateRule extends MigrationRule<RuleUpgradeData> {
-    ruleEnabled: boolean;
+export declare class MiscTemplateMigration extends Migration<UpgradeData> {
+    enabled: boolean;
     visitTemplate(template: ResolvedResource): void;
 }

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

@@ -0,0 +1,47 @@
+/**
+ * @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/misc-template", ["require", "exports", "@angular/cdk/schematics/update-tool/target-version", "@angular/cdk/schematics/update-tool/migration", "@angular/cdk/schematics/ng-update/typescript/literal"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    const target_version_1 = require("@angular/cdk/schematics/update-tool/target-version");
+    const migration_1 = require("@angular/cdk/schematics/update-tool/migration");
+    const literal_1 = require("@angular/cdk/schematics/ng-update/typescript/literal");
+    /**
+     * Migration that walks through every template and reports if there are
+     * instances of outdated Angular CDK API that can't be migrated automatically.
+     */
+    class MiscTemplateMigration extends migration_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 === target_version_1.TargetVersion.V6;
+        }
+        visitTemplate(template) {
+            // Migration for https://github.com/angular/components/pull/10325 (v6)
+            literal_1.findAllSubstringIndices(template.content, 'cdk-focus-trap').forEach(offset => {
+                this.failures.push({
+                    filePath: template.filePath,
+                    position: template.getCharacterAndLineOfPosition(template.start + offset),
+                    message: `Found deprecated element selector "cdk-focus-trap" which has been ` +
+                        `changed to an attribute selector "[cdkTrapFocus]".`
+                });
+            });
+        }
+    }
+    exports.MiscTemplateMigration = MiscTemplateMigration;
+});
+//# sourceMappingURL=data:application/json;base64,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

package/schematics/ng-update/{upgrade-rules/output-names-rule.d.ts → migrations/output-names.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/output-names-rule" />
+/// <amd-module name="@angular/cdk/schematics/ng-update/migrations/output-names" />
 import { ResolvedResource } from '../../update-tool/component-resource-collector';
-import { MigrationRule } from '../../update-tool/migration-rule';
+import { Migration } from '../../update-tool/migration';
 import { OutputNameUpgradeData } from '../data';
-import { RuleUpgradeData } from '../upgrade-data';
+import { UpgradeData } from '../upgrade-data';
 /**
- * Rule that walks through every inline or external HTML template and switches
+ * Migration that walks through every inline or external HTML template and switches
  * changed output binding names to the proper new output name.
  */
-export declare class OutputNamesRule extends MigrationRule<RuleUpgradeData> {
+export declare class OutputNamesMigration extends Migration<UpgradeData> {
     /** Change data that upgrades to the specified target version. */
     data: OutputNameUpgradeData[];
-    ruleEnabled: boolean;
+    enabled: boolean;
     visitTemplate(template: ResolvedResource): void;
     private _replaceOutputName;
 }

package/schematics/ng-update/migrations/output-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/cdk/schematics/ng-update/migrations/output-names", ["require", "exports", "@angular/cdk/schematics/update-tool/migration", "@angular/cdk/schematics/ng-update/html-parsing/angular", "@angular/cdk/schematics/ng-update/upgrade-data"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    const migration_1 = require("@angular/cdk/schematics/update-tool/migration");
+    const angular_1 = require("@angular/cdk/schematics/ng-update/html-parsing/angular");
+    const upgrade_data_1 = require("@angular/cdk/schematics/ng-update/upgrade-data");
+    /**
+     * Migration that walks through every inline or external HTML template and switches
+     * changed output binding names to the proper new output name.
+     */
+    class OutputNamesMigration extends migration_1.Migration {
+        constructor() {
+            super(...arguments);
+            /** Change data that upgrades to the specified target version. */
+            this.data = upgrade_data_1.getVersionUpgradeData(this, 'outputNames');
+            // Only enable the migration rule if there is upgrade data.
+            this.enabled = this.data.length !== 0;
+        }
+        visitTemplate(template) {
+            this.data.forEach(name => {
+                const whitelist = name.whitelist;
+                const relativeOffsets = [];
+                if (whitelist.attributes) {
+                    relativeOffsets.push(...angular_1.findOutputsOnElementWithAttr(template.content, name.replace, whitelist.attributes));
+                }
+                if (whitelist.elements) {
+                    relativeOffsets.push(...angular_1.findOutputsOnElementWithTag(template.content, name.replace, whitelist.elements));
+                }
+                relativeOffsets.map(offset => template.start + offset)
+                    .forEach(start => this._replaceOutputName(template.filePath, start, name.replace.length, name.replaceWith));
+            });
+        }
+        _replaceOutputName(filePath, start, width, newName) {
+            this.fileSystem.edit(filePath)
+                .remove(start, width)
+                .insertRight(start, newName);
+        }
+    }
+    exports.OutputNamesMigration = OutputNamesMigration;
+});
+//# sourceMappingURL=data:application/json;base64,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

package/schematics/ng-update/{upgrade-rules/property-names-rule.d.ts → migrations/property-names.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/property-names-rule" />
+/// <amd-module name="@angular/cdk/schematics/ng-update/migrations/property-names" />
 import * as ts from 'typescript';
-import { MigrationRule } from '../../update-tool/migration-rule';
+import { Migration } from '../../update-tool/migration';
 import { PropertyNameUpgradeData } from '../data';
-import { RuleUpgradeData } from '../upgrade-data';
+import { UpgradeData } from '../upgrade-data';
 /**
- * Rule that walks through every property access expression and updates
+ * Migration that walks through every property access expression and updates
  * accessed properties that have been updated to a new name.
  */
-export declare class PropertyNamesRule extends MigrationRule<RuleUpgradeData> {
+export declare class PropertyNamesMigration extends Migration<UpgradeData> {
     /** Change data that upgrades to the specified target version. */
     data: PropertyNameUpgradeData[];
-    ruleEnabled: boolean;
+    enabled: boolean;
     visitNode(node: ts.Node): void;
     private _visitPropertyAccessExpression;
 }

package/schematics/ng-update/migrations/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/cdk/schematics/ng-update/migrations/property-names", ["require", "exports", "typescript", "@angular/cdk/schematics/update-tool/migration", "@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 upgrade_data_1 = require("@angular/cdk/schematics/ng-update/upgrade-data");
+    /**
+     * Migration that walks through every property access expression and updates
+     * accessed properties that have been updated to a new name.
+     */
+    class PropertyNamesMigration extends migration_1.Migration {
+        constructor() {
+            super(...arguments);
+            /** Change data that upgrades to the specified target version. */
+            this.data = upgrade_data_1.getVersionUpgradeData(this, 'propertyNames');
+            // Only enable the migration rule if there is upgrade data.
+            this.enabled = this.data.length !== 0;
+        }
+        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();
+            this.data.forEach(data => {
+                if (node.name.text !== data.replace) {
+                    return;
+                }
+                if (!data.whitelist || data.whitelist.classes.includes(typeName)) {
+                    this.fileSystem.edit(node.getSourceFile().fileName)
+                        .remove(node.name.getStart(), node.name.getWidth())
+                        .insertRight(node.name.getStart(), data.replaceWith);
+                }
+            });
+        }
+    }
+    exports.PropertyNamesMigration = PropertyNamesMigration;
+});
+//# sourceMappingURL=data:application/json;base64,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

package/schematics/ng-update/public-api.d.ts

@@ -6,12 +6,13 @@
  * found in the LICENSE file at https://angular.io/license
  */
 /// <amd-module name="@angular/cdk/schematics/ng-update/public-api" />
-export * from './upgrade-data';
 export * from './data/index';
+export * from './devkit-migration';
+export * from './devkit-migration-rule';
 export * from './html-parsing/angular';
 export * from './html-parsing/elements';
-export * from './upgrade-rules/index';
 export * from './typescript/base-types';
 export * from './typescript/imports';
 export * from './typescript/literal';
 export * from './typescript/module-specifiers';
+export * from './upgrade-data';

package/schematics/ng-update/public-api.js

@@ -11,7 +11,7 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define("@angular/cdk/schematics/ng-update/public-api", ["require", "exports", "@angular/cdk/schematics/ng-update/upgrade-data", "@angular/cdk/schematics/ng-update/data/index", "@angular/cdk/schematics/ng-update/html-parsing/angular", "@angular/cdk/schematics/ng-update/html-parsing/elements", "@angular/cdk/schematics/ng-update/upgrade-rules/index", "@angular/cdk/schematics/ng-update/typescript/base-types", "@angular/cdk/schematics/ng-update/typescript/imports", "@angular/cdk/schematics/ng-update/typescript/literal", "@angular/cdk/schematics/ng-update/typescript/module-specifiers"], factory);
+        define("@angular/cdk/schematics/ng-update/public-api", ["require", "exports", "@angular/cdk/schematics/ng-update/data/index", "@angular/cdk/schematics/ng-update/devkit-migration", "@angular/cdk/schematics/ng-update/devkit-migration-rule", "@angular/cdk/schematics/ng-update/html-parsing/angular", "@angular/cdk/schematics/ng-update/html-parsing/elements", "@angular/cdk/schematics/ng-update/typescript/base-types", "@angular/cdk/schematics/ng-update/typescript/imports", "@angular/cdk/schematics/ng-update/typescript/literal", "@angular/cdk/schematics/ng-update/typescript/module-specifiers", "@angular/cdk/schematics/ng-update/upgrade-data"], factory);
     }
 })(function (require, exports) {
     "use strict";
@@ -19,14 +19,15 @@
         for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
     }
     Object.defineProperty(exports, "__esModule", { value: true });
-    __export(require("@angular/cdk/schematics/ng-update/upgrade-data"));
     __export(require("@angular/cdk/schematics/ng-update/data/index"));
+    __export(require("@angular/cdk/schematics/ng-update/devkit-migration"));
+    __export(require("@angular/cdk/schematics/ng-update/devkit-migration-rule"));
     __export(require("@angular/cdk/schematics/ng-update/html-parsing/angular"));
     __export(require("@angular/cdk/schematics/ng-update/html-parsing/elements"));
-    __export(require("@angular/cdk/schematics/ng-update/upgrade-rules/index"));
     __export(require("@angular/cdk/schematics/ng-update/typescript/base-types"));
     __export(require("@angular/cdk/schematics/ng-update/typescript/imports"));
     __export(require("@angular/cdk/schematics/ng-update/typescript/literal"));
     __export(require("@angular/cdk/schematics/ng-update/typescript/module-specifiers"));
+    __export(require("@angular/cdk/schematics/ng-update/upgrade-data"));
 });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYy9jZGsvc2NoZW1hdGljcy9uZy11cGRhdGUvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7Ozs7Ozs7Ozs7Ozs7OztJQUVILG9FQUErQjtJQUMvQixrRUFBNkI7SUFDN0IsNEVBQXVDO0lBQ3ZDLDZFQUF3QztJQUN4QywyRUFBc0M7SUFDdEMsNkVBQXdDO0lBQ3hDLDBFQUFxQztJQUNyQywwRUFBcUM7SUFDckMsb0ZBQStDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBMTEMgQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vdXBncmFkZS1kYXRhJztcbmV4cG9ydCAqIGZyb20gJy4vZGF0YS9pbmRleCc7XG5leHBvcnQgKiBmcm9tICcuL2h0bWwtcGFyc2luZy9hbmd1bGFyJztcbmV4cG9ydCAqIGZyb20gJy4vaHRtbC1wYXJzaW5nL2VsZW1lbnRzJztcbmV4cG9ydCAqIGZyb20gJy4vdXBncmFkZS1ydWxlcy9pbmRleCc7XG5leHBvcnQgKiBmcm9tICcuL3R5cGVzY3JpcHQvYmFzZS10eXBlcyc7XG5leHBvcnQgKiBmcm9tICcuL3R5cGVzY3JpcHQvaW1wb3J0cyc7XG5leHBvcnQgKiBmcm9tICcuL3R5cGVzY3JpcHQvbGl0ZXJhbCc7XG5leHBvcnQgKiBmcm9tICcuL3R5cGVzY3JpcHQvbW9kdWxlLXNwZWNpZmllcnMnO1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYy9jZGsvc2NoZW1hdGljcy9uZy11cGRhdGUvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7Ozs7Ozs7Ozs7Ozs7OztJQUVILGtFQUE2QjtJQUM3Qix3RUFBbUM7SUFDbkMsNkVBQXdDO0lBQ3hDLDRFQUF1QztJQUN2Qyw2RUFBd0M7SUFDeEMsNkVBQXdDO0lBQ3hDLDBFQUFxQztJQUNyQywwRUFBcUM7SUFDckMsb0ZBQStDO0lBQy9DLG9FQUErQiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2RhdGEvaW5kZXgnO1xuZXhwb3J0ICogZnJvbSAnLi9kZXZraXQtbWlncmF0aW9uJztcbmV4cG9ydCAqIGZyb20gJy4vZGV2a2l0LW1pZ3JhdGlvbi1ydWxlJztcbmV4cG9ydCAqIGZyb20gJy4vaHRtbC1wYXJzaW5nL2FuZ3VsYXInO1xuZXhwb3J0ICogZnJvbSAnLi9odG1sLXBhcnNpbmcvZWxlbWVudHMnO1xuZXhwb3J0ICogZnJvbSAnLi90eXBlc2NyaXB0L2Jhc2UtdHlwZXMnO1xuZXhwb3J0ICogZnJvbSAnLi90eXBlc2NyaXB0L2ltcG9ydHMnO1xuZXhwb3J0ICogZnJvbSAnLi90eXBlc2NyaXB0L2xpdGVyYWwnO1xuZXhwb3J0ICogZnJvbSAnLi90eXBlc2NyaXB0L21vZHVsZS1zcGVjaWZpZXJzJztcbmV4cG9ydCAqIGZyb20gJy4vdXBncmFkZS1kYXRhJztcbiJdfQ==