@stripchatdev/create-stripchat-extension 0.1.45 → 0.1.47

package/dist/src/projectConfig/recovery/detectPackageManagerFromFiles.test.js

@@ -0,0 +1,37 @@
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { describe, it, expect } from 'vitest';
+import { PACKAGE_MANAGER_LOCK_FILE_MAP } from '../../constants.js';
+import { detectPackageManagerFromFiles } from './detectPackageManagerFromFiles.js';
+const createDirWithLockfile = (packageLockRelPath) => {
+    const projectDir = mkdtempSync(join(tmpdir(), 'sce-detectPackageManagerFromFiles-'));
+    writeFileSync(join(projectDir, packageLockRelPath), '', {
+        encoding: 'utf8',
+    });
+    return projectDir;
+};
+describe('detectPackageManagerFromFiles', () => {
+    it('return value from valid lock', () => {
+        const packageManager = 'npm';
+        const packageLockFileName = PACKAGE_MANAGER_LOCK_FILE_MAP[packageManager];
+        const projectDir = createDirWithLockfile(packageLockFileName);
+        try {
+            const result = detectPackageManagerFromFiles(projectDir);
+            expect(result).toBe(packageManager);
+        }
+        finally {
+            rmSync(projectDir, { recursive: true, force: true });
+        }
+    });
+    it('return null is no known lock file', () => {
+        const projectDir = createDirWithLockfile('some.lock');
+        try {
+            const result = detectPackageManagerFromFiles(projectDir);
+            expect(result).toBe(null);
+        }
+        finally {
+            rmSync(projectDir, { recursive: true, force: true });
+        }
+    });
+});

package/dist/src/projectConfig/recovery/parseAgentsMd.d.ts

@@ -0,0 +1,10 @@
+import type { TCategory, TFramework, TLanguage, TSlot } from '../../types.js';
+type TParseAgentsMdResult = {
+    category?: TCategory;
+    framework?: TFramework;
+    language?: TLanguage;
+    slots: TSlot[];
+};
+export declare const parseAgentsMdV1: (projectDir: string) => TParseAgentsMdResult;
+export declare const parseAgentsMd: (projectDir: string, templateVersion: number) => TParseAgentsMdResult;
+export {};

package/dist/src/projectConfig/recovery/parseAgentsMd.js

@@ -0,0 +1,52 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { AGENTS_MD_REL_PATH } from '../../constants.js';
+import { AppError } from '../../helpers/error.js';
+import { getIsValidCategory } from '../../validators/getIsValidCategory.js';
+import { getIsValidFramework } from '../../validators/getIsValidFramework.js';
+import { getIsValidLanguage } from '../../validators/getIsValidLanguage.js';
+import { getIsValidSlot } from '../../validators/getIsValidSlot.js';
+export const parseAgentsMdV1 = (projectDir) => {
+    const result = {
+        slots: [],
+    };
+    const agentsMdPath = join(projectDir, AGENTS_MD_REL_PATH);
+    if (!existsSync(agentsMdPath)) {
+        throw new AppError(`Agents.md not found, can not recover project config: ${agentsMdPath}`);
+    }
+    const content = readFileSync(agentsMdPath, 'utf8');
+    const languageMatch = content.match(/-\sLanguage: (.+)/);
+    const frameworkMatch = content.match(/-\sFramework: (.+)/);
+    const categoryMatch = content.match(/-\sCategory: (.+)/);
+    const slotsMatch = content.match(/-\sSlots: (.+)/);
+    const languageRaw = languageMatch?.[1] || '';
+    const frameworkRaw = frameworkMatch?.[1] || '';
+    const categoryRaw = categoryMatch?.[1] || '';
+    const slotsRaw = slotsMatch?.[1] || '';
+    if (getIsValidLanguage(languageRaw)) {
+        result.language = languageRaw;
+    }
+    if (getIsValidFramework(frameworkRaw)) {
+        result.framework = frameworkRaw;
+    }
+    if (getIsValidCategory(categoryRaw)) {
+        result.category = categoryRaw;
+    }
+    const slots = new Set();
+    const slotsRawParts = slotsRaw.split(', ');
+    slotsRawParts.forEach((slot) => {
+        if (getIsValidSlot(slot)) {
+            slots.add(slot);
+        }
+    });
+    result.slots = Array.from(slots);
+    return result;
+};
+export const parseAgentsMd = (projectDir, templateVersion) => {
+    switch (templateVersion) {
+        case 1:
+            return parseAgentsMdV1(projectDir);
+        default:
+            throw new AppError('Failed to parse agents md file, version is not supported');
+    }
+};

