@design-factory/design-factory 15.2.2 → 16.0.0

package/schematics/migrations/16_0_0/scss-var/index.d.ts

@@ -0,0 +1,7 @@
+import { Rule } from '@angular-devkit/schematics';
+/**
+ * This migration
+ *
+ * @returns the Rule to migrate the classes
+ */
+export default function scssVars(): Rule;

package/schematics/migrations/16_0_0/scss-var/index.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const schematics_1 = require("@angular-devkit/schematics");
+const project_tsconfig_paths_1 = require("../../utils/project_tsconfig_paths");
+const compiler_host_1 = require("../../utils/typescript/compiler_host");
+const style_updater_1 = require("../../utils/style-updater");
+const fs_1 = require("fs");
+const removed = JSON.parse((0, fs_1.readFileSync)(__dirname + '/files/removed.json', { encoding: 'UTF-8' }));
+const removedSet = new Set();
+for (const removedKey of removed) {
+    removedSet.add(removedKey);
+}
+const renames = JSON.parse((0, fs_1.readFileSync)(__dirname + '/files/renames.json', { encoding: 'UTF-8' }));
+const renameMap = new Map();
+for (const rename of renames) {
+    renameMap.set(rename.from, rename.to);
+}
+const regex = /\$([a-z-]+)([^a-z-])/g;
+/**
+ * This migration
+ *
+ * @returns the Rule to migrate the classes
+ */
+function scssVars() {
+    return async (tree, context) => {
+        const { buildPaths, testPaths } = await (0, project_tsconfig_paths_1.getProjectTsConfigPaths)(tree);
+        const basePath = process.cwd();
+        const allPaths = [...buildPaths, ...testPaths];
+        if (!allPaths.length) {
+            throw new schematics_1.SchematicsException('Could not find any tsconfig file. Cannot run the `NavbarUpdate` migration.');
+        }
+        const replaceStyleContent = (content, filePath) => {
+            return content.replace(regex, (match, grp1, grp2) => {
+                if (renameMap.has(grp1)) {
+                    return `$${renameMap.get(grp1)}${grp2}`;
+                }
+                else {
+                    if (removedSet.has(grp1)) {
+                        context.logger.warn(`Sass var ${grp1} used in ${filePath} was removed in the new version of Design Factory.`);
+                    }
+                    return match;
+                }
+            });
+        };
+        const templateUpdater = new style_updater_1.StyleUpdater(tree, replaceStyleContent);
+        for (const tsconfigPath of allPaths) {
+            const program = (0, compiler_host_1.createMigrationProgram)(tree, tsconfigPath, basePath);
+            const sourceFiles = program
+                .getSourceFiles()
+                .filter((sourceFile) => (0, compiler_host_1.canMigrateFile)(basePath, sourceFile, program));
+            for (const sourceFile of sourceFiles) {
+                templateUpdater.update(sourceFile, program.getTypeChecker());
+            }
+        }
+    };
+}
+exports.default = scssVars;

package/schematics/migrations/16_0_0/stepper-classes/index.d.ts

@@ -0,0 +1,13 @@
+import { Rule } from '@angular-devkit/schematics';
+/**
+ * This migration migrates css classes of the stepper that were renamed as of DF 16.
+ * This migrates:
+ * - any element that contains the class df-stepper-step-600 into df-stepper-step-future
+ * - any element that contains the class df-stepper-outline-number-400 into df-stepper-outline-number-future
+ * - any element that contains the class df-stepper-step-brown into df-stepper-step-warning
+ * - any element that contains the class df-stepper-step-green into df-stepper-step-completed
+ * - any element that contains the class df-stepper-step-primary into df-stepper-step-current
+ *
+ * @returns the Rule to migrate the classes
+ */
+export default function stepperClassesUpdate(): Rule;

