@nx/angular 0.0.0-pr-22179-271588f

package/src/generators/ng-add/migrators/projects/lib.migrator.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LibMigrator = void 0;
+const devkit_1 = require("@nx/devkit");
+const devkit_2 = require("@nx/devkit");
+const utilities_1 = require("../../utilities");
+const builders_1 = require("../builders");
+const project_migrator_1 = require("./project.migrator");
+const supportedBuilderMigrators = [
+    builders_1.AngularDevkitNgPackagrMigrator,
+    builders_1.AngularDevkitKarmaMigrator,
+    builders_1.AngularEslintLintMigrator,
+];
+class LibMigrator extends project_migrator_1.ProjectMigrator {
+    constructor(tree, options, project, logger) {
+        super(tree, options, {}, project, 'libs', logger, supportedBuilderMigrators);
+    }
+    async migrate() {
+        if (this.skipMigration === true) {
+            return;
+        }
+        await super.migrate();
+        await this.updateProjectConfiguration();
+        this.moveProjectFiles();
+        for (const builderMigrator of this.builderMigrators ?? []) {
+            await builderMigrator.migrate();
+        }
+    }
+    validate() {
+        const errors = [...(super.validate() ?? [])];
+        for (const builderMigrator of this.builderMigrators) {
+            errors.push(...(builderMigrator.validate() ?? []));
+        }
+        return errors.length ? errors : null;
+    }
+    moveProjectFiles() {
+        this.moveDir(this.project.oldRoot, this.project.newRoot);
+    }
+    async updateProjectConfiguration() {
+        (0, utilities_1.convertToNxProject)(this.tree, this.project.name);
+        this.moveFile((0, devkit_1.joinPathFragments)(this.project.oldRoot, 'project.json'), (0, devkit_1.joinPathFragments)(this.project.newRoot, 'project.json'));
+        this.projectConfig.root = this.project.newRoot;
+        this.projectConfig.sourceRoot = this.project.newSourceRoot;
+        if (!this.projectConfig.targets ||
+            !Object.keys(this.projectConfig.targets).length) {
+            this.logger.warn('The project does not have any targets configured. This might not be an issue. Skipping updating targets.');
+        }
+        (0, devkit_2.updateProjectConfiguration)(this.tree, this.project.name, {
+            ...this.projectConfig,
+        });
+    }
+}
+exports.LibMigrator = LibMigrator;

package/src/generators/ng-add/migrators/projects/project.migrator.d.ts

@@ -0,0 +1,25 @@
+import type { Tree } from '@nx/devkit';
+import type { GeneratorOptions } from '../../schema';
+import type { MigrationProjectConfiguration, Target, ValidationResult, WorkspaceRootFileTypesInfo } from '../../utilities';
+import { Logger } from '../../utilities';
+import type { BuilderMigrator, BuilderMigratorClassType } from '../builders';
+import { Migrator } from '../migrator';
+export declare class ProjectMigrator<TargetType extends string = string> extends Migrator {
+    protected readonly options: GeneratorOptions;
+    protected readonly targets: Record<TargetType, Target>;
+    get projectName(): string;
+    protected builderMigrators: BuilderMigrator[];
+    protected skipMigration: boolean | TargetType[];
+    protected readonly targetNames: Partial<Record<TargetType, string>>;
+    constructor(tree: Tree, options: GeneratorOptions, targets: Record<TargetType, Target>, project: MigrationProjectConfiguration, rootDir: string, logger?: Logger, supportedBuilderMigrators?: BuilderMigratorClassType[]);
+    getWorkspaceRootFileTypesInfo(): WorkspaceRootFileTypesInfo;
+    migrate(): void | Promise<void>;
+    validate(): ValidationResult;
+    protected convertPath(originalPath: string): string;
+    protected moveDir(from: string, to: string): void;
+    protected shouldSkipTargetTypeMigration(targetType: TargetType): boolean;
+    private collectTargetNames;
+    private createBuilderMigrators;
+    private skipProjectMigration;
+    private skipTargetTypeMigration;
+}

