jqwidgets-ng 23.0.6 → 23.0.8

package/schematics/cdk2/schematics/update-tool/utils/line-mappings.mjs

@@ -0,0 +1,76 @@
+"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.computeLineStartsMap = exports.getLineAndCharacterFromPosition = void 0;
+/*
+ * Line mapping utilities which can be used to retrieve line and character based
+ * on an absolute character position in a given file. This functionality is similar
+ * to TypeScript's "ts.getLineAndCharacterFromPosition" utility, but we cannot leverage
+ * their logic for line mappings as it's internal and we need to generate line mappings
+ * for non-TypeScript files such as HTML templates or stylesheets.
+ *
+ * Line and character can be retrieved by splitting a given source text based on
+ * line breaks into line start entries. Later when a specific position is requested,
+ * the closest line-start position is determined based on the given position.
+ */
+const LF_CHAR = 10;
+const CR_CHAR = 13;
+const LINE_SEP_CHAR = 8232;
+const PARAGRAPH_CHAR = 8233;
+/** Gets the line and character for the given position from the line starts map. */
+function getLineAndCharacterFromPosition(lineStartsMap, position) {
+    const lineIndex = findClosestLineStartPosition(lineStartsMap, position);
+    return { character: position - lineStartsMap[lineIndex], line: lineIndex };
+}
+exports.getLineAndCharacterFromPosition = getLineAndCharacterFromPosition;
+/**
+ * Computes the line start map of the given text. This can be used in order to
+ * retrieve the line and character of a given text position index.
+ */
+function computeLineStartsMap(text) {
+    const result = [0];
+    let pos = 0;
+    while (pos < text.length) {
+        const char = text.charCodeAt(pos++);
+        // Handles the "CRLF" line break. In that case we peek the character
+        // after the "CR" and check if it is a line feed.
+        if (char === CR_CHAR) {
+            if (text.charCodeAt(pos) === LF_CHAR) {
+                pos++;
+            }
+            result.push(pos);
+        }
+        else if (char === LF_CHAR || char === LINE_SEP_CHAR || char === PARAGRAPH_CHAR) {
+            result.push(pos);
+        }
+    }
+    result.push(pos);
+    return result;
+}
+exports.computeLineStartsMap = computeLineStartsMap;
+/** Finds the closest line start for the given position. */
+function findClosestLineStartPosition(linesMap, position, low = 0, high = linesMap.length - 1) {
+    while (low <= high) {
+        const pivotIndex = Math.floor((low + high) / 2);
+        const pivotEl = linesMap[pivotIndex];
+        if (pivotEl === position) {
+            return pivotIndex;
+        }
+        else if (position > pivotEl) {
+            low = pivotIndex + 1;
+        }
+        else {
+            high = pivotIndex - 1;
+        }
+    }
+    // In case there was no exact match, return the closest "lower" line index. We also
+    // subtract the index by one because want the index of the previous line start.
+    return low - 1;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/schematics/cdk2/schematics/update-tool/utils/parse-tsconfig.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @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';
+/** Class capturing a tsconfig parse error. */
+export declare class TsconfigParseError extends Error {
+}
+/**
+ * Attempts to parse the specified tsconfig file.
+ *
+ * @throws {TsconfigParseError} If the tsconfig could not be read or parsed.
+ */
+export declare function parseTsconfigFile(tsconfigPath: WorkspacePath, fileSystem: FileSystem): ts.ParsedCommandLine;

package/schematics/cdk2/schematics/update-tool/utils/parse-tsconfig.mjs

@@ -0,0 +1,45 @@
+"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.parseTsconfigFile = exports.TsconfigParseError = void 0;
+const ts = require("typescript");
+const virtual_host_1 = require("./virtual-host");
+const path_1 = require("path");
+const diagnostics_1 = require("./diagnostics");
+/** Code of the error raised by TypeScript when a tsconfig doesn't match any files. */
+const NO_INPUTS_ERROR_CODE = 18003;
+/** Class capturing a tsconfig parse error. */
+class TsconfigParseError extends Error {
+}
+exports.TsconfigParseError = TsconfigParseError;
+/**
+ * Attempts to parse the specified tsconfig file.
+ *
+ * @throws {TsconfigParseError} If the tsconfig could not be read or parsed.
+ */
+function parseTsconfigFile(tsconfigPath, fileSystem) {
+    if (!fileSystem.fileExists(tsconfigPath)) {
+        throw new TsconfigParseError(`Tsconfig cannot not be read: ${tsconfigPath}`);
+    }
+    const { config, error } = ts.readConfigFile(tsconfigPath, p => fileSystem.read(fileSystem.resolve(p)));
+    // If there is a config reading error, we never attempt to parse the config.
+    if (error) {
+        throw new TsconfigParseError((0, diagnostics_1.formatDiagnostics)([error], fileSystem));
+    }
+    const parsed = ts.parseJsonConfigFileContent(config, new virtual_host_1.FileSystemHost(fileSystem), (0, path_1.dirname)(tsconfigPath), {});
+    // Skip the "No inputs found..." error since we don't want to interrupt the migration if a
+    // tsconfig doesn't match a file. This will result in an empty `Program` which is still valid.
+    const errors = parsed.errors.filter(diag => diag.code !== NO_INPUTS_ERROR_CODE);
+    if (errors.length) {
+        throw new TsconfigParseError((0, diagnostics_1.formatDiagnostics)(errors, fileSystem));
+    }
+    return parsed;
+}
+exports.parseTsconfigFile = parseTsconfigFile;
+//# sourceMappingURL=data:application/json;base64,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

package/schematics/cdk2/schematics/update-tool/utils/property-name.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @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';
+/** Type that describes a property name with an obtainable text. */
+type PropertyNameWithText = Exclude<ts.PropertyName, ts.ComputedPropertyName>;
+/**
+ * Gets the text of the given property name. Returns null if the property
+ * name couldn't be determined statically.
+ */
+export declare function getPropertyNameText(node: ts.PropertyName): string | null;
+/** Checks whether the given property name has a text. */
+export declare function hasPropertyNameText(node: ts.PropertyName): node is PropertyNameWithText;
+export {};

package/schematics/cdk2/schematics/update-tool/utils/property-name.mjs

@@ -0,0 +1,28 @@
+"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.hasPropertyNameText = exports.getPropertyNameText = void 0;
+const ts = require("typescript");
+/**
+ * Gets the text of the given property name. Returns null if the property
+ * name couldn't be determined statically.
+ */
+function getPropertyNameText(node) {
+    if (ts.isIdentifier(node) || ts.isStringLiteralLike(node)) {
+        return node.text;
+    }
+    return null;
+}
+exports.getPropertyNameText = getPropertyNameText;
+/** Checks whether the given property name has a text. */
+function hasPropertyNameText(node) {
+    return ts.isStringLiteral(node) || ts.isNumericLiteral(node) || ts.isIdentifier(node);
+}
+exports.hasPropertyNameText = hasPropertyNameText;
+//# sourceMappingURL=data:application/json;base64,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

package/schematics/cdk2/schematics/update-tool/utils/virtual-host.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @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 } from '../file-system';
+declare module 'typescript' {
+    interface FileSystemEntries {
+        readonly files: readonly string[];
+        readonly directories: readonly string[];
+    }
+    const matchFiles: undefined | ((path: string, extensions: readonly string[] | undefined, excludes: readonly string[] | undefined, includes: readonly string[] | undefined, useCaseSensitiveFileNames: boolean, currentDirectory: string, depth: number | undefined, getFileSystemEntries: (path: string) => FileSystemEntries, realpath: (path: string) => string, directoryExists: (path: string) => boolean) => string[]);
+}
+/**
+ * Implementation of a TypeScript parse config host that relies fully on
+ * a given virtual file system.
+ */
+export declare class FileSystemHost implements ts.ParseConfigHost {
+    private _fileSystem;
+    useCaseSensitiveFileNames: boolean;
+    constructor(_fileSystem: FileSystem);
+    fileExists(path: string): boolean;
+    readFile(path: string): string | undefined;
+    readDirectory(rootDir: string, extensions: string[], excludes: string[] | undefined, includes: string[], depth?: number): string[];
+    private _getFileSystemEntries;
+}
+/**
+ * Creates a TypeScript compiler host that fully relies fully on the given
+ * virtual file system. i.e. no interactions with the working directory.
+ */
+export declare function createFileSystemCompilerHost(options: ts.CompilerOptions, fileSystem: FileSystem): ts.CompilerHost;
+/** Creates a format diagnostic host that works with the given file system. */
+export declare function createFormatDiagnosticHost(fileSystem: FileSystem): ts.FormatDiagnosticsHost;

