@stripchatdev/create-stripchat-extension 0.1.45 → 0.1.47

package/templates/v2/README.md.ejs

@@ -0,0 +1,31 @@
+# <%= name %>
+
+> **Note**
+>
+> This file can be safely modified to fit your project's needs.
+
+Stripchat extension built with <%= framework === 'preact' ? 'Preact' : 'Vanilla' %> + <%= isTypescript ? 'TypeScript' : 'JavaScript' %>
+
+## Start Here
+
+Read `AGENTS.md` first. It is the project contract for SDK usage, slot lifecycles, resolver rules, theming, and settings.
+
+## Documentation
+
+Learn more about building Stripchat extensions in the [official documentation](https://extensions.stripchat.com/docs/).
+
+## Usage
+
+```bash
+# Install dependencies
+<%= packageManagerCommands.install %>
+
+# Start development server
+<%= packageManagerCommands.dev %>
+
+# Build for production
+<%= packageManagerCommands.build %>
+
+# Update template
+<%= packageManagerCommands.templateUpdate %>
+```

package/templates/v2/package.json.ejs

@@ -0,0 +1,26 @@
+{
+  "name": "<%= name %>",
+  "version": "0.0.1",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "<%- isTypescript ? 'tsc && vite build' : 'vite build' %>",
+    "preview": "vite preview",
+<%_ const cliCommandsEntries = Object.entries(cliCommands); _%>
+<%_ cliCommandsEntries.forEach(([name, value], index) => { _%>
+    "<%= name %>": "<%= value %>"<%= index < cliCommandsEntries.length - 1 ? ',' : '' %>
+<%_ }) _%>
+  },
+  "dependencies": {
+<%_ const dependencyEntries = Object.entries(dependencies); _%>
+<%_ dependencyEntries.forEach(([name, version], index) => { _%>
+    "<%= name %>": "<%= version %>"<%= index < dependencyEntries.length - 1 ? ',' : '' %>
+<%_ }) _%>
+  },
+  "devDependencies": {
+<%_ const devDependencyEntries = Object.entries(devDependencies); _%>
+<%_ devDependencyEntries.forEach(([name, version], index) => { _%>
+    "<%= name %>": "<%= version %>"<%= index < devDependencyEntries.length - 1 ? ',' : '' %>
+<%_ }) _%>
+  }
+}

package/dist/bin/cli.js