package/src/generators/ng-add/migrators/projects/project.migrator.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectMigrator = void 0;
+const devkit_1 = require("@nx/devkit");
+const utilities_1 = require("../../utilities");
+const migrator_1 = require("../migrator");
+class ProjectMigrator extends migrator_1.Migrator {
+    get projectName() {
+        return this.project.name;
+    }
+    constructor(tree, options, targets, project, rootDir, logger, 
+    // TODO(leo): this will replace `targets` and become required once the full
+    // refactor is done.
+    supportedBuilderMigrators) {
+        super(tree, project.config, logger ?? new utilities_1.Logger(project.name));
+        this.options = options;
+        this.targets = targets;
+        // TODO(leo): need to handle targets until all are converted to builder migrators,
+        // at that point, project migrators only care about skipping the whole project migration
+        // and each builder migrator will handle whether it should be skipped or not
+        this.skipMigration = false;
+        this.targetNames = {};
+        this.project = {
+            name: project.name,
+            oldRoot: this.projectConfig.root ?? '',
+            oldSourceRoot: this.projectConfig.sourceRoot ||
+                (0, devkit_1.joinPathFragments)(this.projectConfig.root ?? '', 'src'),
+            newRoot: `${rootDir}/${project.name}`,
+            newSourceRoot: `${rootDir}/${project.name}/src`,
+        };
+        this.collectTargetNames();
+        this.createBuilderMigrators(supportedBuilderMigrators);
+    }
+    getWorkspaceRootFileTypesInfo() {
+        const workspaceRootFileTypesInfo = {
+            eslint: Boolean(this.projectConfig.targets?.lint) ||
+                this.tree.exists(`${this.projectConfig.root}/.eslintrc.json`),
+            karma: this.builderMigrators.some((migrator) => migrator.rootFileType === 'karma' && migrator.isBuilderUsed()),
+        };
+        return workspaceRootFileTypesInfo;
+    }
+    migrate() {
+        const validationResult = this.validate();
+        if (!validationResult) {
+            return;
+        }
+        this.logger.warn((0, utilities_1.getProjectValidationResultMessage)(validationResult));
+    }
+    validate() {
+        const errors = [];
+        // check project root
+        if (this.projectConfig.root === undefined ||
+            this.projectConfig.root === null) {
+            errors.push({
+                message: 'The project root is not defined in the project configuration. The project will be skipped.',
+                hint: 'Make sure to manually migrate its configuration and files or remove the project if it is not valid. ' +
+                    `Alternatively, you could revert the migration, ensure the value for "projects.${this.project.name}.root" ` +
+                    'is set and run the migration again.',
+            });
+            this.skipProjectMigration();
+        }
+        else if (this.projectConfig.root !== '' &&
+            !this.tree.exists(this.projectConfig.root)) {
+            errors.push({
+                message: `The project root "${this.project.oldRoot}" could not be found. The project will be skipped.`,
+                hint: 'Make sure to manually migrate its configuration and files or remove the project if it is not valid. ' +
+                    `Alternatively, you could revert the migration, ensure the value for "projects.${this.project.name}.root" ` +
+                    'is correct and run the migration again.',
+            });
+            this.skipProjectMigration();
+        }
+        // check project source root
+        if (this.projectConfig.sourceRoot &&
+            !this.tree.exists(this.projectConfig.sourceRoot)) {
+            errors.push({
+                message: `The project source root "${this.project.oldSourceRoot}" could not be found. The project will be skipped.`,
+                hint: 'Make sure to manually migrate its configuration and files or remove the project if it is not valid. ' +
+                    `Alternatively, you could revert the migration, ensure the value for "projects.${this.project.name}.sourceRoot" ` +
+                    'is correct and run the migration again.',
+            });
+            this.skipProjectMigration();
+        }
+        // check for usage of unsupported builders
+        const allSupportedBuilders = [
+            ...Object.values(this.targets)
+                .map((x) => x.builders)
+                .flat(),
+        ];
+        allSupportedBuilders.push(...this.builderMigrators.map((migrator) => migrator.builderName));
+        const unsupportedBuilders = [];
+        Object.entries(this.projectConfig.targets ?? {}).forEach(([targetName, target]) => {
+            if (!allSupportedBuilders.includes(target.executor)) {
+                unsupportedBuilders.push([targetName, target.executor]);
+            }
+        });
+        if (unsupportedBuilders.length) {
+            errors.push({
+                messageGroup: {
+                    title: 'Unsupported builders',
+                    messages: unsupportedBuilders.map(([target, builder]) => `The "${target}" target is using a builder "${builder}" that's not currently supported by the automated migration. ` +
+                        'The target will be skipped.'),
+                },
+                hint: 'Make sure to manually migrate the target configuration and any possible associated files. Alternatively, you could ' +
+                    `revert the migration, change the builder to one of the builders supported by the automated migration (${(0, utilities_1.arrayToString)(allSupportedBuilders)}), and run the migration again.`,
+            });
+        }
+        // check for multiple targets for the same type of target
+        const targetTypes = Object.keys(this.targets);
+        const targetsByType = Object.entries(this.projectConfig.targets ?? {}).reduce((acc, [target, { executor }]) => {
+            targetTypes.forEach((targetType) => {
+                if (this.targets[targetType].builders.includes(executor)) {
+                    acc[targetType].push(target);
+                    return acc;
+                }
+            });
+            return acc;
+        }, targetTypes.reduce((acc, targetType) => ({ ...acc, [targetType]: [] }), {}));
+        targetTypes.forEach((targetType) => {
+            if (this.targets[targetType].acceptMultipleDefinitions ||
+                targetsByType[targetType].length <= 1) {
+                return;
+            }
+            errors.push({
+                message: `There is more than one target using a builder that is used to ${targetType} the project (${(0, utilities_1.arrayToString)(targetsByType[targetType])}). This is not currently supported by the automated migration. These targets will be skipped.`,
+                hint: 'Make sure to manually migrate their configuration and any possible associated files.',
+            });
+            this.skipTargetTypeMigration(targetType);
+        });
+        return errors.length ? errors : null;
+    }
+    convertPath(originalPath) {
+        if (originalPath?.startsWith(this.project.oldSourceRoot)) {
+            return (0, devkit_1.joinPathFragments)(this.project.newSourceRoot, originalPath.replace(this.project.oldSourceRoot, ''));
+        }
+        if (originalPath?.startsWith(this.project.oldRoot)) {
+            return (0, devkit_1.joinPathFragments)(this.project.newRoot, originalPath.replace(this.project.oldRoot, ''));
+        }
+        return originalPath;
+    }
+    moveDir(from, to) {
+        (0, devkit_1.visitNotIgnoredFiles)(this.tree, from, (file) => {
+            this.moveFile(file, (0, devkit_1.normalizePath)(file).replace(from, to), true);
+        });
+    }
+    shouldSkipTargetTypeMigration(targetType) {
+        return (Array.isArray(this.skipMigration) &&
+            this.skipMigration.includes(targetType));
+    }
+    collectTargetNames() {
+        const targetTypes = Object.keys(this.targets);
+        Object.entries(this.projectConfig.targets ?? {}).forEach(([targetName, target]) => {
+            targetTypes.forEach((targetType) => {
+                if (!this.targetNames[targetType] &&
+                    this.targets[targetType].builders.includes(target.executor)) {
+                    this.targetNames[targetType] = targetName;
+                }
+            });
+        });
+    }
+    createBuilderMigrators(supportedBuilderMigrators) {
+        if (!supportedBuilderMigrators) {
+            this.builderMigrators = [];
+            return;
+        }
+        this.builderMigrators = supportedBuilderMigrators.map((migratorClass) => new migratorClass(this.tree, this.project, this.projectConfig, this.logger));
+    }
+    skipProjectMigration() {
+        this.skipMigration = true;
+    }
+    skipTargetTypeMigration(targetType) {
+        if (this.skipMigration === true) {
+            return;
+        }
+        if (!Array.isArray(this.skipMigration)) {
+            this.skipMigration = [];
+        }
+        this.skipMigration.push(targetType);
+    }
+}
+exports.ProjectMigrator = ProjectMigrator;

