@stripchatdev/create-stripchat-extension 0.1.7

package/README.md

@@ -0,0 +1,35 @@
+# create-stripchat-extension
+
+CLI tool for creating new Stripchat extension projects.
+
+The generated project includes a Vite build setup, extension manifest, slot entry points, and a `resolveSlotPage` resolver -- everything needed to start developing and building an extension. [Read the docs to learn more](https://extensions.stripchat.com/docs/).
+
+## Quick start
+
+With NPM:
+```bash
+npm create @stripchatdev/stripchat-extension
+```
+
+With Yarn:
+```bash
+yarn dlx @stripchatdev/create-stripchat-extension
+```
+
+With PNPM:
+```bash
+pnpm create @stripchatdev/stripchat-extension
+```
+
+With Bun:
+```bash
+bun create @stripchatdev/stripchat-extension
+```
+
+Then follow the prompts to set up your new extension project.
+
+You can also provide options directly via CLI arguments. For example:
+```bash
+npm create @stripchatdev/stripchat-extension -- --name=my-extension --category=games-and-fun
+```
+

package/dist/bin/cli.d.ts

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

package/dist/bin/cli.js

@@ -0,0 +1,176 @@
+#!/usr/bin/env node
+import { checkbox, input, select } from '@inquirer/prompts';
+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, REQUIRED_SLOTS_BY_CATEGORY, SELECTABLE_SLOTS_BY_CATEGORY, SLOT_LABELS, } from '../src/constants.js';
+import { executeCommands } from '../src/executor.js';
+import { detectPackageManager } from '../src/helpers/detectPackageManager.js';
+import { mapProjectConfigToTemplateData } from '../src/mappers/mapProjectConfigToTemplateModel.js';
+import { planProject } from '../src/planner.js';
+import { isValidCategory, isValidFramework, isValidLanguage, validateName, validateProjectDir, validateSlots, } from '../src/validators/index.js';
+const HELP = `
+Usage: create-stripchat-extension [options]
+
+Create a new Stripchat extension project.
+
+Options:
+  --name <name>           Project name (used as directory and package name)
+  --category <category>   Extension category (${CATEGORIES.join(', ')})
+  --slots <items>         Comma-separated slots (e.g. "mainGameFun,rightOverlay") 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 PACKAGE_MANAGER = detectPackageManager();
+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' },
+            },
+            strict: true,
+        });
+        return values;
+    }
+    catch (err) {
+        console.error(`Error: ${err.message}\n`);
+        console.log(HELP);
+        process.exit(1);
+    }
+};
+const resolveName = (flagValue) => {
+    if (flagValue) {
+        const result = validateName(flagValue);
+        if (result !== true) {
+            console.error(`Error: ${result}`);
+            process.exit(1);
+        }
+        return Promise.resolve(flagValue.trim());
+    }
+    return input({
+        message: 'Project name:',
+        validate: validateName,
+    });
+};
+const resolveCategory = (flagValue) => {
+    if (flagValue) {
+        if (!isValidCategory(flagValue)) {
+            console.error(`Error: invalid category "${flagValue}". Choose one of: ${CATEGORIES.join(', ')}`);
+            process.exit(1);
+        }
+        return Promise.resolve(flagValue);
+    }
+    return select({
+        choices: CATEGORIES.map((cat) => ({
+            name: CATEGORY_LABELS[cat],
+            value: cat,
+        })),
+        message: 'Extension category:',
+    });
+};
+const resolveSlots = (flagValue, category) => {
+    const selectable = SELECTABLE_SLOTS_BY_CATEGORY[category];
+    if (flagValue !== undefined) {
+        const requested = flagValue.split(',').map((s) => s.trim());
+        if (flagValue === '')
+            return Promise.resolve([]);
+        const { invalid, valid } = validateSlots(requested, category);
+        if (invalid.length) {
+            console.error(`Error: invalid slot(s) "${invalid.join(', ')}". Choose from: ${selectable.join(', ')}`);
+            process.exit(1);
+        }
+        return Promise.resolve(valid);
+    }
+    return checkbox({
+        choices: selectable.map((slot) => ({
+            checked: true,
+            name: SLOT_LABELS[slot],
+            value: slot,
+        })),
+        message: 'Select optional slots:',
+        required: false,
+    });
+};
+const resolveFramework = (flagValue) => {
+    if (flagValue) {
+        if (!isValidFramework(flagValue)) {
+            console.error(`Error: invalid framework "${flagValue}". Choose one of: ${FRAMEWORKS.join(', ')}`);
+            process.exit(1);
+        }
+        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 (!isValidLanguage(flagValue)) {
+            console.error(`Error: invalid language "${flagValue}". Choose one of: ${LANGUAGES.join(', ')}`);
+            process.exit(1);
+        }
+        return Promise.resolve(flagValue);
+    }
+    return select({
+        choices: LANGUAGES.map((lang) => ({
+            name: LANGUAGE_LABELS[lang],
+            value: lang,
+        })),
+        message: 'Language:',
+    });
+};
+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 selectedSlots = await resolveSlots(opts.slots, category);
+    const framework = await resolveFramework(opts.framework);
+    const language = await resolveLanguage(opts.language);
+    const slots = [...selectedSlots, ...REQUIRED_SLOTS_BY_CATEGORY[category]];
+    const projectDir = join(process.cwd(), name);
+    validateProjectDir(projectDir, name);
+    console.log(`\nCreating project in ./${name}...\n`);
+    const data = mapProjectConfigToTemplateData({
+        category,
+        framework,
+        language,
+        name,
+        packageManager: PACKAGE_MANAGER,
+        slots,
+    });
+    const commands = await planProject(data, projectDir);
+    await executeCommands(commands, (command) => console.log(`  Created ${command.destPath}`));
+    console.log('\nDone! Next steps:\n');
+    console.log(`  cd ${name}`);
+    console.log(`  ${data.packageManagerCommands.install}`);
+    console.log(`  ${data.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

@@ -0,0 +1,28 @@
+{
+    "name": "@stripchatdev/create-stripchat-extension",
+    "version": "0.1.7",
+    "type": "module",
+    "files": [
+        "dist",
+        "templates"
+    ],
+    "bin": {
+        "create-stripchat-extension": "./dist/bin/cli.js"
+    },
+    "scripts": {
+        "build": "tsc -b --force",
+        "dev": "tsc -b --watch",
+        "create:temp": "rm -rf ./temp && node ./dist/bin/cli.js --name=temp",
+        "test": "vitest run",
+        "test:watch": "vitest"
+    },
+    "preferUnplugged": true,
+    "dependencies": {
+        "@inquirer/prompts": "8.3.2",
+        "ejs": "3.1.10"
+    },
+    "devDependencies": {
+        "@types/ejs": "3.1.5",
+        "vitest": "4.1.2"
+    }
+}

package/dist/src/constants.d.ts

@@ -0,0 +1,19 @@
+import type { TCategory, TPackageManager, TSlot } from './types.js';
+export declare const EXT_HELPER_VERSION: string;
+export declare const CATEGORIES: TCategory[];
+export declare const CATEGORY_LABELS: Record<TCategory, string>;
+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 SLOT_TYPES: Record<TSlot, string>;
+export declare const FRAMEWORKS: readonly ["vanilla", "preact"];
+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 TS_ONLY_FILES: string[];

package/dist/src/constants.js

@@ -0,0 +1,48 @@
+import packageJson from '../package.json' with { type: 'json' };
+// All packages use the same versioning
+export const EXT_HELPER_VERSION = packageJson.version;
+export const CATEGORIES = ['games-and-fun', 'sex-toys'];
+export const CATEGORY_LABELS = {
+    'games-and-fun': 'Games & Fun',
+    'sex-toys': 'Sex Toys',
+};
+export const REQUIRED_SLOTS_BY_CATEGORY = {
+    'games-and-fun': ['mainGameFun', 'background', 'rightOverlay'],
+    'sex-toys': ['mainSexToy', 'background', 'moveableOverlay'],
+};
+export const SELECTABLE_SLOTS_BY_CATEGORY = {
+    'games-and-fun': ['moveableOverlay'],
+    'sex-toys': ['rightOverlay'],
+};
+export const SLOT_LABELS = {
+    background: 'background',
+    mainGameFun: 'mainGameFun',
+    mainSexToy: 'mainSexToy',
+    moveableOverlay: 'moveableOverlay',
+    rightOverlay: 'rightOverlay',
+};
+export const SLOT_TYPES = {
+    background: 'EXTENSION_SLOT_BACKGROUND',
+    mainGameFun: 'EXTENSION_SLOT_MAIN_GAME_FUN',
+    mainSexToy: 'EXTENSION_SLOT_MAIN_SEX_TOY',
+    moveableOverlay: 'EXTENSION_SLOT_MOVEABLE_OVERLAY',
+    rightOverlay: 'EXTENSION_SLOT_RIGHT_OVERLAY',
+};
+export const FRAMEWORKS = ['vanilla', 'preact'];
+export const FRAMEWORK_LABELS = {
+    preact: 'Preact',
+    vanilla: 'Vanilla',
+};
+export const LANGUAGES = ['ts', 'js'];
+export const LANGUAGE_LABELS = {
+    js: 'JavaScript',
+    ts: 'TypeScript',
+};
+export const JSX_FRAMEWORKS = ['preact'];
+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' },
+};
+export const TS_ONLY_FILES = ['tsconfig.json'];

