@stripchatdev/create-stripchat-extension 0.1.46 → 0.1.47

package/dist/bin/cli/actions/updateAction.d.ts

@@ -0,0 +1,6 @@
+export type TUpdateOptions = {
+    isDryRun: boolean;
+    projectDir: string;
+    templateVersion: number;
+};
+export declare const updateAction: (options: TUpdateOptions) => Promise<void>;

package/dist/bin/cli/actions/updateAction.js

@@ -0,0 +1,33 @@
+import { executeMigrations } from '../../../src/migrator/executor.js';
+import { planMigrationExecution } from '../../../src/migrator/planner.js';
+import { resolveExistsProjectConfig } from '../../../src/projectConfig/resolveExistsProjectConfig.js';
+export const updateAction = async (options) => {
+    const { isDryRun, projectDir, templateVersion } = options;
+    const targetProjectConfig = resolveExistsProjectConfig(projectDir);
+    const executionPlan = planMigrationExecution(targetProjectConfig, templateVersion);
+    if (!executionPlan.migrationPlans.length) {
+        console.log('\nNo migration plan found, all managed files are up to date.');
+        return;
+    }
+    console.log('\nMigration plan:');
+    executionPlan.migrationPlans.forEach((migration) => {
+        console.log(` ${migration.scriptPath}`);
+    });
+    const migrationDiffs = await executeMigrations({
+        projectDir,
+        isDryRun,
+        executionPlan,
+    });
+    if (!migrationDiffs.length) {
+        console.log('\nNo files changed\n');
+        return;
+    }
+    console.log('\nChanged files:');
+    const changedFiles = new Set();
+    migrationDiffs.forEach((migrationDiff) => {
+        if (!changedFiles.has(migrationDiff.filePath)) {
+            changedFiles.add(migrationDiff.filePath);
+            console.log(` ${migrationDiff.filePath}`);
+        }
+    });
+};

package/dist/bin/cli/helpers/printCliError.d.ts

@@ -0,0 +1 @@
+export declare const printCliError: (err: unknown) => void;

package/dist/bin/cli/helpers/printCliError.js

@@ -0,0 +1,21 @@
+import * as process from 'node:process';
+import { AppError } from '../../../src/helpers/error.js';
+const isDebugMode = process.env.DEBUG === 'true';
+const printErrorMessage = (message) => {
+    console.error(`x ${message}\n`);
+};
+export const printCliError = (err) => {
+    if (err instanceof AppError) {
+        printErrorMessage(err.message);
+        return;
+    }
+    printErrorMessage('Unexpected error occurred.');
+    if (err instanceof Error && isDebugMode) {
+        console.error(err.stack, '\n');
+        return;
+    }
+    if (isDebugMode) {
+        console.error(err);
+    }
+    return;
+};

package/dist/bin/cli/index.js

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+import { resolve } from 'node:path';
+import * as process from 'node:process';
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+import { VERSION } from '../../src/constants.js';
+import { AppError } from '../../src/helpers/error.js';
+import { getIsDirectoryExists } from '../../src/helpers/getIsDirectoryExists.js';
+import { LAST_TEMPLATE_VERSION } from '../../src/templates/templates.js';
+import { updateAction } from './actions/updateAction.js';
+import { printCliError } from './helpers/printCliError.js';
+const app = yargs(hideBin(process.argv))
+    .strict()
+    .demandCommand(1, 'Command was not specified')
+    .showHelpOnFail(false)
+    .version(VERSION)
+    .fail((msg, err) => {
+    if (err) {
+        printCliError(err);
+        process.exit(1);
+    }
+    printCliError(new AppError(msg || 'Invalid command.'));
+    app.showHelp('error');
+    process.exit(1);
+});
+app
+    .command('update', 'Update managed template parts in an existing generated project.', (y) => y
+    .option('path', {
+    alias: 'p',
+    default: '.',
+    description: 'Path to the extension project',
+    type: 'string',
+})
+    .option('dryRun', {
+    alias: 'd',
+    default: false,
+    description: 'Dry run update',
+    type: 'boolean',
+})
+    .option('templateVersion', {
+    alias: 't',
+    description: 'Template version',
+    hidden: true,
+    type: 'number',
+}), async (argv) => {
+    const isDryRun = argv.dryRun;
+    const projectDir = resolve(process.cwd(), argv.path);
+    const templateVersion = argv.templateVersion || LAST_TEMPLATE_VERSION;
+    const { error: projectPathError, isExists: isProjectPathExists } = getIsDirectoryExists(projectDir);
+    if (!isProjectPathExists) {
+        throw new AppError(projectPathError);
+    }
+    try {
+        await updateAction({
+            projectDir: resolve(process.cwd(), argv.path),
+            isDryRun,
+            templateVersion,
+        });
+    }
+    catch (err) {
+        console.log('\nUnable to update this project template automatically.\n' +
+            'The project version is too old or has changed significantly from the generated template.\n' +
+            'Please create a new project with the latest template and then move your custom files into it.\n');
+        throw err;
+    }
+});
+void app.parseAsync().catch((err) => {
+    printCliError(err);
+    process.exit(1);
+});