package/src/generators/ng-add/ng-add.d.ts

@@ -0,0 +1,4 @@
+import type { Tree } from '@nx/devkit';
+import type { GeneratorOptions } from './schema';
+export declare function ngAddGenerator(tree: Tree, options: GeneratorOptions): Promise<import("@nx/devkit").GeneratorCallback>;
+export default ngAddGenerator;

package/src/generators/ng-add/ng-add.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ngAddGenerator = void 0;
+const migrate_from_angular_cli_1 = require("./migrate-from-angular-cli");
+async function ngAddGenerator(tree, options) {
+    return await (0, migrate_from_angular_cli_1.migrateFromAngularCli)(tree, options);
+}
+exports.ngAddGenerator = ngAddGenerator;
+exports.default = ngAddGenerator;

package/src/generators/ng-add/schema.d.ts

@@ -0,0 +1,16 @@
+import { Linter } from '@nx/eslint';
+import { E2eTestRunner, UnitTestRunner } from '../../utils/test-runners';
+import type { Styles } from '../utils/types';
+
+export interface GeneratorOptions {
+  defaultBase?: string;
+
+  unitTestRunner?: UnitTestRunner;
+  e2eTestRunner?: E2eTestRunner;
+  skipFormat?: boolean;
+  skipInstall?: boolean;
+  skipPostInstall?: boolean;
+  style?: Styles;
+  linter?: Linter;
+  skipPackageJson?: boolean;
+}

