@ohos-ports/nx 23.2.1-beta.0 → 23.3.0-beta.0

package/dist/src/command-line/init/implementation/add-nx-to-nest.js

@@ -0,0 +1,350 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addNxToNest = addNxToNest;
+const prompt_helpers_1 = require("../../../utils/prompt-helpers");
+const node_fs_1 = require("node:fs");
+const path_1 = require("path");
+const format_1 = require("./format");
+const fileutils_1 = require("../../../utils/fileutils");
+const output_1 = require("../../../utils/output");
+const package_manager_1 = require("../../../utils/package-manager");
+const utils_1 = require("./utils");
+const versions_1 = require("../../../utils/versions");
+const connect_to_nx_cloud_1 = require("../../nx-cloud/connect/connect-to-nx-cloud");
+async function addNxToNest(options, packageJson) {
+    const repoRoot = process.cwd();
+    output_1.output.log({ title: '🐳 Nx initialization' });
+    // we check upstream that nest-cli.json exists before it reaches this function
+    // so it is guaranteed to be here
+    const nestCliJson = (0, fileutils_1.readJsonFile)((0, path_1.join)(repoRoot, 'nest-cli.json'));
+    const nestCLIConfiguration = mergeWithDefaultConfig(nestCliJson);
+    // For NestJS CLI Monorepo, this property is always "true"
+    if (nestCLIConfiguration.monorepo) {
+        // TODO: update message for NestJS CLI Monorepo support
+        output_1.output.log({ title: 'NestCLI Monorepo support is coming soon' });
+        return;
+    }
+    const isJS = nestCLIConfiguration.language === 'js';
+    const nestCacheableScripts = ['build', 'lint', 'test'];
+    const nestIgnoreScripts = [
+        'start',
+        'start:dev',
+        'start:debug',
+        'test:cov',
+        'test:watch',
+    ];
+    const scripts = Object.keys(packageJson.scripts ?? {}).filter((s) => {
+        if (nestCacheableScripts.includes(s) || nestIgnoreScripts.includes(s)) {
+            return false;
+        }
+        return !s.startsWith('pre') && !s.startsWith('post');
+    });
+    let cacheableOperations;
+    let scriptOutputs = {};
+    let nxCloudChoice;
+    if (options.interactive && scripts.length > 0) {
+        output_1.output.log({
+            title: '🧑‍🔧 Please answer the following questions about the scripts found in your package.json in order to generate task runner configuration',
+        });
+        cacheableOperations = await (0, prompt_helpers_1.multiselectPrompt)({
+            message: 'Which of the following scripts are cacheable? (Produce the same output given the same input, e.g. build, test and lint usually are, serve and start are not)',
+            choices: scripts,
+        });
+        for (const scriptName of cacheableOperations) {
+            scriptOutputs[scriptName] = await (0, prompt_helpers_1.textPrompt)({
+                message: `Does the "${scriptName}" script create any outputs? If not, leave blank, otherwise provide a path (e.g. dist, lib, build, coverage)`,
+            });
+        }
+        nxCloudChoice =
+            options.nxCloud === true
+                ? 'yes'
+                : options.nxCloud === false
+                    ? 'skip'
+                    : await (0, connect_to_nx_cloud_1.connectExistingRepoToNxCloudPrompt)();
+    }
+    else {
+        cacheableOperations = options.cacheable ?? [];
+        nxCloudChoice =
+            options.nxCloud === true
+                ? 'yes'
+                : options.nxCloud === false
+                    ? 'skip'
+                    : options.interactive
+                        ? await (0, connect_to_nx_cloud_1.connectExistingRepoToNxCloudPrompt)()
+                        : 'skip';
+    }
+    (0, utils_1.createNxJsonFile)(repoRoot, [], [...cacheableOperations, ...nestCacheableScripts], scriptOutputs);
+    const packageManager = (0, package_manager_1.detectPackageManager)(repoRoot);
+    const pmc = (0, package_manager_1.getPackageManagerCommand)(packageManager);
+    (0, utils_1.updateGitIgnore)(repoRoot);
+    (0, utils_1.addDepsToPackageJson)(repoRoot, packageManager);
+    addNestPluginToPackageJson(repoRoot);
+    (0, utils_1.markRootPackageJsonAsNxProjectLegacy)(repoRoot, cacheableOperations, pmc);
+    createProjectJson(repoRoot, packageJson, nestCLIConfiguration);
+    removeFile(repoRoot, 'nest-cli.json');
+    updatePackageJsonScripts(repoRoot, isJS);
+    if (!isJS) {
+        updateTsConfig(repoRoot, nestCLIConfiguration.sourceRoot);
+    }
+    output_1.output.log({ title: '📦 Installing dependencies' });
+    (0, utils_1.runInstall)(repoRoot, packageManager, pmc);
+    if (nxCloudChoice === 'yes') {
+        output_1.output.log({ title: '🛠️ Setting up Nx Cloud' });
+        await (0, utils_1.initCloud)('nx-init-nest');
+    }
+}
+function addNestPluginToPackageJson(repoRoot) {
+    const path = (0, path_1.join)(repoRoot, `package.json`);
+    const json = (0, fileutils_1.readJsonFile)(path);
+    json.devDependencies['@nx/nest'] = versions_1.nxVersion;
+    json.devDependencies['@nx/jest'] = versions_1.nxVersion;
+    (0, fileutils_1.writeJsonFile)(path, json);
+    (0, format_1.recordInitWrite)(path);
+}
+function createProjectJson(repoRoot, packageJson, nestCLIOptions) {
+    const packageName = packageJson.name;
+    const path = (0, path_1.join)(repoRoot, 'project.json');
+    const json = {
+        name: packageName,
+        root: '.',
+        sourceRoot: nestCLIOptions.sourceRoot,
+        projectType: 'application',
+        targets: {},
+        tags: [],
+    };
+    json['$schema'] = 'node_modules/nx/schemas/project-schema.json';
+    if (nestCLIOptions.language !== 'js') {
+        json.targets['serve'] = {
+            executor: '@nx/js:node',
+            options: {
+                buildTarget: `${packageName}:build`,
+            },
+        };
+        if (nestCLIOptions.webpackOptions) {
+            json.targets['build'] = {
+                executor: '@nx/webpack:webpack',
+                outputs: ['{options.outputPath}'],
+                options: {
+                    target: 'node',
+                    compiler: 'tsc',
+                    outputPath: `dist/${packageName}`,
+                    main: (0, path_1.join)(nestCLIOptions.sourceRoot, nestCLIOptions.entryFile),
+                    tsConfig: 'tsconfig.build.json',
+                },
+                configurations: {
+                    production: {
+                        optimization: true,
+                        extractLicenses: true,
+                        inspect: false,
+                    },
+                },
+            };
+            json.targets['serve'] = {
+                ...json.targets['serve'],
+                configurations: {
+                    production: {
+                        buildTarget: `${packageName}:build:production`,
+                    },
+                },
+            };
+        }
+        else {
+            json.targets['build'] = {
+                executor: '@nx/js:tsc',
+                outputs: ['{options.outputPath}'],
+                options: {
+                    outputPath: `dist/${packageName}`,
+                    main: (0, path_1.join)(nestCLIOptions.sourceRoot, nestCLIOptions.entryFile),
+                    tsConfig: 'tsconfig.build.json',
+                },
+            };
+            json.targets['serve'] = {
+                ...json.targets['serve'],
+                configurations: {
+                    debug: {
+                        inspect: 'inspect',
+                    },
+                },
+            };
+            // if we're using nrwl/js, then we add nrwl/js analyzeSourceFiles to nx.json
+            addNrwlJsPluginsConfig(repoRoot);
+        }
+        // lint
+        json.targets['lint'] = {
+            executor: '@nx/eslint:lint',
+            options: {
+                lintFilePatterns: ['./src', './test'],
+            },
+        };
+        // test and e2e
+        addJestTargets(repoRoot, packageName, json, packageJson);
+    }
+    (0, fileutils_1.writeJsonFile)(path, json);
+    (0, format_1.recordInitWrite)(path);
+}
+function getJestOptions(isE2E, repoRoot, packageName, existingOptions) {
+    // try get the e2e json if we find it
+    if (isE2E && !existingOptions) {
+        try {
+            existingOptions = (0, fileutils_1.readJsonFile)((0, path_1.join)(repoRoot, 'test/jest-e2e.json'));
+            removeFile(repoRoot, 'test/jest-e2e.json');
+        }
+        catch (e) { }
+    }
+    const jestOptions = existingOptions || {
+        moduleFileExtensions: ['js', 'json', 'ts'],
+        testEnvironment: 'node',
+        transform: { '^.+\\.(t|j)s$': 'ts-jest' },
+    };
+    jestOptions['displayName'] = isE2E ? `${packageName}-e2e` : packageName;
+    // remove rootDir and testRegex, we'll use testMatch instead since we'll have the
+    // root jest.preset.js in the root instead of 'src'
+    delete jestOptions['rootDir'];
+    delete jestOptions['testRegex'];
+    jestOptions['testMatch'] = isE2E
+        ? ['<rootDir>/test/**/?(*.)+(e2e-spec|e2e-test).[jt]s?(x)']
+        : ['<rootDir>/src/**/*(*.)@(spec|test).[jt]s?(x)'];
+    // set coverage directory for unit test
+    if (!isE2E) {
+        jestOptions['coverageDirectory'] = `./coverage/${packageName}`;
+    }
+    return jestOptions;
+}
+function tryCreateJestPreset(repoRoot) {
+    const jestPresetPath = (0, path_1.join)(repoRoot, 'jest.preset.js');
+    if (!(0, fileutils_1.fileExists)(jestPresetPath)) {
+        (0, node_fs_1.writeFileSync)(jestPresetPath, `
+const nxPreset = require('@nx/jest/preset').default;
+module.exports = {...nxPreset};
+`, 'utf8');
+        (0, format_1.recordInitWrite)(jestPresetPath);
+        return true;
+    }
+    return false;
+}
+function addJestTargets(repoRoot, packageName, projectJson, packageJson) {
+    const unitTestOptions = getJestOptions(false, repoRoot, packageName, packageJson['jest']);
+    const unitTestConfigPath = 'jest.config.ts';
+    const e2eTestOptions = getJestOptions(true, repoRoot, packageName);
+    const e2eTestConfigPath = 'jest.e2e-config.ts';
+    const isPresetCreated = tryCreateJestPreset(repoRoot);
+    if (isPresetCreated) {
+        unitTestOptions['preset'] = e2eTestOptions['preset'] = './jest.preset.js';
+    }
+    (0, node_fs_1.writeFileSync)(unitTestConfigPath, `export default ${JSON.stringify(unitTestOptions, null, 2)}`, 'utf8');
+    (0, format_1.recordInitWrite)(unitTestConfigPath);
+    (0, node_fs_1.writeFileSync)(e2eTestConfigPath, `export default ${JSON.stringify(e2eTestOptions, null, 2)}`, 'utf8');
+    (0, format_1.recordInitWrite)(e2eTestConfigPath);
+    projectJson.targets['test'] = {
+        executor: '@nx/jest:jest',
+        outputs: [`{workspaceRoot}/coverage/${packageName}`],
+        options: {
+            passWithNoTests: true,
+            jestConfig: unitTestConfigPath,
+        },
+    };
+    projectJson.targets['e2e'] = {
+        executor: '@nx/jest:jest',
+        options: {
+            passWithNoTests: true,
+            jestConfig: e2eTestConfigPath,
+        },
+    };
+    // remove jest options from package.json
+    delete packageJson['jest'];
+}
+function addNrwlJsPluginsConfig(repoRoot) {
+    const path = (0, path_1.join)(repoRoot, 'nx.json');
+    const json = (0, fileutils_1.readJsonFile)(path);
+    if (!json.pluginsConfig) {
+        json.pluginsConfig = {
+            '@nx/js': {
+                analyzeSourceFiles: true,
+            },
+        };
+    }
+    (0, fileutils_1.writeJsonFile)(path, json);
+    (0, format_1.recordInitWrite)(path);
+}
+function updatePackageJsonScripts(repoRoot, isJS) {
+    const path = (0, path_1.join)(repoRoot, `package.json`);
+    const json = (0, fileutils_1.readJsonFile)(path);
+    if (json.scripts['build']) {
+        json.scripts['build'] = 'nx build';
+    }
+    if (json.scripts['lint']) {
+        json.scripts['lint'] = 'nx lint';
+    }
+    if (json.scripts['start:debug']) {
+        json.scripts['start:debug'] = 'nx serve --configuration=debug';
+    }
+    if (json.scripts['test']) {
+        json.scripts['test'] = 'nx test';
+    }
+    if (json.scripts['test:cov']) {
+        delete json.scripts['test:cov'];
+    }
+    if (json.scripts['test:watch']) {
+        delete json.scripts['test:watch'];
+    }
+    if (json.scripts['test:e2e']) {
+        delete json.scripts['test:e2e'];
+        json.scripts['e2e'] = 'nx e2e';
+    }
+    if (!isJS) {
+        if (json.scripts['start']) {
+            json.scripts['start'] = 'nx serve';
+        }
+        if (json.scripts['start:dev']) {
+            // same as nx serve
+            delete json.scripts['start:dev'];
+        }
+    }
+    (0, fileutils_1.writeJsonFile)(path, json);
+    (0, format_1.recordInitWrite)(path);
+}
+function updateTsConfig(repoRoot, sourceRoot) {
+    const path = (0, path_1.join)(repoRoot, `tsconfig.build.json`);
+    const json = (0, fileutils_1.readJsonFile)(path);
+    // we add include to the tsconfig.build because our executor runs tsc with
+    // generated tsconfig which is in `tmp/**.generated.json`. By default, tsc
+    // cannot find the default source files anymore.
+    if (!json.include)
+        json.include = [];
+    json.include.push(`${sourceRoot}/**/*.ts`);
+    (0, fileutils_1.writeJsonFile)(path, json);
+    (0, format_1.recordInitWrite)(path);
+}
+function removeFile(repoRoot, file) {
+    const path = (0, path_1.join)(repoRoot, file);
+    (0, node_fs_1.unlinkSync)(path);
+}
+function mergeWithDefaultConfig(config) {
+    const defaultNestCliConfigurations = {
+        language: 'ts',
+        sourceRoot: 'src',
+        collection: '@nestjs/schematics',
+        entryFile: 'main',
+        projects: {},
+        monorepo: false,
+        compilerOptions: {
+            tsConfigPath: 'tsconfig.build.json',
+            webpack: false,
+            webpackConfigPath: 'webpack.config.js',
+            plugins: [],
+            assets: [],
+        },
+        generateOptions: {},
+    };
+    if (config.compilerOptions) {
+        return {
+            ...defaultNestCliConfigurations,
+            ...config,
+            compilerOptions: {
+                ...defaultNestCliConfigurations.compilerOptions,
+                ...config.compilerOptions,
+            },
+        };
+    }
+    return { ...defaultNestCliConfigurations, ...config };
+}

