jqwidgets-ng 23.0.7 → 23.1.0

package/schematics/cdk2/schematics/ng-update/upgrade-data.mjs

@@ -0,0 +1,39 @@
+"use strict";
+/**
+ * @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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVersionUpgradeData = exports.cdkUpgradeData = void 0;
+const version_changes_1 = require("../update-tool/version-changes");
+const data_1 = require("./data");
+/** Upgrade data for the Angular CDK. */
+exports.cdkUpgradeData = {
+    attributeSelectors: data_1.attributeSelectors,
+    classNames: data_1.classNames,
+    constructorChecks: data_1.constructorChecks,
+    cssSelectors: data_1.cssSelectors,
+    elementSelectors: data_1.elementSelectors,
+    inputNames: data_1.inputNames,
+    methodCallChecks: data_1.methodCallChecks,
+    outputNames: data_1.outputNames,
+    propertyNames: data_1.propertyNames,
+    symbolRemoval: data_1.symbolRemoval,
+};
+/**
+ * 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(migration, dataName) {
+    if (migration.targetVersion === null) {
+        return [];
+    }
+    // Note that below we need to cast to `unknown` first TS doesn't infer the type of T correctly.
+    return (0, version_changes_1.getChangesForTarget)(migration.targetVersion, migration.upgradeData[dataName]);
+}
+exports.getVersionUpgradeData = getVersionUpgradeData;
+//# sourceMappingURL=data:application/json;base64,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

package/schematics/cdk2/schematics/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/schematics/cdk2/schematics/paths.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @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
+ */
+/** Path to the schematic collection for non-migration schematics. */
+export declare const COLLECTION_PATH: string;
+/** Path to the schematic collection that includes the migrations. */
+export declare const MIGRATION_PATH: string;

package/schematics/cdk2/schematics/paths.mjs

@@ -0,0 +1,16 @@
+"use strict";
+/**
+ * @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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MIGRATION_PATH = exports.COLLECTION_PATH = void 0;
+const path_1 = require("path");
+/** Path to the schematic collection for non-migration schematics. */
+exports.COLLECTION_PATH = (0, path_1.join)(__dirname, 'collection.json');
+/** Path to the schematic collection that includes the migrations. */
+exports.MIGRATION_PATH = (0, path_1.join)(__dirname, 'migration.json');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGF0aHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvY2RrL3NjaGVtYXRpY3MvcGF0aHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOzs7Ozs7R0FNRzs7O0FBRUgsK0JBQTBCO0FBRTFCLHFFQUFxRTtBQUN4RCxRQUFBLGVBQWUsR0FBRyxJQUFBLFdBQUksRUFBQyxTQUFTLEVBQUUsaUJBQWlCLENBQUMsQ0FBQztBQUVsRSxxRUFBcUU7QUFDeEQsUUFBQSxjQUFjLEdBQUcsSUFBQSxXQUFJLEVBQUMsU0FBUyxFQUFFLGdCQUFnQixDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuaW1wb3J0IHtqb2lufSBmcm9tICdwYXRoJztcblxuLyoqIFBhdGggdG8gdGhlIHNjaGVtYXRpYyBjb2xsZWN0aW9uIGZvciBub24tbWlncmF0aW9uIHNjaGVtYXRpY3MuICovXG5leHBvcnQgY29uc3QgQ09MTEVDVElPTl9QQVRIID0gam9pbihfX2Rpcm5hbWUsICdjb2xsZWN0aW9uLmpzb24nKTtcblxuLyoqIFBhdGggdG8gdGhlIHNjaGVtYXRpYyBjb2xsZWN0aW9uIHRoYXQgaW5jbHVkZXMgdGhlIG1pZ3JhdGlvbnMuICovXG5leHBvcnQgY29uc3QgTUlHUkFUSU9OX1BBVEggPSBqb2luKF9fZGlybmFtZSwgJ21pZ3JhdGlvbi5qc29uJyk7XG4iXX0=

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

