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

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>;

package/dist/project.mjs

@@ -0,0 +1,46 @@
+import { existsSync, mkdirSync } from "node:fs";
+import { dirname, 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);
+  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);
+}

package/dist/project.test.mjs

@@ -0,0 +1,177 @@
+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 { createProjectFromTemplate } from "./project.mjs";
+import { getEsmxVersion } from "./template.mjs";
+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);
+  }
+}
+describe("project 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/");
+    const projectNameInput = "hidden-files-dir";
+    const { packageName, targetDir } = formatProjectName(
+      projectNameInput,
+      tmpDir
+    );
+    await createProjectFromTemplate(targetDir, "vue2", tmpDir, false, {
+      projectName: packageName,
+      esmxVersion: getEsmxVersion(),
+      installCommand: "npm install",
+      devCommand: "npm run dev",
+      buildCommand: "npm run build",
+      startCommand: "npm start",
+      buildTypeCommand: "npm run build:type",
+      lintTypeCommand: "npm run lint:type"
+    });
+    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"
+    );
+    const projectNameInput = "very/deep/nested/path/project";
+    const { packageName, targetDir } = formatProjectName(
+      projectNameInput,
+      tmpDir
+    );
+    await createProjectFromTemplate(targetDir, "vue2", tmpDir, false, {
+      projectName: packageName,
+      esmxVersion: getEsmxVersion(),
+      installCommand: "npm install",
+      devCommand: "npm run dev",
+      buildCommand: "npm run build",
+      startCommand: "npm start",
+      buildTypeCommand: "npm run build:type",
+      lintTypeCommand: "npm run lint:type"
+    });
+    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");
+    const projectNameInput = "variable-test";
+    const { packageName, targetDir } = formatProjectName(
+      projectNameInput,
+      tmpDir
+    );
+    await createProjectFromTemplate(targetDir, "vue2", tmpDir, false, {
+      projectName: packageName,
+      esmxVersion: getEsmxVersion(),
+      installCommand: "npm install",
+      devCommand: "npm run dev",
+      buildCommand: "npm run build",
+      startCommand: "npm start",
+      buildTypeCommand: "npm run build:type",
+      lintTypeCommand: "npm run lint:type"
+    });
+    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 });
+    const projectNameInput = "empty-dir";
+    const { packageName, targetDir } = formatProjectName(
+      projectNameInput,
+      tmpDir
+    );
+    await createProjectFromTemplate(targetDir, "vue2", tmpDir, false, {
+      projectName: packageName,
+      esmxVersion: getEsmxVersion(),
+      installCommand: "npm install",
+      devCommand: "npm run dev",
+      buildCommand: "npm run build",
+      startCommand: "npm start",
+      buildTypeCommand: "npm run build:type",
+      lintTypeCommand: "npm run lint:type"
+    });
+    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");
+    const projectNameInput = "mixed-dir";
+    const { packageName, targetDir } = formatProjectName(
+      projectNameInput,
+      tmpDir
+    );
+    await createProjectFromTemplate(
+      targetDir,
+      "vue2",
+      tmpDir,
+      true,
+      // force flag
+      {
+        projectName: packageName,
+        esmxVersion: getEsmxVersion(),
+        installCommand: "npm install",
+        devCommand: "npm run dev",
+        buildCommand: "npm run build",
+        startCommand: "npm start",
+        buildTypeCommand: "npm run build:type",
+        lintTypeCommand: "npm run lint:type"
+      }
+    );
+    expect(existsSync(join(mixedDir, "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);
+      const { packageName, targetDir } = formatProjectName(
+        projectName,
+        tmpDir
+      );
+      await createProjectFromTemplate(targetDir, "vue2", tmpDir, false, {
+        projectName: packageName,
+        esmxVersion: getEsmxVersion(),
+        installCommand: "npm install",
+        devCommand: "npm run dev",
+        buildCommand: "npm run build",
+        startCommand: "npm start",
+        buildTypeCommand: "npm run build:type",
+        lintTypeCommand: "npm run lint:type"
+      });
+      expect(existsSync(projectPath)).toBe(true);
+      expect(existsSync(join(projectPath, "package.json"))).toBe(true);
+    }
+  });
+});

package/dist/template.d.ts

@@ -0,0 +1,17 @@
+import type { TemplateInfo, TemplateVariables } from './types';
+/**
+ * Get version of esmx from package.json
+ */
+export declare function getEsmxVersion(): string;
+/**
+ * Get list of available templates
+ */
+export declare function getAvailableTemplates(): TemplateInfo[];
+/**
+ * Check if directory is empty (ignoring hidden files)
+ */
+export declare function isDirectoryEmpty(dirPath: string): boolean;
+/**
+ * Copy template files to target directory with variable replacement
+ */
+export declare function copyTemplateFiles(templatePath: string, targetPath: string, variables: TemplateVariables): void;

package/dist/template.mjs

@@ -0,0 +1,76 @@
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  statSync,
+  writeFileSync
+} from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { replaceTemplateVariables } from "./utils/index.mjs";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+export 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";
+  }
+}
+export 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));
+}
+export function isDirectoryEmpty(dirPath) {
+  if (!existsSync(dirPath)) {
+    return true;
+  }
+  const files = readdirSync(dirPath);
+  const nonHiddenFiles = files.filter((file) => !file.startsWith("."));
+  return nonHiddenFiles.length === 0;
+}
+export 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);
+    }
+  }
+}

package/dist/template.test.d.ts

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