package/schematics/cdk2/schematics/update-tool/utils/virtual-host.mjs

@@ -0,0 +1,72 @@
+"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.createFormatDiagnosticHost = exports.createFileSystemCompilerHost = exports.FileSystemHost = void 0;
+const ts = require("typescript");
+/**
+ * Implementation of a TypeScript parse config host that relies fully on
+ * a given virtual file system.
+ */
+class FileSystemHost {
+    _fileSystem;
+    useCaseSensitiveFileNames = ts.sys.useCaseSensitiveFileNames;
+    constructor(_fileSystem) {
+        this._fileSystem = _fileSystem;
+    }
+    fileExists(path) {
+        return this._fileSystem.fileExists(this._fileSystem.resolve(path));
+    }
+    readFile(path) {
+        const content = this._fileSystem.read(this._fileSystem.resolve(path));
+        if (content === null) {
+            return undefined;
+        }
+        // Strip BOM as otherwise TSC methods (e.g. "getWidth") will return an offset which
+        // which breaks the CLI UpdateRecorder. https://github.com/angular/angular/pull/30719
+        return content.replace(/^\uFEFF/, '');
+    }
+    readDirectory(rootDir, extensions, excludes, includes, depth) {
+        if (ts.matchFiles === undefined) {
+            throw Error('Unable to read directory in virtual file system host. This means that ' +
+                'TypeScript changed its file matching internals.\n\nPlease consider downgrading your ' +
+                'TypeScript version, and report an issue in the Angular Components repository.');
+        }
+        return ts.matchFiles(rootDir, extensions, extensions, includes, this.useCaseSensitiveFileNames, '/', depth, p => this._getFileSystemEntries(p), p => this._fileSystem.resolve(p), p => this._fileSystem.directoryExists(this._fileSystem.resolve(p)));
+    }
+    _getFileSystemEntries(path) {
+        return this._fileSystem.readDirectory(this._fileSystem.resolve(path));
+    }
+}
+exports.FileSystemHost = FileSystemHost;
+/**
+ * Creates a TypeScript compiler host that fully relies fully on the given
+ * virtual file system. i.e. no interactions with the working directory.
+ */
+function createFileSystemCompilerHost(options, fileSystem) {
+    const host = ts.createCompilerHost(options, true);
+    const virtualHost = new FileSystemHost(fileSystem);
+    host.readFile = virtualHost.readFile.bind(virtualHost);
+    host.readDirectory = virtualHost.readDirectory.bind(virtualHost);
+    host.fileExists = virtualHost.fileExists.bind(virtualHost);
+    host.directoryExists = dirPath => fileSystem.directoryExists(fileSystem.resolve(dirPath));
+    host.getCurrentDirectory = () => '/';
+    host.getCanonicalFileName = p => fileSystem.resolve(p);
+    return host;
+}
+exports.createFileSystemCompilerHost = createFileSystemCompilerHost;
+/** Creates a format diagnostic host that works with the given file system. */
+function createFormatDiagnosticHost(fileSystem) {
+    return {
+        getCanonicalFileName: p => fileSystem.resolve(p),
+        getCurrentDirectory: () => '/',
+        getNewLine: () => '\n',
+    };
+}
+exports.createFormatDiagnosticHost = createFormatDiagnosticHost;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"virtual-host.js","sourceRoot":"","sources":["../../../../../../../../src/cdk/schematics/update-tool/utils/virtual-host.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG;;;AAEH,iCAAiC;AAgCjC;;;GAGG;AACH,MAAa,cAAc;IAGL;IAFpB,yBAAyB,GAAG,EAAE,CAAC,GAAG,CAAC,yBAAyB,CAAC;IAE7D,YAAoB,WAAuB;QAAvB,gBAAW,GAAX,WAAW,CAAY;IAAG,CAAC;IAE/C,UAAU,CAAC,IAAY;QACrB,OAAO,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;IACrE,CAAC;IAED,QAAQ,CAAC,IAAY;QACnB,MAAM,OAAO,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;QACtE,IAAI,OAAO,KAAK,IAAI,EAAE;YACpB,OAAO,SAAS,CAAC;SAClB;QACD,mFAAmF;QACnF,qFAAqF;QACrF,OAAO,OAAO,CAAC,OAAO,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC;IACxC,CAAC;IAED,aAAa,CACX,OAAe,EACf,UAAoB,EACpB,QAA8B,EAC9B,QAAkB,EAClB,KAAc;QAEd,IAAI,EAAE,CAAC,UAAU,KAAK,SAAS,EAAE;YAC/B,MAAM,KAAK,CACT,wEAAwE;gBACtE,sFAAsF;gBACtF,+EAA+E,CAClF,CAAC;SACH;QACD,OAAO,EAAE,CAAC,UAAU,CAClB,OAAO,EACP,UAAU,EACV,UAAU,EACV,QAAQ,EACR,IAAI,CAAC,yBAAyB,EAC9B,GAAG,EACH,KAAK,EACL,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAC,CAAC,EAClC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC,EAChC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,eAAe,CAAC,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CACnE,CAAC;IACJ,CAAC;IAEO,qBAAqB,CAAC,IAAY;QACxC,OAAO,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;IACxE,CAAC;CACF;AAlDD,wCAkDC;AAED;;;GAGG;AACH,SAAgB,4BAA4B,CAC1C,OAA2B,EAC3B,UAAsB;IAEtB,MAAM,IAAI,GAAG,EAAE,CAAC,kBAAkB,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;IAClD,MAAM,WAAW,GAAG,IAAI,cAAc,CAAC,UAAU,CAAC,CAAC;IAEnD,IAAI,CAAC,QAAQ,GAAG,WAAW,CAAC,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IACvD,IAAI,CAAC,aAAa,GAAG,WAAW,CAAC,aAAa,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IACjE,IAAI,CAAC,UAAU,GAAG,WAAW,CAAC,UAAU,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IAC3D,IAAI,CAAC,eAAe,GAAG,OAAO,CAAC,EAAE,CAAC,UAAU,CAAC,eAAe,CAAC,UAAU,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC;IAC1F,IAAI,CAAC,mBAAmB,GAAG,GAAG,EAAE,CAAC,GAAG,CAAC;IACrC,IAAI,CAAC,oBAAoB,GAAG,CAAC,CAAC,EAAE,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;IAEvD,OAAO,IAAI,CAAC;AACd,CAAC;AAfD,oEAeC;AAED,8EAA8E;AAC9E,SAAgB,0BAA0B,CAAC,UAAsB;IAC/D,OAAO;QACL,oBAAoB,EAAE,CAAC,CAAC,EAAE,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC;QAChD,mBAAmB,EAAE,GAAG,EAAE,CAAC,GAAG;QAC9B,UAAU,EAAE,GAAG,EAAE,CAAC,IAAI;KACvB,CAAC;AACJ,CAAC;AAND,gEAMC","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 * as ts from 'typescript';\nimport {FileSystem} from '../file-system';\n\n// We use TypeScript's native `ts.matchFiles` utility for the virtual file system\n// hosts, as that function implements complex logic for matching files with respect\n// to root directory, extensions, excludes, includes etc. The function is currently\n// internal but we can use it as the API most likely will not change any time soon,\n// nor does it seem like this is being made public any time soon.\n// Related issue for tracking: https://github.com/microsoft/TypeScript/issues/13793.\n// https://github.com/microsoft/TypeScript/blob/b397d1fd4abd0edef85adf0afd91c030bb0b4955/src/compiler/utilities.ts#L6192\ndeclare module 'typescript' {\n  export interface FileSystemEntries {\n    readonly files: readonly string[];\n    readonly directories: readonly string[];\n  }\n\n  export const matchFiles:\n    | undefined\n    | ((\n        path: string,\n        extensions: readonly string[] | undefined,\n        excludes: readonly string[] | undefined,\n        includes: readonly string[] | undefined,\n        useCaseSensitiveFileNames: boolean,\n        currentDirectory: string,\n        depth: number | undefined,\n        getFileSystemEntries: (path: string) => FileSystemEntries,\n        realpath: (path: string) => string,\n        directoryExists: (path: string) => boolean,\n      ) => string[]);\n}\n\n/**\n * Implementation of a TypeScript parse config host that relies fully on\n * a given virtual file system.\n */\nexport class FileSystemHost implements ts.ParseConfigHost {\n  useCaseSensitiveFileNames = ts.sys.useCaseSensitiveFileNames;\n\n  constructor(private _fileSystem: FileSystem) {}\n\n  fileExists(path: string): boolean {\n    return this._fileSystem.fileExists(this._fileSystem.resolve(path));\n  }\n\n  readFile(path: string): string | undefined {\n    const content = this._fileSystem.read(this._fileSystem.resolve(path));\n    if (content === null) {\n      return undefined;\n    }\n    // Strip BOM as otherwise TSC methods (e.g. \"getWidth\") will return an offset which\n    // which breaks the CLI UpdateRecorder. https://github.com/angular/angular/pull/30719\n    return content.replace(/^\\uFEFF/, '');\n  }\n\n  readDirectory(\n    rootDir: string,\n    extensions: string[],\n    excludes: string[] | undefined,\n    includes: string[],\n    depth?: number,\n  ): string[] {\n    if (ts.matchFiles === undefined) {\n      throw Error(\n        'Unable to read directory in virtual file system host. This means that ' +\n          'TypeScript changed its file matching internals.\\n\\nPlease consider downgrading your ' +\n          'TypeScript version, and report an issue in the Angular Components repository.',\n      );\n    }\n    return ts.matchFiles(\n      rootDir,\n      extensions,\n      extensions,\n      includes,\n      this.useCaseSensitiveFileNames,\n      '/',\n      depth,\n      p => this._getFileSystemEntries(p),\n      p => this._fileSystem.resolve(p),\n      p => this._fileSystem.directoryExists(this._fileSystem.resolve(p)),\n    );\n  }\n\n  private _getFileSystemEntries(path: string): ts.FileSystemEntries {\n    return this._fileSystem.readDirectory(this._fileSystem.resolve(path));\n  }\n}\n\n/**\n * Creates a TypeScript compiler host that fully relies fully on the given\n * virtual file system. i.e. no interactions with the working directory.\n */\nexport function createFileSystemCompilerHost(\n  options: ts.CompilerOptions,\n  fileSystem: FileSystem,\n): ts.CompilerHost {\n  const host = ts.createCompilerHost(options, true);\n  const virtualHost = new FileSystemHost(fileSystem);\n\n  host.readFile = virtualHost.readFile.bind(virtualHost);\n  host.readDirectory = virtualHost.readDirectory.bind(virtualHost);\n  host.fileExists = virtualHost.fileExists.bind(virtualHost);\n  host.directoryExists = dirPath => fileSystem.directoryExists(fileSystem.resolve(dirPath));\n  host.getCurrentDirectory = () => '/';\n  host.getCanonicalFileName = p => fileSystem.resolve(p);\n\n  return host;\n}\n\n/** Creates a format diagnostic host that works with the given file system. */\nexport function createFormatDiagnosticHost(fileSystem: FileSystem): ts.FormatDiagnosticsHost {\n  return {\n    getCanonicalFileName: p => fileSystem.resolve(p),\n    getCurrentDirectory: () => '/',\n    getNewLine: () => '\\n',\n  };\n}\n"]}

