@stripchatdev/create-stripchat-extension 0.1.46 → 0.1.48

package/dist/src/templater/planner.test.js

@@ -0,0 +1,64 @@
+import { relative, basename, join } from 'node:path';
+import { describe, expect, it } from 'vitest';
+import { CATEGORIES, CLI_COMMANDS_MAP, EXT_HELPER_VERSION, FRAMEWORKS, LANGUAGES, SLOT_RULES_BY_CATEGORY, } from '../constants.js';
+import { toNormalizedRelPath } from '../helpers/normalizePath.js';
+import { buildProjectConfig } from '../projectConfig/buildProjectConfig.js';
+import { MANAGED_TEMPLATES } from '../templates/constants.js';
+import { LAST_TEMPLATE_VERSION, TEMPLATES_DIR } from '../templates/templates.js';
+import { mapProjectConfigToTemplateData } from './mappers/mapProjectConfigToTemplateModel.js';
+import { planProject } from './planner.js';
+const PROJECT_DIR = '/output/my-ext';
+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 combos;
+};
+const SLOT_COMBOS_BY_CATEGORY = Object.fromEntries(CATEGORIES.map((category) => {
+    return [category, buildSlotCombos(category)];
+}));
+const TEST_CASES = CATEGORIES.flatMap((category) => SLOT_COMBOS_BY_CATEGORY[category].flatMap((slots) => FRAMEWORKS.flatMap((framework) => LANGUAGES.flatMap((language) => new Array(LAST_TEMPLATE_VERSION).fill(0).map((_, index) => ({
+    category,
+    framework,
+    language,
+    slots,
+    slotsStr: slots.join(', '),
+    templateVersion: index + 1,
+}))))));
+const normalizeCommands = (commands) => commands.map((cmd) => {
+    const srcRel = join(basename(TEMPLATES_DIR), relative(TEMPLATES_DIR, cmd.srcPath));
+    const srcNormalized = toNormalizedRelPath(srcRel);
+    const destNormalized = toNormalizedRelPath(cmd.destPath).replace('/output/', '');
+    if (cmd.type === 'copy') {
+        return { type: 'copy', src: srcNormalized, dest: destNormalized };
+    }
+    return { type: 'render', src: srcNormalized, dest: destNormalized };
+});
+describe('planProject', { tags: ['snapshot'] }, () => {
+    it.each(TEST_CASES)('template version $templateVersion + $language + $framework, $category ($slotsStr)', ({ category, framework, language, slots, templateVersion, }) => {
+        const projectConfig = buildProjectConfig({
+            category,
+            framework,
+            language,
+            name: basename(PROJECT_DIR),
+            packageManager: 'npm',
+            slots,
+            extHelperVersion: EXT_HELPER_VERSION,
+            lastTemplateVersion: templateVersion,
+            cliCommands: CLI_COMMANDS_MAP,
+            managedTemplates: MANAGED_TEMPLATES,
+            templatesDir: TEMPLATES_DIR,
+        });
+        const data = mapProjectConfigToTemplateData(projectConfig);
+        const commands = planProject(PROJECT_DIR, templateVersion, data);
+        expect(normalizeCommands(commands)).toMatchSnapshot();
+    });
+});

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

@@ -0,0 +1,6 @@
+import type { TRelPath } from '../types.js';
+export declare const INIT_TEMPLATE_VERSION = 1;
+export declare const TEMPLATE_EXT = ".ejs";
+export declare const MANAGED_TEMPLATES: TRelPath[];
+export declare const DELETED_TEMPLATE_EXT = ".deleted";
+export declare const GENERAL_SLOT_NAME_PLACEHOLDER = "__SLOT_KEY__";

package/dist/src/templates/constants.js

@@ -0,0 +1,11 @@
+export const INIT_TEMPLATE_VERSION = 1;
+export const TEMPLATE_EXT = '.ejs';
+// only extends
+export const MANAGED_TEMPLATES = [
+    'AGENTS.md.ejs',
+    'package.json.ejs',
+    'vite.config.ts.ejs',
+    '.project-config.json.ejs',
+];
+export const DELETED_TEMPLATE_EXT = '.deleted';
+export const GENERAL_SLOT_NAME_PLACEHOLDER = '__SLOT_KEY__';

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

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

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

@@ -0,0 +1,16 @@
+import { dirname, join } from 'node:path';
+import { AppError } from '../../helpers/error.js';
+import { getIsDirectoryExists } from '../../helpers/getIsDirectoryExists.js';
+const __dirname = dirname(import.meta.filename);
+export const resolveTemplatesDir = () => {
+    // First value resolves from dist/src/templates/helpers; second resolves from src/templates/helpers.
+    const candidatePaths = ['../../../../templates', '../../../templates'];
+    for (const candidatePath of candidatePaths) {
+        const dir = join(__dirname, candidatePath);
+        const { isExists } = getIsDirectoryExists(dir);
+        if (isExists) {
+            return dir;
+        }
+    }
+    throw new AppError('Templates dir not found');
+};

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

@@ -0,0 +1,10 @@
+import type { TRelPath } from '../types.js';
+import type { TTemplateFile, TTemplateVersionDir, TManagedFile } from './types';
+export declare const discoverVersionDirs: (templatesDir: string, targetVersion: number, order?: "asc" | "desc") => TTemplateVersionDir[];
+export declare const getLastTemplateVersion: (templatesDir: string) => number;
+export declare const collectManagedFiles: (templateDir: string, managedTemplates: TRelPath[], targetVersion: number) => TManagedFile[];
+export declare const collectTemplateFiles: (templatesDir: string, targetVersion: number, subDir?: string) => TTemplateFile[];
+export declare const TEMPLATES_DIR: string;
+export declare const LAST_TEMPLATE_VERSION: number;
+export declare const SLOTS_TEMPLATE_DIR_REL: string;
+export declare const GENERAL_SLOT_TEMPLATE_DIR_REL: string;

package/dist/src/templates/templates.js

@@ -0,0 +1,133 @@
+import { existsSync, readdirSync } from 'node:fs';
+import { join, relative } from 'node:path';
+import { DELETED_TEMPLATE_EXT, INIT_TEMPLATE_VERSION, TEMPLATE_EXT } from './constants.js';
+import { resolveTemplatesDir } from './helpers/resolveTemplatesDir.js';
+const FOLDER_VERSION_PATTERN = /v(\d+)/;
+export const discoverVersionDirs = (templatesDir, targetVersion, order = 'asc') => {
+    const entries = readdirSync(templatesDir, {
+        withFileTypes: true,
+    });
+    return entries
+        .map((entry) => {
+        if (!entry.isDirectory()) {
+            return null;
+        }
+        const match = entry.name.match(FOLDER_VERSION_PATTERN);
+        if (!match) {
+            return null;
+        }
+        const [, versionStr] = match;
+        const version = Number(versionStr);
+        if (!Number.isFinite(version)) {
+            return null;
+        }
+        if (version > targetVersion) {
+            return null;
+        }
+        return {
+            dirPath: join(entry.parentPath, entry.name),
+            version,
+        };
+    })
+        .filter((entry) => entry !== null)
+        .sort((a, b) => {
+        if (order === 'asc') {
+            return a.version - b.version;
+        }
+        return b.version - a.version;
+    });
+};
+export const getLastTemplateVersion = (templatesDir) => {
+    const versionDirs = discoverVersionDirs(templatesDir, Number.MAX_SAFE_INTEGER, 'desc');
+    return versionDirs[0]?.version || INIT_TEMPLATE_VERSION;
+};
+export const collectManagedFiles = (templateDir, managedTemplates, targetVersion) => {
+    const versionDirs = discoverVersionDirs(templateDir, targetVersion, 'asc');
+    const managedTemplatesMap = {};
+    for (const relPath of managedTemplates) {
+        for (const versionDir of versionDirs) {
+            const { dirPath, version } = versionDir;
+            const targetManagedFilePath = join(dirPath, relPath);
+            const targetManagedFilePathDeleted = join(dirPath, `${relPath}.deleted`);
+            if (existsSync(targetManagedFilePath)) {
+                managedTemplatesMap[relPath] = {
+                    relPath,
+                    srcPath: join(dirPath, relPath),
+                    version,
+                };
+            }
+            else if (existsSync(targetManagedFilePathDeleted)) {
+                managedTemplatesMap[relPath] = {
+                    relPath,
+                    srcPath: join(dirPath, relPath),
+                    version,
+                    deleted: true,
+                };
+            }
+        }
+    }
+    return Object.values(managedTemplatesMap).map(({ deleted, relPath, version }) => {
+        return {
+            relPath: relPath.endsWith(TEMPLATE_EXT)
+                ? relPath.slice(0, -TEMPLATE_EXT.length)
+                : relPath,
+            version,
+            deleted,
+        };
+    });
+};
+const listTemplateFiles = (dir, version) => {
+    if (!existsSync(dir)) {
+        return [];
+    }
+    const entries = readdirSync(dir, { recursive: true, withFileTypes: true });
+    return entries
+        .filter((entry) => entry.isFile())
+        .map((entry) => {
+        const relPath = relative(dir, join(entry.parentPath, entry.name));
+        const srcPath = join(entry.parentPath, entry.name);
+        const isDeleted = relPath.endsWith(DELETED_TEMPLATE_EXT);
+        const resolvedRelPath = isDeleted
+            ? relPath.slice(0, -DELETED_TEMPLATE_EXT.length)
+            : relPath;
+        const resolvedSrcPath = isDeleted
+            ? srcPath.slice(0, -DELETED_TEMPLATE_EXT.length)
+            : srcPath;
+        return {
+            relPath: resolvedRelPath,
+            srcPath: resolvedSrcPath,
+            version,
+            deleted: isDeleted,
+        };
+    })
+        .sort((a, b) => a.relPath.localeCompare(b.relPath));
+};
+export const collectTemplateFiles = (templatesDir, targetVersion, subDir) => {
+    const versionDirs = discoverVersionDirs(templatesDir, targetVersion);
+    let subVersionDirs = versionDirs;
+    if (subDir) {
+        subVersionDirs = versionDirs.map(({ dirPath, version }) => {
+            return {
+                dirPath: join(dirPath, subDir),
+                version,
+            };
+        });
+    }
+    const templateFilesMap = {};
+    for (const { dirPath, version } of subVersionDirs) {
+        const templateFiles = listTemplateFiles(dirPath, version);
+        for (const templateFile of templateFiles) {
+            if (templateFile.deleted) {
+                delete templateFilesMap[templateFile.relPath];
+            }
+            else {
+                templateFilesMap[templateFile.relPath] = templateFile;
+            }
+        }
+    }
+    return Object.values(templateFilesMap);
+};
+export const TEMPLATES_DIR = resolveTemplatesDir();
+export const LAST_TEMPLATE_VERSION = getLastTemplateVersion(TEMPLATES_DIR);
+export const SLOTS_TEMPLATE_DIR_REL = join('src', 'slots');
+export const GENERAL_SLOT_TEMPLATE_DIR_REL = join(SLOTS_TEMPLATE_DIR_REL, 'slot');

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

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

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);
     });
 });