genomic 4.0.2 → 5.0.1

package/template/extract.js

@@ -0,0 +1,198 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractVariables = extractVariables;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const PLACEHOLDER_BOUNDARY = '____';
+/**
+ * Pattern to match ____variable____ in filenames and content
+ */
+const VARIABLE_PATTERN = new RegExp(`${PLACEHOLDER_BOUNDARY}([A-Za-z_][A-Za-z0-9_]*)${PLACEHOLDER_BOUNDARY}`, 'g');
+/**
+ * Extract all variables from a template directory
+ * @param templateDir - Path to the template directory
+ * @returns Extracted variables including file replacers, content replacers, and project questions
+ */
+async function extractVariables(templateDir) {
+    const fileReplacers = [];
+    const contentReplacers = [];
+    const fileReplacerVars = new Set();
+    const contentReplacerVars = new Set();
+    const projectQuestions = await loadProjectQuestions(templateDir);
+    await walkDirectory(templateDir, async (filePath) => {
+        const relativePath = path.relative(templateDir, filePath);
+        // Skip boilerplate configuration files from variable extraction
+        if (relativePath === '.boilerplate.json' ||
+            relativePath === '.boilerplate.js' ||
+            relativePath === '.boilerplates.json') {
+            return;
+        }
+        const matches = relativePath.matchAll(VARIABLE_PATTERN);
+        for (const match of matches) {
+            const varName = match[1];
+            if (!fileReplacerVars.has(varName)) {
+                fileReplacerVars.add(varName);
+                fileReplacers.push({
+                    variable: varName,
+                    pattern: new RegExp(`${PLACEHOLDER_BOUNDARY}${varName}${PLACEHOLDER_BOUNDARY}`, 'g'),
+                });
+            }
+        }
+        const contentVars = await extractFromFileContent(filePath);
+        for (const varName of contentVars) {
+            if (!contentReplacerVars.has(varName)) {
+                contentReplacerVars.add(varName);
+                contentReplacers.push({
+                    variable: varName,
+                    pattern: new RegExp(`${PLACEHOLDER_BOUNDARY}${varName}${PLACEHOLDER_BOUNDARY}`, 'g'),
+                });
+            }
+        }
+    });
+    return {
+        fileReplacers,
+        contentReplacers,
+        projectQuestions,
+    };
+}
+/**
+ * Extract variables from file content using streams
+ * @param filePath - Path to the file
+ * @returns Set of variable names found in the file
+ */
+async function extractFromFileContent(filePath) {
+    const variables = new Set();
+    return new Promise((resolve) => {
+        const stream = fs.createReadStream(filePath, { encoding: 'utf8' });
+        let buffer = '';
+        stream.on('data', (chunk) => {
+            buffer += chunk.toString();
+            const lines = buffer.split('\n');
+            buffer = lines.pop() || ''; // Keep the last incomplete line in buffer
+            for (const line of lines) {
+                const matches = line.matchAll(VARIABLE_PATTERN);
+                for (const match of matches) {
+                    variables.add(match[1]);
+                }
+            }
+        });
+        stream.on('end', () => {
+            const matches = buffer.matchAll(VARIABLE_PATTERN);
+            for (const match of matches) {
+                variables.add(match[1]);
+            }
+            resolve(variables);
+        });
+        stream.on('error', () => {
+            resolve(variables);
+        });
+    });
+}
+/**
+ * Walk through a directory recursively
+ * @param dir - Directory to walk
+ * @param callback - Callback function for each file
+ */
+async function walkDirectory(dir, callback) {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            await walkDirectory(fullPath, callback);
+        }
+        else if (entry.isFile()) {
+            await callback(fullPath);
+        }
+    }
+}
+/**
+ * Load project questions from .boilerplate.json or .boilerplate.js
+ * @param templateDir - Path to the template directory
+ * @returns Questions object or null if not found
+ */
+async function loadProjectQuestions(templateDir) {
+    const jsonPath = path.join(templateDir, '.boilerplate.json');
+    if (fs.existsSync(jsonPath)) {
+        try {
+            const content = fs.readFileSync(jsonPath, 'utf8');
+            const parsed = JSON.parse(content);
+            // .boilerplate.json has { questions: [...] } structure
+            const questions = parsed.questions ? { questions: parsed.questions } : parsed;
+            return validateQuestions(questions) ? normalizeQuestions(questions) : null;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.warn(`Failed to parse .boilerplate.json: ${errorMessage}`);
+        }
+    }
+    const jsPath = path.join(templateDir, '.boilerplate.js');
+    if (fs.existsSync(jsPath)) {
+        try {
+            const module = require(jsPath);
+            const exported = module.default || module;
+            // .boilerplate.js can export { questions: [...] } or just the questions array
+            const questions = exported.questions ? { questions: exported.questions } : exported;
+            return validateQuestions(questions) ? normalizeQuestions(questions) : null;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.warn(`Failed to load .boilerplate.js: ${errorMessage}`);
+        }
+    }
+    return null;
+}
+/**
+ * Normalize questions by ensuring all required fields have default values
+ * @param questions - Questions object to normalize
+ * @returns Normalized questions object
+ */
+function normalizeQuestions(questions) {
+    return {
+        ...questions,
+        questions: questions.questions.map((q) => ({
+            ...q,
+            type: q.type || 'text'
+        }))
+    };
+}
+/**
+ * Validate that the questions object has the correct structure
+ * @param obj - Object to validate
+ * @returns True if valid, false otherwise
+ */
+function validateQuestions(obj) {
+    return obj && typeof obj === 'object' && Array.isArray(obj.questions);
+}