package/schematics/migrations/16_0_0/stepper-classes/index.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const schematics_1 = require("@angular-devkit/schematics");
+const project_tsconfig_paths_1 = require("../../utils/project_tsconfig_paths");
+const compiler_host_1 = require("../../utils/typescript/compiler_host");
+const template_updater_1 = require("../../utils/template-updater");
+const colorMapping = {
+    '400': 'future',
+    '600': 'future',
+    brown: 'warning',
+    green: 'completed',
+    primary: 'current'
+};
+const stepperStepMapping = {};
+for (const key of Object.keys(colorMapping)) {
+    const replaced = colorMapping[key];
+    stepperStepMapping[`df-stepper-step-${key}`] = `df-stepper-step-${replaced}`;
+    stepperStepMapping[`df-stepper-outline-number-${key}`] = `df-stepper-outline-number-${replaced}`;
+    stepperStepMapping[`df-stepper-number-${key}`] = `df-stepper-number-${replaced}`;
+}
+const updates = Object.keys(stepperStepMapping).map((key) => ({
+    key,
+    regex: new RegExp(`(<[a-z]+\\s[^>]*\\sclass="|<[a-z]+\\sclass=")([^"]*)${key}([^"]*")`, 'g'),
+    replacement: stepperStepMapping[key]
+}));
+function replaceHtmlContent(content) {
+    for (const update of updates) {
+        content = content.replace(update.regex, (_match, g1, g2, g3) => `${g1}${g2}${stepperStepMapping[update.key]}${g3}`);
+    }
+    return content;
+}
+/**
+ * This migration migrates css classes of the stepper that were renamed as of DF 16.
+ * This migrates:
+ * - any element that contains the class df-stepper-step-600 into df-stepper-step-future
+ * - any element that contains the class df-stepper-outline-number-400 into df-stepper-outline-number-future
+ * - any element that contains the class df-stepper-step-brown into df-stepper-step-warning
+ * - any element that contains the class df-stepper-step-green into df-stepper-step-completed
+ * - any element that contains the class df-stepper-step-primary into df-stepper-step-current
+ *
+ * @returns the Rule to migrate the classes
+ */
+function stepperClassesUpdate() {
+    return async (tree) => {
+        const { buildPaths, testPaths } = await (0, project_tsconfig_paths_1.getProjectTsConfigPaths)(tree);
+        const basePath = process.cwd();
+        const allPaths = [...buildPaths, ...testPaths];
+        if (!allPaths.length) {
+            throw new schematics_1.SchematicsException('Could not find any tsconfig file. Cannot run the `NavbarUpdate` migration.');
+        }
+        const templateUpdater = new template_updater_1.TemplateUpdater(tree, replaceHtmlContent);
+        for (const tsconfigPath of allPaths) {
+            const program = (0, compiler_host_1.createMigrationProgram)(tree, tsconfigPath, basePath);
+            const sourceFiles = program
+                .getSourceFiles()
+                .filter((sourceFile) => (0, compiler_host_1.canMigrateFile)(basePath, sourceFile, program));
+            for (const sourceFile of sourceFiles) {
+                templateUpdater.update(sourceFile, program.getTypeChecker());
+            }
+        }
+    };
+}
+exports.default = stepperClassesUpdate;

package/schematics/migrations/helpers.js

@@ -30,4 +30,3 @@ function dedent(strings, ...values) {
     return result.replace(omitEmptyLineWhitespaceRegex, '');
 }
 exports.dedent = dedent;
-//# sourceMappingURL=helpers.js.map

package/schematics/migrations/migration.json

@@ -5,6 +5,28 @@
       "description": "As of Design Factory version 15, ngx-slider is included as part of the library.",
       "version": "15.0.0",
       "factory": "./15_0_0/remove-ngx-slider"
