@design-factory/angular 21.1.0 → 22.0.0-next.0

package/schematics/component-migration/utils/project_tsconfig_paths.js

@@ -0,0 +1,105 @@
+"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.getProjectTsConfigPaths = getProjectTsConfigPaths;
+exports.getBuildableProjectNames = getBuildableProjectNames;
+exports.resolveProjectNames = resolveProjectNames;
+const core_1 = require("@angular-devkit/core");
+const schematics_1 = require("@angular-devkit/schematics");
+const workspace_1 = require("@schematics/angular/utility/workspace");
+function formatProjectOptions(projectNames) {
+    return projectNames.map((name) => `  --project=${name}`).join('\n');
+}
+function formatAvailableProjectMessage(projectNames) {
+    return `Run again with the project you want to migrate:\n\n${formatProjectOptions(projectNames)}\n\nOr run every buildable project with:\n\n  --all`;
+}
+/**
+ * Gets all tsconfig paths from a CLI project by reading the workspace configuration
+ * and looking for common tsconfig locations.
+ */
+async function getProjectTsConfigPaths(tree, projectName) {
+    // Start with some tsconfig paths that are generally used within CLI projects. Note
+    // that we are not interested in IDE-specific tsconfig files (e.g. /tsconfig.json)
+    const buildPaths = new Set();
+    const testPaths = new Set();
+    const workspace = await (0, workspace_1.getWorkspace)(tree);
+    if (projectName && !workspace.projects.has(projectName)) {
+        throw new schematics_1.SchematicsException(`Project "${projectName}" does not exist.`);
+    }
+    for (const [nameProject, project] of workspace.projects) {
+        if (projectName && nameProject !== projectName) {
+            continue;
+        }
+        for (const [name, target] of project.targets) {
+            if (name !== 'build' && name !== 'test') {
+                continue;
+            }
+            for (const [, options] of (0, workspace_1.allTargetOptions)(target)) {
+                const tsConfig = options['tsConfig'];
+                // Filter out tsconfig files that don't exist in the CLI project.
+                if (typeof tsConfig !== 'string' || !tree.exists(tsConfig)) {
+                    continue;
+                }
+                if (name === 'build') {
+                    buildPaths.add((0, core_1.normalize)(tsConfig));
+                }
+                else {
+                    testPaths.add((0, core_1.normalize)(tsConfig));
+                }
+            }
+        }
+    }
+    return {
+        buildPaths: [...buildPaths],
+        testPaths: [...testPaths]
+    };
+}
+async function getBuildableProjectNames(tree) {
+    const workspace = await (0, workspace_1.getWorkspace)(tree);
+    const projectNames = [];
+    for (const [projectName, project] of workspace.projects) {
+        const buildTarget = project.targets.get('build');
+        if (!buildTarget) {
+            continue;
+        }
+        for (const [, options] of (0, workspace_1.allTargetOptions)(buildTarget)) {
+            const tsConfig = options['tsConfig'];
+            if (typeof tsConfig === 'string' && tree.exists(tsConfig)) {
+                projectNames.push(projectName);
+                break;
+            }
+        }
+    }
+    return projectNames;
+}
+async function resolveProjectNames(tree, projectName, all) {
+    const projectNames = await getBuildableProjectNames(tree);
+    if (all) {
+        if (projectNames.length === 0) {
+            throw new schematics_1.SchematicsException('No projects with a build tsconfig were found.');
+        }
+        return projectNames;
+    }
+    if (projectName) {
+        if (!projectNames.includes(projectName)) {
+            const suffix = projectNames.length === 0
+                ? 'No projects with a build tsconfig were found.'
+                : formatAvailableProjectMessage(projectNames);
+            throw new schematics_1.SchematicsException(`Project "${projectName}" does not exist or does not have a build tsconfig. ${suffix}`);
+        }
+        return [projectName];
+    }
+    if (projectNames.length === 1) {
+        return [projectNames[0]];
+    }
+    if (projectNames.length === 0) {
+        throw new schematics_1.SchematicsException('The "project" option is required. No projects with a build tsconfig were found.');
+    }
+    throw new schematics_1.SchematicsException(`The "project" option is required because this workspace has multiple buildable projects. ${formatAvailableProjectMessage(projectNames)}`);
+}