@@ -1,221 +0,0 @@
-#!/usr/bin/env node
-import { checkbox, input, select } from '@inquirer/prompts';
-import { join } from 'node:path';
-import { parseArgs } from 'node:util';
-import packageJson from '../package.json' with { type: 'json' };
-import { CATEGORIES, CATEGORY_LABELS, FRAMEWORK_LABELS, FRAMEWORKS, LANGUAGE_LABELS, LANGUAGES, REQUIRED_SLOTS_BY_CATEGORY, SLOT_RULES_BY_CATEGORY, SLOT_LABELS, } from '../src/constants.js';
-import { executeCommands } from '../src/executor.js';
-import { detectPackageManager } from '../src/helpers/detectPackageManager.js';
-import { mapProjectConfigToTemplateData } from '../src/mappers/mapProjectConfigToTemplateModel.js';
-import { planProject } from '../src/planner.js';
-import { isValidCategory, isValidFramework, isValidLanguage, validateName, validateProjectDir, validateSlots, } from '../src/validators/index.js';
-const HELP = `
-Usage: create-stripchat-extension [options]
-
-Create a new Stripchat extension project.
-
-Options:
-  --name <name>           Project name (used as a directory and package name)
-  --category <category>   Extension category (${CATEGORIES.join(', ')})
-  --slots <items>         Comma-separated slots (e.g. "EXTENSION_SLOT_MAIN_GAME_FUN,EXTENSION_SLOT_RIGHT_OVERLAY") or empty string
-  --framework <framework> UI framework (${FRAMEWORKS.join(', ')})
-  --language <lang>       Language (${LANGUAGES.join(', ')})
-  -h, --help              Display this help message
-  -v, --version           Show version number
-`.trim();
-const PACKAGE_MANAGER = detectPackageManager();
-const parseCliArgs = () => {
-    try {
-        const { values } = parseArgs({
-            args: process.argv.slice(2),
-            options: {
-                category: { type: 'string' },
-                framework: { type: 'string' },
-                help: { short: 'h', type: 'boolean' },
-                language: { type: 'string' },
-                name: { type: 'string' },
-                slots: { type: 'string' },
-                version: { short: 'v', type: 'boolean' },
-            },
-            strict: true,
-        });
-        return values;
-    }
-    catch (err) {
-        console.error(`Error: ${err.message}\n`);
-        console.log(HELP);
-        process.exit(1);
-    }
-};
-const resolveName = (flagValue) => {
-    if (flagValue) {
-        const result = validateName(flagValue);
-        if (result !== true) {
-            console.error(`Error: ${result}`);
-            process.exit(1);
-        }
-        return Promise.resolve(flagValue.trim());
-    }
-    return input({
-        message: 'Project name:',
-        validate: validateName,
-    });
-};
-const resolveCategory = (flagValue) => {
-    if (flagValue) {
-        if (!isValidCategory(flagValue)) {
-            console.error(`Error: invalid category "${flagValue}". Choose one of: ${CATEGORIES.join(', ')}`);
-            process.exit(1);
-        }
-        return Promise.resolve(flagValue);
-    }
-    return select({
-        choices: CATEGORIES.map((cat) => ({
-            name: CATEGORY_LABELS[cat],
-            value: cat,
-        })),
-        message: 'Extension category:',
-    });
-};
-const getSlotsErrorMessage = (category, requestedSlots) => {
-    const rules = SLOT_RULES_BY_CATEGORY[category];
-    const { invalid, violations } = validateSlots(requestedSlots, category);
-    if (invalid.length > 0) {
-        if (rules.optional.length === 0) {
-            return `Error: invalid slot(s): "${invalid.join(', ')}". This category doesn't have optional slots.`;
-        }
-        return `Error: invalid slot(s) "${invalid.join(', ')}". Choose from: ${rules.optional.join(', ')}`;
-    }
-    if (violations.length > 0) {
-        return `Error: ${violations.join(' ')}`;
-    }
-    return undefined;
-};
-const normalizePromptSlots = (value) => value.flatMap((item) => {
-    if (typeof item === 'string') {
-        return [item];
-    }
-    if (typeof item === 'object' && item !== null && 'value' in item && typeof item.value === 'string') {
-        return [item.value];
-    }
-    return [];
-});
-const resolveSlots = async (flagValue, category) => {
-    if (flagValue !== undefined) {
-        const requested = flagValue.split(',').map((s) => s.trim());
-        if (flagValue === '') {
-            return {
-                errorMessage: getSlotsErrorMessage(category, []),
-                slots: [],
-            };
-        }
-        return {
-            errorMessage: getSlotsErrorMessage(category, requested),
-            slots: validateSlots(requested, category).selected,
-        };
-    }
-    const optionalSlots = SLOT_RULES_BY_CATEGORY[category].optional;
-    const rawSelections = optionalSlots.length === 0
-        ? []
-        : await checkbox({
-            choices: optionalSlots.map((slot) => ({
-                checked: false,
-                name: SLOT_LABELS[slot],
-                value: slot,
-            })),
-            message: 'Select optional slots:',
-            required: false,
-            validate: (value) => getSlotsErrorMessage(category, normalizePromptSlots(value)) ?? true,
-        });
-    const selections = normalizePromptSlots(rawSelections);
-    const { selected } = validateSlots(selections, category);
-    return {
-        errorMessage: getSlotsErrorMessage(category, selections),
-        slots: selected,
-    };
-};
-const resolveFramework = (flagValue) => {
-    if (flagValue) {
-        if (!isValidFramework(flagValue)) {
-            console.error(`Error: invalid framework "${flagValue}". Choose one of: ${FRAMEWORKS.join(', ')}`);
-            process.exit(1);
-        }
-        return Promise.resolve(flagValue);
-    }
-    return select({
-        choices: FRAMEWORKS.map((framework) => ({
-            name: FRAMEWORK_LABELS[framework],
-            value: framework,
-        })),
-        message: 'UI framework:',
-    });
-};
-const resolveLanguage = (flagValue) => {
-    if (flagValue) {
-        if (!isValidLanguage(flagValue)) {
-            console.error(`Error: invalid language "${flagValue}". Choose one of: ${LANGUAGES.join(', ')}`);
-            process.exit(1);
-        }
-        return Promise.resolve(flagValue);
-    }
-    return select({
-        choices: LANGUAGES.map((lang) => ({
-            name: LANGUAGE_LABELS[lang],
-            value: lang,
-        })),
-        message: 'Language:',
-    });
-};
-const main = async () => {
-    const opts = parseCliArgs();
-    if (opts.help) {
-        console.log(HELP);
-        process.exit(0);
-    }
-    if (opts.version) {
-        console.log(packageJson.version);
-        process.exit(0);
-    }
-    const name = await resolveName(opts.name);
-    const category = await resolveCategory(opts.category);
-    const hasSelectableSlots = SLOT_RULES_BY_CATEGORY[category].optional.length > 0;
-    let selectedSlots = [];
-    if (hasSelectableSlots) {
-        const resolvedSlots = await resolveSlots(opts.slots, category);
-        if (resolvedSlots.errorMessage) {
-            console.error(resolvedSlots.errorMessage);
-            process.exit(1);
-        }
-        selectedSlots = resolvedSlots.slots;
-    }
-    const isVanilla = category === 'chat-bots'
-        || (category === 'broadcast-tools' && !selectedSlots.includes('EXTENSION_SLOT_MOVEABLE_OVERLAY'));
-    const framework = isVanilla ? 'vanilla' : await resolveFramework(opts.framework);
-    const language = await resolveLanguage(opts.language);
-    const slots = [...selectedSlots, ...REQUIRED_SLOTS_BY_CATEGORY[category]];
-    const projectDir = join(process.cwd(), name);
-    validateProjectDir(projectDir, name);
-    console.log(`\nCreating project in ./${name}...\n`);
-    const data = mapProjectConfigToTemplateData({
-        category,
-        framework,
-        language,
-        name,
-        packageManager: PACKAGE_MANAGER,
-        slots,
-    });
-    const commands = await planProject(data, projectDir);
-    await executeCommands(commands, (command) => console.log(`  Created ${command.destPath}`));
-    console.log('\nDone! Next steps:\n');
-    console.log(`  cd ${name}`);
-    console.log(`  ${data.packageManagerCommands.install}`);
-    console.log(`  ${data.packageManagerCommands.dev}\n`);
-};
-main().catch((err) => {
-    if (err.name === 'ExitPromptError') {
-        console.log('\nAborted.');
-        process.exit(0);
-    }
-    console.error(err);
-    process.exit(1);
-});

