@depup/nx 22.5.4-depup.0

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

@@ -0,0 +1,345 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addNxToNest = addNxToNest;
+const enquirer = require("enquirer");
+const node_fs_1 = require("node:fs");
+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 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 useNxCloud;
+    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 enquirer.prompt([
+            {
+                type: 'multiselect',
+                name: 'cacheableOperations',
+                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,
+                /**
+                 * limit is missing from the interface but it limits the amount of options shown
+                 */
+                limit: process.stdout.rows - 4, // 4 leaves room for the header above, the prompt and some whitespace
+            },
+        ])).cacheableOperations;
+        for (const scriptName of cacheableOperations) {
+            scriptOutputs[scriptName] = (await enquirer.prompt([
+                {
+                    type: 'input',
+                    name: scriptName,
+                    message: `Does the "${scriptName}" script create any outputs? If not, leave blank, otherwise provide a path (e.g. dist, lib, build, coverage)`,
+                },
+            ]))[scriptName];
+        }
+        useNxCloud =
+            options.nxCloud ?? (await (0, connect_to_nx_cloud_1.connectExistingRepoToNxCloudPrompt)());
+    }
+    else {
+        cacheableOperations = options.cacheable ?? [];
+        useNxCloud =
+            options.nxCloud ??
+                (options.interactive
+                    ? await (0, connect_to_nx_cloud_1.connectExistingRepoToNxCloudPrompt)()
+                    : false);
+    }
+    (0, utils_1.createNxJsonFile)(repoRoot, [], [...cacheableOperations, ...nestCacheableScripts], scriptOutputs);
+    const pmc = (0, package_manager_1.getPackageManagerCommand)();
+    (0, utils_1.updateGitIgnore)(repoRoot);
+    (0, utils_1.addDepsToPackageJson)(repoRoot);
+    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);
+    if (useNxCloud) {
+        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);
+}
+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);
+}
+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');
+        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, node_fs_1.writeFileSync)(e2eTestConfigPath, `export default ${JSON.stringify(e2eTestOptions, null, 2)}`, 'utf8');
+    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);
+}
+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);
+}
+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);
+}
+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/src/command-line/init/implementation/add-nx-to-npm-repo.d.ts

@@ -0,0 +1,7 @@
+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 {};
+//# sourceMappingURL=add-nx-to-npm-repo.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"add-nx-to-npm-repo.d.ts","sourceRoot":"","sources":["../../../../../../../packages/nx/src/command-line/init/implementation/add-nx-to-npm-repo.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAetC,KAAK,OAAO,GAAG,IAAI,CAAC,QAAQ,EAAE,SAAS,GAAG,aAAa,GAAG,WAAW,CAAC,GAAG;IACvE,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF,wBAAsB,cAAc,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,GAAE,OAAc,iBAgF5E"}

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

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addNxToNpmRepo = addNxToNpmRepo;
+const enquirer = require("enquirer");
+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 useNxCloud;
+    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 enquirer.prompt([
+            {
+                type: 'multiselect',
+                name: 'cacheableOperations',
+                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,
+                /**
+                 * limit is missing from the interface but it limits the amount of options shown
+                 */
+                limit: process.stdout.rows - 4, // 4 leaves room for the header above, the prompt and some whitespace
+            },
+        ])).cacheableOperations;
+        for (const scriptName of cacheableOperations) {
+            // eslint-disable-next-line no-await-in-loop
+            scriptOutputs[scriptName] = (await enquirer.prompt([
+                {
+                    type: 'input',
+                    name: scriptName,
+                    message: `Does the "${scriptName}" script create any outputs? If not, leave blank, otherwise provide a path (e.g. dist, lib, build, coverage)`,
+                },
+            ]))[scriptName];
+        }
+        useNxCloud =
+            options.nxCloud ?? (await (0, connect_to_nx_cloud_1.connectExistingRepoToNxCloudPrompt)());
+    }
+    else {
+        cacheableOperations = options.cacheable ?? [];
+        useNxCloud =
+            options.nxCloud ??
+                (options.interactive
+                    ? await (0, connect_to_nx_cloud_1.connectExistingRepoToNxCloudPrompt)()
+                    : false);
+    }
+    (0, utils_1.createNxJsonFile)(repoRoot, [], cacheableOperations, scriptOutputs);
+    const pmc = (0, package_manager_1.getPackageManagerCommand)();
+    (0, utils_1.updateGitIgnore)(repoRoot);
+    (0, utils_1.addDepsToPackageJson)(repoRoot);
+    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, pmc);
+    if (useNxCloud) {
+        output_1.output.log({ title: '🛠️ Setting up Nx Cloud' });
+        await (0, utils_1.initCloud)('nx-init-npm-repo');
+    }
+}

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

