simple-scaffold 3.0.0 → 3.1.1

package/scaffold-DOzCgpZT.js

@@ -0,0 +1,1263 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let node_path = require("node:path");
+node_path = __toESM(node_path);
+let node_os = require("node:os");
+node_os = __toESM(node_os);
+let node_child_process = require("node:child_process");
+let node_fs_promises = require("node:fs/promises");
+node_fs_promises = __toESM(node_fs_promises);
+let glob = require("glob");
+let util = require("util");
+util = __toESM(util);
+let handlebars = require("handlebars");
+handlebars = __toESM(handlebars);
+let date_fns = require("date-fns");
+let node_constants = require("node:constants");
+let _inquirer_input = require("@inquirer/input");
+_inquirer_input = __toESM(_inquirer_input);
+let _inquirer_select = require("@inquirer/select");
+_inquirer_select = __toESM(_inquirer_select);
+let _inquirer_confirm = require("@inquirer/confirm");
+_inquirer_confirm = __toESM(_inquirer_confirm);
+let _inquirer_number = require("@inquirer/number");
+_inquirer_number = __toESM(_inquirer_number);
+let minimatch = require("minimatch");
+let zod_v4 = require("zod/v4");
+//#region src/colors.ts
+/** ANSI color code mapping for terminal output. */
+var colorMap = {
+	reset: 0,
+	dim: 2,
+	bold: 1,
+	italic: 3,
+	underline: 4,
+	red: 31,
+	green: 32,
+	yellow: 33,
+	blue: 34,
+	magenta: 35,
+	cyan: 36,
+	white: 37,
+	gray: 90
+};
+function _colorize(text, color) {
+	const c = colorMap[color];
+	let r;
+	if (c > 1 && c < 30) r = c + 20;
+	else if (c === 1) r = 23;
+	else r = 0;
+	return `\x1b[${c}m${text}\x1b[${r}m`;
+}
+function isTemplateStringArray(template) {
+	return Array.isArray(template) && typeof template[0] === "string";
+}
+var createColorize = (color) => (template, ...params) => {
+	return isTemplateStringArray(template) ? _colorize(template.reduce((acc, str, i) => acc + str + (params[i] ?? ""), ""), color) : _colorize(String(template), color);
+};
+/**
+* Colorize text for terminal output.
+*
+* Can be used as a function: `colorize("text", "red")`
+* Or via named helpers: `colorize.red("text")` / `colorize.red\`template\``
+*/
+var colorize = Object.assign(_colorize, Object.entries(colorMap).reduce((acc, [key]) => {
+	acc[key] = createColorize(key);
+	return acc;
+}, {}));
+//#endregion
+//#region src/utils.ts
+/** Throws the error if non-null, no-ops otherwise. */
+function handleErr(err) {
+	if (err) throw err;
+}
+/** Resolves a value that may be either a static value or a function that produces one. */
+function resolve(resolver, arg) {
+	return typeof resolver === "function" ? resolver(arg) : resolver;
+}
+/** Wraps a static value in a resolver function. If already a function, returns as-is. */
+function wrapNoopResolver(value) {
+	if (typeof value === "function") return value;
+	return (_) => value;
+}
+//#endregion
+//#region src/types.ts
+/**
+* The amount of information to log when generating scaffold.
+* When not `none`, the selected level will be the lowest level included.
+*
+* For example, level `info`  will include `info`, `warning` and `error`, but not `debug`; and `warning` will only
+* show `warning` and `error`, but not `info` or `debug`.
+*
+* @default `info`
+*
+* @category Logging (const)
+*/
+var LogLevel = {
+	none: "none",
+	debug: "debug",
+	info: "info",
+	warning: "warning",
+	error: "error"
+};
+//#endregion
+//#region src/logger.ts
+/** Priority ordering for log levels (higher = more severe). */
+var LOG_PRIORITY = {
+	[LogLevel.none]: 0,
+	[LogLevel.debug]: 1,
+	[LogLevel.info]: 2,
+	[LogLevel.warning]: 3,
+	[LogLevel.error]: 4
+};
+/** Maps each log level to a terminal color. */
+var LOG_LEVEL_COLOR = {
+	[LogLevel.none]: "reset",
+	[LogLevel.debug]: "dim",
+	[LogLevel.info]: "reset",
+	[LogLevel.warning]: "yellow",
+	[LogLevel.error]: "red"
+};
+/** Logs a message at the given level, respecting the configured log level filter. */
+function log(config, level, ...obj) {
+	if (config.logLevel === LogLevel.none || LOG_PRIORITY[level] < LOG_PRIORITY[config.logLevel ?? LogLevel.info]) return;
+	const colorFn = colorize[LOG_LEVEL_COLOR[level]];
+	const key = level === LogLevel.error ? "error" : level === LogLevel.warning ? "warn" : "log";
+	const logFn = console[key];
+	logFn(...obj.map((i) => i instanceof Error ? colorFn(i, JSON.stringify(i, void 0, 1), i.stack) : typeof i === "object" ? util.default.inspect(i, {
+		depth: null,
+		colors: true
+	}) : colorFn(i)));
+}
+/** Logs the full scaffold configuration at debug level. */
+function logInitStep(config) {
+	log(config, LogLevel.debug, "Full config:", {
+		name: config.name,
+		templates: config.templates,
+		output: config.output,
+		subdir: config.subdir,
+		data: config.data,
+		overwrite: config.overwrite,
+		subdirHelper: config.subdirHelper,
+		helpers: Object.keys(config.helpers ?? {}),
+		logLevel: config.logLevel,
+		dryRun: config.dryRun,
+		beforeWrite: config.beforeWrite
+	});
+}
+/**
+* Logs a tree of created files, grouped by directory.
+*/
+function logFileTree(config, files) {
+	if (files.length === 0) return;
+	const commonDir = files.reduce((prefix, file) => {
+		while (!file.startsWith(prefix)) prefix = node_path.default.dirname(prefix);
+		return prefix;
+	}, node_path.default.dirname(files[0]));
+	log(config, LogLevel.info, "");
+	log(config, LogLevel.info, colorize.bold(`📁 ${commonDir}`));
+	const relPaths = files.map((f) => node_path.default.relative(commonDir, f)).sort();
+	for (let i = 0; i < relPaths.length; i++) {
+		const prefix = i === relPaths.length - 1 ? "└── " : "├── ";
+		log(config, LogLevel.info, colorize.dim(prefix) + relPaths[i]);
+	}
+}
+/**
+* Logs a final summary line with file count and elapsed time.
+*/
+function logSummary(config, fileCount, elapsedMs, dryRun) {
+	const timeStr = elapsedMs < 1e3 ? `${Math.round(elapsedMs)}ms` : `${(elapsedMs / 1e3).toFixed(2)}s`;
+	log(config, LogLevel.info, "");
+	if (dryRun) log(config, LogLevel.info, colorize.yellow(`🏜️  Dry run complete — ${fileCount} file(s) would be created (${timeStr})`));
+	else if (fileCount === 0) log(config, LogLevel.info, colorize.yellow(`⚠️  No files created (${timeStr})`));
+	else log(config, LogLevel.info, colorize.green(`✅ Created ${fileCount} file(s) in ${timeStr}`));
+}
+//#endregion
+//#region src/parser.ts
+var dateFns = {
+	add: date_fns.add,
+	format: date_fns.format,
+	parseISO: date_fns.parseISO
+};
+var defaultHelpers = {
+	camelCase,
+	snakeCase,
+	startCase,
+	kebabCase,
+	hyphenCase: kebabCase,
+	pascalCase,
+	lowerCase: (text) => text.toLowerCase(),
+	upperCase: (text) => text.toUpperCase(),
+	now: nowHelper,
+	date: dateHelper
+};
+function _dateHelper(date, formatString, durationDifference, durationType) {
+	if (durationType && durationDifference !== void 0) return dateFns.format(dateFns.add(date, { [durationType]: durationDifference }), formatString);
+	return dateFns.format(date, formatString);
+}
+function nowHelper(formatString, durationDifference, durationType) {
+	return _dateHelper(/* @__PURE__ */ new Date(), formatString, durationDifference, durationType);
+}
+function dateHelper(date, formatString, durationDifference, durationType) {
+	return _dateHelper(dateFns.parseISO(date), formatString, durationDifference, durationType);
+}
+function toWordParts(string) {
+	return string.split(/[^a-zA-Z0-9]/).flatMap((segment) => segment.split(/(?<=[a-z0-9])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])/)).filter((s) => s.length > 0);
+}
+function camelCase(s) {
+	return toWordParts(s).reduce((acc, part, i) => {
+		if (i === 0) return part.toLowerCase();
+		return acc + part[0].toUpperCase() + part.slice(1).toLowerCase();
+	}, "");
+}
+function snakeCase(s) {
+	return toWordParts(s).join("_").toLowerCase();
+}
+function kebabCase(s) {
+	return toWordParts(s).join("-").toLowerCase();
+}
+function startCase(s) {
+	return toWordParts(s).map((part) => part[0].toUpperCase() + part.slice(1).toLowerCase()).join(" ");
+}
+function pascalCase(s) {
+	return startCase(s).replace(/\s+/g, "");
+}
+function registerHelpers(config) {
+	const _helpers = {
+		...defaultHelpers,
+		...config.helpers
+	};
+	for (const helperName in _helpers) {
+		log(config, LogLevel.debug, `Registering helper: ${helperName}`);
+		handlebars.default.registerHelper(helperName, _helpers[helperName]);
+	}
+}
+function handlebarsParse(config, templateBuffer, { asPath = false } = {}) {
+	const { data } = config;
+	try {
+		let str = templateBuffer.toString();
+		if (asPath) str = str.replace(/\\/g, "/");
+		let outputContents = handlebars.default.compile(str, { noEscape: true })(data);
+		if (asPath && node_path.default.sep !== "/") outputContents = outputContents.replace(/\//g, "\\");
+		return Buffer.from(outputContents);
+	} catch (e) {
+		log(config, LogLevel.debug, e);
+		log(config, LogLevel.debug, "Couldn't parse file with handlebars, returning original content");
+		return Buffer.from(templateBuffer);
+	}
+}
+//#endregion
+//#region src/fs-utils.ts
+var { stat, access, mkdir } = node_fs_promises.default;
+/** Recursively creates a directory and its parents if they don't exist. */
+async function createDirIfNotExists(dir, config) {
+	if (config.dryRun) {
+		log(config, LogLevel.info, `Dry Run. Not creating dir ${dir}`);
+		return;
+	}
+	const parentDir = node_path.default.dirname(dir);
+	if (!await pathExists(parentDir)) await createDirIfNotExists(parentDir, config);
+	if (!await pathExists(dir)) try {
+		log(config, LogLevel.debug, `Creating dir ${dir}`);
+		await mkdir(dir);
+		return;
+	} catch (e) {
+		if (e && e.code !== "EEXIST") throw e;
+		return;
+	}
+}
+/** Checks whether a file or directory exists at the given path. */
+async function pathExists(filePath) {
+	try {
+		await access(filePath, node_constants.F_OK);
+		return true;
+	} catch (e) {
+		if (e && e.code === "ENOENT") return false;
+		throw e;
+	}
+}
+/** Returns true if the given path is a directory. */
+async function isDir(dirPath) {
+	return (await stat(dirPath)).isDirectory();
+}
+/** Generates a unique temporary directory path for scaffold operations. @internal */
+function getUniqueTmpPath() {
+	return node_path.default.resolve(node_os.default.tmpdir(), `scaffold-config-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+}
+//#endregion
+//#region src/path-utils.ts
+/** Strips glob wildcard characters from a template path. */
+function removeGlob(template) {
+	return node_path.default.normalize(template.replace(/\*/g, ""));
+}
+/** Removes a leading path separator, making the path relative. */
+function makeRelativePath(str) {
+	return str.startsWith(node_path.default.sep) ? str.slice(1) : str;
+}
+/** Computes a base path relative to the current working directory. */
+function getBasePath(relPath) {
+	return node_path.default.resolve(process.cwd(), relPath).replace(process.cwd() + node_path.default.sep, "").replace(process.cwd(), "");
+}
+//#endregion
+//#region src/file.ts
+var { readFile, writeFile } = node_fs_promises.default;
+/**
+* Resolves a config option that may be either a static value or a per-file function.
+* For function values, the file path is parsed through Handlebars before being passed.
+* @internal
+*/
+function getOptionValueForFile(config, filePath, fn, defaultValue) {
+	if (typeof fn !== "function") return defaultValue ?? fn;
+	return fn(filePath, node_path.default.dirname(handlebarsParse(config, filePath, { asPath: true }).toString()), node_path.default.basename(handlebarsParse(config, filePath, { asPath: true }).toString()));
+}
+/** Expands a list of glob patterns into a flat list of matching file paths. */
+async function getFileList(config, templates) {
+	log(config, LogLevel.debug, `Getting file list for glob list: ${templates}`);
+	return (await (0, glob.glob)(templates, {
+		dot: true,
+		nodir: true
+	})).map(node_path.default.normalize);
+}
+/** Analyzes a template path to determine if it's a glob, directory, or single file. */
+async function getTemplateGlobInfo(config, template) {
+	const _isGlob = (0, glob.hasMagic)(template);
+	log(config, LogLevel.debug, "before isDir", "isGlob:", _isGlob, template);
+	let resolvedTemplate = template;
+	let baseTemplatePath = _isGlob ? removeGlob(template) : template;
+	baseTemplatePath = node_path.default.normalize(baseTemplatePath);
+	const isDirOrGlob = _isGlob ? true : await isDir(template);
+	const shouldAddGlob = !_isGlob && isDirOrGlob;
+	log(config, LogLevel.debug, "after", {
+		isDirOrGlob,
+		shouldAddGlob
+	});
+	if (shouldAddGlob) resolvedTemplate = node_path.default.join(template, "**", "*");
+	return {
+		baseTemplatePath,
+		origTemplate: template,
+		isDirOrGlob,
+		isGlob: _isGlob,
+		template: resolvedTemplate
+	};
+}
+/** Computes the full output path and metadata for a single template file. */
+async function getTemplateFileInfo(config, { templatePath, basePath }) {
+	const inputPath = node_path.default.resolve(process.cwd(), templatePath);
+	const outputPathOpt = getOptionValueForFile(config, inputPath, config.output);
+	const outputDir = getOutputDir(config, outputPathOpt, basePath.replace(config.tmpDir, "./"));
+	const outputPath = handlebarsParse(config, node_path.default.join(outputDir, node_path.default.basename(inputPath)), { asPath: true }).toString();
+	return {
+		inputPath,
+		outputPathOpt,
+		outputDir,
+		outputPath,
+		exists: await pathExists(outputPath)
+	};
+}
+/**
+* Reads a template file, applies Handlebars parsing, runs the beforeWrite hook,
+* and writes the result to the output path.
+*/
+async function copyFileTransformed(config, { exists, overwrite, outputPath, inputPath }) {
+	if (!exists || overwrite) {
+		if (exists && overwrite) log(config, LogLevel.debug, `Overwriting ${outputPath}`);
+		log(config, LogLevel.debug, `Processing file ${inputPath}`);
+		const templateBuffer = await readFile(inputPath);
+		const unprocessedOutputContents = handlebarsParse(config, templateBuffer);
+		const finalOutputContents = await config.beforeWrite?.(unprocessedOutputContents, templateBuffer, outputPath) ?? unprocessedOutputContents;
+		if (!config.dryRun) await writeFile(outputPath, finalOutputContents);
+		else {
+			log(config, LogLevel.debug, "Dry run — output would be:");
+			log(config, LogLevel.debug, finalOutputContents.toString());
+		}
+	} else if (exists) log(config, LogLevel.debug, `Skipped ${outputPath} (already exists)`);
+}
+/** Computes the output directory for a file, combining the output path, base path, and optional subdir. */
+function getOutputDir(config, outputPathOpt, basePath) {
+	return node_path.default.resolve(process.cwd(), ...[
+		outputPathOpt,
+		basePath,
+		config.subdir ? config.subdirHelper ? handlebarsParse(config, `{{ ${config.subdirHelper} name }}`).toString() : config.name : void 0
+	].filter(Boolean));
+}
+/**
+* Processes a single template file: resolves output paths, creates directories,
+* and writes the transformed output.
+* Returns the output path if the file was written, or null if skipped.
+*/
+async function handleTemplateFile(config, { templatePath, basePath }) {
+	try {
+		const { inputPath, outputPathOpt, outputDir, outputPath, exists } = await getTemplateFileInfo(config, {
+			templatePath,
+			basePath
+		});
+		const overwrite = getOptionValueForFile(config, inputPath, config.overwrite ?? false);
+		log(config, LogLevel.debug, `\nParsing ${templatePath}`, `\nBase path: ${basePath}`, `\nFull input path: ${inputPath}`, `\nOutput Path Opt: ${outputPathOpt}`, `\nFull output dir: ${outputDir}`, `\nFull output path: ${outputPath}`, `\n`);
+		await createDirIfNotExists(node_path.default.dirname(outputPath), config);
+		const shouldWrite = (!exists || overwrite) && !config.dryRun;
+		log(config, LogLevel.debug, `Writing to ${outputPath}`);
+		await copyFileTransformed(config, {
+			exists,
+			overwrite,
+			outputPath,
+			inputPath
+		});
+		return shouldWrite ? outputPath : null;
+	} catch (e) {
+		handleErr(e);
+		throw e;
+	}
+}
+//#endregion
+//#region src/git.ts
+async function getGitConfig(url, file, tmpPath, logConfig) {
+	const repoUrl = `${url.protocol}//${url.host}${url.pathname}`;
+	log(logConfig, LogLevel.debug, `Cloning git repo ${repoUrl}`);
+	return new Promise((res, reject) => {
+		log(logConfig, LogLevel.debug, `Cloning git repo to ${tmpPath}`);
+		const clone = (0, node_child_process.spawn)("git", [
+			"clone",
+			"--recurse-submodules",
+			"--depth",
+			"1",
+			repoUrl,
+			tmpPath
+		]);
+		clone.on("error", reject);
+		clone.on("close", async (code) => {
+			if (code === 0) {
+				res(await loadGitConfig({
+					logConfig,
+					url: repoUrl,
+					file,
+					tmpPath
+				}));
+				return;
+			}
+			reject(/* @__PURE__ */ new Error(`Git clone failed with code ${code}`));
+		});
+	});
+}
+/** @internal */
+async function loadGitConfig({ logConfig, url: repoUrl, file, tmpPath }) {
+	log(logConfig, LogLevel.debug, `Loading config from git repo: ${repoUrl}`);
+	const filename = file || await findConfigFile(tmpPath);
+	const absolutePath = node_path.default.resolve(tmpPath, filename);
+	log(logConfig, LogLevel.debug, `Resolving config file: ${absolutePath}`);
+	const loadedConfig = await resolve(async () => (await import(absolutePath)).default, logConfig);
+	log(logConfig, LogLevel.debug, `Loaded config from git`);
+	log(logConfig, LogLevel.debug, `Raw config:`, loadedConfig);
+	const fixedConfig = {};
+	for (const [k, v] of Object.entries(loadedConfig)) fixedConfig[k] = {
+		...v,
+		templates: v.templates.map((t) => node_path.default.resolve(tmpPath, t))
+	};
+	return wrapNoopResolver(fixedConfig);
+}
+//#endregion
+//#region src/before-write.ts
+/**
+* Wraps a CLI beforeWrite command string into a beforeWrite callback function.
+* The command receives the processed content via a temp file and can return modified content via stdout.
+* @internal
+*/
+function wrapBeforeWrite(config, beforeWrite) {
+	return async (content, rawContent, outputFile) => {
+		const tmpDir = node_path.default.join(getUniqueTmpPath(), node_path.default.basename(outputFile));
+		await createDirIfNotExists(node_path.default.dirname(tmpDir), config);
+		const ext = node_path.default.extname(outputFile);
+		const rawTmpPath = tmpDir.replace(ext, ".raw" + ext);
+		try {
+			log(config, LogLevel.debug, "Parsing beforeWrite command", beforeWrite);
+			const cmd = await prepareBeforeWriteCmd({
+				beforeWrite,
+				tmpDir,
+				content,
+				rawTmpPath,
+				rawContent
+			});
+			return await new Promise((resolve, reject) => {
+				log(config, LogLevel.debug, "Running parsed beforeWrite command:", cmd);
+				const proc = (0, node_child_process.exec)(cmd);
+				proc.stdout.on("data", (data) => {
+					if (data.trim()) resolve(data.toString());
+					else resolve(void 0);
+				});
+				proc.stderr.on("data", (data) => {
+					reject(data.toString());
+				});
+			});
+		} catch (e) {
+			log(config, LogLevel.debug, e);
+			log(config, LogLevel.warning, "Error running beforeWrite command, returning original content");
+			return;
+		} finally {
+			await node_fs_promises.default.rm(tmpDir, { force: true });
+			await node_fs_promises.default.rm(rawTmpPath, { force: true });
+		}
+	};
+}
+async function prepareBeforeWriteCmd({ beforeWrite, tmpDir, content, rawTmpPath, rawContent }) {
+	let cmd = "";
+	const pathReg = /\{\{\s*path\s*\}\}/gi;
+	const rawPathReg = /\{\{\s*rawpath\s*\}\}/gi;
+	if (pathReg.test(beforeWrite)) {
+		await node_fs_promises.default.writeFile(tmpDir, content);
+		cmd = beforeWrite.replaceAll(pathReg, tmpDir);
+	}
+	if (rawPathReg.test(beforeWrite)) {
+		await node_fs_promises.default.writeFile(rawTmpPath, rawContent);
+		cmd = beforeWrite.replaceAll(rawPathReg, rawTmpPath);
+	}
+	if (!cmd) {
+		await node_fs_promises.default.writeFile(tmpDir, content);
+		cmd = [beforeWrite, tmpDir].join(" ");
+	}
+	return cmd;
+}
+//#endregion
+//#region src/config.ts
+/** Parses CLI append-data syntax (`key=value` or `key:=jsonValue`) into a data object. @internal */
+function parseAppendData(value, options) {
+	const data = options.data ?? {};
+	const [key, val] = value.split(/:?=/);
+	if (value.includes(":=") && !val.includes(":=")) return {
+		...data,
+		[key]: JSON.parse(val)
+	};
+	return {
+		...data,
+		[key]: isWrappedWithQuotes(val) ? val.substring(1, val.length - 1) : val
+	};
+}
+function isWrappedWithQuotes(string) {
+	return string.startsWith("\"") && string.endsWith("\"") || string.startsWith("'") && string.endsWith("'");
+}
+/** Loads and resolves a config file (local or remote). @internal */
+async function getConfigFile(config) {
+	if (config.git && !config.git.includes("://")) {
+		log(config, LogLevel.debug, `Loading config from GitHub ${config.git}`);
+		config.git = githubPartToUrl(config.git);
+	}
+	const isGit = Boolean(config.git);
+	const configFilename = config.config;
+	const configPath = isGit ? config.git : configFilename;
+	log(config, LogLevel.debug, `Loading config from file ${configFilename}`);
+	let configImport = await resolve(await (isGit ? getRemoteConfig({
+		git: configPath,
+		config: configFilename,
+		logLevel: config.logLevel,
+		tmpDir: config.tmpDir
+	}) : getLocalConfig({
+		config: configFilename,
+		logLevel: config.logLevel
+	})), config);
+	if (typeof configImport.default === "function" || configImport.default instanceof Promise) {
+		log(config, LogLevel.debug, "Config is a function or promise, resolving...");
+		configImport = await resolve(configImport.default, config);
+	}
+	return configImport;
+}
+/**
+* Parses a CLI config into a full ScaffoldConfig by merging CLI args, config file values,
+* and append-data overrides. @internal
+*/
+async function parseConfigFile(config) {
+	let output = {
+		name: config.name,
+		templates: config.templates ?? [],
+		output: config.output,
+		logLevel: config.logLevel,
+		dryRun: config.dryRun,
+		data: config.data,
+		subdir: config.subdir,
+		overwrite: config.overwrite,
+		subdirHelper: config.subdirHelper,
+		beforeWrite: void 0,
+		tmpDir: config.tmpDir
+	};
+	if (config.quiet) config.logLevel = LogLevel.none;
+	if (Boolean(config.config || config.git)) {
+		const key = config.key ?? "default";
+		const configImport = await getConfigFile(config);
+		if (!configImport[key]) throw new Error(`Template "${key}" not found in ${config.config}`);
+		const imported = configImport[key];
+		log(config, LogLevel.debug, "Imported result", imported);
+		output = {
+			...output,
+			...imported,
+			beforeWrite: void 0,
+			templates: config.templates || imported.templates,
+			output: config.output || imported.output,
+			data: {
+				...imported.data,
+				...config.data
+			}
+		};
+	}
+	output.data = {
+		...output.data,
+		...config.appendData
+	};
+	const cmdBeforeWrite = config.beforeWrite ? wrapBeforeWrite(config, config.beforeWrite) : void 0;
+	output.beforeWrite = cmdBeforeWrite ?? output.beforeWrite;
+	if (config.afterScaffold) output.afterScaffold = config.afterScaffold;
+	if (!output.name) throw new Error("simple-scaffold: Missing required option: name");
+	log(output, LogLevel.debug, "Parsed config", output);
+	return output;
+}
+/** Converts a GitHub shorthand (user/repo) to a full HTTPS git URL. @internal */
+function githubPartToUrl(part) {
+	const gitUrl = new URL(`https://github.com/${part}`);
+	if (!gitUrl.pathname.endsWith(".git")) gitUrl.pathname += ".git";
+	return gitUrl.toString();
+}
+/** Loads a scaffold config from a local file or directory. @internal */
+async function getLocalConfig(config) {
+	const { config: configFile, ...logConfig } = config;
+	const absolutePath = node_path.default.resolve(process.cwd(), configFile);
+	if (await isDir(absolutePath)) {
+		log(logConfig, LogLevel.debug, `Resolving config file from directory ${absolutePath}`);
+		const file = await findConfigFile(absolutePath);
+		if (!await pathExists(file)) throw new Error(`Could not find config file in directory ${absolutePath}`);
+		log(logConfig, LogLevel.debug, `Loading config from: ${node_path.default.resolve(absolutePath, file)}`);
+		return wrapNoopResolver(import(node_path.default.resolve(absolutePath, file)));
+	}
+	log(logConfig, LogLevel.debug, `Loading config from: ${absolutePath}`);
+	return wrapNoopResolver(import(absolutePath));
+}
+/** Loads a scaffold config from a remote git repository. @internal */
+async function getRemoteConfig(config) {
+	const { config: configFile, git, tmpDir, ...logConfig } = config;
+	log(logConfig, LogLevel.debug, `Loading config from remote ${git}, config file ${configFile || "<auto-detect>"}`);
+	const url = new URL(git);
+	const isHttp = url.protocol === "http:" || url.protocol === "https:";
+	if (!(url.protocol === "git:" || isHttp && url.pathname.endsWith(".git"))) throw new Error(`Unsupported protocol ${url.protocol}`);
+	return getGitConfig(url, configFile, tmpDir, logConfig);
+}
+/** Searches for a scaffold config file in the given directory, trying known filenames in order. @internal */
+async function findConfigFile(root) {
+	const allowed = [
+		"mjs",
+		"cjs",
+		"js",
+		"json"
+	].reduce((acc, ext) => {
+		acc.push(`scaffold.config.${ext}`);
+		acc.push(`scaffold.${ext}`);
+		acc.push(`.scaffold.${ext}`);
+		return acc;
+	}, []);
+	for (const file of allowed) if (await pathExists(node_path.default.resolve(root, file))) return file;
+	throw new Error(`Could not find config file in git repo`);
+}
+//#endregion
+//#region src/prompts.ts
+/** Prompts the user for a scaffold name. */
+async function promptForName() {
+	return (0, _inquirer_input.default)({
+		message: colorize.cyan("Scaffold name:"),
+		required: true,
+		validate: (value) => {
+			if (!value.trim()) return "Name cannot be empty";
+			return true;
+		}
+	});
+}
+/** Prompts the user to select a template key from the available config keys. */
+async function promptForTemplateKey(configMap) {
+	const keys = Object.keys(configMap);
+	if (keys.length === 0) throw new Error("No templates found in config file");
+	if (keys.length === 1) return keys[0];
+	return (0, _inquirer_select.default)({
+		message: colorize.cyan("Select a template:"),
+		choices: keys.map((key) => ({
+			name: key,
+			value: key
+		}))
+	});
+}
+/** Prompts the user for an output directory path. */
+async function promptForOutput() {
+	return (0, _inquirer_input.default)({
+		message: colorize.cyan("Output directory:"),
+		required: true,
+		default: ".",
+		validate: (value) => {
+			if (!value.trim()) return "Output directory cannot be empty";
+			return true;
+		}
+	});
+}
+/** Prompts the user for template paths (comma-separated). */
+async function promptForTemplates() {
+	return (await (0, _inquirer_input.default)({
+		message: colorize.cyan("Template paths (comma-separated):"),
+		required: true,
+		validate: (value) => {
+			if (!value.trim()) return "At least one template path is required";
+			return true;
+		}
+	})).split(",").map((t) => t.trim()).filter(Boolean);
+}
+/** Prompts for a single input based on its type. */
+async function promptSingleInput(key, def) {
+	const type = def.type ?? "text";
+	const message = colorize.cyan(def.message ?? `${key}:`);
+	switch (type) {
+		case "text": return (0, _inquirer_input.default)({
+			message,
+			required: def.required,
+			default: def.default,
+			validate: def.required ? (value) => {
+				if (!value.trim()) return `${key} is required`;
+				return true;
+			} : void 0
+		});
+		case "select": {
+			const choices = (def.options ?? []).map((opt) => typeof opt === "string" ? {
+				name: opt,
+				value: opt
+			} : opt);
+			if (choices.length === 0) throw new Error(`Input "${key}" has type "select" but no options defined`);
+			return (0, _inquirer_select.default)({
+				message,
+				choices,
+				default: def.default
+			});
+		}
+		case "confirm": return (0, _inquirer_confirm.default)({
+			message,
+			default: def.default ?? false
+		});
+		case "number": return await (0, _inquirer_number.default)({
+			message,
+			required: def.required,
+			default: def.default
+		}) ?? def.default;
+	}
+}
+/**
+* Prompts the user for any required scaffold inputs that are not already provided in data.
+* Also applies default values for optional inputs that have one.
+* Returns the merged data object.
+*/
+async function promptForInputs(inputs, existingData = {}) {
+	const data = { ...existingData };
+	for (const [key, def] of Object.entries(inputs)) {
+		if (key in data && data[key] !== void 0 && data[key] !== "") continue;
+		if (def.required || def.type === "select" || def.type === "confirm") data[key] = await promptSingleInput(key, def);
+		else if (def.default !== void 0 && !(key in data)) data[key] = def.default;
+	}
+	return data;
+}
+/** Returns true if the process is running in an interactive terminal. */
+function isInteractive() {
+	return Boolean(process.stdin.isTTY);
+}
+/**
+* Prompts for name and template key before the config file is parsed.
+* These are needed by parseConfigFile to know which template to load.
+*/
+async function promptBeforeConfig(config, configMap) {
+	if (!isInteractive()) return config;
+	if (!config.name) config.name = await promptForName();
+	if (configMap && !config.key) {
+		if (Object.keys(configMap).length > 1) config.key = await promptForTemplateKey(configMap);
+	}
+	return config;
+}
+/**
+* Prompts for any values still missing after the config file has been parsed.
+* Only prompts in interactive mode.
+*/
+async function promptAfterConfig(config) {
+	if (!isInteractive()) return config;
+	if (!config.output || typeof config.output === "string" && !config.output) config.output = await promptForOutput();
+	if (!config.templates || config.templates.length === 0) config.templates = await promptForTemplates();
+	return config;
+}
+/**
+* Prompts for any required inputs defined in the scaffold config and merges them into data.
+* Only prompts in interactive mode; in non-interactive mode, only applies defaults.
+*/
+async function resolveInputs(config) {
+	if (!config.inputs) return config;
+	if (isInteractive()) config.data = await promptForInputs(config.inputs, config.data);
+	else {
+		const data = { ...config.data };
+		for (const [key, def] of Object.entries(config.inputs)) if (def.default !== void 0 && !(key in data)) data[key] = def.default;
+		config.data = data;
+	}
+	return config;
+}
+//#endregion
+//#region src/ignore.ts
+var IGNORE_FILENAME = ".scaffoldignore";
+/**
+* Reads a `.scaffoldignore` file from the given directory and returns
+* the parsed patterns for filtering.
+*
+* Lines starting with `#` are comments. Empty lines are skipped.
+*
+* @param dir The directory to search for `.scaffoldignore`
+* @returns Array of glob patterns to ignore
+*/
+async function loadIgnorePatterns(dir) {
+	const ignorePath = node_path.default.resolve(dir, IGNORE_FILENAME);
+	if (!await pathExists(ignorePath)) return [];
+	return parseIgnoreFile(await node_fs_promises.default.readFile(ignorePath, "utf-8"));
+}
+/**
+* Parses the contents of a `.scaffoldignore` file into glob patterns.
+* @internal
+*/
+function parseIgnoreFile(content) {
+	return content.split("\n").map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
+}
+/**
+* Filters a list of file paths, removing any that match the ignore patterns.
+* Patterns are matched against the relative path from baseDir.
+* Also always excludes `.scaffoldignore` itself.
+*/
+function filterIgnoredFiles(files, ignorePatterns, baseDir) {
+	return files.filter((file) => {
+		const basename = node_path.default.basename(file);
+		if (basename === IGNORE_FILENAME) return false;
+		const relPath = node_path.default.relative(baseDir, file);
+		for (const pattern of ignorePatterns) if ((0, minimatch.minimatch)(relPath, pattern, { dot: true }) || (0, minimatch.minimatch)(basename, pattern, { dot: true })) return false;
+		return true;
+	});
+}
+//#endregion
+//#region src/validate.ts
+/** Schema for a JavaScript function value. */
+var functionSchema = zod_v4.z.any().refine((v) => typeof v === "function", { message: "Expected a function" });
+/** Schema for a value that can be either a string or a function. */
+var stringOrFunctionSchema = zod_v4.z.union([zod_v4.z.string(), functionSchema]);
+/** Schema for a value that can be either a boolean or a function. */
+var booleanOrFunctionSchema = zod_v4.z.union([zod_v4.z.boolean(), functionSchema]);
+/** Schema for a select input option — either a plain string or a `{ name, value }` object. */
+var selectOptionSchema = zod_v4.z.union([zod_v4.z.string(), zod_v4.z.object({
+	name: zod_v4.z.string(),
+	value: zod_v4.z.string()
+})]);
+/** Schema for the input type enum. */
+var inputTypeSchema = zod_v4.z.enum([
+	"text",
+	"select",
+	"confirm",
+	"number"
+]);
+/** Schema for the log level enum. */
+var logLevelSchema = zod_v4.z.enum([
+	"none",
+	"debug",
+	"info",
+	"warning",
+	"error"
+]);
+/** Zod schema for a single scaffold input definition. */
+var scaffoldInputSchema = zod_v4.z.object({
+	type: inputTypeSchema.optional(),
+	message: zod_v4.z.string().optional(),
+	required: zod_v4.z.boolean().optional(),
+	default: zod_v4.z.union([
+		zod_v4.z.string(),
+		zod_v4.z.boolean(),
+		zod_v4.z.number()
+	]).optional(),
+	options: zod_v4.z.array(selectOptionSchema).optional()
+});
+function validateInputSemantics(key, input) {
+	const issues = [];
+	if (input.type === "select" && (!input.options || input.options.length === 0)) issues.push({
+		path: [
+			"inputs",
+			key,
+			"options"
+		],
+		message: "select input must have a non-empty options array"
+	});
+	if (input.type === "confirm" && input.default !== void 0 && typeof input.default !== "boolean") issues.push({
+		path: [
+			"inputs",
+			key,
+			"default"
+		],
+		message: "confirm input default must be a boolean"
+	});
+	if (input.type === "number" && input.default !== void 0 && typeof input.default !== "number") issues.push({
+		path: [
+			"inputs",
+			key,
+			"default"
+		],
+		message: "number input default must be a number"
+	});
+	return issues;
+}
+/** Zod schema for ScaffoldConfig. */
+var scaffoldConfigSchema = zod_v4.z.object({
+	name: zod_v4.z.string().min(1, "name is required"),
+	templates: zod_v4.z.array(zod_v4.z.string()).min(1, "templates must contain at least one entry"),
+	output: stringOrFunctionSchema,
+	subdir: zod_v4.z.boolean().optional(),
+	data: zod_v4.z.record(zod_v4.z.string(), zod_v4.z.unknown()).optional(),
+	overwrite: booleanOrFunctionSchema.optional(),
+	logLevel: logLevelSchema.optional(),
+	dryRun: zod_v4.z.boolean().optional(),
+	helpers: zod_v4.z.record(zod_v4.z.string(), functionSchema).optional(),
+	subdirHelper: zod_v4.z.string().optional(),
+	inputs: zod_v4.z.record(zod_v4.z.string(), scaffoldInputSchema).optional(),
+	beforeWrite: functionSchema.optional(),
+	afterScaffold: stringOrFunctionSchema.optional(),
+	tmpDir: zod_v4.z.string().optional()
+}).check((ctx) => {
+	const config = ctx.value;
+	if (config.subdirHelper && !config.subdir) ctx.issues.push({
+		code: "custom",
+		message: "subdirHelper is set but subdir is not enabled",
+		path: ["subdirHelper"],
+		input: config
+	});
+	if (config.inputs) for (const [key, val] of Object.entries(config.inputs)) for (const issue of validateInputSemantics(key, val)) ctx.issues.push({
+		code: "custom",
+		...issue,
+		input: config
+	});
+});
+/**
+* Validates a scaffold config and returns a list of human-readable errors.
+* Returns an empty array if the config is valid.
+*/
+function validateConfig(config) {
+	const result = scaffoldConfigSchema.safeParse(config);
+	if (result.success) return [];
+	return result.error.issues.map((issue) => {
+		return `${issue.path.length > 0 ? issue.path.join(".") : "(root)"}: ${issue.message}`;
+	});
+}
+/**
+* Validates template paths exist on disk.
+* Only checks non-glob, non-negation paths.
+*/
+async function validateTemplatePaths(templates) {
+	const errors = [];
+	for (const tpl of templates) {
+		if (tpl.startsWith("!") || tpl.includes("*")) continue;
+		if (!await pathExists(tpl)) errors.push(`templates: path does not exist: ${tpl}`);
+	}
+	return errors;
+}
+/**
+* Validates the config and throws a formatted error if any issues are found.
+* Checks both schema validity and template path existence.
+*/
+async function assertConfigValid(config) {
+	const schemaErrors = validateConfig(config);
+	const pathErrors = config && typeof config === "object" && "templates" in config && Array.isArray(config.templates) ? await validateTemplatePaths(config.templates) : [];
+	const allErrors = [...schemaErrors, ...pathErrors];
+	if (allErrors.length > 0) {
+		const lines = allErrors.map((e) => `  - ${e}`);
+		throw new Error(`Invalid scaffold config:\n${lines.join("\n")}`);
+	}
+}
+//#endregion
+//#region src/scaffold.ts
+/**
+* @module
+* Simple Scaffold
+*
+* See [readme](README.md)
+*/
+/**
+* Create a scaffold using given `options`.
+*
+* #### Create files
+* To create a file structure to output, use any directory and file structure you would like.
+* Inside folder names, file names or file contents, you may place `{{ var }}` where `var` is either
+* `name` which is the scaffold name you provided or one of the keys you provided in the `data` option.
+*
+* The contents and names will be replaced with the transformed values so you can use your original structure as a
+* boilerplate for other projects, components, modules, or even single files.
+*
+* The files will maintain their structure, starting from the directory containing the template (or the template itself
+* if it is already a directory), and will output from that directory into the directory defined by `config.output`.
+*
+* #### Helpers
+* Helpers are functions you can use to transform your `{{ var }}` contents into other values without having to
+* pre-define the data and use a duplicated key.
+*
+* Any functions you provide in `helpers` option will also be available to you to make custom formatting as you see fit
+* (for example, formatting a date)
+*
+* For available default values, see {@link DefaultHelpers}.
+*
+* @param {ScaffoldConfig} config The main configuration object
+* @return {Promise<void>} A promise that resolves when the scaffold is complete
+*
+* @see {@link DefaultHelpers}
+* @see {@link CaseHelpers}
+* @see {@link DateHelpers}
+*
+* @category Main
+*/
+async function Scaffold(config) {
+	config.output ??= process.cwd();
+	await assertConfigValid(config);
+	config = await resolveInputs(config);
+	registerHelpers(config);
+	const startTime = performance.now();
+	const writtenFiles = [];
+	try {
+		config.data = {
+			name: config.name,
+			...config.data
+		};
+		logInitStep(config);
+		log(config, LogLevel.info, `Scaffolding "${config.name}"...`);
+		const excludes = config.templates.filter((t) => t.startsWith("!"));
+		const includes = config.templates.filter((t) => !t.startsWith("!"));
+		const templates = await resolveTemplateGlobs(config, includes);
+		for (const tpl of templates) {
+			const files = await processTemplateGlob(config, tpl, excludes);
+			writtenFiles.push(...files);
+		}
+	} catch (e) {
+		log(config, LogLevel.error, e);
+		throw e;
+	}
+	const elapsed = performance.now() - startTime;
+	logFileTree(config, writtenFiles);
+	logSummary(config, writtenFiles.length, elapsed, config.dryRun);
+	if (config.afterScaffold) await runAfterScaffoldHook(config, writtenFiles);
+}
+/** Resolves included template paths into GlobInfo objects. */
+async function resolveTemplateGlobs(config, includes) {
+	const templates = [];
+	for (const includedTemplate of includes) try {
+		templates.push(await getTemplateGlobInfo(config, includedTemplate));
+	} catch (e) {
+		handleErr(e);
+	}
+	return templates;
+}
+/** Processes all files matching a single template glob pattern. Returns paths of written files. */
+async function processTemplateGlob(config, tpl, excludes) {
+	const written = [];
+	const ignorePatterns = await loadIgnorePatterns(tpl.baseTemplatePath);
+	if (ignorePatterns.length > 0) log(config, LogLevel.debug, `Loaded .scaffoldignore patterns:`, ignorePatterns);
+	const files = filterIgnoredFiles(await getFileList(config, [tpl.template, ...excludes]), ignorePatterns, tpl.baseTemplatePath);
+	for (const file of files) {
+		if (await isDir(file)) continue;
+		log(config, LogLevel.debug, "Iterating files", {
+			files,
+			file
+		});
+		const relPath = makeRelativePath(node_path.default.dirname(removeGlob(file).replace(tpl.baseTemplatePath, "")));
+		const basePath = getBasePath(relPath);
+		log(config, LogLevel.debug, {
+			originalTemplate: tpl.origTemplate,
+			relativePath: relPath,
+			parsedTemplate: tpl.template,
+			inputFilePath: file,
+			baseTemplatePath: tpl.baseTemplatePath,
+			basePath,
+			isDirOrGlob: tpl.isDirOrGlob,
+			isGlob: tpl.isGlob
+		});
+		const outputPath = await handleTemplateFile(config, {
+			templatePath: file,
+			basePath
+		});
+		if (outputPath) written.push(outputPath);
+	}
+	return written;
+}
+/** Executes the afterScaffold hook — either a function or a shell command string. */
+async function runAfterScaffoldHook(config, files) {
+	const hook = config.afterScaffold;
+	if (typeof hook === "function") {
+		log(config, LogLevel.debug, "Running afterScaffold function hook");
+		await hook({
+			config,
+			files
+		});
+		return;
+	}
+	const outputDir = typeof config.output === "string" ? config.output : process.cwd();
+	const cwd = node_path.default.resolve(process.cwd(), outputDir);
+	log(config, LogLevel.info, `Running afterScaffold command: ${hook}`);
+	await new Promise((resolve, reject) => {
+		const proc = (0, node_child_process.exec)(hook, { cwd });
+		proc.stdout?.on("data", (data) => {
+			log(config, LogLevel.info, data.toString().trimEnd());
+		});
+		proc.stderr?.on("data", (data) => {
+			log(config, LogLevel.warning, data.toString().trimEnd());
+		});
+		proc.on("close", (code) => {
+			if (code === 0) resolve();
+			else reject(/* @__PURE__ */ new Error(`afterScaffold command exited with code ${code}`));
+		});
+		proc.on("error", reject);
+	});
+}
+/**
+* Create a scaffold based on a config file or URL.
+*
+* @param {string} pathOrUrl The path or URL to the config file
+* @param {Record<string, string>} config Information needed before loading the config
+* @param {Partial<Omit<ScaffoldConfig, 'name'>>} overrides Any overrides to the loaded config
+*
+* @see {@link Scaffold}
+* @category Main
+* @return {Promise<void>} A promise that resolves when the scaffold is complete
+*/
+Scaffold.fromConfig = async function(pathOrUrl, config, overrides) {
+	const tmpPath = node_path.default.resolve(node_os.default.tmpdir(), `scaffold-config-${Date.now()}`);
+	const _cmdConfig = {
+		dryRun: false,
+		output: process.cwd(),
+		logLevel: LogLevel.info,
+		overwrite: false,
+		templates: [],
+		subdir: false,
+		quiet: false,
+		config: pathOrUrl,
+		version: false,
+		tmpDir: tmpPath,
+		...config
+	};
+	const _overrides = resolve(overrides, _cmdConfig);
+	return Scaffold({
+		...await parseConfigFile(_cmdConfig),
+		..._overrides
+	});
+};
+//#endregion
+Object.defineProperty(exports, "LogLevel", {
+	enumerable: true,
+	get: function() {
+		return LogLevel;
+	}
+});
+Object.defineProperty(exports, "Scaffold", {
+	enumerable: true,
+	get: function() {
+		return Scaffold;
+	}
+});
+Object.defineProperty(exports, "__toESM", {
+	enumerable: true,
+	get: function() {
+		return __toESM;
+	}
+});
+Object.defineProperty(exports, "assertConfigValid", {
+	enumerable: true,
+	get: function() {
+		return assertConfigValid;
+	}
+});
+Object.defineProperty(exports, "colorize", {
+	enumerable: true,
+	get: function() {
+		return colorize;
+	}
+});
+Object.defineProperty(exports, "findConfigFile", {
+	enumerable: true,
+	get: function() {
+		return findConfigFile;
+	}
+});
+Object.defineProperty(exports, "getConfigFile", {
+	enumerable: true,
+	get: function() {
+		return getConfigFile;
+	}
+});
+Object.defineProperty(exports, "getUniqueTmpPath", {
+	enumerable: true,
+	get: function() {
+		return getUniqueTmpPath;
+	}
+});
+Object.defineProperty(exports, "log", {
+	enumerable: true,
+	get: function() {
+		return log;
+	}
+});
+Object.defineProperty(exports, "parseAppendData", {
+	enumerable: true,
+	get: function() {
+		return parseAppendData;
+	}
+});
+Object.defineProperty(exports, "parseConfigFile", {
+	enumerable: true,
+	get: function() {
+		return parseConfigFile;
+	}
+});
+Object.defineProperty(exports, "pathExists", {
+	enumerable: true,
+	get: function() {
+		return pathExists;
+	}
+});
+Object.defineProperty(exports, "promptAfterConfig", {
+	enumerable: true,
+	get: function() {
+		return promptAfterConfig;
+	}
+});
+Object.defineProperty(exports, "promptBeforeConfig", {
+	enumerable: true,
+	get: function() {
+		return promptBeforeConfig;
+	}
+});
+Object.defineProperty(exports, "resolveInputs", {
+	enumerable: true,
+	get: function() {
+		return resolveInputs;
+	}
+});
+Object.defineProperty(exports, "scaffoldConfigSchema", {
+	enumerable: true,
+	get: function() {
+		return scaffoldConfigSchema;
+	}
+});
+Object.defineProperty(exports, "validateConfig", {
+	enumerable: true,
+	get: function() {
+		return validateConfig;
+	}
+});
+
+//# sourceMappingURL=scaffold-DOzCgpZT.js.map