package/dist/src/command-line/init/implementation/add-nx-to-npm-repo.d.ts

@@ -0,0 +1,6 @@
+import { InitArgs } from '../init-v1';
+type Options = Pick<InitArgs, 'nxCloud' | 'interactive' | 'cacheable'> & {
+    legacy?: boolean;
+};
+export declare function addNxToNpmRepo(options: Options, guided?: boolean): Promise<void>;
+export {};

package/dist/src/command-line/init/implementation/add-nx-to-npm-repo.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addNxToNpmRepo = addNxToNpmRepo;
+const prompt_helpers_1 = require("../../../utils/prompt-helpers");
+const path_1 = require("path");
+const fileutils_1 = require("../../../utils/fileutils");
+const output_1 = require("../../../utils/output");
+const package_manager_1 = require("../../../utils/package-manager");
+const utils_1 = require("./utils");
+const connect_to_nx_cloud_1 = require("../../nx-cloud/connect/connect-to-nx-cloud");
+async function addNxToNpmRepo(options, guided = true) {
+    const repoRoot = process.cwd();
+    output_1.output.log({ title: '🐳 Nx initialization' });
+    let cacheableOperations;
+    let scriptOutputs = {};
+    let nxCloudChoice;
+    const packageJson = (0, fileutils_1.readJsonFile)('package.json');
+    const scripts = Object.keys(packageJson.scripts ?? {}).filter((s) => !s.startsWith('pre') && !s.startsWith('post'));
+    if (options.interactive && scripts.length > 0 && guided) {
+        output_1.output.log({
+            title: '🧑‍🔧 Please answer the following questions about the scripts found in your package.json in order to generate task runner configuration',
+        });
+        cacheableOperations = await (0, prompt_helpers_1.multiselectPrompt)({
+            message: 'Which of the following scripts are cacheable? (Produce the same output given the same input, e.g. build, test and lint usually are, serve and start are not). You can use spacebar to select one or more scripts.',
+            choices: scripts,
+        });
+        for (const scriptName of cacheableOperations) {
+            scriptOutputs[scriptName] = await (0, prompt_helpers_1.textPrompt)({
+                message: `Does the "${scriptName}" script create any outputs? If not, leave blank, otherwise provide a path (e.g. dist, lib, build, coverage)`,
+            });
+        }
+        nxCloudChoice =
+            options.nxCloud === true
+                ? 'yes'
+                : options.nxCloud === false
+                    ? 'skip'
+                    : await (0, connect_to_nx_cloud_1.connectExistingRepoToNxCloudPrompt)();
+    }
+    else {
+        cacheableOperations = options.cacheable ?? [];
+        nxCloudChoice =
+            options.nxCloud === true
+                ? 'yes'
+                : options.nxCloud === false
+                    ? 'skip'
+                    : options.interactive
+                        ? await (0, connect_to_nx_cloud_1.connectExistingRepoToNxCloudPrompt)()
+                        : 'skip';
+    }
+    (0, utils_1.createNxJsonFile)(repoRoot, [], cacheableOperations, scriptOutputs);
+    const packageManager = (0, package_manager_1.detectPackageManager)(repoRoot);
+    const pmc = (0, package_manager_1.getPackageManagerCommand)(packageManager);
+    (0, utils_1.updateGitIgnore)(repoRoot);
+    (0, utils_1.addDepsToPackageJson)(repoRoot, packageManager);
+    if (options.legacy) {
+        (0, utils_1.markRootPackageJsonAsNxProjectLegacy)(repoRoot, cacheableOperations, pmc);
+    }
+    else {
+        (0, utils_1.markPackageJsonAsNxProject)((0, path_1.join)(repoRoot, 'package.json'));
+    }
+    output_1.output.log({ title: '📦 Installing dependencies' });
+    (0, utils_1.runInstall)(repoRoot, packageManager, pmc);
+    if (nxCloudChoice === 'yes') {
+        output_1.output.log({ title: '🛠️ Setting up Nx Cloud' });
+        await (0, utils_1.initCloud)('nx-init-npm-repo');
+    }
+}

