create-nx-workspace 16.8.0-beta.4 → 16.8.0-beta.5

package/bin/create-nx-workspace.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.commandsObject = void 0;
-const tslib_1 = require("tslib");
 const enquirer = require("enquirer");
 const yargs = require("yargs");
 const chalk = require("chalk");
@@ -83,49 +82,68 @@ exports.commandsObject = yargs
     describe: chalk.dim `Test runner to use for end to end (E2E) tests.`,
     choices: ['cypress', 'playwright', 'none'],
     type: 'string',
-}), yargs_options_1.withNxCloud, yargs_options_1.withCI, yargs_options_1.withAllPrompts, yargs_options_1.withPackageManager, yargs_options_1.withGitOptions), function handler(argv) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        yield main(argv).catch((error) => {
-            const { version } = require('../package.json');
-            output_1.output.error({
-                title: `Something went wrong! v${version}`,
-            });
-            throw error;
+}), yargs_options_1.withNxCloud, yargs_options_1.withCI, yargs_options_1.withAllPrompts, yargs_options_1.withPackageManager, yargs_options_1.withGitOptions), async function handler(argv) {
+    await main(argv).catch((error) => {
+        const { version } = require('../package.json');
+        output_1.output.error({
+            title: `Something went wrong! v${version}`,
         });
+        throw error;
     });
-}, [normalizeArgsMiddleware])
+}, [
+    normalizeArgsMiddleware,
+    normalizeAndWarnOnDeprecatedPreset({
+        // TODO(v18): Remove Empty and Core presets
+        [preset_1.Preset.Core]: preset_1.Preset.NPM,
+        [preset_1.Preset.Empty]: preset_1.Preset.Apps,
+    }),
+])
     .help('help', chalk.dim `Show help`)
     .updateLocale(decorator_1.yargsDecorator)
     .version('version', chalk.dim `Show version`, nx_version_1.nxVersion);
