create-esmx 3.0.0-rc.104

package/dist/utils/project-name.test.mjs

@@ -0,0 +1,332 @@
+import { describe, expect, it } from "vitest";
+import { formatProjectName } from "./project-name.mjs";
+const isWindows = process.platform === "win32";
+const isUnix = !isWindows;
+describe("project-name utilities", () => {
+  describe("formatProjectName", () => {
+    it("should handle simple project name", () => {
+      const input = "foo";
+      const cwd = isWindows ? "C:\\workspace" : "/home/user";
+      const result = formatProjectName(input, cwd);
+      expect(result.name).toBe("foo");
+      if (isWindows) {
+        expect(result.root).toBe("C:\\workspace\\foo");
+      } else {
+        expect(result.root).toBe("/home/user/foo");
+      }
+    });
+    it("should handle nested path project name", () => {
+      const input = isWindows ? "foo\\bar" : "foo/bar";
+      const cwd = isWindows ? "C:\\workspace" : "/home/user";
+      const result = formatProjectName(input, cwd);
+      expect(result.name).toBe("bar");
+      if (isWindows) {
+        expect(result.root).toBe("C:\\workspace\\foo\\bar");
+      } else {
+        expect(result.root).toBe("/home/user/foo/bar");
+      }
+    });
+    it("should handle scoped package name", () => {
+      const input = "@scope/foo";
+      const cwd = isWindows ? "C:\\workspace" : "/home/user";
+      const result = formatProjectName(input, cwd);
+      expect(result.name).toBe("@scope/foo");
+      if (isWindows) {
+        expect(result.root).toBe("C:\\workspace\\@scope\\foo");
+      } else {
+        expect(result.root).toBe("/home/user/@scope/foo");
+      }
+    });
+    it("should handle relative path project name", () => {
+      const input = isWindows ? ".\\foo\\bar" : "./foo/bar";
+      const cwd = isWindows ? "C:\\workspace\\current" : "/home/user/current";
+      const result = formatProjectName(input, cwd);
+      expect(result.name).toBe("bar");
+      if (isWindows) {
+        expect(result.root).toBe("C:\\workspace\\current\\foo\\bar");
+      } else {
+        expect(result.root).toBe("/home/user/current/foo/bar");
+      }
+    });
+    it("should handle absolute path project name", () => {
+      const input = isWindows ? "C:\\projects\\my-app" : "/root/path/to/foo";
+      const cwd = isWindows ? "D:\\workspace" : "/home/user";
+      const result = formatProjectName(input, cwd);
+      if (isWindows) {
+        expect(result.name).toBe("my-app");
+        expect(result.root).toBe("C:\\projects\\my-app");
+      } else {
+        expect(result.name).toBe("foo");
+        expect(result.root).toBe("/root/path/to/foo");
+      }
+    });
+    it("should handle current directory", () => {
+      const input = ".";
+      const cwd = isWindows ? "C:\\Users\\Developer\\Projects\\WindowsApp" : "/home/user/projects/my-app";
+      const result = formatProjectName(input, cwd);
+      if (isWindows) {
+        expect(result.name).toBe("WindowsApp");
+        expect(result.root).toBe(
+          "C:\\Users\\Developer\\Projects\\WindowsApp"
+        );
+      } else {
+        expect(result.name).toBe("my-app");
+        expect(result.root).toBe("/home/user/projects/my-app");
+      }
+    });
+    it("should handle project name with trailing slashes", () => {
+      const input = isWindows ? "foo\\" : "foo/";
+      const cwd = isWindows ? "C:\\workspace" : "/home/user";
+      const result = formatProjectName(input, cwd);
+      expect(result.name).toBe("foo");
+      if (isWindows) {
+        expect(result.root).toBe("C:\\workspace\\foo");
+      } else {
+        expect(result.root).toBe("/home/user/foo");
+      }
+    });
+    it("should handle project name with multiple trailing slashes", () => {
+      const input = isWindows ? "foo\\\\\\" : "foo///";
+      const cwd = isWindows ? "C:\\workspace" : "/home/user";
+      const result = formatProjectName(input, cwd);
+      expect(result.name).toBe("foo");
+      if (isWindows) {
+        expect(result.root).toBe("C:\\workspace\\foo");
+      } else {
+        expect(result.root).toBe("/home/user/foo");
+      }
+    });
+    it("should handle deep nested path", () => {
+      const input = isWindows ? "path\\to\\nested\\project" : "path/to/nested/project";
+      const cwd = isWindows ? "C:\\workspace" : "/home/user";
+      const result = formatProjectName(input, cwd);
+      expect(result.name).toBe("project");
+      if (isWindows) {
+        expect(result.root).toBe(
+          "C:\\workspace\\path\\to\\nested\\project"
+        );
+      } else {
+        expect(result.root).toBe("/home/user/path/to/nested/project");
+      }
+    });
+    it("should handle scoped package with nested path", () => {
+      const input = isWindows ? "@company\\ui\\library" : "@company/ui/library";
+      const cwd = isWindows ? "C:\\workspace" : "/home/user";
+      const result = formatProjectName(input, cwd);
+      expect(result.name).toBe(input);
+      if (isWindows) {
+        expect(result.root).toBe(
+          "C:\\workspace\\@company\\ui\\library"
+        );
+      } else {
+        expect(result.root).toBe("/home/user/@company/ui/library");
+      }
+    });
+    it("should handle scoped package starting with @", () => {
+      const input = "@my-org/my-package";
+      const cwd = isWindows ? "C:\\workspace" : "/home/user";
+      const result = formatProjectName(input, cwd);
+      expect(result.name).toBe("@my-org/my-package");
+      if (isWindows) {
+        expect(result.root).toBe("C:\\workspace\\@my-org\\my-package");
+      } else {
+        expect(result.root).toBe("/home/user/@my-org/my-package");
+      }
+    });
+    it("should handle empty path segment", () => {
+      const input = isWindows ? "path\\\\with\\\\segments" : "path//with//segments";
+      const cwd = isWindows ? "C:\\workspace" : "/home/user";
+      const result = formatProjectName(input, cwd);
+      expect(result.name).toBe("segments");
+      if (isWindows) {
+        expect(result.root).toBe("C:\\workspace\\path\\with\\segments");
+      } else {
+        expect(result.root).toBe("/home/user/path/with/segments");
+      }
+    });
+    it("should handle single character project name", () => {
+      const input = "a";
+      const cwd = isWindows ? "C:\\workspace" : "/home/user";
+      const result = formatProjectName(input, cwd);
+      expect(result.name).toBe("a");
+      if (isWindows) {
+        expect(result.root).toBe("C:\\workspace\\a");
+      } else {
+        expect(result.root).toBe("/home/user/a");
+      }
+    });
+    it("should handle project name with numbers and hyphens", () => {
+      const input = "my-project-123";
+      const cwd = isWindows ? "C:\\workspace" : "/home/user";
+      const result = formatProjectName(input, cwd);
+      expect(result.name).toBe("my-project-123");
+      if (isWindows) {
+        expect(result.root).toBe("C:\\workspace\\my-project-123");
+      } else {
+        expect(result.root).toBe("/home/user/my-project-123");
+      }
+    });
+    it("should handle project name ending with slash", () => {
+      const input = isWindows ? "my-project\\" : "my-project/";
+      const cwd = isWindows ? "C:\\workspace" : "/home/user";
+      const result = formatProjectName(input, cwd);
+      expect(result.name).toBe("my-project");
+      if (isWindows) {
+        expect(result.root).toBe("C:\\workspace\\my-project");
+      } else {
+        expect(result.root).toBe("/home/user/my-project");
+      }
+    });
+    it("should fall back to default name when path ends with slash and no name", () => {
+      const input = "/";
+      const cwd = isWindows ? "C:\\workspace" : "/home/user";
+      const result = formatProjectName(input, cwd);
+      expect(result.root).toBe("/");
+      expect(result.name).toBe("esmx-project");
+    });
+    it.runIf(isWindows)(
+      "should handle Windows-style absolute paths",
+      () => {
+        const input = "C:\\projects\\my-app";
+        const cwd = "D:\\workspace";
+        const result = formatProjectName(input, cwd);
+        expect(result.name).toBe("my-app");
+        expect(result.root).toMatch(/projects[\\/]my-app/);
+      }
+    );
+    it.runIf(isWindows)("should handle Windows UNC paths", () => {
+      const input = "\\\\server\\share\\project";
+      const cwd = "C:\\workspace";
+      const result = formatProjectName(input, cwd);
+      expect(result.name).toBe("project");
+      expect(result.root).toMatch(/project$/);
+    });
+    it.runIf(isUnix)("should handle mixed path separators on Unix", () => {
+      const input = "path\\to/mixed/separators";
+      const cwd = "/home/user";
+      const result = formatProjectName(input, cwd);
+      expect(result.name).toBe("separators");
+      expect(result.root).toBe("/home/user/path\\to/mixed/separators");
+    });
+    it.runIf(isWindows)(
+      "should handle Windows-style relative paths",
+      () => {
+        const input = "foo\\bar";
+        const cwd = "C:\\workspace";
+        const result = formatProjectName(input, cwd);
+        expect(result.name).toBe("bar");
+        expect(result.root).toMatch(/workspace[\\/]foo[\\/]bar/);
+      }
+    );
+    it.runIf(isWindows)(
+      "should handle Windows-style trailing backslashes",
+      () => {
+        const input = "foo\\bar\\\\\\";
+        const cwd = "C:\\workspace";
+        const result = formatProjectName(input, cwd);
+        expect(result.name).toBe("bar");
+        expect(result.root).toMatch(/workspace[\\/]foo[\\/]bar/);
+      }
+    );
+  });
+  describe("formatProjectName with cwd parameter", () => {
+    it('should use custom cwd when input is "."', () => {
+      const input = ".";
+      const customCwd = isWindows ? "C:\\custom\\path\\to\\project" : "/custom/path/to/project";
+      const result = formatProjectName(
+        input,
+        customCwd
+      );
+      expect(result.name).toBe("project");
+      expect(result.root).toBe(customCwd);
+    });
+    it("should fallback to process.cwd() when cwd is not provided", () => {
+      const input = "test-project";
+      const result = formatProjectName(input);
+      expect(result.name).toBe("test-project");
+      expect(result.root).toMatch(/test-project$/);
+    });
+    it('should ignore cwd parameter when input is not "."', () => {
+      const input = "my-project";
+      const customCwd = isWindows ? "C:\\custom\\path" : "/custom/path";
+      const result = formatProjectName(
+        input,
+        customCwd
+      );
+      expect(result.name).toBe("my-project");
+      if (isWindows) {
+        expect(result.root).toBe("C:\\custom\\path\\my-project");
+      } else {
+        expect(result.root).toBe("/custom/path/my-project");
+      }
+    });
+    it("should handle scoped packages with custom cwd", () => {
+      const input = "@scope/foo";
+      const customCwd = isWindows ? "C:\\custom\\workspace" : "/custom/workspace";
+      const result = formatProjectName(
+        input,
+        customCwd
+      );
+      expect(result.name).toBe("@scope/foo");
+      if (isWindows) {
+        expect(result.root).toBe("C:\\custom\\workspace\\@scope\\foo");
+      } else {
+        expect(result.root).toBe("/custom/workspace/@scope/foo");
+      }
+    });
+    it("should handle nested paths with custom cwd", () => {
+      const input = isWindows ? "foo\\bar" : "foo/bar";
+      const customCwd = isWindows ? "C:\\custom\\workspace" : "/custom/workspace";
+      const result = formatProjectName(
+        input,
+        customCwd
+      );
+      expect(result.name).toBe("bar");
+      if (isWindows) {
+        expect(result.root).toBe("C:\\custom\\workspace\\foo\\bar");
+      } else {
+        expect(result.root).toBe("/custom/workspace/foo/bar");
+      }
+    });
+    it.runIf(isUnix)(
+      "should handle Unix-style absolute paths in cwd",
+      () => {
+        const input = "/root/path/to/foo";
+        const customCwd = "/this/should/be/ignored";
+        const result = formatProjectName(
+          input,
+          customCwd
+        );
+        expect(result.name).toBe("foo");
+        expect(result.root).toBe("/root/path/to/foo");
+      }
+    );
+    it.runIf(isWindows)(
+      "should handle Windows-style absolute paths in cwd",
+      () => {
+        const input = "C:\\projects\\my-app";
+        const customCwd = "D:\\this\\should\\be\\ignored";
+        const result = formatProjectName(
+          input,
+          customCwd
+        );
+        expect(result.name).toBe("my-app");
+        expect(result.root).toBe("C:\\projects\\my-app");
+      }
+    );
+    it("should handle absolute input paths and ignore cwd", () => {
+      const input = isWindows ? "C:\\projects\\absolute-project" : "/projects/absolute-project";
+      const customCwd = isWindows ? "D:\\ignored" : "/ignored";
+      const result = formatProjectName(
+        input,
+        customCwd
+      );
+      expect(result.name).toBe("absolute-project");
+      if (isWindows) {
+        expect(result.root).toBe("C:\\projects\\absolute-project");
+      } else {
+        expect(result.root).toBe("/projects/absolute-project");
+      }
+    });
+  });
+});