package/dist/src/projectConfig/recovery/parseAgentsMd.test.d.ts

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

package/dist/src/projectConfig/recovery/parseAgentsMd.test.js

@@ -0,0 +1,67 @@
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { describe, it, expect } from 'vitest';
+import { CLI_COMMANDS_MAP, EXT_HELPER_VERSION } from '../../constants.js';
+import { executeCommands } from '../../templater/executor.js';
+import { mapProjectConfigToTemplateData } from '../../templater/mappers/mapProjectConfigToTemplateModel.js';
+import { planProject } from '../../templater/planner.js';
+import { MANAGED_TEMPLATES } from '../../templates/constants.js';
+import { LAST_TEMPLATE_VERSION, TEMPLATES_DIR } from '../../templates/templates.js';
+import { buildProjectConfig } from '../buildProjectConfig.js';
+import { parseAgentsMd } from './parseAgentsMd.js';
+const testProjectConfig = buildProjectConfig({
+    category: 'games-and-fun',
+    framework: 'preact',
+    lastTemplateVersion: LAST_TEMPLATE_VERSION,
+    cliCommands: CLI_COMMANDS_MAP,
+    managedTemplates: MANAGED_TEMPLATES,
+    templatesDir: TEMPLATES_DIR,
+    name: 'test',
+    slots: ['EXTENSION_SLOT_MAIN_GAME_FUN', 'EXTENSION_SLOT_BACKGROUND'],
+    extHelperVersion: EXT_HELPER_VERSION,
+    language: 'ts',
+    packageManager: 'npm',
+});
+describe('parseAgentsMd', () => {
+    it('throw error if agents md is not 1 version', () => {
+        expect(() => parseAgentsMd('/some-project-dir', 2)).toThrow();
+    });
+    it('throw error in agents md is not found', () => {
+        expect(() => parseAgentsMd('/some-project-dir', 1)).toThrow();
+    });
+    it('correct parse all data', () => {
+        const projectDir = mkdtempSync(join(tmpdir(), 'sce-parse-agents-md-'));
+        try {
+            const templateVersion = 1;
+            const templateData = mapProjectConfigToTemplateData(testProjectConfig);
+            const commands = planProject(projectDir, templateVersion, templateData);
+            executeCommands(commands);
+            const result = parseAgentsMd(projectDir, templateVersion);
+            expect(result).toEqual({
+                category: templateData.config.category,
+                framework: templateData.config.framework,
+                language: templateData.config.language,
+                slots: templateData.config.slots,
+            });
+        }
+        finally {
+            rmSync(projectDir, { force: true, recursive: true });
+        }
+    });
+    it('return empty values for non parsed values', () => {
+        const projectDir = mkdtempSync(join(tmpdir(), 'sce-parse-agents-md-'));
+        try {
+            writeFileSync(join(projectDir, 'AGENTS.md'), 'some invalid content', {
+                encoding: 'utf8',
+            });
+            const result = parseAgentsMd(projectDir, 1);
+            expect(result).toEqual({
+                slots: [],
+            });
+        }
+        finally {
+            rmSync(projectDir, { force: true, recursive: true });
+        }
+    });
+});

package/dist/src/projectConfig/recovery/resolveProjectNameFromDir.d.ts

@@ -0,0 +1 @@
+export declare const resolveProjectNameFromDir: (projectDir: string) => string;

package/dist/src/projectConfig/recovery/resolveProjectNameFromDir.js

@@ -0,0 +1,11 @@
+import { basename } from 'node:path';
+import { AppError } from '../../helpers/error.js';
+import { validateName } from '../../validators/validateName.js';
+export const resolveProjectNameFromDir = (projectDir) => {
+    const name = basename(projectDir);
+    const result = validateName(name);
+    if (result === true) {
+        return name;
+    }
+    throw new AppError(`Unable to resolve valid project name: ${result}`);
+};

package/dist/src/projectConfig/recovery/resolveProjectNameFromDir.test.d.ts

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

package/dist/src/projectConfig/recovery/resolveProjectNameFromDir.test.js

