create-esmx 3.0.0-rc.104

package/src/project.test.ts

@@ -0,0 +1,200 @@
+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 { createProjectFromTemplate } from './project';
+import { getEsmxVersion } from './template';
+import { formatProjectName } from './utils/index';
+
+async function createTempDir(prefix = 'esmx-unit-test-'): Promise<string> {
+    return mkdtemp(join(tmpdir(), prefix));
+}
+
+async function cleanupTempDir(tmpDir: string): Promise<void> {
+    await rm(tmpDir, { recursive: true, force: true });
+}
+
+describe('project unit tests', () => {
+    let tmpDir: string;
+
+    beforeEach(async () => {
+        tmpDir = await createTempDir();
+    });
+
+    afterEach(async () => {
+        await cleanupTempDir(tmpDir);
+    });
+
+    it('should handle isDirectoryEmpty edge cases', async () => {
+        const hiddenFilesDir = join(tmpDir, 'hidden-files-dir');
+        await mkdir(hiddenFilesDir, { recursive: true });
+        await writeFile(join(hiddenFilesDir, '.hidden-file'), 'hidden content');
+        await writeFile(join(hiddenFilesDir, '.gitignore'), 'node_modules/');
+
+        const projectNameInput = 'hidden-files-dir';
+        const { name, root } = formatProjectName(projectNameInput, tmpDir);
+
+        // Create project from template
+        await createProjectFromTemplate(root, 'vue2-csr', tmpDir, false, {
+            projectName: name,
+            esmxVersion: getEsmxVersion(),
+            installCommand: 'npm install',
+            devCommand: 'npm run dev',
+            buildCommand: 'npm run build',
+            startCommand: 'npm start',
+            buildTypeCommand: 'npm run build:type',
+            lintTypeCommand: 'npm run lint:type'
+        });
+
+        // Should succeed because hidden files are ignored
+        expect(existsSync(join(hiddenFilesDir, 'package.json'))).toBe(true);
+    });
+
+    it('should handle directory creation for nested paths', async () => {
+        const deepPath = join(
+            tmpDir,
+            'very',
+            'deep',
+            'nested',
+            'path',
+            'project'
+        );
+
+        // Get project name and target directory
+        const projectNameInput = 'very/deep/nested/path/project';
+        const { name, root } = formatProjectName(projectNameInput, tmpDir);
+
+        // Create project from template
+        await createProjectFromTemplate(root, 'vue2-csr', tmpDir, false, {
+            projectName: name,
+            esmxVersion: getEsmxVersion(),
+            installCommand: 'npm install',
+            devCommand: 'npm run dev',
+            buildCommand: 'npm run build',
+            startCommand: 'npm start',
+            buildTypeCommand: 'npm run build:type',
+            lintTypeCommand: 'npm run lint:type'
+        });
+
+        expect(existsSync(deepPath)).toBe(true);
+        expect(existsSync(join(deepPath, 'package.json'))).toBe(true);
+    });
+
+    it('should handle file copy with template variable replacement', async () => {
+        const projectPath = join(tmpDir, 'variable-test');
+
+        // Get project name and target directory
+        const projectNameInput = 'variable-test';
+        const { name, root } = formatProjectName(projectNameInput, tmpDir);
+
+        // Create project from template
+        await createProjectFromTemplate(root, 'vue2-csr', tmpDir, false, {
+            projectName: name,
+            esmxVersion: getEsmxVersion(),
+            installCommand: 'npm install',
+            devCommand: 'npm run dev',
+            buildCommand: 'npm run build',
+            startCommand: 'npm start',
+            buildTypeCommand: 'npm run build:type',
+            lintTypeCommand: 'npm run lint:type'
+        });
+
+        // Verify that package.json contains replaced variables
+        const packageJsonPath = join(projectPath, 'package.json');
+        expect(existsSync(packageJsonPath)).toBe(true);
+
+        const packageContent = require('node:fs').readFileSync(
+            packageJsonPath,
+            'utf-8'
+        );
+        const packageJson = JSON.parse(packageContent);
+        expect(packageJson.name).toBe('variable-test');
+    });
+
+    it('should handle empty directory detection correctly', async () => {
+        // Test completely empty directory
+        const emptyDir = join(tmpDir, 'empty-dir');
+        await mkdir(emptyDir, { recursive: true });
+
+        // Get project name and target directory
+        const projectNameInput = 'empty-dir';
+        const { name, root } = formatProjectName(projectNameInput, tmpDir);
+
+        // Create project from template
+        await createProjectFromTemplate(root, 'vue2-csr', tmpDir, false, {
+            projectName: name,
+            esmxVersion: getEsmxVersion(),
+            installCommand: 'npm install',
+            devCommand: 'npm run dev',
+            buildCommand: 'npm run build',
+            startCommand: 'npm start',
+            buildTypeCommand: 'npm run build:type',
+            lintTypeCommand: 'npm run lint:type'
+        });
+
+        expect(existsSync(join(emptyDir, 'package.json'))).toBe(true);
+    });
+
+    it('should handle mixed file types in directory', async () => {
+        // Test directory with mix of hidden and non-hidden files
+        const mixedDir = join(tmpDir, 'mixed-dir');
+        await mkdir(mixedDir, { recursive: true });
+        await writeFile(join(mixedDir, '.dotfile'), 'hidden');
+        await writeFile(join(mixedDir, 'regular-file.txt'), 'visible');
+
+        // Get project name and target directory
+        const projectNameInput = 'mixed-dir';
+        const { name, root } = formatProjectName(projectNameInput, tmpDir);
+
+        // Create project from template with force flag
+        await createProjectFromTemplate(
+            root,
+            'vue2-csr',
+            tmpDir,
+            true, // force flag
+            {
+                projectName: name,
+                esmxVersion: getEsmxVersion(),
+                installCommand: 'npm install',
+                devCommand: 'npm run dev',
+                buildCommand: 'npm run build',
+                startCommand: 'npm start',
+                buildTypeCommand: 'npm run build:type',
+                lintTypeCommand: 'npm run lint:type'
+            }
+        );
+
+        expect(existsSync(join(mixedDir, 'package.json'))).toBe(true);
+    });
+
+    it('should handle special characters in project names', async () => {
+        const specialNames = [
+            'project-with-dashes',
+            'project_with_underscores',
+            'project.with.dots'
+        ];
+
+        for (const projectName of specialNames) {
+            const projectPath = join(tmpDir, projectName);
+
+            // Get project name and target directory
+            const { name, root } = formatProjectName(projectName, tmpDir);
+
+            // Create project from template
+            await createProjectFromTemplate(root, 'vue2-csr', tmpDir, false, {
+                projectName: name,
+                esmxVersion: getEsmxVersion(),
+                installCommand: 'npm install',
+                devCommand: 'npm run dev',
+                buildCommand: 'npm run build',
+                startCommand: 'npm start',
+                buildTypeCommand: 'npm run build:type',
+                lintTypeCommand: 'npm run lint:type'
+            });
+
+            expect(existsSync(projectPath)).toBe(true);
+            expect(existsSync(join(projectPath, 'package.json'))).toBe(true);
+        }
+    });
+});

