@stripchatdev/create-stripchat-extension 0.1.7

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

@@ -0,0 +1,50 @@
+import { describe, expect, it } from 'vitest';
+import { resolveTemplateExtension } from './resolveTemplateExtension.js';
+describe('resolveTemplateExtension', () => {
+    describe('with TypeScript enabled', () => {
+        const isTypescript = true;
+        it('strips .ejs and keeps .ts', () => {
+            expect(resolveTemplateExtension('main.ts.ejs', isTypescript)).toBe('main.ts');
+        });
+        it('strips .ejs and keeps .tsx', () => {
+            expect(resolveTemplateExtension('app.tsx.ejs', isTypescript)).toBe('app.tsx');
+        });
+        it('keeps .ts without .ejs suffix', () => {
+            expect(resolveTemplateExtension('main.ts', isTypescript)).toBe('main.ts');
+        });
+    });
+    describe('with JavaScript (isTypescript = false)', () => {
+        const isTypescript = false;
+        it('converts .ts to .js', () => {
+            expect(resolveTemplateExtension('main.ts.ejs', isTypescript)).toBe('main.js');
+        });
+        it('converts .tsx to .jsx', () => {
+            expect(resolveTemplateExtension('app.tsx.ejs', isTypescript)).toBe('app.jsx');
+        });
+        it('converts .ts without .ejs suffix', () => {
+            expect(resolveTemplateExtension('main.ts', isTypescript)).toBe('main.js');
+        });
+    });
+    describe('non-ts/tsx extensions', () => {
+        it('strips .ejs from .json.ejs', () => {
+            expect(resolveTemplateExtension('package.json.ejs', true)).toBe('package.json');
+        });
+        it('strips .ejs from .html.ejs', () => {
+            expect(resolveTemplateExtension('slot.html.ejs', false)).toBe('slot.html');
+        });
+        it('leaves .svg unchanged (no .ejs)', () => {
+            expect(resolveTemplateExtension('icon.svg', false)).toBe('icon.svg');
+        });
+        it('strips .ejs from bare .ejs file', () => {
+            expect(resolveTemplateExtension('.gitignore.ejs', false)).toBe('.gitignore');
+        });
+    });
+    describe('compound extensions like vite.config.ts', () => {
+        it('keeps .ts when typescript', () => {
+            expect(resolveTemplateExtension('vite.config.ts.ejs', true)).toBe('vite.config.ts');
+        });
+        it('converts .ts to .js when javascript', () => {
+            expect(resolveTemplateExtension('vite.config.ts.ejs', false)).toBe('vite.config.js');
+        });
+    });
+});

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

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

package/dist/src/helpers/resolveTemplatesDir.js

@@ -0,0 +1,11 @@
+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.d.ts

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

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

@@ -0,0 +1,21 @@
+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/mappers/mapProjectConfigToTemplateModel.d.ts

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

package/dist/src/mappers/mapProjectConfigToTemplateModel.js

@@ -0,0 +1,26 @@
+import { EXT_HELPER_VERSION, JSX_FRAMEWORKS, PACKAGE_MANAGER_COMMANDS_MAP, SLOT_TYPES } from '../constants.js';
+const buildSlotResolverEntries = (config) => config.slots.map((slot) => ({
+    slotType: SLOT_TYPES[slot],
+    slot,
+}));
+export const mapProjectConfigToTemplateData = (config) => {
+    const isTypescript = config.language === 'ts';
+    const isJsxFramework = JSX_FRAMEWORKS.includes(config.framework);
+    const ext = isTypescript ? 'ts' : 'js';
+    const jsxExt = isTypescript ? 'tsx' : 'jsx';
+    return {
+        config,
+        ext,
+        extHelperVersion: EXT_HELPER_VERSION,
+        framework: config.framework,
+        isJsxFramework,
+        isTypescript,
+        jsxExt,
+        language: config.language,
+        name: config.name,
+        packageManager: config.packageManager,
+        packageManagerCommands: PACKAGE_MANAGER_COMMANDS_MAP[config.packageManager],
+        slotResolverEntries: buildSlotResolverEntries(config),
+        slots: config.slots,
+    };
+};

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

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

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