package/template/prompt.d.ts

@@ -0,0 +1,19 @@
+import { Inquirerer, Question } from 'inquirerer';
+import { ExtractedVariables } from '../types';
+/**
+ * Generate questions from extracted variables
+ * @param extractedVariables - Variables extracted from the template
+ * @returns Array of questions to prompt the user
+ */
+export declare function generateQuestions(extractedVariables: ExtractedVariables): Question[];
+/**
+ * Prompt the user for variable values
+ * @param extractedVariables - Variables extracted from the template
+ * @param argv - Command-line arguments to pre-populate answers
+ * @param existingPrompter - Optional existing Prompter instance to reuse.
+ *   If provided, the caller retains ownership and must close it themselves.
+ *   If not provided, a new instance is created and closed automatically.
+ * @param noTty - Whether to disable TTY mode (only used when creating a new prompter)
+ * @returns Answers from the user
+ */
+export declare function promptUser(extractedVariables: ExtractedVariables, argv?: Record<string, any>, existingPrompter?: Inquirerer, noTty?: boolean): Promise<Record<string, any>>;

package/template/prompt.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateQuestions = generateQuestions;
+exports.promptUser = promptUser;
+const inquirerer_1 = require("inquirerer");
+const PLACEHOLDER_BOUNDARY = '____';
+/**
+ * Generate questions from extracted variables
+ * @param extractedVariables - Variables extracted from the template
+ * @returns Array of questions to prompt the user
+ */
+function generateQuestions(extractedVariables) {
+    const questions = [];
+    const askedVariables = new Set();
+    if (extractedVariables.projectQuestions) {
+        for (const question of extractedVariables.projectQuestions.questions) {
+            const normalizedName = normalizeQuestionName(question.name);
+            question.name = normalizedName;
+            questions.push(question);
+            askedVariables.add(normalizedName);
+        }
+    }
+    for (const replacer of extractedVariables.fileReplacers) {
+        if (!askedVariables.has(replacer.variable)) {
+            questions.push({
+                name: replacer.variable,
+                type: 'text',
+                message: `Enter value for ${replacer.variable}:`,
+                required: true
+            });
+            askedVariables.add(replacer.variable);
+        }
+    }
+    for (const replacer of extractedVariables.contentReplacers) {
+        if (!askedVariables.has(replacer.variable)) {
+            questions.push({
+                name: replacer.variable,
+                type: 'text',
+                message: `Enter value for ${replacer.variable}:`,
+                required: true
+            });
+            askedVariables.add(replacer.variable);
+        }
+    }
+    return questions;
+}
+function normalizeQuestionName(name) {
+    if (name.startsWith(PLACEHOLDER_BOUNDARY) &&
+        name.endsWith(PLACEHOLDER_BOUNDARY)) {
+        return name.slice(PLACEHOLDER_BOUNDARY.length, -PLACEHOLDER_BOUNDARY.length);
+    }
+    if (name.startsWith('__') && name.endsWith('__')) {
+        return name.slice(2, -2);
+    }
+    return name;
+}
+/**
+ * Prompt the user for variable values
+ * @param extractedVariables - Variables extracted from the template
+ * @param argv - Command-line arguments to pre-populate answers
+ * @param existingPrompter - Optional existing Prompter instance to reuse.
+ *   If provided, the caller retains ownership and must close it themselves.
+ *   If not provided, a new instance is created and closed automatically.
+ * @param noTty - Whether to disable TTY mode (only used when creating a new prompter)
+ * @returns Answers from the user
+ */
+async function promptUser(extractedVariables, argv = {}, existingPrompter, noTty = false) {
+    const questions = generateQuestions(extractedVariables);
+    if (questions.length === 0) {
+        return argv;
+    }
+    const preparedArgv = mapArgvToQuestions(argv, questions);
+    // If an existing prompter is provided, use it (caller owns lifecycle)
+    // Otherwise, create a new one and close it when done
+    const prompter = existingPrompter ?? new inquirerer_1.Inquirerer({ noTty });
+    const shouldClose = !existingPrompter;
+    try {
+        const promptAnswers = await prompter.prompt(preparedArgv, questions);
+        return {
+            ...argv,
+            ...promptAnswers,
+        };
+    }
+    finally {
+        if (shouldClose) {
+            prompter.close();
+        }
+    }
+}
+function mapArgvToQuestions(argv, questions) {
+    if (!questions.length) {
+        return argv;
+    }
+    const prepared = { ...argv };
+    const argvEntries = Object.entries(argv);
+    for (const question of questions) {
+        const name = question.name;
+        if (prepared[name] !== undefined) {
+            continue;
+        }
+        const match = argvEntries.find(([key]) => key === name);
+        if (match) {
+            prepared[name] = match[1];
+        }
+    }
+    return prepared;
+}

