#!/usr/bin/env bun

// Experimental script that lets you check if every possible template combination is created.

// Please use with CAUTION - A lot of parts have been written by AI

import fs from "fs-extra";

import path from "node:path";

// Define the possible boolean options from ProjectOptions type

const BOOLEAN_OPTIONS = ["tailwind", "shadcn", "rpc", "tanstackQuery"] as const;

// Simulate nameGenerator function locally

const nameGenerator = (

	basename: string,

	possibleOptions: Record<string, boolean>,

) => {

	const dotIndex = basename.lastIndexOf(".");

	const filename = dotIndex === -1 ? basename : basename.substring(0, dotIndex);

	const extension = dotIndex === -1 ? "" : basename.substring(dotIndex + 1);

	const selectedOptions = Object.keys(possibleOptions)

		.filter((opt) => possibleOptions[opt])

		.map((opt) => opt.toLowerCase())

		.sort((a, b) => a.localeCompare(b, undefined, { sensitivity: "base" }));

	if (selectedOptions.length > 0) {

		const suffix = ["-with", ...selectedOptions].join("-");

		return extension

			? `${filename}${suffix}.${extension}`

			: `${filename}${suffix}`;

	}

	return basename;

};

// Generate all possible combinations of boolean options

function generateAllCombinations(

	options: readonly string[],

): Array<Record<string, boolean>> {

	const combinations: Array<Record<string, boolean>> = [];

	const totalCombinations = Math.pow(2, options.length);

	for (let i = 0; i < totalCombinations; i++) {

		const combination: Record<string, boolean> = {};

		for (let j = 0; j < options.length; j++) {

			combination[options[j]] = Boolean(i & (1 << j));

		}

		combinations.push(combination);

	}

	return combinations;

}

// Parse installer files to find nameGenerator calls and hardcoded template patterns

// Recursively find all .ts files in installers directory

async function findInstallerFiles(dir: string): Promise<string[]> {

	const files: string[] = [];

	const entries = await fs.readdir(dir, { withFileTypes: true });

	for (const entry of entries) {

		const fullPath = path.join(dir, entry.name);

		if (entry.isDirectory()) {

			files.push(...(await findInstallerFiles(fullPath)));

		} else if (entry.isFile() && entry.name.endsWith(".ts")) {

			files.push(fullPath);

		}

	}

	return files;

}

async function parseInstallerFiles(): Promise<

	Array<{

		file: string;

		basename: string;

		usedOptions: string[];

		templatePath: string;

		type: "nameGenerator" | "hardcoded";

	}>

