create-esmx 3.0.0-rc.33

package/dist/index.d.ts

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

package/dist/index.mjs

@@ -0,0 +1,282 @@
+#!/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;
+if (import.meta.url === `file://${process.argv[1]}`) {
+  createProject().catch((error) => {
+    console.error("Error creating project:", error);
+    process.exit(1);
+  });
+}

package/dist/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.test.mjs

@@ -0,0 +1,123 @@
+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/dist/integration.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/integration.test.mjs

@@ -0,0 +1,165 @@
+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-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("create-esmx integration tests", () => {
+  let tmpDir;
+  beforeEach(async () => {
+    tmpDir = await createTempDir();
+  });
+  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 handle --force parameter correctly", async () => {
+    const projectPath = join(tmpDir, "test-project");
+    await createProject({
+      argv: ["test-project", "--template", "vue2"],
+      cwd: tmpDir,
+      userAgent: "npm/test"
+    });
+    expect(existsSync(join(projectPath, "package.json"))).toBe(true);
+    await createProject({
+      argv: ["test-project", "--template", "vue2", "--force"],
+      cwd: tmpDir,
+      userAgent: "npm/test"
+    });
+    expect(existsSync(join(projectPath, "package.json"))).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 show help information", async () => {
+    const originalLog = console.log;
+    const logOutput = [];
+    console.log = (...args) => {
+      logOutput.push(args.join(" "));
+    };
+    try {
+      await createProject({
+        argv: ["--help"],
+        cwd: tmpDir,
+        userAgent: "npm/test"
+      });
+      const output = logOutput.join("\n");
+      expect(output).toContain("Usage");
+      expect(output).toContain("Options");
+      expect(output).toContain("Examples");
+    } finally {
+      console.log = originalLog;
+    }
+  });
+  it("should show version information", async () => {
+    const originalLog = console.log;
+    const logOutput = [];
+    console.log = (...args) => {
+      logOutput.push(args.join(" "));
+    };
+    try {
+      await createProject({
+        argv: ["--version"],
+        cwd: tmpDir,
+        userAgent: "npm/test"
+      });
+      const output = logOutput.join("\n");
+      expect(output).toMatch(/^\d+\.\d+\.\d+/);
+    } finally {
+      console.log = originalLog;
+    }
+  });
+  it("should handle creating directory when target directory does not exist", async () => {
+    const projectPath = join(tmpDir, "non-existent-parent", "test-project");
+    await createProject({
+      argv: ["non-existent-parent/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, "src"))).toBe(true);
+  });
+  it("should handle force overwrite for non-empty directory", async () => {
+    const projectPath = join(tmpDir, "test-project");
+    await mkdir(projectPath, { recursive: true });
+    await writeFile(
+      join(projectPath, "existing-file.txt"),
+      "existing content"
+    );
+    await createProject({
+      argv: ["test-project", "--template", "vue2", "--force"],
+      cwd: tmpDir,
+      userAgent: "npm/test"
+    });
+    expect(existsSync(join(projectPath, "package.json"))).toBe(true);
+    expect(existsSync(join(projectPath, "src"))).toBe(true);
+  });
+  it("should handle force overwrite in current directory", async () => {
+    const testFile = join(tmpDir, "existing-file.txt");
+    await writeFile(testFile, "existing content");
+    await createProject({
+      argv: [".", "--template", "vue2", "--force"],
+      cwd: tmpDir,
+      userAgent: "npm/test"
+    });
+    expect(existsSync(join(tmpDir, "package.json"))).toBe(true);
+    expect(existsSync(join(tmpDir, "src"))).toBe(true);
+    expect(existsSync(join(tmpDir, "src/entry.client.ts"))).toBe(true);
+  });
+  it('should create project in current directory when target is "."', async () => {
+    await createProject({
+      argv: [".", "--template", "vue2"],
+      cwd: tmpDir,
+      userAgent: "npm/test"
+    });
+    expect(existsSync(join(tmpDir, "package.json"))).toBe(true);
+    expect(existsSync(join(tmpDir, "src"))).toBe(true);
+    expect(existsSync(join(tmpDir, "src/entry.client.ts"))).toBe(true);
+  });
+  it("should handle various project name formats", async () => {
+    const testCases = [
+      "simple-name",
+      "nested/project-name",
+      "deep/nested/project-name"
+    ];
+    for (const projectName of testCases) {
+      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/dist/utils/index.d.ts

@@ -0,0 +1,3 @@
+export { getCommand, type CommandType } from './package-manager';
+export { formatProjectName, type ProjectNameResult } from './project-name';
+export { replaceTemplateVariables } from './template';

package/dist/utils/index.mjs

@@ -0,0 +1,7 @@
+export {
+  getCommand
+} from "./package-manager.mjs";
+export {
+  formatProjectName
+} from "./project-name.mjs";
+export { replaceTemplateVariables } from "./template.mjs";

package/dist/utils/package-manager.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Package manager detection and command generation utilities
+ */
+export type PackageManager = 'npm' | 'yarn' | 'pnpm' | 'bun';
+export type CommandType = 'install' | 'dev' | 'build' | 'start' | 'create' | 'build:type' | 'lint:type';
+/**
+ * Get a specific command for the detected package manager
+ * Business logic only needs to specify what command to execute
+ */
+export declare function getCommand(commandType: CommandType, userAgent?: string): string;

package/dist/utils/package-manager.mjs

@@ -0,0 +1,49 @@
+const PACKAGE_MANAGER_CONFIG = {
+  npm: {
+    install: "npm install",
+    dev: "npm run dev",
+    build: "npm run build",
+    start: "npm start",
+    create: "npm create esmx@latest",
+    "build:type": "npm run build:type",
+    "lint:type": "npm run lint:type"
+  },
+  yarn: {
+    install: "yarn install",
+    dev: "yarn dev",
+    build: "yarn build",
+    start: "yarn start",
+    create: "yarn create esmx",
+    "build:type": "yarn build:type",
+    "lint:type": "yarn lint:type"
+  },
+  pnpm: {
+    install: "pnpm install",
+    dev: "pnpm dev",
+    build: "pnpm build",
+    start: "pnpm start",
+    create: "pnpm create esmx",
+    "build:type": "pnpm build:type",
+    "lint:type": "pnpm lint:type"
+  },
+  bun: {
+    install: "bun install",
+    dev: "bun dev",
+    build: "bun run build",
+    start: "bun start",
+    create: "bun create esmx",
+    "build:type": "bun run build:type",
+    "lint:type": "bun run lint:type"
+  }
+};
+function detectPackageManager(userAgent) {
+  const agent = userAgent || process.env.npm_config_user_agent || "";
+  if (agent.includes("pnpm")) return "pnpm";
+  if (agent.includes("yarn")) return "yarn";
+  if (agent.includes("bun")) return "bun";
+  return "npm";
+}
+export function getCommand(commandType, userAgent) {
+  const packageManager = detectPackageManager(userAgent);
+  return PACKAGE_MANAGER_CONFIG[packageManager][commandType];
+}

package/dist/utils/package-manager.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Unit tests for package-manager utilities
+ */
+export {};