create-esmx 3.0.0-rc.33

package/src/utils/project-name.test.ts

@@ -0,0 +1,345 @@
+/**
+ * Unit tests for project-name utilities
+ */
+
+import { basename } from 'node:path';
+import { describe, expect, it } from 'vitest';
+import { formatProjectName } from './project-name';
+import type { ProjectNameResult } from './project-name';
+
+describe('project-name utilities', () => {
+    describe('formatProjectName', () => {
+        it('should handle simple project name', () => {
+            // Arrange
+            const input = 'foo';
+
+            // Act
+            const result: ProjectNameResult = formatProjectName(input);
+
+            // Assert
+            expect(result.targetDir).toBe('foo');
+            expect(result.packageName).toBe('foo');
+        });
+
+        it('should handle nested path project name', () => {
+            // Arrange
+            const input = 'foo/bar';
+
+            // Act
+            const result: ProjectNameResult = formatProjectName(input);
+
+            // Assert
+            expect(result.targetDir).toBe('foo/bar');
+            expect(result.packageName).toBe('bar');
+        });
+
+        it('should handle scoped package name', () => {
+            // Arrange
+            const input = '@scope/foo';
+
+            // Act
+            const result: ProjectNameResult = formatProjectName(input);
+
+            // Assert
+            expect(result.targetDir).toBe('@scope/foo');
+            expect(result.packageName).toBe('@scope/foo');
+        });
+
+        it('should handle relative path project name', () => {
+            // Arrange
+            const input = './foo/bar';
+
+            // Act
+            const result: ProjectNameResult = formatProjectName(input);
+
+            // Assert
+            expect(result.targetDir).toBe('./foo/bar');
+            expect(result.packageName).toBe('bar');
+        });
+
+        it('should handle absolute path project name', () => {
+            // Arrange
+            const input = '/root/path/to/foo';
+
+            // Act
+            const result: ProjectNameResult = formatProjectName(input);
+
+            // Assert
+            expect(result.targetDir).toBe('/root/path/to/foo');
+            expect(result.packageName).toBe('foo');
+        });
+
+        it('should handle current directory', () => {
+            // Arrange
+            const input = '.';
+            const expectedPackageName = basename(process.cwd());
+
+            // Act
+            const result: ProjectNameResult = formatProjectName(input);
+
+            // Assert
+            expect(result.targetDir).toBe('.');
+            expect(result.packageName).toBe(expectedPackageName);
+        });
+
+        it('should handle project name with trailing slashes', () => {
+            // Arrange
+            const input = 'foo/bar///';
+
+            // Act
+            const result: ProjectNameResult = formatProjectName(input);
+
+            // Assert
+            expect(result.targetDir).toBe('foo/bar');
+            expect(result.packageName).toBe('bar');
+        });
+
+        it('should handle project name with multiple trailing slashes', () => {
+            // Arrange
+            const input = 'my-project/////';
+
+            // Act
+            const result: ProjectNameResult = formatProjectName(input);
+
+            // Assert
+            expect(result.targetDir).toBe('my-project');
+            expect(result.packageName).toBe('my-project');
+        });
+
+        it('should handle deep nested path', () => {
+            // Arrange
+            const input = 'projects/web/frontend/my-app';
+
+            // Act
+            const result: ProjectNameResult = formatProjectName(input);
+
+            // Assert
+            expect(result.targetDir).toBe('projects/web/frontend/my-app');
+            expect(result.packageName).toBe('my-app');
+        });
+
+        it('should handle scoped package with nested path', () => {
+            // Arrange
+            const input = 'org/@scope/package-name';
+
+            // Act
+            const result: ProjectNameResult = formatProjectName(input);
+
+            // Assert
+            expect(result.targetDir).toBe('org/@scope/package-name');
+            expect(result.packageName).toBe('package-name');
+        });
+
+        it('should handle scoped package starting with @', () => {
+            // Arrange
+            const input = '@company/ui-library';
+
+            // Act
+            const result: ProjectNameResult = formatProjectName(input);
+
+            // Assert
+            expect(result.targetDir).toBe('@company/ui-library');
+            expect(result.packageName).toBe('@company/ui-library');
+        });
+
+        it('should handle empty path segment', () => {
+            // Arrange
+            const input = 'foo//bar';
+
+            // Act
+            const result: ProjectNameResult = formatProjectName(input);
+
+            // Assert
+            expect(result.targetDir).toBe('foo//bar');
+            expect(result.packageName).toBe('bar');
+        });
+
+        it('should handle single character project name', () => {
+            // Arrange
+            const input = 'a';
+
+            // Act
+            const result: ProjectNameResult = formatProjectName(input);
+
+            // Assert
+            expect(result.targetDir).toBe('a');
+            expect(result.packageName).toBe('a');
+        });
+
+        it('should handle project name with numbers and hyphens', () => {
+            // Arrange
+            const input = 'my-project-v2';
+
+            // Act
+            const result: ProjectNameResult = formatProjectName(input);
+
+            // Assert
+            expect(result.targetDir).toBe('my-project-v2');
+            expect(result.packageName).toBe('my-project-v2');
+        });
+
+        it('should handle project name ending with slash', () => {
+            // Arrange
+            const input = 'path/to/project/';
+
+            // Act
+            const result: ProjectNameResult = formatProjectName(input);
+
+            // Assert
+            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', () => {
+            // Arrange
+            const input = '/';
+
+            // Act
+            const result: ProjectNameResult = formatProjectName(input);
+
+            // Assert
+            expect(result.targetDir).toBe('');
+            expect(result.packageName).toBe('esmx-project');
+        });
+
+        it('should handle Windows-style paths', () => {
+            // Arrange
+            const input = 'C:\\projects\\my-app';
+
+            // Act
+            const result: ProjectNameResult = formatProjectName(input);
+
+            // Assert
+            expect(result.targetDir).toBe('C:\\projects\\my-app');
+            // Windows paths use backslashes, so the function returns the full path as package name
+            expect(result.packageName).toBe('C:\\projects\\my-app');
+        });
+
+        it('should handle mixed path separators', () => {
+            // Arrange
+            const input = 'path\\to/project';
+
+            // Act
+            const result: ProjectNameResult = formatProjectName(input);
+
+            // Assert
+            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 "."', () => {
+            // Arrange
+            const input = '.';
+            const customCwd = '/custom/working/directory';
+
+            // Act
+            const result: ProjectNameResult = formatProjectName(
+                input,
+                customCwd
+            );
+
+            // Assert
+            expect(result.targetDir).toBe('.');
+            expect(result.packageName).toBe('directory');
+        });
+
+        it('should fallback to process.cwd() when cwd is not provided', () => {
+            // Arrange
+            const input = '.';
+            const expectedPackageName = basename(process.cwd());
+
+            // Act
+            const result: ProjectNameResult = formatProjectName(input);
+
+            // Assert
+            expect(result.targetDir).toBe('.');
+            expect(result.packageName).toBe(expectedPackageName);
+        });
+
+        it('should ignore cwd parameter when input is not "."', () => {
+            // Arrange
+            const input = 'my-project';
+            const customCwd = '/custom/working/directory';
+
+            // Act
+            const result: ProjectNameResult = formatProjectName(
+                input,
+                customCwd
+            );
+
+            // Assert
+            expect(result.targetDir).toBe('my-project');
+            expect(result.packageName).toBe('my-project');
+        });
+
+        it('should handle scoped packages with custom cwd', () => {
+            // Arrange
+            const input = '@scope/package';
+            const customCwd = '/any/directory';
+
+            // Act
+            const result: ProjectNameResult = formatProjectName(
+                input,
+                customCwd
+            );
+
+            // Assert
+            expect(result.targetDir).toBe('@scope/package');
+            expect(result.packageName).toBe('@scope/package');
+        });
+
+        it('should handle nested paths with custom cwd', () => {
+            // Arrange
+            const input = 'org/team/project';
+            const customCwd = '/any/directory';
+
+            // Act
+            const result: ProjectNameResult = formatProjectName(
+                input,
+                customCwd
+            );
+
+            // Assert
+            expect(result.targetDir).toBe('org/team/project');
+            expect(result.packageName).toBe('project');
+        });
+
+        it('should handle Unix-style absolute paths in cwd', () => {
+            // Arrange
+            const input = '.';
+            const customCwd = '/home/user/projects/my-awesome-app';
+
+            // Act
+            const result: ProjectNameResult = formatProjectName(
+                input,
+                customCwd
+            );
+
+            // Assert
+            expect(result.targetDir).toBe('.');
+            expect(result.packageName).toBe('my-awesome-app');
+        });
+
+        it('should handle Windows-style absolute paths in cwd', () => {
+            // Arrange
+            const input = '.';
+            const customCwd = 'C:\\Users\\Developer\\Projects\\WindowsApp';
+
+            // Act
+            const result: ProjectNameResult = formatProjectName(
+                input,
+                customCwd
+            );
+
+            // Assert
+            expect(result.targetDir).toBe('.');
+            // On Unix systems, backslashes are treated as regular characters
+            // On Windows systems, basename would correctly extract 'WindowsApp'
+            // This test verifies the current behavior on the running platform
+            const expectedPackageName = basename(customCwd);
+            expect(result.packageName).toBe(expectedPackageName);
+        });
+    });
+});