+    },
+    "revert-to-old-brand": {
+      "description": "Continue with the old brand. As of Design Factory version 16, the new amadeus branding is applied by default. Launch this migration if you wish to keep using the old branding.",
+      "version": "16.0.0",
+      "factory": "./16_0_0/revert-to-old-brand",
+      "optional": true
+    },
+    "navbar-logo-dark": {
+      "description": "Migrate to the new brand for the navbar and amadeus logo. As of Design Factory version 16, the new amadeus branding is applied by default. This updates the navbar and amadeus logo to the new look.",
+      "version": "16.0.0",
+      "factory": "./16_0_0/navbar-logo-dark",
+      "optional": true
+    },
+    "scss-var": {
+      "description": "Migrates scss vars as best as possible.",
+      "version": "16.0.0",
+      "factory": "./16_0_0/scss-var"
+    },
+    "stepper-classes": {
+      "description": "As of Design Factory version 16, some css classes for the stepper have been renamed.",
+      "version": "16.0.0",
+      "factory": "./16_0_0/stepper-classes"
     }
   }
-}
+}

package/schematics/migrations/utils/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 { LineAndCharacter } from './typescript/line-mappings';
+import { Tree } from '@angular-devkit/schematics';
+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: string;
+    /**
+     * 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 tree;
+    resolvedTemplates: ResolvedResource[];
+    resolvedStylesheets: ResolvedResource[];
+    constructor(typeChecker: ts.TypeChecker, tree: Tree);
+    visitNode(node: ts.Node): void;
+    private _visitClassDeclaration;
+    /** Resolves an external stylesheet by reading its content and computing line mappings. */
+    resolveExternalStylesheet(filePath: string, container: ts.ClassDeclaration | null): ResolvedResource | null;
+    private _trackExternalStylesheet;
+}

package/schematics/migrations/utils/component-resource-collector.js

