create-esmx 3.0.0-rc.33

package/dist/utils/package-manager.test.mjs

@@ -0,0 +1,275 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { getCommand } from "./package-manager.mjs";
+describe("package-manager utilities", () => {
+  let originalUserAgent;
+  beforeEach(() => {
+    originalUserAgent = process.env.npm_config_user_agent;
+  });
+  afterEach(() => {
+    if (originalUserAgent !== void 0) {
+      process.env.npm_config_user_agent = originalUserAgent;
+    } else {
+      process.env.npm_config_user_agent = void 0;
+    }
+  });
+  describe("getCommand", () => {
+    describe("when using npm", () => {
+      beforeEach(() => {
+        process.env.npm_config_user_agent = "npm/8.19.2 node/v18.12.0 darwin x64 workspaces/false";
+      });
+      it("should return npm install command", () => {
+        const commandType = "install";
+        const result = getCommand(commandType);
+        expect(result).toBe("npm install");
+      });
+      it("should return npm dev command", () => {
+        const commandType = "dev";
+        const result = getCommand(commandType);
+        expect(result).toBe("npm run dev");
+      });
+      it("should return npm build command", () => {
+        const commandType = "build";
+        const result = getCommand(commandType);
+        expect(result).toBe("npm run build");
+      });
+      it("should return npm start command", () => {
+        const commandType = "start";
+        const result = getCommand(commandType);
+        expect(result).toBe("npm start");
+      });
+      it("should return npm create command", () => {
+        const commandType = "create";
+        const result = getCommand(commandType);
+        expect(result).toBe("npm create esmx@latest");
+      });
+      it("should return npm build:type command", () => {
+        const commandType = "build:type";
+        const result = getCommand(commandType);
+        expect(result).toBe("npm run build:type");
+      });
+      it("should return npm lint:type command", () => {
+        const commandType = "lint:type";
+        const result = getCommand(commandType);
+        expect(result).toBe("npm run lint:type");
+      });
+    });
+    describe("when using yarn", () => {
+      beforeEach(() => {
+        process.env.npm_config_user_agent = "yarn/1.22.19 npm/? node/v18.12.0 darwin x64";
+      });
+      it("should return yarn install command", () => {
+        const commandType = "install";
+        const result = getCommand(commandType);
+        expect(result).toBe("yarn install");
+      });
+      it("should return yarn dev command", () => {
+        const commandType = "dev";
+        const result = getCommand(commandType);
+        expect(result).toBe("yarn dev");
+      });
+      it("should return yarn build command", () => {
+        const commandType = "build";
+        const result = getCommand(commandType);
+        expect(result).toBe("yarn build");
+      });
+      it("should return yarn start command", () => {
+        const commandType = "start";
+        const result = getCommand(commandType);
+        expect(result).toBe("yarn start");
+      });
+      it("should return yarn create command", () => {
+        const commandType = "create";
+        const result = getCommand(commandType);
+        expect(result).toBe("yarn create esmx");
+      });
+      it("should return yarn build:type command", () => {
+        const commandType = "build:type";
+        const result = getCommand(commandType);
+        expect(result).toBe("yarn build:type");
+      });
+      it("should return yarn lint:type command", () => {
+        const commandType = "lint:type";
+        const result = getCommand(commandType);
+        expect(result).toBe("yarn lint:type");
+      });
+    });
+    describe("when using pnpm", () => {
+      beforeEach(() => {
+        process.env.npm_config_user_agent = "pnpm/7.14.0 npm/? node/v18.12.0 darwin x64";
+      });
+      it("should return pnpm install command", () => {
+        const commandType = "install";
+        const result = getCommand(commandType);
+        expect(result).toBe("pnpm install");
+      });
+      it("should return pnpm dev command", () => {
+        const commandType = "dev";
+        const result = getCommand(commandType);
+        expect(result).toBe("pnpm dev");
+      });
+      it("should return pnpm build command", () => {
+        const commandType = "build";
+        const result = getCommand(commandType);
+        expect(result).toBe("pnpm build");
+      });
+      it("should return pnpm start command", () => {
+        const commandType = "start";
+        const result = getCommand(commandType);
+        expect(result).toBe("pnpm start");
+      });
+      it("should return pnpm create command", () => {
+        const commandType = "create";
+        const result = getCommand(commandType);
+        expect(result).toBe("pnpm create esmx");
+      });
+      it("should return pnpm build:type command", () => {
+        const commandType = "build:type";
+        const result = getCommand(commandType);
+        expect(result).toBe("pnpm build:type");
+      });
+      it("should return pnpm lint:type command", () => {
+        const commandType = "lint:type";
+        const result = getCommand(commandType);
+        expect(result).toBe("pnpm lint:type");
+      });
+    });
+    describe("when using bun", () => {
+      beforeEach(() => {
+        process.env.npm_config_user_agent = "bun/0.6.0 bun/0.6.0 darwin x64";
+      });
+      it("should return bun install command", () => {
+        const commandType = "install";
+        const result = getCommand(commandType);
+        expect(result).toBe("bun install");
+      });
+      it("should return bun dev command", () => {
+        const commandType = "dev";
+        const result = getCommand(commandType);
+        expect(result).toBe("bun dev");
+      });
+      it("should return bun build command", () => {
+        const commandType = "build";
+        const result = getCommand(commandType);
+        expect(result).toBe("bun run build");
+      });
+      it("should return bun start command", () => {
+        const commandType = "start";
+        const result = getCommand(commandType);
+        expect(result).toBe("bun start");
+      });
+      it("should return bun create command", () => {
+        const commandType = "create";
+        const result = getCommand(commandType);
+        expect(result).toBe("bun create esmx");
+      });
+      it("should return bun build:type command", () => {
+        const commandType = "build:type";
+        const result = getCommand(commandType);
+        expect(result).toBe("bun run build:type");
+      });
+      it("should return bun lint:type command", () => {
+        const commandType = "lint:type";
+        const result = getCommand(commandType);
+        expect(result).toBe("bun run lint:type");
+      });
+    });
+    describe("when user agent is not set", () => {
+      beforeEach(() => {
+        process.env.npm_config_user_agent = void 0;
+      });
+      it("should default to npm commands", () => {
+        const commandType = "install";
+        const result = getCommand(commandType);
+        expect(result).toBe("npm install");
+      });
+    });
+    describe("when user agent is empty string", () => {
+      beforeEach(() => {
+        process.env.npm_config_user_agent = "";
+      });
+      it("should default to npm commands", () => {
+        const commandType = "dev";
+        const result = getCommand(commandType);
+        expect(result).toBe("npm run dev");
+      });
+    });
+    describe("when user agent contains unknown package manager", () => {
+      beforeEach(() => {
+        process.env.npm_config_user_agent = "unknown-pm/1.0.0 node/v18.12.0";
+      });
+      it("should default to npm commands", () => {
+        const commandType = "build";
+        const result = getCommand(commandType);
+        expect(result).toBe("npm run build");
+      });
+    });
+  });
+  describe("getCommand with userAgent parameter", () => {
+    beforeEach(() => {
+      process.env.npm_config_user_agent = void 0;
+    });
+    it("should use provided userAgent over environment variable", () => {
+      process.env.npm_config_user_agent = "npm/8.19.2 node/v18.12.0";
+      const customUserAgent = "pnpm/7.14.0 npm/? node/v18.12.0 darwin x64";
+      const result = getCommand("install", customUserAgent);
+      expect(result).toBe("pnpm install");
+    });
+    it("should detect pnpm from custom userAgent", () => {
+      const userAgent = "pnpm/7.14.0 npm/? node/v18.12.0 darwin x64";
+      const installResult = getCommand("install", userAgent);
+      const devResult = getCommand("dev", userAgent);
+      const buildResult = getCommand("build", userAgent);
+      expect(installResult).toBe("pnpm install");
+      expect(devResult).toBe("pnpm dev");
+      expect(buildResult).toBe("pnpm build");
+    });
+    it("should detect yarn from custom userAgent", () => {
+      const userAgent = "yarn/1.22.19 npm/? node/v18.12.0 darwin x64";
+      const installResult = getCommand("install", userAgent);
+      const devResult = getCommand("dev", userAgent);
+      const buildResult = getCommand("build", userAgent);
+      expect(installResult).toBe("yarn install");
+      expect(devResult).toBe("yarn dev");
+      expect(buildResult).toBe("yarn build");
+    });
+    it("should detect bun from custom userAgent", () => {
+      const userAgent = "bun/0.6.0 bun/0.6.0 darwin x64";
+      const installResult = getCommand("install", userAgent);
+      const buildResult = getCommand("build", userAgent);
+      const buildTypeResult = getCommand("build:type", userAgent);
+      expect(installResult).toBe("bun install");
+      expect(buildResult).toBe("bun run build");
+      expect(buildTypeResult).toBe("bun run build:type");
+    });
+    it("should default to npm when userAgent does not match known patterns", () => {
+      const userAgent = "unknown-package-manager/1.0.0";
+      const result = getCommand("install", userAgent);
+      expect(result).toBe("npm install");
+    });
+    it("should handle empty userAgent string", () => {
+      const userAgent = "";
+      const result = getCommand("install", userAgent);
+      expect(result).toBe("npm install");
+    });
+    it("should fallback to environment variable when userAgent is undefined", () => {
+      process.env.npm_config_user_agent = "yarn/1.22.19 npm/? node/v18.12.0";
+      const result = getCommand("install", void 0);
+      expect(result).toBe("yarn install");
+    });
+    it("should handle case-sensitive package manager detection", () => {
+      const userAgent = "PNPM/7.14.0 npm/? node/v18.12.0";
+      const result = getCommand("install", userAgent);
+      expect(result).toBe("npm install");
+    });
+    it("should test all command types with custom userAgent", () => {
+      const userAgent = "pnpm/7.14.0 npm/? node/v18.12.0";
+      expect(getCommand("install", userAgent)).toBe("pnpm install");
+      expect(getCommand("dev", userAgent)).toBe("pnpm dev");
+      expect(getCommand("build", userAgent)).toBe("pnpm build");
+      expect(getCommand("start", userAgent)).toBe("pnpm start");
+      expect(getCommand("create", userAgent)).toBe("pnpm create esmx");
+      expect(getCommand("build:type", userAgent)).toBe("pnpm build:type");
+      expect(getCommand("lint:type", userAgent)).toBe("pnpm lint:type");
+    });
+  });
+});

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