package/schematics/component-migration/utils/typescript/compiler_host.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 { Tree } from '@angular-devkit/schematics';
+import * as ts from 'typescript';
+type FakeReadFileFn = (fileName: string) => string | undefined;
+/**
+ * Creates a TypeScript program instance for a TypeScript project within
+ * the virtual file system tree.
+ * @param tree Virtual file system tree that contains the source files.
+ * @param tsconfigPath Virtual file system path that resolves to the TypeScript project.
+ * @param basePath Base path for the virtual file system tree.
+ * @param fakeFileRead Optional file reader function. Can be used to overwrite files in
+ *   the TypeScript program, or to add in-memory files (e.g. to add global types).
+ * @param additionalFiles Additional file paths that should be added to the program.
+ */
+export declare function createMigrationProgram(tree: Tree, tsconfigPath: string, basePath: string, fakeFileRead?: FakeReadFileFn, additionalFiles?: string[]): ts.Program;
+/**
+ * Creates the options necessary to instantiate a TypeScript program.
+ * @param tree Virtual file system tree that contains the source files.
+ * @param tsconfigPath Virtual file system path that resolves to the TypeScript project.
+ * @param basePath Base path for the virtual file system tree.
+ * @param fakeFileRead Optional file reader function. Can be used to overwrite files in
+ *   the TypeScript program, or to add in-memory files (e.g. to add global types).
+ * @param additionalFiles Additional file paths that should be added to the program.
+ * @param optionOverrides Overrides of the parsed compiler options.
+ */
+export declare function createProgramOptions(tree: Tree, tsconfigPath: string, basePath: string, fakeFileRead?: FakeReadFileFn, additionalFiles?: string[], optionOverrides?: ts.CompilerOptions): {
+    rootNames: string[];
+    options: ts.CompilerOptions;
+    host: ts.CompilerHost;
+};
+/**
+ * Checks whether a file can be migrate by our automated migrations.
+ * @param basePath Absolute path to the project.
+ * @param sourceFile File being checked.
+ * @param program Program that includes the source file.
+ */
+export declare function canMigrateFile(basePath: string, sourceFile: ts.SourceFile, program: ts.Program): boolean;
+export {};

package/schematics/component-migration/utils/typescript/compiler_host.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMigrationProgram = createMigrationProgram;
+exports.createProgramOptions = createProgramOptions;
+exports.canMigrateFile = canMigrateFile;
+const tslib_1 = require("tslib");
+const path_1 = require("path");
+const ts = tslib_1.__importStar(require("typescript"));
+const parse_tsconfig_1 = require("./parse_tsconfig");
+/**
+ * Creates a TypeScript program instance for a TypeScript project within
+ * the virtual file system tree.
+ * @param tree Virtual file system tree that contains the source files.
+ * @param tsconfigPath Virtual file system path that resolves to the TypeScript project.
+ * @param basePath Base path for the virtual file system tree.
+ * @param fakeFileRead Optional file reader function. Can be used to overwrite files in
+ *   the TypeScript program, or to add in-memory files (e.g. to add global types).
+ * @param additionalFiles Additional file paths that should be added to the program.
+ */
+function createMigrationProgram(tree, tsconfigPath, basePath, fakeFileRead, additionalFiles) {
+    const { rootNames, options, host } = createProgramOptions(tree, tsconfigPath, basePath, fakeFileRead, additionalFiles);
+    return ts.createProgram(rootNames, options, host);
+}
+/**
+ * Creates the options necessary to instantiate a TypeScript program.
+ * @param tree Virtual file system tree that contains the source files.
+ * @param tsconfigPath Virtual file system path that resolves to the TypeScript project.
+ * @param basePath Base path for the virtual file system tree.
+ * @param fakeFileRead Optional file reader function. Can be used to overwrite files in
+ *   the TypeScript program, or to add in-memory files (e.g. to add global types).
+ * @param additionalFiles Additional file paths that should be added to the program.
+ * @param optionOverrides Overrides of the parsed compiler options.
+ */
+function createProgramOptions(tree, tsconfigPath, basePath, fakeFileRead, additionalFiles, optionOverrides) {
+    // Resolve the tsconfig path to an absolute path. This is needed as TypeScript otherwise
+    // is not able to resolve root directories in the given tsconfig. More details can be found
+    // in the following issue: https://github.com/microsoft/TypeScript/issues/37731.
+    tsconfigPath = (0, path_1.resolve)(basePath, tsconfigPath);
+    const parsed = (0, parse_tsconfig_1.parseTsconfigFile)(tsconfigPath, (0, path_1.dirname)(tsconfigPath));
+    const options = optionOverrides ? { ...parsed.options, ...optionOverrides } : parsed.options;
+    const host = createMigrationCompilerHost(tree, options, basePath, fakeFileRead);
+    return { rootNames: parsed.fileNames.concat(additionalFiles || []), options, host };
+}
+function createMigrationCompilerHost(tree, options, basePath, fakeRead) {
+    const host = ts.createCompilerHost(options, true);
+    const defaultReadFile = host.readFile;
+    // We need to overwrite the host "readFile" method, as we want the TypeScript
+    // program to be based on the file contents in the virtual file tree. Otherwise
+    // if we run multiple migrations we might have intersecting changes and
+    // source files.
+    host.readFile = (fileName) => {
+        const treeRelativePath = (0, path_1.relative)(basePath, fileName);
+        let result = fakeRead?.(treeRelativePath);
+        if (typeof result !== 'string') {
+            // If the relative path resolved to somewhere outside of the tree, fall back to
+            // TypeScript's default file reading function since the `tree` will throw an error.
+            result = treeRelativePath.startsWith('..')
+                ? defaultReadFile.call(host, fileName)
+                : tree.read(treeRelativePath)?.toString();
+        }
+        // Strip BOM as otherwise TSC methods (Ex: getWidth) will return an offset,
+        // which breaks the CLI UpdateRecorder.
+        // See: https://github.com/angular/angular/pull/30719
+        return typeof result === 'string' ? result.replace(/^\uFEFF/, '') : undefined;
+    };
+    return host;
+}
+/**
+ * Checks whether a file can be migrate by our automated migrations.
+ * @param basePath Absolute path to the project.
+ * @param sourceFile File being checked.
+ * @param program Program that includes the source file.
+ */
+function canMigrateFile(basePath, sourceFile, program) {
+    // We shouldn't migrate .d.ts files, files from an external library or type checking files.
+    if (sourceFile.fileName.endsWith('.ngtypecheck.ts') ||
+        sourceFile.isDeclarationFile ||
+        program.isSourceFileFromExternalLibrary(sourceFile)) {
+        return false;
+    }
+    // Our migrations are set up to create a `Program` from the project's tsconfig and to migrate all
+    // the files within the program. This can include files that are outside of the Angular CLI
+    // project. We can't migrate files outside of the project, because our file system interactions
+    // go through the CLI's `Tree` which assumes that all files are within the project. See:
+    // https://github.com/angular/angular-cli/blob/0b0961c9c233a825b6e4bb59ab7f0790f9b14676/packages/angular_devkit/schematics/src/tree/host-tree.ts#L131
+    return !(0, path_1.relative)(basePath, sourceFile.fileName).startsWith('..');
+}