@@ -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 core_1 = require("@angular-devkit/core");
+const ts = require("typescript");
+const decorators_1 = require("./typescript/decorators");
+const functions_1 = require("./typescript/functions");
+const line_mappings_1 = require("./typescript/line-mappings");
+const property_name_1 = require("./typescript/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 {
+    constructor(typeChecker, tree) {
+        this.typeChecker = typeChecker;
+        this.tree = tree;
+        this.resolvedTemplates = [];
+        this.resolvedStylesheets = [];
+    }
+    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 absFilePath = (0, core_1.normalize)(path_1.posix.resolve('/', (0, core_1.normalize)(sourceFile.fileName)));
+        const filePath = path_1.posix.relative(process.cwd(), absFilePath);
+        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 absTemplatePath = (0, core_1.normalize)(path_1.posix.resolve('/', (0, core_1.normalize)(sourceFileDirPath), (0, core_1.normalize)(templateUrl)));
+                const templatePath = path_1.posix.relative(process.cwd(), absTemplatePath);
+                // In case the template does not exist in the file system, skip this
+                // external template.
+                if (!this.tree.exists(templatePath)) {
+                    return;
+                }
+                const fileContent = stripBom(this.tree.readText(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.tree.readText(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 = path_1.posix.relative(process.cwd(), (0, core_1.normalize)(path_1.posix.resolve('/', (0, core_1.normalize)(sourceFileDirPath), (0, core_1.normalize)(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, '');
+}

package/schematics/migrations/utils/project_tsconfig_paths.js

@@ -88,4 +88,3 @@ async function getWorkspace(tree) {
     const { workspace } = await core_1.workspaces.readWorkspace('/', host);
     return workspace;
 }
-//# sourceMappingURL=project_tsconfig_paths.js.map

package/schematics/migrations/utils/style-updater.d.ts

@@ -0,0 +1,9 @@
+import { Tree } from '@angular-devkit/schematics';
+import * as ts from 'typescript';
+export declare class StyleUpdater {
+    private tree;
+    private replaceContent;
+    private _analyzedFiles;
+    constructor(tree: Tree, replaceContent: (arg: string, filePath: string) => string);
+    update(file: ts.SourceFile, typeChecker: ts.TypeChecker): void;
+}

package/schematics/migrations/utils/style-updater.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StyleUpdater = void 0;
+const core_1 = require("@angular-devkit/core");
+const component_resource_collector_1 = require("./component-resource-collector");
+const ts = require("typescript");
+const path_1 = require("path");
+class StyleUpdater {
+    constructor(tree, replaceContent) {
+        this.tree = tree;
+        this.replaceContent = replaceContent;
+        this._analyzedFiles = new Set();
+    }
+    update(file, typeChecker) {
+        if (this._analyzedFiles.has((0, core_1.normalize)(path_1.posix.resolve(file.fileName)))) {
+            return;
+        }
+        const resourceCollector = new component_resource_collector_1.ComponentResourceCollector(typeChecker, this.tree);
+        const visitNodeAndCollectResources = (node) => {
+            ts.forEachChild(node, visitNodeAndCollectResources);
+            resourceCollector.visitNode(node);
+        };
+        visitNodeAndCollectResources(file);
+        for (const styleSheet of resourceCollector.resolvedStylesheets) {
+            if (styleSheet.inline || !this._analyzedFiles.has(styleSheet.filePath)) {
+                const content = this.replaceContent(styleSheet.content, styleSheet.filePath);
+                if (content !== styleSheet.content) {
+                    const recorder = this.tree.beginUpdate(styleSheet.filePath);
+                    recorder.remove(styleSheet.start, styleSheet.content.length);
+                    recorder.insertRight(styleSheet.start, content);
+                    this.tree.commitUpdate(recorder);
+                }
+                this._analyzedFiles.add(styleSheet.filePath);
+            }
+        }
+    }
+}
+exports.StyleUpdater = StyleUpdater;

package/schematics/migrations/utils/template-updater.d.ts

@@ -0,0 +1,9 @@
+import { Tree } from '@angular-devkit/schematics';
+import * as ts from 'typescript';
+export declare class TemplateUpdater {
+    private tree;
+    private replaceContent;
+    private _analyzedFiles;
+    constructor(tree: Tree, replaceContent: (arg: string) => string);
+    update(file: ts.SourceFile, typeChecker: ts.TypeChecker): void;
+}

package/schematics/migrations/utils/template-updater.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemplateUpdater = void 0;
+const core_1 = require("@angular-devkit/core");
+const component_resource_collector_1 = require("./component-resource-collector");
+const ts = require("typescript");
+const path_1 = require("path");
+class TemplateUpdater {
+    constructor(tree, replaceContent) {
+        this.tree = tree;
+        this.replaceContent = replaceContent;
+        this._analyzedFiles = new Set();
+    }
+    update(file, typeChecker) {
+        if (this._analyzedFiles.has((0, core_1.normalize)(path_1.posix.resolve(file.fileName)))) {
+            return;
+        }
+        const resourceCollector = new component_resource_collector_1.ComponentResourceCollector(typeChecker, this.tree);
+        const visitNodeAndCollectResources = (node) => {
+            ts.forEachChild(node, visitNodeAndCollectResources);
+            resourceCollector.visitNode(node);
+        };
+        visitNodeAndCollectResources(file);
+        for (const template of resourceCollector.resolvedTemplates) {
+            if (template.inline || !this._analyzedFiles.has(template.filePath)) {
+                const content = this.replaceContent(template.content);
+                if (content !== template.content) {
+                    const recorder = this.tree.beginUpdate(template.filePath);
+                    recorder.remove(template.start, template.content.length);
+                    recorder.insertRight(template.start, content);
+                    this.tree.commitUpdate(recorder);
+                }
+                this._analyzedFiles.add(template.filePath);
+            }
+        }
+    }
+}
+exports.TemplateUpdater = TemplateUpdater;

package/schematics/migrations/utils/typescript/compiler_host.js

@@ -83,4 +83,3 @@ function canMigrateFile(basePath, sourceFile, program) {
     return !(0, path_1.relative)(basePath, sourceFile.fileName).startsWith('..');
 }
 exports.canMigrateFile = canMigrateFile;
-//# sourceMappingURL=compiler_host.js.map

package/schematics/migrations/utils/typescript/decorators.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @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 { Import } from './imports';
+export type CallExpressionDecorator = ts.Decorator & {
+    expression: ts.CallExpression;
+};
+export interface NgDecorator {
+    name: string;
+    node: CallExpressionDecorator;
+}
+/**
+ * Gets all decorators which are imported from an Angular package
+ * (e.g. "@angular/core") from a list of decorators.
+ */
+export declare function getAngularDecorators(typeChecker: ts.TypeChecker, decorators: readonly ts.Decorator[]): readonly NgDecorator[];
+export declare function getCallDecoratorImport(typeChecker: ts.TypeChecker, decorator: ts.Decorator): Import | null;

package/schematics/migrations/utils/typescript/decorators.js

@@ -0,0 +1,41 @@
+"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.getCallDecoratorImport = exports.getAngularDecorators = void 0;
+const ts = require("typescript");
+const imports_1 = require("./imports");
+/**
+ * Gets all decorators which are imported from an Angular package
+ * (e.g. "@angular/core") from a list of decorators.
+ */
+function getAngularDecorators(typeChecker, decorators) {
+    return decorators
+        .map((node) => ({ node, importData: getCallDecoratorImport(typeChecker, node) }))
+        .filter(({ importData }) => importData && importData.moduleName.startsWith('@angular/'))
+        .map(({ node, importData }) => ({
+        node: node,
+        name: importData.symbolName
+    }));
+}
+exports.getAngularDecorators = getAngularDecorators;
+function getCallDecoratorImport(typeChecker, decorator) {
+    if (!ts.isCallExpression(decorator.expression)) {
+        return null;
+    }
+    const valueExpr = decorator.expression.expression;
+    let identifier = null;
+    if (ts.isIdentifier(valueExpr)) {
+        identifier = valueExpr;
+    }
+    else if (ts.isPropertyAccessExpression(valueExpr) && ts.isIdentifier(valueExpr.name)) {
+        identifier = valueExpr.name;
+    }
+    return identifier ? (0, imports_1.getImportOfIdentifier)(identifier, typeChecker) : null;
+}
+exports.getCallDecoratorImport = getCallDecoratorImport;

package/schematics/migrations/utils/typescript/functions.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @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';
+/**
+ * Unwraps a given expression TypeScript node. Expressions can be wrapped within multiple
+ * parentheses. e.g. "(((({exp}))))()". The function should return the TypeScript node
+ * referring to the inner expression. e.g "exp".
+ */
+export declare function unwrapExpression(node: ts.Expression | ts.ParenthesizedExpression): ts.Expression;

package/schematics/migrations/utils/typescript/functions.js

@@ -0,0 +1,20 @@
+"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.unwrapExpression = void 0;
+const ts = require("typescript");
+/**
+ * Unwraps a given expression TypeScript node. Expressions can be wrapped within multiple
+ * parentheses. e.g. "(((({exp}))))()". The function should return the TypeScript node
+ * referring to the inner expression. e.g "exp".
+ */
+function unwrapExpression(node) {
+    return ts.isParenthesizedExpression(node) ? unwrapExpression(node.expression) : node;
+}
+exports.unwrapExpression = unwrapExpression;

package/schematics/migrations/utils/typescript/imports.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @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';
+/** Interface describing a resolved import. */
+export interface Import {
+    /** Name of the imported symbol. */
+    symbolName: string;
+    /** Module name from which the symbol has been imported. */
+    moduleName: string;
+}
+/** Resolves the import of the specified identifier. */
+export declare function getImportOfIdentifier(node: ts.Identifier, typeChecker: ts.TypeChecker): Import | null;