@@ -0,0 +1,44 @@
+/**
+ * @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
+ */
+import * as ts from 'typescript';
+import { FileSystem, WorkspacePath } from './file-system';
+import { LineAndCharacter } from './utils/line-mappings';
+export interface ResolvedResource {
+    /** Class declaration that contains this resource. */
+    container: ts.ClassDeclaration | null;
+    /** File content of the given template. */
+    content: string;
+    /** Start offset of the resource content (e.g. in the inline source file) */
+    start: number;
+    /** Whether the given resource is inline or not. */
+    inline: boolean;
+    /** Path to the file that contains this resource. */
+    filePath: WorkspacePath;
+    /**
+     * Gets the character and line of a given position index in the resource.
+     * If the resource is declared inline within a TypeScript source file, the line and
+     * character are based on the full source file content.
+     */
+    getCharacterAndLineOfPosition: (pos: number) => LineAndCharacter;
+}
+/**
+ * Collector that can be used to find Angular templates and stylesheets referenced within
+ * given TypeScript source files (inline or external referenced files)
+ */
+export declare class ComponentResourceCollector {
+    typeChecker: ts.TypeChecker;
+    private _fileSystem;
+    resolvedTemplates: ResolvedResource[];
+    resolvedStylesheets: ResolvedResource[];
+    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. */
+    resolveExternalStylesheet(filePath: WorkspacePath, container: ts.ClassDeclaration | null): ResolvedResource | null;
+    private _trackExternalStylesheet;
+}

package/schematics/cdk2/schematics/update-tool/component-resource-collector.mjs

