create-nx-workspace 17.0.3 → 17.0.4

package/src/create-workspace.js

@@ -11,26 +11,26 @@ const git_1 = require("./utils/git/git");
 const get_third_party_preset_1 = require("./utils/preset/get-third-party-preset");
 const error_utils_1 = require("./utils/error-utils");
 async function createWorkspace(preset, options) {
-    const { packageManager, name, nxCloud, ci = '', skipGit = false, defaultBase = 'main', commit, cliName, } = options;
+    const { packageManager, name, nxCloud, skipGit = false, defaultBase = 'main', commit, cliName, } = options;
     if (cliName) {
         output_1.output.setCliName(cliName ?? 'NX');
     }
     const tmpDir = await (0, create_sandbox_1.createSandbox)(packageManager);
-    // nx new requires preset currently. We should probably make it optional.
+    // nx new requires a preset currently. We should probably make it optional.
     const directory = await (0, create_empty_workspace_1.createEmptyWorkspace)(tmpDir, name, packageManager, { ...options, preset });
     // If the preset is a third-party preset, we need to call createPreset to install it
-    // For first-party presets, it will created by createEmptyWorkspace instead.
+    // For first-party presets, it will be created by createEmptyWorkspace instead.
     // In createEmptyWorkspace, it will call `nx new` -> `@nx/workspace newGenerator` -> `@nx/workspace generatePreset`.
     const thirdPartyPreset = await (0, get_third_party_preset_1.getThirdPartyPreset)(preset);
     if (thirdPartyPreset) {
         await (0, create_preset_1.createPreset)(thirdPartyPreset, options, packageManager, directory);
     }
     let nxCloudInstallRes;
-    if (nxCloud) {
-        nxCloudInstallRes = await (0, nx_cloud_1.setupNxCloud)(directory, packageManager);
-    }
-    if (ci) {
-        await (0, setup_ci_1.setupCI)(directory, ci, packageManager, nxCloud && nxCloudInstallRes?.code === 0);
+    if (nxCloud !== 'skip') {
+        nxCloudInstallRes = await (0, nx_cloud_1.setupNxCloud)(directory, packageManager, nxCloud);
+        if (nxCloud !== 'yes') {
+            await (0, setup_ci_1.setupCI)(directory, nxCloud, packageManager, nxCloudInstallRes?.code === 0);
+        }
     }
     if (!skipGit && commit) {
         try {

package/src/internal-utils/prompts.d.ts

@@ -1,13 +1,9 @@
 import * as yargs from 'yargs';
-import { CI } from '../utils/ci/ci-list';
 import { PackageManager } from '../utils/package-manager';
+import { NxCloud } from '../utils/nx/nx-cloud';
 export declare function determineNxCloud(parsedArgs: yargs.Arguments<{
-    nxCloud: boolean;
-}>): Promise<boolean>;
-export declare function determineCI(parsedArgs: yargs.Arguments<{
-    ci?: CI;
-    allPrompts?: boolean;
-}>, nxCloud: boolean): Promise<string>;
+    nxCloud: NxCloud;
+}>): Promise<NxCloud>;
 export declare function determineDefaultBase(parsedArgs: yargs.Arguments<{
     defaultBase?: string;
 }>): Promise<string>;

package/src/internal-utils/prompts.js

@@ -1,79 +1,44 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.determinePackageManager = exports.determineDefaultBase = exports.determineCI = exports.determineNxCloud = void 0;
+exports.determinePackageManager = exports.determineDefaultBase = exports.determineNxCloud = void 0;
 const ab_testing_1 = require("../utils/nx/ab-testing");
 const output_1 = require("../utils/output");
 const default_base_1 = require("../utils/git/default-base");
 const package_manager_1 = require("../utils/package-manager");
 const string_utils_1 = require("../utils/string-utils");
 const enquirer = require("enquirer");
+const chalk = require("chalk");
 async function determineNxCloud(parsedArgs) {
     if (parsedArgs.nxCloud === undefined) {
-        return enquirer
-            .prompt([
-            {
-                name: 'NxCloud',
-                message: ab_testing_1.messages.getPromptMessage('nxCloudCreation'),
-                type: 'autocomplete',
-                choices: [
-                    {
-                        name: 'Yes',
-                        hint: 'I want faster builds',
-                    },
-                    {
-                        name: 'No',
-                    },
-                ],
-                initial: 'Yes',
-            },
-        ])
-            .then((a) => a.NxCloud === 'Yes');
+        return nxCloudPrompt('setupCI');
     }
     else {
         return parsedArgs.nxCloud;
     }
 }
 exports.determineNxCloud = determineNxCloud;
-async function determineCI(parsedArgs, nxCloud) {
-    if (!nxCloud) {
-        if (parsedArgs.ci) {
-            output_1.output.warn({
-                title: 'Invalid CI value',
-                bodyLines: [
-                    `CI option only works when Nx Cloud is enabled.`,
-                    `The value provided will be ignored.`,
-                ],
-            });
-        }
-        return '';
+async function nxCloudPrompt(key) {
+    const { message, choices, initial, fallback, footer, hint } = ab_testing_1.messages.getPrompt(key);
+    const promptConfig = {
+        name: 'NxCloud',
+        message,
+        type: 'autocomplete',
+        choices,
+        initial,
+    }; // meeroslav: types in enquirer are not up to date
+    if (footer) {
+        promptConfig.footer = () => chalk.dim(footer);
     }
-    if (parsedArgs.ci) {
-        return parsedArgs.ci;
+    if (hint) {
+        promptConfig.hint = () => chalk.dim(hint);
     }
-    if (parsedArgs.allPrompts) {
-        return (enquirer
-            .prompt([
-            {
-                name: 'CI',
-                message: `CI workflow file to generate?      `,
-                type: 'autocomplete',
-                initial: '',
-                choices: [
-                    { message: 'none', name: '' },
-                    { message: 'GitHub Actions', name: 'github' },
-                    { message: 'Circle CI', name: 'circleci' },
-                    { message: 'Azure DevOps', name: 'azure' },
-                ],
-            },
-        ])
-            // enquirer ignores name and value if they are falsy and takes
-            // first field that has a truthy value, so wee need to explicitly
-            // check for none
-            .then((a) => (a.CI !== 'none' ? a.CI : '')));
-    }
-    return '';
+    return enquirer.prompt([promptConfig]).then((a) => {
+        if (fallback && a.NxCloud === fallback.value) {
+            return nxCloudPrompt(fallback.key);
+        }
+        return a.NxCloud;
+    });
 }
-exports.determineCI = determineCI;
 async function determineDefaultBase(parsedArgs) {
     if (parsedArgs.defaultBase) {
         return Promise.resolve(parsedArgs.defaultBase);
@@ -124,7 +89,7 @@ async function determinePackageManager(parsedArgs) {
             {
                 name: 'packageManager',
                 message: `Which package manager to use`,
-                initial: 'npm',
+                initial: 0,
                 type: 'autocomplete',
                 choices: [
                     { name: 'npm', message: 'NPM' },

package/src/internal-utils/yargs-options.d.ts

@@ -1,9 +1,6 @@
 import yargs = require('yargs');
 export declare function withNxCloud<T = unknown>(argv: yargs.Argv<T>): yargs.Argv<T & {
-    nxCloud: boolean | undefined;
-}>;
-export declare function withCI<T = unknown>(argv: yargs.Argv<T>): yargs.Argv<T & {
-    ci: string | undefined;
+    nxCloud: string | undefined;
 }>;
 export declare function withAllPrompts<T = unknown>(argv: yargs.Argv<T>): yargs.Argv<T & {
     allPrompts: boolean;

package/src/internal-utils/yargs-options.js

@@ -1,27 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.withOptions = exports.withGitOptions = exports.withPackageManager = exports.withAllPrompts = exports.withCI = exports.withNxCloud = void 0;
+exports.withOptions = exports.withGitOptions = exports.withPackageManager = exports.withAllPrompts = exports.withNxCloud = void 0;
 const chalk = require("chalk");
-const ci_list_1 = require("../utils/ci/ci-list");
 const ab_testing_1 = require("../utils/nx/ab-testing");
 const package_manager_1 = require("../utils/package-manager");
 function withNxCloud(argv) {
+    const { message } = ab_testing_1.messages.getPrompt('setupCI');
     const result = argv.option('nxCloud', {
-        describe: chalk.dim(ab_testing_1.messages.getPromptMessage('nxCloudCreation')),
-        type: 'boolean',
+        alias: 'ci',
+        describe: chalk.dim(message),
+        choices: ab_testing_1.NxCloudChoices,
+        type: 'string',
     });
     return result;
 }
 exports.withNxCloud = withNxCloud;
-function withCI(argv) {
-    return argv.option('ci', {
-        describe: chalk.dim `Generate a CI workflow file`,
-        choices: ci_list_1.ciList,
-        defaultDescription: '',
-        type: 'string',
-    });
-}
-exports.withCI = withCI;
 function withAllPrompts(argv) {
     return argv.option('allPrompts', {
         alias: 'a',

package/src/utils/nx/ab-testing.d.ts

@@ -1,17 +1,67 @@
+export declare const NxCloudChoices: string[];
 declare const messageOptions: {
-    readonly nxCloudCreation: readonly [{
-        readonly code: "set-up-distributed-caching-ci";
-        readonly message: "Enable distributed caching to make your CI faster";
+    readonly setupCI: readonly [{
+        readonly code: "enable-nx-cloud";
+        readonly message: "Do you want Nx Cloud to make your CI fast?";
+        readonly initial: 1;
+        readonly choices: readonly [{
+            readonly value: "yes";
+            readonly name: "Yes, enable Nx Cloud";
+        }, {
+            readonly value: "github";
+            readonly name: "Yes, configure Nx Cloud for GitHub Actions";
+        }, {
+            readonly value: "circleci";
+            readonly name: "Yes, configure Nx Cloud for Circle CI";
+        }, {
+            readonly value: "skip";
+            readonly name: "Skip for now";
+        }];
+        readonly footer: "\nRead more about remote cache at https://nx.dev/ci/features/remote-cache";
+        readonly hint: "\n(it's free and can be disabled any time)";
+        readonly fallback: undefined;
+    }, {
+        readonly code: "set-up-ci";
+        readonly message: "Set up CI with caching, distribution and test deflaking";
+        readonly initial: 0;
+        readonly choices: readonly [{
+            readonly value: "github";
+            readonly name: "Yes, for GitHub Actions with Nx Cloud";
+        }, {
+            readonly value: "circleci";
+            readonly name: "Yes, for CircleCI with Nx Cloud";
+        }, {
+            readonly value: "skip";
+            readonly name: "Skip for now";
+        }];
+        readonly footer: "\nRead more about CI benefits with Nx at https://nx.dev/ci/intro/ci-with-nx";
+        readonly hint: "\n(it's free and can be disabled any time)";
+        readonly fallback: {
+            readonly value: "skip";
+            readonly key: "setupNxCloud";
+        };
     }];
-    readonly nxCloudMigration: readonly [{
-        readonly code: "make-ci-faster";
-        readonly message: "Enable distributed caching to make your CI faster?";
+    readonly setupNxCloud: readonly [{
+        readonly code: "enable-caching";
+        readonly message: "Would you like remote caching to make your build faster?";
+        readonly initial: 0;
+        readonly choices: readonly [{
+            readonly value: "yes";
+            readonly name: "Yes";
+        }, {
+            readonly value: "skip";
+            readonly name: "Skip for now";
+        }];
+        readonly footer: "\nRead more about remote caching at https://nx.dev/ci/features/remote-cache";
+        readonly hint: "\n(it's free and can be disabled any time)";
+        readonly fallback: undefined;
     }];
 };
-type MessageKey = keyof typeof messageOptions;
+export type MessageKey = keyof typeof messageOptions;
+type MessageData = typeof messageOptions[MessageKey][number];
 export declare class PromptMessages {
     private selectedMessages;
-    getPromptMessage(key: MessageKey): string;
+    getPrompt(key: MessageKey): MessageData;
     codeOfSelectedPromptMessage(key: MessageKey): string;
 }
 export declare const messages: PromptMessages;
@@ -23,6 +73,6 @@ export declare function recordStat(opts: {
     command: string;
     nxVersion: string;
     useCloud: boolean;
-    meta: string;
+    meta: string[];
 }): Promise<void>;
 export {};

package/src/utils/nx/ab-testing.js

@@ -1,18 +1,50 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.recordStat = exports.messages = exports.PromptMessages = void 0;
+exports.recordStat = exports.messages = exports.PromptMessages = exports.NxCloudChoices = void 0;
 const is_ci_1 = require("../ci/is-ci");
+exports.NxCloudChoices = ['yes', 'github', 'circleci', 'skip'];
 const messageOptions = {
-    nxCloudCreation: [
+    setupCI: [
         {
-            code: 'set-up-distributed-caching-ci',
-            message: `Enable distributed caching to make your CI faster`,
+            code: 'enable-nx-cloud',
+            message: `Do you want Nx Cloud to make your CI fast?`,
+            initial: 1,
+            choices: [
+                { value: 'yes', name: 'Yes, enable Nx Cloud' },
+                { value: 'github', name: 'Yes, configure Nx Cloud for GitHub Actions' },
+                { value: 'circleci', name: 'Yes, configure Nx Cloud for Circle CI' },
+                { value: 'skip', name: 'Skip for now' },
+            ],
+            footer: '\nRead more about remote cache at https://nx.dev/ci/features/remote-cache',
+            hint: `\n(it's free and can be disabled any time)`,
+            fallback: undefined,
+        },
+        {
+            code: 'set-up-ci',
+            message: `Set up CI with caching, distribution and test deflaking`,
+            initial: 0,
+            choices: [
+                { value: 'github', name: 'Yes, for GitHub Actions with Nx Cloud' },
+                { value: 'circleci', name: 'Yes, for CircleCI with Nx Cloud' },
+                { value: 'skip', name: 'Skip for now' },
+            ],
+            footer: '\nRead more about CI benefits with Nx at https://nx.dev/ci/intro/ci-with-nx',
+            hint: `\n(it's free and can be disabled any time)`,
+            fallback: { value: 'skip', key: 'setupNxCloud' },
         },
     ],
-    nxCloudMigration: [
+    setupNxCloud: [
         {
-            code: 'make-ci-faster',
-            message: `Enable distributed caching to make your CI faster?`,
+            code: 'enable-caching',
+            message: `Would you like remote caching to make your build faster?`,
+            initial: 0,
+            choices: [
+                { value: 'yes', name: 'Yes' },
+                { value: 'skip', name: 'Skip for now' },
+            ],
+            footer: '\nRead more about remote caching at https://nx.dev/ci/features/remote-cache',
+            hint: `\n(it's free and can be disabled any time)`,
+            fallback: undefined,
         },
     ],
 };
@@ -20,7 +52,7 @@ class PromptMessages {
     constructor() {
         this.selectedMessages = {};
     }
-    getPromptMessage(key) {
+    getPrompt(key) {
         if (this.selectedMessages[key] === undefined) {
             if (process.env.NX_GENERATE_DOCS_PROCESS === 'true') {
                 this.selectedMessages[key] = 0;
@@ -29,12 +61,12 @@ class PromptMessages {
                 this.selectedMessages[key] = Math.floor(Math.random() * messageOptions[key].length);
             }
         }
-        return messageOptions[key][this.selectedMessages[key]].message;
+        return messageOptions[key][this.selectedMessages[key]];
     }
     codeOfSelectedPromptMessage(key) {
         const selected = this.selectedMessages[key];
         if (selected === undefined) {
-            return messageOptions[key][0].code;
+            return '';
         }
         else {
             return messageOptions[key][selected].code;
@@ -65,7 +97,7 @@ async function recordStat(opts) {
             command: opts.command,
             isCI: (0, is_ci_1.isCI)(),
             useCloud: opts.useCloud,
-            meta: opts.meta,
+            meta: opts.meta.filter((v) => !!v).join(','),
         });
     }
     catch (e) {

package/src/utils/nx/nx-cloud.d.ts

@@ -1,5 +1,6 @@
 import { PackageManager } from '../package-manager';
-export declare function setupNxCloud(directory: string, packageManager: PackageManager): Promise<{
+export type NxCloud = 'yes' | 'github' | 'circleci' | 'skip';
+export declare function setupNxCloud(directory: string, packageManager: PackageManager, nxCloud: NxCloud): Promise<{
     code: number;
     stdout: string;
 }>;

package/src/utils/nx/nx-cloud.js

@@ -6,19 +6,24 @@ const child_process_utils_1 = require("../child-process-utils");
 const output_1 = require("../output");
 const package_manager_1 = require("../package-manager");
 const error_utils_1 = require("../error-utils");
-async function setupNxCloud(directory, packageManager) {
-    const nxCloudSpinner = ora(`Setting up NxCloud`).start();
+async function setupNxCloud(directory, packageManager, nxCloud) {
+    const nxCloudSpinner = ora(`Setting up Nx Cloud`).start();
     try {
         const pmc = (0, package_manager_1.getPackageManagerCommand)(packageManager);
         const res = await (0, child_process_utils_1.execAndWait)(`${pmc.exec} nx g nx:connect-to-nx-cloud --no-interactive --quiet`, directory);
-        nxCloudSpinner.succeed('NxCloud has been set up successfully');
+        if (nxCloud !== 'yes') {
+            nxCloudSpinner.succeed('CI workflow with Nx Cloud has been generated successfully');
+        }
+        else {
+            nxCloudSpinner.succeed('Nx Cloud has been set up successfully');
+        }
         return res;
     }
     catch (e) {
         nxCloudSpinner.fail();
         if (e instanceof Error) {
             output_1.output.error({
-                title: `Failed to setup NxCloud`,
+                title: `Failed to setup Nx Cloud`,
                 bodyLines: (0, error_utils_1.mapErrorToBodyLines)(e),
             });
         }
@@ -33,12 +38,19 @@ async function setupNxCloud(directory, packageManager) {
 }
 exports.setupNxCloud = setupNxCloud;
 function printNxCloudSuccessMessage(nxCloudOut) {
-    const bodyLines = nxCloudOut
-        .split('Distributed caching via Nx Cloud has been enabled')[1]
-        .trim();
-    output_1.output.note({
-        title: `Distributed caching via Nx Cloud has been enabled`,
-        bodyLines: bodyLines.split('\n').map((r) => r.trim()),
+    // remove leading Nx carret and any new lines
+    const logContent = nxCloudOut.split('NX   ')[1];
+    const indexOfTitleEnd = logContent.indexOf('\n');
+    const title = logContent.slice(0, logContent.indexOf('\n')).trim();
+    const bodyLines = logContent
+        .slice(indexOfTitleEnd)
+        .replace(/^\n*/, '') // remove leading new lines
+        .replace(/\n*$/, '') // remove trailing new lines
+        .split('\n')
+        .map((r) => r.trim());
+    output_1.output.warn({
+        title,
+        bodyLines,
     });
 }
 exports.printNxCloudSuccessMessage = printNxCloudSuccessMessage;

package/src/utils/nx/show-nx-warning.js

@@ -4,6 +4,7 @@ exports.showNxWarning = void 0;
 const child_process_1 = require("child_process");
 const path_1 = require("path");
 const output_1 = require("../output");
+const package_manager_1 = require("../package-manager");
 function showNxWarning(workspaceName) {
     try {
         const pathToRunNxCommand = (0, path_1.resolve)(process.cwd(), workspaceName);
@@ -14,12 +15,13 @@ function showNxWarning(workspaceName) {
     }
     catch (e) {
         // no nx found
+        const { exec, globalAdd } = (0, package_manager_1.getPackageManagerCommand)();
         output_1.output.addVerticalSeparator();
         output_1.output.note({
             title: `Nx CLI is not installed globally.`,
             bodyLines: [
-                `This means that you might have to use "yarn nx" or "npx nx" to execute commands in the workspace.`,
-                `Run "yarn global add nx" or "npm install -g nx" to be able to execute command directly.`,
+                `This means that you will have to use "${exec} nx" to execute commands in the workspace.`,
+                `Run "${globalAdd} nx" to be able to execute command directly.`,
             ],
         });
     }

package/src/utils/output.d.ts

@@ -16,7 +16,6 @@ export interface CLISuccessMessageConfig {
     bodyLines?: string[];
 }
 declare class CLIOutput {
-    readonly X_PADDING = " ";
     /**
      * Longer dash character which forms more of a continuous line when place side to side
      * with itself, unlike the standard dash character

package/src/utils/output.js

@@ -16,7 +16,6 @@ if ((0, is_ci_1.isCI)()) {
 }
 class CLIOutput {
     constructor() {
-        this.X_PADDING = ' ';
         /**
          * Expose some color and other utility functions so that other parts of the codebase that need
          * more fine-grained control of message bodies are still using a centralized
@@ -40,7 +39,7 @@ class CLIOutput {
      */
     get VERTICAL_SEPARATOR() {
         let divider = '';
-        for (let i = 0; i < process.stdout.columns - this.X_PADDING.length * 2; i++) {
+        for (let i = 0; i < process.stdout.columns - 1; i++) {
             divider += '\u2014';
         }
         return divider;
@@ -49,14 +48,14 @@ class CLIOutput {
         process.stdout.write(str);
     }
     writeOutputTitle({ color, title, }) {
-        this.writeToStdOut(` ${this.applyCLIPrefix(color, title)}${os_1.EOL}`);
+        this.writeToStdOut(`${this.applyCLIPrefix(color, title)}${os_1.EOL}`);
     }
     writeOptionalOutputBody(bodyLines) {
         if (!bodyLines) {
             return;
         }
         this.addNewline();
-        bodyLines.forEach((bodyLine) => this.writeToStdOut(`   ${bodyLine}${os_1.EOL}`));
+        bodyLines.forEach((bodyLine) => this.writeToStdOut(`${bodyLine}${os_1.EOL}`));
     }
     setCliName(name) {
         this.cliName = name;
@@ -64,10 +63,10 @@ class CLIOutput {
     applyCLIPrefix(color = 'cyan', text) {
         let cliPrefix = '';
         if (chalk[color]) {
-            cliPrefix = `${chalk[color]('>')} ${chalk.reset.inverse.bold[color](` ${this.cliName} `)}`;
+            cliPrefix = chalk.reset.inverse.bold[color](` ${this.cliName} `);
         }
         else {
-            cliPrefix = `${chalk.keyword(color)('>')} ${chalk.reset.inverse.bold.keyword(color)(` ${this.cliName} `)}`;
+            cliPrefix = chalk.reset.inverse.bold.keyword(color)(` ${this.cliName} `);
         }
         return `${cliPrefix}  ${text}`;
     }
@@ -80,7 +79,7 @@ class CLIOutput {
         this.addNewline();
     }
     addVerticalSeparatorWithoutNewLines(color = 'gray') {
-        this.writeToStdOut(`${this.X_PADDING}${chalk.dim[color](this.VERTICAL_SEPARATOR)}${os_1.EOL}`);
+        this.writeToStdOut(`${chalk.dim[color](this.VERTICAL_SEPARATOR)}${os_1.EOL}`);
     }
     error({ title, bodyLines }) {
         this.addNewline();

package/src/utils/package-manager.d.ts

@@ -17,6 +17,7 @@ export declare function getPackageManagerCommand(packageManager?: PackageManager
     install: string;
     exec: string;
     preInstall?: string;
+    globalAdd: string;
 };
 export declare function generatePackageManagerFiles(root: string, packageManager?: PackageManager): void;
 export declare function getPackageManagerVersion(packageManager: PackageManager, cwd?: string): string;

package/src/utils/package-manager.js

@@ -43,6 +43,7 @@ function getPackageManagerCommand(packageManager = detectPackageManager()) {
                     : `${installCommand} --ignore-scripts`,
                 // using npx is necessary to avoid yarn classic manipulating the version detection when using berry
                 exec: useBerry ? 'npx' : 'yarn',
+                globalAdd: 'yarn global add',
             };
         case 'pnpm':
             let useExec = false;
@@ -52,11 +53,13 @@ function getPackageManagerCommand(packageManager = detectPackageManager()) {
             return {
                 install: 'pnpm install --no-frozen-lockfile --silent --ignore-scripts',
                 exec: useExec ? 'pnpm exec' : 'pnpx',
+                globalAdd: 'pnpm add -g',
             };
         case 'npm':
             return {
                 install: 'npm install --silent --ignore-scripts',
                 exec: 'npx',
+                globalAdd: 'npm i -g',
             };
     }
 }

package/src/utils/preset/point-to-tutorial-and-course.js

@@ -12,7 +12,7 @@ function pointToTutorialAndCourse(preset) {
             output_1.output.note({
                 title,
                 bodyLines: [
-                    `https://nx.dev/getting-started/tutorials/package-based-repo-tutorial`,
+                    `https://nx.dev/getting-started/tutorials/npm-workspaces-tutorial`,
                 ],
             });
             break;

package/src/utils/preset/preset-options.js

@@ -23,6 +23,10 @@ exports.presetOptions = [
         name: preset_1.Preset.VueMonorepo,
         message: 'vue               [a monorepo with a single Vue application]',
     },
+    {
+        name: preset_1.Preset.Nuxt,
+        message: 'nuxt              [a monorepo with a single Nuxt application]',
+    },
     {
         name: preset_1.Preset.NextJs,
         message: 'next.js           [a monorepo with a single Next.js application]',

package/src/utils/preset/preset.d.ts

@@ -1,7 +1,7 @@
 export declare enum Preset {
     Apps = "apps",
-    Empty = "empty",
-    Core = "core",
+    Empty = "empty",// same as apps, deprecated
+    Core = "core",// same as npm, deprecated
     NPM = "npm",
     TS = "ts",
     WebComponents = "web-components",
@@ -11,13 +11,18 @@ export declare enum Preset {
     ReactStandalone = "react-standalone",
     VueMonorepo = "vue-monorepo",
     VueStandalone = "vue-standalone",
+    Nuxt = "nuxt",
+    NuxtStandalone = "nuxt-standalone",
     NextJs = "next",
     NextJsStandalone = "nextjs-standalone",
+    RemixMonorepo = "remix-monorepo",
+    RemixStandalone = "remix-standalone",
     ReactNative = "react-native",
     Expo = "expo",
     Nest = "nest",
     Express = "express",
     React = "react",
+    Vue = "vue",
     Angular = "angular",
     NodeStandalone = "node-standalone",
     NodeMonorepo = "node-monorepo",

package/src/utils/preset/preset.js

@@ -15,13 +15,18 @@ var Preset;
     Preset["ReactStandalone"] = "react-standalone";
     Preset["VueMonorepo"] = "vue-monorepo";
     Preset["VueStandalone"] = "vue-standalone";
+    Preset["Nuxt"] = "nuxt";
+    Preset["NuxtStandalone"] = "nuxt-standalone";
     Preset["NextJs"] = "next";
     Preset["NextJsStandalone"] = "nextjs-standalone";
+    Preset["RemixMonorepo"] = "remix-monorepo";
+    Preset["RemixStandalone"] = "remix-standalone";
     Preset["ReactNative"] = "react-native";
     Preset["Expo"] = "expo";
     Preset["Nest"] = "nest";
     Preset["Express"] = "express";
     Preset["React"] = "react";
+    Preset["Vue"] = "vue";
     Preset["Angular"] = "angular";
     Preset["NodeStandalone"] = "node-standalone";
     Preset["NodeMonorepo"] = "node-monorepo";

package/src/utils/ci/ci-list.d.ts

@@ -1,2 +0,0 @@
-export declare const ciList: string[];
-export type CI = typeof ciList[number];