@stripchatdev/create-stripchat-extension 0.1.46 → 0.1.48

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

package/dist/src/{executor.test.js → templater/executor.test.js}

@@ -2,6 +2,10 @@ import { readFile, rm, mkdtemp } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { CLI_COMMANDS_MAP, EXT_HELPER_VERSION } from '../constants.js';
+import { buildProjectConfig } from '../projectConfig/buildProjectConfig.js';
+import { MANAGED_TEMPLATES } from '../templates/constants.js';
+import { LAST_TEMPLATE_VERSION, TEMPLATES_DIR } from '../templates/templates.js';
 import { executeCommands } from './executor.js';
 import { mapProjectConfigToTemplateData } from './mappers/mapProjectConfigToTemplateModel.js';
 import { planProject } from './planner.js';
@@ -13,9 +17,9 @@ const rewriteDestPaths = (commands, destDir) => commands.map((cmd) => {
     }
     return { ...cmd, destPath };
 });
-const buildCommands = async (config, destDir) => {
+const buildCommands = (config, destDir) => {
     const data = mapProjectConfigToTemplateData(config);
-    const commands = await planProject(data, '/output/my-ext');
+    const commands = planProject('/output/my-ext', config.lastTemplateVersion, data);
     return rewriteDestPaths(commands, destDir);
 };
 describe('executeCommands', () => {
@@ -27,17 +31,22 @@ describe('executeCommands', () => {
         await rm(tmpDir, { recursive: true });
     });
     it('renders EJS templates into destination files', async () => {
-        const config = {
+        const projectConfig = buildProjectConfig({
             category: 'games-and-fun',
             framework: 'vanilla',
             language: 'ts',
             name: 'my-ext',
             packageManager: 'npm',
             slots: ['EXTENSION_SLOT_MAIN_GAME_FUN', 'EXTENSION_SLOT_BACKGROUND'],
-        };
-        const commands = await buildCommands(config, tmpDir);
+            extHelperVersion: EXT_HELPER_VERSION,
+            lastTemplateVersion: LAST_TEMPLATE_VERSION,
+            cliCommands: CLI_COMMANDS_MAP,
+            managedTemplates: MANAGED_TEMPLATES,
+            templatesDir: TEMPLATES_DIR,
+        });
+        const commands = buildCommands(projectConfig, tmpDir);
         const cb = vi.fn();
-        await executeCommands(commands, cb);
+        executeCommands(commands, cb);
         for (const command of commands) {
             if (command.type === 'render') {
                 const content = await readFile(command.destPath, 'utf-8');
@@ -56,22 +65,27 @@ describe('executeCommands', () => {
         }
         expect(cb).toHaveBeenCalledTimes(commands.length);
     });
-    it('rejects with ENOENT when a source template is missing', async () => {
-        const config = {
+    it('rejects with ENOENT when a source template is missing', () => {
+        const projectConfig = buildProjectConfig({
             category: 'sex-toys',
             framework: 'vanilla',
             language: 'js',
             name: 'my-ext',
             packageManager: 'npm',
             slots: ['EXTENSION_SLOT_MAIN_SEX_TOY', 'EXTENSION_SLOT_BACKGROUND'],
-        };
-        const commands = await buildCommands(config, tmpDir);
+            extHelperVersion: EXT_HELPER_VERSION,
+            lastTemplateVersion: LAST_TEMPLATE_VERSION,
+            cliCommands: CLI_COMMANDS_MAP,
+            managedTemplates: MANAGED_TEMPLATES,
+            templatesDir: TEMPLATES_DIR,
+        });
+        const commands = buildCommands(projectConfig, tmpDir);
         const corruptedIndex = commands.findIndex((c) => c.type === 'render');
         const corrupted = [...commands];
         corrupted[corruptedIndex] = {
             ...corrupted[corruptedIndex],
             srcPath: join(tmpDir, 'nonexistent.ejs'),
         };
-        await expect(executeCommands(corrupted)).rejects.toThrow(/ENOENT/);
+        expect(() => executeCommands(corrupted)).toThrow(/ENOENT/);
     });
 });

package/dist/src/templater/helpers/getIsTypescriptOnlyFile.d.ts

@@ -0,0 +1 @@
+export declare const getIsTypescriptOnlyFile: (templateFilePath: string) => boolean;

package/dist/src/templater/helpers/getIsTypescriptOnlyFile.js

@@ -0,0 +1,10 @@
+import { relative } from 'node:path';
+import { TS_ONLY_FILES } from '../../constants.js';
+import { toNormalizedRelPath } from '../../helpers/normalizePath.js';
+import { TEMPLATES_DIR } from '../../templates/templates.js';
+export const getIsTypescriptOnlyFile = (templateFilePath) => {
+    const withoutEjs = relative(TEMPLATES_DIR, templateFilePath).replace(/\.ejs$/, '');
+    const normalizedFile = toNormalizedRelPath(withoutEjs);
+    const withoutVersion = normalizedFile.split('/').slice(1).join('/');
+    return TS_ONLY_FILES.includes(withoutVersion);
+};

package/dist/src/templater/helpers/getIsTypescriptOnlyFile.test.d.ts

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

package/dist/src/templater/helpers/getIsTypescriptOnlyFile.test.js

@@ -0,0 +1,25 @@
+import { join } from 'node:path';
+import { describe, expect, it } from 'vitest';
+import { TEMPLATES_DIR } from '../../templates/templates.js';
+import { getIsTypescriptOnlyFile } from './getIsTypescriptOnlyFile.js';
+const templatePath = (fileName) => join(TEMPLATES_DIR, 'v1', fileName);
+describe('isTypescriptOnlyFile', () => {
+    it('returns true for tsconfig.json', () => {
+        expect(getIsTypescriptOnlyFile(templatePath('tsconfig.json'))).toBe(true);
+    });
+    it('returns true for tsconfig.json.ejs (strips .ejs suffix)', () => {
+        expect(getIsTypescriptOnlyFile(templatePath('tsconfig.json.ejs'))).toBe(true);
+    });
+    it('returns false for package.json', () => {
+        expect(getIsTypescriptOnlyFile(templatePath('package.json'))).toBe(false);
+    });
+    it('returns false for package.json.ejs', () => {
+        expect(getIsTypescriptOnlyFile(templatePath('package.json.ejs'))).toBe(false);
+    });
+    it('returns false for vite.config.ts.ejs', () => {
+        expect(getIsTypescriptOnlyFile(templatePath('vite.config.ts.ejs'))).toBe(false);
+    });
+    it('returns false for an empty string', () => {
+        expect(getIsTypescriptOnlyFile('')).toBe(false);
+    });
+});

package/dist/src/templater/helpers/resolveTemplateExtension.d.ts

@@ -0,0 +1 @@
+export declare const resolveTemplateExtension: (templatePath: string, isTypescript: boolean) => string;

package/dist/src/templater/helpers/resolveTemplateExtension.js

@@ -0,0 +1,16 @@
+import { dirname, join, parse } from 'node:path';
+import { TEMPLATE_EXT } from '../../templates/constants.js';
+const resolveOutputExtension = (templateExt, isTypescript) => {
+    const map = {
+        '.ts': isTypescript ? '.ts' : '.js',
+        '.tsx': isTypescript ? '.tsx' : '.jsx',
+    };
+    return map[templateExt] ?? templateExt;
+};
+export const resolveTemplateExtension = (templatePath, isTypescript) => {
+    const withoutEjs = templatePath.endsWith(TEMPLATE_EXT)
+        ? templatePath.slice(0, -TEMPLATE_EXT.length)
+        : templatePath;
+    const withoutEjsParsed = parse(withoutEjs);
+    return join(dirname(templatePath), `${withoutEjsParsed.name}${resolveOutputExtension(withoutEjsParsed.ext, isTypescript)}`);
+};

package/dist/src/templater/helpers/resolveTemplateExtension.test.d.ts

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

package/dist/src/{mappers → templater/mappers}/mapProjectConfigToTemplateModel.d.ts

@@ -1,2 +1,2 @@
-import type { TProjectConfig, TTemplateData } from '../types.js';
+import type { TProjectConfig, TTemplateData } from '../../types.js';
 export declare const mapProjectConfigToTemplateData: (config: TProjectConfig) => TTemplateData;

package/dist/src/{mappers → templater/mappers}/mapProjectConfigToTemplateModel.js

@@ -1,24 +1,22 @@
-import { EXT_HELPER_VERSION, JSX_FRAMEWORKS, PACKAGE_MANAGER_COMMANDS_MAP, SLOT_LABELS } from '../constants.js';
+import { PACKAGE_MANAGER_COMMANDS_MAP, SLOT_LABELS } from '../../constants.js';
+import { getIsJsxFramework } from '../../helpers/getIsJsxFramework.js';
+import { getIsTypescript } from '../../helpers/getIsTypescript.js';
 const buildSlotResolverEntries = (config) => config.slots.map((slot) => ({
     slotCamelCased: SLOT_LABELS[slot],
     slot,
 }));
 export const mapProjectConfigToTemplateData = (config) => {
-    const isTypescript = config.language === 'ts';
-    const isJsxFramework = JSX_FRAMEWORKS.includes(config.framework);
+    const isTypescript = getIsTypescript(config.language);
+    const isJsxFramework = getIsJsxFramework(config.framework);
     const ext = isTypescript ? 'ts' : 'js';
     const jsxExt = isTypescript ? 'tsx' : 'jsx';
     return {
         config,
+        ...config,
         ext,
-        extHelperVersion: EXT_HELPER_VERSION,
-        framework: config.framework,
         isJsxFramework,
         isTypescript,
         jsxExt,
-        language: config.language,
-        name: config.name,
-        packageManager: config.packageManager,
         packageManagerCommands: PACKAGE_MANAGER_COMMANDS_MAP[config.packageManager],
         slotsEntries: buildSlotResolverEntries(config),
     };

package/dist/src/templater/mappers/mapProjectConfigToTemplateModel.test.d.ts

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

package/dist/src/{mappers → templater/mappers}/mapProjectConfigToTemplateModel.test.js

@@ -1,15 +1,31 @@
 import { describe, expect, it } from 'vitest';
-import { EXT_HELPER_VERSION } from '../constants.js';
-import { mapProjectConfigToTemplateData } from '../mappers/mapProjectConfigToTemplateModel.js';
-const makeConfig = (overrides = {}) => ({
-    category: 'games-and-fun',
-    framework: 'vanilla',
-    language: 'ts',
-    name: 'test-ext',
-    packageManager: 'npm',
-    slots: ['EXTENSION_SLOT_MAIN_GAME_FUN', 'EXTENSION_SLOT_BACKGROUND'],
-    ...overrides,
-});
+import { CLI_COMMANDS_MAP, EXT_HELPER_VERSION } from '../../constants.js';
+import { DEPENDENCIES } from '../../dependencies/constants.js';
+import { buildProjectConfig } from '../../projectConfig/buildProjectConfig.js';
+import { MANAGED_TEMPLATES } from '../../templates/constants.js';
+import { LAST_TEMPLATE_VERSION, TEMPLATES_DIR } from '../../templates/templates.js';
+import { mapProjectConfigToTemplateData } from './mapProjectConfigToTemplateModel.js';
+const makeConfig = (overrides = {}) => {
+    const language = overrides.language ?? 'ts';
+    const framework = overrides.framework ?? 'vanilla';
+    const projectConfig = buildProjectConfig({
+        name: 'test-ext',
+        category: 'games-and-fun',
+        framework,
+        language,
+        packageManager: 'npm',
+        slots: ['EXTENSION_SLOT_MAIN_GAME_FUN', 'EXTENSION_SLOT_BACKGROUND'],
+        extHelperVersion: EXT_HELPER_VERSION,
+        lastTemplateVersion: LAST_TEMPLATE_VERSION,
+        cliCommands: CLI_COMMANDS_MAP,
+        managedTemplates: MANAGED_TEMPLATES,
+        templatesDir: TEMPLATES_DIR,
+    });
+    return {
+        ...projectConfig,
+        ...overrides,
+    };
+};
 describe('mapProjectConfigToTemplateData', () => {
     it('sets typescript flags when language is ts', () => {
         const result = mapProjectConfigToTemplateData(makeConfig({ language: 'ts' }));
@@ -75,11 +91,6 @@ describe('mapProjectConfigToTemplateData', () => {
         const result = mapProjectConfigToTemplateData(makeConfig({ slots: [] }));
         expect(result.slotsEntries).toEqual([]);
     });
-    it('passes config reference unchanged', () => {
-        const config = makeConfig();
-        const result = mapProjectConfigToTemplateData(config);
-        expect(result.config).toBe(config);
-    });
     it('passes name, framework, language, and slots from config', () => {
         const config = makeConfig({
             framework: 'preact',
@@ -95,13 +106,8 @@ describe('mapProjectConfigToTemplateData', () => {
             { slot: 'EXTENSION_SLOT_MAIN_GAME_FUN', slotCamelCased: 'mainGameFun' },
         ]);
     });
-    it('does not include entryModulePath or slot', () => {
-        const result = mapProjectConfigToTemplateData(makeConfig());
-        expect(result.entryModulePath).toBeUndefined();
-        expect(result.slot).toBeUndefined();
-    });
-    it('sets extHelperVersion from package version', () => {
+    it('sets ext-helper dependency from resolved dependencies', () => {
         const result = mapProjectConfigToTemplateData(makeConfig());
-        expect(result.extHelperVersion).toBe(EXT_HELPER_VERSION);
+        expect(result.config.dependencies['@stripchatdev/ext-helper']).toBe(DEPENDENCIES['@stripchatdev/ext-helper']);
     });
 });

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

@@ -0,0 +1,2 @@
+import type { TTemplateCommand, TTemplateData } from '../types.js';
+export declare const planProject: (projectDir: string, targetVersion: number, data: TTemplateData) => TTemplateCommand[];

package/dist/src/templater/planner.js

@@ -0,0 +1,104 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { isSubPath } from '../helpers/isSubPath.js';
+import { GENERAL_SLOT_NAME_PLACEHOLDER, TEMPLATE_EXT, } from '../templates/constants.js';
+import { collectTemplateFiles, GENERAL_SLOT_TEMPLATE_DIR_REL, SLOTS_TEMPLATE_DIR_REL, TEMPLATES_DIR, } from '../templates/templates.js';
+import { getIsTypescriptOnlyFile } from './helpers/getIsTypescriptOnlyFile.js';
+import { resolveTemplateExtension } from './helpers/resolveTemplateExtension.js';
+const shouldSkipGlobalTemplate = (templatePath, data) => getIsTypescriptOnlyFile(templatePath) && !data.isTypescript;
+const shouldSkipSlotTemplate = (relPath, allRelPaths, isJsxFramework) => {
+    if (relPath.endsWith('.tsx.ejs')) {
+        const tsCounterpart = relPath.replace(/\.tsx\.ejs$/, '.ts.ejs');
+        if (allRelPaths.has(tsCounterpart) && !isJsxFramework) {
+            return true;
+        }
+    }
+    if (relPath.endsWith('.ts.ejs')) {
+        const tsxCounterpart = relPath.replace(/\.ts\.ejs$/, '.tsx.ejs');
+        if (allRelPaths.has(tsxCounterpart) && isJsxFramework) {
+            return true;
+        }
+    }
+    return false;
+};
+const planGlobalTemplates = (projectDir, targetVersion, data) => {
+    const files = collectTemplateFiles(TEMPLATES_DIR, targetVersion);
+    const commands = [];
+    for (const file of files) {
+        if (file.deleted) {
+            continue;
+        }
+        if (isSubPath('src/slots', file.relPath)) {
+            continue;
+        }
+        if (shouldSkipGlobalTemplate(file.srcPath, data)) {
+            continue;
+        }
+        const isEjs = file.srcPath.endsWith(TEMPLATE_EXT);
+        if (!isEjs) {
+            commands.push({
+                destPath: join(projectDir, file.relPath),
+                srcPath: file.srcPath,
+                type: 'copy',
+            });
+            continue;
+        }
+        commands.push({
+            data,
+            destPath: join(projectDir, resolveTemplateExtension(file.relPath, data.isTypescript)),
+            srcPath: file.srcPath,
+            type: 'render',
+        });
+    }
+    return commands;
+};
+const buildSlotTemplateData = (data, slotKey) => {
+    const isBackground = slotKey === 'background';
+    const entryExt = isBackground || !data.isJsxFramework ? data.ext : data.jsxExt;
+    return {
+        ...data,
+        entryModulePath: `/src/slots/${slotKey}/main.${entryExt}`,
+        slot: slotKey,
+        stylePath: `/src/slots/${slotKey}/main.css`,
+    };
+};
+const planSlotTemplates = (projectDir, targetVersion, data, slotKey) => {
+    const specificDir = join(SLOTS_TEMPLATE_DIR_REL, slotKey);
+    const hasSpecificDir = existsSync(specificDir);
+    const slotTemplatedDirRel = hasSpecificDir ? specificDir : GENERAL_SLOT_TEMPLATE_DIR_REL;
+    const slotData = buildSlotTemplateData(data, slotKey);
+    const files = collectTemplateFiles(TEMPLATES_DIR, targetVersion, slotTemplatedDirRel);
+    const allRelPaths = new Set(files.map((f) => f.relPath));
+    const commands = [];
+    for (const file of files) {
+        if (shouldSkipSlotTemplate(file.relPath, allRelPaths, data.isJsxFramework)) {
+            continue;
+        }
+        const outputRelPath = file.relPath.replace(GENERAL_SLOT_NAME_PLACEHOLDER, slotKey);
+        const resolvedPath = resolveTemplateExtension(outputRelPath, data.isTypescript);
+        const isHtml = resolvedPath.endsWith('.html');
+        const destPath = isHtml
+            ? join(projectDir, resolvedPath)
+            : join(projectDir, 'src', 'slots', slotKey, resolvedPath);
+        if (file.relPath.endsWith(TEMPLATE_EXT)) {
+            commands.push({
+                data: slotData,
+                destPath,
+                srcPath: file.srcPath,
+                type: 'render',
+            });
+            continue;
+        }
+        commands.push({
+            destPath,
+            srcPath: file.srcPath,
+            type: 'copy',
+        });
+    }
+    return commands;
+};
+export const planProject = (projectDir, targetVersion, data) => {
+    const globalCommands = planGlobalTemplates(projectDir, targetVersion, data);
+    const slotCommands = data.slotsEntries.flatMap(({ slotCamelCased }) => planSlotTemplates(projectDir, targetVersion, data, slotCamelCased));
+    return [...globalCommands, ...slotCommands];
+};

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

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