-function main(parsedArgs) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+async function main(parsedArgs) {
+    output_1.output.log({
+        title: `Creating your v${nx_version_1.nxVersion} workspace.`,
+        bodyLines: [
+            'To make sure the command works reliably in all environments, and that the preset is applied correctly,',
+            `Nx will run "${parsedArgs.packageManager} install" several times. Please wait.`,
+        ],
+    });
+    const workspaceInfo = await (0, create_workspace_1.createWorkspace)(parsedArgs.preset, parsedArgs);
+    (0, show_nx_warning_1.showNxWarning)(parsedArgs.name);
+    await (0, ab_testing_1.recordStat)({
+        nxVersion: nx_version_1.nxVersion,
+        command: 'create-nx-workspace',
+        useCloud: parsedArgs.nxCloud,
+        meta: ab_testing_1.messages.codeOfSelectedPromptMessage('nxCloudCreation'),
+    });
+    if (parsedArgs.nxCloud && workspaceInfo.nxCloudInfo) {
+        (0, nx_cloud_1.printNxCloudSuccessMessage)(workspaceInfo.nxCloudInfo);
+    }
+    if ((0, preset_1.isKnownPreset)(parsedArgs.preset)) {
+        (0, point_to_tutorial_and_course_1.pointToTutorialAndCourse)(parsedArgs.preset);
+    }
+    else {
         output_1.output.log({
-            title: `Creating your v${nx_version_1.nxVersion} workspace.`,
-            bodyLines: [
-                'To make sure the command works reliably in all environments, and that the preset is applied correctly,',
-                `Nx will run "${parsedArgs.packageManager} install" several times. Please wait.`,
-            ],
-        });
-        const workspaceInfo = yield (0, create_workspace_1.createWorkspace)(parsedArgs.preset, parsedArgs);
-        (0, show_nx_warning_1.showNxWarning)(parsedArgs.name);
-        yield (0, ab_testing_1.recordStat)({
-            nxVersion: nx_version_1.nxVersion,
-            command: 'create-nx-workspace',
-            useCloud: parsedArgs.nxCloud,
-            meta: ab_testing_1.messages.codeOfSelectedPromptMessage('nxCloudCreation'),
+            title: `Successfully applied preset: ${parsedArgs.preset}`,
         });
-        if (parsedArgs.nxCloud && workspaceInfo.nxCloudInfo) {
-            (0, nx_cloud_1.printNxCloudSuccessMessage)(workspaceInfo.nxCloudInfo);
-        }
-        if ((0, preset_1.isKnownPreset)(parsedArgs.preset)) {
-            (0, point_to_tutorial_and_course_1.pointToTutorialAndCourse)(parsedArgs.preset);
-        }
-        else {
-            output_1.output.log({
-                title: `Successfully applied preset: ${parsedArgs.preset}`,
+    }
+}
+function normalizeAndWarnOnDeprecatedPreset(deprecatedPresets) {
+    return async (args) => {
+        if (!args.preset)
+            return;
+        if (deprecatedPresets[args.preset]) {
+            args.preset = deprecatedPresets[args.preset];
+            output_1.output.addVerticalSeparator();
+            output_1.output.note({
+                title: `The "${args.preset}" preset is deprecated.`,
+                bodyLines: [
+                    `The "${args.preset}" preset will be removed in a future Nx release. Use the "${deprecatedPresets[args.preset]}" preset instead.`,
+                ],
             });
         }
-    });
+    };
 }
 /**
  * This function is used to normalize the arguments passed to the command.
@@ -133,53 +151,51 @@ function main(parsedArgs) {
  * - normalize the preset.
  * @param argv user arguments
  */
-function normalizeArgsMiddleware(argv) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        output_1.output.log({
-            title: "Let's create a new workspace [https://nx.dev/getting-started/intro]",
-        });
+async function normalizeArgsMiddleware(argv) {
+    output_1.output.log({
+        title: "Let's create a new workspace [https://nx.dev/getting-started/intro]",
+    });
+    try {
+        let thirdPartyPreset;
+        // Node options
+        let docker;
         try {
-            let thirdPartyPreset;
-            // Node options
-            let docker;
-            try {
-                thirdPartyPreset = yield (0, get_third_party_preset_1.getThirdPartyPreset)(argv.preset);
-            }
-            catch (e) {
-                output_1.output.error({
-                    title: `Could not find preset "${argv.preset}"`,
-                });
-                process.exit(1);
-            }
-            argv.name = yield determineFolder(argv);
-            if (thirdPartyPreset) {
-                Object.assign(argv, {
-                    preset: thirdPartyPreset,
-                    appName: '',
-                    style: '',
-                });
-            }
-            else {
-                argv.stack = yield determineStack(argv);
-                const presetOptions = yield determinePresetOptions(argv);
-                Object.assign(argv, presetOptions);
-            }
-            const packageManager = yield (0, prompts_1.determinePackageManager)(argv);
-            const defaultBase = yield (0, prompts_1.determineDefaultBase)(argv);
-            const nxCloud = yield (0, prompts_1.determineNxCloud)(argv);
-            const ci = yield (0, prompts_1.determineCI)(argv, nxCloud);
-            Object.assign(argv, {
-                nxCloud,
-                packageManager,
-                defaultBase,
-                ci,
-            });
+            thirdPartyPreset = await (0, get_third_party_preset_1.getThirdPartyPreset)(argv.preset);
         }
         catch (e) {
-            console.error(e);
+            output_1.output.error({
+                title: `Could not find preset "${argv.preset}"`,
+            });
             process.exit(1);
         }
-    });
+        argv.name = await determineFolder(argv);
+        if (thirdPartyPreset) {
+            Object.assign(argv, {
+                preset: thirdPartyPreset,
+                appName: '',
+                style: '',
+            });
+        }
+        else {
+            argv.stack = await determineStack(argv);
+            const presetOptions = await determinePresetOptions(argv);
+            Object.assign(argv, presetOptions);
+        }
+        const packageManager = await (0, prompts_1.determinePackageManager)(argv);
+        const defaultBase = await (0, prompts_1.determineDefaultBase)(argv);
+        const nxCloud = await (0, prompts_1.determineNxCloud)(argv);
+        const ci = await (0, prompts_1.determineCI)(argv, nxCloud);
+        Object.assign(argv, {
+            nxCloud,
+            packageManager,
+            defaultBase,
+            ci,
+        });
+    }
+    catch (e) {
+        console.error(e);
+        process.exit(1);
+    }
 }
 function invariant(predicate, message) {
     if (!predicate) {
@@ -187,583 +203,337 @@ function invariant(predicate, message) {
         process.exit(1);
     }
 }
-function determineFolder(parsedArgs) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        const folderName = parsedArgs._[0]
-            ? parsedArgs._[0].toString()
-            : parsedArgs.name;
-        if (folderName)
-            return folderName;
-        const reply = yield enquirer.prompt([
-            {
-                name: 'folderName',
-                message: `Where would you like to create your workspace?`,
-                initial: 'org',
-                type: 'input',
-            },
-        ]);
-        invariant(reply.folderName, {
-            title: 'Invalid folder name',
-            bodyLines: [`Folder name cannot be empty`],
-        });
-        invariant(!(0, fs_1.existsSync)(reply.folderName), {
-            title: 'That folder is already taken',
-        });
-        return reply.folderName;
+async function determineFolder(parsedArgs) {
+    const folderName = parsedArgs._[0]
+        ? parsedArgs._[0].toString()
+        : parsedArgs.name;
+    if (folderName)
+        return folderName;
+    const reply = await enquirer.prompt([
+        {
+            name: 'folderName',
+            message: `Where would you like to create your workspace?`,
+            initial: 'org',
+            type: 'input',
+        },
+    ]);
+    invariant(reply.folderName, {
+        title: 'Invalid folder name',
+        bodyLines: [`Folder name cannot be empty`],
+    });
+    invariant(!(0, fs_1.existsSync)(reply.folderName), {
+        title: 'That folder is already taken',
     });
+    return reply.folderName;
 }
-function determineStack(parsedArgs) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        if (parsedArgs.preset) {
-            switch (parsedArgs.preset) {
-                case preset_1.Preset.Angular:
-                case preset_1.Preset.AngularStandalone:
-                case preset_1.Preset.AngularMonorepo:
-                    return 'angular';
-                case preset_1.Preset.React:
-                case preset_1.Preset.ReactStandalone:
-                case preset_1.Preset.ReactMonorepo:
-                case preset_1.Preset.NextJs:
-                case preset_1.Preset.NextJsStandalone:
-                    return 'react';
-                case preset_1.Preset.Nest:
-                case preset_1.Preset.NodeStandalone:
-                case preset_1.Preset.Express:
-                    return 'node';
-                case preset_1.Preset.Core:
-                case preset_1.Preset.Empty:
-                case preset_1.Preset.Apps:
-                case preset_1.Preset.NPM:
-                case preset_1.Preset.TS:
-                case preset_1.Preset.TsStandalone:
-                    return 'none';
-                case preset_1.Preset.WebComponents:
-                case preset_1.Preset.ReactNative:
-                case preset_1.Preset.Expo:
-                default:
-                    return 'unknown';
-            }
+async function determineStack(parsedArgs) {
+    if (parsedArgs.preset) {
+        switch (parsedArgs.preset) {
+            case preset_1.Preset.Angular:
+            case preset_1.Preset.AngularStandalone:
+            case preset_1.Preset.AngularMonorepo:
+                return 'angular';
+            case preset_1.Preset.React:
+            case preset_1.Preset.ReactStandalone:
+            case preset_1.Preset.ReactMonorepo:
+            case preset_1.Preset.NextJs:
+            case preset_1.Preset.NextJsStandalone:
+                return 'react';
+            case preset_1.Preset.Nest:
+            case preset_1.Preset.NodeStandalone:
+            case preset_1.Preset.Express:
+                return 'node';
+            case preset_1.Preset.Apps:
+            case preset_1.Preset.NPM:
+            case preset_1.Preset.TS:
+            case preset_1.Preset.TsStandalone:
+                return 'none';
+            case preset_1.Preset.WebComponents:
+            case preset_1.Preset.ReactNative:
+            case preset_1.Preset.Expo:
+            default:
+                return 'unknown';
         }
-        const { stack } = yield enquirer.prompt([
+    }
+    const { stack } = await enquirer.prompt([
+        {
+            name: 'stack',
+            message: `Which stack do you want to use?`,
+            type: 'autocomplete',
+            choices: [
+                {
+                    name: `none`,
+                    message: `None:          Configures a TypeScript/JavaScript project with minimal structure.`,
+                },
+                {
+                    name: `react`,
+                    message: `React:         Configures a React application with your framework of choice.`,
+                },
+                {
+                    name: `angular`,
+                    message: `Angular:       Configures a Angular application with modern tooling.`,
+                },
+                {
+                    name: `node`,
+                    message: `Node:          Configures a Node API application with your framework of choice.`,
+                },
+            ],
+        },
+    ]);
+    return stack;
+}
+async function determinePresetOptions(parsedArgs) {
+    switch (parsedArgs.stack) {
+        case 'none':
+            return determineNoneOptions(parsedArgs);
+        case 'react':
+            return determineReactOptions(parsedArgs);
+        case 'angular':
+            return determineAngularOptions(parsedArgs);
+        case 'node':
+            return determineNodeOptions(parsedArgs);
+        default:
+            return parsedArgs;
+    }
+}
+async function determineNoneOptions(parsedArgs) {
+    let preset;
+    let workspaceType = undefined;
+    let appName = undefined;
+    let js;
+    if (parsedArgs.preset) {
+        preset = parsedArgs.preset;
+    }
+    else {
+        workspaceType = await determinePackageBasedOrIntegratedOrStandalone();
+        if (workspaceType === 'standalone') {
+            preset = preset_1.Preset.TsStandalone;
+        }
+        else if (workspaceType === 'integrated') {
+            preset = preset_1.Preset.Apps;
+        }
+        else {
+            preset = preset_1.Preset.NPM;
+        }
+    }
+    if (parsedArgs.js !== undefined) {
+        js = parsedArgs.js;
+    }
+    else if (preset === preset_1.Preset.TsStandalone) {
+        // Only standalone TS preset generates a default package, so we need to provide --js and --appName options.
+        appName = parsedArgs.name;
+        const reply = await enquirer.prompt([
             {
-                name: 'stack',
-                message: `Which stack do you want to use?`,
+                name: 'ts',
+                message: `Would you like to use TypeScript with this project?`,
                 type: 'autocomplete',
                 choices: [
                     {
-                        name: `none`,
-                        message: `None:          Configures a TypeScript/JavaScript project with minimal structure.`,
-                    },
-                    {
-                        name: `react`,
-                        message: `React:         Configures a React application with your framework of choice.`,
-                    },
-                    {
-                        name: `angular`,
-                        message: `Angular:       Configures a Angular application with modern tooling.`,
+                        name: 'Yes',
                     },
                     {
-                        name: `node`,
-                        message: `Node:          Configures a Node API application with your framework of choice.`,
+                        name: 'No',
                     },
                 ],
+                initial: 'Yes',
             },
         ]);
-        return stack;
-    });
-}
-function determinePresetOptions(parsedArgs) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        switch (parsedArgs.stack) {
-            case 'none':
-                return determineNoneOptions(parsedArgs);
-            case 'react':
-                return determineReactOptions(parsedArgs);
-            case 'angular':
-                return determineAngularOptions(parsedArgs);
-            case 'node':
-                return determineNodeOptions(parsedArgs);
-            default:
-                return parsedArgs;
-        }
-    });
+        js = reply.ts === 'No';
+    }
+    return { preset, js, appName };
 }