package/src/generators/ng-add/schema.json

@@ -0,0 +1,66 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "NxAngularNgAddGenerator",
+  "title": "Angular plugin initialization",
+  "cli": "nx",
+  "description": "Migrates an Angular CLI workspace to Nx or adds the Angular plugin to an Nx workspace. NOTE: Does not work in the `--dry-run` mode.",
+  "type": "object",
+  "properties": {
+    "defaultBase": {
+      "type": "string",
+      "description": "Default base branch for affected. NOTE: only used if running the generator in an Angular CLI workspace.",
+      "x-priority": "important"
+    },
+    "skipInstall": {
+      "type": "boolean",
+      "description": "Skip installing added packages.",
+      "default": false,
+      "x-priority": "internal"
+    },
+
+    "unitTestRunner": {
+      "type": "string",
+      "enum": ["karma", "jest", "none"],
+      "description": "Test runner to use for unit tests. NOTE: only used if running the generator in an Nx workspace.",
+      "default": "jest"
+    },
+    "e2eTestRunner": {
+      "type": "string",
+      "enum": ["protractor", "cypress", "none"],
+      "description": "Test runner to use for end to end (e2e) tests. NOTE: only used if running the generator in an Nx workspace.",
+      "default": "cypress"
+    },
+    "skipFormat": {
+      "description": "Skip formatting files. NOTE: only used if running the generator in an Nx workspace.",
+      "type": "boolean",
+      "default": false,
+      "x-priority": "internal"
+    },
+    "linter": {
+      "description": "The tool to use for running lint checks. NOTE: only used if running the generator in an Nx workspace.",
+      "type": "string",
+      "enum": ["eslint", "none"],
+      "default": "eslint"
+    },
+    "style": {
+      "description": "The file extension to be used for style files. NOTE: only used if running the generator in an Nx workspace.",
+      "type": "string",
+      "default": "css",
+      "enum": ["css", "scss", "sass", "less"]
+    },
+    "skipPackageJson": {
+      "type": "boolean",
+      "default": false,
+      "description": "Do not add dependencies to `package.json`. NOTE: only used if running the generator in an Nx workspace.",
+      "x-priority": "internal"
+    },
+    "skipPostInstall": {
+      "type": "boolean",
+      "default": false,
+      "description": "Do not add or append `ngcc` to the `postinstall` script in `package.json`. NOTE: only used if running the generator in an Nx workspace.",
+      "x-priority": "internal"
+    }
+  },
+  "additionalProperties": false,
+  "examplesFile": "../../../docs/ng-add-examples.md"
+}

package/src/generators/ng-add/utilities/dependencies.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '@nx/devkit';
+export declare function ensureAngularDevKitPeerDependenciesAreInstalled(tree: Tree): void;

package/src/generators/ng-add/utilities/dependencies.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureAngularDevKitPeerDependenciesAreInstalled = void 0;
+const devkit_1 = require("@nx/devkit");
+const version_utils_1 = require("../../../utils/version-utils");
+const version_utils_2 = require("../../utils/version-utils");
+function ensureAngularDevKitPeerDependenciesAreInstalled(tree) {
+    const packagesToInstall = [
+        '@angular-devkit/core',
+        '@angular-devkit/schematics',
+        '@schematics/angular',
+    ];
+    const { devDependencies, dependencies } = (0, devkit_1.readJson)(tree, 'package.json');
+    let angularCliVersion = devDependencies?.['@angular/cli'] ?? dependencies?.['@angular/cli'];
+    if (!angularCliVersion) {
+        const angularMajorVersion = (0, version_utils_2.getInstalledAngularMajorVersion)(tree);
+        const angularDevkitVersion = (0, version_utils_1.getPkgVersionForAngularMajorVersion)('angularDevkitVersion', angularMajorVersion);
+        angularCliVersion = angularDevkitVersion;
+    }
+    const filteredPackages = packagesToInstall
+        .filter((pkg) => !devDependencies?.[pkg] && !dependencies?.[pkg])
+        .reduce((allPkgs, pkg) => {
+        allPkgs[pkg] = angularCliVersion;
+        return allPkgs;
+    }, {});
+    (0, devkit_1.addDependenciesToPackageJson)(tree, {}, filteredPackages);
+}
+exports.ensureAngularDevKitPeerDependenciesAreInstalled = ensureAngularDevKitPeerDependenciesAreInstalled;

