create-esmx 3.0.0-rc.35 → 3.0.0-rc.37

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,
+    readFileSync,
+    readdirSync,
+    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,31 @@
+/**
+ * Options for project creation
+ */
+export interface CliOptions {
+    argv?: string[]; // Command line arguments
+    cwd?: string; // Working directory
+    userAgent?: string; // Package manager user agent
+}
+
+/**
+ * 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/template.test.ts

@@ -170,7 +170,7 @@ Esmx version: {{esmxVersion}}`;
   "scripts": {
     "dev": "esmx dev",
     "build": "esmx build",
-    "start": "esmx start"
+    "start": "NODE_ENV=production node dist/index.mjs"
   },
   "dependencies": {
     "esmx": "{{esmxVersion}}"

package/template/vue2/README.md

@@ -60,7 +60,7 @@ Visit http://localhost:3000 to see the development environment.
 │   │   └── hello-world.vue # Example component with counter functionality
 │   ├── create-app.ts       # Vue instance creation
 │   ├── entry.client.ts     # Client-side entry
-│   ├── entry.node.ts       # Server-side rendering entry
+│   ├── entry.node.ts       # Node.js environment entry point
 │   └── entry.server.ts     # Server-side rendering functions
 ├── package.json
 ├── tsconfig.json

package/template/vue2/package.json

@@ -8,7 +8,7 @@
         "dev": "esmx dev",
         "build": "esmx build",
         "preview": "esmx preview",
-        "start": "esmx start",
+        "start": "NODE_ENV=production node dist/index.mjs",
         "lint:type": "vue-tsc --noEmit",
         "build:type": "vue-tsc --declaration --emitDeclarationOnly --noEmit false --outDir dist/src && tsc-alias -p tsconfig.json --outDir dist/src"
     },

package/template/vue2/src/components/hello-world.vue

@@ -28,11 +28,9 @@ const count = ref<number>(0);
 <style scoped>
 .card {
 	padding: 2em;
-	border: 1px solid var(--border-color);
 	border-radius: 12px;
 	margin: 2.5em 0;
 	background-color: var(--bg-card);
-	box-shadow: 0 4px 12px var(--shadow-color);
 }
 
 button {

package/dist/index.test.mjs

@@ -1,123 +0,0 @@
-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.mjs";
-async function createTempDir(prefix = "esmx-unit-test-") {
-  return mkdtemp(join(tmpdir(), prefix));
-}
-async function cleanupTempDir(tempDir) {
-  try {
-    await rm(tempDir, { recursive: true, force: true });
-  } catch (error) {
-    console.warn(`Failed to cleanup temp directory: ${tempDir}`, error);
-  }
-}
-describe("createProject unit tests", () => {
-  let tmpDir;
-  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/");
-    await createProject({
-      argv: ["hidden-files-dir", "--template", "vue2"],
-      cwd: tmpDir,
-      userAgent: "npm/test"
-    });
-    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"
-    );
-    await createProject({
-      argv: ["very/deep/nested/path/project", "--template", "vue2"],
-      cwd: tmpDir,
-      userAgent: "npm/test"
-    });
-    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");
-    await createProject({
-      argv: ["variable-test", "--template", "vue2"],
-      cwd: tmpDir,
-      userAgent: "npm/test"
-    });
-    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 () => {
-    const emptyDir = join(tmpDir, "empty-dir");
-    await mkdir(emptyDir, { recursive: true });
-    await createProject({
-      argv: ["empty-dir", "--template", "vue2"],
-      cwd: tmpDir,
-      userAgent: "npm/test"
-    });
-    expect(existsSync(join(emptyDir, "package.json"))).toBe(true);
-  });
-  it("should handle mixed file types in directory", async () => {
-    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");
-    await createProject({
-      argv: ["mixed-dir", "--template", "vue2", "--force"],
-      cwd: tmpDir,
-      userAgent: "npm/test"
-    });
-    expect(existsSync(join(mixedDir, "package.json"))).toBe(true);
-  });
-  it("should handle various package manager user agents", async () => {
-    const testCases = ["npm", "yarn", "pnpm", "bun"];
-    for (const userAgent of testCases) {
-      const projectName = `test-${userAgent}`;
-      const projectPath = join(tmpDir, projectName);
-      await createProject({
-        argv: [projectName, "--template", "vue2"],
-        cwd: tmpDir,
-        userAgent: `${userAgent}/test-version`
-      });
-      expect(existsSync(projectPath)).toBe(true);
-      expect(existsSync(join(projectPath, "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);
-      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/index.test.ts

@@ -1,159 +0,0 @@
-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-unit-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('createProject unit tests', () => {
-    let tmpDir: string;
-
-    beforeEach(async () => {
-        tmpDir = await createTempDir();
-    });
-
-    afterEach(async () => {
-        await cleanupTempDir(tmpDir);
-    });
-
-    it('should handle isDirectoryEmpty edge cases', async () => {
-        // Test with directory containing only hidden files
-        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/');
-
-        await createProject({
-            argv: ['hidden-files-dir', '--template', 'vue2'],
-            cwd: tmpDir,
-            userAgent: 'npm/test'
-        });
-
-        // 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'
-        );
-
-        await createProject({
-            argv: ['very/deep/nested/path/project', '--template', 'vue2'],
-            cwd: tmpDir,
-            userAgent: 'npm/test'
-        });
-
-        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');
-
-        await createProject({
-            argv: ['variable-test', '--template', 'vue2'],
-            cwd: tmpDir,
-            userAgent: 'npm/test'
-        });
-
-        // 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 });
-
-        await createProject({
-            argv: ['empty-dir', '--template', 'vue2'],
-            cwd: tmpDir,
-            userAgent: 'npm/test'
-        });
-
-        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');
-
-        // This should require force flag since directory is not empty
-        await createProject({
-            argv: ['mixed-dir', '--template', 'vue2', '--force'],
-            cwd: tmpDir,
-            userAgent: 'npm/test'
-        });
-
-        expect(existsSync(join(mixedDir, 'package.json'))).toBe(true);
-    });
-
-    it('should handle various package manager user agents', async () => {
-        const testCases = ['npm', 'yarn', 'pnpm', 'bun'];
-
-        for (const userAgent of testCases) {
-            const projectName = `test-${userAgent}`;
-            const projectPath = join(tmpDir, projectName);
-
-            await createProject({
-                argv: [projectName, '--template', 'vue2'],
-                cwd: tmpDir,
-                userAgent: `${userAgent}/test-version`
-            });
-
-            expect(existsSync(projectPath)).toBe(true);
-            expect(existsSync(join(projectPath, '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);
-
-            await createProject({
-                argv: [projectName, '--template', 'vue2'],
-                cwd: tmpDir,
-                userAgent: 'npm/test'
-            });
-
-            expect(existsSync(projectPath)).toBe(true);
-            expect(existsSync(join(projectPath, 'package.json'))).toBe(true);
-        }
-    });
-});