@@ -0,0 +1,5 @@
+import { InitArgs } from '../init-v1';
+type Options = Pick<InitArgs, 'nxCloud' | 'interactive'>;
+export declare function addNxToTurborepo(_options: Options): Promise<void>;
+export {};
+//# sourceMappingURL=add-nx-to-turborepo.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"add-nx-to-turborepo.d.ts","sourceRoot":"","sources":["../../../../../../../packages/nx/src/command-line/init/implementation/add-nx-to-turborepo.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAQtC,KAAK,OAAO,GAAG,IAAI,CAAC,QAAQ,EAAE,SAAS,GAAG,aAAa,CAAC,CAAC;AAEzD,wBAAsB,gBAAgB,CAAC,QAAQ,EAAE,OAAO,iBAgDvD"}

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

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addNxToTurborepo = addNxToTurborepo;
+const node_fs_1 = require("node:fs");
+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 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');
+    // Turborepo workspaces usually have prettier installed, so try and match the formatting before writing the file
+    try {
+        const prettier = await Promise.resolve().then(() => require('prettier'));
+        const config = await prettier.resolveConfig(repoRoot);
+        (0, node_fs_1.writeFileSync)(nxJsonPath, 
+        // @ts-ignore - Always await prettier.format, in modern versions it's async
+        await prettier.format(JSON.stringify(nxJson, null, 2), {
+            ...(config ?? {}),
+            parser: 'json',
+        }));
+    }
+    catch (err) {
+        // Apply fallback JSON write
+        (0, fileutils_1.writeJsonFile)(nxJsonPath, nxJson);
+    }
+    const pmc = (0, package_manager_1.getPackageManagerCommand)();
+    (0, utils_1.updateGitIgnore)(repoRoot);
+    (0, utils_1.addDepsToPackageJson)(repoRoot);
+    output_1.output.log({ title: '📦 Installing dependencies' });
+    (0, utils_1.runInstall)(repoRoot, pmc);
+}

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

@@ -0,0 +1,3 @@
+import type { Options } from './types';
+export declare function addNxToAngularCliRepo(options: Options): Promise<void>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/nx/src/command-line/init/implementation/angular/index.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAqB,OAAO,EAAE,MAAM,SAAS,CAAC;AAa1D,wBAAsB,qBAAqB,CAAC,OAAO,EAAE,OAAO,iBAqC3D"}

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

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addNxToAngularCliRepo = addNxToAngularCliRepo;
+const enquirer_1 = require("enquirer");
+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_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 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();
+        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 useNxCloud = options.nxCloud ??
+        (options.interactive ? await (0, connect_to_nx_cloud_1.connectExistingRepoToNxCloudPrompt)() : false);
+    output_1.output.log({ title: '📦 Installing dependencies' });
+    installDependencies();
+    output_1.output.log({ title: '📝 Setting up workspace' });
+    await setupWorkspace(cacheableOperations, options.integrated);
+    if (useNxCloud) {
+        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, enquirer_1.prompt)([
+            {
+                type: 'multiselect',
+                name: 'cacheableOperations',
+                initial: defaultCacheableTargetsInWorkspace,
+                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)',
+                // enquirer mutates the array below, create a new one to avoid it
+                choices: [...workspaceTargets],
+                /**
+                 * limit is missing from the interface but it limits the amount of options shown
+                 */
+                limit: process.stdout.rows - 4, // 4 leaves room for the header above, the prompt and some whitespace
+            },
+        ])).cacheableOperations;
+    }
+    else {
+        cacheableOperations =
+            options.cacheable ?? defaultCacheableTargetsInWorkspace;
+    }
+    return cacheableOperations;
+}
+function installDependencies() {
+    (0, utils_1.addDepsToPackageJson)(repoRoot);
+    addPluginDependencies();
+    (0, utils_1.runInstall)(repoRoot);
+}
+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);
+}
+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/src/command-line/init/implementation/angular/integrated-workspace.d.ts

@@ -0,0 +1,2 @@
+export declare function setupIntegratedWorkspace(): void;
+//# sourceMappingURL=integrated-workspace.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"integrated-workspace.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/nx/src/command-line/init/implementation/angular/integrated-workspace.ts"],"names":[],"mappings":"AAGA,wBAAgB,wBAAwB,IAAI,IAAI,CAO/C"}

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupIntegratedWorkspace = setupIntegratedWorkspace;
+const child_process_1 = require("child_process");
+const package_manager_1 = require("../../../../utils/package-manager");
+function setupIntegratedWorkspace() {
+    const pmc = (0, package_manager_1.getPackageManagerCommand)();
+    (0, child_process_1.execSync)(`${pmc.exec} nx g @nx/angular:ng-add`, {
+        stdio: [0, 1, 2],
+        windowsHide: false,
+    });
+}

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

@@ -0,0 +1,3 @@
+import type { Options } from './types';
+export declare function getLegacyMigrationFunctionIfApplicable(repoRoot: string, options: Options): Promise<() => Promise<void> | null>;
+//# sourceMappingURL=legacy-angular-versions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"legacy-angular-versions.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/nx/src/command-line/init/implementation/angular/legacy-angular-versions.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAmBvC,wBAAsB,sCAAsC,CAC1D,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,OAAO,GACf,OAAO,CAAC,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,CAqGrC"}