package/src/generators/ng-add/utilities/format-files-task.d.ts

@@ -0,0 +1,2 @@
+import type { Tree } from '@nx/devkit';
+export declare function formatFilesTask(tree: Tree): void;

package/src/generators/ng-add/utilities/format-files-task.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatFilesTask = void 0;
+const child_process_1 = require("nx/src/utils/child-process");
+function formatFilesTask(tree) {
+    if (!tree
+        .listChanges()
+        .some((change) => change.type === 'CREATE' || change.type === 'UPDATE')) {
+        return;
+    }
+    try {
+        (0, child_process_1.runNxSync)(`format`, { cwd: tree.root, stdio: [0, 1, 2] });
+    }
+    catch { }
+}
+exports.formatFilesTask = formatFilesTask;

package/src/generators/ng-add/utilities/index.d.ts

@@ -0,0 +1,7 @@
+export * from './dependencies';
+export * from './format-files-task';
+export * from './logger';
+export * from './projects';
+export * from './types';
+export * from './validation-logging';
+export * from './workspace';

package/src/generators/ng-add/utilities/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./dependencies"), exports);
+tslib_1.__exportStar(require("./format-files-task"), exports);
+tslib_1.__exportStar(require("./logger"), exports);
+tslib_1.__exportStar(require("./projects"), exports);
+tslib_1.__exportStar(require("./types"), exports);
+tslib_1.__exportStar(require("./validation-logging"), exports);
+tslib_1.__exportStar(require("./workspace"), exports);

package/src/generators/ng-add/utilities/logger.d.ts

@@ -0,0 +1,8 @@
+export declare class Logger {
+    private project;
+    private message;
+    constructor(project: string);
+    info(message: string): void;
+    warn(message: string): void;
+    error(message: string): void;
+}

package/src/generators/ng-add/utilities/logger.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+const devkit_1 = require("@nx/devkit");
+class Logger {
+    constructor(project) {
+        this.project = project;
+        this.message = (_, message) => `[${this.project}] ${message}`;
+    }
+    info(message) {
+        devkit_1.logger.info(this.message `${message}`);
+    }
+    warn(message) {
+        devkit_1.logger.warn(this.message `${message}`);
+    }
+    error(message) {
+        devkit_1.logger.error(this.message `${message}`);
+    }
+}
+exports.Logger = Logger;

package/src/generators/ng-add/utilities/projects.d.ts

@@ -0,0 +1,4 @@
+import { Tree } from '@nx/devkit';
+import type { WorkspaceProjects } from './types';
+export declare function getAllProjects(tree: Tree): WorkspaceProjects;
+export declare function convertToNxProject(tree: Tree, projectName: string): void;

package/src/generators/ng-add/utilities/projects.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertToNxProject = exports.getAllProjects = void 0;
+const devkit_1 = require("@nx/devkit");
+const angular_json_1 = require("nx/src/adapter/angular-json");
+function getAllProjects(tree) {
+    const projects = (0, devkit_1.getProjects)(tree);
+    const result = {
+        apps: [],
+        libs: [],
+    };
+    for (const [name, project] of projects) {
+        const migrationProject = {
+            config: project,
+            name,
+        };
+        if (project.projectType === 'library') {
+            result.libs.push(migrationProject);
+        }
+        else {
+            result.apps.push(migrationProject);
+        }
+    }
+    return result;
+}
+exports.getAllProjects = getAllProjects;
+function convertToNxProject(tree, projectName) {
+    const angularJson = (0, devkit_1.readJson)(tree, 'angular.json');
+    const project = (0, angular_json_1.toNewFormat)(angularJson).projects[projectName];
+    project.name = projectName;
+    (0, devkit_1.addProjectConfiguration)(tree, projectName, project);
+    delete angularJson.projects[projectName];
+    (0, devkit_1.writeJson)(tree, 'angular.json', { ...angularJson, version: 1 });
+}
+exports.convertToNxProject = convertToNxProject;

