esa-cli 0.0.2-beta.10 → 0.0.2-beta.13

package/dist/commands/init/index.js

@@ -7,30 +7,65 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import fs from 'fs-extra';
+import { execSync } from 'child_process';
 import path from 'path';
-import inquirer from 'inquirer';
 import { exit } from 'process';
-import Template from '../../libs/templates/index.js';
-import { installGit } from '../../libs/git/index.js';
+import fs from 'fs-extra';
+import inquirer from 'inquirer';
 import multiLevelSelect from '../../components/mutiLevelSelect.js';
-import { generateConfigFile, getCliConfig, getProjectConfig, getTemplatesConfig, templateHubPath, updateProjectConfigFile } from '../../utils/fileUtils/index.js';
 import t from '../../i18n/index.js';
+import { installGit } from '../../libs/git/index.js';
 import logger from '../../libs/logger.js';
-import { quickDeploy } from '../deploy/index.js';
-import { ApiService } from '../../libs/apiService.js';
-import { checkRoutineExist } from '../../utils/checkIsRoutineCreated.js';
-import { checkIsLoginSuccess } from '../utils.js';
-import chalk from 'chalk';
-import { checkAndUpdatePackage, getTemplateInstances, preInstallDependencies, transferTemplatesToSelectItem } from './helper.js';
+import Template from '../../libs/templates/index.js';
+import { generateConfigFile, getCliConfig, getProjectConfig, getTemplatesConfig, templateHubPath, updateProjectConfigFile } from '../../utils/fileUtils/index.js';
+import { quickDeployForInit } from '../common/routineUtils.js';
+import { checkAndUpdatePackage, getAllFrameworkConfig, getFrameworkConfig, getTemplateInstances, preInstallDependencies, transferTemplatesToSelectItem } from './helper.js';
 const init = {
-    command: 'init',
+    command: 'init [name]',
     describe: `📥 ${t('init_describe').d('Initialize a routine with a template')}`,
     builder: (yargs) => {
-        return yargs.option('config', {
+        return yargs
+            .positional('name', {
+            describe: t('init_project_name').d('Project name'),
+            type: 'string'
+        })
+            .option('framework', {
+            alias: 'f',
+            describe: 'Choose a frontend framework (react/vue/nextjs)',
+            type: 'string',
+            choices: ['react', 'vue', 'nextjs']
+        })
+            .option('language', {
+            alias: 'l',
+            describe: 'Choose programming language (typescript/javascript)',
+            type: 'string',
+            choices: ['typescript', 'javascript']
+        })
+            .option('template', {
+            alias: 't',
+            describe: t('init_template_name').d('Template name to use'),
+            type: 'string'
+        })
+            .option('config', {
             alias: 'c',
             describe: t('init_config_file').d('Generate a config file for your project'),
             type: 'boolean'
+        })
+            .option('templateParams', {
+            describe: 'Generate a global template-params config file',
+            type: 'boolean'
+        })
+            .option('yes', {
+            alias: 'y',
+            describe: t('init_yes').d('Answer "Yes" to all prompts.'),
+            type: 'boolean',
+            default: false
+        })
+            .option('skip', {
+            alias: 's',
+            describe: t('init_skip').d('Answer "No" to any prompts for new projects.'),
+            type: 'boolean',
+            default: false
         });
     },
     handler: (argv) => __awaiter(void 0, void 0, void 0, function* () {
@@ -39,13 +74,45 @@ const init = {
     })
 };
 export default init;
+export function findTemplatePathByName(templateName) {
+    const templateInstanceList = getTemplateInstances(templateHubPath);
+    const templateConfig = getTemplatesConfig();
+    // find template recursively
+    function findTemplateRecursive(configs) {
+        for (const config of configs) {
+            const title = config.Title_EN;
+            if (title === templateName) {
+                const template = templateInstanceList.find((template) => {
+                    return config.Title_EN === template.title;
+                });
+                return (template === null || template === void 0 ? void 0 : template.path) || null;
+            }
+        }
+        return null;
+    }
+    return findTemplateRecursive(templateConfig);
+}
+export function validateProjectName(name) {
+    const regex = /^[a-z0-9-]{2,}$/;
+    return regex.test(name);
+}
 export function promptProjectName() {
-    return __awaiter(this, void 0, void 0, function* () {
+    return __awaiter(this, arguments, void 0, function* (yes = false) {
+        if (yes) {
+            // Generate a default name when --yes is used
+            const defaultName = `edge-routine-${Date.now()}`;
+            logger.log(`${t('init_input_name').d('Enter the name of edgeRoutine:')} ${defaultName}`);
+            logger.replacePrevLines(2, `├ ${t('init_input_name').d('Enter the name of edgeRoutine')}`);
+            logger.cfStepKV('name', defaultName);
+            logger.cfStepSpacer();
+            return defaultName;
+        }
         const { name } = yield inquirer.prompt([
             {
                 type: 'input',
                 name: 'name',
-                message: `🖊️ ${t('init_input_name').d('Enter the name of edgeRoutine:')}`,
+                message: `${t('init_input_name').d('Enter the name of edgeRoutine:')}\n`,
+                prefix: '╰',
                 validate: (input) => {
                     const regex = /^[a-z0-9-]{2,}$/;
                     if (!regex.test(input)) {
@@ -55,6 +122,9 @@ export function promptProjectName() {
                 }
             }
         ]);
+        logger.replacePrevLines(2, `├ ${t('init_input_name').d('Enter the name of edgeRoutine:')}`);
+        logger.cfStepKV('ER Name', name);
+        logger.cfStepSpacer();
         return name;
     });
 }
@@ -66,8 +136,21 @@ export function prepareTemplateItems() {
     const lang = (_a = cliConfig === null || cliConfig === void 0 ? void 0 : cliConfig.lang) !== null && _a !== void 0 ? _a : 'en';
     return transferTemplatesToSelectItem(templateConfig, templateInstanceList, lang);
 }
-export function selectTemplate(items) {
-    return __awaiter(this, void 0, void 0, function* () {
+export function selectTemplate(items_1) {
+    return __awaiter(this, arguments, void 0, function* (items, yes = false) {
+        if (yes) {
+            // Select the first available template when --yes is used
+            const firstTemplate = items[0];
+            if (firstTemplate) {
+                logger.log(`Select a template: ${firstTemplate.label}`);
+                return firstTemplate.value;
+            }
+            else {
+                logger.error(t('init_no_templates').d('No templates available.'));
+                return null;
+            }
+        }
+        logger.cfStepEnd();
         const selectedTemplatePath = yield multiLevelSelect(items, 'Select a template:');
         if (!selectedTemplatePath) {
             logger.log(t('init_cancel').d('User canceled the operation.'));
@@ -96,30 +179,236 @@ export function initializeProject(selectedTemplatePath, name) {
         return { template: selectTemplate, targetPath };
     });
 }
-export function handleGitInitialization(targetPath) {
-    return __awaiter(this, void 0, void 0, function* () {
+export function handleGitInitialization(targetPath_1) {
+    return __awaiter(this, arguments, void 0, function* (targetPath, yes = false) {
+        if (yes) {
+            logger.log(`${t('init_git').d('Do you want to init git in your project?')} Yes`);
+            installGit(targetPath);
+            return;
+        }
         const { initGit } = yield inquirer.prompt([
             {
                 type: 'list',
                 name: 'initGit',
                 message: t('init_git').d('Do you want to init git in your project?'),
+                prefix: '╰',
                 choices: ['Yes', 'No']
             }
         ]);
+        logger.replacePrevLine('├ Do you want to init git in your project?');
         if (initGit === 'Yes') {
-            installGit(targetPath);
+            const success = installGit(targetPath);
+            if (success) {
+                logger.cfStepKV('git', t('git_installed_success').d('Git has been installed successfully.'));
+                logger.cfStepSpacer();
+            }
         }
         else {
-            logger.log(t('init_skip_git').d('Git installation was skipped.'));
+            logger.cfStepKV('git', t('init_skip_git').d('Git installation was skipped.'));
+            logger.cfStepSpacer();
         }
     });
 }
-export function handleDeployment(targetPath, projectConfig) {
+// STEP 1 prepare
+// 1. check is template latest
+// 2. input project name
+// 3. choose framework or template
+// 4. select a framework/template
+// 5. TODO: js/ts
+// STEP 2 init
+// 1. execute framework init command
+// 2. install esa-cli
+// 3. config toml/jsonc
+// STEP 3 customize
+// 1. git yes/no
+// 2. deploy yes/no
+export function handleInit(argv) {
     return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b, _c;
-        const isLoginSuccess = yield checkIsLoginSuccess();
-        if (!isLoginSuccess) {
-            logger.log(chalk.yellow(t('not_login_auto_deploy').d('You are not logged in, automatic deployment cannot be performed. Please log in later and manually deploy.')));
+        var _a, _b;
+        yield checkAndUpdatePackage('esa-template');
+        // Step 1 of 3: Planning selections (Cloudflare-like)
+        logger.cfStepHeader('Create an ESA application', 1, 3);
+        if (argv.config) {
+            const configFormat = yield promptConfigFormat(argv.yes);
+            yield generateConfigFile(undefined, undefined, undefined, configFormat);
+            exit(0);
+        }
+        // Update the template package (currently commented out)
+        // If config option is provided, generate config file and exit
+        const config = getCliConfig();
+        if (config === undefined) {
+            const configFormat = yield promptConfigFormat(argv.yes);
+            yield generateConfigFile(String(config), undefined, undefined, configFormat);
+        }
+        // Handle project name parameter
+        let name = argv.name;
+        if (!name) {
+            name = yield promptProjectName(argv.yes);
+        }
+        else {
+            if (!validateProjectName(name)) {
+                logger.error(t('init_name_error').d('Error: The project name must be at least 2 characters long and can only contain lowercase letters, numbers, and hyphens.'));
+                return;
+            }
+        }
+        // Show chosen directory
+        logger.cfStepItem('In which directory do you want to create your application?');
+        logger.cfStepKV('dir', `./${name}`);
+        logger.cfStepSpacer();
+        // Decide between framework or template if neither provided and not --yes
+        let framework = argv.framework;
+        let language = argv.language;
+        const allFrameworkConfig = getAllFrameworkConfig();
+        if (!framework && !argv.template && !argv.yes) {
+            const { initMode } = yield inquirer.prompt([
+                {
+                    type: 'list',
+                    name: 'initMode',
+                    message: 'How would you like to initialize the project?',
+                    prefix: '╰',
+                    choices: [
+                        { name: 'Use a framework (React/Vue/Next.js)', value: 'framework' },
+                        {
+                            name: 'Use ESA template (recommended for EdgeRoutine demos)',
+                            value: 'template'
+                        }
+                    ]
+                }
+            ]);
+            logger.replacePrevLine('├ How would you like to initialize the project?');
+            logger.cfStepKV('category', initMode === 'framework' ? 'Framework Starter' : 'ESA Template');
+            logger.cfStepSpacer();
+            if (initMode === 'framework') {
+                const { fw } = yield inquirer.prompt([
+                    {
+                        type: 'list',
+                        name: 'fw',
+                        message: 'Select a framework',
+                        prefix: '╰',
+                        choices: Object.keys(allFrameworkConfig).map((fw) => ({
+                            name: allFrameworkConfig[fw].label,
+                            value: fw
+                        }))
+                    }
+                ]);
+                logger.replacePrevLine('├ Select a framework');
+                framework = fw;
+                logger.cfStepKV('framework', String(framework));
+                const frameworkConfig = getFrameworkConfig(framework);
+                if (frameworkConfig.templates) {
+                    if (!language) {
+                        language = yield promptLanguage(argv.yes);
+                    }
+                    logger.cfStepKV(t('init_language_selected').d('Language'), language);
+                }
+                logger.cfStepEnd('Configuration collected');
+            }
+            else if (initMode === 'template') {
+                // Use ESA Template creation method
+                const templateItems = prepareTemplateItems();
+                const selectedTemplatePath = yield selectTemplate(templateItems, argv.yes);
+                if (!selectedTemplatePath) {
+                    return;
+                }
+                logger.cfStepEnd('Template selected');
+                // Step 2 of 3: Scaffold project
+                logger.cfStepHeader('Scaffold project', 2, 3);
+                const { template, targetPath } = (yield initializeProject(selectedTemplatePath, name)) || {};
+                if (!template || !targetPath) {
+                    return;
+                }
+                logger.cfStepSpacer();
+                logger.cfStepEnd('Project initialized');
+                // Step 3 of 3: Configure and finalize
+                logger.cfStepHeader('Configure and finalize', 3, 3);
+                if (!argv.skip) {
+                    yield handleGitInitialization(targetPath, argv.yes);
+                }
+                // Deployment prompt relies on config file just generated
+                if (!argv.skip) {
+                    const projectConfig = getProjectConfig(targetPath);
+                    if (projectConfig) {
+                        yield initDeployment(targetPath, projectConfig, argv.yes, initMode);
+                    }
+                }
+                logger.success('Project created successfully.');
+                return;
+            }
+        }
+        const frameworkConfig = getFrameworkConfig(framework || '');
+        if (framework) {
+            const targetPath = path.join(process.cwd(), name);
+            if (fs.existsSync(targetPath)) {
+                logger.error(t('already_exist_file_error').d('Error: The project already exists. It looks like a folder named "<project-name>" is already present in the current directory. Please try the following options: 1. Choose a different project name. 2. Delete the existing folder if it\'s not needed: `rm -rf <project-name>` (use with caution!). 3. Move to a different directory before running the init command.'));
+                return;
+            }
+            // Step 2 of 3: Scaffold project
+            logger.cfStepHeader('Scaffold project', 2, 3);
+            const command = frameworkConfig.command;
+            const templateFlag = ((_a = frameworkConfig.templates) === null || _a === void 0 ? void 0 : _a[language || 'typescript']) || '';
+            const fullCommand = `${command} ${name} ${templateFlag}`;
+            logger.cfStepItem(`Continue with ${framework} via \`${fullCommand}\``);
+            logger.cfStepKV('dir', `./${name}`);
+            logger.cfStepSpacer();
+            logger.log(`Creating ${framework} app in ${targetPath} ...`);
+            // Execute the command with proper arguments
+            if (templateFlag) {
+                execSync(`${command} ${name} ${templateFlag}`, {
+                    stdio: 'inherit',
+                    cwd: process.cwd()
+                });
+            }
+            else {
+                execSync(`${command} ${name}`, {
+                    stdio: 'inherit',
+                    cwd: process.cwd()
+                });
+            }
+            logger.cfStepSpacer();
+            // install dependencies
+            logger.cfStepItem('Install dependencies');
+            execSync('npm install', {
+                stdio: 'inherit',
+                cwd: targetPath
+            });
+            logger.cfStepSpacer();
+            // Post-process nextjs configuration for static export
+            if (framework === 'nextjs') {
+                logger.cfStepItem('Configuring Next.js for static export');
+                yield configureNextJsForStaticExport(targetPath);
+                logger.cfStepSpacer();
+            }
+            logger.cfStepEnd('Project initialized');
+            const assetsDirectory = (_b = frameworkConfig.assets) === null || _b === void 0 ? void 0 : _b.directory;
+            // Step 3 of 3: Configure and finalize
+            logger.cfStepHeader('Configure and finalize', 3, 3);
+            const configFormat = yield promptConfigFormat(argv.yes);
+            // logger.cfStepItem('Generate config file');
+            logger.cfStepKV('format', configFormat);
+            logger.cfStepSpacer();
+            yield generateConfigFile(name, {
+                assets: assetsDirectory ? { directory: assetsDirectory } : undefined
+            }, targetPath, configFormat);
+            if (!argv.skip) {
+                yield handleGitInitialization(targetPath, argv.yes);
+            }
+            // Deployment prompt relies on config file just generated
+            if (!argv.skip) {
+                const projectConfig = getProjectConfig(targetPath);
+                if (projectConfig) {
+                    yield initDeployment(targetPath, projectConfig, argv.yes);
+                }
+            }
+            logger.success('Project created successfully.');
+            return;
+        }
+    });
+}
+export function initDeployment(targetPath_1, projectConfig_1) {
+    return __awaiter(this, arguments, void 0, function* (targetPath, projectConfig, yes = false, initMode = 'framework') {
+        if (yes) {
+            logger.log(`${t('auto_deploy').d('Do you want to deploy your project?')} Yes`);
+            yield quickDeployForInit(targetPath, projectConfig);
             return;
         }
         const { deploy } = yield inquirer.prompt([
@@ -127,49 +416,164 @@ export function handleDeployment(targetPath, projectConfig) {
                 type: 'list',
                 name: 'deploy',
                 message: t('auto_deploy').d('Do you want to deploy your project?'),
+                prefix: '╰',
                 choices: ['Yes', 'No']
             }
         ]);
+        logger.replacePrevLine('├ Do you want to deploy your project?');
         if (deploy === 'Yes') {
-            yield checkRoutineExist((_a = projectConfig === null || projectConfig === void 0 ? void 0 : projectConfig.name) !== null && _a !== void 0 ? _a : '', targetPath);
-            yield quickDeploy(targetPath, projectConfig);
-            const service = yield ApiService.getInstance();
-            const res = yield service.getRoutine({ Name: (_b = projectConfig === null || projectConfig === void 0 ? void 0 : projectConfig.name) !== null && _b !== void 0 ? _b : '' });
-            const defaultUrl = (_c = res === null || res === void 0 ? void 0 : res.data) === null || _c === void 0 ? void 0 : _c.DefaultRelatedRecord;
-            const visitUrl = defaultUrl ? 'http://' + defaultUrl : '';
-            logger.success(`${t('init_deploy_success').d('Project deployment completed. Visit: ')}${chalk.yellowBright(visitUrl)}`);
-            logger.warn(t('deploy_url_warn').d('The domain may take some time to take effect, please try again later.'));
+            if (initMode === 'framework') {
+                execSync('npm run build', { stdio: 'inherit', cwd: targetPath });
+            }
+            yield quickDeployForInit(targetPath, projectConfig);
         }
     });
 }
-export function handleInit(argv) {
+function promptConfigFormat(yes) {
     return __awaiter(this, void 0, void 0, function* () {
-        // Update the template package (currently commented out)
-        yield checkAndUpdatePackage('esa-template');
-        // If config option is provided, generate config file and exit
-        const config = getCliConfig();
-        if (config === undefined) {
-            yield generateConfigFile(String(config));
+        if (yes) {
+            return 'jsonc';
         }
-        const name = yield promptProjectName();
-        const templateItems = prepareTemplateItems();
-        // Select a template
-        const selectedTemplatePath = yield selectTemplate(templateItems);
-        if (!selectedTemplatePath) {
+        const { configFormat } = yield inquirer.prompt([
+            {
+                type: 'list',
+                name: 'configFormat',
+                message: t('init_config_format_select').d('Select configuration file format:'),
+                prefix: '╰',
+                choices: [
+                    {
+                        name: t('init_config_format_jsonc').d('JSONC (.jsonc) - JSON with comments, recommended'),
+                        value: 'jsonc'
+                    },
+                    {
+                        name: t('init_config_format_toml').d('TOML (.toml) - Traditional format'),
+                        value: 'toml'
+                    }
+                ],
+                default: 'jsonc'
+            }
+        ]);
+        logger.replacePrevLine('├ Select configuration file format:');
+        return configFormat;
+    });
+}
+function promptLanguage(yes) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (yes) {
+            return 'typescript';
+        }
+        const { language } = yield inquirer.prompt([
+            {
+                type: 'list',
+                name: 'language',
+                message: t('init_language_select').d('Select programming language:'),
+                prefix: '╰',
+                choices: [
+                    {
+                        name: t('init_language_typescript').d('TypeScript (.ts) - Type-safe JavaScript, recommended'),
+                        value: 'typescript'
+                    },
+                    {
+                        name: t('init_language_javascript').d('JavaScript (.js) - Traditional JavaScript'),
+                        value: 'javascript'
+                    }
+                ],
+                default: 'typescript'
+            }
+        ]);
+        logger.replacePrevLine('├ Select programming language:');
+        return language;
+    });
+}
+/**
+ * Configure Next.js for static export by modifying next.config.ts/js
+ * @param targetPath Path to the Next.js project
+ */
+export function configureNextJsForStaticExport(targetPath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const nextConfigTsPath = path.join(targetPath, 'next.config.ts');
+        const nextConfigJsPath = path.join(targetPath, 'next.config.js');
+        const nextConfigMjsPath = path.join(targetPath, 'next.config.mjs');
+        let configPath = null;
+        let configContent = '';
+        // Check which config file exists
+        if (fs.existsSync(nextConfigTsPath)) {
+            configPath = nextConfigTsPath;
+            configContent = fs.readFileSync(nextConfigTsPath, 'utf-8');
+        }
+        else if (fs.existsSync(nextConfigJsPath)) {
+            configPath = nextConfigJsPath;
+            configContent = fs.readFileSync(nextConfigJsPath, 'utf-8');
+        }
+        else if (fs.existsSync(nextConfigMjsPath)) {
+            configPath = nextConfigMjsPath;
+            configContent = fs.readFileSync(nextConfigMjsPath, 'utf-8');
+        }
+        if (!configPath) {
+            // Create a new next.config.ts file if none exists
+            configPath = nextConfigTsPath;
+            const newConfig = `import type { NextConfig } from "next";
+
+const nextConfig: NextConfig = {
+  output: "export",
+  trailingSlash: true,
+  images: {
+    unoptimized: true
+  }
+};
+
+export default nextConfig;`;
+            fs.writeFileSync(configPath, newConfig, 'utf-8');
+            logger.success('Created next.config.ts with static export configuration');
             return;
         }
-        // Initialize project files and configuration
-        const project = yield initializeProject(selectedTemplatePath, name);
-        if (!project) {
+        // Check if output: 'export' is already configured
+        if (configContent.includes('output: "export"') || configContent.includes("output: 'export'")) {
+            logger.success('Next.js is already configured for static export');
             return;
         }
-        const { template, targetPath } = project;
-        // Handle Git initialization
-        yield handleGitInitialization(targetPath);
-        // Handle deployment
-        const projectConfig = getProjectConfig(targetPath);
-        yield handleDeployment(targetPath, projectConfig);
-        template.printSummary();
-        return;
+        // Modify existing config to add output: 'export'
+        let modifiedContent = configContent;
+        // Handle different config formats
+        if (configPath.endsWith('.ts')) {
+            // TypeScript config
+            if (configContent.includes('const nextConfig = {')) {
+                // Add output: 'export' after the opening brace
+                modifiedContent = configContent.replace(/(const nextConfig\s*=\s*\{)/, `$1
+  output: "export",`);
+            }
+            else if (configContent.includes('export default {')) {
+                // Add output: 'export' after the opening brace
+                modifiedContent = configContent.replace(/(export default\s*\{)/, `$1
+  output: "export",`);
+            }
+        }
+        else {
+            // JavaScript config
+            if (configContent.includes('const nextConfig = {')) {
+                // Add output: 'export' after the opening brace
+                modifiedContent = configContent.replace(/(const nextConfig\s*=\s*\{)/, `$1
+  output: "export",`);
+            }
+            else if (configContent.includes('module.exports = {')) {
+                // Add output: 'export' after the opening brace
+                modifiedContent = configContent.replace(/(module\.exports\s*=\s*\{)/, `$1
+  output: "export",`);
+            }
+        }
+        // Add trailingSlash and images configuration if not present
+        if (!modifiedContent.includes('trailingSlash')) {
+            modifiedContent = modifiedContent.replace(/(output: "export",)/, `$1
+  trailingSlash: true,`);
+        }
+        if (!modifiedContent.includes('images')) {
+            modifiedContent = modifiedContent.replace(/(trailingSlash: true,)/, `$1
+  images: {
+    unoptimized: true
+  }`);
+        }
+        // Write the modified config back to file
+        fs.writeFileSync(configPath, modifiedContent, 'utf-8');
+        logger.success('Next.js configured for static export successfully');
     });
 }

package/dist/commands/init/template.jsonc

@@ -0,0 +1,34 @@
+{
+  "react": {
+    "label": "React",
+    "command": "npm create vite@latest",
+    "templates": {
+      "typescript": "-- --template react-ts",
+      "javascript": "-- --template react"
+    },
+    "assets": {
+      "directory": "./dist",
+      "notFoundStrategy": "singlePageApplication"
+    }
+  },
+  "vue": {
+    "label": "Vue",
+    "command": "npm create vite@latest",
+    "templates": {
+      "typescript": "-- --template vue-ts -- --use-npm",
+      "javascript": "-- --template vue"
+    },
+    "assets": {
+      "directory": "./dist",
+      "notFoundStrategy": "singlePageApplication"
+    }
+  },
+  "nextjs": {
+    "label": "Next.js",
+    "command": "npx create-next-app@latest",
+    "assets": {
+      "directory": "./out",
+      "notFoundStrategy": "singlePageApplication"
+    }
+  }
+}

package/dist/commands/lang.js

@@ -8,9 +8,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import SelectItems from '../components/selectInput.js';
-import { updateCliConfigFile } from '../utils/fileUtils/index.js';
-import logger from '../libs/logger.js';
 import t from '../i18n/index.js';
+import logger from '../libs/logger.js';
+import { updateCliConfigFile } from '../utils/fileUtils/index.js';
 const docs = {
     command: 'lang',
     describe: `🌐 ${t('lang_describe').d('Set the language of the CLI')}`,