package/schematics/cdk2/schematics/update-tool/version-changes.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @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 { TargetVersion } from './target-version';
+export type VersionChanges<T> = {
+    [target in TargetVersion]?: ReadableChange<T>[];
+};
+export type ReadableChange<T> = {
+    pr: string;
+    changes: T[];
+};
+/** Conditional type that unwraps the value of a version changes type. */
+export type ValueOfChanges<T> = T extends VersionChanges<infer X> ? X : null;
+/**
+ * Gets the changes for a given target version from the specified version changes object.
+ *
+ * For readability and a good overview of breaking changes, the version change data always
+ * includes the related Pull Request link. Since this data is not needed when performing the
+ * upgrade, this unused data can be removed and the changes data can be flattened into an
+ * easy iterable array.
+ */
+export declare function getChangesForTarget<T>(target: TargetVersion, data: VersionChanges<T>): T[];
+/**
+ * Gets all changes from the specified version changes object. This is helpful in case a migration
+ * rule does not distinguish data based on the target version, but for readability the
+ * upgrade data is separated for each target version.
+ */
+export declare function getAllChanges<T>(data: VersionChanges<T>): T[];

package/schematics/cdk2/schematics/update-tool/version-changes.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.getAllChanges = exports.getChangesForTarget = void 0;
+const target_version_1 = require("./target-version");
+/**
+ * Gets the changes for a given target version from the specified version changes object.
+ *
+ * For readability and a good overview of breaking changes, the version change data always
+ * includes the related Pull Request link. Since this data is not needed when performing the
+ * upgrade, this unused data can be removed and the changes data can be flattened into an
+ * easy iterable array.
+ */
+function getChangesForTarget(target, data) {
+    if (!data) {
+        const version = target_version_1.TargetVersion[target];
+        throw new Error(`No data could be found for target version: ${version}`);
+    }
+    return (data[target] || []).reduce((result, prData) => result.concat(prData.changes), []);
+}
+exports.getChangesForTarget = getChangesForTarget;
+/**
+ * Gets all changes from the specified version changes object. This is helpful in case a migration
+ * rule does not distinguish data based on the target version, but for readability the
+ * upgrade data is separated for each target version.
+ */
+function getAllChanges(data) {
+    return Object.keys(data)
+        .map(targetVersion => getChangesForTarget(targetVersion, data))
+        .reduce((result, versionData) => result.concat(versionData), []);
+}
+exports.getAllChanges = getAllChanges;
+//# sourceMappingURL=data:application/json;base64,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

