create-esmx 3.0.0-rc.104

package/dist/project.test.mjs

@@ -0,0 +1,155 @@
+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(tmpDir) {
+  await rm(tmpDir, { recursive: true, force: true });
+}
+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 { name, root } = formatProjectName(projectNameInput, tmpDir);
+    await createProjectFromTemplate(root, "vue2-csr", tmpDir, false, {
+      projectName: name,
+      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 { name, root } = formatProjectName(projectNameInput, tmpDir);
+    await createProjectFromTemplate(root, "vue2-csr", tmpDir, false, {
+      projectName: name,
+      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 { name, root } = formatProjectName(projectNameInput, tmpDir);
+    await createProjectFromTemplate(root, "vue2-csr", tmpDir, false, {
+      projectName: name,
+      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 { name, root } = formatProjectName(projectNameInput, tmpDir);
+    await createProjectFromTemplate(root, "vue2-csr", tmpDir, false, {
+      projectName: name,
+      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 { name, root } = formatProjectName(projectNameInput, tmpDir);
+    await createProjectFromTemplate(
+      root,
+      "vue2-csr",
+      tmpDir,
+      true,
+      // force flag
+      {
+        projectName: name,
+        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 { name, root } = formatProjectName(projectName, tmpDir);
+      await createProjectFromTemplate(root, "vue2-csr", tmpDir, false, {
+        projectName: name,
+        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,
+  readdirSync,
+  readFileSync,
+  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 {};

package/dist/template.test.mjs

@@ -0,0 +1,106 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { mkdir, mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import {
+  copyTemplateFiles,
+  getAvailableTemplates,
+  getEsmxVersion,
+  isDirectoryEmpty
+} from "./template.mjs";
+async function createTempDir(prefix = "esmx-template-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("template unit tests", () => {
+  let tmpDir;
+  beforeEach(async () => {
+    tmpDir = await createTempDir();
+  });
+  afterEach(async () => {
+    await cleanupTempDir(tmpDir);
+  });
+  it("should get Esmx version from package.json", () => {
+    const version = getEsmxVersion();
+    expect(typeof version).toBe("string");
+    expect(version.length).toBeGreaterThan(0);
+  });
+  it("should get available templates", () => {
+    const templates = getAvailableTemplates();
+    expect(templates.length).toBeGreaterThan(0);
+    expect(templates[0]).toHaveProperty("folder");
+    expect(templates[0]).toHaveProperty("name");
+    expect(templates[0]).toHaveProperty("description");
+  });
+  it("should detect empty directory", async () => {
+    const emptyDir = join(tmpDir, "empty");
+    await mkdir(emptyDir);
+    expect(isDirectoryEmpty(emptyDir)).toBe(true);
+    const hiddenDir = join(tmpDir, "hidden");
+    await mkdir(hiddenDir);
+    writeFileSync(join(hiddenDir, ".hiddenfile"), "hidden");
+    expect(isDirectoryEmpty(hiddenDir)).toBe(true);
+    const nonEmptyDir = join(tmpDir, "non-empty");
+    await mkdir(nonEmptyDir);
+    writeFileSync(join(nonEmptyDir, "visible.txt"), "visible");
+    expect(isDirectoryEmpty(nonEmptyDir)).toBe(false);
+  });
+  it("should copy template files with variable replacement", () => {
+    const templateDir = join(tmpDir, "template");
+    const targetDir = join(tmpDir, "target");
+    mkdirSync(templateDir, { recursive: true });
+    mkdirSync(join(templateDir, "src"), { recursive: true });
+    mkdirSync(targetDir, { recursive: true });
+    writeFileSync(
+      join(templateDir, "package.json"),
+      JSON.stringify({
+        name: "{{projectName}}",
+        version: "1.0.0",
+        dependencies: {
+          esmx: "{{esmxVersion}}"
+        },
+        scripts: {
+          dev: "{{devCommand}}",
+          build: "{{buildCommand}}"
+        }
+      })
+    );
+    writeFileSync(
+      join(templateDir, "src", "index.ts"),
+      'console.log("Welcome to {{projectName}}!");'
+    );
+    copyTemplateFiles(templateDir, targetDir, {
+      projectName: "test-project",
+      esmxVersion: "1.2.3",
+      devCommand: "npm run dev",
+      buildCommand: "npm run build",
+      installCommand: "npm install",
+      startCommand: "npm start",
+      buildTypeCommand: "npm run build:type",
+      lintTypeCommand: "npm run lint:type"
+    });
+    expect(existsSync(join(targetDir, "package.json"))).toBe(true);
+    expect(existsSync(join(targetDir, "src", "index.ts"))).toBe(true);
+    const packageJson = JSON.parse(
+      require("node:fs").readFileSync(
+        join(targetDir, "package.json"),
+        "utf-8"
+      )
+    );
+    expect(packageJson.name).toBe("test-project");
+    expect(packageJson.dependencies.esmx).toBe("1.2.3");
+    expect(packageJson.scripts.dev).toBe("npm run dev");
+    const indexContent = require("node:fs").readFileSync(
+      join(targetDir, "src", "index.ts"),
+      "utf-8"
+    );
+    expect(indexContent).toBe('console.log("Welcome to test-project!");');
+  });
+});

package/dist/types.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Options for project creation
+ */
+export interface CliOptions {
+    argv?: string[];
+    cwd?: string;
+    userAgent?: string;
+    version?: string;
+}
+/**
+ * Template information structure
+ */
+export interface TemplateInfo {
+    folder: string;
+    name: string;
+    description: string;
+}
+/**
+ * Variables used in templates for replacement
+ */
+export interface TemplateVariables extends Record<string, string> {
+    projectName: string;
+    esmxVersion: string;
+    installCommand: string;
+    devCommand: string;
+    buildCommand: string;
+    startCommand: string;
+    buildTypeCommand: string;
+    lintTypeCommand: string;
+}

package/dist/utils/index.d.ts

@@ -0,0 +1,3 @@
+export { type CommandType, getCommand } 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 {};