-function determineNoneOptions(parsedArgs) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        let preset;
-        let workspaceType = undefined;
-        let appName = undefined;
-        let js;
-        if (parsedArgs.preset) {
-            preset = parsedArgs.preset;
+async function determineReactOptions(parsedArgs) {
+    let preset;
+    let style = undefined;
+    let appName;
+    let bundler = undefined;
+    let e2eTestRunner = undefined;
+    let nextAppDir = false;
+    if (parsedArgs.preset && parsedArgs.preset !== preset_1.Preset.React) {
+        preset = parsedArgs.preset;
+        if (preset === preset_1.Preset.ReactStandalone ||
+            preset === preset_1.Preset.NextJsStandalone) {
+            appName = parsedArgs.appName ?? parsedArgs.name;
         }
         else {
-            workspaceType = yield determinePackageBasedOrIntegratedOrStandalone();
-            if (workspaceType === 'standalone') {
-                preset = preset_1.Preset.TsStandalone;
-            }
-            else if (workspaceType === 'integrated') {
-                preset = preset_1.Preset.Apps;
-            }
-            else {
-                preset = preset_1.Preset.NPM;
-            }
-        }
-        if (parsedArgs.js !== undefined) {
-            js = parsedArgs.js;
+            appName = await determineAppName(parsedArgs);
         }
-        else if (preset === preset_1.Preset.TsStandalone) {
-            // Only standalone TS preset generates a default package, so we need to provide --js and --appName options.
+    }
+    else {
+        const framework = await determineReactFramework(parsedArgs);
+        // React Native and Expo only support integrated monorepos for now.
+        // TODO(jack): Add standalone support for React Native and Expo.
+        const workspaceType = framework === 'react-native' || framework === 'expo'
+            ? 'integrated'
+            : await determineStandaloneOrMonorepo();
+        if (workspaceType === 'standalone') {
             appName = parsedArgs.name;
-            const reply = yield enquirer.prompt([
-                {
-                    name: 'ts',
-                    message: `Would you like to use TypeScript with this project?`,
-                    type: 'autocomplete',
-                    choices: [
-                        {
-                            name: 'Yes',
-                        },
-                        {
-                            name: 'No',
-                        },
-                    ],
-                    initial: 'Yes',
-                },
-            ]);
-            js = reply.ts === 'No';
-        }
-        return { preset, js, appName };
-    });
-}
-function determineReactOptions(parsedArgs) {
-    var _a;
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        let preset;
-        let style = undefined;
-        let appName;
-        let bundler = undefined;
-        let e2eTestRunner = undefined;
-        let nextAppDir = false;
-        if (parsedArgs.preset && parsedArgs.preset !== preset_1.Preset.React) {
-            preset = parsedArgs.preset;
-            if (preset === preset_1.Preset.ReactStandalone ||
-                preset === preset_1.Preset.NextJsStandalone) {
-                appName = (_a = parsedArgs.appName) !== null && _a !== void 0 ? _a : parsedArgs.name;
-            }
-            else {
-                appName = yield determineAppName(parsedArgs);
-            }
         }
         else {
-            const framework = yield determineReactFramework(parsedArgs);
-            // React Native and Expo only support integrated monorepos for now.
-            // TODO(jack): Add standalone support for React Native and Expo.
-            const workspaceType = framework === 'react-native' || framework === 'expo'
-                ? 'integrated'
-                : yield determineStandaloneOrMonorepo();
-            if (workspaceType === 'standalone') {
-                appName = parsedArgs.name;
-            }
-            else {
-                appName = yield determineAppName(parsedArgs);
-            }
-            if (framework === 'nextjs') {
-                if (workspaceType === 'standalone') {
-                    preset = preset_1.Preset.NextJsStandalone;
-                }
-                else {
-                    preset = preset_1.Preset.NextJs;
-                }
-            }
-            else if (framework === 'react-native') {
-                preset = preset_1.Preset.ReactNative;
-            }
-            else if (framework === 'expo') {
-                preset = preset_1.Preset.Expo;
-            }
-            else {
-                if (workspaceType === 'standalone') {
-                    preset = preset_1.Preset.ReactStandalone;
-                }
-                else {
-                    preset = preset_1.Preset.ReactMonorepo;
-                }
-            }
-        }
-        if (preset === preset_1.Preset.ReactStandalone || preset === preset_1.Preset.ReactMonorepo) {
-            bundler = yield determineReactBundler(parsedArgs);
-            e2eTestRunner = yield determineE2eTestRunner(parsedArgs);
-        }
-        else if (preset === preset_1.Preset.NextJs || preset === preset_1.Preset.NextJsStandalone) {
-            nextAppDir = yield determineNextAppDir(parsedArgs);
-            e2eTestRunner = yield determineE2eTestRunner(parsedArgs);
-        }
-        if (parsedArgs.style) {
-            style = parsedArgs.style;
-        }
-        else if (preset === preset_1.Preset.ReactStandalone ||
-            preset === preset_1.Preset.ReactMonorepo ||
-            preset === preset_1.Preset.NextJs ||
-            preset === preset_1.Preset.NextJsStandalone) {
-            const reply = yield enquirer.prompt([
-                {
-                    name: 'style',
-                    message: `Default stylesheet format`,
-                    initial: 'css',
-                    type: 'autocomplete',
-                    choices: [
-                        {
-                            name: 'css',
-                            message: 'CSS',
-                        },
-                        {
-                            name: 'scss',
-                            message: 'SASS(.scss)       [ http://sass-lang.com   ]',
-                        },
-                        {
-                            name: 'less',
-                            message: 'LESS              [ http://lesscss.org     ]',
-                        },
-                        {
-                            name: 'styled-components',
-                            message: 'styled-components [ https://styled-components.com            ]',
-                        },
-                        {
-                            name: '@emotion/styled',
-                            message: 'emotion           [ https://emotion.sh                       ]',
-                        },
-                        {
-                            name: 'styled-jsx',
-                            message: 'styled-jsx        [ https://www.npmjs.com/package/styled-jsx ]',
-                        },
-                    ],
-                },
-            ]);
-            style = reply.style;
+            appName = await determineAppName(parsedArgs);
         }
-        return { preset, style, appName, bundler, nextAppDir, e2eTestRunner };
-    });
-}
-function determineAngularOptions(parsedArgs) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        let preset;
-        let style;
-        let appName;
-        let standaloneApi;
-        let e2eTestRunner = undefined;
-        let routing;
-        if (parsedArgs.preset && parsedArgs.preset !== preset_1.Preset.Angular) {
-            preset = parsedArgs.preset;
-            if (preset === preset_1.Preset.AngularStandalone) {
-                appName = parsedArgs.name;
-            }
-            else {
-                appName = yield determineAppName(parsedArgs);
-            }
-        }
-        else {
-            const workspaceType = yield determineStandaloneOrMonorepo();
+        if (framework === 'nextjs') {
             if (workspaceType === 'standalone') {
-                preset = preset_1.Preset.AngularStandalone;
-                appName = parsedArgs.name;
+                preset = preset_1.Preset.NextJsStandalone;
             }
             else {
-                preset = preset_1.Preset.AngularMonorepo;
-                appName = yield determineAppName(parsedArgs);
+                preset = preset_1.Preset.NextJs;
             }
         }
-        if (parsedArgs.style) {
-            style = parsedArgs.style;
+        else if (framework === 'react-native') {
+            preset = preset_1.Preset.ReactNative;
         }
-        else {
-            const reply = yield enquirer.prompt([
-                {
-                    name: 'style',
-                    message: `Default stylesheet format`,
-                    initial: 'css',
-                    type: 'autocomplete',
-                    choices: [
-                        {
-                            name: 'css',
-                            message: 'CSS',
-                        },
-                        {
-                            name: 'scss',
-                            message: 'SASS(.scss)       [ http://sass-lang.com   ]',
-                        },
-                        {
-                            name: 'less',
-                            message: 'LESS              [ http://lesscss.org     ]',
-                        },
-                    ],
-                },
-            ]);
-            style = reply.style;
-        }
-        e2eTestRunner = yield determineE2eTestRunner(parsedArgs);
-        if (parsedArgs.standaloneApi !== undefined) {
-            standaloneApi = parsedArgs.standaloneApi;
+        else if (framework === 'expo') {
+            preset = preset_1.Preset.Expo;
         }
         else {
-            const reply = yield enquirer.prompt([
-                {
-                    name: 'standaloneApi',
-                    message: 'Would you like to use Standalone Components in your application?',
-                    type: 'autocomplete',
-                    choices: [
-                        {
-                            name: 'No',
-                        },
-                        {
-                            name: 'Yes',
-                        },
-                    ],
-                    initial: 'No',
-                },
-            ]);
-            standaloneApi = reply.standaloneApi === 'Yes';
-        }
-        if (parsedArgs.routing !== undefined) {
-            routing = parsedArgs.routing;
-        }
-        else {
-            const reply = yield enquirer.prompt([
-                {
-                    name: 'routing',
-                    message: 'Would you like to add routing?',
-                    type: 'autocomplete',
-                    choices: [
-                        {
-                            name: 'Yes',
-                        },
-                        {
-                            name: 'No',
-                        },
-                    ],
-                    initial: 'Yes',
-                },
-            ]);
-            routing = reply.routing === 'Yes';
-        }
-        return { preset, style, appName, standaloneApi, routing, e2eTestRunner };
-    });
-}
-function determineNodeOptions(parsedArgs) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        let preset;
-        let appName;
-        let framework;
-        let docker;
-        if (parsedArgs.preset) {
-            preset = parsedArgs.preset;
-            if (preset === preset_1.Preset.Nest ||
-                preset === preset_1.Preset.Express ||
-                preset === preset_1.Preset.NodeMonorepo) {
-                appName = yield determineAppName(parsedArgs);
-            }
-            else {
-                appName = parsedArgs.name;
-            }
-            if (preset === preset_1.Preset.NodeStandalone || preset === preset_1.Preset.NodeMonorepo) {
-                framework = yield determineNodeFramework(parsedArgs);
-            }
-            else {
-                framework = 'none';
-            }
-        }
-        else {
-            framework = yield determineNodeFramework(parsedArgs);
-            const workspaceType = yield determineStandaloneOrMonorepo();
             if (workspaceType === 'standalone') {
-                preset = preset_1.Preset.NodeStandalone;
-                appName = parsedArgs.name;
+                preset = preset_1.Preset.ReactStandalone;
             }
             else {
-                preset = preset_1.Preset.NodeMonorepo;
-                appName = yield determineAppName(parsedArgs);
+                preset = preset_1.Preset.ReactMonorepo;
             }
         }
