@stripchatdev/create-stripchat-extension 0.1.46 → 0.1.47

package/dist/src/templates/templates.test.js

@@ -0,0 +1,263 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { describe, expect, it } from 'vitest';
+import { toNormalizedRelPath } from '../helpers/normalizePath.js';
+import { discoverVersionDirs, collectManagedFiles, collectTemplateFiles } from './templates.js';
+const getVersionsFromDirs = (dirs) => dirs.map(({ version }) => version);
+const sortManagedFiles = (files) => [...files].sort((a, b) => a.relPath.localeCompare(b.relPath));
+const normalizeCollectedManagedFiles = (files) => sortManagedFiles(files).map((file) => ({
+    ...file,
+    deleted: file.deleted === true,
+    relPath: toNormalizedRelPath(file.relPath),
+}));
+const normalizeExpectedManagedFiles = (files) => sortManagedFiles(files).map((file) => ({
+    ...file,
+    deleted: file.deleted === true,
+}));
+const sortTemplateFiles = (files) => [...files].sort((a, b) => a.relPath.localeCompare(b.relPath));
+const normalizeCollectedTemplateFiles = (files) => sortTemplateFiles(files).map((file) => ({
+    ...file,
+    deleted: file.deleted === true,
+    relPath: toNormalizedRelPath(file.relPath),
+}));
+const normalizeExpectedTemplateFiles = (files) => sortTemplateFiles(files).map((file) => ({
+    ...file,
+    deleted: file.deleted === true,
+}));
+describe('discoverVersionDirs', () => {
+    it('discover only version dirs in correct order', () => {
+        const templatesDir = mkdtempSync(join(tmpdir(), 'sce-template-versions-'));
+        try {
+            mkdirSync(join(templatesDir, 'v2'));
+            mkdirSync(join(templatesDir, 'v10'));
+            mkdirSync(join(templatesDir, 'v1'));
+            mkdirSync(join(templatesDir, 'draft'));
+            writeFileSync(join(templatesDir, 'v3.txt'), 'not a directory');
+            const ascResult = discoverVersionDirs(templatesDir, 10, 'asc');
+            const descResult = discoverVersionDirs(templatesDir, 10, 'desc');
+            const limitedResult = discoverVersionDirs(templatesDir, 2, 'asc');
+            expect(getVersionsFromDirs(ascResult)).toEqual([1, 2, 10]);
+            expect(getVersionsFromDirs(descResult)).toEqual([10, 2, 1]);
+            expect(getVersionsFromDirs(limitedResult)).toEqual([1, 2]);
+            expect(ascResult.every(({ dirPath }) => dirPath.startsWith(templatesDir))).toBe(true);
+        }
+        finally {
+            rmSync(templatesDir, { recursive: true, force: true });
+        }
+    });
+});
+describe('collectManagedFiles', () => {
+    it('selects files from highest available version up to targetVersion', () => {
+        const templatesDir = mkdtempSync(join(tmpdir(), 'sce-collectManagedFiles-'));
+        try {
+            // v1: package.json, AGENTS.md, .project-config.json
+            mkdirSync(join(templatesDir, 'v1'));
+            writeFileSync(join(templatesDir, 'v1', 'package.json.ejs'), '{}');
+            writeFileSync(join(templatesDir, 'v1', 'AGENTS.md.ejs'), 'agents v1');
+            writeFileSync(join(templatesDir, 'v1', '.project-config.json.ejs'), '{}');
+            writeFileSync(join(templatesDir, 'v1', 'README.md'), 'readme v1');
+            mkdirSync(join(templatesDir, 'v2'));
+            writeFileSync(join(templatesDir, 'v2', 'vite.config.ts.ejs'), 'export default {}');
+            writeFileSync(join(templatesDir, 'v2', 'README.md.deleted'), '');
+            // v3: higher version of vite.config.ts (should be picked over v2 if targetVersion >= 3)
+            mkdirSync(join(templatesDir, 'v3'));
+            writeFileSync(join(templatesDir, 'v3', 'vite.config.ts.ejs'), 'export default { minify: false }');
+            const managedTemplates = [
+                'package.json.ejs',
+                'AGENTS.md.ejs',
+                '.project-config.json.ejs',
+                'vite.config.ts.ejs',
+                'README.md',
+            ];
+            const expectedV1 = [
+                {
+                    relPath: 'package.json',
+                    version: 1,
+                },
+                {
+                    relPath: 'AGENTS.md',
+                    version: 1,
+                },
+                {
+                    relPath: '.project-config.json',
+                    version: 1,
+                },
+                {
+                    relPath: 'README.md',
+                    version: 1,
+                },
+            ];
+            const resultV1 = collectManagedFiles(templatesDir, managedTemplates, 1);
+            expect(normalizeCollectedManagedFiles(resultV1)).toEqual(normalizeExpectedManagedFiles(expectedV1));
+            const expectedV2 = [
+                {
+                    relPath: 'package.json',
+                    version: 1,
+                },
+                {
+                    relPath: 'AGENTS.md',
+                    version: 1,
+                },
+                {
+                    relPath: '.project-config.json',
+                    version: 1,
+                },
+                {
+                    relPath: 'vite.config.ts',
+                    version: 2,
+                },
+                {
+                    relPath: 'README.md',
+                    version: 2,
+                    deleted: true,
+                },
+            ];
+            const resultV2 = collectManagedFiles(templatesDir, managedTemplates, 2);
+            expect(normalizeCollectedManagedFiles(resultV2)).toEqual(normalizeExpectedManagedFiles(expectedV2));
+            const expectedV3 = [
+                {
+                    relPath: 'package.json',
+                    version: 1,
+                },
+                {
+                    relPath: 'AGENTS.md',
+                    version: 1,
+                },
+                {
+                    relPath: '.project-config.json',
+                    version: 1,
+                },
+                {
+                    relPath: 'vite.config.ts',
+                    version: 3,
+                },
+                {
+                    relPath: 'README.md',
+                    version: 2,
+                    deleted: true,
+                },
+            ];
+            const resultV3 = collectManagedFiles(templatesDir, managedTemplates, 3);
+            expect(normalizeCollectedManagedFiles(resultV3)).toEqual(normalizeExpectedManagedFiles(expectedV3));
+        }
+        finally {
+            rmSync(templatesDir, { recursive: true, force: true });
+        }
+    });
+});
+describe('collectTemplateFiles', () => {
+    it('selects files from highest available version up to targetVersion and skips deleted', () => {
+        const templatesDir = mkdtempSync(join(tmpdir(), 'sce-collectTemplateFiles-'));
+        try {
+            mkdirSync(join(templatesDir, 'v1'));
+            writeFileSync(join(templatesDir, 'v1', 'package.json.ejs'), '{}');
+            writeFileSync(join(templatesDir, 'v1', 'AGENTS.md.ejs'), 'agents v1');
+            writeFileSync(join(templatesDir, 'v1', '.project-config.json.ejs'), '{}');
+            writeFileSync(join(templatesDir, 'v1', 'README.md.ejs'), 'readme v1');
+            mkdirSync(join(templatesDir, 'v2'));
+            writeFileSync(join(templatesDir, 'v2', 'vite.config.ts.ejs'), 'export default {}');
+            writeFileSync(join(templatesDir, 'v2', 'README.md.ejs.deleted'), '');
+            mkdirSync(join(templatesDir, 'v3'));
+            writeFileSync(join(templatesDir, 'v3', 'vite.config.ts.ejs'), 'export default { minify: false }');
+            const expectedV1 = [
+                {
+                    relPath: '.project-config.json.ejs',
+                    srcPath: join(templatesDir, 'v1', '.project-config.json.ejs'),
+                    version: 1,
+                },
+                {
+                    relPath: 'AGENTS.md.ejs',
+                    srcPath: join(templatesDir, 'v1', 'AGENTS.md.ejs'),
+                    version: 1,
+                },
+                {
+                    relPath: 'README.md.ejs',
+                    srcPath: join(templatesDir, 'v1', 'README.md.ejs'),
+                    version: 1,
+                },
+                {
+                    relPath: 'package.json.ejs',
+                    srcPath: join(templatesDir, 'v1', 'package.json.ejs'),
+                    version: 1,
+                },
+            ];
+            const resultV1 = collectTemplateFiles(templatesDir, 1);
+            expect(normalizeCollectedTemplateFiles(resultV1)).toEqual(normalizeExpectedTemplateFiles(expectedV1));
+            const expectedV2 = [
+                {
+                    relPath: '.project-config.json.ejs',
+                    srcPath: join(templatesDir, 'v1', '.project-config.json.ejs'),
+                    version: 1,
+                },
+                {
+                    relPath: 'AGENTS.md.ejs',
+                    srcPath: join(templatesDir, 'v1', 'AGENTS.md.ejs'),
+                    version: 1,
+                },
+                {
+                    relPath: 'package.json.ejs',
+                    srcPath: join(templatesDir, 'v1', 'package.json.ejs'),
+                    version: 1,
+                },
+                {
+                    relPath: 'vite.config.ts.ejs',
+                    srcPath: join(templatesDir, 'v2', 'vite.config.ts.ejs'),
+                    version: 2,
+                },
+            ];
+            const resultV2 = collectTemplateFiles(templatesDir, 2);
+            expect(normalizeCollectedTemplateFiles(resultV2)).toEqual(normalizeExpectedTemplateFiles(expectedV2));
+            const expectedV3 = [
+                {
+                    relPath: '.project-config.json.ejs',
+                    srcPath: join(templatesDir, 'v1', '.project-config.json.ejs'),
+                    version: 1,
+                },
+                {
+                    relPath: 'AGENTS.md.ejs',
+                    srcPath: join(templatesDir, 'v1', 'AGENTS.md.ejs'),
+                    version: 1,
+                },
+                {
+                    relPath: 'package.json.ejs',
+                    srcPath: join(templatesDir, 'v1', 'package.json.ejs'),
+                    version: 1,
+                },
+                {
+                    relPath: 'vite.config.ts.ejs',
+                    srcPath: join(templatesDir, 'v3', 'vite.config.ts.ejs'),
+                    version: 3,
+                },
+            ];
+            const resultV3 = collectTemplateFiles(templatesDir, 3);
+            expect(normalizeCollectedTemplateFiles(resultV3)).toEqual(normalizeExpectedTemplateFiles(expectedV3));
+        }
+        finally {
+            rmSync(templatesDir, { recursive: true, force: true });
+        }
+    });
+    it('collects template files from subDir with version overrides and delete markers', () => {
+        const templatesDir = mkdtempSync(join(tmpdir(), 'sce-collectTemplateFiles-subdir-'));
+        try {
+            mkdirSync(join(templatesDir, 'v1', 'public'), { recursive: true });
+            writeFileSync(join(templatesDir, 'v1', 'public', 'manifest.json.ejs'), '{"v":1}');
+            writeFileSync(join(templatesDir, 'v1', 'public', 'resolveSlotPage.js.ejs'), 'export default 1');
+            mkdirSync(join(templatesDir, 'v2', 'public'), { recursive: true });
+            writeFileSync(join(templatesDir, 'v2', 'public', 'manifest.json.ejs'), '{"v":2}');
+            writeFileSync(join(templatesDir, 'v2', 'public', 'resolveSlotPage.js.ejs.deleted'), '');
+            const result = collectTemplateFiles(templatesDir, 2, 'public');
+            const expected = [
+                {
+                    relPath: 'manifest.json.ejs',
+                    srcPath: join(templatesDir, 'v2', 'public', 'manifest.json.ejs'),
+                    version: 2,
+                },
+            ];
+            expect(normalizeCollectedTemplateFiles(result)).toEqual(normalizeExpectedTemplateFiles(expected));
+        }
+        finally {
+            rmSync(templatesDir, { recursive: true, force: true });
+        }
+    });
+});