@@ -0,0 +1,166 @@
+"use strict";
+/**
+ * @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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComponentResourceCollector = void 0;
+const path_1 = require("path");
+const ts = require("typescript");
+const decorators_1 = require("./utils/decorators");
+const functions_1 = require("./utils/functions");
+const line_mappings_1 = require("./utils/line-mappings");
+const property_name_1 = require("./utils/property-name");
+/**
+ * Collector that can be used to find Angular templates and stylesheets referenced within
+ * given TypeScript source files (inline or external referenced files)
+ */
+class ComponentResourceCollector {
+    typeChecker;
+    _fileSystem;
+    resolvedTemplates = [];
+    resolvedStylesheets = [];
+    constructor(typeChecker, _fileSystem) {
+        this.typeChecker = typeChecker;
+        this._fileSystem = _fileSystem;
+    }
+    visitNode(node) {
+        if (node.kind === ts.SyntaxKind.ClassDeclaration) {
+            this._visitClassDeclaration(node);
+        }
+    }
+    _visitClassDeclaration(node) {
+        const decorators = ts.getDecorators(node);
+        if (!decorators || !decorators.length) {
+            return;
+        }
+        const ngDecorators = (0, decorators_1.getAngularDecorators)(this.typeChecker, decorators);
+        const componentDecorator = ngDecorators.find(dec => dec.name === 'Component');
+        // In case no "@Component" decorator could be found on the current class, skip.
+        if (!componentDecorator) {
+            return;
+        }
+        const decoratorCall = componentDecorator.node.expression;
+        // In case the component decorator call is not valid, skip this class declaration.
+        if (decoratorCall.arguments.length !== 1) {
+            return;
+        }
+        const componentMetadata = (0, functions_1.unwrapExpression)(decoratorCall.arguments[0]);
+        // Ensure that the component metadata is an object literal expression.
+        if (!ts.isObjectLiteralExpression(componentMetadata)) {
+            return;
+        }
+        const sourceFile = node.getSourceFile();
+        const filePath = this._fileSystem.resolve(sourceFile.fileName);
+        const sourceFileDirPath = (0, path_1.dirname)(sourceFile.fileName);
+        // Walk through all component metadata properties and determine the referenced
+        // HTML templates (either external or inline)
+        componentMetadata.properties.forEach(property => {
+            if (!ts.isPropertyAssignment(property)) {
+                return;
+            }
+            const propertyName = (0, property_name_1.getPropertyNameText)(property.name);
+            if (propertyName === 'styles') {
+                const elements = ts.isArrayLiteralExpression(property.initializer)
+                    ? property.initializer.elements
+                    : [property.initializer];
+                elements.forEach(el => {
+                    if (ts.isStringLiteralLike(el)) {
+                        // Need to add an offset of one to the start because the template quotes are
+                        // not part of the template content.
+                        const templateStartIdx = el.getStart() + 1;
+                        const content = stripBom(el.text);
+                        this.resolvedStylesheets.push({
+                            filePath,
+                            container: node,
+                            content,
+                            inline: true,
+                            start: templateStartIdx,
+                            getCharacterAndLineOfPosition: pos => ts.getLineAndCharacterOfPosition(sourceFile, pos + templateStartIdx),
+                        });
+                    }
+                });
+            }
+            // In case there is an inline template specified, ensure that the value is statically
+            // analyzable by checking if the initializer is a string literal-like node.
+            if (propertyName === 'template' && ts.isStringLiteralLike(property.initializer)) {
+                // Need to add an offset of one to the start because the template quotes are
+                // not part of the template content.
+                const templateStartIdx = property.initializer.getStart() + 1;
+                this.resolvedTemplates.push({
+                    filePath,
+                    container: node,
+                    content: property.initializer.text,
+                    inline: true,
+                    start: templateStartIdx,
+                    getCharacterAndLineOfPosition: pos => ts.getLineAndCharacterOfPosition(sourceFile, pos + templateStartIdx),
+                });
+            }
+            if (propertyName === 'styleUrls' && ts.isArrayLiteralExpression(property.initializer)) {
+                property.initializer.elements.forEach(el => {
+                    if (ts.isStringLiteralLike(el)) {
+                        this._trackExternalStylesheet(sourceFileDirPath, el, node);
+                    }
+                });
+            }
+            if (propertyName === 'styleUrl' && ts.isStringLiteralLike(property.initializer)) {
+                this._trackExternalStylesheet(sourceFileDirPath, property.initializer, node);
+            }
+            if (propertyName === 'templateUrl' && ts.isStringLiteralLike(property.initializer)) {
+                const templateUrl = property.initializer.text;
+                const templatePath = this._fileSystem.resolve(sourceFileDirPath, templateUrl);
+                // In case the template does not exist in the file system, skip this
+                // external template.
+                if (!this._fileSystem.fileExists(templatePath)) {
+                    return;
+                }
+                const fileContent = stripBom(this._fileSystem.read(templatePath) || '');
+                if (fileContent) {
+                    const lineStartsMap = (0, line_mappings_1.computeLineStartsMap)(fileContent);
+                    this.resolvedTemplates.push({
+                        filePath: templatePath,
+                        container: node,
+                        content: fileContent,
+                        inline: false,
+                        start: 0,
+                        getCharacterAndLineOfPosition: p => (0, line_mappings_1.getLineAndCharacterFromPosition)(lineStartsMap, p),
+                    });
+                }
+            }
+        });
+    }
+    /** Resolves an external stylesheet by reading its content and computing line mappings. */
+    resolveExternalStylesheet(filePath, container) {
+        // Strip the BOM to avoid issues with the Sass compiler. See:
+        // https://github.com/angular/components/issues/24227#issuecomment-1200934258
+        const fileContent = stripBom(this._fileSystem.read(filePath) || '');
+        if (!fileContent) {
+            return null;
+        }
+        const lineStartsMap = (0, line_mappings_1.computeLineStartsMap)(fileContent);
+        return {
+            filePath: filePath,
+            container: container,
+            content: fileContent,
+            inline: false,
+            start: 0,
+            getCharacterAndLineOfPosition: pos => (0, line_mappings_1.getLineAndCharacterFromPosition)(lineStartsMap, pos),
+        };
+    }
+    _trackExternalStylesheet(sourceFileDirPath, node, container) {
+        const stylesheetPath = this._fileSystem.resolve(sourceFileDirPath, node.text);
+        const stylesheet = this.resolveExternalStylesheet(stylesheetPath, container);
+        if (stylesheet) {
+            this.resolvedStylesheets.push(stylesheet);
+        }
+    }
+}
+exports.ComponentResourceCollector = ComponentResourceCollector;
+/** Strips the BOM from a string. */
+function stripBom(content) {
+    return content.replace(/\uFEFF/g, '');
+}
+//# 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} from 'path';\nimport * as ts from 'typescript';\nimport {FileSystem, WorkspacePath} 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: WorkspacePath;\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(\n    public typeChecker: ts.TypeChecker,\n    private _fileSystem: FileSystem,\n  ) {}\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    const decorators = ts.getDecorators(node);\n\n    if (!decorators || !decorators.length) {\n      return;\n    }\n\n    const ngDecorators = getAngularDecorators(this.typeChecker, 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 filePath = this._fileSystem.resolve(sourceFile.fileName);\n    const sourceFileDirPath = dirname(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\n      if (propertyName === 'styles') {\n        const elements = ts.isArrayLiteralExpression(property.initializer)\n          ? property.initializer.elements\n          : [property.initializer];\n\n        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            const content = stripBom(el.text);\n            this.resolvedStylesheets.push({\n              filePath,\n              container: node,\n              content,\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,\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            this._trackExternalStylesheet(sourceFileDirPath, el, node);\n          }\n        });\n      }\n\n      if (propertyName === 'styleUrl' && ts.isStringLiteralLike(property.initializer)) {\n        this._trackExternalStylesheet(sourceFileDirPath, property.initializer, node);\n      }\n\n      if (propertyName === 'templateUrl' && ts.isStringLiteralLike(property.initializer)) {\n        const templateUrl = property.initializer.text;\n        const templatePath = this._fileSystem.resolve(sourceFileDirPath, templateUrl);\n\n        // In case the template does not exist in the file system, skip this\n        // external template.\n        if (!this._fileSystem.fileExists(templatePath)) {\n          return;\n        }\n\n        const fileContent = stripBom(this._fileSystem.read(templatePath) || '');\n\n        if (fileContent) {\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: p => getLineAndCharacterFromPosition(lineStartsMap, p),\n          });\n        }\n      }\n    });\n  }\n\n  /** Resolves an external stylesheet by reading its content and computing line mappings. */\n  resolveExternalStylesheet(\n    filePath: WorkspacePath,\n    container: ts.ClassDeclaration | null,\n  ): ResolvedResource | null {\n    // Strip the BOM to avoid issues with the Sass compiler. See:\n    // https://github.com/angular/components/issues/24227#issuecomment-1200934258\n    const fileContent = stripBom(this._fileSystem.read(filePath) || '');\n\n    if (!fileContent) {\n      return null;\n    }\n\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  private _trackExternalStylesheet(\n    sourceFileDirPath: string,\n    node: ts.StringLiteralLike,\n    container: ts.ClassDeclaration,\n  ) {\n    const stylesheetPath = this._fileSystem.resolve(sourceFileDirPath, node.text);\n    const stylesheet = this.resolveExternalStylesheet(stylesheetPath, container);\n\n    if (stylesheet) {\n      this.resolvedStylesheets.push(stylesheet);\n    }\n  }\n}\n\n/** Strips the BOM from a string. */\nfunction stripBom(content: string): string {\n  return content.replace(/\\uFEFF/g, '');\n}\n"]}

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