-        if (parsedArgs.docker !== undefined) {
-            docker = parsedArgs.docker;
-        }
-        else {
-            const reply = yield enquirer.prompt([
-                {
-                    name: 'docker',
-                    message: 'Would you like to generate a Dockerfile? [https://docs.docker.com/]',
-                    type: 'autocomplete',
-                    choices: [
-                        {
-                            name: 'Yes',
-                            hint: 'I want to generate a Dockerfile',
-                        },
-                        {
-                            name: 'No',
-                        },
-                    ],
-                    initial: 'No',
-                },
-            ]);
-            docker = reply.docker === 'Yes';
-        }
-        return {
-            preset,
-            appName,
-            framework,
-            docker,
-        };
-    });
-}
-function determinePackageBasedOrIntegratedOrStandalone() {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        const { workspaceType } = yield enquirer.prompt([
+    }
+    if (preset === preset_1.Preset.ReactStandalone || preset === preset_1.Preset.ReactMonorepo) {
+        bundler = await determineReactBundler(parsedArgs);
+        e2eTestRunner = await determineE2eTestRunner(parsedArgs);
+    }
+    else if (preset === preset_1.Preset.NextJs || preset === preset_1.Preset.NextJsStandalone) {
+        nextAppDir = await determineNextAppDir(parsedArgs);
+        e2eTestRunner = await determineE2eTestRunner(parsedArgs);
+    }
+    if (parsedArgs.style) {
+        style = parsedArgs.style;
+    }
+    else if (preset === preset_1.Preset.ReactStandalone ||
+        preset === preset_1.Preset.ReactMonorepo ||
+        preset === preset_1.Preset.NextJs ||
+        preset === preset_1.Preset.NextJsStandalone) {
+        const reply = await enquirer.prompt([
             {
+                name: 'style',
+                message: `Default stylesheet format`,
+                initial: 'css',
                 type: 'autocomplete',
-                name: 'workspaceType',
-                message: `Package-based monorepo, integrated monorepo, or standalone project?`,
-                initial: 'package-based',
                 choices: [
                     {
-                        name: 'package-based',
-                        message: 'Package-based Monorepo:     Nx makes it fast, but lets you run things your way.',
+                        name: 'css',
+                        message: 'CSS',
                     },
                     {
-                        name: 'integrated',
-                        message: 'Integrated Monorepo:        Nx creates a monorepo that contains multiple projects.',
+                        name: 'scss',
+                        message: 'SASS(.scss)       [ http://sass-lang.com   ]',
                     },
                     {
-                        name: 'standalone',
-                        message: 'Standalone:                 Nx creates a single project and makes it fast.',
+                        name: 'less',
+                        message: 'LESS              [ http://lesscss.org     ]',
                     },
-                ],
-            },
-        ]);
-        invariant(workspaceType, {
-            title: 'Invalid workspace type',
-            bodyLines: [
-                `It must be one of the following: standalone, integrated. Got ${workspaceType}`,
-            ],
-        });
-        return workspaceType;
-    });
-}
-function determineStandaloneOrMonorepo() {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        const { workspaceType } = yield enquirer.prompt([
-            {
-                type: 'autocomplete',
-                name: 'workspaceType',
-                message: `Integrated monorepo, or standalone project?`,
-                initial: 'standalone',
-                choices: [
                     {
-                        name: 'integrated',
-                        message: 'Integrated Monorepo:  Nx creates a monorepo that contains multiple projects.',
+                        name: 'styled-components',
+                        message: 'styled-components [ https://styled-components.com            ]',
                     },
                     {
-                        name: 'standalone',
-                        message: 'Standalone:           Nx creates a single project and makes it fast.',
+                        name: '@emotion/styled',
+                        message: 'emotion           [ https://emotion.sh                       ]',
+                    },
+                    {
+                        name: 'styled-jsx',
+                        message: 'styled-jsx        [ https://www.npmjs.com/package/styled-jsx ]',
                     },
                 ],
             },
         ]);
-        invariant(workspaceType, {
-            title: 'Invalid workspace type',
-            bodyLines: [
-                `It must be one of the following: standalone, integrated. Got ${workspaceType}`,
-            ],
-        });
-        return workspaceType;
-    });
-}
-function determineAppName(parsedArgs) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        if (parsedArgs.appName)
-            return parsedArgs.appName;
-        const { appName } = yield enquirer.prompt([
-            {
-                name: 'appName',
-                message: `Application name`,
-                type: 'input',
-                initial: parsedArgs.name,
-            },
-        ]);
-        invariant(appName, {
-            title: 'Invalid name',
-            bodyLines: [`Name cannot be empty`],
-        });
-        return appName;
-    });
+        style = reply.style;
+    }
+    return { preset, style, appName, bundler, nextAppDir, e2eTestRunner };
 }