package/dist/src/executor.d.ts

@@ -0,0 +1,2 @@
+import type { TTemplateCommand } from './types.js';
+export declare const executeCommands: (commands: TTemplateCommand[], cb?: (command: TTemplateCommand) => void) => Promise<void>;

package/dist/src/executor.js

@@ -0,0 +1,22 @@
+import ejs from 'ejs';
+import { copyFile, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
+const renderTemplate = async (templatePath, data) => {
+    const template = await readFile(templatePath, 'utf-8');
+    return ejs.render(template, data, { filename: templatePath });
+};
+export const executeCommands = async (commands, cb) => {
+    for (const command of commands) {
+        await mkdir(dirname(command.destPath), { recursive: true });
+        cb?.(command);
+        if (command.type === 'render') {
+            const content = await renderTemplate(command.srcPath, command.data);
+            await writeFile(command.destPath, content, 'utf-8');
+            continue;
+        }
+        if (command.type === 'copy') {
+            await copyFile(command.srcPath, command.destPath);
+            continue;
+        }
+    }
+};

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

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

package/dist/src/executor.test.js

@@ -0,0 +1,77 @@
+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 { executeCommands } from './executor.js';
+import { mapProjectConfigToTemplateData } from './mappers/mapProjectConfigToTemplateModel.js';
+import { planProject } from './planner.js';
+const EJS_TAG_PATTERN = /<%/;
+const rewriteDestPaths = (commands, destDir) => commands.map((cmd) => {
+    const destPath = join(destDir, cmd.destPath.replace(/^.*?\/my-ext\//, ''));
+    if (cmd.type === 'copy') {
+        return { ...cmd, destPath };
+    }
+    return { ...cmd, destPath };
+});
+const buildCommands = async (config, destDir) => {
+    const data = mapProjectConfigToTemplateData(config);
+    const commands = await planProject(data, '/output/my-ext');
+    return rewriteDestPaths(commands, destDir);
+};
+describe('executeCommands', () => {
+    let tmpDir;
+    beforeEach(async () => {
+        tmpDir = await mkdtemp(join(tmpdir(), 'executor-test-'));
+    });
+    afterEach(async () => {
+        await rm(tmpDir, { recursive: true });
+    });
+    it('renders EJS templates into destination files', async () => {
+        const config = {
+            category: 'games-and-fun',
+            framework: 'vanilla',
+            language: 'ts',
+            name: 'my-ext',
+            packageManager: 'npm',
+            slots: ['mainGameFun', 'background'],
+        };
+        const commands = await buildCommands(config, tmpDir);
+        const cb = vi.fn();
+        await executeCommands(commands, cb);
+        for (const command of commands) {
+            if (command.type === 'render') {
+                const content = await readFile(command.destPath, 'utf-8');
+                expect(content.length).toBeGreaterThan(0);
+                expect(content).not.toMatch(EJS_TAG_PATTERN);
+                continue;
+            }
+            if (command.type === 'copy') {
+                const [src, dest] = await Promise.all([
+                    readFile(command.srcPath),
+                    readFile(command.destPath),
+                ]);
+                expect(dest.equals(src)).toBe(true);
+                continue;
+            }
+        }
+        expect(cb).toHaveBeenCalledTimes(commands.length);
+    });
+    it('rejects with ENOENT when a source template is missing', async () => {
+        const config = {
+            category: 'sex-toys',
+            framework: 'vanilla',
+            language: 'js',
+            name: 'my-ext',
+            packageManager: 'npm',
+            slots: ['mainSexToy', 'background'],
+        };
+        const commands = await buildCommands(config, 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/);
+    });
+});

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

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

package/dist/src/helpers/detectPackageManager.js

@@ -0,0 +1,12 @@
+export const detectPackageManager = () => {
+    if ('Bun' in globalThis || process?.versions?.bun)
+        return 'bun';
+    const ua = process.env.npm_config_user_agent;
+    if (ua?.includes('bun'))
+        return 'bun';
+    if (ua?.includes('pnpm'))
+        return 'pnpm';
+    if (ua?.includes('yarn'))
+        return 'yarn';
+    return 'npm';
+};

package/dist/src/helpers/detectPackageManager.test.d.ts

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

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

@@ -0,0 +1,47 @@
+/* eslint-disable camelcase */
+import { afterEach, describe, expect, it } from 'vitest';
+import { detectPackageManager } from './detectPackageManager.js';
+describe('detectPackageManager', () => {
+    const originalEnv = process.env.npm_config_user_agent;
+    afterEach(() => {
+        process.env.npm_config_user_agent = originalEnv;
+        // @ts-expect-error -- cleaning up test-injected global
+        delete globalThis.Bun;
+    });
+    it('returns bun when globalThis.Bun exists', () => {
+        // @ts-expect-error -- simulating Bun runtime
+        globalThis.Bun = {};
+        process.env.npm_config_user_agent = 'pnpm/9.0.0';
+        expect(detectPackageManager()).toBe('bun');
+    });
+    it('returns bun when user agent contains bun', () => {
+        process.env.npm_config_user_agent = 'bun/1.2.0 node/v22.12.0';
+        expect(detectPackageManager()).toBe('bun');
+    });
+    it('returns pnpm when user agent contains pnpm', () => {
+        process.env.npm_config_user_agent = 'pnpm/9.0.0 node/v22.12.0';
+        expect(detectPackageManager()).toBe('pnpm');
+    });
+    it('returns yarn when user agent contains yarn', () => {
+        process.env.npm_config_user_agent = 'yarn/4.1.0 node/v22.12.0';
+        expect(detectPackageManager()).toBe('yarn');
+    });
+    it('returns npm when user agent contains npm', () => {
+        process.env.npm_config_user_agent = 'npm/10.9.0 node/v22.12.0';
+        expect(detectPackageManager()).toBe('npm');
+    });
+    it('returns npm when user agent is undefined', () => {
+        delete process.env.npm_config_user_agent;
+        expect(detectPackageManager()).toBe('npm');
+    });
+    it('prioritises bun over user agent', () => {
+        // @ts-expect-error -- simulating Bun runtime
+        globalThis.Bun = {};
+        process.env.npm_config_user_agent = 'yarn/4.1.0';
+        expect(detectPackageManager()).toBe('bun');
+    });
+    it('prioritises pnpm over yarn in user agent', () => {
+        process.env.npm_config_user_agent = 'pnpm/9.0.0 yarn/4.1.0';
+        expect(detectPackageManager()).toBe('pnpm');
+    });
+});

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

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

package/dist/src/helpers/isDirectory.js

@@ -0,0 +1,9 @@
+import { statSync } from 'node:fs';
+export const isDirectory = (pathValue) => {
+    try {
+        return statSync(pathValue).isDirectory();
+    }
+    catch {
+        return false;
+    }
+};

package/dist/src/helpers/isDirectory.test.d.ts

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

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

@@ -0,0 +1,22 @@
+import { describe, expect, it, vi } from 'vitest';
+import { isDirectory } from './isDirectory.js';
+vi.mock('node:fs', () => ({
+    statSync: (path) => {
+        if (path === '/exists/dir')
+            return { isDirectory: () => true };
+        if (path === '/exists/file')
+            return { isDirectory: () => false };
+        throw new Error('ENOENT');
+    },
+}));
+describe('isDirectory', () => {
+    it('returns true for an existing directory', () => {
+        expect(isDirectory('/exists/dir')).toBe(true);
+    });
+    it('returns false for an existing file', () => {
+        expect(isDirectory('/exists/file')).toBe(false);
+    });
+    it('returns false when path does not exist', () => {
+        expect(isDirectory('/does/not/exist')).toBe(false);
+    });
+});

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

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

package/dist/src/helpers/isTypescriptOnlyFile.js

@@ -0,0 +1,5 @@
+import { TS_ONLY_FILES } from '../constants.js';
+export const isTypescriptOnlyFile = (normalizedRelPath) => {
+    const withoutEjs = normalizedRelPath.replace(/\.ejs$/, '');
+    return TS_ONLY_FILES.includes(withoutEjs);
+};

package/dist/src/helpers/isTypescriptOnlyFile.test.d.ts

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

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

@@ -0,0 +1,22 @@
+import { describe, expect, it } from 'vitest';
+import { isTypescriptOnlyFile } from './isTypescriptOnlyFile.js';
+describe('isTypescriptOnlyFile', () => {
+    it('returns true for tsconfig.json', () => {
+        expect(isTypescriptOnlyFile('tsconfig.json')).toBe(true);
+    });
+    it('returns true for tsconfig.json.ejs (strips .ejs suffix)', () => {
+        expect(isTypescriptOnlyFile('tsconfig.json.ejs')).toBe(true);
+    });
+    it('returns false for package.json', () => {
+        expect(isTypescriptOnlyFile('package.json')).toBe(false);
+    });
+    it('returns false for package.json.ejs', () => {
+        expect(isTypescriptOnlyFile('package.json.ejs')).toBe(false);
+    });
+    it('returns false for vite.config.ts.ejs', () => {
+        expect(isTypescriptOnlyFile('vite.config.ts.ejs')).toBe(false);
+    });
+    it('returns false for an empty string', () => {
+        expect(isTypescriptOnlyFile('')).toBe(false);
+    });
+});

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

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

package/dist/src/helpers/normalizeRelPath.js

@@ -0,0 +1 @@
+export const normalizeRelPath = (pathValue) => pathValue.replaceAll('\\', '/');

package/dist/src/helpers/normalizeRelPath.test.d.ts

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

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

@@ -0,0 +1,19 @@
+import { describe, expect, it } from 'vitest';
+import { normalizeRelPath } from './normalizeRelPath.js';
+describe('normalizeRelPath', () => {
+    it('replaces backslashes with forward slashes', () => {
+        expect(normalizeRelPath('src\\slots\\main')).toBe('src/slots/main');
+    });
+    it('replaces multiple backslashes', () => {
+        expect(normalizeRelPath('a\\b\\c\\d')).toBe('a/b/c/d');
+    });
+    it('leaves forward slashes unchanged', () => {
+        expect(normalizeRelPath('src/slots/main')).toBe('src/slots/main');
+    });
+    it('handles mixed separators', () => {
+        expect(normalizeRelPath('src\\slots/main\\file.ts')).toBe('src/slots/main/file.ts');
+    });
+    it('returns empty string unchanged', () => {
+        expect(normalizeRelPath('')).toBe('');
+    });
+});

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

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

package/dist/src/helpers/resolveTemplateExtension.js

@@ -0,0 +1,17 @@
+const resolveOutputExtension = (templateExt, isTypescript) => {
+    const map = {
+        '.ts': isTypescript ? '.ts' : '.js',
+        '.tsx': isTypescript ? '.tsx' : '.jsx',
+    };
+    return map[templateExt] ?? templateExt;
+};
+export const resolveTemplateExtension = (normalizedRelPath, isTypescript) => {
+    const withoutEjs = normalizedRelPath.replace(/\.ejs$/, '');
+    const extMatch = withoutEjs.match(/\.(tsx?|jsx?)$/);
+    if (!extMatch) {
+        return withoutEjs;
+    }
+    const templateExt = extMatch[0];
+    const base = withoutEjs.slice(0, -templateExt.length);
+    return `${base}${resolveOutputExtension(templateExt, isTypescript)}`;
+};

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

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