package/dist/src/command-line/init/implementation/add-nx-to-turborepo.d.ts

@@ -0,0 +1,4 @@
+import { InitArgs } from '../init-v1';
+type Options = Pick<InitArgs, 'nxCloud' | 'interactive'>;
+export declare function addNxToTurborepo(_options: Options): Promise<void>;
+export {};

package/dist/src/command-line/init/implementation/add-nx-to-turborepo.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addNxToTurborepo = addNxToTurborepo;
+const node_path_1 = require("node:path");
+const fileutils_1 = require("../../../utils/fileutils");
+const output_1 = require("../../../utils/output");
+const package_manager_1 = require("../../../utils/package-manager");
+const format_1 = require("./format");
+const utils_1 = require("./utils");
+async function addNxToTurborepo(_options) {
+    const repoRoot = process.cwd();
+    output_1.output.log({
+        title: 'Initializing Nx based on your old Turborepo configuration',
+    });
+    output_1.output.log({
+        title: '💡 Did you know?',
+        bodyLines: [
+            '- Turborepo requires you to maintain all your common scripts like "build", "lint", "test" in all your packages, as well as their applicable cache inputs and outputs.',
+            `- Nx is extensible and has plugins for the tools you use to infer all of this for you purely based on that tool's configuration file within your packages.`,
+            '',
+            '  - E.g. the `@nx/vite` plugin will infer the "build" script based on the existence of a vite.config.js file.',
+            '  - Therefore with zero package level config, `nx build my-app` knows to run the `vite build` CLI directly, with all Nx cache inputs and outputs automatically inferred.',
+            '',
+            `NOTE: None of your existing package.json scripts will be modified as part of this initialization process, you can already use them as-is with Nx, but you can learn more about the benefits of Nx's inferred tasks at https://nx.dev/concepts/inferred-tasks`,
+        ],
+    });
+    let nxJson = (0, utils_1.createNxJsonFromTurboJson)((0, fileutils_1.readJsonFile)('turbo.json'));
+    const nxJsonPath = (0, node_path_1.join)(repoRoot, 'nx.json');
+    (0, fileutils_1.writeJsonFile)(nxJsonPath, nxJson);
+    (0, format_1.recordInitWrite)(nxJsonPath);
+    const packageManager = (0, package_manager_1.detectPackageManager)(repoRoot);
+    const pmc = (0, package_manager_1.getPackageManagerCommand)(packageManager);
+    (0, utils_1.updateGitIgnore)(repoRoot);
+    (0, utils_1.addDepsToPackageJson)(repoRoot, packageManager);
+    output_1.output.log({ title: '📦 Installing dependencies' });
+    (0, utils_1.runInstall)(repoRoot, packageManager, pmc);
+}

