@stripchatdev/create-stripchat-extension 0.1.46 → 0.1.48

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

@@ -0,0 +1,2 @@
+import type { TLanguage } from '../types.js';
+export declare const getIsValidLanguage: (value: string) => value is TLanguage;

package/dist/src/validators/getIsValidLanguage.js

@@ -0,0 +1,2 @@
+import { LANGUAGES } from '../constants.js';
+export const getIsValidLanguage = (value) => LANGUAGES.includes(value);

package/dist/src/validators/getIsValidLanguage.test.d.ts

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

package/dist/src/validators/{isValidLanguage.test.js → getIsValidLanguage.test.js}

@@ -1,10 +1,10 @@
 import { describe, expect, it } from 'vitest';
-import { isValidLanguage } from './isValidLanguage.js';
+import { getIsValidLanguage } from './getIsValidLanguage.js';
 describe('isValidLanguage', () => {
     it.each(['ts', 'js'])('returns true for valid language: %s', (lang) => {
-        expect(isValidLanguage(lang)).toBe(true);
+        expect(getIsValidLanguage(lang)).toBe(true);
     });
     it.each(['typescript', '', 'TS', 'javascript'])('returns false for invalid language: %s', (lang) => {
-        expect(isValidLanguage(lang)).toBe(false);
+        expect(getIsValidLanguage(lang)).toBe(false);
     });
 });

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

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

package/dist/src/validators/getIsValidPackageManager.js

@@ -0,0 +1,4 @@
+import { PACKAGE_MANAGERS } from '../constants.js';
+export const getIsValidPackageManager = (value) => {
+    return typeof value === 'string' && PACKAGE_MANAGERS.includes(value);
+};

package/dist/src/validators/getIsValidPackageManager.test.d.ts

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

package/dist/src/validators/getIsValidPackageManager.test.js

@@ -0,0 +1,11 @@
+import { describe, expect, it } from 'vitest';
+import { PACKAGE_MANAGERS } from '../constants.js';
+import { getIsValidPackageManager } from './getIsValidPackageManager.js';
+describe('isValidPackageManager', () => {
+    it.each(PACKAGE_MANAGERS)('return true if package manager is valid', (packageManager) => {
+        expect(getIsValidPackageManager(packageManager)).toBe(true);
+    });
+    it.each(['some-invalid-page-manager', ''])('return false if package manager is invalid', (packageManager) => {
+        expect(getIsValidPackageManager(packageManager)).toBe(false);
+    });
+});

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

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

package/dist/src/validators/getIsValidSlot.js

@@ -0,0 +1,4 @@
+import { SLOTS } from '../constants.js';
+export const getIsValidSlot = (value) => {
+    return typeof value === 'string' && SLOTS.includes(value);
+};

package/dist/src/validators/getIsValidSlot.test.d.ts

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

package/dist/src/validators/getIsValidSlot.test.js

@@ -0,0 +1,26 @@
+import { describe, expect, it } from 'vitest';
+import { getIsValidSlot } from './getIsValidSlot.js';
+describe('getIsValidSlot', () => {
+    it.each([
+        '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',
+    ])('returns true for valid slot: %s', (slot) => {
+        expect(getIsValidSlot(slot)).toBe(true);
+    });
+    it.each([
+        'mainGameFun',
+        'EXTENSION_SLOT_MAIN_GAMEFUN',
+        'EXTENSION_SLOT_MOVEABLE_OVERLAY ',
+        'extension_slot_background',
+        '',
+    ])('returns false for invalid slot string: %s', (slot) => {
+        expect(getIsValidSlot(slot)).toBe(false);
+    });
+    it.each([null, undefined, 1, true, {}, []])('returns false for non-string slot value: %o', (slot) => {
+        expect(getIsValidSlot(slot)).toBe(false);
+    });
+});

package/dist/src/validators/validateSlots.js

@@ -1,24 +1,43 @@
 import { SLOT_RULES_BY_CATEGORY } from '../constants.js';