package/src/project.ts

@@ -0,0 +1,75 @@
+import { existsSync, mkdirSync } from 'node:fs';
+import { dirname, isAbsolute, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { cancel, confirm, isCancel } from '@clack/prompts';
+import { copyTemplateFiles, isDirectoryEmpty } from './template';
+import type { TemplateVariables } from './types';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+/**
+ * Create a project from template
+ */
+export async function createProjectFromTemplate(
+    targetDir: string,
+    templateType: string,
+    workingDir: string,
+    force: boolean,
+    variables: TemplateVariables
+): Promise<void> {
+    const templatePath = resolve(__dirname, '../template', templateType);
+    const targetPath = isAbsolute(targetDir)
+        ? targetDir
+        : 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);
+}

package/src/template.test.ts

@@ -0,0 +1,135 @@
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { mkdir, mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import {
+    copyTemplateFiles,
+    getAvailableTemplates,
+    getEsmxVersion,
+    isDirectoryEmpty
+} from './template';
+
+// Test utilities
+async function createTempDir(prefix = 'esmx-template-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('template unit tests', () => {
+    let tmpDir: string;
+
+    beforeEach(async () => {
+        tmpDir = await createTempDir();
+    });
+
+    afterEach(async () => {
+        await cleanupTempDir(tmpDir);
+    });
+
+    it('should get Esmx version from package.json', () => {
+        const version = getEsmxVersion();
+        // 版本可能是 x.y.z 格式，也可能是 x.y.z-rc.n 格式，或 'latest'
+        expect(typeof version).toBe('string');
+        expect(version.length).toBeGreaterThan(0);
+    });
+
+    it('should get available templates', () => {
+        const templates = getAvailableTemplates();
+        expect(templates.length).toBeGreaterThan(0);
+        expect(templates[0]).toHaveProperty('folder');
+        expect(templates[0]).toHaveProperty('name');
+        expect(templates[0]).toHaveProperty('description');
+    });
+
+    it('should detect empty directory', async () => {
+        // Create empty directory
+        const emptyDir = join(tmpDir, 'empty');
+        await mkdir(emptyDir);
+        expect(isDirectoryEmpty(emptyDir)).toBe(true);
+
+        // Create directory with only hidden files
+        const hiddenDir = join(tmpDir, 'hidden');
+        await mkdir(hiddenDir);
+        writeFileSync(join(hiddenDir, '.hiddenfile'), 'hidden');
+        expect(isDirectoryEmpty(hiddenDir)).toBe(true);
+
+        // Create directory with visible files
+        const nonEmptyDir = join(tmpDir, 'non-empty');
+        await mkdir(nonEmptyDir);
+        writeFileSync(join(nonEmptyDir, 'visible.txt'), 'visible');
+        expect(isDirectoryEmpty(nonEmptyDir)).toBe(false);
+    });
+
+    it('should copy template files with variable replacement', () => {
+        // Create a simple template
+        const templateDir = join(tmpDir, 'template');
+        const targetDir = join(tmpDir, 'target');
+
+        mkdirSync(templateDir, { recursive: true });
+        mkdirSync(join(templateDir, 'src'), { recursive: true });
+        mkdirSync(targetDir, { recursive: true });
+
+        // Create template files with variables
+        writeFileSync(
+            join(templateDir, 'package.json'),
+            JSON.stringify({
+                name: '{{projectName}}',
+                version: '1.0.0',
+                dependencies: {
+                    esmx: '{{esmxVersion}}'
+                },
+                scripts: {
+                    dev: '{{devCommand}}',
+                    build: '{{buildCommand}}'
+                }
+            })
+        );
+
+        writeFileSync(
+            join(templateDir, 'src', 'index.ts'),
+            'console.log("Welcome to {{projectName}}!");'
+        );
+
+        // Copy with variable replacement
+        copyTemplateFiles(templateDir, targetDir, {
+            projectName: 'test-project',
+            esmxVersion: '1.2.3',
+            devCommand: 'npm run dev',
+            buildCommand: 'npm run build',
+            installCommand: 'npm install',
+            startCommand: 'npm start',
+            buildTypeCommand: 'npm run build:type',
+            lintTypeCommand: 'npm run lint:type'
+        });
+
+        // Check that files were created
+        expect(existsSync(join(targetDir, 'package.json'))).toBe(true);
+        expect(existsSync(join(targetDir, 'src', 'index.ts'))).toBe(true);
+
+        // Check variable replacement in package.json
+        const packageJson = JSON.parse(
+            require('node:fs').readFileSync(
+                join(targetDir, 'package.json'),
+                'utf-8'
+            )
+        );
+        expect(packageJson.name).toBe('test-project');
+        expect(packageJson.dependencies.esmx).toBe('1.2.3');
+        expect(packageJson.scripts.dev).toBe('npm run dev');
+
+        // Check variable replacement in source file
+        const indexContent = require('node:fs').readFileSync(
+            join(targetDir, 'src', 'index.ts'),
+            'utf-8'
+        );
+        expect(indexContent).toBe('console.log("Welcome to test-project!");');
+    });
+});

