jqwidgets-ng 23.0.7 → 23.0.8

package/schematics/cdk2/schematics/ng-update/index.mjs

@@ -0,0 +1,30 @@
+"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.updateToV17 = void 0;
+const target_version_1 = require("../update-tool/target-version");
+const upgrade_data_1 = require("./upgrade-data");
+const devkit_migration_rule_1 = require("./devkit-migration-rule");
+const cdkMigrations = [];
+/** Entry point for the migration schematics with target of Angular CDK 17.0.0 */
+function updateToV17() {
+    return (0, devkit_migration_rule_1.createMigrationSchematicRule)(target_version_1.TargetVersion.V17, cdkMigrations, upgrade_data_1.cdkUpgradeData, onMigrationComplete);
+}
+exports.updateToV17 = updateToV17;
+/** Function that will be called when the migration completed. */
+function onMigrationComplete(context, targetVersion, hasFailures) {
+    context.logger.info('');
+    context.logger.info(`  ✓  Updated Angular CDK to ${targetVersion}`);
+    context.logger.info('');
+    if (hasFailures) {
+        context.logger.warn('  ⚠  Some issues were detected but could not be fixed automatically. Please check the ' +
+            'output above and fix these issues manually.');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/schematics/cdk2/schematics/ng-update/migrations/attribute-selectors.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @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 { ResolvedResource } from '../../update-tool/component-resource-collector';
+import { Migration } from '../../update-tool/migration';
+import { AttributeSelectorUpgradeData } from '../data/attribute-selectors';
+import { UpgradeData } from '../upgrade-data';
+/**
+ * Migration that walks through every string literal, template and stylesheet
+ * in order to switch deprecated attribute selectors to the updated selector.
+ */
+export declare class AttributeSelectorsMigration extends Migration<UpgradeData> {
+    /** Required upgrade changes for specified target version. */
+    data: AttributeSelectorUpgradeData[];
+    enabled: boolean;
+    visitNode(node: ts.Node): void;
+    visitTemplate(template: ResolvedResource): void;
+    visitStylesheet(stylesheet: ResolvedResource): void;
+    private _visitStringLiteralLike;
+    private _replaceSelector;
+}

package/schematics/cdk2/schematics/ng-update/migrations/attribute-selectors.mjs

@@ -0,0 +1,68 @@
+"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.AttributeSelectorsMigration = void 0;
+const ts = require("typescript");
+const migration_1 = require("../../update-tool/migration");
+const literal_1 = require("../typescript/literal");
+const upgrade_data_1 = require("../upgrade-data");
+/**
+ * Migration that walks through every string literal, template and stylesheet
+ * in order to switch deprecated attribute selectors to the updated selector.
+ */
+class AttributeSelectorsMigration extends migration_1.Migration {
+    /** Required upgrade changes for specified target version. */
+    data = (0, upgrade_data_1.getVersionUpgradeData)(this, 'attributeSelectors');
+    // Only enable the migration rule if there is upgrade data.
+    enabled = this.data.length !== 0;
+    visitNode(node) {
+        if (ts.isStringLiteralLike(node)) {
+            this._visitStringLiteralLike(node);
+        }
+    }
+    visitTemplate(template) {
+        this.data.forEach(selector => {
+            (0, literal_1.findAllSubstringIndices)(template.content, selector.replace)
+                .map(offset => template.start + offset)
+                .forEach(start => this._replaceSelector(template.filePath, start, selector));
+        });
+    }
+    visitStylesheet(stylesheet) {
+        this.data.forEach(selector => {
+            const currentSelector = `[${selector.replace}]`;
+            const updatedSelector = `[${selector.replaceWith}]`;
+            (0, literal_1.findAllSubstringIndices)(stylesheet.content, currentSelector)
+                .map(offset => stylesheet.start + offset)
+                .forEach(start => this._replaceSelector(stylesheet.filePath, start, {
+                replace: currentSelector,
+                replaceWith: updatedSelector,
+            }));
+        });
+    }
+    _visitStringLiteralLike(literal) {
+        if (literal.parent && literal.parent.kind !== ts.SyntaxKind.CallExpression) {
+            return;
+        }
+        const literalText = literal.getText();
+        const filePath = this.fileSystem.resolve(literal.getSourceFile().fileName);
+        this.data.forEach(selector => {
+            (0, literal_1.findAllSubstringIndices)(literalText, selector.replace)
+                .map(offset => literal.getStart() + offset)
+                .forEach(start => this._replaceSelector(filePath, start, selector));
+        });
+    }
+    _replaceSelector(filePath, start, data) {
+        this.fileSystem
+            .edit(filePath)
+            .remove(start, data.replace.length)
+            .insertRight(start, data.replaceWith);
+    }
+}
+exports.AttributeSelectorsMigration = AttributeSelectorsMigration;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,26 @@
+/**
+ * @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 { Migration } from '../../update-tool/migration';
+import { PropertyNameUpgradeData } from '../data/property-names';
+import { UpgradeData } from '../upgrade-data';
+/**
+ * Migration that identifies class declarations that extend CDK or Material classes
+ * which had a public property change.
+ */
+export declare class ClassInheritanceMigration extends Migration<UpgradeData> {
+    /**
+     * Map of classes that have been updated. Each class name maps to the according property
+     * change data.
+     */
+    propertyNames: Map<string, PropertyNameUpgradeData>;
+    enabled: boolean;
+    init(): void;
+    visitNode(node: ts.Node): void;
+    private _visitClassDeclaration;
+}

package/schematics/cdk2/schematics/ng-update/migrations/class-inheritance.mjs

@@ -0,0 +1,55 @@
+"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.ClassInheritanceMigration = void 0;
+const ts = require("typescript");
+const migration_1 = require("../../update-tool/migration");
+const base_types_1 = require("../typescript/base-types");
+const upgrade_data_1 = require("../upgrade-data");
+/**
+ * Migration that identifies class declarations that extend CDK or Material classes
+ * which had a public property change.
+ */
+class ClassInheritanceMigration extends migration_1.Migration {
+    /**
+     * Map of classes that have been updated. Each class name maps to the according property
+     * change data.
+     */
+    propertyNames = new Map();
+    // Only enable the migration rule if there is upgrade data.
+    enabled = this.propertyNames.size !== 0;
+    init() {
+        (0, upgrade_data_1.getVersionUpgradeData)(this, 'propertyNames')
+            .filter(data => data.limitedTo && data.limitedTo.classes)
+            .forEach(data => data.limitedTo.classes.forEach(name => this.propertyNames.set(name, data)));
+    }
+    visitNode(node) {
+        if (ts.isClassDeclaration(node)) {
+            this._visitClassDeclaration(node);
+        }
+    }
+    _visitClassDeclaration(node) {
+        const baseTypes = (0, base_types_1.determineBaseTypes)(node);
+        const className = node.name ? node.name.text : '{unknown-name}';
+        if (!baseTypes) {
+            return;
+        }
+        baseTypes.forEach(typeName => {
+            const data = this.propertyNames.get(typeName);
+            if (data) {
+                this.createFailureAtNode(node, `Found class "${className}" which extends class ` +
+                    `"${typeName}". Please note that the base class property ` +
+                    `"${data.replace}" has changed to "${data.replaceWith}". ` +
+                    `You may need to update your class as well.`);
+            }
+        });
+    }
+}
+exports.ClassInheritanceMigration = ClassInheritanceMigration;
+//# sourceMappingURL=data:application/json;base64,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

package/schematics/cdk2/schematics/ng-update/migrations/class-names.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 * as ts from 'typescript';
+import { Migration } from '../../update-tool/migration';
+import { ClassNameUpgradeData } from '../data';
+import { UpgradeData } from '../upgrade-data';
+/**
+ * Migration that walks through every identifier that is part of Angular Material or thr CDK
+ * and replaces the outdated name with the new one if specified in the upgrade data.
+ */
+export declare class ClassNamesMigration extends Migration<UpgradeData> {
+    /** Change data that upgrades to the specified target version. */
+    data: ClassNameUpgradeData[];
+    /**
+     * List of identifier names that have been imported from `@angular/material` or `@angular/cdk`
+     * in the current source file and therefore can be considered trusted.
+     */
+    trustedIdentifiers: Set<string>;
+    /** List of namespaces that have been imported from `@angular/material` or `@angular/cdk`. */
+    trustedNamespaces: Set<string>;
+    enabled: boolean;
+    visitNode(node: ts.Node): void;
+    /** Method that is called for every identifier inside of the specified project. */
+    private _visitIdentifier;
+    /** Creates a failure and replacement for the specified identifier. */
+    private _createFailureWithReplacement;
+}

package/schematics/cdk2/schematics/ng-update/migrations/class-names.mjs

@@ -0,0 +1,88 @@
+"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.ClassNamesMigration = void 0;
+const ts = require("typescript");
+const migration_1 = require("../../update-tool/migration");
+const imports_1 = require("../typescript/imports");
+const module_specifiers_1 = require("../typescript/module-specifiers");
+const upgrade_data_1 = require("../upgrade-data");
+/**
+ * Migration that walks through every identifier that is part of Angular Material or thr CDK
+ * and replaces the outdated name with the new one if specified in the upgrade data.
+ */
+// TODO: rework this rule to identify symbols using the import identifier resolver. This
+// makes it more robust, less AST convoluted and is more TypeScript AST idiomatic. COMP-300.
+class ClassNamesMigration extends migration_1.Migration {
+    /** Change data that upgrades to the specified target version. */
+    data = (0, upgrade_data_1.getVersionUpgradeData)(this, 'classNames');
+    /**
+     * List of identifier names that have been imported from `@angular/material` or `@angular/cdk`
+     * in the current source file and therefore can be considered trusted.
+     */
+    trustedIdentifiers = new Set();
+    /** List of namespaces that have been imported from `@angular/material` or `@angular/cdk`. */
+    trustedNamespaces = new Set();
+    // Only enable the migration rule if there is upgrade data.
+    enabled = this.data.length !== 0;
+    visitNode(node) {
+        if (ts.isIdentifier(node)) {
+            this._visitIdentifier(node);
+        }
+    }
+    /** Method that is called for every identifier inside of the specified project. */
+    _visitIdentifier(identifier) {
+        // For identifiers that aren't listed in the className data, the whole check can be
+        // skipped safely.
+        if (!this.data.some(data => data.replace === identifier.text)) {
+            return;
+        }
+        // For namespace imports that are referring to Angular Material or the CDK, we store the
+        // namespace name in order to be able to safely find identifiers that don't belong to the
+        // developer's application.
+        if ((0, imports_1.isNamespaceImportNode)(identifier) && (0, module_specifiers_1.isMaterialImportDeclaration)(identifier)) {
+            this.trustedNamespaces.add(identifier.text);
+            return this._createFailureWithReplacement(identifier);
+        }
+        // For export declarations that are referring to Angular Material or the CDK, the identifier
+        // can be immediately updated to the new name.
+        if ((0, imports_1.isExportSpecifierNode)(identifier) && (0, module_specifiers_1.isMaterialExportDeclaration)(identifier)) {
+            return this._createFailureWithReplacement(identifier);
+        }
+        // For import declarations that are referring to Angular Material or the CDK, the name of
+        // the import identifiers. This allows us to identify identifiers that belong to Material and
+        // the CDK, and we won't accidentally touch a developer's identifier.
+        if ((0, imports_1.isImportSpecifierNode)(identifier) && (0, module_specifiers_1.isMaterialImportDeclaration)(identifier)) {
+            this.trustedIdentifiers.add(identifier.text);
+            return this._createFailureWithReplacement(identifier);
+        }
+        // In case the identifier is part of a property access expression, we need to verify that the
+        // property access originates from a namespace that has been imported from Material or the CDK.
+        if (ts.isPropertyAccessExpression(identifier.parent)) {
+            const expression = identifier.parent.expression;
+            if (ts.isIdentifier(expression) && this.trustedNamespaces.has(expression.text)) {
+                return this._createFailureWithReplacement(identifier);
+            }
+        }
+        else if (this.trustedIdentifiers.has(identifier.text)) {
+            return this._createFailureWithReplacement(identifier);
+        }
+    }
+    /** Creates a failure and replacement for the specified identifier. */
+    _createFailureWithReplacement(identifier) {
+        const classData = this.data.find(data => data.replace === identifier.text);
+        const filePath = this.fileSystem.resolve(identifier.getSourceFile().fileName);
+        this.fileSystem
+            .edit(filePath)
+            .remove(identifier.getStart(), identifier.getWidth())
+            .insertRight(identifier.getStart(), classData.replaceWith);
+    }
+}
+exports.ClassNamesMigration = ClassNamesMigration;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"class-names.js","sourceRoot":"","sources":["../../../../../../../../src/cdk/schematics/ng-update/migrations/class-names.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 * as ts from 'typescript';\nimport {Migration} from '../../update-tool/migration';\n\nimport {ClassNameUpgradeData} from '../data';\nimport {\n  isExportSpecifierNode,\n  isImportSpecifierNode,\n  isNamespaceImportNode,\n} from '../typescript/imports';\nimport {\n  isMaterialExportDeclaration,\n  isMaterialImportDeclaration,\n} from '../typescript/module-specifiers';\nimport {getVersionUpgradeData, UpgradeData} from '../upgrade-data';\n\n/**\n * Migration that walks through every identifier that is part of Angular Material or thr CDK\n * and replaces the outdated name with the new one if specified in the upgrade data.\n */\n// TODO: rework this rule to identify symbols using the import identifier resolver. This\n// makes it more robust, less AST convoluted and is more TypeScript AST idiomatic. COMP-300.\nexport class ClassNamesMigration extends Migration<UpgradeData> {\n  /** Change data that upgrades to the specified target version. */\n  data: ClassNameUpgradeData[] = getVersionUpgradeData(this, 'classNames');\n\n  /**\n   * List of identifier names that have been imported from `@angular/material` or `@angular/cdk`\n   * in the current source file and therefore can be considered trusted.\n   */\n  trustedIdentifiers: Set<string> = new Set();\n\n  /** List of namespaces that have been imported from `@angular/material` or `@angular/cdk`. */\n  trustedNamespaces: Set<string> = new Set();\n\n  // Only enable the migration rule if there is upgrade data.\n  enabled = this.data.length !== 0;\n\n  override visitNode(node: ts.Node): void {\n    if (ts.isIdentifier(node)) {\n      this._visitIdentifier(node);\n    }\n  }\n\n  /** Method that is called for every identifier inside of the specified project. */\n  private _visitIdentifier(identifier: ts.Identifier) {\n    // For identifiers that aren't listed in the className data, the whole check can be\n    // skipped safely.\n    if (!this.data.some(data => data.replace === identifier.text)) {\n      return;\n    }\n\n    // For namespace imports that are referring to Angular Material or the CDK, we store the\n    // namespace name in order to be able to safely find identifiers that don't belong to the\n    // developer's application.\n    if (isNamespaceImportNode(identifier) && isMaterialImportDeclaration(identifier)) {\n      this.trustedNamespaces.add(identifier.text);\n\n      return this._createFailureWithReplacement(identifier);\n    }\n\n    // For export declarations that are referring to Angular Material or the CDK, the identifier\n    // can be immediately updated to the new name.\n    if (isExportSpecifierNode(identifier) && isMaterialExportDeclaration(identifier)) {\n      return this._createFailureWithReplacement(identifier);\n    }\n\n    // For import declarations that are referring to Angular Material or the CDK, the name of\n    // the import identifiers. This allows us to identify identifiers that belong to Material and\n    // the CDK, and we won't accidentally touch a developer's identifier.\n    if (isImportSpecifierNode(identifier) && isMaterialImportDeclaration(identifier)) {\n      this.trustedIdentifiers.add(identifier.text);\n\n      return this._createFailureWithReplacement(identifier);\n    }\n\n    // In case the identifier is part of a property access expression, we need to verify that the\n    // property access originates from a namespace that has been imported from Material or the CDK.\n    if (ts.isPropertyAccessExpression(identifier.parent)) {\n      const expression = identifier.parent.expression;\n\n      if (ts.isIdentifier(expression) && this.trustedNamespaces.has(expression.text)) {\n        return this._createFailureWithReplacement(identifier);\n      }\n    } else if (this.trustedIdentifiers.has(identifier.text)) {\n      return this._createFailureWithReplacement(identifier);\n    }\n  }\n\n  /** Creates a failure and replacement for the specified identifier. */\n  private _createFailureWithReplacement(identifier: ts.Identifier) {\n    const classData = this.data.find(data => data.replace === identifier.text)!;\n    const filePath = this.fileSystem.resolve(identifier.getSourceFile().fileName);\n\n    this.fileSystem\n      .edit(filePath)\n      .remove(identifier.getStart(), identifier.getWidth())\n      .insertRight(identifier.getStart(), classData.replaceWith);\n  }\n}\n"]}

package/schematics/cdk2/schematics/ng-update/migrations/constructor-signature.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @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 { Migration } from '../../update-tool/migration';
+import { UpgradeData } from '../upgrade-data';
+/**
+ * Migration that visits every TypeScript new expression or super call and checks if
+ * the parameter type signature is invalid and needs to be updated manually.
+ */
+export declare class ConstructorSignatureMigration extends Migration<UpgradeData> {
+    data: string[];
+    enabled: boolean;
+    visitNode(node: ts.Node): void;
+    /**
+     * Method that will be called for each source file of the upgrade project. In order to
+     * properly determine invalid constructor signatures, we take advantage of the pre-emit
+     * diagnostics from TypeScript.
+     *
+     * By using the diagnostics, the migration can handle type assignability. Not using
+     * diagnostics would mean that we need to use simple type equality checking which is
+     * too strict. See related issue: https://github.com/Microsoft/TypeScript/issues/9879
+     */
+    private _visitSourceFile;
+}

package/schematics/cdk2/schematics/ng-update/migrations/constructor-signature.mjs

@@ -0,0 +1,136 @@
+"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.ConstructorSignatureMigration = void 0;
+const ts = require("typescript");
+const migration_1 = require("../../update-tool/migration");
+const version_changes_1 = require("../../update-tool/version-changes");
+/**
+ * List of diagnostic codes that refer to pre-emit diagnostics which indicate invalid
+ * new expression or super call signatures. See the list of diagnostics here:
+ *
+ * https://github.com/Microsoft/TypeScript/blob/master/src/compiler/diagnosticMessages.json
+ */
+const signatureErrorDiagnostics = [
+    // Type not assignable error diagnostic.
+    2345,
+    // Constructor argument length invalid diagnostics
+    2554, 2555, 2556, 2557,
+];
+/**
+ * Migration that visits every TypeScript new expression or super call and checks if
+ * the parameter type signature is invalid and needs to be updated manually.
+ */
+class ConstructorSignatureMigration extends migration_1.Migration {
+    // Note that the data for this rule is not distinguished based on the target version because
+    // we don't keep track of the new signature and don't want to update incrementally.
+    // See: https://github.com/angular/components/pull/12970#issuecomment-418337566
+    data = (0, version_changes_1.getAllChanges)(this.upgradeData.constructorChecks);
+    // Only enable the migration rule if there is upgrade data.
+    enabled = this.data.length !== 0;
+    visitNode(node) {
+        if (ts.isSourceFile(node)) {
+            this._visitSourceFile(node);
+        }
+    }
+    /**
+     * Method that will be called for each source file of the upgrade project. In order to
+     * properly determine invalid constructor signatures, we take advantage of the pre-emit
+     * diagnostics from TypeScript.
+     *
+     * By using the diagnostics, the migration can handle type assignability. Not using
+     * diagnostics would mean that we need to use simple type equality checking which is
+     * too strict. See related issue: https://github.com/Microsoft/TypeScript/issues/9879
+     */
+    _visitSourceFile(sourceFile) {
+        // List of classes of which the constructor signature has changed.
+        const diagnostics = ts
+            .getPreEmitDiagnostics(this.program, sourceFile)
+            .filter(diagnostic => signatureErrorDiagnostics.includes(diagnostic.code))
+            .filter(diagnostic => diagnostic.start !== undefined);
+        for (const diagnostic of diagnostics) {
+            const node = findConstructorNode(diagnostic, sourceFile);
+            if (!node) {
+                continue;
+            }
+            const classType = this.typeChecker.getTypeAtLocation(node.expression);
+            const className = classType.symbol && classType.symbol.name;
+            const isNewExpression = ts.isNewExpression(node);
+            // Determine the class names of the actual construct signatures because we cannot assume that
+            // the diagnostic refers to a constructor of the actual expression. In case the constructor
+            // is inherited, we need to detect that the owner-class of the constructor is added to the
+            // constructor checks upgrade data. e.g. `class CustomCalendar extends MatCalendar {}`.
+            const signatureClassNames = classType
+                .getConstructSignatures()
+                .map(signature => getClassDeclarationOfSignature(signature))
+                .map(declaration => (declaration && declaration.name ? declaration.name.text : null))
+                .filter(Boolean);
+            // Besides checking the signature class names, we need to check the actual class name because
+            // there can be classes without an explicit constructor.
+            if (!this.data.includes(className) &&
+                !signatureClassNames.some(name => this.data.includes(name))) {
+                continue;
+            }
+            const classSignatures = classType
+                .getConstructSignatures()
+                .map(signature => getParameterTypesFromSignature(signature, this.typeChecker));
+            const expressionName = isNewExpression ? `new ${className}` : 'super';
+            const signatures = classSignatures
+                .map(signature => signature.map(t => (t === null ? 'any' : this.typeChecker.typeToString(t))))
+                .map(signature => `${expressionName}(${signature.join(', ')})`)
+                .join(' or ');
+            this.createFailureAtNode(node, `Found "${className}" constructed with ` +
+                `an invalid signature. Please manually update the ${expressionName} expression to ` +
+                `match the new signature${classSignatures.length > 1 ? 's' : ''}: ${signatures}`);
+        }
+    }
+}
+exports.ConstructorSignatureMigration = ConstructorSignatureMigration;
+/** Resolves the type for each parameter in the specified signature. */
+function getParameterTypesFromSignature(signature, typeChecker) {
+    return signature
+        .getParameters()
+        .map(param => param.declarations ? typeChecker.getTypeAtLocation(param.declarations[0]) : null);
+}
+/**
+ * Walks through each node of a source file in order to find a new-expression node or super-call
+ * expression node that is captured by the specified diagnostic.
+ */
+function findConstructorNode(diagnostic, sourceFile) {
+    let resolvedNode = null;
+    const _visitNode = (node) => {
+        // Check whether the current node contains the diagnostic. If the node contains the diagnostic,
+        // walk deeper in order to find all constructor expression nodes.
+        if (node.getStart() <= diagnostic.start && node.getEnd() >= diagnostic.start) {
+            if (ts.isNewExpression(node) ||
+                (ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.SuperKeyword)) {
+                resolvedNode = node;
+            }
+            ts.forEachChild(node, _visitNode);
+        }
+    };
+    ts.forEachChild(sourceFile, _visitNode);
+    return resolvedNode;
+}
+/** Determines the class declaration of the specified construct signature. */
+function getClassDeclarationOfSignature(signature) {
+    let node = signature.getDeclaration();
+    // Handle signatures which don't have an actual declaration. This happens if a class
+    // does not have an explicitly written constructor.
+    if (!node) {
+        return null;
+    }
+    while (!ts.isSourceFile((node = node.parent))) {
+        if (ts.isClassDeclaration(node)) {
+            return node;
+        }
+    }
+    return null;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"constructor-signature.js","sourceRoot":"","sources":["../../../../../../../../src/cdk/schematics/ng-update/migrations/constructor-signature.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 * as ts from 'typescript';\nimport {Migration} from '../../update-tool/migration';\nimport {getAllChanges} from '../../update-tool/version-changes';\nimport {UpgradeData} from '../upgrade-data';\n\n/**\n * List of diagnostic codes that refer to pre-emit diagnostics which indicate invalid\n * new expression or super call signatures. See the list of diagnostics here:\n *\n * https://github.com/Microsoft/TypeScript/blob/master/src/compiler/diagnosticMessages.json\n */\nconst signatureErrorDiagnostics = [\n  // Type not assignable error diagnostic.\n  2345,\n  // Constructor argument length invalid diagnostics\n  2554, 2555, 2556, 2557,\n];\n\n/**\n * Migration that visits every TypeScript new expression or super call and checks if\n * the parameter type signature is invalid and needs to be updated manually.\n */\nexport class ConstructorSignatureMigration extends Migration<UpgradeData> {\n  // Note that the data for this rule is not distinguished based on the target version because\n  // we don't keep track of the new signature and don't want to update incrementally.\n  // See: https://github.com/angular/components/pull/12970#issuecomment-418337566\n  data = getAllChanges(this.upgradeData.constructorChecks);\n\n  // Only enable the migration rule if there is upgrade data.\n  enabled = this.data.length !== 0;\n\n  override visitNode(node: ts.Node): void {\n    if (ts.isSourceFile(node)) {\n      this._visitSourceFile(node);\n    }\n  }\n\n  /**\n   * Method that will be called for each source file of the upgrade project. In order to\n   * properly determine invalid constructor signatures, we take advantage of the pre-emit\n   * diagnostics from TypeScript.\n   *\n   * By using the diagnostics, the migration can handle type assignability. Not using\n   * diagnostics would mean that we need to use simple type equality checking which is\n   * too strict. See related issue: https://github.com/Microsoft/TypeScript/issues/9879\n   */\n  private _visitSourceFile(sourceFile: ts.SourceFile) {\n    // List of classes of which the constructor signature has changed.\n    const diagnostics = ts\n      .getPreEmitDiagnostics(this.program, sourceFile)\n      .filter(diagnostic => signatureErrorDiagnostics.includes(diagnostic.code))\n      .filter(diagnostic => diagnostic.start !== undefined);\n\n    for (const diagnostic of diagnostics) {\n      const node = findConstructorNode(diagnostic, sourceFile);\n\n      if (!node) {\n        continue;\n      }\n\n      const classType = this.typeChecker.getTypeAtLocation(node.expression);\n      const className = classType.symbol && classType.symbol.name;\n      const isNewExpression = ts.isNewExpression(node);\n\n      // Determine the class names of the actual construct signatures because we cannot assume that\n      // the diagnostic refers to a constructor of the actual expression. In case the constructor\n      // is inherited, we need to detect that the owner-class of the constructor is added to the\n      // constructor checks upgrade data. e.g. `class CustomCalendar extends MatCalendar {}`.\n      const signatureClassNames = classType\n        .getConstructSignatures()\n        .map(signature => getClassDeclarationOfSignature(signature))\n        .map(declaration => (declaration && declaration.name ? declaration.name.text : null))\n        .filter(Boolean);\n\n      // Besides checking the signature class names, we need to check the actual class name because\n      // there can be classes without an explicit constructor.\n      if (\n        !this.data.includes(className) &&\n        !signatureClassNames.some(name => this.data.includes(name!))\n      ) {\n        continue;\n      }\n\n      const classSignatures = classType\n        .getConstructSignatures()\n        .map(signature => getParameterTypesFromSignature(signature, this.typeChecker));\n\n      const expressionName = isNewExpression ? `new ${className}` : 'super';\n      const signatures = classSignatures\n        .map(signature =>\n          signature.map(t => (t === null ? 'any' : this.typeChecker.typeToString(t))),\n        )\n        .map(signature => `${expressionName}(${signature.join(', ')})`)\n        .join(' or ');\n\n      this.createFailureAtNode(\n        node,\n        `Found \"${className}\" constructed with ` +\n          `an invalid signature. Please manually update the ${expressionName} expression to ` +\n          `match the new signature${classSignatures.length > 1 ? 's' : ''}: ${signatures}`,\n      );\n    }\n  }\n}\n\n/** Resolves the type for each parameter in the specified signature. */\nfunction getParameterTypesFromSignature(\n  signature: ts.Signature,\n  typeChecker: ts.TypeChecker,\n): (ts.Type | null)[] {\n  return signature\n    .getParameters()\n    .map(param =>\n      param.declarations ? typeChecker.getTypeAtLocation(param.declarations[0]) : null,\n    );\n}\n\n/**\n * Walks through each node of a source file in order to find a new-expression node or super-call\n * expression node that is captured by the specified diagnostic.\n */\nfunction findConstructorNode(\n  diagnostic: ts.Diagnostic,\n  sourceFile: ts.SourceFile,\n): ts.CallExpression | ts.NewExpression | null {\n  let resolvedNode: ts.Node | null = null;\n\n  const _visitNode = (node: ts.Node) => {\n    // Check whether the current node contains the diagnostic. If the node contains the diagnostic,\n    // walk deeper in order to find all constructor expression nodes.\n    if (node.getStart() <= diagnostic.start! && node.getEnd() >= diagnostic.start!) {\n      if (\n        ts.isNewExpression(node) ||\n        (ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.SuperKeyword)\n      ) {\n        resolvedNode = node;\n      }\n\n      ts.forEachChild(node, _visitNode);\n    }\n  };\n\n  ts.forEachChild(sourceFile, _visitNode);\n\n  return resolvedNode;\n}\n\n/** Determines the class declaration of the specified construct signature. */\nfunction getClassDeclarationOfSignature(signature: ts.Signature): ts.ClassDeclaration | null {\n  let node: ts.Node = signature.getDeclaration();\n  // Handle signatures which don't have an actual declaration. This happens if a class\n  // does not have an explicitly written constructor.\n  if (!node) {\n    return null;\n  }\n  while (!ts.isSourceFile((node = node.parent))) {\n    if (ts.isClassDeclaration(node)) {\n      return node;\n    }\n  }\n  return null;\n}\n"]}

package/schematics/cdk2/schematics/ng-update/migrations/css-selectors.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @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 { ResolvedResource } from '../../update-tool/component-resource-collector';
+import { Migration } from '../../update-tool/migration';
+import { CssSelectorUpgradeData } from '../data/css-selectors';
+import { UpgradeData } from '../upgrade-data';
+/**
+ * Migration that walks through every string literal, template and stylesheet in
+ * order to migrate outdated CSS selectors to the new selector.
+ */
+export declare class CssSelectorsMigration extends Migration<UpgradeData> {
+    /** Change data that upgrades to the specified target version. */
+    data: CssSelectorUpgradeData[];
+    enabled: boolean;
+    visitNode(node: ts.Node): void;
+    visitTemplate(template: ResolvedResource): void;
+    visitStylesheet(stylesheet: ResolvedResource): void;
+    private _visitStringLiteralLike;
+    private _replaceSelector;
+}