package/schematics/component-migration/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/component-migration/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.getAngularDecorators = getAngularDecorators;
+exports.getCallDecoratorImport = getCallDecoratorImport;
+const tslib_1 = require("tslib");
+const ts = tslib_1.__importStar(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
+    }));
+}
+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;
+}

package/schematics/component-migration/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/component-migration/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 = unwrapExpression;
+const tslib_1 = require("tslib");
+const ts = tslib_1.__importStar(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;
+}

package/schematics/component-migration/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;

package/schematics/component-migration/utils/typescript/imports.js

@@ -0,0 +1,110 @@
+"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.getImportOfIdentifier = getImportOfIdentifier;
+const tslib_1 = require("tslib");
+const ts = tslib_1.__importStar(require("typescript"));
+/** Resolves the import of the specified identifier. */
+function getImportOfIdentifier(node, typeChecker) {
+    // Free standing identifiers which resolve to an import will be handled
+    // as direct imports. e.g. "@Component()" where "Component" is an identifier
+    // referring to an import specifier.
+    const directImport = getSpecificImportOfIdentifier(node, typeChecker);
+    if (directImport !== null) {
+        return directImport;
+    }
+    else if (ts.isQualifiedName(node.parent) && node.parent.right === node) {
+        // Determines the import of a qualified name. e.g. "let t: core.Component". In that
+        // case, the import of the most left identifier will be determined ("core").
+        const qualifierRoot = getQualifiedNameRoot(node.parent);
+        if (qualifierRoot) {
+            const moduleName = getImportOfNamespacedIdentifier(qualifierRoot, typeChecker);
+            if (moduleName) {
+                return { moduleName, symbolName: node.text };
+            }
+        }
+    }
+    else if (ts.isPropertyAccessExpression(node.parent) && node.parent.name === node) {
+        // Determines the import of a property expression. e.g. "@core.Component". In that
+        // case, the import of the most left identifier will be determined ("core").
+        const rootIdentifier = getPropertyAccessRoot(node.parent);
+        if (rootIdentifier) {
+            const moduleName = getImportOfNamespacedIdentifier(rootIdentifier, typeChecker);
+            if (moduleName) {
+                return { moduleName, symbolName: node.text };
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Resolves the import of the specified identifier. Expects the identifier to resolve
+ * to a fine-grained import declaration with import specifiers.
+ */
+function getSpecificImportOfIdentifier(node, typeChecker) {
+    const symbol = typeChecker.getSymbolAtLocation(node);
+    if (!symbol || !symbol.declarations || !symbol.declarations.length) {
+        return null;
+    }
+    const declaration = symbol.declarations[0];
+    if (!ts.isImportSpecifier(declaration)) {
+        return null;
+    }
+    // Since the declaration is an import specifier, we can walk up three times to get a reference
+    // to the import declaration node (NamedImports -> ImportClause -> ImportDeclaration).
+    const importDecl = declaration.parent.parent.parent;
+    if (!ts.isStringLiteral(importDecl.moduleSpecifier)) {
+        return null;
+    }
+    return {
+        moduleName: importDecl.moduleSpecifier.text,
+        symbolName: declaration.propertyName ? declaration.propertyName.text : declaration.name.text
+    };
+}
+/**
+ * Resolves the import of the specified identifier. Expects the identifier to
+ * resolve to a namespaced import declaration. e.g. "import * as core from ...".
+ */
+function getImportOfNamespacedIdentifier(node, typeChecker) {
+    const symbol = typeChecker.getSymbolAtLocation(node);
+    if (!symbol || !symbol.declarations || !symbol.declarations.length) {
+        return null;
+    }
+    const declaration = symbol.declarations[0];
+    if (!ts.isNamespaceImport(declaration)) {
+        return null;
+    }
+    // Since the declaration is a namespace import, we can walk up three times to get a reference
+    // to the import declaration node (NamespaceImport -> ImportClause -> ImportDeclaration).
+    const importDecl = declaration.parent.parent;
+    if (!ts.isStringLiteral(importDecl.moduleSpecifier)) {
+        return null;
+    }
+    return importDecl.moduleSpecifier.text;
+}
+/**
+ * Gets the root identifier of a qualified type chain. For example: "core.GestureConfig"
+ * will return the "core" identifier. Allowing us to find the import of "core".
+ */
+function getQualifiedNameRoot(name) {
+    while (ts.isQualifiedName(name.left)) {
+        name = name.left;
+    }
+    return ts.isIdentifier(name.left) ? name.left : null;
+}
+/**
+ * Gets the root identifier of a property access chain. For example: "core.GestureConfig"
+ * will return the "core" identifier. Allowing us to find the import of "core".
+ */
+function getPropertyAccessRoot(node) {
+    while (ts.isPropertyAccessExpression(node.expression)) {
+        node = node.expression;
+    }
+    return ts.isIdentifier(node.expression) ? node.expression : null;
+}

package/schematics/component-migration/utils/typescript/parse_tsconfig.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @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';
+export declare function parseTsconfigFile(tsconfigPath: string, basePath: string): ts.ParsedCommandLine;

package/schematics/component-migration/utils/typescript/parse_tsconfig.js

@@ -0,0 +1,29 @@
+"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 = parseTsconfigFile;
+const tslib_1 = require("tslib");
+const path = tslib_1.__importStar(require("path"));
+const ts = tslib_1.__importStar(require("typescript"));
+function parseTsconfigFile(tsconfigPath, basePath) {
+    const { config } = ts.readConfigFile(tsconfigPath, ts.sys.readFile);
+    const parseConfigHost = {
+        useCaseSensitiveFileNames: ts.sys.useCaseSensitiveFileNames,
+        fileExists: ts.sys.fileExists,
+        readDirectory: ts.sys.readDirectory,
+        readFile: ts.sys.readFile
+    };
+    // Throw if incorrect arguments are passed to this function. Passing relative base paths
+    // results in root directories not being resolved and in later type checking runtime errors.
+    // More details can be found here: https://github.com/microsoft/TypeScript/issues/37731.
+    if (!path.isAbsolute(basePath)) {
+        throw Error('Unexpected relative base path has been specified.');
+    }
+    return ts.parseJsonConfigFileContent(config, parseConfigHost, basePath, {});
+}

package/schematics/component-migration/utils/typescript/property-name.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @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';
+/**
+ * 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;

package/schematics/component-migration/utils/typescript/property-name.js

@@ -0,0 +1,22 @@
+"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.getPropertyNameText = getPropertyNameText;
+const tslib_1 = require("tslib");
+const ts = tslib_1.__importStar(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;
+}

package/schematics/package.json

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