package/template/replace.d.ts

@@ -0,0 +1,9 @@
+import { ExtractedVariables } from '../types';
+/**
+ * Replace variables in all files in the template directory
+ * @param templateDir - Path to the template directory
+ * @param outputDir - Path to the output directory
+ * @param extractedVariables - Variables extracted from the template
+ * @param answers - User answers for variable values
+ */
+export declare function replaceVariables(templateDir: string, outputDir: string, extractedVariables: ExtractedVariables, answers: Record<string, any>): Promise<void>;

package/template/replace.js

@@ -0,0 +1,146 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replaceVariables = replaceVariables;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const stream_1 = require("stream");
+const promises_1 = require("stream/promises");
+const licenses_1 = require("../licenses");
+/**
+ * Replace variables in all files in the template directory
+ * @param templateDir - Path to the template directory
+ * @param outputDir - Path to the output directory
+ * @param extractedVariables - Variables extracted from the template
+ * @param answers - User answers for variable values
+ */
+async function replaceVariables(templateDir, outputDir, extractedVariables, answers) {
+    if (!fs.existsSync(outputDir)) {
+        fs.mkdirSync(outputDir, { recursive: true });
+    }
+    await walkAndReplace(templateDir, outputDir, extractedVariables, answers);
+    await ensureLicenseFile(outputDir, answers);
+}
+/**
+ * Walk through directory and replace variables in files and filenames
+ * @param sourceDir - Source directory
+ * @param destDir - Destination directory
+ * @param extractedVariables - Variables extracted from the template
+ * @param answers - User answers for variable values
+ * @param sourceRelativePath - Current relative path in source (for recursion)
+ * @param destRelativePath - Current relative path in destination (for recursion)
+ */
+async function walkAndReplace(sourceDir, destDir, extractedVariables, answers, sourceRelativePath = '', destRelativePath = '') {
+    const currentSource = path.join(sourceDir, sourceRelativePath);
+    const entries = fs.readdirSync(currentSource, { withFileTypes: true });
+    for (const entry of entries) {
+        const sourceEntryPath = path.join(currentSource, entry.name);
+        // Skip template configuration files - they should not be copied to output
+        if (entry.name === '.boilerplate.json' ||
+            entry.name === '.boilerplate.js' ||
+            entry.name === '.boilerplates.json') {
+            continue;
+        }
+        let newName = entry.name;
+        for (const replacer of extractedVariables.fileReplacers) {
+            if (answers[replacer.variable] !== undefined) {
+                newName = newName.replace(replacer.pattern, String(answers[replacer.variable]));
+            }
+        }
+        const destEntryPath = path.join(destDir, destRelativePath, newName);
+        if (entry.isDirectory()) {
+            if (!fs.existsSync(destEntryPath)) {
+                fs.mkdirSync(destEntryPath, { recursive: true });
+            }
+            await walkAndReplace(sourceDir, destDir, extractedVariables, answers, path.join(sourceRelativePath, entry.name), path.join(destRelativePath, newName));
+        }
+        else if (entry.isFile()) {
+            await replaceInFile(sourceEntryPath, destEntryPath, extractedVariables, answers);
+        }
+    }
+}
+async function ensureLicenseFile(outputDir, answers) {
+    const licenseValue = (0, licenses_1.findLicenseValue)(answers);
+    if (typeof licenseValue !== 'string' || licenseValue.trim() === '') {
+        return;
+    }
+    const selectedLicense = licenseValue.trim();
+    if (!(0, licenses_1.isSupportedLicense)(selectedLicense)) {
+        console.warn(`[@genomic/scaffolds] License "${selectedLicense}" is not supported by the built-in templates. Leaving template LICENSE file as-is.`);
+        return;
+    }
+    const author = (0, licenses_1.findLicenseAuthor)(answers) ?? 'Unknown Author';
+    const email = (0, licenses_1.findLicenseEmail)(answers) ?? '';
+    const content = (0, licenses_1.renderLicense)(selectedLicense, {
+        author: String(author),
+        email: String(email || ''),
+    });
+    if (!content) {
+        return;
+    }
+    const licensePath = path.join(outputDir, 'LICENSE');
+    fs.mkdirSync(path.dirname(licensePath), { recursive: true });
+    fs.writeFileSync(licensePath, content.trimEnd() + '\n', 'utf8');
+}
+/**
+ * Replace variables in a file using streams
+ * @param sourcePath - Source file path
+ * @param destPath - Destination file path
+ * @param extractedVariables - Variables extracted from the template
+ * @param answers - User answers for variable values
+ */
+async function replaceInFile(sourcePath, destPath, extractedVariables, answers) {
+    const destDir = path.dirname(destPath);
+    if (!fs.existsSync(destDir)) {
+        fs.mkdirSync(destDir, { recursive: true });
+    }
+    const replaceTransform = new stream_1.Transform({
+        transform(chunk, _encoding, callback) {
+            let content = chunk.toString();
+            for (const replacer of extractedVariables.contentReplacers) {
+                if (answers[replacer.variable] !== undefined) {
+                    content = content.replace(replacer.pattern, String(answers[replacer.variable]));
+                }
+            }
+            callback(null, Buffer.from(content));
+        }
+    });
+    try {
+        await (0, promises_1.pipeline)(fs.createReadStream(sourcePath), replaceTransform, fs.createWriteStream(destPath));
+    }
+    catch (error) {
+        fs.copyFileSync(sourcePath, destPath);
+    }
+}