+import { getIsValidSlot } from './getIsValidSlot.js';
 const formatGroupMessage = (kind, slots) => {
-    const prefix = kind === 'exactly-one' ? 'Choose exactly one of' : 'Choose at most one of';
+    let prefix = '';
+    switch (kind) {
+        case 'exactly-one':
+            prefix = 'Choose exactly one of';
+            break;
+        case 'at-most-one':
+            prefix = 'Choose at most one of';
+            break;
+        case 'required':
+            prefix = 'Missing required slots';
+            break;
+    }
     return `${prefix}: ${slots.join(', ')}.`;
 };
 export const validateSlots = (slots, category) => {
     const rules = SLOT_RULES_BY_CATEGORY[category];
     const allowed = new Set(rules.optional);
-    const selected = [];
-    const invalid = [];
+    const requiredBase = new Set(rules.requiredBase);
+    const selected = new Set();
+    const invalid = new Set();
     for (const slot of slots) {
+        if (!getIsValidSlot(slot)) {
+            invalid.add(slot);
+            continue;
+        }
         if (allowed.has(slot)) {
-            selected.push(slot);
+            selected.add(slot);
+        }
+        else if (requiredBase.has(slot)) {
+            selected.add(slot);
         }
         else {
-            invalid.push(slot);
+            invalid.add(slot);
         }
     }
-    const selectedSet = new Set(selected);
     const violations = rules.groups.flatMap((group) => {
-        const count = group.slots.filter((slot) => selectedSet.has(slot)).length;
+        const count = group.slots.filter((slot) => selected.has(slot)).length;
         if (group.kind === 'exactly-one' && count !== 1) {
             return [formatGroupMessage(group.kind, group.slots)];
         }
@@ -27,5 +46,18 @@ export const validateSlots = (slots, category) => {
         }
         return [];
     });
-    return { invalid, selected, violations };
+    const missingRequiredSlots = [];
+    requiredBase.forEach((requiredSlot) => {
+        if (!selected.has(requiredSlot)) {
+            missingRequiredSlots.push(requiredSlot);
+        }
+    });
+    if (missingRequiredSlots.length) {
+        violations.unshift(formatGroupMessage('required', missingRequiredSlots));
+    }
+    return {
+        invalid: Array.from(invalid),
+        selected: Array.from(selected),
+        violations,
+    };
 };

package/dist/src/validators/validateSlots.test.js

@@ -1,15 +1,24 @@
 import { describe, expect, it } from 'vitest';