@@ -0,0 +1,72 @@
+/**
+ * @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
+ */
+import { UpdateRecorder } from './update-recorder';
+/**
+ * A workspace path semantically is equivalent to the `Path` type provided by the
+ * Angular devkit. Paths denoted with such a type are guaranteed to be representing
+ * paths of a given virtual file system. This means that the root of a path can be
+ * different, and does not necessarily need to match the root in the real file system.
+ *
+ * For example: Consider we have a project in `/home/<..>/my-project`. Then a path
+ * like `/package.json` could actually refer to the `package.json` file in `my-project`.
+ * Note that in the real file system this would not match though.
+ *
+ * One might wonder why another type has been declared for such paths, when there
+ * already is the `Path` type provided by the devkit. We do this for a couple of reasons:
+ *
+ *   1. The update-tool cannot have a dependency on the Angular devkit as that one
+ *      is not synced into g3. We want to be able to run migrations in g3 if needed.
+ */
+export type WorkspacePath = string & {
+    __PRIVATE_DEVKIT_PATH: void;
+};
+/** Interface that describes a directory. */
+export interface DirectoryEntry {
+    /** List of directories inside the directory. */
+    directories: string[];
+    /** List of files inside the directory. */
+    files: string[];
+}
+/**
+ * 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 declare abstract class FileSystem {
+    /** Checks whether the given file exists. */
+    abstract fileExists(path: WorkspacePath): boolean;
+    /** Checks whether the given directory exists. */
+    abstract directoryExists(path: WorkspacePath): boolean;
+    /** Gets the contents of the given file. */
+    abstract read(filePath: WorkspacePath): string | null;
+    /** Reads the given directory to retrieve children. */
+    abstract readDirectory(dirPath: WorkspacePath): DirectoryEntry;
+    /**
+     * 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.
+     */
+    abstract edit(filePath: WorkspacePath): UpdateRecorder;
+    /** Applies all changes which have been recorded in update recorders. */
+    abstract commitEdits(): void;
+    /** Creates a new file with the given content. */
+    abstract create(filePath: WorkspacePath, content: string): void;
+    /** Overwrites an existing file with the given content. */
+    abstract overwrite(filePath: WorkspacePath, content: string): void;
+    /** Deletes the given file. */
+    abstract delete(filePath: WorkspacePath): void;
+    /**
+     * Resolves given paths to a resolved path in the file system. For example, the devkit
+     * tree considers the actual workspace directory as file system root.
+     *
+     * Follows the same semantics as the native path `resolve` method. i.e. segments
+     * are processed in reverse. The last segment is considered the target and the
+     * function will iterate from the target through other segments until it finds an
+     * absolute path segment.
+     */
+    abstract resolve(...segments: string[]): WorkspacePath;
+}