package/template/templatizer.d.ts

@@ -0,0 +1,33 @@
+import { ExtractedVariables } from '../types';
+import { ProcessOptions, TemplatizerResult } from './types';
+export declare class Templatizer {
+    constructor();
+    /**
+     * Process a local template directory (extract + prompt + replace)
+     * @param templateDir - Local directory path (MUST be local, NOT git URL)
+     * @param outputDir - Output directory for generated project
+     * @param options - Processing options (argv overrides, noTty, prompter)
+     * @returns Processing result
+     */
+    process(templateDir: string, outputDir: string, options?: ProcessOptions): Promise<TemplatizerResult>;
+    /**
+     * Extract variables from template directory
+     */
+    extract(templateDir: string): Promise<ExtractedVariables>;
+    /**
+     * Prompt user for variables
+     * @param extracted - Extracted variables from template
+     * @param argv - Pre-populated answers
+     * @param prompter - Optional existing Prompter instance to reuse
+     * @param noTty - Whether to disable TTY mode (only used when creating a new prompter)
+     */
+    prompt(extracted: ExtractedVariables, argv?: Record<string, any>, prompter?: import('inquirerer').Inquirerer, noTty?: boolean): Promise<Record<string, any>>;
+    /**
+     * Replace variables in template
+     */
+    replace(templateDir: string, outputDir: string, extracted: ExtractedVariables, answers: Record<string, any>): Promise<void>;
+    /**
+     * Validate template directory exists and has content
+     */
+    validateTemplateDir(templateDir: string): void;
+}

