create-wp-typia 0.1.0

package/lib/scaffold.d.ts

@@ -0,0 +1,64 @@
+export interface ScaffoldProjectOptions {
+	projectDir: string;
+	templateId: string;
+	answers: {
+		author: string;
+		description: string;
+		namespace: string;
+		slug: string;
+		title: string;
+	};
+	packageManager: "bun" | "npm" | "pnpm" | "yarn";
+	allowExistingDir?: boolean;
+	noInstall?: boolean;
+	installDependencies?: (context: {
+		projectDir: string;
+		packageManager: "bun" | "npm" | "pnpm" | "yarn";
+	}) => Promise<void> | void;
+}
+
+export interface ScaffoldProjectResult {
+	projectDir: string;
+	templateId: string;
+	packageManager: "bun" | "npm" | "pnpm" | "yarn";
+	variables: Record<string, string>;
+}
+
+export function detectAuthor(): string;
+export function collectScaffoldAnswers(options: {
+	projectName: string;
+	templateId: string;
+	yes?: boolean;
+	promptText?: (
+		message: string,
+		defaultValue: string,
+		validate?: (input: string) => boolean | string,
+	) => Promise<string>;
+}): Promise<{
+	author: string;
+	description: string;
+	namespace: string;
+	slug: string;
+	title: string;
+}>;
+export function getDefaultAnswers(projectName: string, templateId: string): {
+	author: string;
+	description: string;
+	namespace: string;
+	slug: string;
+	title: string;
+};
+export function resolveTemplateId(options: {
+	templateId?: string;
+	yes?: boolean;
+	isInteractive?: boolean;
+	selectTemplate?: () => Promise<string> | string;
+}): Promise<string>;
+export function resolvePackageManagerId(options: {
+	packageManager?: "bun" | "npm" | "pnpm" | "yarn";
+	yes?: boolean;
+	isInteractive?: boolean;
+	selectPackageManager?: () => Promise<"bun" | "npm" | "pnpm" | "yarn"> | "bun" | "npm" | "pnpm" | "yarn";
+}): Promise<"bun" | "npm" | "pnpm" | "yarn">;
+export function scaffoldProject(options: ScaffoldProjectOptions): Promise<ScaffoldProjectResult>;
+export function runLegacyCli(templateId: string, argv?: string[]): Promise<void>;

package/lib/scaffold.js