package/dist/src/command-line/init/implementation/angular/index.d.ts

@@ -0,0 +1,2 @@
+import type { Options } from './types';
+export declare function addNxToAngularCliRepo(options: Options): Promise<void>;

package/dist/src/command-line/init/implementation/angular/index.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addNxToAngularCliRepo = addNxToAngularCliRepo;
+const prompt_helpers_1 = require("../../../../utils/prompt-helpers");
+const path_1 = require("path");
+const fileutils_1 = require("../../../../utils/fileutils");
+const versions_1 = require("../../../../utils/versions");
+const object_sort_1 = require("../../../../utils/object-sort");
+const output_1 = require("../../../../utils/output");
+const package_manager_1 = require("../../../../utils/package-manager");
+const package_json_1 = require("../../../../utils/package-json");
+const utils_1 = require("../utils");
+const integrated_workspace_1 = require("./integrated-workspace");
+const legacy_angular_versions_1 = require("./legacy-angular-versions");
+const standalone_workspace_1 = require("./standalone-workspace");
+const connect_to_nx_cloud_1 = require("../../../nx-cloud/connect/connect-to-nx-cloud");
+const format_1 = require("../format");
+const defaultCacheableOperations = [
+    'build',
+    'server',
+    'test',
+    'lint',
+];
+let repoRoot;
+let workspaceTargets;
+async function addNxToAngularCliRepo(options) {
+    repoRoot = process.cwd();
+    output_1.output.log({ title: '🧐 Checking versions compatibility' });
+    const legacyMigrationFn = await (0, legacy_angular_versions_1.getLegacyMigrationFunctionIfApplicable)(repoRoot, options);
+    if (legacyMigrationFn) {
+        output_1.output.log({ title: '💽 Running migration for a legacy Angular version' });
+        await legacyMigrationFn();
+        // The exit skips the caller's drain, so format the recorded writes here.
+        await (0, format_1.formatInitWrites)(repoRoot);
+        process.exit(0);
+    }
+    output_1.output.success({
+        title: '✅ The Angular version is compatible with the latest version of Nx!',
+    });
+    output_1.output.log({ title: '🐳 Nx initialization' });
+    const cacheableOperations = !options.integrated
+        ? await collectCacheableOperations(options)
+        : [];
+    const nxCloudChoice = options.nxCloud === true
+        ? 'yes'
+        : options.nxCloud === false
+            ? 'skip'
+            : options.interactive
+                ? await (0, connect_to_nx_cloud_1.connectExistingRepoToNxCloudPrompt)()
+                : 'skip';
+    output_1.output.log({ title: '📦 Installing dependencies' });
+    installDependencies();
+    output_1.output.log({ title: '📝 Setting up workspace' });
+    await setupWorkspace(cacheableOperations, options.integrated);
+    if (nxCloudChoice === 'yes') {
+        output_1.output.log({ title: '🛠️ Setting up Nx Cloud' });
+        await (0, utils_1.initCloud)('nx-init-angular');
+    }
+}
+async function collectCacheableOperations(options) {
+    let cacheableOperations;
+    workspaceTargets = getWorkspaceTargets();
+    const defaultCacheableTargetsInWorkspace = defaultCacheableOperations.filter((t) => workspaceTargets.includes(t));
+    if (options.interactive && workspaceTargets.length > 0) {
+        output_1.output.log({
+            title: '🧑‍🔧 Please answer the following questions about the targets found in your angular.json in order to generate task runner configuration',
+        });
+        cacheableOperations = await (0, prompt_helpers_1.multiselectPrompt)({
+            message: 'Which of the following targets are cacheable? (Produce the same output given the same input, e.g. build, test and lint usually are, serve and start are not)',
+            choices: workspaceTargets,
+            initialValues: defaultCacheableTargetsInWorkspace,
+        });
+    }
+    else {
+        cacheableOperations =
+            options.cacheable ?? defaultCacheableTargetsInWorkspace;
+    }
+    return cacheableOperations;
+}
+function installDependencies() {
+    const packageManager = (0, package_manager_1.detectPackageManager)(repoRoot);
+    (0, utils_1.addDepsToPackageJson)(repoRoot, packageManager);
+    addPluginDependencies();
+    (0, utils_1.runInstall)(repoRoot, packageManager);
+}
+function addPluginDependencies() {
+    const packageJsonPath = (0, path_1.join)(repoRoot, 'package.json');
+    const packageJson = (0, fileutils_1.readJsonFile)(packageJsonPath);
+    packageJson.devDependencies ??= {};
+    packageJson.devDependencies['@nx/angular'] = versions_1.nxVersion;
+    packageJson.devDependencies['@nx/workspace'] = versions_1.nxVersion;
+    const peerDepsToInstall = [
+        '@angular-devkit/core',
+        '@angular-devkit/schematics',
+        '@schematics/angular',
+    ];
+    const angularCliVersion = (0, package_json_1.getDependencyVersionFromPackageJson)('@angular/cli', repoRoot, packageJson) ??
+        (0, package_json_1.getDependencyVersionFromPackageJson)('@angular-devkit/build-angular', repoRoot, packageJson) ??
+        (0, package_json_1.getDependencyVersionFromPackageJson)('@angular/build', repoRoot, packageJson);
+    for (const dep of peerDepsToInstall) {
+        if (!packageJson.devDependencies[dep] && !packageJson.dependencies?.[dep]) {
+            packageJson.devDependencies[dep] = angularCliVersion;
+        }
+    }
+    packageJson.devDependencies = (0, object_sort_1.sortObjectByKeys)(packageJson.devDependencies);
+    (0, fileutils_1.writeJsonFile)(packageJsonPath, packageJson);
+    (0, format_1.recordInitWrite)(packageJsonPath);
+}
+async function setupWorkspace(cacheableOperations, isIntegratedMigration) {
+    (0, utils_1.updateGitIgnore)(repoRoot);
+    if (isIntegratedMigration) {
+        (0, integrated_workspace_1.setupIntegratedWorkspace)();
+    }
+    else {
+        await (0, standalone_workspace_1.setupStandaloneWorkspace)(repoRoot, cacheableOperations, workspaceTargets);
+    }
+}
+function getWorkspaceTargets() {
+    const { projects } = (0, fileutils_1.readJsonFile)((0, path_1.join)(repoRoot, 'angular.json'));
+    const targets = new Set();
+    for (const project of Object.values(projects ?? {})) {
+        for (const target of Object.keys(project.architect ?? {})) {
+            targets.add(target);
+        }
+    }
+    return Array.from(targets);
+}

package/dist/src/command-line/init/implementation/angular/integrated-workspace.d.ts

@@ -0,0 +1 @@
+export declare function setupIntegratedWorkspace(): void;

package/dist/src/command-line/init/implementation/angular/integrated-workspace.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupIntegratedWorkspace = setupIntegratedWorkspace;
+const child_process_1 = require("../../../../utils/child-process");
+function setupIntegratedWorkspace() {
+    (0, child_process_1.runNxSync)(`g @nx/angular:ng-add`, {
+        stdio: [0, 1, 2],
+    });
+}

package/dist/src/command-line/init/implementation/angular/legacy-angular-versions.d.ts

@@ -0,0 +1,2 @@
+import type { Options } from './types';
+export declare function getLegacyMigrationFunctionIfApplicable(repoRoot: string, options: Options): Promise<() => Promise<void> | null>;