package/template/templatizer.js

@@ -0,0 +1,110 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Templatizer = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const extract_1 = require("./extract");
+const prompt_1 = require("./prompt");
+const replace_1 = require("./replace");
+class Templatizer {
+    constructor() {
+        // Pure template processor - no configuration needed
+    }
+    /**
+     * Process a local template directory (extract + prompt + replace)
+     * @param templateDir - Local directory path (MUST be local, NOT git URL)
+     * @param outputDir - Output directory for generated project
+     * @param options - Processing options (argv overrides, noTty, prompter)
+     * @returns Processing result
+     */
+    async process(templateDir, outputDir, options) {
+        this.validateTemplateDir(templateDir);
+        // Handle subdirectory within template
+        const actualTemplateDir = options?.fromPath
+            ? path.join(templateDir, options.fromPath)
+            : templateDir;
+        this.validateTemplateDir(actualTemplateDir);
+        // Extract variables
+        const variables = await this.extract(actualTemplateDir);
+        // Prompt for values (pass through optional prompter)
+        const answers = await this.prompt(variables, options?.argv, options?.prompter, options?.noTty);
+        // Replace variables
+        await this.replace(actualTemplateDir, outputDir, variables, answers);
+        return {
+            outputDir,
+            variables,
+            answers,
+        };
+    }
+    /**
+     * Extract variables from template directory
+     */
+    async extract(templateDir) {
+        return (0, extract_1.extractVariables)(templateDir);
+    }
+    /**
+     * Prompt user for variables
+     * @param extracted - Extracted variables from template
+     * @param argv - Pre-populated answers
+     * @param prompter - Optional existing Prompter instance to reuse
+     * @param noTty - Whether to disable TTY mode (only used when creating a new prompter)
+     */
+    async prompt(extracted, argv, prompter, noTty) {
+        return (0, prompt_1.promptUser)(extracted, argv ?? {}, prompter, noTty ?? false);
+    }
+    /**
+     * Replace variables in template
+     */
+    async replace(templateDir, outputDir, extracted, answers) {
+        return (0, replace_1.replaceVariables)(templateDir, outputDir, extracted, answers);
+    }
+    /**
+     * Validate template directory exists and has content
+     */
+    validateTemplateDir(templateDir) {
+        if (!fs.existsSync(templateDir)) {
+            throw new Error(`Template directory does not exist: ${templateDir}`);
+        }
+        if (!fs.statSync(templateDir).isDirectory()) {
+            throw new Error(`Template path is not a directory: ${templateDir}`);
+        }
+        const entries = fs.readdirSync(templateDir);
+        if (entries.length === 0) {
+            throw new Error(`Template directory is empty: ${templateDir}`);
+        }
+    }
+}
+exports.Templatizer = Templatizer;

package/template/types.d.ts

@@ -0,0 +1,18 @@
+import { Inquirerer } from 'inquirerer';
+import { ExtractedVariables } from '../types';
+export interface ProcessOptions {
+    argv?: Record<string, any>;
+    noTty?: boolean;
+    fromPath?: string;
+    /**
+     * Optional Prompter instance to reuse for prompting.
+     * If provided, the caller retains ownership and is responsible for closing it.
+     * If not provided, a new instance will be created and closed automatically.
+     */
+    prompter?: Inquirerer;
+}
+export interface TemplatizerResult {
+    outputDir: string;
+    variables: ExtractedVariables;
+    answers: Record<string, any>;
+}

package/template/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });