@stripchatdev/create-stripchat-extension 0.1.21 → 0.1.23

package/dist/bin/cli.js

@@ -3,7 +3,7 @@ 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 { CATEGORY_SLOTS, CATEGORIES, CATEGORY_LABELS, FRAMEWORK_LABELS, FRAMEWORKS, LANGUAGE_LABELS, LANGUAGES, REQUIRED_SLOTS_BY_CATEGORY, SELECTABLE_SLOTS_BY_CATEGORY, SLOT_LABELS, } from '../src/constants.js';
+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';
@@ -15,9 +15,9 @@ Usage: create-stripchat-extension [options]
 Create a new Stripchat extension project.
 
 Options:
-  --name <name>           Project name (used as directory and package name)
+  --name <name>           Project name (used as a directory and package name)
   --category <category>   Extension category (${CATEGORIES.join(', ')})
-  --slots <items>         Comma-separated slots (e.g. "mainGameFun,rightOverlay") or empty string
+  --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
@@ -77,54 +77,62 @@ const resolveCategory = (flagValue) => {
         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) => {
-    const { selectable, validations } = CATEGORY_SLOTS[category];
-    const exactOneOfValidation = validations?.find((validation) => validation.type === 'exactlyOneOf');
     if (flagValue !== undefined) {
         const requested = flagValue.split(',').map((s) => s.trim());
         if (flagValue === '') {
-            const { errors } = validateSlots([], category);
-            if (errors.length > 0) {
-                console.error(`Error: ${errors.join('. ')}`);
-                process.exit(1);
-            }
-            return Promise.resolve([]);
-        }
-        const { errors, invalid, valid } = validateSlots(requested, category);
-        if (invalid.length) {
-            if (selectable.length !== 0) {
-                console.error(`Error: invalid slot(s) "${invalid.join(', ')}". Choose from: ${selectable.join(', ')}`);
-            }
-            else {
-                console.error(`Error: invalid slot(s): "${invalid.join(', ')}". This category doesn't have optional slots.`);
-            }
-            process.exit(1);
-        }
-        if (errors.length) {
-            console.error(`Error: ${errors.join('. ')}`);
-            process.exit(1);
+            return {
+                errorMessage: getSlotsErrorMessage(category, []),
+                slots: [],
+            };
         }
-        return Promise.resolve(valid);
+        return {
+            errorMessage: getSlotsErrorMessage(category, requested),
+            slots: validateSlots(requested, category).selected,
+        };
     }
-    if (exactOneOfValidation && exactOneOfValidation.slots.length === selectable.length) {
-        const slot = await select({
-            choices: selectable.map((slot) => ({
+    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 one optional slot:',
+            message: 'Select optional slots:',
+            required: false,
+            validate: (value) => getSlotsErrorMessage(category, normalizePromptSlots(value)) ?? true,
         });
-        return [slot];
-    }
-    return checkbox({
-        choices: selectable.map((slot) => ({
-            checked: false,
-            name: SLOT_LABELS[slot],
-            value: slot,
-        })),
-        message: 'Select optional slots:',
-        required: false,
-    });
+    const selections = normalizePromptSlots(rawSelections);
+    const { selected } = validateSlots(selections, category);
+    return {
+        errorMessage: getSlotsErrorMessage(category, selections),
+        slots: selected,
+    };
 };
 const resolveFramework = (flagValue) => {
     if (flagValue) {
@@ -170,10 +178,15 @@ const main = async () => {
     }
     const name = await resolveName(opts.name);
     const category = await resolveCategory(opts.category);
-    const hasSelectableSlots = SELECTABLE_SLOTS_BY_CATEGORY[category].length > 0;
+    const hasSelectableSlots = SLOT_RULES_BY_CATEGORY[category].optional.length > 0;
     let selectedSlots = [];
     if (hasSelectableSlots) {
-        selectedSlots = await resolveSlots(opts.slots, category);
+        const resolvedSlots = await resolveSlots(opts.slots, category);
+        if (resolvedSlots.errorMessage) {
+            console.error(resolvedSlots.errorMessage);
+            process.exit(1);
+        }
+        selectedSlots = resolvedSlots.slots;
     }
     const framework = category === 'chat-bots' ? 'vanilla' : await resolveFramework(opts.framework);
     const language = await resolveLanguage(opts.language);

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stripchatdev/create-stripchat-extension",
-    "version": "0.1.21",
+    "version": "0.1.23",
     "type": "module",
     "files": [
         "dist",

package/dist/src/constants.d.ts

@@ -1,21 +1,11 @@
-import type { TCategory, TPackageManager, TSlot } from './types.js';
+import type { TCategory, TCategorySlotRules, TPackageManager, TSlot } from './types.js';
 export declare const EXT_HELPER_VERSION: string;
 export declare const CATEGORIES: TCategory[];
 export declare const CATEGORY_LABELS: Record<TCategory, string>;
-export type TSlotValidationRule = {
-    slots: TSlot[];
-    type: 'exactlyOneOf';
-};
-export type TCategorySlotsConfig = {
-    required: TSlot[];
-    selectable: TSlot[];
-    validations?: TSlotValidationRule[];
-};
-export declare const CATEGORY_SLOTS: Record<TCategory, TCategorySlotsConfig>;
+export declare const SLOT_RULES_BY_CATEGORY: Record<TCategory, TCategorySlotRules>;
 export declare const REQUIRED_SLOTS_BY_CATEGORY: Record<TCategory, TSlot[]>;
 export declare const SELECTABLE_SLOTS_BY_CATEGORY: Record<TCategory, TSlot[]>;
 export declare const SLOT_LABELS: Record<TSlot, string>;
-export declare const SLOT_TYPES: Record<TSlot, string>;
 export declare const FRAMEWORKS: readonly ["vanilla", "preact"];
 export declare const FRAMEWORK_LABELS: Record<(typeof FRAMEWORKS)[number], string>;
 export declare const LANGUAGES: readonly ["ts", "js"];

package/dist/src/constants.js

@@ -1,5 +1,5 @@
-import packageJson from '../package.json' with { type: 'json' };
 // All packages use the same versioning
+import packageJson from '../package.json' with { type: 'json' };
 export const EXT_HELPER_VERSION = packageJson.version;
 export const CATEGORIES = ['games-and-fun', 'sex-toys', 'chat-bots'];
 export const CATEGORY_LABELS = {
@@ -7,43 +7,46 @@ export const CATEGORY_LABELS = {
     'sex-toys': 'Sex Toys',
     'chat-bots': 'Chat Bots',
 };
-export const CATEGORY_SLOTS = {
+export const SLOT_RULES_BY_CATEGORY = {
     'games-and-fun': {
-        required: ['mainGameFun', 'background'],
-        selectable: ['rightOverlay', 'videoDecorativeOverlay'],
-        validations: [
+        groups: [
             {
-                slots: ['rightOverlay', 'videoDecorativeOverlay'],
-                type: 'exactlyOneOf',
+                kind: 'exactly-one',
+                slots: ['EXTENSION_SLOT_RIGHT_OVERLAY', 'EXTENSION_SLOT_VIDEO_DECORATIVE_OVERLAY'],
             },
         ],
+        optional: ['EXTENSION_SLOT_RIGHT_OVERLAY', 'EXTENSION_SLOT_VIDEO_DECORATIVE_OVERLAY'],
+        requiredBase: ['EXTENSION_SLOT_MAIN_GAME_FUN', 'EXTENSION_SLOT_BACKGROUND'],
     },
     'sex-toys': {
-        required: ['mainSexToy', 'background', 'moveableOverlay'],
-        selectable: ['rightOverlay', 'videoDecorativeOverlay'],
+        groups: [
+            {
+                kind: 'at-most-one',
+                slots: ['EXTENSION_SLOT_RIGHT_OVERLAY', 'EXTENSION_SLOT_VIDEO_DECORATIVE_OVERLAY'],
+            },
+        ],
+        optional: [
+            'EXTENSION_SLOT_MOVEABLE_OVERLAY',
+            'EXTENSION_SLOT_RIGHT_OVERLAY',
+            'EXTENSION_SLOT_VIDEO_DECORATIVE_OVERLAY',
+        ],
+        requiredBase: ['EXTENSION_SLOT_MAIN_SEX_TOY', 'EXTENSION_SLOT_BACKGROUND'],
     },
     'chat-bots': {
-        required: ['background'],
-        selectable: [],
+        groups: [],
+        optional: ['EXTENSION_SLOT_VIDEO_DECORATIVE_OVERLAY'],
+        requiredBase: ['EXTENSION_SLOT_BACKGROUND'],
     },
 };
-export const REQUIRED_SLOTS_BY_CATEGORY = Object.fromEntries(CATEGORIES.map((category) => [category, CATEGORY_SLOTS[category].required]));
-export const SELECTABLE_SLOTS_BY_CATEGORY = Object.fromEntries(CATEGORIES.map((category) => [category, CATEGORY_SLOTS[category].selectable]));
+export const REQUIRED_SLOTS_BY_CATEGORY = Object.fromEntries(Object.entries(SLOT_RULES_BY_CATEGORY).map(([category, rules]) => [category, rules.requiredBase]));
+export const SELECTABLE_SLOTS_BY_CATEGORY = Object.fromEntries(Object.entries(SLOT_RULES_BY_CATEGORY).map(([category, rules]) => [category, rules.optional]));
 export const SLOT_LABELS = {
-    background: 'background',
-    mainGameFun: 'mainGameFun',
-    mainSexToy: 'mainSexToy',
-    moveableOverlay: 'moveableOverlay',
-    rightOverlay: 'rightOverlay',
-    videoDecorativeOverlay: 'videoDecorativeOverlay',
-};
-export const SLOT_TYPES = {
-    background: 'EXTENSION_SLOT_BACKGROUND',
-    mainGameFun: 'EXTENSION_SLOT_MAIN_GAME_FUN',
-    mainSexToy: 'EXTENSION_SLOT_MAIN_SEX_TOY',
-    moveableOverlay: 'EXTENSION_SLOT_MOVEABLE_OVERLAY',
-    rightOverlay: 'EXTENSION_SLOT_RIGHT_OVERLAY',
-    videoDecorativeOverlay: 'EXTENSION_SLOT_VIDEO_DECORATIVE_OVERLAY',
+    EXTENSION_SLOT_BACKGROUND: 'background',
+    EXTENSION_SLOT_MAIN_GAME_FUN: 'mainGameFun',
+    EXTENSION_SLOT_MAIN_SEX_TOY: 'mainSexToy',
+    EXTENSION_SLOT_MOVEABLE_OVERLAY: 'moveableOverlay',
+    EXTENSION_SLOT_RIGHT_OVERLAY: 'rightOverlay',
+    EXTENSION_SLOT_VIDEO_DECORATIVE_OVERLAY: 'videoDecorativeOverlay',
 };
 export const FRAMEWORKS = ['vanilla', 'preact'];
 export const FRAMEWORK_LABELS = {

package/dist/src/executor.test.js

@@ -33,7 +33,7 @@ describe('executeCommands', () => {
             language: 'ts',
             name: 'my-ext',
             packageManager: 'npm',
-            slots: ['mainGameFun', 'background'],
+            slots: ['EXTENSION_SLOT_MAIN_GAME_FUN', 'EXTENSION_SLOT_BACKGROUND'],
         };
         const commands = await buildCommands(config, tmpDir);
         const cb = vi.fn();
@@ -63,7 +63,7 @@ describe('executeCommands', () => {
             language: 'js',
             name: 'my-ext',
             packageManager: 'npm',
-            slots: ['mainSexToy', 'background'],
+            slots: ['EXTENSION_SLOT_MAIN_SEX_TOY', 'EXTENSION_SLOT_BACKGROUND'],
         };
         const commands = await buildCommands(config, tmpDir);
         const corruptedIndex = commands.findIndex((c) => c.type === 'render');

package/dist/src/mappers/mapProjectConfigToTemplateModel.js

@@ -1,6 +1,6 @@
-import { EXT_HELPER_VERSION, JSX_FRAMEWORKS, PACKAGE_MANAGER_COMMANDS_MAP, SLOT_TYPES } from '../constants.js';
+import { EXT_HELPER_VERSION, JSX_FRAMEWORKS, PACKAGE_MANAGER_COMMANDS_MAP, SLOT_LABELS } from '../constants.js';
 const buildSlotResolverEntries = (config) => config.slots.map((slot) => ({
-    slotType: SLOT_TYPES[slot],
+    slotCamelCased: SLOT_LABELS[slot],
     slot,
 }));
 export const mapProjectConfigToTemplateData = (config) => {
@@ -20,7 +20,6 @@ export const mapProjectConfigToTemplateData = (config) => {
         name: config.name,
         packageManager: config.packageManager,
         packageManagerCommands: PACKAGE_MANAGER_COMMANDS_MAP[config.packageManager],
-        slotResolverEntries: buildSlotResolverEntries(config),
-        slots: config.slots,
+        slotsEntries: buildSlotResolverEntries(config),
     };
 };

package/dist/src/mappers/mapProjectConfigToTemplateModel.test.js

@@ -7,7 +7,7 @@ const makeConfig = (overrides = {}) => ({
     language: 'ts',
     name: 'test-ext',
     packageManager: 'npm',
-    slots: ['mainGameFun', 'background'],
+    slots: ['EXTENSION_SLOT_MAIN_GAME_FUN', 'EXTENSION_SLOT_BACKGROUND'],
     ...overrides,
 });
 describe('mapProjectConfigToTemplateData', () => {
@@ -32,32 +32,38 @@ describe('mapProjectConfigToTemplateData', () => {
         expect(result.isJsxFramework).toBe(false);
     });
     it('maps each slot to its SLOT_TYPE constant', () => {
-        const result = mapProjectConfigToTemplateData(makeConfig({ slots: ['mainGameFun', 'background', 'rightOverlay'] }));
-        expect(result.slotResolverEntries).toEqual([
-            { slot: 'mainGameFun', slotType: 'EXTENSION_SLOT_MAIN_GAME_FUN' },
-            { slot: 'background', slotType: 'EXTENSION_SLOT_BACKGROUND' },
-            { slot: 'rightOverlay', slotType: 'EXTENSION_SLOT_RIGHT_OVERLAY' },
+        const result = mapProjectConfigToTemplateData(makeConfig({
+            slots: [
+                'EXTENSION_SLOT_MAIN_GAME_FUN',
+                'EXTENSION_SLOT_BACKGROUND',
+                'EXTENSION_SLOT_VIDEO_DECORATIVE_OVERLAY',
+            ],
+        }));
+        expect(result.slotsEntries).toEqual([
+            { slot: 'EXTENSION_SLOT_MAIN_GAME_FUN', slotCamelCased: 'mainGameFun' },
+            { slot: 'EXTENSION_SLOT_BACKGROUND', slotCamelCased: 'background' },
+            { slot: 'EXTENSION_SLOT_VIDEO_DECORATIVE_OVERLAY', slotCamelCased: 'videoDecorativeOverlay' },
         ]);
     });
     it('maps sex-toys category slots correctly', () => {
         const result = mapProjectConfigToTemplateData(makeConfig({
             category: 'sex-toys',
-            slots: ['mainSexToy', 'background', 'moveableOverlay'],
+            slots: ['EXTENSION_SLOT_MAIN_SEX_TOY', 'EXTENSION_SLOT_BACKGROUND', 'EXTENSION_SLOT_MOVEABLE_OVERLAY'],
         }));
-        expect(result.slotResolverEntries).toEqual([
-            { slot: 'mainSexToy', slotType: 'EXTENSION_SLOT_MAIN_SEX_TOY' },
-            { slot: 'background', slotType: 'EXTENSION_SLOT_BACKGROUND' },
-            { slot: 'moveableOverlay', slotType: 'EXTENSION_SLOT_MOVEABLE_OVERLAY' },
+        expect(result.slotsEntries).toEqual([
+            { slot: 'EXTENSION_SLOT_MAIN_SEX_TOY', slotCamelCased: 'mainSexToy' },
+            { slot: 'EXTENSION_SLOT_BACKGROUND', slotCamelCased: 'background' },
+            { slot: 'EXTENSION_SLOT_MOVEABLE_OVERLAY', slotCamelCased: 'moveableOverlay' },
         ]);
     });
     it('preserves slot order from config', () => {
-        const result = mapProjectConfigToTemplateData(makeConfig({ slots: ['background', 'mainGameFun'] }));
-        expect(result.slotResolverEntries[0].slot).toBe('background');
-        expect(result.slotResolverEntries[1].slot).toBe('mainGameFun');
+        const result = mapProjectConfigToTemplateData(makeConfig({ slots: ['EXTENSION_SLOT_BACKGROUND', 'EXTENSION_SLOT_MAIN_GAME_FUN'] }));
+        expect(result.slotsEntries[0].slot).toBe('EXTENSION_SLOT_BACKGROUND');
+        expect(result.slotsEntries[1].slot).toBe('EXTENSION_SLOT_MAIN_GAME_FUN');
     });
     it('returns empty array when no slots provided', () => {
         const result = mapProjectConfigToTemplateData(makeConfig({ slots: [] }));
-        expect(result.slotResolverEntries).toEqual([]);
+        expect(result.slotsEntries).toEqual([]);
     });
     it('passes config reference unchanged', () => {
         const config = makeConfig();
@@ -69,13 +75,15 @@ describe('mapProjectConfigToTemplateData', () => {
             framework: 'preact',
             language: 'js',
             name: 'my-project',
-            slots: ['mainGameFun'],
+            slots: ['EXTENSION_SLOT_MAIN_GAME_FUN'],
         });
         const result = mapProjectConfigToTemplateData(config);
         expect(result.name).toBe('my-project');
         expect(result.framework).toBe('preact');
         expect(result.language).toBe('js');
-        expect(result.slots).toEqual(['mainGameFun']);
+        expect(result.slotsEntries).toEqual([
+            { slot: 'EXTENSION_SLOT_MAIN_GAME_FUN', slotCamelCased: 'mainGameFun' },
+        ]);
     });
     it('does not include entryModulePath or slot', () => {
         const result = mapProjectConfigToTemplateData(makeConfig());

package/dist/src/planner.js

@@ -121,6 +121,6 @@ const planSlotTemplates = async (projectDir, data, slotKey) => {
 };
 export const planProject = async (data, projectDir) => {
     const globalCommands = await planGlobalTemplates(projectDir, data);
-    const slotCommandArrays = await Promise.all(data.slots.map((slot) => planSlotTemplates(projectDir, data, slot)));
+    const slotCommandArrays = await Promise.all(data.slotsEntries.map(({ slotCamelCased }) => planSlotTemplates(projectDir, data, slotCamelCased)));
     return [...globalCommands, ...slotCommandArrays.flat()];
 };

package/dist/src/planner.test.js

@@ -1,23 +1,25 @@
 import { describe, expect, it } from 'vitest';
-import { CATEGORY_SLOTS, CATEGORIES, FRAMEWORKS, LANGUAGES, REQUIRED_SLOTS_BY_CATEGORY, SELECTABLE_SLOTS_BY_CATEGORY, } from './constants.js';
+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 SLOT_COMBOS_BY_CATEGORY = Object.fromEntries(CATEGORIES.map((category) => {
-    const required = REQUIRED_SLOTS_BY_CATEGORY[category];
-    const selectable = SELECTABLE_SLOTS_BY_CATEGORY[category];
-    const exactOneOfValidation = CATEGORY_SLOTS[category].validations?.find((validation) => validation.type === 'exactlyOneOf');
-    if (exactOneOfValidation) {
-        return [
-            category,
-            exactOneOfValidation.slots.map((slot) => [...required, slot]),
-        ];
+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']);
     }
-    return [
-        category,
-        [required, ...(selectable.length > 0 ? [[...required, ...selectable]] : [])],
-    ];
+    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,

package/dist/src/types.d.ts

@@ -1,7 +1,7 @@
 export type TCategory = 'games-and-fun' | 'sex-toys' | 'chat-bots';
 export type TFramework = 'vanilla' | 'preact';
 export type TLanguage = 'ts' | 'js';
-export type TSlot = 'mainGameFun' | 'mainSexToy' | 'rightOverlay' | 'moveableOverlay' | 'background' | 'videoDecorativeOverlay';
+export type TSlot = 'EXTENSION_SLOT_MAIN_GAME_FUN' | 'EXTENSION_SLOT_MAIN_SEX_TOY' | 'EXTENSION_SLOT_RIGHT_OVERLAY' | 'EXTENSION_SLOT_VIDEO_DECORATIVE_OVERLAY' | 'EXTENSION_SLOT_MOVEABLE_OVERLAY' | 'EXTENSION_SLOT_BACKGROUND';
 export type TPackageManager = 'npm' | 'yarn' | 'pnpm' | 'bun';
 export type TProjectConfig = {
     category: TCategory;
@@ -11,9 +11,10 @@ export type TProjectConfig = {
     packageManager: TPackageManager;
     slots: TSlot[];
 };
-export type TSlotResolverEntry = {
-    slot: string;
-    slotType: string;
+export type TSlotEntry = {
+    slot: TSlot;
+    /** The camel cased version of the slot (e.g. `mainGameFun`). It's used as html file names */
+    slotCamelCased: string;
 };
 export type TPackageManagerCommands = {
     build: string;
@@ -34,8 +35,7 @@ export type TTemplateData = {
     packageManager: TPackageManager;
     packageManagerCommands: TPackageManagerCommands;
     slot?: string;
-    slotResolverEntries: TSlotResolverEntry[];
-    slots: TSlot[];
+    slotsEntries: TSlotEntry[];
     stylePath?: string;
 };
 export type TTemplateCommand = {
@@ -48,3 +48,12 @@ export type TTemplateCommand = {
     srcPath: string;
     type: 'render';
 };
+export type TSlotGroupRule = {
+    kind: 'at-most-one' | 'exactly-one';
+    slots: TSlot[];
+};
+export type TCategorySlotRules = {
+    groups: TSlotGroupRule[];
+    optional: TSlot[];
+    requiredBase: TSlot[];
+};

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

@@ -1,7 +1,7 @@
 import type { TCategory, TSlot } from '../types.js';
 export type TValidateSlotsResult = {
-    errors: string[];
     invalid: string[];
-    valid: TSlot[];
+    selected: TSlot[];
+    violations: string[];
 };
 export declare const validateSlots: (slots: string[], category: TCategory) => TValidateSlotsResult;

package/dist/src/validators/validateSlots.js

@@ -1,27 +1,31 @@
-import { CATEGORY_SLOTS } from '../constants.js';
+import { SLOT_RULES_BY_CATEGORY } from '../constants.js';
+const formatGroupMessage = (kind, slots) => {
+    const prefix = kind === 'exactly-one' ? 'Choose exactly one of' : 'Choose at most one of';
+    return `${prefix}: ${slots.join(', ')}.`;
+};
 export const validateSlots = (slots, category) => {
-    const { selectable, validations } = CATEGORY_SLOTS[category];
-    const allowed = new Set(selectable);
-    const valid = [];
+    const rules = SLOT_RULES_BY_CATEGORY[category];
+    const allowed = new Set(rules.optional);
+    const selected = [];
     const invalid = [];
-    const errors = [];
-    const hasOptionalSlots = allowed.size > 0;
-    if (!hasOptionalSlots) {
-        return { errors, invalid: slots, valid };
-    }
     for (const slot of slots) {
         if (allowed.has(slot)) {
-            valid.push(slot);
+            selected.push(slot);
         }
         else {
             invalid.push(slot);
         }
     }
-    validations?.forEach((validation) => {
-        const selectedCount = validation.slots.filter((slot) => valid.includes(slot)).length;
-        if (validation.type === 'exactlyOneOf' && selectedCount !== 1) {
-            errors.push(`Select exactly one of: ${validation.slots.join(', ')}`);
+    const selectedSet = new Set(selected);
+    const violations = rules.groups.flatMap((group) => {
+        const count = group.slots.filter((slot) => selectedSet.has(slot)).length;
+        if (group.kind === 'exactly-one' && count !== 1) {
+            return [formatGroupMessage(group.kind, group.slots)];
+        }
+        if (group.kind === 'at-most-one' && count > 1) {
+            return [formatGroupMessage(group.kind, group.slots)];
         }
+        return [];
     });
-    return { errors, invalid, valid };
+    return { invalid, selected, violations };
 };