@@ -0,0 +1,21 @@
+import { describe, expect, it } from 'vitest';
+import { AppError } from '../../helpers/error.js';
+import { resolveProjectNameFromDir } from './resolveProjectNameFromDir.js';
+describe('resolveProjectNameFromDir', () => {
+    it('returns valid project name from directory basename', () => {
+        expect(resolveProjectNameFromDir('/tmp/some-extension')).toBe('some-extension');
+    });
+    it('returns valid project name from directory basename with trailing slash', () => {
+        expect(resolveProjectNameFromDir('/tmp/some-extension/')).toBe('some-extension');
+    });
+    it('throws AppError when basename is not a valid project name', () => {
+        try {
+            resolveProjectNameFromDir('/tmp/Invalid Name With Spaces');
+            throw new Error('Expected resolveProjectNameFromDir to throw');
+        }
+        catch (error) {
+            expect(error).toBeInstanceOf(AppError);
+            expect(error.message).toMatch(/^Unable to resolve valid project name:/);
+        }
+    });
+});

package/dist/src/projectConfig/resolveExistsProjectConfig.d.ts

@@ -0,0 +1,2 @@
+import type { TProjectConfig } from '../types.js';
+export declare const resolveExistsProjectConfig: (projectDir: string) => TProjectConfig;

package/dist/src/projectConfig/resolveExistsProjectConfig.js

@@ -0,0 +1,34 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { PROJECT_CONFIG_REL_PATH } from '../constants.js';
+import { AppError } from '../helpers/error.js';
+import { recoverProjectConfig } from './recoverProjectConfig.js';
+import { getIsValidProjectConfig } from './validators/getIsValidProjectConfig.js';
+import { validateProjectConfig } from './validators/validateProjectConfig.js';
+export const resolveExistsProjectConfig = (projectDir) => {
+    const projectConfigPath = join(projectDir, PROJECT_CONFIG_REL_PATH);
+    let projectConfig;
+    if (!existsSync(projectConfigPath)) {
+        projectConfig = recoverProjectConfig(projectDir);
+    }
+    else {
+        const contentRaw = readFileSync(projectConfigPath, 'utf8');
+        if (!contentRaw) {
+            throw new AppError(`Project config is empty: ${projectConfigPath}`);
+        }
+        try {
+            projectConfig = JSON.parse(contentRaw);
+        }
+        catch {
+            throw new AppError(`Failed to parse exists project config: ${projectConfigPath}`);
+        }
+    }
+    if (!getIsValidProjectConfig(projectConfig)) {
+        throw new AppError(`Project config is invalid: ${projectConfigPath}`);
+    }
+    const validationResult = validateProjectConfig(projectConfig);
+    if (validationResult !== true) {
+        throw new AppError(`Project config setup is invalid: ${validationResult}`);
+    }
+    return projectConfig;
+};

package/dist/src/projectConfig/updateProjectConfig.d.ts

@@ -0,0 +1,2 @@
+import type { TProjectConfig, TProjectConfigUserProps } from '../types.js';
+export declare const updateProjectConfig: (lastTemplateVersion: number, projectConfigUserProps: TProjectConfigUserProps) => TProjectConfig;

package/dist/src/projectConfig/updateProjectConfig.js

@@ -0,0 +1,20 @@
+import { CLI_COMMANDS_MAP, EXT_HELPER_VERSION } from '../constants.js';
+import { MANAGED_TEMPLATES } from '../templates/constants.js';
+import { TEMPLATES_DIR } from '../templates/templates.js';
+import { buildProjectConfig } from './buildProjectConfig.js';
+export const updateProjectConfig = (lastTemplateVersion, projectConfigUserProps) => {
+    const { category, framework, language, name, packageManager, slots } = projectConfigUserProps;
+    return buildProjectConfig({
+        name,
+        category,
+        language,
+        framework,
+        packageManager,
+        slots,
+        extHelperVersion: EXT_HELPER_VERSION,
+        lastTemplateVersion,
+        cliCommands: CLI_COMMANDS_MAP,
+        managedTemplates: MANAGED_TEMPLATES,
+        templatesDir: TEMPLATES_DIR,
+    });
+};

package/dist/src/projectConfig/validators/getIsValidProjectConfig.d.ts

@@ -0,0 +1,2 @@
+import type { TProjectConfig } from '../../types.js';
+export declare const getIsValidProjectConfig: (data: unknown) => data is TProjectConfig;

package/dist/src/projectConfig/validators/getIsValidProjectConfig.js

@@ -0,0 +1,6 @@
+export const getIsValidProjectConfig = (data) => {
+    if (!data) {
+        return false;
+    }
+    return typeof data === 'object';
+};

package/dist/src/projectConfig/validators/getIsValidProjectConfig.test.d.ts

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

package/dist/src/projectConfig/validators/getIsValidProjectConfig.test.js

@@ -0,0 +1,33 @@
+import { describe, expect, it } from 'vitest';
+import { CLI_COMMANDS_MAP } from '../../constants.js';
+import { resolveDependencies } from '../../dependencies/resolveDependencies.js';
+import { LAST_TEMPLATE_VERSION } from '../../templates/templates.js';
+import { getIsValidProjectConfig } from './getIsValidProjectConfig.js';
+describe('isValidProjectConfig', () => {
+    const language = 'ts';
+    const framework = 'preact';
+    const { dependencies, devDependencies } = resolveDependencies(language, framework);
+    const baseConfig = {
+        cliCommands: CLI_COMMANDS_MAP,
+        name: 'project-name',
+        packageManager: 'npm',
+        framework,
+        language,
+        category: 'chat-bots',
+        dependencies,
+        devDependencies,
+        extHelperVersion: '0.0.0-test',
+        slots: ['EXTENSION_SLOT_MAIN_GAME_FUN', 'EXTENSION_SLOT_BACKGROUND'],
+        managedFiles: [],
+        lastTemplateVersion: LAST_TEMPLATE_VERSION,
+    };
+    it('return true if config project is valid', () => {
+        expect(getIsValidProjectConfig(baseConfig)).toBe(true);
+    });
+    it('return false for non object type', () => {
+        expect(getIsValidProjectConfig('')).toBe(false);
+    });
+    it('return false for null', () => {
+        expect(getIsValidProjectConfig(null)).toBe(false);
+    });
+});

package/dist/src/projectConfig/validators/validateProjectConfig.d.ts

@@ -0,0 +1,2 @@
+import type { TProjectConfig } from '../../types.js';
+export declare const validateProjectConfig: (projectConfig: TProjectConfig) => string | true;

package/dist/src/projectConfig/validators/validateProjectConfig.js

@@ -0,0 +1,30 @@
+import { getIsValidCategory } from '../../validators/getIsValidCategory.js';
+import { getIsValidFramework } from '../../validators/getIsValidFramework.js';
+import { getIsValidLanguage } from '../../validators/getIsValidLanguage.js';
+import { getIsValidPackageManager } from '../../validators/getIsValidPackageManager.js';
+import { validateName } from '../../validators/validateName.js';
+import { validateSlots } from '../../validators/validateSlots.js';
+export const validateProjectConfig = (projectConfig) => {
+    const { category, framework, language, name, packageManager, slots } = projectConfig;
+    const validateNameResult = validateName(name);
+    if (validateNameResult !== true) {
+        return validateNameResult;
+    }
+    if (!getIsValidFramework(framework)) {
+        return `Framework is invalid: ${framework}`;
+    }
+    if (!getIsValidLanguage(language)) {
+        return `Language is invalid: ${language}`;
+    }
+    if (!getIsValidCategory(category)) {
+        return `Category is invalid: ${category}`;
+    }
+    if (!getIsValidPackageManager(packageManager)) {
+        return 'Invalid package manager';
+    }
+    const validateSlotsResult = validateSlots(slots, category);
+    if (validateSlotsResult.invalid.length > 0 || validateSlotsResult.violations.length > 0) {
+        return `Invalid slots ${slots.join(', ')} for category: ${category}`;
+    }
+    return true;
+};

package/dist/src/projectConfig/validators/validateProjectConfig.test.d.ts

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

package/dist/src/projectConfig/validators/validateProjectConfig.test.js

