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

package/dist/cli.d.ts

@@ -1,2 +1,5 @@
-#!/usr/bin/env node
-export {};
+import type { CliOptions } from './types';
+/**
+ * Main function to create a project
+ */
+export declare function cli(options?: CliOptions): Promise<void>;

package/dist/{integration.test.mjs → cli.integration.test.mjs}

@@ -1,9 +1,11 @@
 import { existsSync } from "node:fs";
+import { readFileSync } 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";
+import { cli } from "./cli.mjs";
+import { getAvailableTemplates } from "./template.mjs";
 async function createTempDir(prefix = "esmx-test-") {
   return mkdtemp(join(tmpdir(), prefix));
 }
@@ -14,7 +16,75 @@ async function cleanupTempDir(tempDir) {
     console.warn(`Failed to cleanup temp directory: ${tempDir}`, error);
   }
 }
-describe("create-esmx integration tests", () => {
+async function verifyProjectStructure(projectPath, projectName) {
+  expect(existsSync(projectPath)).toBe(true);
+  expect(existsSync(join(projectPath, "src"))).toBe(true);
+  const requiredFiles = [
+    "package.json",
+    "tsconfig.json",
+    "README.md",
+    "src/entry.client.ts",
+    "src/entry.node.ts",
+    "src/create-app.ts"
+  ];
+  for (const file of requiredFiles) {
+    expect(existsSync(join(projectPath, file))).toBe(true);
+    if (!existsSync(join(projectPath, file))) {
+      throw new Error(`Missing required file: ${file}`);
+    }
+  }
+  const packageJson = JSON.parse(
+    readFileSync(join(projectPath, "package.json"), "utf-8")
+  );
+  const typeCheckCommands = ["vue-tsc --noEmit", "tsc --noEmit"];
+  const typeGenCommands = [
+    "vue-tsc --declaration --emitDeclarationOnly --noEmit false --outDir dist/src && tsc-alias -p tsconfig.json --outDir dist/src",
+    "tsc --declaration --emitDeclarationOnly --outDir dist/src && tsc-alias -p tsconfig.json --outDir dist/src"
+  ];
+  expect(packageJson).toMatchObject({
+    name: projectName,
+    type: "module",
+    private: true,
+    scripts: {
+      dev: "esmx dev",
+      build: "esmx build",
+      preview: "esmx preview",
+      start: "NODE_ENV=production node dist/index.mjs"
+    },
+    dependencies: {
+      "@esmx/core": expect.any(String)
+    },
+    devDependencies: {
+      typescript: expect.any(String),
+      "@types/node": expect.any(String),
+      "tsc-alias": expect.any(String)
+    }
+  });
+  expect(packageJson.scripts["lint:type"]).toBeOneOf(typeCheckCommands);
+  expect(packageJson.scripts["build:type"]).toBeOneOf(typeGenCommands);
+  const tsconfig = JSON.parse(
+    readFileSync(join(projectPath, "tsconfig.json"), "utf-8")
+  );
+  expect(tsconfig).toMatchObject({
+    compilerOptions: {
+      module: "ESNext",
+      moduleResolution: "node",
+      target: "ESNext",
+      strict: true,
+      baseUrl: ".",
+      paths: {
+        [`${projectName}/src/*`]: ["./src/*"],
+        [`${projectName}/*`]: ["./*"]
+      }
+    },
+    include: ["src"],
+    exclude: ["dist", "node_modules"]
+  });
+  const readmeContent = readFileSync(join(projectPath, "README.md"), "utf-8");
+  expect(readmeContent.length).toBeGreaterThan(0);
+  expect(readmeContent).toContain(projectName);
+}
+describe("create-esmx CLI integration tests", () => {
   let tmpDir;
   beforeEach(async () => {
     tmpDir = await createTempDir();
@@ -22,32 +92,29 @@ describe("create-esmx integration tests", () => {
   afterEach(async () => {
     await cleanupTempDir(tmpDir);
   });
-  it("should create project with vue2 template", async () => {
-    const projectPath = join(tmpDir, "test-project");
-    await createProject({
-      argv: ["test-project", "--template", "vue2"],
-      cwd: tmpDir,
-      userAgent: "npm/test"
-    });
-    expect(existsSync(projectPath)).toBe(true);
-    expect(existsSync(join(projectPath, "package.json"))).toBe(true);
-    expect(existsSync(join(projectPath, "tsconfig.json"))).toBe(true);
-    expect(existsSync(join(projectPath, "README.md"))).toBe(true);
-    expect(existsSync(join(projectPath, "src"))).toBe(true);
-    expect(existsSync(join(projectPath, "src/entry.client.ts"))).toBe(true);
-    expect(existsSync(join(projectPath, "src/entry.node.ts"))).toBe(true);
-    expect(existsSync(join(projectPath, "src/entry.server.ts"))).toBe(true);
-    expect(existsSync(join(projectPath, "src/create-app.ts"))).toBe(true);
+  it("should create project with all available templates", async () => {
+    const templates = getAvailableTemplates();
+    expect(templates.length).toBeGreaterThan(0);
+    for (const template of templates) {
+      const projectName = `test-${template.folder}`;
+      const projectPath = join(tmpDir, projectName);
+      await cli({
+        argv: [projectName, "--template", template.folder],
+        cwd: tmpDir,
+        userAgent: "npm/test"
+      });
+      await verifyProjectStructure(projectPath, projectName);
+    }
   });
   it("should handle --force parameter correctly", async () => {
     const projectPath = join(tmpDir, "test-project");
-    await createProject({
+    await cli({
       argv: ["test-project", "--template", "vue2"],
       cwd: tmpDir,
       userAgent: "npm/test"
     });
     expect(existsSync(join(projectPath, "package.json"))).toBe(true);
-    await createProject({
+    await cli({
       argv: ["test-project", "--template", "vue2", "--force"],
       cwd: tmpDir,
       userAgent: "npm/test"
@@ -66,7 +133,7 @@ describe("create-esmx integration tests", () => {
       logOutput.push(args.join(" "));
     };
     try {
-      await createProject({
+      await cli({
         argv: ["--help"],
         cwd: tmpDir,
         userAgent: "npm/test"
@@ -86,7 +153,7 @@ describe("create-esmx integration tests", () => {
       logOutput.push(args.join(" "));
     };
     try {
-      await createProject({
+      await cli({
         argv: ["--version"],
         cwd: tmpDir,
         userAgent: "npm/test"
@@ -99,7 +166,7 @@ describe("create-esmx integration tests", () => {
   });
   it("should handle creating directory when target directory does not exist", async () => {
     const projectPath = join(tmpDir, "non-existent-parent", "test-project");
-    await createProject({
+    await cli({
       argv: ["non-existent-parent/test-project", "--template", "vue2"],
       cwd: tmpDir,
       userAgent: "npm/test"
@@ -115,7 +182,7 @@ describe("create-esmx integration tests", () => {
       join(projectPath, "existing-file.txt"),
       "existing content"
     );
-    await createProject({
+    await cli({
       argv: ["test-project", "--template", "vue2", "--force"],
       cwd: tmpDir,
       userAgent: "npm/test"
@@ -126,7 +193,7 @@ describe("create-esmx integration tests", () => {
   it("should handle force overwrite in current directory", async () => {
     const testFile = join(tmpDir, "existing-file.txt");
     await writeFile(testFile, "existing content");
-    await createProject({
+    await cli({
       argv: [".", "--template", "vue2", "--force"],
       cwd: tmpDir,
       userAgent: "npm/test"
@@ -136,7 +203,7 @@ describe("create-esmx integration tests", () => {
     expect(existsSync(join(tmpDir, "src/entry.client.ts"))).toBe(true);
   });
   it('should create project in current directory when target is "."', async () => {
-    await createProject({
+    await cli({
       argv: [".", "--template", "vue2"],
       cwd: tmpDir,
       userAgent: "npm/test"
@@ -153,7 +220,7 @@ describe("create-esmx integration tests", () => {
     ];
     for (const projectName of testCases) {
       const projectPath = join(tmpDir, projectName);
-      await createProject({
+      await cli({
         argv: [projectName, "--template", "vue2"],
         cwd: tmpDir,
         userAgent: "npm/test"

package/dist/cli.mjs

@@ -1,6 +1,156 @@
-#!/usr/bin/env node
-import { createProject } from "./index.mjs";
-createProject().catch((error) => {
-  console.error("Error creating project:", error);
-  process.exit(1);
-});
+import {
+  cancel,
+  intro,
+  isCancel,
+  note,
+  outro,
+  select,
+  text
+} from "@clack/prompts";
+import minimist from "minimist";
+import color from "picocolors";
+import { createProjectFromTemplate } from "./project.mjs";
+import { getAvailableTemplates, getEsmxVersion } from "./template.mjs";
+import { formatProjectName, getCommand } from "./utils/index.mjs";
+function showHelp(userAgent) {
+  const createCmd = getCommand("create", userAgent);
+  console.log(`
+${color.reset(color.bold(color.blue("\u{1F680} Create Esmx Project")))}
+
+${color.bold("Usage:")}
+  ${createCmd} [project-name]
+  ${createCmd} [project-name] [options]
+
+${color.bold("Options:")}
+  -t, --template <template>    Template to use (default: vue2)
+  -n, --name <name>            Project name or path
+  -f, --force                  Force overwrite existing directory
+  -h, --help                   Show help information
+  -v, --version                Show version number
+
+${color.bold("Examples:")}
+  ${createCmd} my-project
+  ${createCmd} my-project -t vue2
+  ${createCmd} my-project --force
+  ${createCmd} . -f -t vue2
+
+${color.bold("Available Templates:")}
+${getAvailableTemplates().map((t) => `  ${t.folder.padEnd(25)} ${t.description}`).join("\n")}
+
+For more information, visit: ${color.cyan("https://esmnext.com")}
+`);
+}
+async function getProjectName(argName, positionalName) {
+  const providedName = argName || positionalName;
+  if (providedName) {
+    return providedName;
+  }
+  const projectName = await text({
+    message: "Project name or path:",
+    placeholder: "my-esmx-project",
+    validate: (value) => {
+      if (!value.trim()) {
+        return "Project name or path is required";
+      }
+      if (!/^[a-zA-Z0-9_.\/@-]+$/.test(value.trim())) {
+        return "Project name or path should only contain letters, numbers, hyphens, underscores, dots, and slashes";
+      }
+    }
+  });
+  return String(projectName).trim();
+}
+async function getTemplateType(argTemplate) {
+  const availableTemplates = getAvailableTemplates();
+  if (argTemplate && availableTemplates.some((t) => t.folder === argTemplate)) {
+    return argTemplate;
+  }
+  const options = availableTemplates.map((t) => ({
+    label: color.reset(color.gray(`${t.folder} - `) + color.bold(t.name)),
+    value: t.folder,
+    hint: t.description
+  }));
+  const template = await select({
+    message: "Select a template:",
+    options
+  });
+  return template;
+}
+export async function cli(options = {}) {
+  const { argv, cwd, userAgent } = options;
+  const commandLineArgs = argv || process.argv.slice(2);
+  const workingDir = cwd || process.cwd();
+  const parsedArgs = minimist(commandLineArgs, {
+    string: ["template", "name"],
+    boolean: ["help", "version", "force"],
+    alias: {
+      t: "template",
+      n: "name",
+      f: "force",
+      h: "help",
+      v: "version"
+    }
+  });
+  if (parsedArgs.help) {
+    showHelp(userAgent);
+    return;
+  }
+  if (parsedArgs.version) {
+    console.log(getEsmxVersion());
+    return;
+  }
+  console.log();
+  intro(
+    color.reset(
+      color.bold(color.blue("\u{1F680} Welcome to Esmx Project Creator!"))
+    )
+  );
+  const projectNameInput = await getProjectName(
+    parsedArgs.name,
+    parsedArgs._[0]
+  );
+  if (isCancel(projectNameInput)) {
+    cancel("Operation cancelled");
+    return;
+  }
+  const { packageName, targetDir } = formatProjectName(
+    projectNameInput,
+    workingDir
+  );
+  const templateType = await getTemplateType(parsedArgs.template);
+  if (isCancel(templateType)) {
+    cancel("Operation cancelled");
+    return;
+  }
+  const installCommand = getCommand("install", userAgent);
+  const devCommand = getCommand("dev", userAgent);
+  const buildCommand = getCommand("build", userAgent);
+  const startCommand = getCommand("start", userAgent);
+  const buildTypeCommand = getCommand("build:type", userAgent);
+  const lintTypeCommand = getCommand("lint:type", userAgent);
+  await createProjectFromTemplate(
+    targetDir,
+    templateType,
+    workingDir,
+    parsedArgs.force,
+    {
+      projectName: packageName,
+      esmxVersion: getEsmxVersion(),
+      installCommand,
+      devCommand,
+      buildCommand,
+      startCommand,
+      buildTypeCommand,
+      lintTypeCommand
+    }
+  );
+  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)}`)
+  ];
+  note(nextSteps.join("\n"), "Next steps");
+  outro(color.reset(color.green("Happy coding! \u{1F389}")));
+}

package/dist/create.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/create.mjs

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+import { cli } from "./cli.mjs";
+cli().catch((error) => {
+  console.error("Error creating project:", error);
+  process.exit(1);
+});

package/dist/index.d.ts

@@ -1,8 +1 @@
-#!/usr/bin/env node
-interface CreateProjectOptions {
-    argv?: string[];
-    cwd?: string;
-    userAgent?: string;
-}
-export declare function createProject(options?: CreateProjectOptions): Promise<void>;
-export default createProject;
+export { cli } from './cli';

package/dist/index.mjs

@@ -1,276 +1 @@
-#!/usr/bin/env node
-import {
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  readdirSync,
-  statSync,
-  writeFileSync
-} from "node:fs";
-import { dirname, join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import {
-  cancel,
-  confirm,
-  intro,
-  isCancel,
-  note,
-  outro,
-  select,
-  text
-} from "@clack/prompts";
-import minimist from "minimist";
-import color from "picocolors";
-import {
-  formatProjectName,
-  getCommand,
-  replaceTemplateVariables
-} from "./utils/index.mjs";
-const __dirname = dirname(fileURLToPath(import.meta.url));
-function getEsmxVersion() {
-  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";
-  }
-}
-function getAvailableTemplates() {
-  const templateDir = resolve(__dirname, "../template");
-  const templates = [];
-  const templateFolders = readdirSync(templateDir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
-  for (const folder of templateFolders) {
-    const name = folder;
-    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) {
-        console.warn(
-          `Warning: Failed to parse package.json for template '${folder}', skipping.`
-        );
-      }
-    }
-  }
-  return templates.sort((a, b) => a.name.localeCompare(b.name));
-}
-function showHelp(userAgent) {
-  const createCmd = getCommand("create", userAgent);
-  console.log(`
-${color.reset(color.bold(color.blue("\u{1F680} Create Esmx Project")))}
-
-${color.bold("Usage:")}
-  ${createCmd} [project-name]
-  ${createCmd} [project-name] [options]
-
-${color.bold("Options:")}
-  -t, --template <template>    Template to use (default: vue2)
-  -n, --name <name>            Project name or path
-  -f, --force                  Force overwrite existing directory
-  -h, --help                   Show help information
-  -v, --version                Show version number
-
-${color.bold("Examples:")}
-  ${createCmd} my-project
-  ${createCmd} my-project -t vue2
-  ${createCmd} my-project --force
-  ${createCmd} . -f -t vue2
-
-${color.bold("Available Templates:")}
-${getAvailableTemplates().map((t) => `  ${t.folder.padEnd(25)} ${t.description}`).join("\n")}
-
-For more information, visit: ${color.cyan("https://esmnext.com")}
-`);
-}
-export async function createProject(options = {}) {
-  const { argv, cwd, userAgent } = options;
-  const commandLineArgs = argv || process.argv.slice(2);
-  const workingDir = cwd || process.cwd();
-  const parsedArgs = minimist(commandLineArgs, {
-    string: ["template", "name"],
-    boolean: ["help", "version", "force"],
-    alias: {
-      t: "template",
-      n: "name",
-      f: "force",
-      h: "help",
-      v: "version"
-    }
-  });
-  if (parsedArgs.help) {
-    showHelp(userAgent);
-    return;
-  }
-  if (parsedArgs.version) {
-    console.log(getEsmxVersion());
-    return;
-  }
-  console.log();
-  intro(
-    color.reset(
-      color.bold(color.blue("\u{1F680} Welcome to Esmx Project Creator!"))
-    )
-  );
-  const projectNameInput = await getProjectName(
-    parsedArgs.name,
-    parsedArgs._[0]
-  );
-  if (isCancel(projectNameInput)) {
-    cancel("Operation cancelled");
-    return;
-  }
-  const { packageName, targetDir } = formatProjectName(
-    projectNameInput,
-    workingDir
-  );
-  const templateType = await getTemplateType(parsedArgs.template);
-  if (isCancel(templateType)) {
-    cancel("Operation cancelled");
-    return;
-  }
-  const installCommand = getCommand("install", userAgent);
-  const devCommand = getCommand("dev", userAgent);
-  const buildCommand = getCommand("build", userAgent);
-  const startCommand = getCommand("start", userAgent);
-  const buildTypeCommand = getCommand("build:type", userAgent);
-  const lintTypeCommand = getCommand("lint:type", userAgent);
-  await createProjectFromTemplate(
-    targetDir,
-    templateType,
-    workingDir,
-    parsedArgs.force,
-    {
-      projectName: packageName,
-      esmxVersion: getEsmxVersion(),
-      installCommand,
-      devCommand,
-      buildCommand,
-      startCommand,
-      buildTypeCommand,
-      lintTypeCommand
-    }
-  );
-  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)}`)
-  ];
-  note(nextSteps.join("\n"), "Next steps");
-  outro(color.reset(color.green("Happy coding! \u{1F389}")));
-}
-async function getProjectName(argName, positionalName) {
-  const providedName = argName || positionalName;
-  if (providedName) {
-    return providedName;
-  }
-  const projectName = await text({
-    message: "Project name or path:",
-    placeholder: "my-esmx-project",
-    validate: (value) => {
-      if (!value.trim()) {
-        return "Project name or path is required";
-      }
-      if (!/^[a-zA-Z0-9_.\/@-]+$/.test(value.trim())) {
-        return "Project name or path should only contain letters, numbers, hyphens, underscores, dots, and slashes";
-      }
-    }
-  });
-  return String(projectName).trim();
-}
-async function getTemplateType(argTemplate) {
-  const availableTemplates = getAvailableTemplates();
-  if (argTemplate && availableTemplates.some((t) => t.folder === argTemplate)) {
-    return argTemplate;
-  }
-  const options = availableTemplates.map((t) => ({
-    label: color.reset(color.gray(`${t.folder} - `) + color.bold(t.name)),
-    value: t.folder,
-    hint: t.description
-  }));
-  const template = await select({
-    message: "Select a template:",
-    options
-  });
-  return template;
-}
-function isDirectoryEmpty(dirPath) {
-  if (!existsSync(dirPath)) {
-    return true;
-  }
-  const files = readdirSync(dirPath);
-  const nonHiddenFiles = files.filter((file) => !file.startsWith("."));
-  return nonHiddenFiles.length === 0;
-}
-async function createProjectFromTemplate(targetDir, templateType, workingDir, force, variables) {
-  const templatePath = resolve(__dirname, "../template", templateType);
-  const targetPath = targetDir === "." ? workingDir : resolve(workingDir, targetDir);
-  if (!existsSync(templatePath)) {
-    throw new Error(`Template "${templateType}" not found`);
-  }
-  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");
-        }
-      }
-    }
-  } else if (targetDir !== ".") {
-    mkdirSync(targetPath, { recursive: true });
-  }
-  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);
-}
-function copyTemplateFiles(templatePath, targetPath, variables) {
-  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");
-      content = replaceTemplateVariables(content, variables);
-      writeFileSync(targetFilePath, content);
-    }
-  }
-}
-export default createProject;
+export { cli } from "./cli.mjs";

package/dist/project.d.ts

@@ -0,0 +1,5 @@
+import type { TemplateVariables } from './types';
+/**
+ * Create a project from template
+ */
+export declare function createProjectFromTemplate(targetDir: string, templateType: string, workingDir: string, force: boolean, variables: TemplateVariables): Promise<void>;