package/src/template.ts

@@ -0,0 +1,117 @@
+import {
+    existsSync,
+    mkdirSync,
+    readdirSync,
+    readFileSync,
+    statSync,
+    writeFileSync
+} from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import type { TemplateInfo, TemplateVariables } from './types';
+import { replaceTemplateVariables } from './utils/index';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+/**
+ * Get version of esmx from package.json
+ */
+export 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';
+    }
+}
+
+/**
+ * Get list of available templates
+ */
+export 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));
+}
+
+/**
+ * Check if directory is empty (ignoring hidden files)
+ */
+export 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;
+}
+
+/**
+ * Copy template files to target directory with variable replacement
+ */
+export 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);
+        }
+    }
+}

package/src/types.ts

@@ -0,0 +1,32 @@
+/**
+ * Options for project creation
+ */
+export interface CliOptions {
+    argv?: string[]; // Command line arguments
+    cwd?: string; // Working directory
+    userAgent?: string; // Package manager user agent
+    version?: string; // Esmx version override
+}
+
+/**
+ * Template information structure
+ */
+export interface TemplateInfo {
+    folder: string;
+    name: string;
+    description: string;
+}
+
+/**
+ * Variables used in templates for replacement
+ */
+export interface TemplateVariables extends Record<string, string> {
+    projectName: string;
+    esmxVersion: string;
+    installCommand: string;
+    devCommand: string;
+    buildCommand: string;
+    startCommand: string;
+    buildTypeCommand: string;
+    lintTypeCommand: string;
+}

package/src/utils/index.ts

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