@@ -0,0 +1,89 @@
+import { describe, expect, it } from 'vitest';
+import { EXT_HELPER_VERSION } from '../constants.js';
+import { mapProjectConfigToTemplateData } from '../mappers/mapProjectConfigToTemplateModel.js';
+const makeConfig = (overrides = {}) => ({
+    category: 'games-and-fun',
+    framework: 'vanilla',
+    language: 'ts',
+    name: 'test-ext',
+    packageManager: 'npm',
+    slots: ['mainGameFun', 'background'],
+    ...overrides,
+});
+describe('mapProjectConfigToTemplateData', () => {
+    it('sets typescript flags when language is ts', () => {
+        const result = mapProjectConfigToTemplateData(makeConfig({ language: 'ts' }));
+        expect(result.isTypescript).toBe(true);
+        expect(result.ext).toBe('ts');
+        expect(result.jsxExt).toBe('tsx');
+    });
+    it('sets javascript flags when language is js', () => {
+        const result = mapProjectConfigToTemplateData(makeConfig({ language: 'js' }));
+        expect(result.isTypescript).toBe(false);
+        expect(result.ext).toBe('js');
+        expect(result.jsxExt).toBe('jsx');
+    });
+    it('marks preact as a JSX framework', () => {
+        const result = mapProjectConfigToTemplateData(makeConfig({ framework: 'preact' }));
+        expect(result.isJsxFramework).toBe(true);
+    });
+    it('marks vanilla as a non-JSX framework', () => {
+        const result = mapProjectConfigToTemplateData(makeConfig({ framework: 'vanilla' }));
+        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' },
+        ]);
+    });
+    it('maps sex-toys category slots correctly', () => {
+        const result = mapProjectConfigToTemplateData(makeConfig({
+            category: 'sex-toys',
+            slots: ['mainSexToy', 'background', 'moveableOverlay'],
+        }));
+        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' },
+        ]);
+    });
+    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');
+    });
+    it('returns empty array when no slots provided', () => {
+        const result = mapProjectConfigToTemplateData(makeConfig({ slots: [] }));
+        expect(result.slotResolverEntries).toEqual([]);
+    });
+    it('passes config reference unchanged', () => {
+        const config = makeConfig();
+        const result = mapProjectConfigToTemplateData(config);
+        expect(result.config).toBe(config);
+    });
+    it('passes name, framework, language, and slots from config', () => {
+        const config = makeConfig({
+            framework: 'preact',
+            language: 'js',
+            name: 'my-project',
+            slots: ['mainGameFun'],
+        });
+        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']);
+    });
+    it('does not include entryModulePath or slot', () => {
+        const result = mapProjectConfigToTemplateData(makeConfig());
+        expect(result.entryModulePath).toBeUndefined();
+        expect(result.slot).toBeUndefined();
+    });
+    it('sets extHelperVersion from package version', () => {
+        const result = mapProjectConfigToTemplateData(makeConfig());
+        expect(result.extHelperVersion).toBe(EXT_HELPER_VERSION);
+    });
+});

package/dist/src/planner.d.ts

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

package/dist/src/planner.js

@@ -0,0 +1,126 @@
+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.slots.map((slot) => planSlotTemplates(projectDir, data, slot)));
+    return [...globalCommands, ...slotCommandArrays.flat()];
+};

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

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

package/dist/src/planner.test.js

@@ -0,0 +1,46 @@
+import { describe, expect, it } from 'vitest';
+import { CATEGORIES, FRAMEWORKS, LANGUAGES, REQUIRED_SLOTS_BY_CATEGORY, SELECTABLE_SLOTS_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];
+    return [
+        category,
+        [required, ...(selectable.length > 0 ? [[...required, ...selectable]] : [])],
+    ];
+}));
+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/types.d.ts

@@ -0,0 +1,50 @@
+export type TCategory = 'games-and-fun' | 'sex-toys';
+export type TFramework = 'vanilla' | 'preact';
+export type TLanguage = 'ts' | 'js';
+export type TSlot = 'mainGameFun' | 'mainSexToy' | 'rightOverlay' | 'moveableOverlay' | 'background';
+export type TPackageManager = 'npm' | 'yarn' | 'pnpm' | 'bun';
+export type TProjectConfig = {
+    category: TCategory;
+    framework: TFramework;
+    language: TLanguage;
+    name: string;
+    packageManager: TPackageManager;
+    slots: TSlot[];
+};
+export type TSlotResolverEntry = {
+    slot: string;
+    slotType: string;
+};
+export type TPackageManagerCommands = {
+    build: string;
+    dev: string;
+    install: string;
+};
+export type TTemplateData = {
+    config: TProjectConfig;
+    entryModulePath?: string;
+    ext: 'ts' | 'js';
+    extHelperVersion: string;
+    framework: TFramework;
+    isJsxFramework: boolean;
+    isTypescript: boolean;
+    jsxExt: 'tsx' | 'jsx';
+    language: TLanguage;
+    name: string;
+    packageManager: TPackageManager;
+    packageManagerCommands: TPackageManagerCommands;
+    slot?: string;
+    slotResolverEntries: TSlotResolverEntry[];
+    slots: TSlot[];
+    stylePath?: string;
+};
+export type TTemplateCommand = {
+    destPath: string;
+    srcPath: string;
+    type: 'copy';
+} | {
+    data: TTemplateData;
+    destPath: string;
+    srcPath: string;
+    type: 'render';
+};