-function determineReactFramework(parsedArgs) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        const reply = yield enquirer.prompt([
+async function determineAngularOptions(parsedArgs) {
+    let preset;
+    let style;
+    let appName;
+    let standaloneApi;
+    let e2eTestRunner = undefined;
+    let routing;
+    if (parsedArgs.preset && parsedArgs.preset !== preset_1.Preset.Angular) {
+        preset = parsedArgs.preset;
+        if (preset === preset_1.Preset.AngularStandalone) {
+            appName = parsedArgs.name;
+        }
+        else {
+            appName = await determineAppName(parsedArgs);
+        }
+    }
+    else {
+        const workspaceType = await determineStandaloneOrMonorepo();
+        if (workspaceType === 'standalone') {
+            preset = preset_1.Preset.AngularStandalone;
+            appName = parsedArgs.name;
+        }
+        else {
+            preset = preset_1.Preset.AngularMonorepo;
+            appName = await determineAppName(parsedArgs);
+        }
+    }
+    if (parsedArgs.style) {
+        style = parsedArgs.style;
+    }
+    else {
+        const reply = await enquirer.prompt([
             {
-                name: 'framework',
-                message: 'What framework would you like to use?',
+                name: 'style',
+                message: `Default stylesheet format`,
+                initial: 'css',
                 type: 'autocomplete',
                 choices: [
                     {
-                        name: 'none',
-                        message: 'None',
-                        hint: '         I only want react and react-dom',
+                        name: 'css',
+                        message: 'CSS',
                     },
                     {
-                        name: 'nextjs',
-                        message: 'Next.js       [ https://nextjs.org/      ]',
+                        name: 'scss',
+                        message: 'SASS(.scss)       [ http://sass-lang.com   ]',
                     },
                     {
-                        name: 'expo',
-                        message: 'Expo          [ https://expo.io/         ]',
-                    },
-                    {
-                        name: 'react-native',
-                        message: 'React Native  [ https://reactnative.dev/ ]',
+                        name: 'less',
+                        message: 'LESS              [ http://lesscss.org     ]',
                     },
                 ],
-                initial: 'none',
             },
         ]);
-        return reply.framework;
-    });
-}
-function determineReactBundler(parsedArgs) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        if (parsedArgs.bundler)
-            return parsedArgs.bundler;
-        const reply = yield enquirer.prompt([
+        style = reply.style;
+    }
+    e2eTestRunner = await determineE2eTestRunner(parsedArgs);
+    if (parsedArgs.standaloneApi !== undefined) {
+        standaloneApi = parsedArgs.standaloneApi;
+    }
+    else {
+        const reply = await enquirer.prompt([
             {
-                name: 'bundler',
-                message: `Which bundler would you like to use?`,
+                name: 'standaloneApi',
+                message: 'Would you like to use Standalone Components in your application?',
                 type: 'autocomplete',
                 choices: [
                     {
-                        name: 'vite',
-                        message: 'Vite    [ https://vitejs.dev/     ]',
-                    },
-                    {
-                        name: 'webpack',
-                        message: 'Webpack [ https://webpack.js.org/ ]',
+                        name: 'No',
                     },
                     {
-                        name: 'rspack',
-                        message: 'Rspack  [ https://www.rspack.dev/ ]',
+                        name: 'Yes',
                     },
                 ],
+                initial: 'No',
             },
         ]);
-        return reply.bundler;
-    });
-}
-function determineNextAppDir(parsedArgs) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        if (parsedArgs.nextAppDir !== undefined)
-            return parsedArgs.nextAppDir;
-        const reply = yield enquirer.prompt([
+        standaloneApi = reply.standaloneApi === 'Yes';
+    }
+    if (parsedArgs.routing !== undefined) {
+        routing = parsedArgs.routing;
+    }
+    else {
+        const reply = await enquirer.prompt([
             {
-                name: 'nextAppDir',
-                message: 'Would you like to use the App Router (recommended)?',
+                name: 'routing',
+                message: 'Would you like to add routing?',
                 type: 'autocomplete',
                 choices: [
                     {
@@ -776,70 +546,283 @@ function determineNextAppDir(parsedArgs) {
                 initial: 'Yes',
             },
         ]);
-        return reply.nextAppDir === 'Yes';
-    });
+        routing = reply.routing === 'Yes';
+    }
+    return { preset, style, appName, standaloneApi, routing, e2eTestRunner };
 }
-function determineNodeFramework(parsedArgs) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        if (parsedArgs.framework)
-            return parsedArgs.framework;
-        const reply = yield enquirer.prompt([
+async function determineNodeOptions(parsedArgs) {
+    let preset;
+    let appName;
+    let framework;
+    let docker;
+    if (parsedArgs.preset) {
+        preset = parsedArgs.preset;
+        if (preset === preset_1.Preset.Nest ||
+            preset === preset_1.Preset.Express ||
+            preset === preset_1.Preset.NodeMonorepo) {
+            appName = await determineAppName(parsedArgs);
+        }
+        else {
+            appName = parsedArgs.name;
+        }
+        if (preset === preset_1.Preset.NodeStandalone || preset === preset_1.Preset.NodeMonorepo) {
+            framework = await determineNodeFramework(parsedArgs);
+        }
+        else {
+            framework = 'none';
+        }
+    }
+    else {
+        framework = await determineNodeFramework(parsedArgs);
+        const workspaceType = await determineStandaloneOrMonorepo();
+        if (workspaceType === 'standalone') {
+            preset = preset_1.Preset.NodeStandalone;
+            appName = parsedArgs.name;
+        }
+        else {
+            preset = preset_1.Preset.NodeMonorepo;
+            appName = await determineAppName(parsedArgs);
+        }
+    }
+    if (parsedArgs.docker !== undefined) {
+        docker = parsedArgs.docker;
+    }
+    else {
+        const reply = await enquirer.prompt([
             {
-                message: 'What framework should be used?',
+                name: 'docker',
+                message: 'Would you like to generate a Dockerfile? [https://docs.docker.com/]',
                 type: 'autocomplete',
-                name: 'framework',
                 choices: [
                     {
-                        name: 'none',
-                        message: 'None',
-                    },
-                    {
-                        name: 'express',
-                        message: 'Express [ https://expressjs.com/ ]',
-                    },
-                    {
-                        name: 'fastify',
-                        message: 'Fastify [ https://www.fastify.dev/ ]',
-                    },
-                    {
-                        name: 'koa',
-                        message: 'Koa     [ https://koajs.com/      ]',
+                        name: 'Yes',
+                        hint: 'I want to generate a Dockerfile',
                     },
                     {
-                        name: 'nest',
-                        message: 'NestJs  [ https://nestjs.com/     ]',
+                        name: 'No',
                     },
                 ],
+                initial: 'No',
             },
         ]);
-        return reply.framework;
+        docker = reply.docker === 'Yes';
+    }
+    return {
+        preset,
+        appName,
+        framework,
+        docker,
+    };
+}
+async function determinePackageBasedOrIntegratedOrStandalone() {
+    const { workspaceType } = await enquirer.prompt([
+        {
+            type: 'autocomplete',
+            name: 'workspaceType',
+            message: `Package-based monorepo, integrated monorepo, or standalone project?`,
+            initial: 'package-based',
+            choices: [
+                {
+                    name: 'package-based',
+                    message: 'Package-based Monorepo:     Nx makes it fast, but lets you run things your way.',
+                },
+                {
+                    name: 'integrated',
+                    message: 'Integrated Monorepo:        Nx creates a monorepo that contains multiple projects.',
+                },
+                {
+                    name: 'standalone',
+                    message: 'Standalone:                 Nx creates a single project and makes it fast.',
+                },
+            ],
+        },
+    ]);
+    invariant(workspaceType, {
+        title: 'Invalid workspace type',
+        bodyLines: [
+            `It must be one of the following: standalone, integrated. Got ${workspaceType}`,
+        ],
     });
+    return workspaceType;
 }
-function determineE2eTestRunner(parsedArgs) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        if (parsedArgs.e2eTestRunner)
-            return parsedArgs.e2eTestRunner;
-        const reply = yield enquirer.prompt([
-            {
-                message: 'Test runner to use for end to end (E2E) tests',
-                type: 'autocomplete',
-                name: 'e2eTestRunner',
-                choices: [
-                    {
-                        name: 'cypress',
-                        message: 'Cypress [ https://www.cypress.io/ ]',
-                    },
-                    {
-                        name: 'playwright',
-                        message: 'Playwright [ https://playwright.dev/ ]',
-                    },
-                    {
-                        name: 'none',
-                        message: 'None',
-                    },
-                ],
-            },
-        ]);
-        return reply.e2eTestRunner;
+async function determineStandaloneOrMonorepo() {
+    const { workspaceType } = await enquirer.prompt([
+        {
+            type: 'autocomplete',
+            name: 'workspaceType',
+            message: `Integrated monorepo, or standalone project?`,
+            initial: 'standalone',
+            choices: [
+                {
+                    name: 'integrated',
+                    message: 'Integrated Monorepo:  Nx creates a monorepo that contains multiple projects.',
+                },
+                {
+                    name: 'standalone',
+                    message: 'Standalone:           Nx creates a single project and makes it fast.',
+                },
+            ],
+        },
+    ]);
+    invariant(workspaceType, {
+        title: 'Invalid workspace type',
+        bodyLines: [
+            `It must be one of the following: standalone, integrated. Got ${workspaceType}`,
+        ],
+    });
+    return workspaceType;
+}
+async function determineAppName(parsedArgs) {
+    if (parsedArgs.appName)
+        return parsedArgs.appName;
+    const { appName } = await enquirer.prompt([
+        {
+            name: 'appName',
+            message: `Application name`,
+            type: 'input',
+            initial: parsedArgs.name,
+        },
+    ]);
+    invariant(appName, {
+        title: 'Invalid name',
+        bodyLines: [`Name cannot be empty`],
     });
+    return appName;
+}
+async function determineReactFramework(parsedArgs) {
+    const reply = await enquirer.prompt([
+        {
+            name: 'framework',
+            message: 'What framework would you like to use?',
+            type: 'autocomplete',
+            choices: [
+                {
+                    name: 'none',
+                    message: 'None',
+                    hint: '         I only want react and react-dom',
+                },
+                {
+                    name: 'nextjs',
+                    message: 'Next.js       [ https://nextjs.org/      ]',
+                },
+                {
+                    name: 'expo',
+                    message: 'Expo          [ https://expo.io/         ]',
+                },
+                {
+                    name: 'react-native',
+                    message: 'React Native  [ https://reactnative.dev/ ]',
+                },
+            ],
+            initial: 'none',
+        },
+    ]);
+    return reply.framework;
+}
+async function determineReactBundler(parsedArgs) {
+    if (parsedArgs.bundler)
+        return parsedArgs.bundler;
+    const reply = await enquirer.prompt([
+        {
+            name: 'bundler',
+            message: `Which bundler would you like to use?`,
+            type: 'autocomplete',
+            choices: [
+                {
+                    name: 'vite',
+                    message: 'Vite    [ https://vitejs.dev/     ]',
+                },
+                {
+                    name: 'webpack',
+                    message: 'Webpack [ https://webpack.js.org/ ]',
+                },
+                {
+                    name: 'rspack',
+                    message: 'Rspack  [ https://www.rspack.dev/ ]',
+                },
+            ],
+        },
+    ]);
+    return reply.bundler;
+}
+async function determineNextAppDir(parsedArgs) {
+    if (parsedArgs.nextAppDir !== undefined)
+        return parsedArgs.nextAppDir;
+    const reply = await enquirer.prompt([
+        {
+            name: 'nextAppDir',
+            message: 'Would you like to use the App Router (recommended)?',
+            type: 'autocomplete',
+            choices: [
+                {
+                    name: 'Yes',
+                },
+                {
+                    name: 'No',
+                },
+            ],
+            initial: 'Yes',
+        },
+    ]);
+    return reply.nextAppDir === 'Yes';
+}
+async function determineNodeFramework(parsedArgs) {
+    if (parsedArgs.framework)
+        return parsedArgs.framework;
+    const reply = await enquirer.prompt([
+        {
+            message: 'What framework should be used?',
+            type: 'autocomplete',
+            name: 'framework',
+            choices: [
+                {
+                    name: 'none',
+                    message: 'None',
+                },
+                {
+                    name: 'express',
+                    message: 'Express [ https://expressjs.com/ ]',
+                },
+                {
+                    name: 'fastify',
+                    message: 'Fastify [ https://www.fastify.dev/ ]',
+                },
+                {
+                    name: 'koa',
+                    message: 'Koa     [ https://koajs.com/      ]',
+                },
+                {
+                    name: 'nest',
+                    message: 'NestJs  [ https://nestjs.com/     ]',
+                },
+            ],
+        },
+    ]);
+    return reply.framework;
+}
+async function determineE2eTestRunner(parsedArgs) {
+    if (parsedArgs.e2eTestRunner)
+        return parsedArgs.e2eTestRunner;
+    const reply = await enquirer.prompt([
+        {
+            message: 'Test runner to use for end to end (E2E) tests',
+            type: 'autocomplete',
+            name: 'e2eTestRunner',
+            choices: [
+                {
+                    name: 'cypress',
+                    message: 'Cypress [ https://www.cypress.io/ ]',
+                },
+                {
+                    name: 'playwright',
+                    message: 'Playwright [ https://playwright.dev/ ]',
+                },
+                {
+                    name: 'none',
+                    message: 'None',
+                },
+            ],
+        },
+    ]);
+    return reply.e2eTestRunner;
 }