package/dist/bin/create.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin/create.js

@@ -0,0 +1,238 @@
+#!/usr/bin/env node
+import { checkbox, input, select } from '@inquirer/prompts';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { parseArgs } from 'node:util';
+import packageJson from '../package.json' with { type: 'json' };
+import { CATEGORIES, CATEGORY_LABELS, FRAMEWORK_LABELS, FRAMEWORKS, LANGUAGE_LABELS, LANGUAGES, SLOT_RULES_BY_CATEGORY, SLOT_LABELS, EXT_HELPER_VERSION, CLI_COMMANDS_MAP, } from '../src/constants.js';
+import { AppError } from '../src/helpers/error.js';
+import { buildProjectConfig } from '../src/projectConfig/buildProjectConfig.js';
+import { detectPackageManagerRuntime } from '../src/projectConfig/detectPackageManagerRuntime.js';
+import { executeCommands } from '../src/templater/executor.js';
+import { mapProjectConfigToTemplateData } from '../src/templater/mappers/mapProjectConfigToTemplateModel.js';
+import { planProject } from '../src/templater/planner.js';
+import { MANAGED_TEMPLATES } from '../src/templates/constants.js';
+import { LAST_TEMPLATE_VERSION, TEMPLATES_DIR } from '../src/templates/templates.js';
+import { getIsValidCategory } from '../src/validators/getIsValidCategory.js';
+import { getIsValidFramework } from '../src/validators/getIsValidFramework.js';
+import { getIsValidLanguage } from '../src/validators/getIsValidLanguage.js';
+import { validateName } from '../src/validators/validateName.js';
+import { validateSlots } from '../src/validators/validateSlots.js';
+const HELP = `
+Usage: create-stripchat-extension [options]
+
+Create a new Stripchat extension project.
+
+Options:
+  --name <name>           Project name (used as a directory and package name)
+  --category <category>   Extension category (${CATEGORIES.join(', ')})
+  --slots <items>         Comma-separated slots (e.g. "EXTENSION_SLOT_MAIN_GAME_FUN,EXTENSION_SLOT_RIGHT_OVERLAY") or empty string
+  --framework <framework> UI framework (${FRAMEWORKS.join(', ')})
+  --language <lang>       Language (${LANGUAGES.join(', ')})
+  -h, --help              Display this help message
+  -v, --version           Show version number
+`.trim();
+const parseCliArgs = () => {
+    try {
+        const { values } = parseArgs({
+            args: process.argv.slice(2),
+            options: {
+                category: { type: 'string' },
+                framework: { type: 'string' },
+                help: { short: 'h', type: 'boolean' },
+                language: { type: 'string' },
+                name: { type: 'string' },
+                slots: { type: 'string' },
+                version: { short: 'v', type: 'boolean' },
+                templateVersion: { short: 't', type: 'string' },
+            },
+            strict: true,
+        });
+        return values;
+    }
+    catch (err) {
+        console.error(`Failed to parse arguments: ${err instanceof Error ? err.message : 'unknown error'}\n`);
+        console.log(HELP);
+        process.exit(1);
+    }
+};
+const resolveName = (flagValue) => {
+    if (flagValue) {
+        const result = validateName(flagValue);
+        if (result !== true) {
+            throw new AppError(result);
+        }
+        return Promise.resolve(flagValue.trim());
+    }
+    return input({
+        message: 'Project name:',
+        validate: validateName,
+    });
+};
+const resolveCategory = (flagValue) => {
+    if (flagValue) {
+        if (!getIsValidCategory(flagValue)) {
+            throw new AppError(`Invalid category "${flagValue}". Choose one of: ${CATEGORIES.join(', ')}`);
+        }
+        return Promise.resolve(flagValue);
+    }
+    return select({
+        choices: CATEGORIES.map((cat) => ({
+            name: CATEGORY_LABELS[cat],
+            value: cat,
+        })),
+        message: 'Extension category:',
+    });
+};
+const composeSlotsValidationErrorMessage = (invalid, violations, optional) => {
+    const errorMsgs = [];
+    if (invalid.length > 0) {
+        if (optional.length === 0) {
+            errorMsgs.push(`Invalid slot(s): "${invalid.join(', ')}". This category doesn't have optional slots.`);
+        }
+        else {
+            errorMsgs.push(`Invalid slot(s) "${invalid.join(', ')}". Choose from: ${optional.join(', ')}.`);
+        }
+    }
+    if (violations.length > 0) {
+        errorMsgs.push(violations.join(' '));
+    }
+    return errorMsgs.join(' ');
+};
+const validateCheckboxSlotsSelection = (category, slots) => {
+    const rules = SLOT_RULES_BY_CATEGORY[category];
+    const { invalid, violations } = validateSlots(slots, category);
+    if (invalid.length || violations.length) {
+        return composeSlotsValidationErrorMessage(invalid, violations, rules.optional);
+    }
+    return undefined;
+};
+const normalizePromptSlots = (value) => value.flatMap((item) => {
+    if (typeof item === 'string') {
+        return [item];
+    }
+    if (typeof item === 'object' && item !== null && 'value' in item && typeof item.value === 'string') {
+        return [item.value];
+    }
+    return [];
+});
+const resolveSlots = async (flagValue, category) => {
+    const requiredSlots = [...SLOT_RULES_BY_CATEGORY[category].requiredBase];
+    const optionalSlots = [...SLOT_RULES_BY_CATEGORY[category].optional];
+    if (flagValue !== undefined) {
+        const requestedSlots = flagValue.split(',').map((s) => s.trim()).filter(s => !!s);
+        const { invalid, selected: selectedSlots, violations } = validateSlots([...requiredSlots, ...requestedSlots], category);
+        if (violations.length || invalid.length) {
+            throw new AppError(composeSlotsValidationErrorMessage(invalid, violations, optionalSlots));
+        }
+        return [...requiredSlots, ...selectedSlots];
+    }
+    if (!optionalSlots.length) {
+        return requiredSlots;
+    }
+    const selectedSlots = await checkbox({
+        choices: optionalSlots.map((slot) => ({
+            checked: false,
+            name: SLOT_LABELS[slot],
+            value: slot,
+        })),
+        message: 'Select optional slots:',
+        required: false,
+        validate: (value) => validateCheckboxSlotsSelection(category, [...requiredSlots, ...normalizePromptSlots(value)]) ?? true,
+    });
+    return [...requiredSlots, ...selectedSlots];
+};
+const resolveFramework = (flagValue, category) => {
+    if (category === 'chat-bots') {
+        return Promise.resolve('vanilla');
+    }
+    if (flagValue) {
+        if (!getIsValidFramework(flagValue)) {
+            throw new AppError(`Invalid framework "${flagValue}". Choose one of: ${FRAMEWORKS.join(', ')}`);
+        }
+        return Promise.resolve(flagValue);
+    }
+    return select({
+        choices: FRAMEWORKS.map((framework) => ({
+            name: FRAMEWORK_LABELS[framework],
+            value: framework,
+        })),
+        message: 'UI framework:',
+    });
+};
+const resolveLanguage = (flagValue) => {
+    if (flagValue) {
+        if (!getIsValidLanguage(flagValue)) {
+            throw new AppError(`Invalid language "${flagValue}". Choose one of: ${LANGUAGES.join(', ')}`);
+        }
+        return Promise.resolve(flagValue);
+    }
+    return select({
+        choices: LANGUAGES.map((lang) => ({
+            name: LANGUAGE_LABELS[lang],
+            value: lang,
+        })),
+        message: 'Language:',
+    });
+};
+const resolveProjectDir = (projectName) => {
+    const dir = join(process.cwd(), projectName);
+    if (existsSync(dir)) {
+        throw new AppError(`Project dir ${dir} already exists`);
+    }
+    return dir;
+};
+const resolveTemplateVersion = (flagValue) => {
+    let templateVersion = Number(flagValue);
+    if (!templateVersion || !isFinite(templateVersion)) {
+        templateVersion = LAST_TEMPLATE_VERSION;
+    }
+    return templateVersion;
+};
+const main = async () => {
+    const opts = parseCliArgs();
+    if (opts.help) {
+        console.log(HELP);
+        process.exit(0);
+    }
+    if (opts.version) {
+        console.log(packageJson.version);
+        process.exit(0);
+    }
+    const name = await resolveName(opts.name);
+    const category = await resolveCategory(opts.category);
+    const slots = await resolveSlots(opts.slots, category);
+    const framework = await resolveFramework(opts.framework, category);
+    const language = await resolveLanguage(opts.language);
+    const projectDir = resolveProjectDir(name);
+    const templateVersion = resolveTemplateVersion(opts.templateVersion);
+    console.log(`\nCreating project in ./${name}...\n`);
+    const projectConfig = buildProjectConfig({
+        name,
+        category,
+        slots,
+        framework,
+        language,
+        packageManager: detectPackageManagerRuntime(),
+        extHelperVersion: EXT_HELPER_VERSION,
+        lastTemplateVersion: templateVersion,
+        cliCommands: CLI_COMMANDS_MAP,
+        managedTemplates: MANAGED_TEMPLATES,
+        templatesDir: TEMPLATES_DIR,
+    });
+    const templateData = mapProjectConfigToTemplateData(projectConfig);
+    const commands = planProject(projectDir, templateVersion, templateData);
+    executeCommands(commands, (command) => console.log(`  Created ${command.destPath}`));
+    console.log('\nDone! Next steps:\n');
+    console.log(`  cd ${name}`);
+    console.log(`  ${templateData.packageManagerCommands.install}`);
+    console.log(`  ${templateData.packageManagerCommands.dev}\n`);
+};
+main().catch((err) => {
+    if (err.name === 'ExitPromptError') {
+        console.log('\nAborted.');
+        process.exit(0);
+    }
+    console.error(err);
+    process.exit(1);
+});

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stripchatdev/create-stripchat-extension",
-    "version": "0.1.46",
+    "version": "0.1.47",
     "type": "module",
     "files": [
         "dist",
@@ -22,7 +22,10 @@
     "preferUnplugged": true,
     "dependencies": {
         "@inquirer/prompts": "8.3.2",
-        "ejs": "3.1.10"
+        "diff": "9.0.0",
+        "ejs": "3.1.10",
+        "ts-morph": "28.0.0",
+        "type-fest": "5.8.0"
     },
     "devDependencies": {
         "@types/ejs": "3.1.5",

package/dist/src/constants.d.ts

@@ -1,19 +1,24 @@
-import type { TCategory, TCategorySlotRules, TPackageManager, TSlot } from './types.js';
+import type { TCategory, TCategorySlotRules, TPackageManager, TPackageManagerCommands, TSlot } from './types';
+export declare const VERSION: string;
 export declare const EXT_HELPER_VERSION: string;
-export declare const CATEGORIES: TCategory[];
+export declare const CATEGORIES: readonly ["games-and-fun", "sex-toys", "chat-bots", "broadcast-tools"];
 export declare const CATEGORY_LABELS: Record<TCategory, string>;
+export declare const SLOTS: readonly ["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 declare const SLOT_RULES_BY_CATEGORY: Record<TCategory, TCategorySlotRules>;
-export declare const REQUIRED_SLOTS_BY_CATEGORY: Record<TCategory, TSlot[]>;
-export declare const SELECTABLE_SLOTS_BY_CATEGORY: Record<TCategory, TSlot[]>;
 export declare const SLOT_LABELS: Record<TSlot, string>;
 export declare const FRAMEWORKS: readonly ["preact", "vanilla"];
 export declare const FRAMEWORK_LABELS: Record<(typeof FRAMEWORKS)[number], string>;
 export declare const LANGUAGES: readonly ["ts", "js"];
 export declare const LANGUAGE_LABELS: Record<(typeof LANGUAGES)[number], string>;
 export declare const JSX_FRAMEWORKS: string[];
-export declare const PACKAGE_MANAGER_COMMANDS_MAP: Record<TPackageManager, {
-    build: string;
-    dev: string;
-    install: string;
-}>;
+export declare const PACKAGE_MANAGERS: readonly ["npm", "yarn", "pnpm", "bun"];
+export declare const PACKAGE_MANAGER_LOCK_FILE_MAP: Record<TPackageManager, string>;
+export declare const PACKAGE_MANAGER_COMMANDS_MAP: Record<TPackageManager, TPackageManagerCommands>;
+export declare const CLI_COMMANDS_MAP: Record<string, string>;
 export declare const TS_ONLY_FILES: string[];
+export declare const PROJECT_CONFIG_REL_PATH = ".project-config.json";
+export declare const AGENTS_MD_REL_PATH = "AGENTS.md";
+export declare const PACKAGE_JSON_REL_PATH = "package.json";
+export declare const VITE_CONFIG_REL_PATH_BY_LANGUAGE: Record<(typeof LANGUAGES)[number], string>;
+export declare const AGENTS_TEMPLATE_START = "<!-- AUTO-GENERATED SECTION START -->";
+export declare const AGENTS_TEMPLATE_END = "<!-- AUTO-GENERATED SECTION END -->";

package/dist/src/constants.js

@@ -1,5 +1,5 @@
-// All packages use the same versioning
-import packageJson from '../package.json' with { type: 'json' };
+import packageJson from '../package.json';
+export const VERSION = packageJson.version;
 export const EXT_HELPER_VERSION = packageJson.version;
 export const CATEGORIES = ['games-and-fun', 'sex-toys', 'chat-bots', 'broadcast-tools'];
 export const CATEGORY_LABELS = {
@@ -8,6 +8,14 @@ export const CATEGORY_LABELS = {
     'chat-bots': 'Chat Bots',
     'broadcast-tools': 'Broadcast Tools',
 };
+export const SLOTS = [
+    '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 const SLOT_RULES_BY_CATEGORY = {
     'games-and-fun': {
         groups: [
@@ -44,8 +52,6 @@ export const SLOT_RULES_BY_CATEGORY = {
         requiredBase: ['EXTENSION_SLOT_BACKGROUND'],
     },
 };
-export const REQUIRED_SLOTS_BY_CATEGORY = Object.fromEntries(Object.entries(SLOT_RULES_BY_CATEGORY).map(([category, rules]) => [category, rules.requiredBase]));
-export const SELECTABLE_SLOTS_BY_CATEGORY = Object.fromEntries(Object.entries(SLOT_RULES_BY_CATEGORY).map(([category, rules]) => [category, rules.optional]));
 export const SLOT_LABELS = {
     EXTENSION_SLOT_BACKGROUND: 'background',
     EXTENSION_SLOT_MAIN_GAME_FUN: 'mainGameFun',
@@ -65,10 +71,49 @@ export const LANGUAGE_LABELS = {
     ts: 'TypeScript (Recommended)',
 };
 export const JSX_FRAMEWORKS = ['preact'];
+export const PACKAGE_MANAGERS = ['npm', 'yarn', 'pnpm', 'bun'];
+export const PACKAGE_MANAGER_LOCK_FILE_MAP = {
+    'npm': 'package-lock.json',
+    'yarn': 'yarn.lock',
+    'pnpm': 'pnpm-lock.yaml',
+    'bun': 'bun.lock',
+};
 export const PACKAGE_MANAGER_COMMANDS_MAP = {
-    npm: { build: 'npm run build', dev: 'npm run dev', install: 'npm install' },
-    yarn: { build: 'yarn build', dev: 'yarn dev', install: 'yarn' },
-    pnpm: { build: 'pnpm build', dev: 'pnpm dev', install: 'pnpm install' },
-    bun: { build: 'bun run build', dev: 'bun dev', install: 'bun install' },
+    npm: {
+        build: 'npm run build',
+        dev: 'npm run dev',
+        install: 'npm install',
+        templateUpdate: 'npm run template:update',
+    },
+    yarn: {
+        build: 'yarn build',
+        dev: 'yarn dev',
+        install: 'yarn',
+        templateUpdate: 'npm run template:update',
+    },
+    pnpm: {
+        build: 'pnpm build',
+        dev: 'pnpm dev',
+        install: 'pnpm install',
+        templateUpdate: 'npm run template:update',
+    },
+    bun: {
+        build: 'bun run build',
+        dev: 'bun dev',
+        install: 'bun install',
+        templateUpdate: 'npm run template:update',
+    },
+};
+export const CLI_COMMANDS_MAP = {
+    'template:update': `npm exec --package=@stripchatdev/create-stripchat-extension@${packageJson.version} -- cli update`,
 };
 export const TS_ONLY_FILES = ['tsconfig.json'];
+export const PROJECT_CONFIG_REL_PATH = '.project-config.json';
+export const AGENTS_MD_REL_PATH = 'AGENTS.md';
+export const PACKAGE_JSON_REL_PATH = 'package.json';
+export const VITE_CONFIG_REL_PATH_BY_LANGUAGE = {
+    js: 'vite.config.js',
+    ts: 'vite.config.ts',
+};
+export const AGENTS_TEMPLATE_START = '<!-- AUTO-GENERATED SECTION START -->';
+export const AGENTS_TEMPLATE_END = '<!-- AUTO-GENERATED SECTION END -->';

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

@@ -0,0 +1,2 @@
+export declare const DEPENDENCIES: Record<string, string>;
+export declare const DEV_DEPENDENCIES: Record<string, string>;

package/dist/src/dependencies/constants.js

@@ -0,0 +1,11 @@
+import packageJson from '../../package.json' with { type: 'json' };
+export const DEPENDENCIES = {
+    '@stripchatdev/ext-helper': packageJson.version,
+    'preact': '10.25.4',
+};
+export const DEV_DEPENDENCIES = {
+    'vite': '6.4.2',
+    'typescript': '5.8.2',
+    '@preact/preset-vite': '2.10.5',
+    '@stripchatdev/create-stripchat-extension': packageJson.version,
+};

package/dist/src/dependencies/resolveDependencies.d.ts

@@ -0,0 +1,6 @@
+import type { TFramework, TLanguage, TPackageDependenciesMap } from '../types.js';
+export declare const resolveMainDependencies: (framework: TFramework) => TPackageDependenciesMap;
+export declare const resolveDependencies: (language: TLanguage, framework: TFramework) => {
+    dependencies: TPackageDependenciesMap;
+    devDependencies: TPackageDependenciesMap;
+};

package/dist/src/dependencies/resolveDependencies.js

@@ -0,0 +1,43 @@
+import { getIsJsxFramework } from '../helpers/getIsJsxFramework.js';
+import { getIsTypescript } from '../helpers/getIsTypescript.js';
+import { DEPENDENCIES, DEV_DEPENDENCIES } from './constants.js';
+export const resolveMainDependencies = (framework) => {
+    const depsMap = {};
+    const isJsx = getIsJsxFramework(framework);
+    for (const packageName in DEPENDENCIES) {
+        const packageVersion = DEPENDENCIES[packageName];
+        if (!packageVersion) {
+            continue;
+        }
+        if (packageName === 'preact' && !isJsx) {
+            continue;
+        }
+        depsMap[packageName] = packageVersion;
+    }
+    return depsMap;
+};
+const resolveDevDependencies = (language, framework) => {
+    const depsMap = {};
+    const isTypescript = getIsTypescript(language);
+    const isJsx = getIsJsxFramework(framework);
+    for (const packageName in DEV_DEPENDENCIES) {
+        const packageVersion = DEV_DEPENDENCIES[packageName];
+        if (!packageVersion) {
+            continue;
+        }
+        if (packageName === 'typescript' && !isTypescript) {
+            continue;
+        }
+        if (packageName === '@preact/preset-vite' && !isJsx) {
+            continue;
+        }
+        depsMap[packageName] = packageVersion;
+    }
+    return depsMap;
+};
+export const resolveDependencies = (language, framework) => {
+    return {
+        dependencies: resolveMainDependencies(framework),
+        devDependencies: resolveDevDependencies(language, framework),
+    };
+};

package/dist/src/dependencies/resolveDependencies.test.js

@@ -0,0 +1,74 @@
+import { describe, it, expect } from 'vitest';
+import { DEPENDENCIES, DEV_DEPENDENCIES } from './constants.js';
+import { resolveDependencies } from './resolveDependencies.js';
+const EXPECTED_EXT_HELPER = DEPENDENCIES['@stripchatdev/ext-helper'];
+const EXPECTED_VITE = DEV_DEPENDENCIES.vite;
+const EXPECTED_TYPESCRIPT = DEV_DEPENDENCIES.typescript;
+const EXPECTED_PREACT = DEPENDENCIES.preact;
+const EXPECTED_PREACT_PRESET_VITE = DEV_DEPENDENCIES['@preact/preset-vite'];
+const EXPECTED_CREATE_STRIPCHAT_EXTENSION = DEV_DEPENDENCIES['@stripchatdev/create-stripchat-extension'];
+const TEST_CASES = [
+    {
+        framework: 'vanilla',
+        language: 'js',
+        expected: {
+            dependencies: {
+                '@stripchatdev/ext-helper': EXPECTED_EXT_HELPER,
+            },
+            devDependencies: {
+                vite: EXPECTED_VITE,
+                '@stripchatdev/create-stripchat-extension': EXPECTED_CREATE_STRIPCHAT_EXTENSION,
+            },
+        },
+    },
+    {
+        framework: 'vanilla',
+        language: 'ts',
+        expected: {
+            dependencies: {
+                '@stripchatdev/ext-helper': EXPECTED_EXT_HELPER,
+            },
+            devDependencies: {
+                typescript: EXPECTED_TYPESCRIPT,
+                vite: EXPECTED_VITE,
+                '@stripchatdev/create-stripchat-extension': EXPECTED_CREATE_STRIPCHAT_EXTENSION,
+            },
+        },
+    },
+    {
+        framework: 'preact',
+        language: 'js',
+        expected: {
+            dependencies: {
+                '@stripchatdev/ext-helper': EXPECTED_EXT_HELPER,
+                preact: EXPECTED_PREACT,
+            },
+            devDependencies: {
+                '@preact/preset-vite': EXPECTED_PREACT_PRESET_VITE,
+                vite: EXPECTED_VITE,
+                '@stripchatdev/create-stripchat-extension': EXPECTED_CREATE_STRIPCHAT_EXTENSION,
+            },
+        },
+    },
+    {
+        framework: 'preact',
+        language: 'ts',
+        expected: {
+            dependencies: {
+                '@stripchatdev/ext-helper': EXPECTED_EXT_HELPER,
+                preact: EXPECTED_PREACT,
+            },
+            devDependencies: {
+                '@preact/preset-vite': EXPECTED_PREACT_PRESET_VITE,
+                typescript: EXPECTED_TYPESCRIPT,
+                vite: EXPECTED_VITE,
+                '@stripchatdev/create-stripchat-extension': EXPECTED_CREATE_STRIPCHAT_EXTENSION,
+            },
+        },
+    },
+];
+describe('resolveDependencies', () => {
+    it.each(TEST_CASES)('$language + $framework dependencies', ({ expected, framework, language }) => {
+        expect(resolveDependencies(language, framework)).toEqual(expected);
+    });
+});

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

@@ -0,0 +1,3 @@
+export declare class AppError extends Error {
+    constructor(message: string, cause?: Error);
+}