@@ -0,0 +1,215 @@
+import { describe, it, expect } from 'vitest';
+import { CLI_COMMANDS_MAP, EXT_HELPER_VERSION, SLOT_RULES_BY_CATEGORY } from '../../constants.js';
+import { MANAGED_TEMPLATES } from '../../templates/constants.js';
+import { TEMPLATES_DIR } from '../../templates/templates.js';
+import { buildProjectConfig } from '../buildProjectConfig.js';
+import { validateProjectConfig } from './validateProjectConfig.js';
+const baseValidConfig = buildProjectConfig({
+    slots: [...SLOT_RULES_BY_CATEGORY['games-and-fun'].requiredBase, 'EXTENSION_SLOT_RIGHT_OVERLAY'],
+    category: 'games-and-fun',
+    packageManager: 'npm',
+    framework: 'preact',
+    language: 'ts',
+    name: 'some-extension',
+    extHelperVersion: EXT_HELPER_VERSION,
+    lastTemplateVersion: 1,
+    cliCommands: CLI_COMMANDS_MAP,
+    managedTemplates: MANAGED_TEMPLATES,
+    templatesDir: TEMPLATES_DIR,
+});
+describe('validateProjectConfig', () => {
+    it('return true if valid', () => {
+        const result = validateProjectConfig(baseValidConfig);
+        expect(result).toBe(true);
+    });
+    describe('name validation', () => {
+        it('return error message if name is invalid', () => {
+            const invalidNameConfig = {
+                ...baseValidConfig,
+                name: 'Invalid Name With Spaces', // invalid name format
+            };
+            const result = validateProjectConfig(invalidNameConfig);
+            expect(result).not.toBe(true);
+            expect(typeof result).toBe('string');
+        });
+        it('return error message if name is empty', () => {
+            const invalidNameConfig = {
+                ...baseValidConfig,
+                name: '',
+            };
+            const result = validateProjectConfig(invalidNameConfig);
+            expect(result).not.toBe(true);
+            expect(typeof result).toBe('string');
+        });
+    });
+    describe('framework validation', () => {
+        it('return error message if framework is invalid', () => {
+            const invalidFrameworkConfig = {
+                ...baseValidConfig,
+                framework: 'invalid-framework',
+            };
+            const result = validateProjectConfig(invalidFrameworkConfig);
+            expect(result).toBe('Framework is invalid: invalid-framework');
+        });
+        it('accept preact framework', () => {
+            const result = validateProjectConfig(baseValidConfig);
+            expect(result).toBe(true);
+        });
+        it('accept vanilla framework', () => {
+            const vanillaConfig = {
+                ...baseValidConfig,
+                framework: 'vanilla',
+            };
+            const result = validateProjectConfig(vanillaConfig);
+            expect(result).toBe(true);
+        });
+    });
+    describe('language validation', () => {
+        it('return error message if language is invalid', () => {
+            const invalidLanguageConfig = {
+                ...baseValidConfig,
+                language: 'python',
+            };
+            const result = validateProjectConfig(invalidLanguageConfig);
+            expect(result).toBe('Language is invalid: python');
+        });
+        it('accept typescript language', () => {
+            const result = validateProjectConfig(baseValidConfig);
+            expect(result).toBe(true);
+        });
+        it('accept javascript language', () => {
+            const jsConfig = {
+                ...baseValidConfig,
+                language: 'js',
+            };
+            const result = validateProjectConfig(jsConfig);
+            expect(result).toBe(true);
+        });
+    });
+    describe('category validation', () => {
+        it('return error message if category is invalid', () => {
+            const invalidCategoryConfig = {
+                ...baseValidConfig,
+                category: 'invalid-category',
+            };
+            const result = validateProjectConfig(invalidCategoryConfig);
+            expect(result).toBe('Category is invalid: invalid-category');
+        });
+        it('accept games-and-fun category', () => {
+            const result = validateProjectConfig(baseValidConfig);
+            expect(result).toBe(true);
+        });
+        it('accept sex-toys category', () => {
+            const sexToysConfig = {
+                ...baseValidConfig,
+                category: 'sex-toys',
+                slots: [...SLOT_RULES_BY_CATEGORY['sex-toys'].requiredBase, 'EXTENSION_SLOT_RIGHT_OVERLAY'],
+            };
+            const result = validateProjectConfig(sexToysConfig);
+            expect(result).toBe(true);
+        });
+        it('accept chat-bots category', () => {
+            const chatBotsConfig = {
+                ...baseValidConfig,
+                category: 'chat-bots',
+                slots: [...SLOT_RULES_BY_CATEGORY['chat-bots'].requiredBase],
+            };
+            const result = validateProjectConfig(chatBotsConfig);
+            expect(result).toBe(true);
+        });
+    });
+    describe('package manager validation', () => {
+        it('return error message if package manager is invalid', () => {
+            const invalidPackageManagerConfig = {
+                ...baseValidConfig,
+                packageManager: 'invalid-pm',
+            };
+            const result = validateProjectConfig(invalidPackageManagerConfig);
+            expect(result).toBe('Invalid package manager');
+        });
+        it('accept npm package manager', () => {
+            const result = validateProjectConfig(baseValidConfig);
+            expect(result).toBe(true);
+        });
+        it('accept yarn package manager', () => {
+            const yarnConfig = {
+                ...baseValidConfig,
+                packageManager: 'yarn',
+            };
+            const result = validateProjectConfig(yarnConfig);
+            expect(result).toBe(true);
+        });
+        it('accept pnpm package manager', () => {
+            const pnpmConfig = {
+                ...baseValidConfig,
+                packageManager: 'pnpm',
+            };
+            const result = validateProjectConfig(pnpmConfig);
+            expect(result).toBe(true);
+        });
+        it('accept bun package manager', () => {
+            const bunConfig = {
+                ...baseValidConfig,
+                packageManager: 'bun',
+            };
+            const result = validateProjectConfig(bunConfig);
+            expect(result).toBe(true);
+        });
+    });
+    describe('slots validation', () => {
+        it('fails when slots are invalid for category', () => {
+            const invalidSlotsConfig = {
+                ...baseValidConfig,
+                slots: ['invalid-slot'],
+            };
+            const result = validateProjectConfig(invalidSlotsConfig);
+            expect(result).toBe('Invalid slots invalid-slot for category: games-and-fun');
+        });
+        it('fails when required slots for category are missing', () => {
+            const invalidSlotsConfig = {
+                ...baseValidConfig,
+                category: 'games-and-fun',
+                slots: [],
+            };
+            const result = validateProjectConfig(invalidSlotsConfig);
+            expect(result).toBe('Invalid slots  for category: games-and-fun');
+        });
+        it('accept valid overlay slot for games-and-fun category', () => {
+            const result = validateProjectConfig(baseValidConfig);
+            expect(result).toBe(true);
+        });
+        it('accept another overlay slot for games-and-fun category', () => {
+            const validSlotsConfig = {
+                ...baseValidConfig,
+                slots: [
+                    ...SLOT_RULES_BY_CATEGORY['games-and-fun'].requiredBase,
+                    'EXTENSION_SLOT_VIDEO_DECORATIVE_OVERLAY',
+                ],
+            };
+            const result = validateProjectConfig(validSlotsConfig);
+            expect(result).toBe(true);
+        });
+    });
+    describe('combined validations', () => {
+        it('return first validation error when multiple fields are invalid', () => {
+            const multipleInvalidConfig = {
+                ...baseValidConfig,
+                name: 'Invalid Name',
+                framework: 'invalid-framework',
+            };
+            const result = validateProjectConfig(multipleInvalidConfig);
+            // Should return the first error (name validation runs first)
+            expect(result).not.toBe(true);
+            expect(typeof result).toBe('string');
+        });
+        it('return error when both framework and slots are invalid', () => {
+            const multipleInvalidConfig = {
+                ...baseValidConfig,
+                framework: 'invalid-framework',
+                slots: [],
+            };
+            const result = validateProjectConfig(multipleInvalidConfig);
+            expect(result).toBe('Framework is invalid: invalid-framework');
+        });
+    });
+});

package/dist/src/templater/executor.d.ts

@@ -0,0 +1,2 @@
+import type { TTemplateCommand } from '../types.js';
+export declare const executeCommands: (commands: TTemplateCommand[], cb?: (command: TTemplateCommand) => void) => void;

package/dist/src/templater/executor.js

@@ -0,0 +1,22 @@
+import ejs from 'ejs';
+import { copyFileSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+const renderTemplate = (templatePath, data) => {
+    const template = readFileSync(templatePath, 'utf-8');
+    return ejs.render(template, data, { filename: templatePath });
+};
+export const executeCommands = (commands, cb) => {
+    for (const command of commands) {
+        mkdirSync(dirname(command.destPath), { recursive: true });
+        cb?.(command);
+        if (command.type === 'render') {
+            const content = renderTemplate(command.srcPath, command.data);
+            writeFileSync(command.destPath, content, 'utf-8');
+            continue;
+        }
+        if (command.type === 'copy') {
+            copyFileSync(command.srcPath, command.destPath);
+            continue;
+        }
+    }
+};

package/dist/src/templater/executor.test.d.ts

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