package/dist/src/executor.d.ts

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

package/dist/src/executor.js

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

package/dist/src/helpers/detectPackageManager.d.ts

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

package/dist/src/helpers/isDirectory.d.ts

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

package/dist/src/helpers/isDirectory.js

@@ -1,9 +0,0 @@
-import { statSync } from 'node:fs';
-export const isDirectory = (pathValue) => {
-    try {
-        return statSync(pathValue).isDirectory();
-    }
-    catch {
-        return false;
-    }
-};

package/dist/src/helpers/isDirectory.test.js

@@ -1,22 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { isDirectory } from './isDirectory.js';
-vi.mock('node:fs', () => ({
-    statSync: (path) => {
-        if (path === '/exists/dir')
-            return { isDirectory: () => true };
-        if (path === '/exists/file')
-            return { isDirectory: () => false };
-        throw new Error('ENOENT');
-    },
-}));
-describe('isDirectory', () => {
-    it('returns true for an existing directory', () => {
-        expect(isDirectory('/exists/dir')).toBe(true);
-    });
-    it('returns false for an existing file', () => {
-        expect(isDirectory('/exists/file')).toBe(false);
-    });
-    it('returns false when path does not exist', () => {
-        expect(isDirectory('/does/not/exist')).toBe(false);
-    });
-});

package/dist/src/helpers/isTypescriptOnlyFile.d.ts

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

package/dist/src/helpers/isTypescriptOnlyFile.js

@@ -1,5 +0,0 @@
-import { TS_ONLY_FILES } from '../constants.js';
-export const isTypescriptOnlyFile = (normalizedRelPath) => {
-    const withoutEjs = normalizedRelPath.replace(/\.ejs$/, '');
-    return TS_ONLY_FILES.includes(withoutEjs);
-};

package/dist/src/helpers/isTypescriptOnlyFile.test.js

@@ -1,22 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { isTypescriptOnlyFile } from './isTypescriptOnlyFile.js';
-describe('isTypescriptOnlyFile', () => {
-    it('returns true for tsconfig.json', () => {
-        expect(isTypescriptOnlyFile('tsconfig.json')).toBe(true);
-    });
-    it('returns true for tsconfig.json.ejs (strips .ejs suffix)', () => {
-        expect(isTypescriptOnlyFile('tsconfig.json.ejs')).toBe(true);
-    });
-    it('returns false for package.json', () => {
-        expect(isTypescriptOnlyFile('package.json')).toBe(false);
-    });
-    it('returns false for package.json.ejs', () => {
-        expect(isTypescriptOnlyFile('package.json.ejs')).toBe(false);
-    });
-    it('returns false for vite.config.ts.ejs', () => {
-        expect(isTypescriptOnlyFile('vite.config.ts.ejs')).toBe(false);
-    });
-    it('returns false for an empty string', () => {
-        expect(isTypescriptOnlyFile('')).toBe(false);
-    });
-});