@@ -0,0 +1,30 @@
+/**
+ * Project name utilities
+ */
+export interface ProjectNameResult {
+    packageName: string;
+    targetDir: string;
+}
+/**
+ * Format project name and determine target directory
+ *
+ * Examples:
+ * 1. Input: 'foo'
+ *    Output: folder `<cwd>/foo`, `package.json#name` -> `foo`
+ *
+ * 2. Input: 'foo/bar'
+ *    Output: folder -> `<cwd>/foo/bar` folder, `package.json#name` -> `bar`
+ *
+ * 3. Input: '@scope/foo'
+ *    Output: folder -> `<cwd>/@scope/foo` folder, `package.json#name` -> `@scope/foo`
+ *
+ * 4. Input: './foo/bar'
+ *    Output: folder -> `<cwd>/foo/bar` folder, `package.json#name` -> `bar`
+ *
+ * 5. Input: '/root/path/to/foo'
+ *    Output: folder -> `'/root/path/to/foo'` folder, `package.json#name` -> `foo`
+ *
+ * 6. Input: '.'
+ *    Output: folder -> `<cwd>` folder, `package.json#name` -> `<current-dir-name>`
+ */
+export declare function formatProjectName(input: string, cwd?: string): ProjectNameResult;

package/dist/utils/project-name.mjs

