@wp-typia/create 0.1.0

package/dist/runtime/scaffold.js

@@ -0,0 +1,334 @@
+import fs from "node:fs";
+import { promises as fsp } from "node:fs";
+import path from "node:path";
+import { execSync } from "node:child_process";
+import { PACKAGE_MANAGER_IDS, formatInstallCommand, formatRunScript, getPackageManager, 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";
+    }
+}
+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/
+.yarn/
+.pnp.*
+
+# Build
+build/
+dist/
+
+# Editor
+.vscode/
+.idea/
+
+# OS
+.DS_Store
+Thumbs.db
+
+# WordPress
+*.log
+.wp-env/
+`;
+}
+async function normalizePackageManagerFiles(targetDir, packageManagerId) {
+    const yarnRcPath = path.join(targetDir, ".yarnrc.yml");
+    if (packageManagerId === "yarn") {
+        await fsp.writeFile(yarnRcPath, "nodeLinker: node-modules\n", "utf8");
+        return;
+    }
+    if (fs.existsSync(yarnRcPath)) {
+        await fsp.rm(yarnRcPath, { force: true });
+    }
+}
+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")
+            .replace(/yourusername\/wp-typia/g, "imjlk/wp-typia");
+        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 = undefined, }) {
+    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 normalizePackageManagerFiles(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,
+    };
+}

package/dist/runtime/template-registry.js

@@ -0,0 +1,75 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+function resolvePackageRoot(startDir) {
+    let currentDir = startDir;
+    while (true) {
+        const packageJsonPath = path.join(currentDir, "package.json");
+        if (fs.existsSync(packageJsonPath)) {
+            try {
+                const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+                if (packageJson.name === "@wp-typia/create") {
+                    return currentDir;
+                }
+            }
+            catch {
+                // Ignore malformed package.json while walking upward.
+            }
+        }
+        const parentDir = path.dirname(currentDir);
+        if (parentDir === currentDir) {
+            throw new Error("Unable to resolve the @wp-typia/create package root.");
+        }
+        currentDir = parentDir;
+    }
+}
+const TEMPLATE_ROOT = path.join(resolvePackageRoot(__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(", "),
+    }));
+}

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@wp-typia/create",
+  "version": "0.1.0",
+  "description": "Bun-first scaffolding CLI for WordPress Typia block templates",
+  "packageManager": "bun@1.3.10",
+  "type": "module",
+  "main": "dist/runtime/index.js",
+  "exports": {
+    ".": "./dist/runtime/index.js",
+    "./cli": "./dist/cli.js",
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "wp-typia": "dist/cli.js"
+  },
+  "files": [
+    "dist/",
+    "templates/",
+    "README.md",
+    "package.json"
+  ],
+  "scripts": {
+    "build": "rm -rf dist && bunli build --runtime node && tsc -p tsconfig.runtime.json",
+    "dev": "bun run src/cli.ts",
+    "test": "bun run build && bunli test --pattern ./tests/create-cli.test.ts && bunli test --pattern ./tests/migrations.test.ts",
+    "test:coverage": "bun run build && bunli test --pattern ./tests/create-cli.test.ts --coverage && bunli test --pattern ./tests/migrations.test.ts --coverage && bun test tests/*.test.ts --coverage --coverage-reporter=lcov --coverage-dir=coverage",
+    "clean": "rm -rf dist",
+    "prepack": "bun run build"
+  },
+  "keywords": [
+    "wordpress",
+    "gutenberg",
+    "typia",
+    "template",
+    "scaffold",
+    "cli",
+    "bun"
+  ],
+  "author": "imjlk",
+  "license": "GPL-2.0-or-later",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/imjlk/wp-typia.git",
+    "directory": "packages/create"
+  },
+  "bugs": {
+    "url": "https://github.com/imjlk/wp-typia/issues"
+  },
+  "homepage": "https://github.com/imjlk/wp-typia/tree/main/packages/create#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=16.0.0",
+    "bun": ">=1.3.10"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "bunli": "^0.8.2",
+    "react": "^19.2.0",
+    "react-devtools-core": "^7.0.1",
+    "typescript": "^5.9.2",
+    "ws": "^8.18.0"
+  }
+}

package/templates/advanced/README.md.mustache

@@ -0,0 +1,150 @@
+# {{title}}
+
+A WordPress block with **Typia validation**, a **dynamic `render.php` server boundary**, **Interactivity API** support, and **snapshot-based migration tooling**.
+
+## 🚀 Features
+
+- **✅ Typia Validation**: Type-safe attributes with compile-time and runtime validation
+- **🧱 Dynamic Rendering**: `render.php` uses the generated `typia-validator.php` at the server boundary
+- **⚡ Interactivity API**: Lightweight frontend interactions
+- **🎯 Auto-Sync**: Types automatically sync to `block.json` and `typia.manifest.json`
+- **🧬 Snapshot Migrations**: Preserve legacy block contracts and scaffold deprecated migrations from Typia manifests
+- **🔧 TypeScript**: Full type safety throughout
+
+## 🏗️ Development
+
+```bash
+# Install dependencies
+bun install
+
+# Development with hot reload
+bun run start
+
+# Build for production  
+bun run build
+
+# Type checking
+npx tsc --noEmit
+
+# Sync block metadata manually
+bun run sync-types
+
+# Bootstrap migration snapshots for the first release
+bun run migration:init
+
+# Compare the current schema with an older snapshot
+bun run migration:diff -- --from 1.0.0
+
+# Scaffold a legacy-to-current migration edge
+bun run migration:scaffold -- --from 1.0.0
+
+# Verify generated migration rules against stored fixtures
+bun run migration:verify
+```
+
+## 📝 Type System
+
+Edit `src/types.ts` to define your block attributes:
+
+```typescript
+export interface {{titleCase}}Attributes {
+	content: string & tags.MinLength<1> & tags.Default<"Hello World">;
+	isVisible: boolean & tags.Default<true>;
+	count: number & tags.Minimum<0> & tags.Maximum<100>;
+}
+```
+
+**`block.json`, `typia.manifest.json`, and `typia-validator.php` are automatically updated** when you run `bun run start` or `bun run build`.
+
+## 🎨 Styling
+
+- `src/style.scss` - Frontend and editor styles
+- Block CSS class: `.wp-block-{{slugKebabCase}}`
+
+## ⚡ Interactivity
+
+Frontend interactions are defined in `src/view.ts`:
+
+```typescript
+const { state, actions } = store('{{namespace}}/{{slug}}', {
+	state: { isActive: false },
+	actions: { toggle() { state.isActive = !state.isActive; } }
+});
+```
+
+## 🧱 Server Boundary
+
+The block renders on the server through `render.php`. That file loads the generated `typia-validator.php`, applies defaults, validates the supported subset, and safely returns an empty string when the payload is invalid.
+
+## 🧬 Migration Authoring
+
+Generated rule files now expose both `renameMap` and `transforms`:
+
+```ts
+export const renameMap = {
+	"content": "headline",
+	"settings.label": "settings.title",
+	// "linkTarget.url.href": "cta.href",
+};
+
+export const transforms = {
+	// "count": (legacyValue) => Number(legacyValue ?? 0),
+};
+```
+
+Scaffold now does more than leave TODOs behind:
+
+- high-confidence top-level and nested leaf renames are written directly into `renameMap`
+- semantic-risk coercions get suggested transform bodies
+- edge fixtures are generated at `src/migrations/fixtures/<from>-to-<to>.json`
+- `migration:verify` replays every fixture case before it accepts the edge
+- `src/migrations/examples/rename-transform-union/` ships a realistic reference pack that does not affect the active migration graph
+
+Recommended flow:
+
+1. update `src/types.ts`
+2. run `bun run sync-types`
+3. snapshot the release you want to preserve
+4. scaffold the legacy edge
+5. review auto-applied renames and suggested transforms
+6. adjust nested `renameMap` / `transforms` entries if object or union branch leaves changed
+6. edit the generated fixture cases if the real legacy payload is richer
+7. run `bun run migration:verify`
+8. use the admin dashboard for dry-run previews before batch migration
+
+Example:
+
+```bash
+bun run migration:snapshot -- --version 2.0.0
+bun run migration:scaffold -- --from 1.0.0
+# review auto-applied renameMap entries
+# review nested leaf paths like "settings.label" or "linkTarget.url.href"
+# fill suggested transforms if needed
+bun run migration:verify
+```
+
+The dashboard then shows:
+
+- changed field paths
+- union branch matches
+- unresolved/manual review badges
+- dry-run previews before any write happens
+
+## 📦 Generated Files
+
+- `block.json` - WordPress-facing attribute metadata generated from TypeScript types
+- `typia.manifest.json` - Manifest v2 with default markers and discriminated union metadata
+- `typia-validator.php` - Generated PHP validator for the supported server-side subset
+- `render.php` - Dynamic block rendering entrypoint
+- `typia-migration-registry.php` - PHP-readable snapshot and edge summary
+- `src/migrations/versions/` - Versioned snapshots of legacy block contracts and save implementations
+- `src/migrations/rules/` - Per-edge migration rules generated from Typia manifest diffs
+- `src/migrations/fixtures/` - Edge fixtures used by `migration:verify` and the dashboard preview
+- `src/migrations/examples/` - Reference-only migration examples for rename + transform + union authoring
+- `src/migrations/generated/` - Generated deprecated array, registry, and verification helpers
+- `build/` - Compiled JavaScript and CSS
+- `src/types.ts` - **Edit this to change block attributes**
+
+---
+
+*Generated with `@wp-typia/create` and Typia validation*

package/templates/advanced/block.json.mustache

@@ -0,0 +1,43 @@
+{
+	"$schema": "https://schemas.wp.org/trunk/block.json",
+	"apiVersion": 3,
+	"name": "{{namespace}}/{{slug}}",
+	"version": "0.1.0",
+	"title": "{{title}}",
+	"category": "{{category}}",
+	"icon": "{{dashicon}}",
+	"description": "{{description}}",
+	"keywords": [
+		"typia",
+		"{{slug}}",
+		"custom"
+	],
+	"example": {
+		"attributes": {
+			"id": "Example id",
+			"version": 1,
+			"className": "Example className",
+			"content": "",
+			"alignment": "left",
+			"isVisible": true
+		}
+	},
+	"supports": {
+		"html": false,
+		"interactivity": {
+			"clientNavigation": true
+		}
+	},
+	"textdomain": "{{textdomain}}",
+	"editorScript": "file:./index.js",
+	"editorStyle": "file:./index.css",
+	"render": "file:./render.php",
+	"style": "file:./style-index.css",
+	"viewScript": "file:./view.js",
+	"attributes": {
+		"content": {
+			"type": "string",
+			"default": ""
+		}
+	}
+}

package/templates/advanced/index.js

@@ -0,0 +1,21 @@
+const { join } = require( 'path' );
+
+module.exports = {
+	templatesPath: join( __dirname ),
+	defaultValues: {
+		namespace: 'create-block',
+		category: 'widgets',
+		dashicon: 'admin-site-alt3',
+		textdomain: '',
+		editorScript: 'file:./index.js',
+		editorStyle: 'file:./index.css',
+		style: 'file:./style-index.css',
+		viewScript: 'file:./view.js',
+	},
+	variants: {
+		'typia': {
+			title: 'Typia Block',
+			description: 'A WordPress block with Typia validation and Interactivity API',
+		}
+	}
+};