package/dist/src/helpers/normalizeRelPath.d.ts

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

package/dist/src/helpers/normalizeRelPath.js

@@ -1 +0,0 @@
-export const normalizeRelPath = (pathValue) => pathValue.replaceAll('\\', '/');

package/dist/src/helpers/normalizeRelPath.test.js

@@ -1,19 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { normalizeRelPath } from './normalizeRelPath.js';
-describe('normalizeRelPath', () => {
-    it('replaces backslashes with forward slashes', () => {
-        expect(normalizeRelPath('src\\slots\\main')).toBe('src/slots/main');
-    });
-    it('replaces multiple backslashes', () => {
-        expect(normalizeRelPath('a\\b\\c\\d')).toBe('a/b/c/d');
-    });
-    it('leaves forward slashes unchanged', () => {
-        expect(normalizeRelPath('src/slots/main')).toBe('src/slots/main');
-    });
-    it('handles mixed separators', () => {
-        expect(normalizeRelPath('src\\slots/main\\file.ts')).toBe('src/slots/main/file.ts');
-    });
-    it('returns empty string unchanged', () => {
-        expect(normalizeRelPath('')).toBe('');
-    });
-});

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

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

package/dist/src/helpers/resolveTemplateExtension.js

@@ -1,17 +0,0 @@
-const resolveOutputExtension = (templateExt, isTypescript) => {
-    const map = {
-        '.ts': isTypescript ? '.ts' : '.js',
-        '.tsx': isTypescript ? '.tsx' : '.jsx',
-    };
-    return map[templateExt] ?? templateExt;
-};
-export const resolveTemplateExtension = (normalizedRelPath, isTypescript) => {
-    const withoutEjs = normalizedRelPath.replace(/\.ejs$/, '');
-    const extMatch = withoutEjs.match(/\.(tsx?|jsx?)$/);
-    if (!extMatch) {
-        return withoutEjs;
-    }
-    const templateExt = extMatch[0];
-    const base = withoutEjs.slice(0, -templateExt.length);
-    return `${base}${resolveOutputExtension(templateExt, isTypescript)}`;
-};

package/dist/src/helpers/resolveTemplatesDir.d.ts

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

package/dist/src/helpers/resolveTemplatesDir.js

@@ -1,11 +0,0 @@
-import { resolve } from 'node:path';
-import { isDirectory } from './isDirectory.js';
-export const resolveTemplatesDir = (moduleDir) => {
-    const candidates = ['../templates', '../../templates'].map((candidate) => resolve(moduleDir, candidate));
-    for (const candidate of candidates) {
-        if (isDirectory(candidate)) {
-            return candidate;
-        }
-    }
-    throw new Error(`Could not find templates directory near ${moduleDir}. Tried: ${candidates.join(', ')}`);
-};

package/dist/src/helpers/resolveTemplatesDir.test.js

@@ -1,21 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { resolveTemplatesDir } from './resolveTemplatesDir.js';
-vi.mock('./isDirectory', () => ({
-    isDirectory: (path) => path.endsWith('/templates') && path.includes('good'),
-}));
-describe('resolveTemplatesDir', () => {
-    it('returns ../templates when it exists', () => {
-        const result = resolveTemplatesDir('/project/good/src');
-        expect(result).toMatch(/\/templates$/);
-    });
-    it('returns ../../templates when ../templates does not exist', () => {
-        const result = resolveTemplatesDir('/project/good/dist/src');
-        expect(result).toMatch(/\/templates$/);
-    });
-    it('throws when no templates directory is found', () => {
-        expect(() => resolveTemplatesDir('/project/bad/src')).toThrow(/Could not find templates directory/);
-    });
-    it('includes tried paths in error message', () => {
-        expect(() => resolveTemplatesDir('/project/bad/src')).toThrow(/Tried:/);
-    });
-});

package/dist/src/planner.d.ts

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

package/dist/src/planner.js