@@ -0,0 +1,17 @@
+import { basename } 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;
+  } else {
+    packageName = targetDir.split("/").pop() || "esmx-project";
+  }
+  return {
+    packageName,
+    targetDir
+  };
+}

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

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

package/dist/utils/project-name.test.mjs

@@ -0,0 +1,186 @@
+import { basename } from "node:path";
+import { describe, expect, it } from "vitest";
+import { formatProjectName } from "./project-name.mjs";
+describe("project-name utilities", () => {
+  describe("formatProjectName", () => {
+    it("should handle simple project name", () => {
+      const input = "foo";
+      const result = formatProjectName(input);
+      expect(result.targetDir).toBe("foo");
+      expect(result.packageName).toBe("foo");
+    });
+    it("should handle nested path project name", () => {
+      const input = "foo/bar";
+      const result = formatProjectName(input);
+      expect(result.targetDir).toBe("foo/bar");
+      expect(result.packageName).toBe("bar");
+    });
+    it("should handle scoped package name", () => {
+      const input = "@scope/foo";
+      const result = formatProjectName(input);
+      expect(result.targetDir).toBe("@scope/foo");
+      expect(result.packageName).toBe("@scope/foo");
+    });
+    it("should handle relative path project name", () => {
+      const input = "./foo/bar";
+      const result = formatProjectName(input);
+      expect(result.targetDir).toBe("./foo/bar");
+      expect(result.packageName).toBe("bar");
+    });
+    it("should handle absolute path project name", () => {
+      const input = "/root/path/to/foo";
+      const result = formatProjectName(input);
+      expect(result.targetDir).toBe("/root/path/to/foo");
+      expect(result.packageName).toBe("foo");
+    });
+    it("should handle current directory", () => {
+      const input = ".";
+      const expectedPackageName = basename(process.cwd());
+      const result = formatProjectName(input);
+      expect(result.targetDir).toBe(".");
+      expect(result.packageName).toBe(expectedPackageName);
+    });
+    it("should handle project name with trailing slashes", () => {
+      const input = "foo/bar///";
+      const result = formatProjectName(input);
+      expect(result.targetDir).toBe("foo/bar");
+      expect(result.packageName).toBe("bar");
+    });
+    it("should handle project name with multiple trailing slashes", () => {
+      const input = "my-project/////";
+      const result = formatProjectName(input);
+      expect(result.targetDir).toBe("my-project");
+      expect(result.packageName).toBe("my-project");
+    });
+    it("should handle deep nested path", () => {
+      const input = "projects/web/frontend/my-app";
+      const result = formatProjectName(input);
+      expect(result.targetDir).toBe("projects/web/frontend/my-app");
+      expect(result.packageName).toBe("my-app");
+    });
+    it("should handle scoped package with nested path", () => {
+      const input = "org/@scope/package-name";
+      const result = formatProjectName(input);
+      expect(result.targetDir).toBe("org/@scope/package-name");
+      expect(result.packageName).toBe("package-name");
+    });
+    it("should handle scoped package starting with @", () => {
+      const input = "@company/ui-library";
+      const result = formatProjectName(input);
+      expect(result.targetDir).toBe("@company/ui-library");
+      expect(result.packageName).toBe("@company/ui-library");
+    });
+    it("should handle empty path segment", () => {
+      const input = "foo//bar";
+      const result = formatProjectName(input);
+      expect(result.targetDir).toBe("foo//bar");
+      expect(result.packageName).toBe("bar");
+    });
+    it("should handle single character project name", () => {
+      const input = "a";
+      const result = formatProjectName(input);
+      expect(result.targetDir).toBe("a");
+      expect(result.packageName).toBe("a");
+    });
+    it("should handle project name with numbers and hyphens", () => {
+      const input = "my-project-v2";
+      const result = formatProjectName(input);
+      expect(result.targetDir).toBe("my-project-v2");
+      expect(result.packageName).toBe("my-project-v2");
+    });
+    it("should handle project name ending with slash", () => {
+      const input = "path/to/project/";
+      const result = formatProjectName(input);
+      expect(result.targetDir).toBe("path/to/project");
+      expect(result.packageName).toBe("project");
+    });
+    it("should fall back to default name when path ends with slash and no name", () => {
+      const input = "/";
+      const result = formatProjectName(input);
+      expect(result.targetDir).toBe("");
+      expect(result.packageName).toBe("esmx-project");
+    });
+    it("should handle Windows-style paths", () => {
+      const input = "C:\\projects\\my-app";
+      const result = formatProjectName(input);
+      expect(result.targetDir).toBe("C:\\projects\\my-app");
+      expect(result.packageName).toBe("C:\\projects\\my-app");
+    });
+    it("should handle mixed path separators", () => {
+      const input = "path\\to/project";
+      const result = formatProjectName(input);
+      expect(result.targetDir).toBe("path\\to/project");
+      expect(result.packageName).toBe("project");
+    });
+  });
+  describe("formatProjectName with cwd parameter", () => {
+    it('should use custom cwd when input is "."', () => {
+      const input = ".";
+      const customCwd = "/custom/working/directory";
+      const result = formatProjectName(
+        input,
+        customCwd
+      );
+      expect(result.targetDir).toBe(".");
+      expect(result.packageName).toBe("directory");
+    });
+    it("should fallback to process.cwd() when cwd is not provided", () => {
+      const input = ".";
+      const expectedPackageName = basename(process.cwd());
+      const result = formatProjectName(input);
+      expect(result.targetDir).toBe(".");
+      expect(result.packageName).toBe(expectedPackageName);
+    });
+    it('should ignore cwd parameter when input is not "."', () => {
+      const input = "my-project";
+      const customCwd = "/custom/working/directory";
+      const result = formatProjectName(
+        input,
+        customCwd
+      );
+      expect(result.targetDir).toBe("my-project");
+      expect(result.packageName).toBe("my-project");
+    });
+    it("should handle scoped packages with custom cwd", () => {
+      const input = "@scope/package";
+      const customCwd = "/any/directory";
+      const result = formatProjectName(
+        input,
+        customCwd
+      );
+      expect(result.targetDir).toBe("@scope/package");
+      expect(result.packageName).toBe("@scope/package");
+    });
+    it("should handle nested paths with custom cwd", () => {
+      const input = "org/team/project";
+      const customCwd = "/any/directory";
+      const result = formatProjectName(
+        input,
+        customCwd
+      );
+      expect(result.targetDir).toBe("org/team/project");
+      expect(result.packageName).toBe("project");
+    });
+    it("should handle Unix-style absolute paths in cwd", () => {
+      const input = ".";
+      const customCwd = "/home/user/projects/my-awesome-app";
+      const result = formatProjectName(
+        input,
+        customCwd
+      );
+      expect(result.targetDir).toBe(".");
+      expect(result.packageName).toBe("my-awesome-app");
+    });
+    it("should handle Windows-style absolute paths in cwd", () => {
+      const input = ".";
+      const customCwd = "C:\\Users\\Developer\\Projects\\WindowsApp";
+      const result = formatProjectName(
+        input,
+        customCwd
+      );
+      expect(result.targetDir).toBe(".");
+      const expectedPackageName = basename(customCwd);
+      expect(result.packageName).toBe(expectedPackageName);
+    });
+  });
+});

package/dist/utils/template.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Template variable replacement utilities
+ */
+/**
+ * Replace template variables in content using mustache-style syntax {{variableName}}
+ *
+ * @param content - The content string containing template variables
+ * @param variables - Object containing variable names and their replacement values
+ * @returns Content with all template variables replaced
+ *
+ * @example
+ * ```typescript
+ * const content = "Hello {{name}}, version {{version}}!";
+ * const variables = { name: "World", version: "1.0.0" };
+ * const result = replaceTemplateVariables(content, variables);
+ * // Result: "Hello World, version 1.0.0!"
+ * ```
+ */
+export declare function replaceTemplateVariables(content: string, variables: Record<string, string>): string;

package/dist/utils/template.mjs

@@ -0,0 +1,8 @@
+export function replaceTemplateVariables(content, variables) {
+  let result = content;
+  for (const [key, value] of Object.entries(variables)) {
+    const pattern = new RegExp(`\\{\\{${key}\\}\\}`, "g");
+    result = result.replace(pattern, value);
+  }
+  return result;
+}

package/dist/utils/template.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Unit tests for template variable replacement utilities
+ */
+export {};