create-esmx 3.0.0-rc.33

package/src/index.ts

@@ -0,0 +1,391 @@
+#!/usr/bin/env node
+
+import {
+    existsSync,
+    mkdirSync,
+    readFileSync,
+    readdirSync,
+    statSync,
+    writeFileSync
+} from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import {
+    cancel,
+    confirm,
+    intro,
+    isCancel,
+    log,
+    note,
+    outro,
+    select,
+    text
+} from '@clack/prompts';
+import minimist from 'minimist';
+import color from 'picocolors';
+import {
+    formatProjectName,
+    getCommand,
+    replaceTemplateVariables
+} from './utils/index';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+interface CreateProjectOptions {
+    argv?: string[]; // Command line arguments
+    cwd?: string; // Working directory
+    userAgent?: string; // Package manager user agent
+}
+
+function getEsmxVersion(): string {
+    try {
+        const packageJsonPath = resolve(__dirname, '../package.json');
+        const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+
+        return packageJson.version || 'latest';
+    } catch (error) {
+        console.warn('Failed to read esmx version, using latest version');
+        return 'latest';
+    }
+}
+
+interface TemplateInfo {
+    folder: string;
+    name: string;
+    description: string;
+}
+
+function getAvailableTemplates(): TemplateInfo[] {
+    const templateDir = resolve(__dirname, '../template');
+
+    const templates: TemplateInfo[] = [];
+    const templateFolders = readdirSync(templateDir, { withFileTypes: true })
+        .filter((dirent) => dirent.isDirectory())
+        .map((dirent) => dirent.name);
+
+    for (const folder of templateFolders) {
+        // Use folder name as display name
+        const name = folder;
+
+        // Try to read description from package.json
+        const packageJsonPath = resolve(templateDir, folder, 'package.json');
+        let description = `${name} template`;
+
+        if (existsSync(packageJsonPath)) {
+            try {
+                const packageJson = JSON.parse(
+                    readFileSync(packageJsonPath, 'utf-8')
+                );
+                if (packageJson.description) {
+                    description = packageJson.description;
+                }
+                templates.push({
+                    folder,
+                    name,
+                    description
+                });
+            } catch (error) {
+                // JSON parsing failed, skip this template
+                console.warn(
+                    `Warning: Failed to parse package.json for template '${folder}', skipping.`
+                );
+            }
+        }
+    }
+
+    // Sort by name alphabetically
+    return templates.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+interface TemplateVariables extends Record<string, string> {
+    projectName: string;
+    esmxVersion: string;
+    installCommand: string;
+    devCommand: string;
+    buildCommand: string;
+    startCommand: string;
+    buildTypeCommand: string;
+    lintTypeCommand: string;
+}
+
+function showHelp(userAgent?: string): void {
+    const createCmd = getCommand('create', userAgent);
+
+    console.log(`
+${color.reset(color.bold(color.blue('🚀 Create Esmx Project')))}
+
+${color.bold('Usage:')}
+  ${createCmd} [project-name]
+  ${createCmd} [project-name] [options]
+
+${color.bold('Options:')}
+  -t, --template <template>    Template to use (default: vue2)
+  -n, --name <name>            Project name or path
+  -f, --force                  Force overwrite existing directory
+  -h, --help                   Show help information
+  -v, --version                Show version number
+
+${color.bold('Examples:')}
+  ${createCmd} my-project
+  ${createCmd} my-project -t vue2
+  ${createCmd} my-project --force
+  ${createCmd} . -f -t vue2
+
+${color.bold('Available Templates:')}
+${getAvailableTemplates()
+    .map((t) => `  ${t.folder.padEnd(25)} ${t.description}`)
+    .join('\n')}
+
+For more information, visit: ${color.cyan('https://esmnext.com')}
+`);
+}
+
+export async function createProject(
+    options: CreateProjectOptions = {}
+): Promise<void> {
+    const { argv, cwd, userAgent } = options;
+    const commandLineArgs = argv || process.argv.slice(2);
+    const workingDir = cwd || process.cwd();
+
+    const parsedArgs = minimist(commandLineArgs, {
+        string: ['template', 'name'],
+        boolean: ['help', 'version', 'force'],
+        alias: {
+            t: 'template',
+            n: 'name',
+            f: 'force',
+            h: 'help',
+            v: 'version'
+        }
+    });
+
+    if (parsedArgs.help) {
+        showHelp(userAgent);
+        return;
+    }
+
+    if (parsedArgs.version) {
+        console.log(getEsmxVersion());
+        return;
+    }
+
+    console.log();
+    intro(
+        color.reset(
+            color.bold(color.blue('🚀 Welcome to Esmx Project Creator!'))
+        )
+    );
+
+    const projectNameInput = await getProjectName(
+        parsedArgs.name,
+        parsedArgs._[0]
+    );
+    if (isCancel(projectNameInput)) {
+        cancel('Operation cancelled');
+        return;
+    }
+
+    const { packageName, targetDir } = formatProjectName(
+        projectNameInput,
+        workingDir
+    );
+
+    const templateType = await getTemplateType(parsedArgs.template);
+    if (isCancel(templateType)) {
+        cancel('Operation cancelled');
+        return;
+    }
+
+    const installCommand = getCommand('install', userAgent);
+    const devCommand = getCommand('dev', userAgent);
+    const buildCommand = getCommand('build', userAgent);
+    const startCommand = getCommand('start', userAgent);
+    const buildTypeCommand = getCommand('build:type', userAgent);
+    const lintTypeCommand = getCommand('lint:type', userAgent);
+
+    await createProjectFromTemplate(
+        targetDir,
+        templateType,
+        workingDir,
+        parsedArgs.force,
+        {
+            projectName: packageName,
+            esmxVersion: getEsmxVersion(),
+            installCommand,
+            devCommand,
+            buildCommand,
+            startCommand,
+            buildTypeCommand,
+            lintTypeCommand
+        }
+    );
+    const installCmd = installCommand;
+    const devCmd = devCommand;
+
+    const nextSteps = [
+        color.reset(`1. ${color.cyan(`cd ${targetDir}`)}`),
+        color.reset(`2. ${color.cyan(installCmd)}`),
+        color.reset(`3. ${color.cyan('git init')} ${color.gray('(optional)')}`),
+        color.reset(`4. ${color.cyan(devCmd)}`)
+    ];
+
+    note(nextSteps.join('\n'), 'Next steps');
+
+    outro(color.reset(color.green('Happy coding! 🎉')));
+}
+
+async function getProjectName(
+    argName?: string,
+    positionalName?: string
+): Promise<string | symbol> {
+    const providedName = argName || positionalName;
+    if (providedName) {
+        return providedName;
+    }
+
+    const projectName = await text({
+        message: 'Project name or path:',
+        placeholder: 'my-esmx-project',
+        validate: (value: string) => {
+            if (!value.trim()) {
+                return 'Project name or path is required';
+            }
+            if (!/^[a-zA-Z0-9_.\/@-]+$/.test(value.trim())) {
+                return 'Project name or path should only contain letters, numbers, hyphens, underscores, dots, and slashes';
+            }
+        }
+    });
+
+    return String(projectName).trim();
+}
+
+async function getTemplateType(argTemplate?: string): Promise<string | symbol> {
+    const availableTemplates = getAvailableTemplates();
+
+    if (
+        argTemplate &&
+        availableTemplates.some((t) => t.folder === argTemplate)
+    ) {
+        return argTemplate;
+    }
+
+    const options = availableTemplates.map((t) => ({
+        label: color.reset(color.gray(`${t.folder} - `) + color.bold(t.name)),
+        value: t.folder,
+        hint: t.description
+    }));
+
+    const template = await select({
+        message: 'Select a template:',
+        options: options
+    });
+
+    return template as string | symbol;
+}
+
+function isDirectoryEmpty(dirPath: string): boolean {
+    if (!existsSync(dirPath)) {
+        return true;
+    }
+
+    const files = readdirSync(dirPath);
+    // Only consider non-hidden files and directories
+    const nonHiddenFiles = files.filter((file) => !file.startsWith('.'));
+    return nonHiddenFiles.length === 0;
+}
+
+async function createProjectFromTemplate(
+    targetDir: string,
+    templateType: string,
+    workingDir: string,
+    force: boolean,
+    variables: TemplateVariables
+): Promise<void> {
+    const templatePath = resolve(__dirname, '../template', templateType);
+    const targetPath =
+        targetDir === '.' ? workingDir : resolve(workingDir, targetDir);
+
+    if (!existsSync(templatePath)) {
+        throw new Error(`Template "${templateType}" not found`);
+    }
+
+    // Handle directory existence and overwrite confirmation
+    if (targetDir !== '.' && existsSync(targetPath)) {
+        if (!isDirectoryEmpty(targetPath)) {
+            if (!force) {
+                const shouldOverwrite = await confirm({
+                    message: `Directory "${targetDir}" is not empty. Do you want to overwrite it?`
+                });
+
+                if (isCancel(shouldOverwrite)) {
+                    cancel('Operation cancelled');
+                    return;
+                }
+
+                if (!shouldOverwrite) {
+                    throw new Error('Operation cancelled by user');
+                }
+            }
+
+            // Files will be overwritten during copyTemplateFiles
+        }
+    } else if (targetDir !== '.') {
+        mkdirSync(targetPath, { recursive: true });
+    }
+
+    // Handle current directory case
+    if (targetDir === '.' && !isDirectoryEmpty(targetPath)) {
+        if (!force) {
+            const shouldOverwrite = await confirm({
+                message:
+                    'Current directory is not empty. Do you want to overwrite existing files?'
+            });
+
+            if (isCancel(shouldOverwrite)) {
+                cancel('Operation cancelled');
+                return;
+            }
+
+            if (!shouldOverwrite) {
+                throw new Error('Operation cancelled by user');
+            }
+        }
+    }
+
+    copyTemplateFiles(templatePath, targetPath, variables);
+}
+
+function copyTemplateFiles(
+    templatePath: string,
+    targetPath: string,
+    variables: TemplateVariables
+): void {
+    const files = readdirSync(templatePath);
+
+    for (const file of files) {
+        const filePath = join(templatePath, file);
+        const targetFilePath = join(targetPath, file);
+        const stat = statSync(filePath);
+
+        if (stat.isDirectory()) {
+            mkdirSync(targetFilePath, { recursive: true });
+            copyTemplateFiles(filePath, targetFilePath, variables);
+        } else {
+            let content = readFileSync(filePath, 'utf-8');
+
+            // Replace all template variables using the utility function
+            content = replaceTemplateVariables(content, variables);
+
+            writeFileSync(targetFilePath, content);
+        }
+    }
+}
+
+export default createProject;
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+    createProject().catch((error) => {
+        console.error('Error creating project:', error);
+        process.exit(1);
+    });
+}