@@ -1,126 +0,0 @@
-import { existsSync } from 'node:fs';
-import { readdir } from 'node:fs/promises';
-import { dirname, join, relative } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { isTypescriptOnlyFile } from './helpers/isTypescriptOnlyFile.js';
-import { normalizeRelPath } from './helpers/normalizeRelPath.js';
-import { resolveTemplateExtension } from './helpers/resolveTemplateExtension.js';
-import { resolveTemplatesDir } from './helpers/resolveTemplatesDir.js';
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const TEMPLATES_DIR = resolveTemplatesDir(__dirname);
-const SLOTS_TEMPLATE_DIR = join(TEMPLATES_DIR, 'src', 'slots');
-const GENERIC_SLOT_DIR = join(SLOTS_TEMPLATE_DIR, 'slot');
-const shouldSkipGlobalTemplate = (normalizedRelPath, data) => isTypescriptOnlyFile(normalizedRelPath) && !data.isTypescript;
-const shouldSkipSlotTemplate = (normalizedRelPath, allPaths, isJsxFramework) => {
-    if (normalizedRelPath.endsWith('.tsx.ejs')) {
-        const tsCounterpart = normalizedRelPath.replace(/\.tsx\.ejs$/, '.ts.ejs');
-        if (allPaths.has(tsCounterpart) && !isJsxFramework) {
-            return true;
-        }
-    }
-    if (normalizedRelPath.endsWith('.ts.ejs')) {
-        const tsxCounterpart = normalizedRelPath.replace(/\.ts\.ejs$/, '.tsx.ejs');
-        if (allPaths.has(tsxCounterpart) && isJsxFramework) {
-            return true;
-        }
-    }
-    return false;
-};
-const listFiles = async (dir) => {
-    const entries = await readdir(dir, { recursive: true, withFileTypes: true });
-    return entries
-        .filter((entry) => entry.isFile())
-        .map((entry) => ({
-        relPath: normalizeRelPath(relative(dir, join(entry.parentPath, entry.name))),
-        srcPath: join(entry.parentPath, entry.name),
-    }))
-        .sort((a, b) => a.relPath.localeCompare(b.relPath));
-};
-const planGlobalTemplates = async (projectDir, data) => {
-    const files = await listFiles(TEMPLATES_DIR);
-    const commands = [];
-    for (const file of files) {
-        if (file.relPath.startsWith('src/slots/')) {
-            continue;
-        }
-        if (shouldSkipGlobalTemplate(file.relPath, data)) {
-            continue;
-        }
-        const isEjs = file.relPath.endsWith('.ejs');
-        if (!isEjs) {
-            commands.push({
-                destPath: join(projectDir, ...file.relPath.split('/')),
-                srcPath: file.srcPath,
-                type: 'copy',
-            });
-            continue;
-        }
-        commands.push({
-            data,
-            destPath: join(projectDir, ...resolveTemplateExtension(file.relPath, data.isTypescript).split('/')),
-            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 resolveSlotOutputPath = (templateRelPath, slotKey, templateDirName) => {
-    const parts = templateRelPath.split('/');
-    const fileName = parts.at(-1);
-    const dirPrefix = parts.slice(0, -1).join('/');
-    const renamedFile = fileName.startsWith(`${templateDirName}.`)
-        ? `${slotKey}${fileName.slice(templateDirName.length)}`
-        : fileName;
-    return dirPrefix ? `${dirPrefix}/${renamedFile}` : renamedFile;
-};
-const planSlotTemplates = async (projectDir, data, slotKey) => {
-    const specificDir = join(SLOTS_TEMPLATE_DIR, slotKey);
-    const hasSpecificDir = existsSync(specificDir);
-    const templateDir = hasSpecificDir ? specificDir : GENERIC_SLOT_DIR;
-    const templateDirName = hasSpecificDir ? slotKey : 'slot';
-    const slotData = buildSlotTemplateData(data, slotKey);
-    const files = await listFiles(templateDir);
-    const allPaths = new Set(files.map((f) => f.relPath));
-    const commands = [];
-    for (const file of files) {
-        if (shouldSkipSlotTemplate(file.relPath, allPaths, data.isJsxFramework)) {
-            continue;
-        }
-        const outputRelPath = resolveSlotOutputPath(file.relPath, slotKey, templateDirName);
-        const resolvedPath = resolveTemplateExtension(outputRelPath, data.isTypescript);
-        const isHtml = resolvedPath.endsWith('.html');
-        const destPath = isHtml
-            ? join(projectDir, resolvedPath)
-            : join(projectDir, 'src', 'slots', slotKey, ...resolvedPath.split('/'));
-        if (!file.relPath.endsWith('.ejs')) {
-            commands.push({
-                destPath,
-                srcPath: file.srcPath,
-                type: 'copy',
-            });
-            continue;
-        }
-        commands.push({
-            data: slotData,
-            destPath,
-            srcPath: file.srcPath,
-            type: 'render',
-        });
-    }
-    return commands;
-};
-export const planProject = async (data, projectDir) => {
-    const globalCommands = await planGlobalTemplates(projectDir, data);
-    const slotCommandArrays = await Promise.all(data.slotsEntries.map(({ slotCamelCased }) => planSlotTemplates(projectDir, data, slotCamelCased)));
-    return [...globalCommands, ...slotCommandArrays.flat()];
-};

package/dist/src/planner.test.js

@@ -1,58 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { CATEGORIES, FRAMEWORKS, LANGUAGES, SLOT_RULES_BY_CATEGORY, } from './constants.js';
-import { mapProjectConfigToTemplateData } from './mappers/mapProjectConfigToTemplateModel.js';
-import { planProject } from './planner.js';
-const PROJECT_DIR = '/output/my-ext';
-const buildLabel = (language, framework, category, slots) => `${language} + ${framework}, ${category} (${slots.join(', ')})`;
-const buildSlotCombos = (category) => {
-    const rules = SLOT_RULES_BY_CATEGORY[category];
-    const base = [...rules.requiredBase];
-    const combos = [base];
-    if (category === 'games-and-fun') {
-        combos.length = 0;
-        combos.push([...base, 'EXTENSION_SLOT_RIGHT_OVERLAY'], [...base, 'EXTENSION_SLOT_VIDEO_DECORATIVE_OVERLAY']);
-        return combos;
-    }
-    if (category === 'sex-toys') {
-        combos.push([...base, 'EXTENSION_SLOT_MOVEABLE_OVERLAY'], [...base, 'EXTENSION_SLOT_RIGHT_OVERLAY'], [...base, 'EXTENSION_SLOT_VIDEO_DECORATIVE_OVERLAY'], [...base, 'EXTENSION_SLOT_MOVEABLE_OVERLAY', 'EXTENSION_SLOT_RIGHT_OVERLAY'], [...base, 'EXTENSION_SLOT_MOVEABLE_OVERLAY', 'EXTENSION_SLOT_VIDEO_DECORATIVE_OVERLAY']);
-    }
-    if (category === 'broadcast-tools') {
-        combos.push([...base, 'EXTENSION_SLOT_MOVEABLE_OVERLAY']);
-    }
-    return combos;
-};
-const SLOT_COMBOS_BY_CATEGORY = Object.fromEntries(CATEGORIES.map((category) => {
-    return [category, buildSlotCombos(category)];
-}));
-const TEST_MATRIX = CATEGORIES.flatMap((category) => SLOT_COMBOS_BY_CATEGORY[category].flatMap((slots) => FRAMEWORKS.flatMap((framework) => LANGUAGES.map((language) => ({
-    category,
-    framework,
-    label: buildLabel(language, framework, category, slots),
-    language,
-    slots,
-})))));
-const normalizeCommands = (commands) => commands.map((cmd) => {
-    const srcRel = cmd.srcPath.replace(/^.*\/templates\//, 'templates/');
-    const destRel = cmd.destPath.replace(/^\/output\//, '');
-    if (cmd.type === 'copy') {
-        return { type: 'copy', src: srcRel, dest: destRel };
-    }
-    return { type: 'render', src: srcRel, dest: destRel };
-});
-describe('planProject', () => {
-    for (const { category, framework, label, language, slots } of TEST_MATRIX) {
-        it(label, async () => {
-            const config = {
-                category,
-                framework,
-                language,
-                name: 'my-ext',
-                packageManager: 'npm',
-                slots,
-            };
-            const data = mapProjectConfigToTemplateData(config);
-            const commands = await planProject(data, PROJECT_DIR);
-            expect(normalizeCommands(commands)).toMatchSnapshot();
-        });
-    }
-});

package/dist/src/validators/index.d.ts

@@ -1,6 +0,0 @@
-export { isValidCategory } from './isValidCategory.js';
-export { isValidFramework } from './isValidFramework.js';
-export { isValidLanguage } from './isValidLanguage.js';
-export { validateName } from './validateName.js';
-export { validateProjectDir } from './validateProjectDir.js';
-export { validateSlots } from './validateSlots.js';