create-esmx 3.0.0-rc.33

package/dist/utils/template.test.mjs

@@ -0,0 +1,150 @@
+import { describe, expect, it } from "vitest";
+import { replaceTemplateVariables } from "./template.mjs";
+describe("replaceTemplateVariables", () => {
+  describe("basic functionality", () => {
+    it("should replace single variable", () => {
+      const content = "Hello {{name}}!";
+      const variables = { name: "World" };
+      const result = replaceTemplateVariables(content, variables);
+      expect(result).toBe("Hello World!");
+    });
+    it("should replace multiple different variables", () => {
+      const content = "Project {{projectName}} version {{version}}";
+      const variables = {
+        projectName: "my-app",
+        version: "1.0.0"
+      };
+      const result = replaceTemplateVariables(content, variables);
+      expect(result).toBe("Project my-app version 1.0.0");
+    });
+    it("should replace same variable multiple times", () => {
+      const content = "{{greeting}} {{name}}, {{greeting}} again!";
+      const variables = {
+        greeting: "Hello",
+        name: "World"
+      };
+      const result = replaceTemplateVariables(content, variables);
+      expect(result).toBe("Hello World, Hello again!");
+    });
+  });
+  describe("edge cases", () => {
+    it("should handle content without variables", () => {
+      const content = "No variables here";
+      const variables = { name: "World" };
+      const result = replaceTemplateVariables(content, variables);
+      expect(result).toBe("No variables here");
+    });
+    it("should handle empty variables object", () => {
+      const content = "Hello {{name}}!";
+      const variables = {};
+      const result = replaceTemplateVariables(content, variables);
+      expect(result).toBe("Hello {{name}}!");
+    });
+    it("should handle empty content", () => {
+      const content = "";
+      const variables = { name: "World" };
+      const result = replaceTemplateVariables(content, variables);
+      expect(result).toBe("");
+    });
+    it("should handle variables with special characters", () => {
+      const content = "Command: {{installCommand}}";
+      const variables = { installCommand: "npm install --save-dev" };
+      const result = replaceTemplateVariables(content, variables);
+      expect(result).toBe("Command: npm install --save-dev");
+    });
+    it("should handle variables with regex special characters", () => {
+      const content = "Pattern: {{pattern}}";
+      const variables = { pattern: "[a-z]+.*$" };
+      const result = replaceTemplateVariables(content, variables);
+      expect(result).toBe("Pattern: [a-z]+.*$");
+    });
+  });
+  describe("real-world scenarios", () => {
+    it("should handle all template variables from create-esmx", () => {
+      const content = `# {{projectName}}
+
+Install dependencies:
+\`\`\`bash
+{{installCommand}}
+\`\`\`
+
+Start development:
+\`\`\`bash
+{{devCommand}}
+\`\`\`
+
+Build for production:
+\`\`\`bash
+{{buildCommand}}
+\`\`\`
+
+Start production server:
+\`\`\`bash
+{{startCommand}}
+\`\`\`
+
+Esmx version: {{esmxVersion}}`;
+      const variables = {
+        projectName: "my-awesome-app",
+        installCommand: "pnpm install",
+        devCommand: "pnpm dev",
+        buildCommand: "pnpm build",
+        startCommand: "pnpm start",
+        esmxVersion: "3.0.0-rc.33"
+      };
+      const result = replaceTemplateVariables(content, variables);
+      expect(result).toContain("# my-awesome-app");
+      expect(result).toContain("pnpm install");
+      expect(result).toContain("pnpm dev");
+      expect(result).toContain("pnpm build");
+      expect(result).toContain("pnpm start");
+      expect(result).toContain("3.0.0-rc.33");
+      expect(result).not.toContain("{{");
+      expect(result).not.toContain("}}");
+    });
+    it("should handle package.json template", () => {
+      const content = `{
+  "name": "{{projectName}}",
+  "version": "1.0.0",
+  "scripts": {
+    "dev": "esmx dev",
+    "build": "esmx build",
+    "start": "esmx start"
+  },
+  "dependencies": {
+    "esmx": "{{esmxVersion}}"
+  }
+}`;
+      const variables = {
+        projectName: "@scope/my-package",
+        esmxVersion: "^3.0.0"
+      };
+      const result = replaceTemplateVariables(content, variables);
+      expect(result).toContain('"name": "@scope/my-package"');
+      expect(result).toContain('"esmx": "^3.0.0"');
+    });
+  });
+  describe("variable name validation", () => {
+    it("should handle variables with underscores", () => {
+      const content = "Command: {{install_command}}";
+      const variables = { install_command: "npm install" };
+      const result = replaceTemplateVariables(content, variables);
+      expect(result).toBe("Command: npm install");
+    });
+    it("should handle variables with numbers", () => {
+      const content = "Node version: {{node18}}";
+      const variables = { node18: "v18.12.0" };
+      const result = replaceTemplateVariables(content, variables);
+      expect(result).toBe("Node version: v18.12.0");
+    });
+    it("should be case sensitive", () => {
+      const content = "Hello {{Name}} and {{name}}!";
+      const variables = {
+        Name: "Alice",
+        name: "Bob"
+      };
+      const result = replaceTemplateVariables(content, variables);
+      expect(result).toBe("Hello Alice and Bob!");
+    });
+  });
+});

package/package.json

@@ -0,0 +1,71 @@
+{
+    "name": "create-esmx",
+    "version": "3.0.0-rc.33",
+    "description": "A scaffold tool for creating Esmx projects",
+    "type": "module",
+    "private": false,
+    "bin": {
+        "create-esmx": "./dist/index.mjs"
+    },
+    "template": "library-node",
+    "scripts": {
+        "lint:css": "stylelint '**/*.{css,vue}' --fix --aei",
+        "lint:type": "tsc --noEmit",
+        "test": "vitest run --pass-with-no-tests",
+        "coverage": "vitest run --coverage --pass-with-no-tests",
+        "lint:js": "biome check --write --no-errors-on-unmatched",
+        "build": "unbuild"
+    },
+    "dependencies": {
+        "@clack/prompts": "^0.7.0",
+        "picocolors": "^1.0.0",
+        "minimist": "^1.2.8"
+    },
+    "devDependencies": {
+        "@esmx/lint": "3.0.0-rc.33",
+        "@types/node": "^24.0.0",
+        "@types/minimist": "^1.2.5",
+        "stylelint": "16.21.0",
+        "typescript": "5.8.3",
+        "vitest": "3.2.4",
+        "@vitest/coverage-v8": "3.2.4",
+        "@biomejs/biome": "1.9.4",
+        "unbuild": "3.5.0"
+    },
+    "exports": {
+        ".": {
+            "import": "./dist/index.mjs",
+            "types": "./dist/index.d.ts"
+        }
+    },
+    "module": "dist/index.mjs",
+    "types": "./dist/index.d.ts",
+    "files": [
+        "lib",
+        "src",
+        "dist",
+        "*.mjs",
+        "template",
+        "public",
+        "bin"
+    ],
+    "keywords": [
+        "esmx",
+        "scaffold",
+        "template",
+        "vue",
+        "ssr",
+        "esm"
+    ],
+    "author": "Esmx Team",
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/esmnext/esmx.git",
+        "directory": "packages/create-esmx"
+    },
+    "bugs": {
+        "url": "https://github.com/esmnext/esmx/issues"
+    },
+    "homepage": "https://github.com/esmnext/esmx#readme"
+}

package/src/index.test.ts

@@ -0,0 +1,159 @@
+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);
+        }
+    });
+});