package/src/integration.test.ts

@@ -0,0 +1,226 @@
+import { existsSync } from 'node:fs';
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { createProject } from './index';
+
+// Test utilities
+async function createTempDir(prefix = 'esmx-test-'): Promise<string> {
+    return mkdtemp(join(tmpdir(), prefix));
+}
+
+async function cleanupTempDir(tempDir: string): Promise<void> {
+    try {
+        await rm(tempDir, { recursive: true, force: true });
+    } catch (error) {
+        console.warn(`Failed to cleanup temp directory: ${tempDir}`, error);
+    }
+}
+
+describe('create-esmx integration tests', () => {
+    let tmpDir: string;
+
+    beforeEach(async () => {
+        tmpDir = await createTempDir();
+    });
+
+    afterEach(async () => {
+        await cleanupTempDir(tmpDir);
+    });
+
+    it('should create project with vue2 template', async () => {
+        const projectPath = join(tmpDir, 'test-project');
+
+        await createProject({
+            argv: ['test-project', '--template', 'vue2'],
+            cwd: tmpDir,
+            userAgent: 'npm/test'
+        });
+
+        // Verify project directory exists
+        expect(existsSync(projectPath)).toBe(true);
+
+        // Verify essential common files exist
+        expect(existsSync(join(projectPath, 'package.json'))).toBe(true);
+        expect(existsSync(join(projectPath, 'tsconfig.json'))).toBe(true);
+        expect(existsSync(join(projectPath, 'README.md'))).toBe(true);
+
+        // Verify src directory exists
+        expect(existsSync(join(projectPath, 'src'))).toBe(true);
+
+        // Verify Esmx common entry files exist
+        expect(existsSync(join(projectPath, 'src/entry.client.ts'))).toBe(true);
+        expect(existsSync(join(projectPath, 'src/entry.node.ts'))).toBe(true);
+        expect(existsSync(join(projectPath, 'src/entry.server.ts'))).toBe(true);
+        expect(existsSync(join(projectPath, 'src/create-app.ts'))).toBe(true);
+    });
+
+    it('should handle --force parameter correctly', async () => {
+        const projectPath = join(tmpDir, 'test-project');
+
+        // Create project first time
+        await createProject({
+            argv: ['test-project', '--template', 'vue2'],
+            cwd: tmpDir,
+            userAgent: 'npm/test'
+        });
+
+        // Verify project exists
+        expect(existsSync(join(projectPath, 'package.json'))).toBe(true);
+
+        // Create project again with force flag
+        await createProject({
+            argv: ['test-project', '--template', 'vue2', '--force'],
+            cwd: tmpDir,
+            userAgent: 'npm/test'
+        });
+
+        // Verify project still exists and is valid
+        expect(existsSync(join(projectPath, 'package.json'))).toBe(true);
+        expect(existsSync(join(projectPath, 'src'))).toBe(true);
+
+        // Verify Esmx common entry files still exist after force overwrite
+        expect(existsSync(join(projectPath, 'src/entry.client.ts'))).toBe(true);
+        expect(existsSync(join(projectPath, 'src/entry.node.ts'))).toBe(true);
+        expect(existsSync(join(projectPath, 'src/entry.server.ts'))).toBe(true);
+        expect(existsSync(join(projectPath, 'src/create-app.ts'))).toBe(true);
+    });
+
+    it('should show help information', async () => {
+        // Mock console.log to capture help output
+        const originalLog = console.log;
+        const logOutput: string[] = [];
+        console.log = (...args: any[]) => {
+            logOutput.push(args.join(' '));
+        };
+
+        try {
+            await createProject({
+                argv: ['--help'],
+                cwd: tmpDir,
+                userAgent: 'npm/test'
+            });
+
+            const output = logOutput.join('\n');
+            expect(output).toContain('Usage');
+            expect(output).toContain('Options');
+            expect(output).toContain('Examples');
+        } finally {
+            console.log = originalLog;
+        }
+    });
+
+    it('should show version information', async () => {
+        // Mock console.log to capture version output
+        const originalLog = console.log;
+        const logOutput: string[] = [];
+        console.log = (...args: any[]) => {
+            logOutput.push(args.join(' '));
+        };
+
+        try {
+            await createProject({
+                argv: ['--version'],
+                cwd: tmpDir,
+                userAgent: 'npm/test'
+            });
+
+            const output = logOutput.join('\n');
+            expect(output).toMatch(/^\d+\.\d+\.\d+/);
+        } finally {
+            console.log = originalLog;
+        }
+    });
+
+    it('should handle creating directory when target directory does not exist', async () => {
+        const projectPath = join(tmpDir, 'non-existent-parent', 'test-project');
+
+        await createProject({
+            argv: ['non-existent-parent/test-project', '--template', 'vue2'],
+            cwd: tmpDir,
+            userAgent: 'npm/test'
+        });
+
+        // Verify project was created in nested directory
+        expect(existsSync(projectPath)).toBe(true);
+        expect(existsSync(join(projectPath, 'package.json'))).toBe(true);
+        expect(existsSync(join(projectPath, 'src'))).toBe(true);
+    });
+
+    it('should handle force overwrite for non-empty directory', async () => {
+        const projectPath = join(tmpDir, 'test-project');
+
+        // Create directory with some files
+        await mkdir(projectPath, { recursive: true });
+        await writeFile(
+            join(projectPath, 'existing-file.txt'),
+            'existing content'
+        );
+
+        // Create project with force flag in non-empty directory
+        await createProject({
+            argv: ['test-project', '--template', 'vue2', '--force'],
+            cwd: tmpDir,
+            userAgent: 'npm/test'
+        });
+
+        // Verify project was created successfully
+        expect(existsSync(join(projectPath, 'package.json'))).toBe(true);
+        expect(existsSync(join(projectPath, 'src'))).toBe(true);
+    });
+
+    it('should handle force overwrite in current directory', async () => {
+        // Create some files in current directory
+        const testFile = join(tmpDir, 'existing-file.txt');
+        await writeFile(testFile, 'existing content');
+
+        // Create project in current directory with force flag
+        await createProject({
+            argv: ['.', '--template', 'vue2', '--force'],
+            cwd: tmpDir,
+            userAgent: 'npm/test'
+        });
+
+        // Verify project was created successfully in current directory
+        expect(existsSync(join(tmpDir, 'package.json'))).toBe(true);
+        expect(existsSync(join(tmpDir, 'src'))).toBe(true);
+        expect(existsSync(join(tmpDir, 'src/entry.client.ts'))).toBe(true);
+    });
+
+    it('should create project in current directory when target is "."', async () => {
+        // Create project in current directory
+        await createProject({
+            argv: ['.', '--template', 'vue2'],
+            cwd: tmpDir,
+            userAgent: 'npm/test'
+        });
+
+        // Verify project was created in current directory
+        expect(existsSync(join(tmpDir, 'package.json'))).toBe(true);
+        expect(existsSync(join(tmpDir, 'src'))).toBe(true);
+        expect(existsSync(join(tmpDir, 'src/entry.client.ts'))).toBe(true);
+    });
+
+    it('should handle various project name formats', async () => {
+        // Test with different naming styles
+        const testCases = [
+            'simple-name',
+            'nested/project-name',
+            'deep/nested/project-name'
+        ];
+
+        for (const projectName of testCases) {
+            const projectPath = join(tmpDir, projectName);
+
+            await createProject({
+                argv: [projectName, '--template', 'vue2'],
+                cwd: tmpDir,
+                userAgent: 'npm/test'
+            });
+
+            expect(existsSync(projectPath)).toBe(true);
+            expect(existsSync(join(projectPath, 'package.json'))).toBe(true);
+        }
+    });
+});

package/src/utils/index.ts

@@ -0,0 +1,11 @@
+export {
+    getCommand,
+    type CommandType
+} from './package-manager';
+
+export {
+    formatProjectName,
+    type ProjectNameResult
+} from './project-name';
+
+export { replaceTemplateVariables } from './template';