package/dist/src/types.js

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

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

@@ -0,0 +1,6 @@
+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';

package/dist/src/validators/index.js

@@ -0,0 +1,6 @@
+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';

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

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

package/dist/src/validators/isValidCategory.js

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

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

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

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

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

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

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

package/dist/src/validators/isValidFramework.js

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

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

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

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

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

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

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

package/dist/src/validators/isValidLanguage.js

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

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

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

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

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

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

@@ -0,0 +1 @@
+export declare const validateName: (value: string) => string | true;

package/dist/src/validators/validateName.js

@@ -0,0 +1,10 @@
+export const validateName = (value) => {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return 'Project name is required';
+    }
+    if (!/^[a-z0-9@][a-z0-9._-]*[a-z0-9]?$/i.test(trimmed)) {
+        return 'Invalid project name. Use lowercase letters, numbers, hyphens, and dots.';
+    }
+    return true;
+};

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

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

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

@@ -0,0 +1,33 @@
+import { describe, expect, it } from 'vitest';
+import { validateName } from './validateName.js';
+describe('validateName', () => {
+    it.each([
+        'my-extension',
+        'my.extension',
+        'my-ext-123',
+        'a',
+        '@scope',
+        'MyExtension',
+    ])('accepts valid name: %s', (name) => {
+        expect(validateName(name)).toBe(true);
+    });
+    it('accepts a name with leading/trailing whitespace by trimming', () => {
+        expect(validateName('  my-extension  ')).toBe(true);
+    });
+    it('rejects empty string', () => {
+        expect(validateName('')).toBe('Project name is required');
+    });
+    it('rejects whitespace-only string', () => {
+        expect(validateName('   ')).toBe('Project name is required');
+    });
+    it.each([
+        'has spaces',
+        '-starts-with-dash',
+        '.starts-with-dot',
+        'special!chars',
+        'no/slashes',
+    ])('rejects invalid name: %s', (name) => {
+        expect(validateName(name)).toBeTypeOf('string');
+        expect(validateName(name)).not.toBe(true);
+    });
+});

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

@@ -0,0 +1 @@
+export declare const validateProjectDir: (projectDir: string, projectName: string) => void;

package/dist/src/validators/validateProjectDir.js

@@ -0,0 +1,6 @@
+import { existsSync } from 'node:fs';
+export const validateProjectDir = (projectDir, projectName) => {
+    if (existsSync(projectDir)) {
+        throw new Error(`Directory "${projectName}" already exists.`);
+    }
+};

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

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

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

@@ -0,0 +1,19 @@
+import { describe, expect, it, vi } from 'vitest';
+import { validateProjectDir } from './validateProjectDir.js';
+vi.mock('node:fs', () => ({
+    existsSync: (path) => path.includes('existing-dir'),
+}));
+describe('validateProjectDir', () => {
+    it('does not throw when directory does not exist', () => {
+        expect(() => validateProjectDir('/tmp/new-dir', 'new-dir')).not.toThrow();
+    });
+    it('includes project name and dir in the error', () => {
+        try {
+            validateProjectDir('/tmp/existing-dir', 'existing-dir');
+            expect.fail('should have thrown');
+        }
+        catch (error) {
+            expect(error.message).toContain('existing-dir');
+        }
+    });
+});

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

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

package/dist/src/validators/validateSlots.js

@@ -0,0 +1,15 @@
+import { SELECTABLE_SLOTS_BY_CATEGORY } from '../constants.js';
+export const validateSlots = (slots, category) => {
+    const allowed = new Set(SELECTABLE_SLOTS_BY_CATEGORY[category]);
+    const valid = [];
+    const invalid = [];
+    for (const slot of slots) {
+        if (allowed.has(slot)) {
+            valid.push(slot);
+        }
+        else {
+            invalid.push(slot);
+        }
+    }
+    return { invalid, valid };
+};