package/schematics/cdk2/schematics/update-tool/file-system.mjs

@@ -0,0 +1,18 @@
+"use strict";
+/**
+ * @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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileSystem = void 0;
+/**
+ * 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.
+ */
+class FileSystem {
+}
+exports.FileSystem = FileSystem;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -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
+ */
+import * as ts from 'typescript';
+import { FileSystem, WorkspacePath } from './file-system';
+import { UpdateLogger } from './logger';
+import { MigrationCtor } from './migration';
+import { TargetVersion } from './target-version';
+/**
+ * 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> {
+    /** Context provided to all migrations. */
+    private _context;
+    /** TypeScript program using workspace paths. */
+    private _program;
+    /** File system used for reading, writing and editing files. */
+    private _fileSystem;
+    /**
+     * Set of analyzed files. Used for avoiding multiple migration runs if
+     * files overlap between targets.
+     */
+    private _analyzedFiles;
+    /** Logger used for printing messages. */
+    private _logger;
+    private readonly _typeChecker;
+    constructor(
+    /** Context provided to all migrations. */
+    _context: Context, 
+    /** TypeScript program using workspace paths. */
+    _program: ts.Program, 
+    /** File system used for reading, writing and editing files. */
+    _fileSystem: FileSystem, 
+    /**
+     * Set of analyzed files. Used for avoiding multiple migration runs if
+     * files overlap between targets.
+     */
+    _analyzedFiles?: Set<WorkspacePath>, 
+    /** Logger used for printing messages. */
+    _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. Can be `null` if the set of
+     *   specified migrations runs regardless of a target version.
+     * @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.
+     * @param limitToDirectory If specified, changes will be limited to the given directory.
+     */
+    migrate<Data>(migrationTypes: MigrationCtor<Data, Context>[], target: TargetVersion | null, data: Data, additionalStylesheetPaths?: string[], limitToDirectory?: 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 and directories through the given file system.
+     *
+     * @throws {TsconfigParseError} If the tsconfig could not be parsed.
+     */
+    static createProgramFromTsconfig(tsconfigPath: WorkspacePath, fs: FileSystem): ts.Program;
+}