package/schematics/cdk2/schematics/utils/ast/ng-module-imports.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @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 { Tree } from '@angular-devkit/schematics';
+/**
+ * Whether the Angular module in the given path imports the specified module class name.
+ */
+export declare function hasNgModuleImport(tree: Tree, modulePath: string, className: string): boolean;

package/schematics/cdk2/schematics/utils/ast/ng-module-imports.mjs

@@ -0,0 +1,83 @@
+"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.hasNgModuleImport = void 0;
+const schematics_1 = require("@angular-devkit/schematics");
+const ts = require("typescript");
+/**
+ * Whether the Angular module in the given path imports the specified module class name.
+ */
+function hasNgModuleImport(tree, modulePath, className) {
+    const moduleFileContent = tree.read(modulePath);
+    if (!moduleFileContent) {
+        throw new schematics_1.SchematicsException(`Could not read Angular module file: ${modulePath}`);
+    }
+    const parsedFile = ts.createSourceFile(modulePath, moduleFileContent.toString(), ts.ScriptTarget.Latest, true);
+    const ngModuleMetadata = findNgModuleMetadata(parsedFile);
+    if (!ngModuleMetadata) {
+        throw new schematics_1.SchematicsException(`Could not find NgModule declaration inside: "${modulePath}"`);
+    }
+    for (let property of ngModuleMetadata.properties) {
+        if (!ts.isPropertyAssignment(property) ||
+            property.name.getText() !== 'imports' ||
+            !ts.isArrayLiteralExpression(property.initializer)) {
+            continue;
+        }
+        if (property.initializer.elements.some(element => element.getText() === className)) {
+            return true;
+        }
+    }
+    return false;
+}
+exports.hasNgModuleImport = hasNgModuleImport;
+/**
+ * Resolves the last identifier that is part of the given expression. This helps resolving
+ * identifiers of nested property access expressions (e.g. myNamespace.core.NgModule).
+ */
+function resolveIdentifierOfExpression(expression) {
+    if (ts.isIdentifier(expression)) {
+        return expression;
+    }
+    else if (ts.isPropertyAccessExpression(expression) && ts.isIdentifier(expression.name)) {
+        return expression.name;
+    }
+    return null;
+}
+/**
+ * Finds a NgModule declaration within the specified TypeScript node and returns the
+ * corresponding metadata for it. This function searches breadth first because
+ * NgModule's are usually not nested within other expressions or declarations.
+ */
+function findNgModuleMetadata(rootNode) {
+    // Add immediate child nodes of the root node to the queue.
+    const nodeQueue = [...rootNode.getChildren()];
+    while (nodeQueue.length) {
+        const node = nodeQueue.shift();
+        if (ts.isDecorator(node) &&
+            ts.isCallExpression(node.expression) &&
+            isNgModuleCallExpression(node.expression)) {
+            return node.expression.arguments[0];
+        }
+        else {
+            nodeQueue.push(...node.getChildren());
+        }
+    }
+    return null;
+}
+/** Whether the specified call expression is referring to a NgModule definition. */
+function isNgModuleCallExpression(callExpression) {
+    if (!callExpression.arguments.length ||
+        !ts.isObjectLiteralExpression(callExpression.arguments[0])) {
+        return false;
+    }
+    // The `NgModule` call expression name is never referring to a `PrivateIdentifier`.
+    const decoratorIdentifier = resolveIdentifierOfExpression(callExpression.expression);
+    return decoratorIdentifier ? decoratorIdentifier.text === 'NgModule' : false;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/schematics/cdk2/schematics/utils/ast.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @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 { Tree } from '@angular-devkit/schematics';
+import { Schema as ComponentOptions } from '@schematics/angular/component/schema';
+import { workspaces } from '@angular-devkit/core';
+import * as ts from 'typescript';
+/** Reads file given path and returns TypeScript source file. */
+export declare function parseSourceFile(host: Tree, path: string): ts.SourceFile;
+/** Import and add module to root app module. */
+export declare function addModuleImportToRootModule(host: Tree, moduleName: string, src: string, project: workspaces.ProjectDefinition): void;
+/**
+ * Import and add module to specific module path.
+ * @param host the tree we are updating
+ * @param modulePath src location of the module to import
+ * @param moduleName name of module to import
+ * @param src src location to import
+ */
+export declare function addModuleImportToModule(host: Tree, modulePath: string, moduleName: string, src: string): void;
+/** Wraps the internal find module from options with undefined path handling  */
+export declare function findModuleFromOptions(host: Tree, options: ComponentOptions): Promise<string | undefined>;

package/schematics/cdk2/schematics/utils/ast.mjs

@@ -0,0 +1,69 @@
+"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.findModuleFromOptions = exports.addModuleImportToModule = exports.addModuleImportToRootModule = exports.parseSourceFile = void 0;
+const schematics_1 = require("@angular-devkit/schematics");
+const change_1 = require("@schematics/angular/utility/change");
+const workspace_1 = require("@schematics/angular/utility/workspace");
+const find_module_1 = require("@schematics/angular/utility/find-module");
+const ast_utils_1 = require("@schematics/angular/utility/ast-utils");
+const ng_ast_utils_1 = require("@schematics/angular/utility/ng-ast-utils");
+const ts = require("typescript");
+const project_main_file_1 = require("./project-main-file");
+/** Reads file given path and returns TypeScript source file. */
+function parseSourceFile(host, path) {
+    const buffer = host.read(path);
+    if (!buffer) {
+        throw new schematics_1.SchematicsException(`Could not find file for path: ${path}`);
+    }
+    return ts.createSourceFile(path, buffer.toString(), ts.ScriptTarget.Latest, true);
+}
+exports.parseSourceFile = parseSourceFile;
+/** Import and add module to root app module. */
+function addModuleImportToRootModule(host, moduleName, src, project) {
+    const modulePath = (0, ng_ast_utils_1.getAppModulePath)(host, (0, project_main_file_1.getProjectMainFile)(project));
+    addModuleImportToModule(host, modulePath, moduleName, src);
+}
+exports.addModuleImportToRootModule = addModuleImportToRootModule;
+/**
+ * Import and add module to specific module path.
+ * @param host the tree we are updating
+ * @param modulePath src location of the module to import
+ * @param moduleName name of module to import
+ * @param src src location to import
+ */
+function addModuleImportToModule(host, modulePath, moduleName, src) {
+    const moduleSource = parseSourceFile(host, modulePath);
+    if (!moduleSource) {
+        throw new schematics_1.SchematicsException(`Module not found: ${modulePath}`);
+    }
+    const changes = (0, ast_utils_1.addImportToModule)(moduleSource, modulePath, moduleName, src);
+    const recorder = host.beginUpdate(modulePath);
+    changes.forEach(change => {
+        if (change instanceof change_1.InsertChange) {
+            recorder.insertLeft(change.pos, change.toAdd);
+        }
+    });
+    host.commitUpdate(recorder);
+}
+exports.addModuleImportToModule = addModuleImportToModule;
+/** Wraps the internal find module from options with undefined path handling  */
+async function findModuleFromOptions(host, options) {
+    const workspace = await (0, workspace_1.getWorkspace)(host);
+    if (!options.project) {
+        options.project = Array.from(workspace.projects.keys())[0];
+    }
+    const project = workspace.projects.get(options.project);
+    if (options.path === undefined) {
+        options.path = `/${project.root}/src/app`;
+    }
+    return (0, find_module_1.findModuleFromOptions)(host, options);
+}
+exports.findModuleFromOptions = findModuleFromOptions;
+//# sourceMappingURL=data:application/json;base64,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