@angular/cdk 9.2.1 → 9.2.2

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

@@ -6,16 +6,16 @@
  * found in the LICENSE file at https://angular.io/license
  */
 /// <amd-module name="@angular/cdk/schematics/ng-update/upgrade-data" />
-import { MigrationRule } from '../update-tool/migration-rule';
+import { Migration } from '../update-tool/migration';
 import { ValueOfChanges, VersionChanges } from '../update-tool/version-changes';
 import { AttributeSelectorUpgradeData, ClassNameUpgradeData, ConstructorChecksUpgradeData, CssSelectorUpgradeData, ElementSelectorUpgradeData, InputNameUpgradeData, MethodCallUpgradeData, OutputNameUpgradeData, PropertyNameUpgradeData } from './data';
 /** Upgrade data for the Angular CDK. */
-export declare const cdkUpgradeData: RuleUpgradeData;
+export declare const cdkUpgradeData: UpgradeData;
 /**
  * Interface that describes the upgrade data that needs to be defined when using the CDK
  * upgrade rules.
  */
-export interface RuleUpgradeData {
+export interface UpgradeData {
     attributeSelectors: VersionChanges<AttributeSelectorUpgradeData>;
     classNames: VersionChanges<ClassNameUpgradeData>;
     constructorChecks: VersionChanges<ConstructorChecksUpgradeData>;
@@ -27,9 +27,8 @@ export interface RuleUpgradeData {
     propertyNames: VersionChanges<PropertyNameUpgradeData>;
 }
 /**
- * Gets the reduced upgrade data for the specified data key from the rule walker options.
- *
- * The function reads out the target version and upgrade data object from the rule options and
- * resolves the specified data portion that is specifically tied to the target version.
+ * Gets the reduced upgrade data for the specified data key. The function reads out the
+ * target version and upgrade data object from the migration and resolves the specified
+ * data portion that is specifically tied to the target version.
  */
-export declare function getVersionUpgradeData<T extends keyof RuleUpgradeData, U = ValueOfChanges<RuleUpgradeData[T]>>(r: MigrationRule<RuleUpgradeData>, dataName: T): U[];
+export declare function getVersionUpgradeData<T extends keyof UpgradeData, U = ValueOfChanges<UpgradeData[T]>>(migration: Migration<UpgradeData>, dataName: T): U[];

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

@@ -31,15 +31,14 @@
         propertyNames: data_1.propertyNames,
     };
     /**
-     * Gets the reduced upgrade data for the specified data key from the rule walker options.
-     *
-     * The function reads out the target version and upgrade data object from the rule options and
-     * resolves the specified data portion that is specifically tied to the target version.
+     * Gets the reduced upgrade data for the specified data key. The function reads out the
+     * target version and upgrade data object from the migration and resolves the specified
+     * data portion that is specifically tied to the target version.
      */
-    function getVersionUpgradeData(r, dataName) {
+    function getVersionUpgradeData(migration, dataName) {
         // Note that below we need to cast to `unknown` first TS doesn't infer the type of T correctly.
-        return version_changes_1.getChangesForTarget(r.targetVersion, r.upgradeData[dataName]);
+        return version_changes_1.getChangesForTarget(migration.targetVersion, migration.upgradeData[dataName]);
     }
     exports.getVersionUpgradeData = getVersionUpgradeData;
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/schematics/update-tool/component-resource-collector.d.ts

@@ -7,6 +7,7 @@
  */
 /// <amd-module name="@angular/cdk/schematics/update-tool/component-resource-collector" />
 import * as ts from 'typescript';
+import { FileSystem } from './file-system';
 import { LineAndCharacter } from './utils/line-mappings';
 export interface ResolvedResource {
     /** Class declaration that contains this resource. */
@@ -32,9 +33,10 @@ export interface ResolvedResource {
  */
 export declare class ComponentResourceCollector {
     typeChecker: ts.TypeChecker;
+    private _fileSystem;
     resolvedTemplates: ResolvedResource[];
     resolvedStylesheets: ResolvedResource[];
-    constructor(typeChecker: ts.TypeChecker);
+    constructor(typeChecker: ts.TypeChecker, _fileSystem: FileSystem);
     visitNode(node: ts.Node): void;
     private _visitClassDeclaration;
     /** Resolves an external stylesheet by reading its content and computing line mappings. */

package/schematics/update-tool/component-resource-collector.js

@@ -11,12 +11,11 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define("@angular/cdk/schematics/update-tool/component-resource-collector", ["require", "exports", "fs", "path", "typescript", "@angular/cdk/schematics/update-tool/utils/decorators", "@angular/cdk/schematics/update-tool/utils/functions", "@angular/cdk/schematics/update-tool/utils/line-mappings", "@angular/cdk/schematics/update-tool/utils/property-name"], factory);
+        define("@angular/cdk/schematics/update-tool/component-resource-collector", ["require", "exports", "path", "typescript", "@angular/cdk/schematics/update-tool/utils/decorators", "@angular/cdk/schematics/update-tool/utils/functions", "@angular/cdk/schematics/update-tool/utils/line-mappings", "@angular/cdk/schematics/update-tool/utils/property-name"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    const fs_1 = require("fs");
     const path_1 = require("path");
     const ts = require("typescript");
     const decorators_1 = require("@angular/cdk/schematics/update-tool/utils/decorators");
@@ -28,8 +27,9 @@
      * given TypeScript source files (inline or external referenced files)
      */
     class ComponentResourceCollector {
-        constructor(typeChecker) {
+        constructor(typeChecker, _fileSystem) {
             this.typeChecker = typeChecker;
+            this._fileSystem = _fileSystem;
             this.resolvedTemplates = [];
             this.resolvedStylesheets = [];
         }
@@ -105,7 +105,7 @@
                         if (ts.isStringLiteralLike(el)) {
                             const stylesheetPath = path_1.resolve(path_1.dirname(sourceFileName), el.text);
                             // In case the stylesheet does not exist in the file system, skip it gracefully.
-                            if (!fs_1.existsSync(stylesheetPath)) {
+                            if (!this._fileSystem.exists(stylesheetPath)) {
                                 return;
                             }
                             this.resolvedStylesheets.push(this.resolveExternalStylesheet(stylesheetPath, node));
@@ -116,10 +116,10 @@
                     const templatePath = path_1.resolve(path_1.dirname(sourceFileName), property.initializer.text);
                     // In case the template does not exist in the file system, skip this
                     // external template.
-                    if (!fs_1.existsSync(templatePath)) {
+                    if (!this._fileSystem.exists(templatePath)) {
                         return;
                     }
-                    const fileContent = fs_1.readFileSync(templatePath, 'utf8');
+                    const fileContent = this._fileSystem.read(templatePath);
                     const lineStartsMap = line_mappings_1.computeLineStartsMap(fileContent);
                     this.resolvedTemplates.push({
                         filePath: templatePath,
@@ -134,7 +134,7 @@
         }
         /** Resolves an external stylesheet by reading its content and computing line mappings. */
         resolveExternalStylesheet(filePath, container) {
-            const fileContent = fs_1.readFileSync(filePath, 'utf8');
+            const fileContent = this._fileSystem.read(filePath);
             const lineStartsMap = line_mappings_1.computeLineStartsMap(fileContent);
             return {
                 filePath: filePath,
@@ -148,4 +148,4 @@
     }
     exports.ComponentResourceCollector = ComponentResourceCollector;
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"component-resource-collector.js","sourceRoot":"","sources":["../../../../../../../src/cdk/schematics/update-tool/component-resource-collector.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;;;;;;;;;;;;IAEH,2BAA4C;IAC5C,+BAAsC;IACtC,iCAAiC;IACjC,qFAAwD;IACxD,mFAAmD;IACnD,2FAI+B;IAC/B,2FAA0D;IAqB1D;;;OAGG;IACH,MAAa,0BAA0B;QAIrC,YAAmB,WAA2B;YAA3B,gBAAW,GAAX,WAAW,CAAgB;YAH9C,sBAAiB,GAAuB,EAAE,CAAC;YAC3C,wBAAmB,GAAuB,EAAE,CAAC;QAEI,CAAC;QAElD,SAAS,CAAC,IAAa;YACrB,IAAI,IAAI,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,gBAAgB,EAAE;gBAChD,IAAI,CAAC,sBAAsB,CAAC,IAA2B,CAAC,CAAC;aAC1D;QACH,CAAC;QAEO,sBAAsB,CAAC,IAAyB;YACtD,IAAI,CAAC,IAAI,CAAC,UAAU,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE;gBAC/C,OAAO;aACR;YAED,MAAM,YAAY,GAAG,iCAAoB,CAAC,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;YAC7E,MAAM,kBAAkB,GAAG,YAAY,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,IAAI,KAAK,WAAW,CAAC,CAAC;YAE9E,+EAA+E;YAC/E,IAAI,CAAC,kBAAkB,EAAE;gBACvB,OAAO;aACR;YAED,MAAM,aAAa,GAAG,kBAAkB,CAAC,IAAI,CAAC,UAAU,CAAC;YAEzD,kFAAkF;YAClF,IAAI,aAAa,CAAC,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE;gBACxC,OAAO;aACR;YAED,MAAM,iBAAiB,GAAG,4BAAgB,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;YAEvE,sEAAsE;YACtE,IAAI,CAAC,EAAE,CAAC,yBAAyB,CAAC,iBAAiB,CAAC,EAAE;gBACpD,OAAO;aACR;YAED,MAAM,UAAU,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC;YACxC,MAAM,cAAc,GAAG,UAAU,CAAC,QAAQ,CAAC;YAE3C,8EAA8E;YAC9E,6CAA6C;YAC7C,iBAAiB,CAAC,UAAU,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE;gBAC9C,IAAI,CAAC,EAAE,CAAC,oBAAoB,CAAC,QAAQ,CAAC,EAAE;oBACtC,OAAO;iBACR;gBAED,MAAM,YAAY,GAAG,mCAAmB,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;gBACxD,MAAM,QAAQ,GAAG,cAAO,CAAC,cAAc,CAAC,CAAC;gBAEzC,IAAI,YAAY,KAAK,QAAQ,IAAI,EAAE,CAAC,wBAAwB,CAAC,QAAQ,CAAC,WAAW,CAAC,EAAE;oBAClF,QAAQ,CAAC,WAAW,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,EAAE;wBACzC,IAAI,EAAE,CAAC,mBAAmB,CAAC,EAAE,CAAC,EAAE;4BAC9B,4EAA4E;4BAC5E,oCAAoC;4BACpC,MAAM,gBAAgB,GAAG,EAAE,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC;4BAC3C,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC;gCAC5B,QAAQ,EAAE,QAAQ;gCAClB,SAAS,EAAE,IAAI;gCACf,OAAO,EAAE,EAAE,CAAC,IAAI;gCAChB,MAAM,EAAE,IAAI;gCACZ,KAAK,EAAE,gBAAgB;gCACvB,6BAA6B,EAAE,GAAG,CAAC,EAAE,CACjC,EAAE,CAAC,6BAA6B,CAAC,UAAU,EAAE,GAAG,GAAG,gBAAgB,CAAC;6BACzE,CAAC,CAAC;yBACJ;oBACH,CAAC,CAAC,CAAC;iBACJ;gBAED,qFAAqF;gBACrF,2EAA2E;gBAC3E,IAAI,YAAY,KAAK,UAAU,IAAI,EAAE,CAAC,mBAAmB,CAAC,QAAQ,CAAC,WAAW,CAAC,EAAE;oBAC/E,4EAA4E;oBAC5E,oCAAoC;oBACpC,MAAM,gBAAgB,GAAG,QAAQ,CAAC,WAAW,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC;oBAC7D,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC;wBAC1B,QAAQ,EAAE,QAAQ;wBAClB,SAAS,EAAE,IAAI;wBACf,OAAO,EAAE,QAAQ,CAAC,WAAW,CAAC,IAAI;wBAClC,MAAM,EAAE,IAAI;wBACZ,KAAK,EAAE,gBAAgB;wBACvB,6BAA6B,EAAE,GAAG,CAAC,EAAE,CACjC,EAAE,CAAC,6BAA6B,CAAC,UAAU,EAAE,GAAG,GAAG,gBAAgB,CAAC;qBACzE,CAAC,CAAC;iBACJ;gBAED,IAAI,YAAY,KAAK,WAAW,IAAI,EAAE,CAAC,wBAAwB,CAAC,QAAQ,CAAC,WAAW,CAAC,EAAE;oBACrF,QAAQ,CAAC,WAAW,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,EAAE;wBACzC,IAAI,EAAE,CAAC,mBAAmB,CAAC,EAAE,CAAC,EAAE;4BAC9B,MAAM,cAAc,GAAG,cAAO,CAAC,cAAO,CAAC,cAAc,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC;4BAEjE,gFAAgF;4BAChF,IAAI,CAAC,eAAU,CAAC,cAAc,CAAC,EAAE;gCAC/B,OAAO;6BACR;4BAED,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,IAAI,CAAC,yBAAyB,CAAC,cAAc,EAAE,IAAI,CAAC,CAAC,CAAC;yBACrF;oBACH,CAAC,CAAC,CAAC;iBACJ;gBAED,IAAI,YAAY,KAAK,aAAa,IAAI,EAAE,CAAC,mBAAmB,CAAC,QAAQ,CAAC,WAAW,CAAC,EAAE;oBAClF,MAAM,YAAY,GAAG,cAAO,CAAC,cAAO,CAAC,cAAc,CAAC,EAAE,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;oBAEjF,oEAAoE;oBACpE,qBAAqB;oBACrB,IAAI,CAAC,eAAU,CAAC,YAAY,CAAC,EAAE;wBAC7B,OAAO;qBACR;oBAED,MAAM,WAAW,GAAG,iBAAY,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC;oBACvD,MAAM,aAAa,GAAG,oCAAoB,CAAC,WAAW,CAAC,CAAC;oBAExD,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC;wBAC1B,QAAQ,EAAE,YAAY;wBACtB,SAAS,EAAE,IAAI;wBACf,OAAO,EAAE,WAAW;wBACpB,MAAM,EAAE,KAAK;wBACb,KAAK,EAAE,CAAC;wBACR,6BAA6B,EAAE,GAAG,CAAC,EAAE,CAAC,+CAA+B,CAAC,aAAa,EAAE,GAAG,CAAC;qBAC1F,CAAC,CAAC;iBACJ;YACH,CAAC,CAAC,CAAC;QACL,CAAC;QAED,0FAA0F;QAC1F,yBAAyB,CAAC,QAAgB,EAAE,SAAmC;YAE7E,MAAM,WAAW,GAAG,iBAAY,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;YACnD,MAAM,aAAa,GAAG,oCAAoB,CAAC,WAAW,CAAC,CAAC;YAExD,OAAO;gBACL,QAAQ,EAAE,QAAQ;gBAClB,SAAS,EAAE,SAAS;gBACpB,OAAO,EAAE,WAAW;gBACpB,MAAM,EAAE,KAAK;gBACb,KAAK,EAAE,CAAC;gBACR,6BAA6B,EAAE,GAAG,CAAC,EAAE,CAAC,+CAA+B,CAAC,aAAa,EAAE,GAAG,CAAC;aAC1F,CAAC;QACJ,CAAC;KACF;IA9ID,gEA8IC","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 {existsSync, readFileSync} from 'fs';\nimport {dirname, resolve} from 'path';\nimport * as ts from 'typescript';\nimport {getAngularDecorators} from './utils/decorators';\nimport {unwrapExpression} from './utils/functions';\nimport {\n  computeLineStartsMap,\n  getLineAndCharacterFromPosition,\n  LineAndCharacter\n} from './utils/line-mappings';\nimport {getPropertyNameText} from './utils/property-name';\n\nexport interface ResolvedResource {\n  /** Class declaration that contains this resource. */\n  container: ts.ClassDeclaration|null;\n  /** File content of the given template. */\n  content: string;\n  /** Start offset of the resource content (e.g. in the inline source file) */\n  start: number;\n  /** Whether the given resource is inline or not. */\n  inline: boolean;\n  /** Path to the file that contains this resource. */\n  filePath: string;\n  /**\n   * Gets the character and line of a given position index in the resource.\n   * If the resource is declared inline within a TypeScript source file, the line and\n   * character are based on the full source file content.\n   */\n  getCharacterAndLineOfPosition: (pos: number) => LineAndCharacter;\n}\n\n/**\n * Collector that can be used to find Angular templates and stylesheets referenced within\n * given TypeScript source files (inline or external referenced files)\n */\nexport class ComponentResourceCollector {\n  resolvedTemplates: ResolvedResource[] = [];\n  resolvedStylesheets: ResolvedResource[] = [];\n\n  constructor(public typeChecker: ts.TypeChecker) {}\n\n  visitNode(node: ts.Node) {\n    if (node.kind === ts.SyntaxKind.ClassDeclaration) {\n      this._visitClassDeclaration(node as ts.ClassDeclaration);\n    }\n  }\n\n  private _visitClassDeclaration(node: ts.ClassDeclaration) {\n    if (!node.decorators || !node.decorators.length) {\n      return;\n    }\n\n    const ngDecorators = getAngularDecorators(this.typeChecker, node.decorators);\n    const componentDecorator = ngDecorators.find(dec => dec.name === 'Component');\n\n    // In case no \"@Component\" decorator could be found on the current class, skip.\n    if (!componentDecorator) {\n      return;\n    }\n\n    const decoratorCall = componentDecorator.node.expression;\n\n    // In case the component decorator call is not valid, skip this class declaration.\n    if (decoratorCall.arguments.length !== 1) {\n      return;\n    }\n\n    const componentMetadata = unwrapExpression(decoratorCall.arguments[0]);\n\n    // Ensure that the component metadata is an object literal expression.\n    if (!ts.isObjectLiteralExpression(componentMetadata)) {\n      return;\n    }\n\n    const sourceFile = node.getSourceFile();\n    const sourceFileName = sourceFile.fileName;\n\n    // Walk through all component metadata properties and determine the referenced\n    // HTML templates (either external or inline)\n    componentMetadata.properties.forEach(property => {\n      if (!ts.isPropertyAssignment(property)) {\n        return;\n      }\n\n      const propertyName = getPropertyNameText(property.name);\n      const filePath = resolve(sourceFileName);\n\n      if (propertyName === 'styles' && ts.isArrayLiteralExpression(property.initializer)) {\n        property.initializer.elements.forEach(el => {\n          if (ts.isStringLiteralLike(el)) {\n            // Need to add an offset of one to the start because the template quotes are\n            // not part of the template content.\n            const templateStartIdx = el.getStart() + 1;\n            this.resolvedStylesheets.push({\n              filePath: filePath,\n              container: node,\n              content: el.text,\n              inline: true,\n              start: templateStartIdx,\n              getCharacterAndLineOfPosition: pos =>\n                  ts.getLineAndCharacterOfPosition(sourceFile, pos + templateStartIdx),\n            });\n          }\n        });\n      }\n\n      // In case there is an inline template specified, ensure that the value is statically\n      // analyzable by checking if the initializer is a string literal-like node.\n      if (propertyName === 'template' && ts.isStringLiteralLike(property.initializer)) {\n        // Need to add an offset of one to the start because the template quotes are\n        // not part of the template content.\n        const templateStartIdx = property.initializer.getStart() + 1;\n        this.resolvedTemplates.push({\n          filePath: filePath,\n          container: node,\n          content: property.initializer.text,\n          inline: true,\n          start: templateStartIdx,\n          getCharacterAndLineOfPosition: pos =>\n              ts.getLineAndCharacterOfPosition(sourceFile, pos + templateStartIdx)\n        });\n      }\n\n      if (propertyName === 'styleUrls' && ts.isArrayLiteralExpression(property.initializer)) {\n        property.initializer.elements.forEach(el => {\n          if (ts.isStringLiteralLike(el)) {\n            const stylesheetPath = resolve(dirname(sourceFileName), el.text);\n\n            // In case the stylesheet does not exist in the file system, skip it gracefully.\n            if (!existsSync(stylesheetPath)) {\n              return;\n            }\n\n            this.resolvedStylesheets.push(this.resolveExternalStylesheet(stylesheetPath, node));\n          }\n        });\n      }\n\n      if (propertyName === 'templateUrl' && ts.isStringLiteralLike(property.initializer)) {\n        const templatePath = resolve(dirname(sourceFileName), property.initializer.text);\n\n        // In case the template does not exist in the file system, skip this\n        // external template.\n        if (!existsSync(templatePath)) {\n          return;\n        }\n\n        const fileContent = readFileSync(templatePath, 'utf8');\n        const lineStartsMap = computeLineStartsMap(fileContent);\n\n        this.resolvedTemplates.push({\n          filePath: templatePath,\n          container: node,\n          content: fileContent,\n          inline: false,\n          start: 0,\n          getCharacterAndLineOfPosition: pos => getLineAndCharacterFromPosition(lineStartsMap, pos),\n        });\n      }\n    });\n  }\n\n  /** Resolves an external stylesheet by reading its content and computing line mappings. */\n  resolveExternalStylesheet(filePath: string, container: ts.ClassDeclaration|null):\n      ResolvedResource {\n    const fileContent = readFileSync(filePath, 'utf8');\n    const lineStartsMap = computeLineStartsMap(fileContent);\n\n    return {\n      filePath: filePath,\n      container: container,\n      content: fileContent,\n      inline: false,\n      start: 0,\n      getCharacterAndLineOfPosition: pos => getLineAndCharacterFromPosition(lineStartsMap, pos),\n    };\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"component-resource-collector.js","sourceRoot":"","sources":["../../../../../../../src/cdk/schematics/update-tool/component-resource-collector.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 {dirname, resolve} from 'path';\nimport * as ts from 'typescript';\nimport {FileSystem} from './file-system';\nimport {getAngularDecorators} from './utils/decorators';\nimport {unwrapExpression} from './utils/functions';\nimport {\n  computeLineStartsMap,\n  getLineAndCharacterFromPosition,\n  LineAndCharacter\n} from './utils/line-mappings';\nimport {getPropertyNameText} from './utils/property-name';\n\nexport interface ResolvedResource {\n  /** Class declaration that contains this resource. */\n  container: ts.ClassDeclaration|null;\n  /** File content of the given template. */\n  content: string;\n  /** Start offset of the resource content (e.g. in the inline source file) */\n  start: number;\n  /** Whether the given resource is inline or not. */\n  inline: boolean;\n  /** Path to the file that contains this resource. */\n  filePath: string;\n  /**\n   * Gets the character and line of a given position index in the resource.\n   * If the resource is declared inline within a TypeScript source file, the line and\n   * character are based on the full source file content.\n   */\n  getCharacterAndLineOfPosition: (pos: number) => LineAndCharacter;\n}\n\n/**\n * Collector that can be used to find Angular templates and stylesheets referenced within\n * given TypeScript source files (inline or external referenced files)\n */\nexport class ComponentResourceCollector {\n  resolvedTemplates: ResolvedResource[] = [];\n  resolvedStylesheets: ResolvedResource[] = [];\n\n  constructor(public typeChecker: ts.TypeChecker, private _fileSystem: FileSystem) {}\n\n  visitNode(node: ts.Node) {\n    if (node.kind === ts.SyntaxKind.ClassDeclaration) {\n      this._visitClassDeclaration(node as ts.ClassDeclaration);\n    }\n  }\n\n  private _visitClassDeclaration(node: ts.ClassDeclaration) {\n    if (!node.decorators || !node.decorators.length) {\n      return;\n    }\n\n    const ngDecorators = getAngularDecorators(this.typeChecker, node.decorators);\n    const componentDecorator = ngDecorators.find(dec => dec.name === 'Component');\n\n    // In case no \"@Component\" decorator could be found on the current class, skip.\n    if (!componentDecorator) {\n      return;\n    }\n\n    const decoratorCall = componentDecorator.node.expression;\n\n    // In case the component decorator call is not valid, skip this class declaration.\n    if (decoratorCall.arguments.length !== 1) {\n      return;\n    }\n\n    const componentMetadata = unwrapExpression(decoratorCall.arguments[0]);\n\n    // Ensure that the component metadata is an object literal expression.\n    if (!ts.isObjectLiteralExpression(componentMetadata)) {\n      return;\n    }\n\n    const sourceFile = node.getSourceFile();\n    const sourceFileName = sourceFile.fileName;\n\n    // Walk through all component metadata properties and determine the referenced\n    // HTML templates (either external or inline)\n    componentMetadata.properties.forEach(property => {\n      if (!ts.isPropertyAssignment(property)) {\n        return;\n      }\n\n      const propertyName = getPropertyNameText(property.name);\n      const filePath = resolve(sourceFileName);\n\n      if (propertyName === 'styles' && ts.isArrayLiteralExpression(property.initializer)) {\n        property.initializer.elements.forEach(el => {\n          if (ts.isStringLiteralLike(el)) {\n            // Need to add an offset of one to the start because the template quotes are\n            // not part of the template content.\n            const templateStartIdx = el.getStart() + 1;\n            this.resolvedStylesheets.push({\n              filePath: filePath,\n              container: node,\n              content: el.text,\n              inline: true,\n              start: templateStartIdx,\n              getCharacterAndLineOfPosition: pos =>\n                  ts.getLineAndCharacterOfPosition(sourceFile, pos + templateStartIdx),\n            });\n          }\n        });\n      }\n\n      // In case there is an inline template specified, ensure that the value is statically\n      // analyzable by checking if the initializer is a string literal-like node.\n      if (propertyName === 'template' && ts.isStringLiteralLike(property.initializer)) {\n        // Need to add an offset of one to the start because the template quotes are\n        // not part of the template content.\n        const templateStartIdx = property.initializer.getStart() + 1;\n        this.resolvedTemplates.push({\n          filePath: filePath,\n          container: node,\n          content: property.initializer.text,\n          inline: true,\n          start: templateStartIdx,\n          getCharacterAndLineOfPosition: pos =>\n              ts.getLineAndCharacterOfPosition(sourceFile, pos + templateStartIdx)\n        });\n      }\n\n      if (propertyName === 'styleUrls' && ts.isArrayLiteralExpression(property.initializer)) {\n        property.initializer.elements.forEach(el => {\n          if (ts.isStringLiteralLike(el)) {\n            const stylesheetPath = resolve(dirname(sourceFileName), el.text);\n\n            // In case the stylesheet does not exist in the file system, skip it gracefully.\n            if (!this._fileSystem.exists(stylesheetPath)) {\n              return;\n            }\n\n            this.resolvedStylesheets.push(this.resolveExternalStylesheet(stylesheetPath, node));\n          }\n        });\n      }\n\n      if (propertyName === 'templateUrl' && ts.isStringLiteralLike(property.initializer)) {\n        const templatePath = resolve(dirname(sourceFileName), property.initializer.text);\n\n        // In case the template does not exist in the file system, skip this\n        // external template.\n        if (!this._fileSystem.exists(templatePath)) {\n          return;\n        }\n\n        const fileContent = this._fileSystem.read(templatePath);\n        const lineStartsMap = computeLineStartsMap(fileContent);\n\n        this.resolvedTemplates.push({\n          filePath: templatePath,\n          container: node,\n          content: fileContent,\n          inline: false,\n          start: 0,\n          getCharacterAndLineOfPosition: pos => getLineAndCharacterFromPosition(lineStartsMap, pos),\n        });\n      }\n    });\n  }\n\n  /** Resolves an external stylesheet by reading its content and computing line mappings. */\n  resolveExternalStylesheet(filePath: string, container: ts.ClassDeclaration|null):\n      ResolvedResource {\n    const fileContent = this._fileSystem.read(filePath);\n    const lineStartsMap = computeLineStartsMap(fileContent);\n\n    return {\n      filePath: filePath,\n      container: container,\n      content: fileContent,\n      inline: false,\n      start: 0,\n      getCharacterAndLineOfPosition: pos => getLineAndCharacterFromPosition(lineStartsMap, pos),\n    };\n  }\n}\n"]}

package/schematics/update-tool/file-system.d.ts

@@ -0,0 +1,38 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+/// <amd-module name="@angular/cdk/schematics/update-tool/file-system" />
+import { UpdateRecorder } from './update-recorder';
+/**
+ * Abstraction of the file system that migrations can use to record and apply
+ * changes. This is necessary to support virtual file systems as used in the CLI devkit.
+ */
+export interface FileSystem {
+    /**
+     * Resolves an absolute path to a unique path in the file system. For example,
+     * the devkit tree considers the workspace as disk root in paths.
+     */
+    resolve(fsFilePath: string): string;
+    /** Checks whether a given file exists. */
+    exists(fsFilePath: string): boolean;
+    /** Gets the contents of the given file. */
+    read(fsFilePath: string): string | null;
+    /**
+     * Creates an update recorder for the given file. Edits can be recorded and
+     * committed in batches. Changes are not applied automatically because otherwise
+     * migrations would need to re-read files, or account for shifted file contents.
+     */
+    edit(fsFilePath: string): UpdateRecorder;
+    /** Applies all changes which have been recorded in update recorders. */
+    commitEdits(): void;
+    /** Creates a new file with the given content. */
+    create(fsFilePath: string, content: string): any;
+    /** Overwrites an existing file with the given content. */
+    overwrite(fsFilePath: string, content: string): any;
+    /** Deletes the given file. */
+    delete(fsFilePath: string): any;
+}

package/schematics/update-tool/file-system.js

@@ -0,0 +1,20 @@
+/**
+ * @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/update-tool/file-system", ["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/schematics/update-tool/index.d.ts

@@ -6,15 +6,45 @@
  * found in the LICENSE file at https://angular.io/license
  */
 /// <amd-module name="@angular/cdk/schematics/update-tool" />
-import { logging } from '@angular-devkit/core';
-import { Tree } from '@angular-devkit/schematics';
-import { WorkspaceProject } from '@schematics/angular/utility/workspace-models';
-import { MigrationRule } from './migration-rule';
+import * as ts from 'typescript';
+import { FileSystem } from './file-system';
+import { UpdateLogger } from './logger';
+import { MigrationCtor } from './migration';
 import { TargetVersion } from './target-version';
-export declare type Constructor<T> = (new (...args: any[]) => T);
-export declare type MigrationRuleType<T> = Constructor<MigrationRule<T>> & {
-    [m in keyof typeof MigrationRule]: (typeof MigrationRule)[m];
-};
-export declare function runMigrationRules<T>(project: WorkspaceProject, tree: Tree, logger: logging.LoggerApi, tsconfigPath: string, isTestTarget: boolean, targetVersion: TargetVersion, ruleTypes: MigrationRuleType<T>[], upgradeData: T, analyzedFiles: Set<string>): {
-    hasFailures: boolean;
-};
+/**
+ * An update project that can be run against individual migrations. An update project
+ * accepts a TypeScript program and a context that is provided to all migrations. The
+ * context is usually not used by migrations, but in some cases migrations rely on
+ * specifics from the tool that performs the update (e.g. the Angular CLI). In those cases,
+ * the context can provide the necessary specifics to the migrations in a type-safe way.
+ */
+export declare class UpdateProject<Context> {
+    private _context;
+    private _program;
+    private _fileSystem;
+    private _analyzedFiles;
+    private _logger;
+    private readonly _typeChecker;
+    constructor(_context: Context, _program: ts.Program, _fileSystem: FileSystem, _analyzedFiles?: Set<string>, _logger?: UpdateLogger);
+    /**
+     * Migrates the project to the specified target version.
+     * @param migrationTypes Migrations that should be run.
+     * @param target Version the project should be updated to.
+     * @param data Upgrade data that is passed to all migration rules.
+     * @param additionalStylesheetPaths Additional stylesheets that should be migrated, if not
+     *   referenced in an Angular component. This is helpful for global stylesheets in a project.
+     */
+    migrate<Data>(migrationTypes: MigrationCtor<Data, Context>[], target: TargetVersion, data: Data, additionalStylesheetPaths?: string[]): {
+        hasFailures: boolean;
+    };
+    /**
+     * Creates instances of the given migrations with the specified target
+     * version and data.
+     */
+    private _createMigrations;
+    /**
+     * Creates a program form the specified tsconfig and patches the host
+     * to read files through the given file system.
+     */
+    static createProgramFromTsconfig(tsconfigFsPath: string, fs: FileSystem): ts.Program;
+}