package/dist/utils/template.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Template variable replacement utilities
+ */
+/**
+ * Replace template variables in content using mustache-style syntax {{variableName}}
+ *
+ * @param content - The content string containing template variables
+ * @param variables - Object containing variable names and their replacement values
+ * @returns Content with all template variables replaced
+ *
+ * @example
+ * ```typescript
+ * const content = "Hello {{name}}, version {{version}}!";
+ * const variables = { name: "World", version: "1.0.0" };
+ * const result = replaceTemplateVariables(content, variables);
+ * // Result: "Hello World, version 1.0.0!"
+ * ```
+ */
+export declare function replaceTemplateVariables(content: string, variables: Record<string, string>): string;

package/dist/utils/template.mjs

@@ -0,0 +1,8 @@
+export function replaceTemplateVariables(content, variables) {
+  let result = content;
+  for (const [key, value] of Object.entries(variables)) {
+    const pattern = new RegExp(`\\{\\{${key}\\}\\}`, "g");
+    result = result.replace(pattern, value);
+  }
+  return result;
+}

package/dist/utils/template.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Unit tests for template variable replacement utilities
+ */
+export {};

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,75 @@
+{
+    "name": "create-esmx",
+    "version": "3.0.0-rc.104",
+    "description": "A scaffold tool for creating Esmx projects",
+    "type": "module",
+    "private": false,
+    "bin": {
+        "create-esmx": "./dist/create.mjs"
+    },
+    "template": "library-node",
+    "scripts": {
+        "lint:css": "pnpm run lint:js",
+        "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",
+        "postbuild": "node build/postbuild.mjs"
+    },
+    "dependencies": {
+        "@clack/prompts": "^0.7.0",
+        "minimist": "^1.2.8",
+        "picocolors": "^1.0.0"
+    },
+    "devDependencies": {
+        "@biomejs/biome": "2.3.7",
+        "@esmx/core": "3.0.0-rc.104",
+        "@esmx/rspack": "3.0.0-rc.104",
+        "@esmx/rspack-react": "3.0.0-rc.104",
+        "@esmx/rspack-vue": "3.0.0-rc.104",
+        "@types/minimist": "^1.2.5",
+        "@types/node": "^24.0.0",
+        "@vitest/coverage-v8": "3.2.4",
+        "typescript": "5.9.3",
+        "unbuild": "3.6.1",
+        "vitest": "3.2.4",
+        "vue": "^3.5.23"
+    },
+    "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"
+    ],
+    "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",
+    "gitHead": "329b299f906e7b59ba909a23b6c96509405ced51"
+}