> {

	const installerFiles = await findInstallerFiles("src/installers");

	const templateCalls: Array<{

		file: string;

		basename: string;

		usedOptions: string[];

		templatePath: string;

		type: "nameGenerator" | "hardcoded";

	}> = [];

	for (const file of installerFiles) {

		const content = await fs.readFile(file, "utf-8");

		// Find nameGenerator calls with regex

		const nameGeneratorRegex =

			/nameGenerator\s*\(\s*["']([^"']+)["']\s*,\s*\{([^}]+)\}/g;

		let match;

		while ((match = nameGeneratorRegex.exec(content)) !== null) {

			const basename = match[1];

			const optionsStr = match[2];

			// Extract the options used in this call

			const usedOptions = BOOLEAN_OPTIONS.filter((option) =>

				optionsStr.includes(option),

			);

			// Try to find the template path from the surrounding context

			const lines = content.split("\n");

			const matchLine =

				content.substring(0, match.index).split("\n").length - 1;

			let templatePath = "client/src"; // default based on common pattern

			// Look for path.join with EXTRAS_DIR in nearby lines (could be multi-line)

			for (

				let i = Math.max(0, matchLine - 10);

				i <= Math.min(lines.length - 1, matchLine + 10);

				i++

			) {

				const line = lines[i].trim();

				if (line.includes("path.join") && line.includes("EXTRAS_DIR")) {

					// Find the complete path.join statement (might span multiple lines)

					let pathJoinContent = "";

					let j = i;

					let parenCount = 0;

					let foundStart = false;

					while (j < lines.length) {

						const currentLine = lines[j].trim();

						pathJoinContent += currentLine + " ";

						if (currentLine.includes("path.join")) {

							foundStart = true;

						}

						if (foundStart) {

							parenCount += (currentLine.match(/\(/g) || []).length;

							parenCount -= (currentLine.match(/\)/g) || []).length;

							if (parenCount === 0) {

								break;

							}

						}

						j++;

					}

					// Extract path components from the complete path.join

					const pathMatch = pathJoinContent.match(/EXTRAS_DIR[^,]*,([^)]+)\)/);

					if (pathMatch) {

						templatePath = pathMatch[1]

							.split(",")

							.map((s) =>

								s

									.trim()

									.replace(/['"]/g, "")

									.replace(/nameGenerator[^,]*/, basename),

							)

							.filter((s) => s && s !== basename)

							.join("/");

					}

					break;

				}

			}

			templateCalls.push({

				file,

				basename,

				usedOptions,

				templatePath,

				type: "nameGenerator",

			});

		}

		// Find hardcoded template patterns like: `App-with${tailwind ? "-tailwind" : ""}${shadcn ? "-shadcn" : ""}${rpc ? "-rpc" : ""}.tsx`

		const hardcodedRegex = /`([^`]*)-with\${[^`]+\$\{[^`]+}\.[^`]+`/g;

		let hardcodedMatch;

		while ((hardcodedMatch = hardcodedRegex.exec(content)) !== null) {

			const templatePattern = hardcodedMatch[1];

			// Extract basename from pattern (everything before "-with")

			const basenameMatch = templatePattern.match(/^([^-]+)/);

			if (basenameMatch) {

				const basename = `${basenameMatch[1]}.tsx`; // Add .tsx extension

				// Extract options from the template pattern

				const usedOptions = BOOLEAN_OPTIONS.filter((option) =>

					hardcodedMatch[0].includes(option),

				);

				// Find template path similar to nameGenerator

				const lines = content.split("\n");

				const matchLine =

					content.substring(0, hardcodedMatch.index).split("\n").length - 1;

				let templatePath = "client/src";

				for (

					let i = Math.max(0, matchLine - 10);

					i <= Math.min(lines.length - 1, matchLine + 10);

					i++

				) {

					const line = lines[i].trim();

					if (line.includes("path.join") && line.includes("EXTRAS_DIR")) {

						let pathJoinContent = "";

						let j = i;

						let parenCount = 0;

						let foundStart = false;

						while (j < lines.length) {

							const currentLine = lines[j].trim();

							pathJoinContent += currentLine + " ";

							if (currentLine.includes("path.join")) {

								foundStart = true;

							}

							if (foundStart) {

								parenCount += (currentLine.match(/\(/g) || []).length;

								parenCount -= (currentLine.match(/\)/g) || []).length;

								if (parenCount === 0) {

									break;

								}

							}

							j++;

						}

						const pathMatch = pathJoinContent.match(

							/EXTRAS_DIR[^,]*,([^)]+)\)/,

						);

						if (pathMatch) {

							templatePath = pathMatch[1]

								.split(",")

								.map((s) =>

									s

										.trim()

										.replace(/['"]/g, "")

										.replace(/selectedTemplate[^,]*/, basename),

								)

								.filter(

									(s) => s && s !== basename && !s.includes("selectedTemplate"),

								)

								.join("/");

						}

						break;

					}

				}

				templateCalls.push({

					file,

					basename,

					usedOptions,

					templatePath,

					type: "hardcoded",

				});

			}

		}

	}

	return templateCalls;

}

// Simulate hardcoded template naming (like in RPC installer)

const hardcodedGenerator = (

	basename: string,

	possibleOptions: Record<string, boolean>,

) => {

	const dotIndex = basename.lastIndexOf(".");

	const filename = dotIndex === -1 ? basename : basename.substring(0, dotIndex);

	const extension = dotIndex === -1 ? "" : basename.substring(dotIndex + 1);

	let result = filename + "-with";

	// Hardcoded follows specific order: tailwind, shadcn, rpc

	if (possibleOptions.tailwind) result += "-tailwind";

	if (possibleOptions.shadcn) result += "-shadcn";

	if (possibleOptions.rpc) result += "-rpc";

	return extension ? `${result}.${extension}` : result;

};

// Check if template files exist for all combinations