@@ -0,0 +1,565 @@
+import fs from "node:fs";
+import { promises as fsp } from "node:fs";
+import path from "node:path";
+import readline from "node:readline";
+import { execSync } from "node:child_process";
+
+import {
+	PACKAGE_MANAGER_IDS,
+	formatInstallCommand,
+	formatRunScript,
+	getPackageManager,
+	getPackageManagerSelectOptions,
+	transformPackageManagerText,
+} from "./package-managers.js";
+import { TEMPLATE_IDS, getTemplateById } from "./template-registry.js";
+
+const BLOCK_SLUG_PATTERN = /^[a-z][a-z0-9-]*$/;
+const LOCKFILES = {
+	bun: ["bun.lock", "bun.lockb"],
+	npm: ["package-lock.json"],
+	pnpm: ["pnpm-lock.yaml"],
+	yarn: ["yarn.lock"],
+};
+
+function toKebabCase(input) {
+	return input
+		.trim()
+		.replace(/([a-z0-9])([A-Z])/g, "$1-$2")
+		.replace(/[^A-Za-z0-9]+/g, "-")
+		.replace(/^-+|-+$/g, "")
+		.replace(/-{2,}/g, "-")
+		.toLowerCase();
+}
+
+function toSnakeCase(input) {
+	return toKebabCase(input).replace(/-/g, "_");
+}
+
+function toPascalCase(input) {
+	return toKebabCase(input)
+		.split("-")
+		.filter(Boolean)
+		.map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1))
+		.join("");
+}
+
+function toTitle(input) {
+	return toKebabCase(input)
+		.split("-")
+		.filter(Boolean)
+		.map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1))
+		.join(" ");
+}
+
+function validateBlockSlug(input) {
+	return BLOCK_SLUG_PATTERN.test(input) || "Use lowercase letters, numbers, and hyphens only";
+}
+
+export function detectAuthor() {
+	try {
+		return (
+			execSync("git config user.name", {
+				encoding: "utf8",
+				stdio: ["ignore", "pipe", "ignore"],
+			}).trim() || "Your Name"
+		);
+	} catch {
+		return "Your Name";
+	}
+}
+
+function createReadlinePrompt() {
+	const rl = readline.createInterface({
+		input: process.stdin,
+		output: process.stdout,
+	});
+
+	return {
+		async text(message, defaultValue, validate) {
+			const suffix = defaultValue ? ` (${defaultValue})` : "";
+			const answer = await new Promise((resolve) => {
+				rl.question(`${message}${suffix}: `, resolve);
+			});
+
+			const value = String(answer).trim() || defaultValue;
+			if (validate) {
+				const result = validate(value);
+				if (result !== true) {
+					console.error(`❌ ${result}`);
+					return this.text(message, defaultValue, validate);
+				}
+			}
+
+			return value;
+		},
+		async select(message, options, defaultValue) {
+			console.log(message);
+			options.forEach((option, index) => {
+				const hint = option.hint ? ` - ${option.hint}` : "";
+				console.log(`  ${index + 1}. ${option.label}${hint}`);
+			});
+
+			const answer = await this.text("Choice", String(defaultValue ?? 1));
+			const numericChoice = Number(answer);
+			if (!Number.isNaN(numericChoice) && options[numericChoice - 1]) {
+				return options[numericChoice - 1].value;
+			}
+
+			const directChoice = options.find((option) => option.value === answer);
+			if (directChoice) {
+				return directChoice.value;
+			}
+
+			console.error(`❌ Invalid selection: ${answer}`);
+			return this.select(message, options, defaultValue);
+		},
+		close() {
+			rl.close();
+		},
+	};
+}
+
+export function getDefaultAnswers(projectName, templateId) {
+	const template = getTemplateById(templateId);
+	const slugDefault = toKebabCase(projectName || "my-wp-typia-block");
+	return {
+		author: detectAuthor(),
+		description: template.description,
+		namespace: "create-block",
+		slug: slugDefault,
+		title: toTitle(slugDefault),
+	};
+}
+
+export async function resolveTemplateId({
+	templateId,
+	yes = false,
+	isInteractive = false,
+	selectTemplate,
+}) {
+	if (templateId) {
+		return getTemplateById(templateId).id;
+	}
+
+	if (yes) {
+		return "basic";
+	}
+
+	if (!isInteractive || !selectTemplate) {
+		throw new Error(`Template is required in non-interactive mode. Use --template <${TEMPLATE_IDS.join("|")}>.`);
+	}
+
+	return selectTemplate();
+}
+
+export async function resolvePackageManagerId({
+	packageManager,
+	yes = false,
+	isInteractive = false,
+	selectPackageManager,
+}) {
+	if (packageManager) {
+		return getPackageManager(packageManager).id;
+	}
+
+	if (yes) {
+		throw new Error(
+			`Package manager is required when using --yes. Use --package-manager <${PACKAGE_MANAGER_IDS.join("|")}>.`,
+		);
+	}
+
+	if (!isInteractive || !selectPackageManager) {
+		throw new Error(
+			`Package manager is required in non-interactive mode. Use --package-manager <${PACKAGE_MANAGER_IDS.join("|")}>.`,
+		);
+	}
+
+	return selectPackageManager();
+}
+
+export async function collectScaffoldAnswers({
+	projectName,
+	templateId,
+	yes = false,
+	promptText,
+}) {
+	const defaults = getDefaultAnswers(projectName, templateId);
+
+	if (yes) {
+		return defaults;
+	}
+
+	if (!promptText) {
+		throw new Error("Interactive answers require a promptText callback.");
+	}
+
+	const slug = toKebabCase(
+		await promptText("Block slug", defaults.slug, validateBlockSlug),
+	);
+
+	return {
+		author: await promptText("Author", defaults.author),
+		description: await promptText("Description", defaults.description),
+		namespace: await promptText("Namespace", defaults.namespace),
+		slug,
+		title: await promptText("Block title", toTitle(slug)),
+	};
+}
+
+export function getTemplateVariables(templateId, answers) {
+	const template = getTemplateById(templateId);
+	const slug = toKebabCase(answers.slug);
+	const slugSnakeCase = toSnakeCase(slug);
+	const pascalCase = toPascalCase(slug);
+	const title = answers.title.trim();
+	const namespace = answers.namespace.trim();
+	const description = answers.description.trim();
+
+	return {
+		author: answers.author.trim(),
+		category: template.defaultCategory,
+		cssClassName: `wp-block-${slug}`,
+		dashCase: slug,
+		dashicon: "smiley",
+		description,
+		keyword: slug.replace(/-/g, " "),
+		namespace,
+		needsMigration: "{{needsMigration}}",
+		pascalCase,
+		slug,
+		slugCamelCase: pascalCase.charAt(0).toLowerCase() + pascalCase.slice(1),
+		slugKebabCase: slug,
+		slugSnakeCase,
+		textDomain: slugSnakeCase,
+		textdomain: slugSnakeCase,
+		title,
+		titleCase: pascalCase,
+	};
+}
+
+function replaceVariables(content, variables) {
+	return content.replace(/\{\{([^}]+)\}\}/g, (match, rawKey) => {
+		const key = rawKey.trim();
+		return Object.prototype.hasOwnProperty.call(variables, key) ? variables[key] : match;
+	});
+}
+
+async function ensureDirectory(targetDir, allowExisting = false) {
+	if (!fs.existsSync(targetDir)) {
+		await fsp.mkdir(targetDir, { recursive: true });
+		return;
+	}
+
+	if (allowExisting) {
+		return;
+	}
+
+	const entries = await fsp.readdir(targetDir);
+	if (entries.length > 0) {
+		throw new Error(`Target directory is not empty: ${targetDir}`);
+	}
+}
+
+async function copyTemplateDir(sourceDir, targetDir, variables) {
+	const entries = await fsp.readdir(sourceDir, { withFileTypes: true });
+	for (const entry of entries) {
+		const sourcePath = path.join(sourceDir, entry.name);
+		const destinationName = entry.name.endsWith(".mustache")
+			? entry.name.slice(0, -".mustache".length)
+			: entry.name;
+		const destinationPath = path.join(targetDir, destinationName);
+
+		if (entry.isDirectory()) {
+			await fsp.mkdir(destinationPath, { recursive: true });
+			await copyTemplateDir(sourcePath, destinationPath, variables);
+			continue;
+		}
+
+		const content = await fsp.readFile(sourcePath, "utf8");
+		await fsp.writeFile(destinationPath, replaceVariables(content, variables), "utf8");
+	}
+}
+
+function buildReadme(templateId, variables, packageManager) {
+	return `# ${variables.title}
+
+${variables.description}
+
+## Template
+
+${templateId}
+
+## Development
+
+\`\`\`bash
+${formatInstallCommand(packageManager)}
+${formatRunScript(packageManager, "start")}
+\`\`\`
+
+## Build
+
+\`\`\`bash
+${formatRunScript(packageManager, "build")}
+\`\`\`
+
+## Type Sync
+
+\`\`\`bash
+${formatRunScript(packageManager, "sync-types")}
+\`\`\`
+
+\`src/types.ts\` remains the source of truth for \`block.json\` and \`typia.manifest.json\`.
+`;
+}
+
+function buildGitignore() {
+	return `# Dependencies
+node_modules/
+
+# Build
+build/
+dist/
+
+# Editor
+.vscode/
+.idea/
+
+# OS
+.DS_Store
+Thumbs.db
+
+# WordPress
+*.log
+.wp-env/
+`;
+}
+
+async function normalizePackageJson(targetDir, packageManagerId) {
+	const packageJsonPath = path.join(targetDir, "package.json");
+	if (!fs.existsSync(packageJsonPath)) {
+		return;
+	}
+
+	const packageManager = getPackageManager(packageManagerId);
+	const packageJson = JSON.parse(await fsp.readFile(packageJsonPath, "utf8"));
+	packageJson.packageManager = packageManager.packageManagerField;
+
+	if (packageJson.scripts) {
+		for (const [key, value] of Object.entries(packageJson.scripts)) {
+			if (typeof value === "string") {
+				packageJson.scripts[key] = transformPackageManagerText(value, packageManagerId);
+			}
+		}
+	}
+
+	await fsp.writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, "\t")}\n`, "utf8");
+}
+
+async function removeUnexpectedLockfiles(targetDir, packageManagerId) {
+	const keep = new Set(LOCKFILES[packageManagerId] ?? []);
+	const allLockfiles = Object.values(LOCKFILES).flat();
+
+	await Promise.all(
+		allLockfiles.map(async (filename) => {
+			if (keep.has(filename)) {
+				return;
+			}
+
+			const filePath = path.join(targetDir, filename);
+			if (fs.existsSync(filePath)) {
+				await fsp.rm(filePath, { force: true });
+			}
+		}),
+	);
+}
+
+async function replaceTextRecursively(targetDir, packageManagerId) {
+	const textExtensions = new Set([
+		".css",
+		".js",
+		".json",
+		".jsx",
+		".md",
+		".php",
+		".scss",
+		".ts",
+		".tsx",
+		".txt",
+	]);
+
+	async function visit(currentPath) {
+		const stats = await fsp.stat(currentPath);
+		if (stats.isDirectory()) {
+			const entries = await fsp.readdir(currentPath);
+			for (const entry of entries) {
+				await visit(path.join(currentPath, entry));
+			}
+			return;
+		}
+
+		if (path.basename(currentPath) === "package.json" || !textExtensions.has(path.extname(currentPath))) {
+			return;
+		}
+
+		const content = await fsp.readFile(currentPath, "utf8");
+		const nextContent = transformPackageManagerText(content, packageManagerId)
+			.replace(/yourusername\/wp-typia-boilerplate/g, "imjlk/wp-typia-templates")
+			.replace(/@wp-typia\/basic/g, "wp-typia-basic")
+			.replace(/@wp-typia\/full/g, "wp-typia-full")
+			.replace(/@wp-typia\/interactivity/g, "wp-typia-interactivity")
+			.replace(/@wp-typia\/advanced/g, "wp-typia-advanced");
+
+		if (nextContent !== content) {
+			await fsp.writeFile(currentPath, nextContent, "utf8");
+		}
+	}
+
+	await visit(targetDir);
+}
+
+async function defaultInstallDependencies({ projectDir, packageManager }) {
+	execSync(formatInstallCommand(packageManager), {
+		cwd: projectDir,
+		stdio: "inherit",
+	});
+}
+
+export async function scaffoldProject({
+	projectDir,
+	templateId,
+	answers,
+	packageManager,
+	allowExistingDir = false,
+	noInstall = false,
+	installDependencies,
+}) {
+	const template = getTemplateById(templateId);
+	const resolvedPackageManager = getPackageManager(packageManager).id;
+
+	await ensureDirectory(projectDir, allowExistingDir);
+
+	const variables = getTemplateVariables(template.id, answers);
+
+	await copyTemplateDir(template.templateDir, projectDir, variables);
+	const readmePath = path.join(projectDir, "README.md");
+	if (!fs.existsSync(readmePath)) {
+		await fsp.writeFile(
+			readmePath,
+			buildReadme(template.id, variables, resolvedPackageManager),
+			"utf8",
+		);
+	}
+	await fsp.writeFile(path.join(projectDir, ".gitignore"), buildGitignore(), "utf8");
+	await normalizePackageJson(projectDir, resolvedPackageManager);
+	await removeUnexpectedLockfiles(projectDir, resolvedPackageManager);
+	await replaceTextRecursively(projectDir, resolvedPackageManager);
+
+	if (!noInstall) {
+		const installer = installDependencies ?? defaultInstallDependencies;
+		await installer({
+			projectDir,
+			packageManager: resolvedPackageManager,
+		});
+	}
+
+	return {
+		projectDir,
+		templateId: template.id,
+		packageManager: resolvedPackageManager,
+		variables,
+	};
+}
+
+function parseLegacyArgs(argv) {
+	const parsed = {
+		yes: false,
+		noInstall: false,
+		help: false,
+		packageManager: undefined,
+	};
+
+	for (let index = 0; index < argv.length; index += 1) {
+		const arg = argv[index];
+
+		if (arg === "--yes" || arg === "-y") {
+			parsed.yes = true;
+			continue;
+		}
+		if (arg === "--no-install") {
+			parsed.noInstall = true;
+			continue;
+		}
+		if (arg === "--help" || arg === "-h") {
+			parsed.help = true;
+			continue;
+		}
+		if (arg === "--package-manager" || arg === "-p") {
+			parsed.packageManager = argv[index + 1];
+			index += 1;
+			continue;
+		}
+		if (arg.startsWith("--package-manager=")) {
+			parsed.packageManager = arg.split("=", 2)[1];
+			continue;
+		}
+		throw new Error(`Unknown flag: ${arg}`);
+	}
+
+	return parsed;
+}
+
+export async function runLegacyCli(templateId, argv = process.argv.slice(2)) {
+	const args = parseLegacyArgs(argv);
+	const isInteractive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+	if (args.help) {
+		console.log(
+			`Usage: wp-typia-${templateId} [--yes] [--no-install] [--package-manager <${PACKAGE_MANAGER_IDS.join("|")}>]`,
+		);
+		return;
+	}
+
+	const prompt = createReadlinePrompt();
+
+	try {
+		const packageManager = await resolvePackageManagerId({
+			packageManager: args.packageManager,
+			yes: args.yes,
+			isInteractive,
+			selectPackageManager: () =>
+				prompt.select("Choose a package manager:", getPackageManagerSelectOptions(), 1),
+		});
+
+		if (!args.yes && !isInteractive) {
+			throw new Error("Interactive answers require a TTY. Use --yes inside an existing directory.");
+		}
+
+		const projectDir = process.cwd();
+		const projectName = path.basename(projectDir);
+		const answers = await collectScaffoldAnswers({
+			projectName,
+			templateId,
+			yes: args.yes,
+			promptText: (message, defaultValue, validate) =>
+				prompt.text(message, defaultValue, validate),
+		});
+
+		const result = await scaffoldProject({
+			allowExistingDir: true,
+			answers,
+			noInstall: args.noInstall,
+			packageManager,
+			projectDir,
+			templateId,
+		});
+
+		console.log(`\n✅ Scaffolded ${result.variables.title} in the current directory`);
+		console.log("Next steps:");
+		if (args.noInstall) {
+			console.log(`  ${formatInstallCommand(packageManager)}`);
+		}
+		console.log(`  ${formatRunScript(packageManager, "start")}`);
+	} finally {
+		prompt.close();
+	}
+}

package/lib/template-registry.d.ts

@@ -0,0 +1,18 @@
+export interface TemplateDefinition {
+	id: "basic" | "full" | "interactivity" | "advanced";
+	description: string;
+	defaultCategory: string;
+	features: string[];
+	templateDir: string;
+}
+
+export const TEMPLATE_REGISTRY: readonly TemplateDefinition[];
+export const TEMPLATE_IDS: Array<TemplateDefinition["id"]>;
+
+export function listTemplates(): readonly TemplateDefinition[];
+export function getTemplateById(templateId: string): TemplateDefinition;
+export function getTemplateSelectOptions(): Array<{
+	label: TemplateDefinition["id"];
+	value: TemplateDefinition["id"];
+	hint: string;
+}>;

package/lib/template-registry.js

@@ -0,0 +1,58 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const TEMPLATE_ROOT = path.join(__dirname, "..", "templates");
+
+export const TEMPLATE_REGISTRY = Object.freeze([
+	{
+		id: "basic",
+		description: "A lightweight WordPress block with Typia validation",
+		defaultCategory: "text",
+		features: ["Type-safe attributes", "Runtime validation", "Minimal setup"],
+		templateDir: path.join(TEMPLATE_ROOT, "basic"),
+	},
+	{
+		id: "full",
+		description: "A full-featured WordPress block with Typia validation and utilities",
+		defaultCategory: "widgets",
+		features: ["Advanced controls", "Custom hooks", "Style options"],
+		templateDir: path.join(TEMPLATE_ROOT, "full"),
+	},
+	{
+		id: "interactivity",
+		description: "An interactive WordPress block with Typia validation and Interactivity API",
+		defaultCategory: "widgets",
+		features: ["Interactivity API", "Client-side state", "Event handling"],
+		templateDir: path.join(TEMPLATE_ROOT, "interactivity"),
+	},
+	{
+		id: "advanced",
+		description: "An advanced WordPress block with Typia validation and migration tooling",
+		defaultCategory: "widgets",
+		features: ["Migration system", "Version tracking", "Admin dashboard"],
+		templateDir: path.join(TEMPLATE_ROOT, "advanced"),
+	},
+]);
+
+export const TEMPLATE_IDS = TEMPLATE_REGISTRY.map((template) => template.id);
+
+export function listTemplates() {
+	return TEMPLATE_REGISTRY;
+}
+
+export function getTemplateById(templateId) {
+	const template = TEMPLATE_REGISTRY.find((entry) => entry.id === templateId);
+	if (!template) {
+		throw new Error(`Unknown template "${templateId}". Expected one of: ${TEMPLATE_IDS.join(", ")}`);
+	}
+	return template;
+}
+
+export function getTemplateSelectOptions() {
+	return TEMPLATE_REGISTRY.map((template) => ({
+		label: template.id,
+		value: template.id,
+		hint: template.features.join(", "),
+	}));
+}