package/src/utils/project-name.ts

@@ -0,0 +1,55 @@
+/**
+ * Project name utilities
+ */
+
+import { basename } from 'node:path';
+
+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 function formatProjectName(
+    input: string,
+    cwd?: string
+): ProjectNameResult {
+    const targetDir = input.replace(/\/+$/g, '');
+
+    let packageName: string;
+    if (targetDir === '.') {
+        // Use current directory name as package name
+        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/src/utils/template.test.ts

@@ -0,0 +1,234 @@
+/**
+ * Unit tests for template variable replacement utilities
+ */
+
+import { describe, expect, it } from 'vitest';
+import { replaceTemplateVariables } from './template';
+
+describe('replaceTemplateVariables', () => {
+    describe('basic functionality', () => {
+        it('should replace single variable', () => {
+            // Arrange
+            const content = 'Hello {{name}}!';
+            const variables = { name: 'World' };
+
+            // Act
+            const result = replaceTemplateVariables(content, variables);
+
+            // Assert
+            expect(result).toBe('Hello World!');
+        });
+
+        it('should replace multiple different variables', () => {
+            // Arrange
+            const content = 'Project {{projectName}} version {{version}}';
+            const variables = {
+                projectName: 'my-app',
+                version: '1.0.0'
+            };
+
+            // Act
+            const result = replaceTemplateVariables(content, variables);
+
+            // Assert
+            expect(result).toBe('Project my-app version 1.0.0');
+        });
+
+        it('should replace same variable multiple times', () => {
+            // Arrange
+            const content = '{{greeting}} {{name}}, {{greeting}} again!';
+            const variables = {
+                greeting: 'Hello',
+                name: 'World'
+            };
+
+            // Act
+            const result = replaceTemplateVariables(content, variables);
+
+            // Assert
+            expect(result).toBe('Hello World, Hello again!');
+        });
+    });
+
+    describe('edge cases', () => {
+        it('should handle content without variables', () => {
+            // Arrange
+            const content = 'No variables here';
+            const variables = { name: 'World' };
+
+            // Act
+            const result = replaceTemplateVariables(content, variables);
+
+            // Assert
+            expect(result).toBe('No variables here');
+        });
+
+        it('should handle empty variables object', () => {
+            // Arrange
+            const content = 'Hello {{name}}!';
+            const variables = {};
+
+            // Act
+            const result = replaceTemplateVariables(content, variables);
+
+            // Assert
+            expect(result).toBe('Hello {{name}}!');
+        });
+
+        it('should handle empty content', () => {
+            // Arrange
+            const content = '';
+            const variables = { name: 'World' };
+
+            // Act
+            const result = replaceTemplateVariables(content, variables);
+
+            // Assert
+            expect(result).toBe('');
+        });
+
+        it('should handle variables with special characters', () => {
+            // Arrange
+            const content = 'Command: {{installCommand}}';
+            const variables = { installCommand: 'npm install --save-dev' };
+
+            // Act
+            const result = replaceTemplateVariables(content, variables);
+
+            // Assert
+            expect(result).toBe('Command: npm install --save-dev');
+        });
+
+        it('should handle variables with regex special characters', () => {
+            // Arrange
+            const content = 'Pattern: {{pattern}}';
+            const variables = { pattern: '[a-z]+.*$' };
+
+            // Act
+            const result = replaceTemplateVariables(content, variables);
+
+            // Assert
+            expect(result).toBe('Pattern: [a-z]+.*$');
+        });
+    });
+
+    describe('real-world scenarios', () => {
+        it('should handle all template variables from create-esmx', () => {
+            // Arrange
+            const content = `# {{projectName}}
+
+Install dependencies:
+\`\`\`bash
+{{installCommand}}
+\`\`\`
+
+Start development:
+\`\`\`bash
+{{devCommand}}
+\`\`\`
+
+Build for production:
+\`\`\`bash
+{{buildCommand}}
+\`\`\`
+
+Start production server:
+\`\`\`bash
+{{startCommand}}
+\`\`\`
+
+Esmx version: {{esmxVersion}}`;
+
+            const variables = {
+                projectName: 'my-awesome-app',
+                installCommand: 'pnpm install',
+                devCommand: 'pnpm dev',
+                buildCommand: 'pnpm build',
+                startCommand: 'pnpm start',
+                esmxVersion: '3.0.0-rc.33'
+            };
+
+            // Act
+            const result = replaceTemplateVariables(content, variables);
+
+            // Assert
+            expect(result).toContain('# my-awesome-app');
+            expect(result).toContain('pnpm install');
+            expect(result).toContain('pnpm dev');
+            expect(result).toContain('pnpm build');
+            expect(result).toContain('pnpm start');
+            expect(result).toContain('3.0.0-rc.33');
+            expect(result).not.toContain('{{');
+            expect(result).not.toContain('}}');
+        });
+
+        it('should handle package.json template', () => {
+            // Arrange
+            const content = `{
+  "name": "{{projectName}}",
+  "version": "1.0.0",
+  "scripts": {
+    "dev": "esmx dev",
+    "build": "esmx build",
+    "start": "esmx start"
+  },
+  "dependencies": {
+    "esmx": "{{esmxVersion}}"
+  }
+}`;
+
+            const variables = {
+                projectName: '@scope/my-package',
+                esmxVersion: '^3.0.0'
+            };
+
+            // Act
+            const result = replaceTemplateVariables(content, variables);
+
+            // Assert
+            expect(result).toContain('"name": "@scope/my-package"');
+            expect(result).toContain('"esmx": "^3.0.0"');
+        });
+    });
+
+    describe('variable name validation', () => {
+        it('should handle variables with underscores', () => {
+            // Arrange
+            const content = 'Command: {{install_command}}';
+            const variables = { install_command: 'npm install' };
+
+            // Act
+            const result = replaceTemplateVariables(content, variables);
+
+            // Assert
+            expect(result).toBe('Command: npm install');
+        });
+
+        it('should handle variables with numbers', () => {
+            // Arrange
+            const content = 'Node version: {{node18}}';
+            const variables = { node18: 'v18.12.0' };
+
+            // Act
+            const result = replaceTemplateVariables(content, variables);
+
+            // Assert
+            expect(result).toBe('Node version: v18.12.0');
+        });
+
+        it('should be case sensitive', () => {
+            // Arrange
+            const content = 'Hello {{Name}} and {{name}}!';
+            const variables = {
+                Name: 'Alice',
+                name: 'Bob'
+            };
+
+            // Act
+            const result = replaceTemplateVariables(content, variables);
+
+            // Assert
+            expect(result).toBe('Hello Alice and Bob!');
+        });
+    });
+});

package/src/utils/template.ts

@@ -0,0 +1,34 @@
+/**
+ * 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 function replaceTemplateVariables(
+    content: string,
+    variables: Record<string, string>
+): string {
+    let result = content;
+
+    // Iterate through all variables and replace them
+    for (const [key, value] of Object.entries(variables)) {
+        // Create regex pattern for {{variableName}} with global flag
+        const pattern = new RegExp(`\\{\\{${key}\\}\\}`, 'g');
+        result = result.replace(pattern, value);
+    }
+
+    return result;
+}