package/src/generators/ng-add/utilities/types.d.ts

@@ -0,0 +1,31 @@
+import type { ProjectConfiguration } from '@nx/devkit';
+export type MigrationProjectConfiguration = {
+    config: ProjectConfiguration;
+    name: string;
+};
+export type WorkspaceProjects = {
+    apps: MigrationProjectConfiguration[];
+    libs: MigrationProjectConfiguration[];
+};
+export type ProjectMigrationInfo = {
+    name: string;
+    oldRoot: string;
+    oldSourceRoot: string;
+    newRoot: string;
+    newSourceRoot: string;
+};
+export type WorkspaceRootFileType = 'karma' | 'eslint';
+export type WorkspaceRootFileTypesInfo = Record<WorkspaceRootFileType, boolean>;
+export type ValidationError = {
+    message?: string;
+    messageGroup?: {
+        title: string;
+        messages: string[];
+    };
+    hint?: string;
+};
+export type ValidationResult = ValidationError[] | null;
+export type Target = {
+    builders: string[];
+    acceptMultipleDefinitions?: boolean;
+};

package/src/generators/ng-add/utilities/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/generators/ng-add/utilities/validation-logging.d.ts

@@ -0,0 +1,3 @@
+import type { ValidationError } from './types';
+export declare function arrayToString(array: string[]): string;
+export declare function getProjectValidationResultMessage(validationResult: ValidationError[]): string;

package/src/generators/ng-add/utilities/validation-logging.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProjectValidationResultMessage = exports.arrayToString = void 0;
+const chalk = require("chalk");
+function arrayToString(array) {
+    if (array.length === 0) {
+        return '';
+    }
+    if (array.length === 1) {
+        return quote(array[0]);
+    }
+    const last = array[array.length - 1];
+    const rest = array.slice(0, array.length - 1);
+    return `${rest.map(quote).join(', ')} and ${quote(last)}`;
+}
+exports.arrayToString = arrayToString;
+function getProjectValidationResultMessage(validationResult) {
+    return `${chalk.bold('Validation results')}:
+
+  ${validationResult
+        .map((error) => getValidationErrorText(error))
+        .join('\n\n  ')}`;
+}
+exports.getProjectValidationResultMessage = getProjectValidationResultMessage;
+function getValidationErrorText({ message, messageGroup, hint, }) {
+    let lines = message
+        ? [`- ${message}`, ...(hint ? [chalk.dim(chalk.italic(`  ${hint}`))] : [])]
+        : [
+            `- ${messageGroup.title}:`,
+            '  - Errors:',
+            ...messageGroup.messages.map((message) => `    - ${message}`),
+            ...(hint ? [chalk.dim(chalk.italic(`  - ${hint}`))] : []),
+        ];
+    return lines.join('\n  ');
+}
+function quote(str) {
+    return `"${str}"`;
+}

package/src/generators/ng-add/utilities/workspace.d.ts

@@ -0,0 +1,17 @@
+import type { Tree } from '@nx/devkit';
+import type { ProjectMigrator } from '../migrators';
+import type { GeneratorOptions } from '../schema';
+import type { WorkspaceRootFileTypesInfo } from './types';
+export declare function validateWorkspace(tree: Tree): void;
+export declare function createNxJson(tree: Tree, options: GeneratorOptions, defaultProject: string | undefined): void;
+export declare function updateWorkspaceConfigDefaults(tree: Tree): void;
+export declare function updateRootTsConfig(tree: Tree): void;
+export declare function updatePackageJson(tree: Tree): void;
+export declare function updateRootEsLintConfig(tree: Tree, existingEsLintConfig: any | undefined, unitTestRunner?: string): Promise<void>;
+export declare function cleanupEsLintPackages(tree: Tree): void;
+export declare function createWorkspaceFiles(tree: Tree): Promise<void>;
+export declare function createRootKarmaConfig(tree: Tree): void;
+export declare function getWorkspaceRootFileTypesInfo(tree: Tree, migrators: ProjectMigrator[]): WorkspaceRootFileTypesInfo;
+export declare function updateVsCodeRecommendedExtensions(tree: Tree): void;
+export declare function deleteAngularJson(tree: Tree): void;
+export declare function deleteGitKeepFilesIfNotNeeded(tree: Tree): void;