+import { SLOT_RULES_BY_CATEGORY } from '../constants.js';
 import { validateSlots } from './validateSlots.js';
 describe('validateSlots', () => {
     it('accepts right overlay for games-and-fun', () => {
-        const result = validateSlots(['EXTENSION_SLOT_RIGHT_OVERLAY'], 'games-and-fun');
-        expect(result.selected).toEqual(['EXTENSION_SLOT_RIGHT_OVERLAY']);
+        const slots = [
+            ...SLOT_RULES_BY_CATEGORY['games-and-fun'].requiredBase,
+            'EXTENSION_SLOT_RIGHT_OVERLAY',
+        ];
+        const result = validateSlots(slots, 'games-and-fun');
+        expect(result.selected).toEqual(slots);
         expect(result.invalid).toEqual([]);
         expect(result.violations).toEqual([]);
     });
     it('accepts video decorative overlay for games-and-fun', () => {
-        const result = validateSlots(['EXTENSION_SLOT_VIDEO_DECORATIVE_OVERLAY'], 'games-and-fun');
-        expect(result.selected).toEqual(['EXTENSION_SLOT_VIDEO_DECORATIVE_OVERLAY']);
+        const slots = [
+            ...SLOT_RULES_BY_CATEGORY['games-and-fun'].requiredBase,
+            'EXTENSION_SLOT_VIDEO_DECORATIVE_OVERLAY',
+        ];
+        const result = validateSlots(slots, 'games-and-fun');
+        expect(result.selected).toEqual(slots);
         expect(result.invalid).toEqual([]);
         expect(result.violations).toEqual([]);
     });
@@ -18,48 +27,93 @@ describe('validateSlots', () => {
         expect(result.selected).toEqual([]);
         expect(result.invalid).toEqual([]);
         expect(result.violations).toEqual([
+            'Missing required slots: EXTENSION_SLOT_MAIN_GAME_FUN, EXTENSION_SLOT_BACKGROUND.',
+            'Choose exactly one of: EXTENSION_SLOT_RIGHT_OVERLAY, EXTENSION_SLOT_VIDEO_DECORATIVE_OVERLAY.',
+        ]);
+    });
+    it('report about missing required base slots for game-and-fun', () => {
+        const result = validateSlots(['EXTENSION_SLOT_VIDEO_DECORATIVE_OVERLAY'], 'games-and-fun');
+        expect(result.selected).toEqual(['EXTENSION_SLOT_VIDEO_DECORATIVE_OVERLAY']);
+        expect(result.invalid).toEqual([]);
+        expect(result.violations).toEqual([
+            'Missing required slots: EXTENSION_SLOT_MAIN_GAME_FUN, EXTENSION_SLOT_BACKGROUND.',
+        ]);
+    });
+    it('report about missing required base and selectable slots for game-and-fun', () => {
+        const result = validateSlots([], 'games-and-fun');
+        expect(result.selected).toEqual([]);
+        expect(result.invalid).toEqual([]);
+        expect(result.violations).toEqual([
+            'Missing required slots: EXTENSION_SLOT_MAIN_GAME_FUN, EXTENSION_SLOT_BACKGROUND.',
             'Choose exactly one of: EXTENSION_SLOT_RIGHT_OVERLAY, EXTENSION_SLOT_VIDEO_DECORATIVE_OVERLAY.',
         ]);
     });
     it('rejects both shared activity overlays for games-and-fun', () => {
-        const result = validateSlots(['EXTENSION_SLOT_RIGHT_OVERLAY', 'EXTENSION_SLOT_VIDEO_DECORATIVE_OVERLAY'], 'games-and-fun');
-        expect(result.selected).toEqual([
+        const slots = [
+            ...SLOT_RULES_BY_CATEGORY['games-and-fun'].requiredBase,
             'EXTENSION_SLOT_RIGHT_OVERLAY',
             'EXTENSION_SLOT_VIDEO_DECORATIVE_OVERLAY',
-        ]);
+        ];
+        const result = validateSlots(slots, 'games-and-fun');
+        expect(result.selected).toEqual(slots);
         expect(result.invalid).toEqual([]);
         expect(result.violations).toEqual([
             'Choose exactly one of: EXTENSION_SLOT_RIGHT_OVERLAY, EXTENSION_SLOT_VIDEO_DECORATIVE_OVERLAY.',
         ]);
     });
     it('allows sex-toys with no optional slots', () => {
-        const result = validateSlots([], 'sex-toys');
-        expect(result.selected).toEqual([]);
+        const slots = [
+            ...SLOT_RULES_BY_CATEGORY['sex-toys'].requiredBase,
+        ];
+        const result = validateSlots(slots, 'sex-toys');
+        expect(result.selected).toEqual(slots);
         expect(result.invalid).toEqual([]);
         expect(result.violations).toEqual([]);
     });
     it('allows moveable overlay for sex-toys', () => {
-        const result = validateSlots(['EXTENSION_SLOT_MOVEABLE_OVERLAY'], 'sex-toys');
-        expect(result.selected).toEqual(['EXTENSION_SLOT_MOVEABLE_OVERLAY']);
+        const result = validateSlots([...SLOT_RULES_BY_CATEGORY['sex-toys'].requiredBase, 'EXTENSION_SLOT_MOVEABLE_OVERLAY'], 'sex-toys');
+        expect(result.selected).toEqual([
+            ...SLOT_RULES_BY_CATEGORY['sex-toys'].requiredBase,
+            'EXTENSION_SLOT_MOVEABLE_OVERLAY',
+        ]);
         expect(result.invalid).toEqual([]);
         expect(result.violations).toEqual([]);
     });
     it('allows one shared activity overlay for sex-toys', () => {
-        const result = validateSlots(['EXTENSION_SLOT_VIDEO_DECORATIVE_OVERLAY'], 'sex-toys');
-        expect(result.selected).toEqual(['EXTENSION_SLOT_VIDEO_DECORATIVE_OVERLAY']);
+        const slots = [
+            ...SLOT_RULES_BY_CATEGORY['sex-toys'].requiredBase,
+            'EXTENSION_SLOT_VIDEO_DECORATIVE_OVERLAY',
+        ];
+        const result = validateSlots(slots, 'sex-toys');
+        expect(result.selected).toEqual(slots);
         expect(result.invalid).toEqual([]);
         expect(result.violations).toEqual([]);
     });
     it('allows one shared activity overlay plus moveable overlay for sex-toys', () => {
-        const result = validateSlots(['EXTENSION_SLOT_MOVEABLE_OVERLAY', 'EXTENSION_SLOT_RIGHT_OVERLAY'], 'sex-toys');
-        expect(result.selected).toEqual([
+        const slots = [
+            ...SLOT_RULES_BY_CATEGORY['sex-toys'].requiredBase,
             'EXTENSION_SLOT_MOVEABLE_OVERLAY',
             'EXTENSION_SLOT_RIGHT_OVERLAY',
-        ]);
+        ];
+        const result = validateSlots(slots, 'sex-toys');
+        expect(result.selected).toEqual(slots);
         expect(result.invalid).toEqual([]);
         expect(result.violations).toEqual([]);
     });
     it('rejects both shared activity overlays for sex-toys', () => {
+        const slots = [
+            ...SLOT_RULES_BY_CATEGORY['sex-toys'].requiredBase,
+            'EXTENSION_SLOT_RIGHT_OVERLAY',
+            'EXTENSION_SLOT_VIDEO_DECORATIVE_OVERLAY',
+        ];
+        const result = validateSlots(slots, 'sex-toys');
+        expect(result.selected).toEqual(slots);
+        expect(result.invalid).toEqual([]);
+        expect(result.violations).toEqual([
+            'Choose at most one of: EXTENSION_SLOT_RIGHT_OVERLAY, EXTENSION_SLOT_VIDEO_DECORATIVE_OVERLAY.',
+        ]);
+    });
+    it('reports missing required base slots together with overlay-group violation for sex-toys', () => {
         const result = validateSlots(['EXTENSION_SLOT_RIGHT_OVERLAY', 'EXTENSION_SLOT_VIDEO_DECORATIVE_OVERLAY'], 'sex-toys');
         expect(result.selected).toEqual([
             'EXTENSION_SLOT_RIGHT_OVERLAY',
@@ -67,63 +121,100 @@ describe('validateSlots', () => {
         ]);
         expect(result.invalid).toEqual([]);
         expect(result.violations).toEqual([
+            'Missing required slots: EXTENSION_SLOT_MAIN_SEX_TOY, EXTENSION_SLOT_BACKGROUND.',
             'Choose at most one of: EXTENSION_SLOT_RIGHT_OVERLAY, EXTENSION_SLOT_VIDEO_DECORATIVE_OVERLAY.',
         ]);
     });
     it('reports invalid slot names separately from rule violations', () => {
-        const result = validateSlots(['EXTENSION_SLOT_RIGHT_OVERLAY', 'unknown-slot'], 'games-and-fun');
-        expect(result.selected).toEqual(['EXTENSION_SLOT_RIGHT_OVERLAY']);
+        const result = validateSlots([
+            ...SLOT_RULES_BY_CATEGORY['games-and-fun'].requiredBase,
+            'EXTENSION_SLOT_RIGHT_OVERLAY',
+            'unknown-slot',
+        ], 'games-and-fun');
+        expect(result.selected).toEqual([
+            ...SLOT_RULES_BY_CATEGORY['games-and-fun'].requiredBase,
+            'EXTENSION_SLOT_RIGHT_OVERLAY',
+        ]);
         expect(result.invalid).toEqual(['unknown-slot']);
         expect(result.violations).toEqual([]);
     });
     it('rejects all optional slots for chat-bots', () => {
-        const result = validateSlots(['EXTENSION_SLOT_RIGHT_OVERLAY'], 'chat-bots');
-        expect(result.selected).toEqual([]);
+        const result = validateSlots([...SLOT_RULES_BY_CATEGORY['chat-bots'].requiredBase, 'EXTENSION_SLOT_RIGHT_OVERLAY'], 'chat-bots');
+        expect(result.selected).toEqual(SLOT_RULES_BY_CATEGORY['chat-bots'].requiredBase);
         expect(result.invalid).toEqual(['EXTENSION_SLOT_RIGHT_OVERLAY']);
         expect(result.violations).toEqual([]);
     });
-    it('returns empty result for empty input on category with no selectable slots', () => {
+    it('reports missing required slots for empty input on category with no selectable slots', () => {
         const result = validateSlots([], 'chat-bots');
         expect(result.selected).toEqual([]);
         expect(result.invalid).toEqual([]);
-        expect(result.violations).toEqual([]);
+        expect(result.violations).toEqual([
+            'Missing required slots: EXTENSION_SLOT_BACKGROUND.',
+        ]);
     });
     it('allows broadcast-tools with no optional slots', () => {
-        const result = validateSlots([], 'broadcast-tools');
-        expect(result.selected).toEqual([]);
+        const slots = [
+            ...SLOT_RULES_BY_CATEGORY['broadcast-tools'].requiredBase,
+        ];
+        const result = validateSlots(slots, 'broadcast-tools');
+        expect(result.selected).toEqual(slots);
         expect(result.invalid).toEqual([]);
         expect(result.violations).toEqual([]);
     });
     it('allows moveable overlay for broadcast-tools', () => {
-        const result = validateSlots(['EXTENSION_SLOT_MOVEABLE_OVERLAY'], 'broadcast-tools');
-        expect(result.selected).toEqual(['EXTENSION_SLOT_MOVEABLE_OVERLAY']);
+        const slots = [
+            ...SLOT_RULES_BY_CATEGORY['broadcast-tools'].requiredBase,
+            'EXTENSION_SLOT_MOVEABLE_OVERLAY',
+        ];
+        const result = validateSlots(slots, 'broadcast-tools');
+        expect(result.selected).toEqual(slots);
         expect(result.invalid).toEqual([]);
         expect(result.violations).toEqual([]);
     });
     it('rejects unsupported optional slots for broadcast-tools', () => {
-        const result = validateSlots(['EXTENSION_SLOT_RIGHT_OVERLAY'], 'broadcast-tools');
-        expect(result.selected).toEqual([]);
+        const slots = [
+            'EXTENSION_SLOT_BACKGROUND',
+            'EXTENSION_SLOT_RIGHT_OVERLAY',
+        ];
+        const result = validateSlots(slots, 'broadcast-tools');
+        expect(result.selected).toEqual(['EXTENSION_SLOT_BACKGROUND']);
         expect(result.invalid).toEqual(['EXTENSION_SLOT_RIGHT_OVERLAY']);
         expect(result.violations).toEqual([]);
     });
     it('filters invalid slot names while preserving valid selections', () => {
-        const result = validateSlots(['EXTENSION_SLOT_RIGHT_OVERLAY', 'nonExistent', 'alsoWrong'], 'sex-toys');
-        expect(result.selected).toEqual(['EXTENSION_SLOT_RIGHT_OVERLAY']);
+        const result = validateSlots([
+            ...SLOT_RULES_BY_CATEGORY['sex-toys'].requiredBase,
+            'EXTENSION_SLOT_RIGHT_OVERLAY',
+            'nonExistent',
+            'alsoWrong',
+        ], 'sex-toys');
+        expect(result.selected).toEqual([
+            ...SLOT_RULES_BY_CATEGORY['sex-toys'].requiredBase,
+            'EXTENSION_SLOT_RIGHT_OVERLAY',
+        ]);
         expect(result.invalid).toEqual(['nonExistent', 'alsoWrong']);
         expect(result.violations).toEqual([]);
     });
     it('rejects alias-like slot names that are not slot constants', () => {
-        const result = validateSlots(['moveableOverlay'], 'games-and-fun');
-        expect(result.selected).toEqual([]);
+        const result = validateSlots([...SLOT_RULES_BY_CATEGORY['games-and-fun'].requiredBase, 'moveableOverlay'], 'games-and-fun');
+        expect(result.selected).toEqual(SLOT_RULES_BY_CATEGORY['games-and-fun'].requiredBase);
         expect(result.invalid).toEqual(['moveableOverlay']);
         expect(result.violations).toEqual([
             'Choose exactly one of: EXTENSION_SLOT_RIGHT_OVERLAY, EXTENSION_SLOT_VIDEO_DECORATIVE_OVERLAY.',
         ]);
     });
     it('handles all invalid slots', () => {
-        const result = validateSlots(['unknown1', 'unknown2'], 'sex-toys');
-        expect(result.selected).toEqual([]);
+        const result = validateSlots([...SLOT_RULES_BY_CATEGORY['sex-toys'].requiredBase, 'unknown1', 'unknown2'], 'sex-toys');
+        expect(result.selected).toEqual(SLOT_RULES_BY_CATEGORY['sex-toys'].requiredBase);
         expect(result.invalid).toEqual(['unknown1', 'unknown2']);
         expect(result.violations).toEqual([]);
     });
+    it('report about missing required slots for game-and-fun', () => {
+        const result = validateSlots(['EXTENSION_SLOT_VIDEO_DECORATIVE_OVERLAY'], 'games-and-fun');
+        expect(result.selected).toEqual(['EXTENSION_SLOT_VIDEO_DECORATIVE_OVERLAY']);
+        expect(result.invalid).toEqual([]);
+        expect(result.violations).toEqual([
+            'Missing required slots: EXTENSION_SLOT_MAIN_GAME_FUN, EXTENSION_SLOT_BACKGROUND.',
+        ]);
+    });
 });