create-esmx 3.0.0-rc.45 → 3.0.0-rc.47

package/dist/cli.integration.test.mjs

@@ -109,13 +109,13 @@ describe("create-esmx CLI integration tests", () => {
   it("should handle --force parameter correctly", async () => {
     const projectPath = join(tmpDir, "test-project");
     await cli({
-      argv: ["test-project", "--template", "vue2"],
+      argv: ["test-project", "--template", "vue2-csr"],
       cwd: tmpDir,
       userAgent: "npm/test"
     });
     expect(existsSync(join(projectPath, "package.json"))).toBe(true);
     await cli({
-      argv: ["test-project", "--template", "vue2", "--force"],
+      argv: ["test-project", "--template", "vue2-csr", "--force"],
       cwd: tmpDir,
       userAgent: "npm/test"
     });
@@ -167,7 +167,11 @@ describe("create-esmx CLI integration tests", () => {
   it("should handle creating directory when target directory does not exist", async () => {
     const projectPath = join(tmpDir, "non-existent-parent", "test-project");
     await cli({
-      argv: ["non-existent-parent/test-project", "--template", "vue2"],
+      argv: [
+        "non-existent-parent/test-project",
+        "--template",
+        "vue2-csr"
+      ],
       cwd: tmpDir,
       userAgent: "npm/test"
     });
@@ -183,7 +187,7 @@ describe("create-esmx CLI integration tests", () => {
       "existing content"
     );
     await cli({
-      argv: ["test-project", "--template", "vue2", "--force"],
+      argv: ["test-project", "--template", "vue2-csr", "--force"],
       cwd: tmpDir,
       userAgent: "npm/test"
     });
@@ -194,7 +198,7 @@ describe("create-esmx CLI integration tests", () => {
     const testFile = join(tmpDir, "existing-file.txt");
     await writeFile(testFile, "existing content");
     await cli({
-      argv: [".", "--template", "vue2", "--force"],
+      argv: [".", "--template", "vue2-csr", "--force"],
       cwd: tmpDir,
       userAgent: "npm/test"
     });
@@ -204,7 +208,7 @@ describe("create-esmx CLI integration tests", () => {
   });
   it('should create project in current directory when target is "."', async () => {
     await cli({
-      argv: [".", "--template", "vue2"],
+      argv: [".", "--template", "vue2-csr"],
       cwd: tmpDir,
       userAgent: "npm/test"
     });
@@ -221,7 +225,7 @@ describe("create-esmx CLI integration tests", () => {
     for (const projectName of testCases) {
       const projectPath = join(tmpDir, projectName);
       await cli({
-        argv: [projectName, "--template", "vue2"],
+        argv: [projectName, "--template", "vue2-csr"],
         cwd: tmpDir,
         userAgent: "npm/test"
       });

package/dist/cli.mjs

@@ -22,7 +22,7 @@ ${color.bold("Usage:")}
   ${createCmd} [project-name] [options]
 
 ${color.bold("Options:")}
-  -t, --template <template>    Template to use (default: vue2)
+  -t, --template <template>    Template to use (default: vue2-csr)
   -n, --name <name>            Project name or path
   -f, --force                  Force overwrite existing directory
   -h, --help                   Show help information
@@ -30,9 +30,9 @@ ${color.bold("Options:")}
 
 ${color.bold("Examples:")}
   ${createCmd} my-project
-  ${createCmd} my-project -t vue2
+  ${createCmd} my-project -t vue2-csr
   ${createCmd} my-project --force
-  ${createCmd} . -f -t vue2
+  ${createCmd} . -f -t vue2-csr
 
 ${color.bold("Available Templates:")}
 ${getAvailableTemplates().map((t) => `  ${t.folder.padEnd(25)} ${t.description}`).join("\n")}
@@ -73,10 +73,10 @@ async function getTemplateType(argTemplate) {
     message: "Select a template:",
     options
   });
-  return template;
+  return String(template);
 }
 export async function cli(options = {}) {
-  const { argv, cwd, userAgent } = options;
+  const { argv, cwd, userAgent, version } = options;
   const commandLineArgs = argv || process.argv.slice(2);
   const workingDir = cwd || process.cwd();
   const parsedArgs = minimist(commandLineArgs, {
@@ -112,10 +112,7 @@ export async function cli(options = {}) {
     cancel("Operation cancelled");
     return;
   }
-  const { packageName, targetDir } = formatProjectName(
-    projectNameInput,
-    workingDir
-  );
+  const { name, root } = formatProjectName(projectNameInput, workingDir);
   const templateType = await getTemplateType(parsedArgs.template);
   if (isCancel(templateType)) {
     cancel("Operation cancelled");
@@ -128,13 +125,13 @@ export async function cli(options = {}) {
   const buildTypeCommand = getCommand("build:type", userAgent);
   const lintTypeCommand = getCommand("lint:type", userAgent);
   await createProjectFromTemplate(
-    targetDir,
+    root,
     templateType,
     workingDir,
     parsedArgs.force,
     {
-      projectName: packageName,
-      esmxVersion: getEsmxVersion(),
+      projectName: name,
+      esmxVersion: version || getEsmxVersion(),
       installCommand,
       devCommand,
       buildCommand,
@@ -145,12 +142,16 @@ export async function cli(options = {}) {
   );
   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)}`)
-  ];
+  const targetDirForDisplay = projectNameInput === "." ? "." : projectNameInput;
+  const steps = [
+    projectNameInput !== "." ? `cd ${targetDirForDisplay}` : null,
+    installCmd,
+    `git init ${color.gray("(optional)")}`,
+    devCmd
+  ].filter(Boolean);
+  const nextSteps = steps.map((step, index) => {
+    return color.reset(`${index + 1}. ${color.cyan(step)}`);
+  });
   note(nextSteps.join("\n"), "Next steps");
   outro(color.reset(color.green("Happy coding! \u{1F389}")));
 }

package/dist/index.d.ts

@@ -1 +1,3 @@
 export { cli } from './cli';
+export { getAvailableTemplates } from './template';
+export type { TemplateInfo } from './types';

package/dist/index.mjs

@@ -1 +1,2 @@
 export { cli } from "./cli.mjs";
+export { getAvailableTemplates } from "./template.mjs";

package/dist/project.mjs

@@ -1,12 +1,12 @@
 import { existsSync, mkdirSync } from "node:fs";
-import { dirname, resolve } from "node:path";
+import { dirname, isAbsolute, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { cancel, confirm, isCancel } from "@clack/prompts";
 import { copyTemplateFiles, isDirectoryEmpty } from "./template.mjs";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 export async function createProjectFromTemplate(targetDir, templateType, workingDir, force, variables) {
   const templatePath = resolve(__dirname, "../template", templateType);
-  const targetPath = targetDir === "." ? workingDir : resolve(workingDir, targetDir);
+  const targetPath = isAbsolute(targetDir) ? targetDir : targetDir === "." ? workingDir : resolve(workingDir, targetDir);
   if (!existsSync(templatePath)) {
     throw new Error(`Template "${templateType}" not found`);
   }

package/dist/project.test.mjs

@@ -9,12 +9,8 @@ import { formatProjectName } from "./utils/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);
-  }
+async function cleanupTempDir(tmpDir) {
+  await rm(tmpDir, { recursive: true, force: true });
 }
 describe("project unit tests", () => {
   let tmpDir;
@@ -30,12 +26,9 @@ describe("project unit tests", () => {
     await writeFile(join(hiddenFilesDir, ".hidden-file"), "hidden content");
     await writeFile(join(hiddenFilesDir, ".gitignore"), "node_modules/");
     const projectNameInput = "hidden-files-dir";
-    const { packageName, targetDir } = formatProjectName(
-      projectNameInput,
-      tmpDir
-    );
-    await createProjectFromTemplate(targetDir, "vue2", tmpDir, false, {
-      projectName: packageName,
+    const { name, root } = formatProjectName(projectNameInput, tmpDir);
+    await createProjectFromTemplate(root, "vue2-csr", tmpDir, false, {
+      projectName: name,
       esmxVersion: getEsmxVersion(),
       installCommand: "npm install",
       devCommand: "npm run dev",
@@ -56,12 +49,9 @@ describe("project unit tests", () => {
       "project"
     );
     const projectNameInput = "very/deep/nested/path/project";
-    const { packageName, targetDir } = formatProjectName(
-      projectNameInput,
-      tmpDir
-    );
-    await createProjectFromTemplate(targetDir, "vue2", tmpDir, false, {
-      projectName: packageName,
+    const { name, root } = formatProjectName(projectNameInput, tmpDir);
+    await createProjectFromTemplate(root, "vue2-csr", tmpDir, false, {
+      projectName: name,
       esmxVersion: getEsmxVersion(),
       installCommand: "npm install",
       devCommand: "npm run dev",
@@ -76,12 +66,9 @@ describe("project unit tests", () => {
   it("should handle file copy with template variable replacement", async () => {
     const projectPath = join(tmpDir, "variable-test");
     const projectNameInput = "variable-test";
-    const { packageName, targetDir } = formatProjectName(
-      projectNameInput,
-      tmpDir
-    );
-    await createProjectFromTemplate(targetDir, "vue2", tmpDir, false, {
-      projectName: packageName,
+    const { name, root } = formatProjectName(projectNameInput, tmpDir);
+    await createProjectFromTemplate(root, "vue2-csr", tmpDir, false, {
+      projectName: name,
       esmxVersion: getEsmxVersion(),
       installCommand: "npm install",
       devCommand: "npm run dev",
@@ -103,12 +90,9 @@ describe("project unit tests", () => {
     const emptyDir = join(tmpDir, "empty-dir");
     await mkdir(emptyDir, { recursive: true });
     const projectNameInput = "empty-dir";
-    const { packageName, targetDir } = formatProjectName(
-      projectNameInput,
-      tmpDir
-    );
-    await createProjectFromTemplate(targetDir, "vue2", tmpDir, false, {
-      projectName: packageName,
+    const { name, root } = formatProjectName(projectNameInput, tmpDir);
+    await createProjectFromTemplate(root, "vue2-csr", tmpDir, false, {
+      projectName: name,
       esmxVersion: getEsmxVersion(),
       installCommand: "npm install",
       devCommand: "npm run dev",
@@ -125,18 +109,15 @@ describe("project unit tests", () => {
     await writeFile(join(mixedDir, ".dotfile"), "hidden");
     await writeFile(join(mixedDir, "regular-file.txt"), "visible");
     const projectNameInput = "mixed-dir";
-    const { packageName, targetDir } = formatProjectName(
-      projectNameInput,
-      tmpDir
-    );
+    const { name, root } = formatProjectName(projectNameInput, tmpDir);
     await createProjectFromTemplate(
-      targetDir,
-      "vue2",
+      root,
+      "vue2-csr",
       tmpDir,
       true,
       // force flag
       {
-        projectName: packageName,
+        projectName: name,
         esmxVersion: getEsmxVersion(),
         installCommand: "npm install",
         devCommand: "npm run dev",
@@ -156,12 +137,9 @@ describe("project unit tests", () => {
     ];
     for (const projectName of specialNames) {
       const projectPath = join(tmpDir, projectName);
-      const { packageName, targetDir } = formatProjectName(
-        projectName,
-        tmpDir
-      );
-      await createProjectFromTemplate(targetDir, "vue2", tmpDir, false, {
-        projectName: packageName,
+      const { name, root } = formatProjectName(projectName, tmpDir);
+      await createProjectFromTemplate(root, "vue2-csr", tmpDir, false, {
+        projectName: name,
         esmxVersion: getEsmxVersion(),
         installCommand: "npm install",
         devCommand: "npm run dev",

package/dist/types.d.ts

@@ -5,6 +5,7 @@ export interface CliOptions {
     argv?: string[];
     cwd?: string;
     userAgent?: string;
+    version?: string;
 }
 /**
  * Template information structure

package/dist/utils/project-name.d.ts

@@ -2,29 +2,47 @@
  * Project name utilities
  */
 export interface ProjectNameResult {
-    packageName: string;
-    targetDir: string;
+    name: string;
+    root: string;
 }
 /**
  * Format project name and determine target directory
  *
  * Examples:
- * 1. Input: 'foo'
- *    Output: folder `<cwd>/foo`, `package.json#name` -> `foo`
+ * 1. Input: 'foo', cwd: '/home/user' (Unix)
+ *    Output: { name: 'foo', root: '/home/user/foo' }
+ *    Input: 'foo', cwd: 'C:\\workspace' (Windows)
+ *    Output: { name: 'foo', root: 'C:\\workspace\\foo' }
  *
- * 2. Input: 'foo/bar'
- *    Output: folder -> `<cwd>/foo/bar` folder, `package.json#name` -> `bar`
+ * 2. Input: 'foo/bar', cwd: '/home/user' (Unix)
+ *    Output: { name: 'bar', root: '/home/user/foo/bar' }
+ *    Input: 'foo\\bar', cwd: 'C:\\workspace' (Windows)
+ *    Output: { name: 'bar', root: 'C:\\workspace\\foo\\bar' }
  *
- * 3. Input: '@scope/foo'
- *    Output: folder -> `<cwd>/@scope/foo` folder, `package.json#name` -> `@scope/foo`
+ * 3. Input: '@scope/foo', cwd: '/home/user' (Unix)
+ *    Output: { name: '@scope/foo', root: '/home/user/@scope/foo' }
+ *    Input: '@scope/foo', cwd: 'C:\\workspace' (Windows)
+ *    Output: { name: '@scope/foo', root: 'C:\\workspace\\@scope\\foo' }
  *
- * 4. Input: './foo/bar'
- *    Output: folder -> `<cwd>/foo/bar` folder, `package.json#name` -> `bar`
+ * 4. Input: './foo/bar', cwd: '/home/user/current' (Unix)
+ *    Output: { name: 'bar', root: '/home/user/current/foo/bar' }
+ *    Input: '.\\foo\\bar', cwd: 'C:\\workspace\\current' (Windows)
+ *    Output: { name: 'bar', root: 'C:\\workspace\\current\\foo\\bar' }
  *
- * 5. Input: '/root/path/to/foo'
- *    Output: folder -> `'/root/path/to/foo'` folder, `package.json#name` -> `foo`
+ * 5. Input: '/root/path/to/foo', cwd: '/home/user' (Unix absolute)
+ *    Output: { name: 'foo', root: '/root/path/to/foo' }
+ *    Input: 'C:\\projects\\my-app', cwd: 'D:\\workspace' (Windows absolute)
+ *    Output: { name: 'my-app', root: 'C:\\projects\\my-app' }
  *
- * 6. Input: '.'
- *    Output: folder -> `<cwd>` folder, `package.json#name` -> `<current-dir-name>`
+ * 6. Input: '.', cwd: '/home/user/projects/my-app' (Unix current dir)
+ *    Output: { name: 'my-app', root: '/home/user/projects/my-app' }
+ *    Input: '.', cwd: 'C:\\Users\\Developer\\Projects\\WindowsApp' (Windows current dir)
+ *    Output: { name: 'WindowsApp', root: 'C:\\Users\\Developer\\Projects\\WindowsApp' }
+ *
+ * 7. Input: '\\\\server\\share\\project', cwd: 'C:\\workspace' (Windows UNC)
+ *    Output: { name: 'project', root: '\\\\server\\share\\project' }
+ *
+ * 8. Input: 'path\\to/project', cwd: '/home/user' (Mixed separators)
+ *    Output: { name: 'project', root: '/home/user/path/to/project' }
  */
 export declare function formatProjectName(input: string, cwd?: string): ProjectNameResult;

package/dist/utils/project-name.mjs

@@ -1,17 +1,42 @@
-import { basename } from "node:path";
+import { basename, isAbsolute, normalize, resolve } from "node:path";
 export function formatProjectName(input, cwd) {
-  const targetDir = input.replace(/\/+$/g, "");
-  let packageName;
-  if (targetDir === ".") {
-    const workingDir = cwd || process.cwd();
-    packageName = basename(workingDir);
-  } else if (targetDir.startsWith("@")) {
-    packageName = targetDir;
+  const workingDir = cwd || process.cwd();
+  let cleanInput = input;
+  if (input !== "/" && input !== "\\" && input.length > 1) {
+    cleanInput = input.replace(/[\\/]+$/, "");
+  }
+  if (cleanInput === ".") {
+    return {
+      name: basename(workingDir),
+      root: workingDir
+    };
+  }
+  if (cleanInput === "" || cleanInput === "/" || cleanInput === "\\") {
+    if (cleanInput === "/") {
+      return {
+        name: "esmx-project",
+        root: "/"
+      };
+    }
+    return {
+      name: "esmx-project",
+      root: resolve(workingDir, "esmx-project")
+    };
+  }
+  let root;
+  if (isAbsolute(cleanInput)) {
+    root = normalize(cleanInput);
+  } else {
+    root = resolve(workingDir, cleanInput);
+  }
+  let name;
+  if (cleanInput.startsWith("@")) {
+    name = cleanInput;
   } else {
-    packageName = targetDir.split("/").pop() || "esmx-project";
+    name = basename(normalize(cleanInput)) || "esmx-project";
   }
   return {
-    packageName,
-    targetDir
+    name,
+    root
   };
 }

package/dist/utils/project-name.test.d.ts

@@ -1,4 +1 @@
-/**
- * Unit tests for project-name utilities
- */
 export {};