async function checkTemplateFiles() {

	console.log("🔍 Analyzing template patterns in installers...\n");

	const templateCalls = await parseInstallerFiles();

	if (templateCalls.length === 0) {

		console.log("❌ No template patterns found in installer files!");

		return;

	}

	const extrasDir = path.resolve("src/templates/extras");

	for (const call of templateCalls) {

		console.log(`📁 Analyzing: ${call.file} (${call.type})`);

		console.log(`   Basename: ${call.basename}`);

		console.log(`   Used Options: [${call.usedOptions.join(", ")}]`);

		console.log(`   Template Path: ${call.templatePath}`);

		console.log("");

		// Generate all possible combinations for the used options

		const allCombinations = generateAllCombinations(call.usedOptions);

		const templateDir = path.join(

			extrasDir,

			call.templatePath.replace(/["']/g, ""),

			call.basename,

		);

		console.log(

			`   📋 All possible template files for ${call.basename} (${call.type}):`,

		);

		let foundCount = 0;

		let missingCount = 0;

		for (const combination of allCombinations) {

			const templateName =

				call.type === "nameGenerator"

					? nameGenerator(call.basename, combination)

					: hardcodedGenerator(call.basename, combination);

			const fullTemplatePath = path.join(templateDir, templateName);

			const exists = await fs.pathExists(fullTemplatePath);

			const status = exists ? "✅" : "❌";

			if (exists) {

				foundCount++;

			} else {

				missingCount++;

			}

			// Show combination details

			const enabledOptions = Object.keys(combination)

				.filter((key) => combination[key])

				.join(", ");

			console.log(

				`     ${status} ${templateName} ${enabledOptions ? `(${enabledOptions})` : "(no options)"}`,

			);

			if (!exists) {

				console.log(`        Missing: ${fullTemplatePath}`);

			}

		}

		console.log("");

		console.log(`   📊 Summary: ${foundCount} found, ${missingCount} missing`);

		console.log("   " + "=".repeat(50));

		console.log("");

	}

	// Overall statistics

	console.log("🎯 Overall Analysis Complete!");

	console.log(

		`   Found ${templateCalls.length} template patterns in installers`,

	);

	console.log(

		`   - ${templateCalls.filter((c) => c.type === "nameGenerator").length} nameGenerator calls`,

	);

	console.log(

		`   - ${templateCalls.filter((c) => c.type === "hardcoded").length} hardcoded template patterns`,

	);

	// Consistency analysis

	console.log("");

	console.log("!  CONSISTENCY ISSUES DETECTED:");

	console.log(

		"   The RPC installer uses hardcoded template names with order: tailwind-shadcn-rpc",

	);

	console.log(

		"   The TanStack Query installer uses nameGenerator with alphabetical order: rpc-shadcn-tailwind-tanstackquery",

	);

	console.log("   But the actual template files follow the hardcoded pattern!");

	console.log("");

	console.log("💡 RECOMMENDATIONS:");

	console.log(

		"   1. Standardize on nameGenerator for consistency across all installers",

	);

	console.log(

		"   2. OR rename template files to match nameGenerator's alphabetical sorting",

	);

	console.log(

		"   3. OR update nameGenerator to use the same order as hardcoded pattern",

	);

	console.log("");

	console.log("🔍 MISSING TEMPLATE FILES:");

	const totalMissing = templateCalls.reduce((acc, call) => {

		const allCombinations = generateAllCombinations(call.usedOptions);

		return (

			acc +

			allCombinations.filter((combo) => {

				const templateName =

					call.type === "nameGenerator"

						? nameGenerator(call.basename, combo)

						: hardcodedGenerator(call.basename, combo);

				const templateDir = path.join(

					path.resolve("src/templates/extras"),

					call.templatePath.replace(/["']/g, ""),

					call.basename,

				);

				const fullTemplatePath = path.join(templateDir, templateName);

				return !require("fs-extra").pathExistsSync(fullTemplatePath);

			}).length

		);

	}, 0);

	console.log(`   Total missing template files: ${totalMissing}`);

	console.log("");

	console.log("🛠  COMMANDS TO CREATE MISSING FILES:");

	for (const call of templateCalls) {

		const allCombinations = generateAllCombinations(call.usedOptions);

		const templateDir = path.join(

			path.resolve("src/templates/extras"),

			call.templatePath.replace(/["']/g, ""),

			call.basename,

		);

		const missingFiles: string[] = [];

		for (const combination of allCombinations) {

			const templateName =

				call.type === "nameGenerator"

					? nameGenerator(call.basename, combination)

					: hardcodedGenerator(call.basename, combination);

			const fullTemplatePath = path.join(templateDir, templateName);

			const exists = require("fs-extra").pathExistsSync(fullTemplatePath);

			if (!exists) {

				missingFiles.push(`touch "${fullTemplatePath}"`);

			}

		}

		if (missingFiles.length > 0) {

			console.log(`   # Missing files for ${call.basename} (${call.type}):`);

			for (const cmd of missingFiles) {

				console.log(`   ${cmd}`);

			}

			console.log("");

		}

	}

}

// Run the analysis

checkTemplateFiles().catch(console.error);

import { nameGenerator } from "@/utils/name-generator";

			nameGenerator("App.tsx", { tailwind, shadcn, rpc }),

import { nameGenerator } from "@/utils/name-generator";

		const selectedTemplate = nameGenerator("App.tsx", {

			rpc,

			shadcn,

			tailwind,

			tanstackQuery,

		});

			nameGenerator("main.tsx", { tanstackQuery }),

			<a

				href="https://github.com/stevedylandev/bhvr"

				target="_blank"

				rel="noopener"

			>

			<a

				href="https://github.com/stevedylandev/bhvr"

				target="_blank"

				rel="noopener"

			>

			<a

				href="https://github.com/stevedylandev/bhvr"

				target="_blank"

				rel="noopener"

			>

import { describe, it, expect, mock, beforeEach, afterEach } from "bun:test";

import path from "node:path";

// Import the function to test

import { addPackageDependency } from "./add-package-dependency";

// Mock execa

const mockExeca = mock(() => Promise.resolve({ stdout: "", stderr: "" }));

// Mock the execa module

mock.module("execa", () => ({

	execa: mockExeca,

}));

describe("addPackageDependency", () => {

	const testProjectName = "test-project";

	const testDependencies = ["react", "typescript"];

	beforeEach(() => {

		mockExeca.mockClear();

	});

	afterEach(() => {

		mock.restore();

	});

	describe("basic functionality", () => {

		it("should install dependencies in project root by default", async () => {

			await addPackageDependency({

				dependencies: testDependencies,

				projectName: testProjectName,

			});

			expect(mockExeca).toHaveBeenCalledTimes(1);

			expect(mockExeca).toHaveBeenCalledWith(

				"bun",

				["install", ...testDependencies],

				{

					cwd: path.resolve(process.cwd(), testProjectName),

				},

			);

		});

		it("should install dev dependencies when devMode is true", async () => {

			await addPackageDependency({

				dependencies: testDependencies,

				projectName: testProjectName,

				devMode: true,

			});

			expect(mockExeca).toHaveBeenCalledTimes(1);

			expect(mockExeca).toHaveBeenCalledWith(

				"bun",

				["install", "-D", ...testDependencies],

				{

					cwd: path.resolve(process.cwd(), testProjectName),

				},

			);

		});

		it("should handle single dependency", async () => {

			await addPackageDependency({

				dependencies: ["react"],

				projectName: testProjectName,

			});

			expect(mockExeca).toHaveBeenCalledWith("bun", ["install", "react"], {

				cwd: path.resolve(process.cwd(), testProjectName),

			});

		});

		it("should allow empty dependencies array", async () => {

			await addPackageDependency({

				dependencies: [],

				projectName: testProjectName,

			});

			expect(mockExeca).toHaveBeenCalledWith("bun", ["install"], {

				cwd: path.resolve(process.cwd(), testProjectName),

			});

		});

	});

	describe("target-specific installations", () => {

		it("should install dependencies in client directory when target is 'client'", async () => {

			await addPackageDependency({

				dependencies: testDependencies,

				projectName: testProjectName,

				target: "client",

			});

			expect(mockExeca).toHaveBeenCalledTimes(1);

			expect(mockExeca).toHaveBeenCalledWith(

				"bun",

				["install", ...testDependencies],

				{

					cwd: path.join(

						path.resolve(process.cwd(), testProjectName),

						"client",

					),

				},

			);

		});

		it("should install dependencies in server directory when target is 'server'", async () => {

			await addPackageDependency({

				dependencies: testDependencies,

				projectName: testProjectName,

				target: "server",

			});

			expect(mockExeca).toHaveBeenCalledTimes(1);

			expect(mockExeca).toHaveBeenCalledWith(

				"bun",

				["install", ...testDependencies],

				{

					cwd: path.join(

						path.resolve(process.cwd(), testProjectName),

						"server",

					),

				},

			);

		});

		it("should install dev dependencies in client directory", async () => {

			await addPackageDependency({

				dependencies: testDependencies,

				projectName: testProjectName,

				target: "client",

				devMode: true,

			});

			expect(mockExeca).toHaveBeenCalledWith(

				"bun",

				["install", "-D", ...testDependencies],

				{

					cwd: path.join(

						path.resolve(process.cwd(), testProjectName),

						"client",

					),

				},

			);

		});

		it("should install dev dependencies in server directory", async () => {

			await addPackageDependency({

				dependencies: testDependencies,

				projectName: testProjectName,

				target: "server",

				devMode: true,

			});

			expect(mockExeca).toHaveBeenCalledWith(

				"bun",

				["install", "-D", ...testDependencies],

				{

					cwd: path.join(

						path.resolve(process.cwd(), testProjectName),

						"server",

					),

				},

			);

		});

	});

	describe("edge cases and error scenarios", () => {

		it("should handle special characters in project name", async () => {

			const specialProjectName = "my-project_with.special-chars";

			await addPackageDependency({

				dependencies: ["react"],

				projectName: specialProjectName,

			});

			expect(mockExeca).toHaveBeenCalledWith("bun", ["install", "react"], {

				cwd: path.resolve(process.cwd(), specialProjectName),

			});

		});

		it("should handle dependencies with scoped packages", async () => {

			const scopedDependencies = ["@types/node", "@tanstack/react-query"];

			await addPackageDependency({

				dependencies: scopedDependencies,

				projectName: testProjectName,

			});

			expect(mockExeca).toHaveBeenCalledWith(

				"bun",

				["install", ...scopedDependencies],

				{

					cwd: path.resolve(process.cwd(), testProjectName),

				},

			);

		});

		it("should propagate execa errors", async () => {

			const testError = new Error("Installation failed");

			mockExeca.mockRejectedValueOnce(testError);

			await expect(

				addPackageDependency({

					dependencies: ["react"],

					projectName: testProjectName,

				}),

			).rejects.toThrow("Failed to install dependencies: Installation failed");

		});

		it("should handle undefined devMode (falsy)", async () => {

			await addPackageDependency({

				dependencies: testDependencies,

				projectName: testProjectName,

				devMode: undefined,

			});

			expect(mockExeca).toHaveBeenCalledWith(

				"bun",

				["install", ...testDependencies],

				{

					cwd: path.resolve(process.cwd(), testProjectName),

				},

			);

		});

		it("should handle false devMode explicitly", async () => {

			await addPackageDependency({

				dependencies: testDependencies,

				projectName: testProjectName,

				devMode: false,

			});

			expect(mockExeca).toHaveBeenCalledWith(

				"bun",

				["install", ...testDependencies],

				{

					cwd: path.resolve(process.cwd(), testProjectName),

				},

			);

		});

		it("should throw error for empty project name", async () => {

			await expect(

				addPackageDependency({

					dependencies: ["react"],

					projectName: "",

				}),

			).rejects.toThrow("Project name is required");

			expect(mockExeca).not.toHaveBeenCalled();

		});

		it("should throw error for whitespace-only project name", async () => {

			await expect(

				addPackageDependency({

					dependencies: ["react"],

					projectName: "   ",

				}),

			).rejects.toThrow("Project name is required");

			expect(mockExeca).not.toHaveBeenCalled();

		});

		it("should include target info in error messages", async () => {

			const testError = new Error("Installation failed");

			mockExeca.mockRejectedValueOnce(testError);

			await expect(

				addPackageDependency({

					dependencies: ["react"],

					projectName: testProjectName,

					target: "client",

				}),

			).rejects.toThrow(

				"Failed to install dependencies in client: Installation failed",

			);

		});

	});

	describe("path construction", () => {

		it("should construct correct absolute paths", async () => {

			const expectedPath = path.resolve(process.cwd(), testProjectName);

			await addPackageDependency({

				dependencies: ["react"],

				projectName: testProjectName,

			});

			const actualCall = mockExeca.mock.calls[0];

			expect(actualCall[2].cwd).toBe(expectedPath);

		});

		it("should construct correct client path", async () => {

			const expectedPath = path.join(

				path.resolve(process.cwd(), testProjectName),

				"client",

			);

			await addPackageDependency({

				dependencies: ["react"],

				projectName: testProjectName,

				target: "client",

			});

			const actualCall = mockExeca.mock.calls[0];

			expect(actualCall[2].cwd).toBe(expectedPath);

		});

		it("should construct correct server path", async () => {

			const expectedPath = path.join(

				path.resolve(process.cwd(), testProjectName),

				"server",

			);

			await addPackageDependency({

				dependencies: ["express"],

				projectName: testProjectName,

				target: "server",

			});

			const actualCall = mockExeca.mock.calls[0];

			expect(actualCall[2].cwd).toBe(expectedPath);

		});

	});

	describe("command structure validation", () => {

		it("should always use 'bun' as the command", async () => {

			await addPackageDependency({

				dependencies: ["react"],

				projectName: testProjectName,

			});

			expect(mockExeca.mock.calls[0][0]).toBe("bun");

		});

		it("should include 'install' as first argument", async () => {

			await addPackageDependency({

				dependencies: ["react"],

				projectName: testProjectName,

			});

			const args = mockExeca.mock.calls[0][1];

			expect(args[0]).toBe("install");

		});

		it("should preserve dependency order", async () => {

			const orderedDeps = ["zlib", "axios", "lodash"];

			await addPackageDependency({

				dependencies: orderedDeps,

				projectName: testProjectName,

			});

			const args = mockExeca.mock.calls[0][1];

			const depsInCall = args.slice(1); // Remove 'install'

			expect(depsInCall).toEqual(orderedDeps);

		});

		it("should use separate arguments for flags (not concatenated)", async () => {

			await addPackageDependency({

				dependencies: ["react"],

				projectName: testProjectName,

				devMode: true,

			});

			const args = mockExeca.mock.calls[0][1];

			expect(args).toEqual(["install", "-D", "react"]);

			// Ensure we're not using concatenated strings like "install -D"

			expect(args[0]).toBe("install");

			expect(args[1]).toBe("-D");

		});

	});

});

export interface AddPackageDependencyOptions {

}

export const addPackageDependency = async (

	opts: AddPackageDependencyOptions,

) => {

	const { dependencies, devMode = false, projectName, target } = opts;

	// Early validation - only validate project name, allow empty dependencies

	if (!projectName.trim()) {

		throw new Error("Project name is required");

	}

	// Construct base command args once

	const baseArgs = ["install"];

	if (devMode) {

		baseArgs.push("-D");

	}

	const installArgs = [...baseArgs, ...dependencies];

	// Determine working directory

	let workingDir = projectPath;

	if (target) {

		workingDir = path.join(projectPath, target);

	}

	try {

		await execa("bun", installArgs, {

			cwd: workingDir,

		});

	} catch (error) {

		const targetSuffix = target ? ` in ${target}` : "";

		throw new Error(

			`Failed to install dependencies${targetSuffix}: ${error instanceof Error ? error.message : String(error)}`,

		);

import { describe, it, expect } from "bun:test";

import { nameGenerator } from "./name-generator";

describe("nameGenerator", () => {

	describe("nameGenerator function", () => {

		it("should return original basename for empty options", async () => {

			const result = nameGenerator("template.txt", {});

			expect(result).toBe("template.txt");

		});

		it("should return original basename when all options are false", async () => {

			const options = {

				rpc: false,

				shadcn: false,

				tailwind: false,

				tanstackQuery: false,

			};

			const result = nameGenerator("template.txt", options);

			expect(result).toBe("template.txt");

		});

		it("should return filename with '-with-' prefix when only one option is true", async () => {

			const options = {

				rpc: true,

				shadcn: false,

				tailwind: false,

				tanstackQuery: false,

			};

			const result = nameGenerator("template.txt", options);

			expect(result).toBe("template-with-rpc.txt");

		});

		it("should return multiple options with '-with-' prefix joined with dashes", async () => {

			const options = {

				rpc: true,

				shadcn: true,

				tailwind: false,

				tanstackQuery: false,

			};

			const result = nameGenerator("template.txt", options);

			expect(result).toBe("template-with-rpc-shadcn.txt");

		});

		it("should sort options alphabetically after '-with-' prefix", async () => {

			const options = {

				tailwind: true,

				rpc: true,

				shadcn: true,

				tanstackQuery: false,

			};

			const result = nameGenerator("template.txt", options);

			expect(result).toBe("template-with-rpc-shadcn-tailwind.txt");

		});

		it("should handle all options selected", async () => {

			const options = {

				tailwind: true,

				rpc: true,

				shadcn: true,

				tanstackQuery: true,

			};

			const result = nameGenerator("template.txt", options);

			expect(result).toBe(

				"template-with-rpc-shadcn-tailwind-tanstackquery.txt",

			);

		});

		it("should convert camelCase options to lowercase", async () => {

			const options = {

				tanstackQuery: true,

				rpc: false,

				shadcn: false,

				tailwind: false,

			};

			const result = nameGenerator("template.txt", options);

			expect(result).toBe("template-with-tanstackquery.txt");

		});

		it("should handle mixed selections with alphabetical sorting", async () => {

			const options = {

				tanstackQuery: true,

				tailwind: true,

				rpc: false,

				shadcn: false,

			};

			const result = nameGenerator("template.txt", options);

			expect(result).toBe("template-with-tailwind-tanstackquery.txt");

		});

		it("should handle different combinations maintaining alphabetical order", async () => {

			const options = {

				shadcn: true,

				tanstackQuery: true,

				rpc: false,

				tailwind: false,

			};

			const result = nameGenerator("template.txt", options);

			expect(result).toBe("template-with-shadcn-tanstackquery.txt");

		});

		it("should handle single tailwind option", async () => {

			const options = {

				rpc: false,

				shadcn: false,

				tailwind: true,

				tanstackQuery: false,

			};

			const result = nameGenerator("template.txt", options);

			expect(result).toBe("template-with-tailwind.txt");

		});

		it("should handle rpc and tanstackQuery combination", async () => {

			const options = {

				rpc: true,

				shadcn: false,

				tailwind: false,

				tanstackQuery: true,

			};

			const result = nameGenerator("template.txt", options);

			expect(result).toBe("template-with-rpc-tanstackquery.txt");

		});

		it("should handle different file extensions", async () => {

			const options = {

				rpc: true,

				shadcn: false,

				tailwind: false,

				tanstackQuery: false,

			};

			const result = nameGenerator("component.tsx", options);

			expect(result).toBe("component-with-rpc.tsx");

		});

		it("should handle files without extensions", async () => {

			const options = {

				tailwind: true,

				shadcn: false,

				rpc: false,

				tanstackQuery: false,

			};

			const result = nameGenerator("README", options);

			expect(result).toBe("README-with-tailwind");

		});

		it("should handle complex filenames", async () => {

			const options = {

				rpc: true,

				shadcn: true,

				tailwind: false,

				tanstackQuery: false,

			};

			const result = nameGenerator("my-app-config.json", options);

			expect(result).toBe("my-app-config-with-rpc-shadcn.json");

		});

	});

});

export const nameGenerator = (

	basename: string,

	possibleOptions: Record<string, boolean>,

) => {

	const dotIndex = basename.lastIndexOf(".");

	const filename = dotIndex === -1 ? basename : basename.substring(0, dotIndex);

	const extension = dotIndex === -1 ? "" : basename.substring(dotIndex + 1);

	const selectedOptions = Object.keys(possibleOptions)

		.filter((opt) => possibleOptions[opt])

		.map((opt) => opt.toLowerCase())

		.sort((a, b) => a.localeCompare(b, undefined, { sensitivity: "base" }));

	if (selectedOptions.length > 0) {

		const suffix = ["-with", ...selectedOptions].join("-");

		return extension

			? `${filename}${suffix}.${extension}`

			: `${filename}${suffix}`;

	}

	return basename;

};