@stripchatdev/create-stripchat-extension 0.1.45 → 0.1.47

package/dist/src/{executor.test.js → templater/executor.test.js}

@@ -2,6 +2,10 @@ import { readFile, rm, mkdtemp } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { CLI_COMMANDS_MAP, EXT_HELPER_VERSION } from '../constants.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 { executeCommands } from './executor.js';
 import { mapProjectConfigToTemplateData } from './mappers/mapProjectConfigToTemplateModel.js';
 import { planProject } from './planner.js';
@@ -13,9 +17,9 @@ const rewriteDestPaths = (commands, destDir) => commands.map((cmd) => {
     }
     return { ...cmd, destPath };
 });
-const buildCommands = async (config, destDir) => {
+const buildCommands = (config, destDir) => {
     const data = mapProjectConfigToTemplateData(config);
-    const commands = await planProject(data, '/output/my-ext');
+    const commands = planProject('/output/my-ext', config.lastTemplateVersion, data);
     return rewriteDestPaths(commands, destDir);
 };
 describe('executeCommands', () => {
@@ -27,17 +31,22 @@ describe('executeCommands', () => {
         await rm(tmpDir, { recursive: true });
     });
     it('renders EJS templates into destination files', async () => {
-        const config = {
+        const projectConfig = buildProjectConfig({
             category: 'games-and-fun',
             framework: 'vanilla',
             language: 'ts',
             name: 'my-ext',
             packageManager: 'npm',
             slots: ['EXTENSION_SLOT_MAIN_GAME_FUN', 'EXTENSION_SLOT_BACKGROUND'],
-        };
-        const commands = await buildCommands(config, tmpDir);
+            extHelperVersion: EXT_HELPER_VERSION,
+            lastTemplateVersion: LAST_TEMPLATE_VERSION,
+            cliCommands: CLI_COMMANDS_MAP,
+            managedTemplates: MANAGED_TEMPLATES,
+            templatesDir: TEMPLATES_DIR,
+        });
+        const commands = buildCommands(projectConfig, tmpDir);
         const cb = vi.fn();
-        await executeCommands(commands, cb);
+        executeCommands(commands, cb);
         for (const command of commands) {
             if (command.type === 'render') {
                 const content = await readFile(command.destPath, 'utf-8');
@@ -56,22 +65,27 @@ describe('executeCommands', () => {
         }
         expect(cb).toHaveBeenCalledTimes(commands.length);
     });
-    it('rejects with ENOENT when a source template is missing', async () => {
-        const config = {
+    it('rejects with ENOENT when a source template is missing', () => {
+        const projectConfig = buildProjectConfig({
             category: 'sex-toys',
             framework: 'vanilla',
             language: 'js',
             name: 'my-ext',
             packageManager: 'npm',
             slots: ['EXTENSION_SLOT_MAIN_SEX_TOY', 'EXTENSION_SLOT_BACKGROUND'],
-        };
-        const commands = await buildCommands(config, tmpDir);
+            extHelperVersion: EXT_HELPER_VERSION,
+            lastTemplateVersion: LAST_TEMPLATE_VERSION,
+            cliCommands: CLI_COMMANDS_MAP,
+            managedTemplates: MANAGED_TEMPLATES,
+            templatesDir: TEMPLATES_DIR,
+        });
+        const commands = buildCommands(projectConfig, tmpDir);
         const corruptedIndex = commands.findIndex((c) => c.type === 'render');
         const corrupted = [...commands];
         corrupted[corruptedIndex] = {
             ...corrupted[corruptedIndex],
             srcPath: join(tmpDir, 'nonexistent.ejs'),
         };
-        await expect(executeCommands(corrupted)).rejects.toThrow(/ENOENT/);
+        expect(() => executeCommands(corrupted)).toThrow(/ENOENT/);
     });
 });

package/dist/src/templater/helpers/getIsTypescriptOnlyFile.d.ts

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

package/dist/src/templater/helpers/getIsTypescriptOnlyFile.js

@@ -0,0 +1,10 @@
+import { relative } from 'node:path';
+import { TS_ONLY_FILES } from '../../constants.js';
+import { toNormalizedRelPath } from '../../helpers/normalizePath.js';
+import { TEMPLATES_DIR } from '../../templates/templates.js';
+export const getIsTypescriptOnlyFile = (templateFilePath) => {
+    const withoutEjs = relative(TEMPLATES_DIR, templateFilePath).replace(/\.ejs$/, '');
+    const normalizedFile = toNormalizedRelPath(withoutEjs);
+    const withoutVersion = normalizedFile.split('/').slice(1).join('/');
+    return TS_ONLY_FILES.includes(withoutVersion);
+};

package/dist/src/templater/helpers/getIsTypescriptOnlyFile.test.d.ts

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

package/dist/src/templater/helpers/getIsTypescriptOnlyFile.test.js

@@ -0,0 +1,25 @@
+import { join } from 'node:path';
+import { describe, expect, it } from 'vitest';
+import { TEMPLATES_DIR } from '../../templates/templates.js';
+import { getIsTypescriptOnlyFile } from './getIsTypescriptOnlyFile.js';
+const templatePath = (fileName) => join(TEMPLATES_DIR, 'v1', fileName);
+describe('isTypescriptOnlyFile', () => {
+    it('returns true for tsconfig.json', () => {
+        expect(getIsTypescriptOnlyFile(templatePath('tsconfig.json'))).toBe(true);
+    });
+    it('returns true for tsconfig.json.ejs (strips .ejs suffix)', () => {
+        expect(getIsTypescriptOnlyFile(templatePath('tsconfig.json.ejs'))).toBe(true);
+    });
+    it('returns false for package.json', () => {
+        expect(getIsTypescriptOnlyFile(templatePath('package.json'))).toBe(false);
+    });
+    it('returns false for package.json.ejs', () => {
+        expect(getIsTypescriptOnlyFile(templatePath('package.json.ejs'))).toBe(false);
+    });
+    it('returns false for vite.config.ts.ejs', () => {
+        expect(getIsTypescriptOnlyFile(templatePath('vite.config.ts.ejs'))).toBe(false);
+    });
+    it('returns false for an empty string', () => {
+        expect(getIsTypescriptOnlyFile('')).toBe(false);
+    });
+});

package/dist/src/templater/helpers/resolveTemplateExtension.d.ts

@@ -0,0 +1 @@
+export declare const resolveTemplateExtension: (templatePath: string, isTypescript: boolean) => string;

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

@@ -0,0 +1,16 @@
+import { dirname, join, parse } from 'node:path';
+import { TEMPLATE_EXT } from '../../templates/constants.js';
+const resolveOutputExtension = (templateExt, isTypescript) => {
+    const map = {
+        '.ts': isTypescript ? '.ts' : '.js',
+        '.tsx': isTypescript ? '.tsx' : '.jsx',
+    };
+    return map[templateExt] ?? templateExt;
+};
+export const resolveTemplateExtension = (templatePath, isTypescript) => {
+    const withoutEjs = templatePath.endsWith(TEMPLATE_EXT)
+        ? templatePath.slice(0, -TEMPLATE_EXT.length)
+        : templatePath;
+    const withoutEjsParsed = parse(withoutEjs);
+    return join(dirname(templatePath), `${withoutEjsParsed.name}${resolveOutputExtension(withoutEjsParsed.ext, isTypescript)}`);
+};

package/dist/src/templater/helpers/resolveTemplateExtension.test.d.ts

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

package/dist/src/{mappers → templater/mappers}/mapProjectConfigToTemplateModel.d.ts

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

package/dist/src/{mappers → templater/mappers}/mapProjectConfigToTemplateModel.js

@@ -1,24 +1,22 @@
-import { EXT_HELPER_VERSION, JSX_FRAMEWORKS, PACKAGE_MANAGER_COMMANDS_MAP, SLOT_LABELS } from '../constants.js';
+import { PACKAGE_MANAGER_COMMANDS_MAP, SLOT_LABELS } from '../../constants.js';
+import { getIsJsxFramework } from '../../helpers/getIsJsxFramework.js';
+import { getIsTypescript } from '../../helpers/getIsTypescript.js';
 const buildSlotResolverEntries = (config) => config.slots.map((slot) => ({
     slotCamelCased: SLOT_LABELS[slot],
     slot,
 }));
 export const mapProjectConfigToTemplateData = (config) => {
-    const isTypescript = config.language === 'ts';
-    const isJsxFramework = JSX_FRAMEWORKS.includes(config.framework);
+    const isTypescript = getIsTypescript(config.language);
+    const isJsxFramework = getIsJsxFramework(config.framework);
     const ext = isTypescript ? 'ts' : 'js';
     const jsxExt = isTypescript ? 'tsx' : 'jsx';
     return {
         config,
+        ...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],
         slotsEntries: buildSlotResolverEntries(config),
     };

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

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

package/dist/src/{mappers → templater/mappers}/mapProjectConfigToTemplateModel.test.js

@@ -1,15 +1,31 @@
 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: ['EXTENSION_SLOT_MAIN_GAME_FUN', 'EXTENSION_SLOT_BACKGROUND'],
-    ...overrides,
-});
+import { CLI_COMMANDS_MAP, EXT_HELPER_VERSION } from '../../constants.js';
+import { DEPENDENCIES } from '../../dependencies/constants.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 './mapProjectConfigToTemplateModel.js';
+const makeConfig = (overrides = {}) => {
+    const language = overrides.language ?? 'ts';
+    const framework = overrides.framework ?? 'vanilla';
+    const projectConfig = buildProjectConfig({
+        name: 'test-ext',
+        category: 'games-and-fun',
+        framework,
+        language,
+        packageManager: 'npm',
+        slots: ['EXTENSION_SLOT_MAIN_GAME_FUN', 'EXTENSION_SLOT_BACKGROUND'],
+        extHelperVersion: EXT_HELPER_VERSION,
+        lastTemplateVersion: LAST_TEMPLATE_VERSION,
+        cliCommands: CLI_COMMANDS_MAP,
+        managedTemplates: MANAGED_TEMPLATES,
+        templatesDir: TEMPLATES_DIR,
+    });
+    return {
+        ...projectConfig,
+        ...overrides,
+    };
+};
 describe('mapProjectConfigToTemplateData', () => {
     it('sets typescript flags when language is ts', () => {
         const result = mapProjectConfigToTemplateData(makeConfig({ language: 'ts' }));
@@ -75,11 +91,6 @@ describe('mapProjectConfigToTemplateData', () => {
         const result = mapProjectConfigToTemplateData(makeConfig({ slots: [] }));
         expect(result.slotsEntries).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',
@@ -95,13 +106,8 @@ describe('mapProjectConfigToTemplateData', () => {
             { slot: 'EXTENSION_SLOT_MAIN_GAME_FUN', slotCamelCased: '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', () => {
+    it('sets ext-helper dependency from resolved dependencies', () => {
         const result = mapProjectConfigToTemplateData(makeConfig());
-        expect(result.extHelperVersion).toBe(EXT_HELPER_VERSION);
+        expect(result.config.dependencies['@stripchatdev/ext-helper']).toBe(DEPENDENCIES['@stripchatdev/ext-helper']);
     });
 });

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

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

package/dist/src/templater/planner.js

@@ -0,0 +1,104 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { isSubPath } from '../helpers/isSubPath.js';
+import { GENERAL_SLOT_NAME_PLACEHOLDER, TEMPLATE_EXT, } from '../templates/constants.js';
+import { collectTemplateFiles, GENERAL_SLOT_TEMPLATE_DIR_REL, SLOTS_TEMPLATE_DIR_REL, TEMPLATES_DIR, } from '../templates/templates.js';
+import { getIsTypescriptOnlyFile } from './helpers/getIsTypescriptOnlyFile.js';
+import { resolveTemplateExtension } from './helpers/resolveTemplateExtension.js';
+const shouldSkipGlobalTemplate = (templatePath, data) => getIsTypescriptOnlyFile(templatePath) && !data.isTypescript;
+const shouldSkipSlotTemplate = (relPath, allRelPaths, isJsxFramework) => {
+    if (relPath.endsWith('.tsx.ejs')) {
+        const tsCounterpart = relPath.replace(/\.tsx\.ejs$/, '.ts.ejs');
+        if (allRelPaths.has(tsCounterpart) && !isJsxFramework) {
+            return true;
+        }
+    }
+    if (relPath.endsWith('.ts.ejs')) {
+        const tsxCounterpart = relPath.replace(/\.ts\.ejs$/, '.tsx.ejs');
+        if (allRelPaths.has(tsxCounterpart) && isJsxFramework) {
+            return true;
+        }
+    }
+    return false;
+};
+const planGlobalTemplates = (projectDir, targetVersion, data) => {
+    const files = collectTemplateFiles(TEMPLATES_DIR, targetVersion);
+    const commands = [];
+    for (const file of files) {
+        if (file.deleted) {
+            continue;
+        }
+        if (isSubPath('src/slots', file.relPath)) {
+            continue;
+        }
+        if (shouldSkipGlobalTemplate(file.srcPath, data)) {
+            continue;
+        }
+        const isEjs = file.srcPath.endsWith(TEMPLATE_EXT);
+        if (!isEjs) {
+            commands.push({
+                destPath: join(projectDir, file.relPath),
+                srcPath: file.srcPath,
+                type: 'copy',
+            });
+            continue;
+        }
+        commands.push({
+            data,
+            destPath: join(projectDir, resolveTemplateExtension(file.relPath, data.isTypescript)),
+            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 planSlotTemplates = (projectDir, targetVersion, data, slotKey) => {
+    const specificDir = join(SLOTS_TEMPLATE_DIR_REL, slotKey);
+    const hasSpecificDir = existsSync(specificDir);
+    const slotTemplatedDirRel = hasSpecificDir ? specificDir : GENERAL_SLOT_TEMPLATE_DIR_REL;
+    const slotData = buildSlotTemplateData(data, slotKey);
+    const files = collectTemplateFiles(TEMPLATES_DIR, targetVersion, slotTemplatedDirRel);
+    const allRelPaths = new Set(files.map((f) => f.relPath));
+    const commands = [];
+    for (const file of files) {
+        if (shouldSkipSlotTemplate(file.relPath, allRelPaths, data.isJsxFramework)) {
+            continue;
+        }
+        const outputRelPath = file.relPath.replace(GENERAL_SLOT_NAME_PLACEHOLDER, slotKey);
+        const resolvedPath = resolveTemplateExtension(outputRelPath, data.isTypescript);
+        const isHtml = resolvedPath.endsWith('.html');
+        const destPath = isHtml
+            ? join(projectDir, resolvedPath)
+            : join(projectDir, 'src', 'slots', slotKey, resolvedPath);
+        if (file.relPath.endsWith(TEMPLATE_EXT)) {
+            commands.push({
+                data: slotData,
+                destPath,
+                srcPath: file.srcPath,
+                type: 'render',
+            });
+            continue;
+        }
+        commands.push({
+            destPath,
+            srcPath: file.srcPath,
+            type: 'copy',
+        });
+    }
+    return commands;
+};
+export const planProject = (projectDir, targetVersion, data) => {
+    const globalCommands = planGlobalTemplates(projectDir, targetVersion, data);
+    const slotCommands = data.slotsEntries.flatMap(({ slotCamelCased }) => planSlotTemplates(projectDir, targetVersion, data, slotCamelCased));
+    return [...globalCommands, ...slotCommands];
+};

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

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

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 - for dist folder, second value for tests
+    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 {};