package/dist/src/templates/types.d.ts

@@ -0,0 +1,21 @@
+import type { TNormalizedRelPath, TRelPath } from '../types.js';
+export type TTemplateFile = {
+    deleted?: boolean;
+    relPath: TRelPath;
+    srcPath: string;
+    version: number;
+};
+export type TManagedFile = {
+    deleted?: boolean;
+    relPath: TRelPath;
+    version: number;
+};
+export type TNormalizedManagedFile = {
+    deleted?: boolean;
+    relPath: TNormalizedRelPath;
+    version: number;
+};
+export type TTemplateVersionDir = {
+    dirPath: string;
+    version: number;
+};

package/dist/src/templates/types.js

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

package/dist/src/types.d.ts

@@ -1,9 +1,17 @@
-export type TCategory = 'games-and-fun' | 'sex-toys' | 'chat-bots' | 'broadcast-tools';
-export type TFramework = 'vanilla' | 'preact';
-export type TLanguage = 'ts' | 'js';
-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 = {
+import type { CATEGORIES, FRAMEWORKS, LANGUAGES, PACKAGE_MANAGERS, SLOTS } from './constants';
+import type { TNormalizedManagedFile } from './templates/types';
+export type TCategory = typeof CATEGORIES[number];
+export type TRelPath = string;
+export type TNormalizedRelPath = TRelPath & {
+    readonly __normalizedRelPath: true;
+};
+export type TFramework = typeof FRAMEWORKS[number];
+export type TLanguage = typeof LANGUAGES[number];
+export type TSlot = typeof SLOTS[number];
+export type TPackageManager = typeof PACKAGE_MANAGERS[number];
+export type TPackageDependenciesMap = Record<string, string>;
+export type TCliCommandsMap = Record<string, string>;
+export type TProjectConfigUserProps = {
     category: TCategory;
     framework: TFramework;
     language: TLanguage;
@@ -11,6 +19,14 @@ export type TProjectConfig = {
     packageManager: TPackageManager;
     slots: TSlot[];
 };
+export type TProjectConfig = TProjectConfigUserProps & {
+    cliCommands: TCliCommandsMap;
+    dependencies: TPackageDependenciesMap;
+    devDependencies: TPackageDependenciesMap;
+    extHelperVersion: string;
+    lastTemplateVersion: number;
+    managedFiles: TNormalizedManagedFile[];
+};
 export type TSlotEntry = {
     slot: TSlot;
     /** The camel cased version of the slot (e.g. `mainGameFun`). It's used as html file names */
@@ -20,12 +36,11 @@ export type TPackageManagerCommands = {
     build: string;
     dev: string;
     install: string;
+    templateUpdate: string;
 };
 export type TTemplateData = {
     config: TProjectConfig;
-    entryModulePath?: string;
     ext: 'ts' | 'js';
-    extHelperVersion: string;
     framework: TFramework;
     isJsxFramework: boolean;
     isTypescript: boolean;
@@ -34,8 +49,12 @@ export type TTemplateData = {
     name: string;
     packageManager: TPackageManager;
     packageManagerCommands: TPackageManagerCommands;
-    slot?: string;
+    slots: TSlot[];
     slotsEntries: TSlotEntry[];
+};
+export type TTemplateSlotData = TTemplateData & {
+    entryModulePath?: string;
+    slot?: string;
     stylePath?: string;
 };
 export type TTemplateCommand = {

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

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

package/dist/src/validators/getIsValidCategory.js

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

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

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

package/dist/src/validators/{isValidCategory.test.js → getIsValidCategory.test.js}

@@ -1,10 +1,10 @@
 import { describe, expect, it } from 'vitest';
-import { isValidCategory } from './isValidCategory.js';
+import { getIsValidCategory } from './getIsValidCategory.js';
 describe('isValidCategory', () => {
     it.each(['games-and-fun', 'sex-toys', 'chat-bots', 'broadcast-tools'])('returns true for valid category: %s', (cat) => {
-        expect(isValidCategory(cat)).toBe(true);
+        expect(getIsValidCategory(cat)).toBe(true);
     });
     it.each(['invalid', '', 'Games-and-Fun', 'games_and_fun'])('returns false for invalid category: %s', (cat) => {
-        expect(isValidCategory(cat)).toBe(false);
+        expect(getIsValidCategory(cat)).toBe(false);
     });
 });

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

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

package/dist/src/validators/getIsValidFramework.js

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

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

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

package/dist/src/validators/{isValidFramework.test.js → getIsValidFramework.test.js}

@@ -1,10 +1,10 @@
 import { describe, expect, it } from 'vitest';
-import { isValidFramework } from './isValidFramework.js';
+import { getIsValidFramework } from './getIsValidFramework.js';
 describe('isValidFramework', () => {
     it.each(['vanilla', 'preact'])('returns true for valid framework: %s', (fw) => {
-        expect(isValidFramework(fw)).toBe(true);
+        expect(getIsValidFramework(fw)).toBe(true);
     });
     it.each(['react', '', 'Vanilla', 'vue'])('returns false for invalid framework: %s', (fw) => {
-        expect(isValidFramework(fw)).toBe(false);
+        expect(getIsValidFramework(fw)).toBe(false);
     });
 });

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,
+    };
 };