create-wp-typia 0.1.0

package/templates/advanced/src/utils/debounce.ts.mustache

@@ -0,0 +1,37 @@
+/**
+ * Debounce function
+ */
+export function debounce<T extends (...args: any[]) => void>(
+	func: T,
+	wait: number
+): (...args: Parameters<T>) => void {
+	let timeout: NodeJS.Timeout;
+
+	return function executedFunction(...args: Parameters<T>) {
+		const later = () => {
+			clearTimeout(timeout);
+			func(...args);
+		};
+
+		clearTimeout(timeout);
+		timeout = setTimeout(later, wait);
+	};
+}
+
+/**
+ * Throttle function
+ */
+export function throttle<T extends (...args: any[]) => void>(
+	func: T,
+	limit: number
+): (...args: Parameters<T>) => void {
+	let inThrottle: boolean;
+
+	return function executedFunction(...args: Parameters<T>) {
+		if (!inThrottle) {
+			func.apply(this, args);
+			inThrottle = true;
+			setTimeout(() => inThrottle = false, limit);
+		}
+	};
+}

package/templates/advanced/src/utils/index.ts.mustache

@@ -0,0 +1,7 @@
+/**
+ * {{title}} utilities
+ */
+
+export * from './uuid';
+export * from './classnames';
+export * from './debounce';

package/templates/advanced/src/utils/uuid.ts.mustache

@@ -0,0 +1,17 @@
+/**
+ * Generate UUID v4
+ */
+export function generateUUID(): string {
+	return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
+		const r = Math.random() * 16 | 0;
+		const v = c === 'x' ? r : (r & 0x3 | 0x8);
+		return v.toString(16);
+	});
+}
+
+/**
+ * Generate short ID (8 characters)
+ */
+export function generateShortId(): string {
+	return Math.random().toString(36).substring(2, 10);
+}

package/templates/advanced/src/validators.ts.mustache

@@ -0,0 +1,39 @@
+import typia from "typia";
+import { {{titleCase}}Attributes } from "./types";
+
+/**
+ * Typia validators for the block attributes
+ */
+export const validators = {
+	validate: typia.createValidate<{{titleCase}}Attributes>(),
+	assert: typia.createAssert<{{titleCase}}Attributes>(),
+	is: typia.createIs<{{titleCase}}Attributes>(),
+	random: typia.createRandom<{{titleCase}}Attributes>(),
+	clone: typia.misc.createClone<{{titleCase}}Attributes>(),
+	prune: typia.misc.createPrune<{{titleCase}}Attributes>(),
+};
+
+/**
+ * Create safe attribute updater with validation
+ */
+export function createAttributeUpdater(
+	attributes: {{titleCase}}Attributes,
+	setAttributes: (attrs: Partial<{{titleCase}}Attributes>) => void,
+	validator = validators.validate
+) {
+	return <K extends keyof {{titleCase}}Attributes>(
+		key: K,
+		value: {{titleCase}}Attributes[K]
+	) => {
+		const newAttrs = { ...attributes, [key]: value };
+		
+		const validation = validator(newAttrs);
+		if (validation.success) {
+			setAttributes({ [key]: value } as Partial<{{titleCase}}Attributes>);
+			return true;
+		} else {
+			console.error(`Validation failed for ${String(key)}:`, validation.errors);
+			return false;
+		}
+	};
+}

package/templates/advanced/src/view.ts.mustache

@@ -0,0 +1,59 @@
+import { store, getContext } from '@wordpress/interactivity';
+import { {{titleCase}}State } from './types';
+
+const { state, actions, callbacks } = store('{{namespace}}/{{slug}}', {
+	state: {
+		isActive: false,
+		isVisible: true,
+		isLoading: false,
+	} as {{titleCase}}State,
+	
+	actions: {
+		toggle() {
+			state.isActive = !state.isActive;
+			console.log('{{titleCase}} toggled:', state.isActive);
+		},
+		
+		hide() {
+			state.isVisible = false;
+		},
+		
+		show() {
+			state.isVisible = true;
+		},
+		
+		async loadContent() {
+			state.isLoading = true;
+			
+			try {
+				// Simulate async operation
+				await new Promise(resolve => setTimeout(resolve, 1000));
+				
+				// Get context data
+				const context = getContext<{
+					content: string;
+					alignment: string;
+				}>();
+				
+				console.log('{{titleCase}} content loaded:', context);
+				
+			} catch (error) {
+				state.error = error instanceof Error ? error.message : 'Unknown error';
+				console.error('{{titleCase}} loading failed:', error);
+			} finally {
+				state.isLoading = false;
+			}
+		}
+	},
+	
+	callbacks: {
+		init() {
+			console.log('{{titleCase}} initialized with Typia validation and Interactivity API');
+		},
+		
+		mounted() {
+			const context = getContext();
+			console.log('{{titleCase}} mounted with context:', context);
+		}
+	},
+});

package/templates/advanced/tsconfig.json.mustache

@@ -0,0 +1,9 @@
+{
+	"extends": "@wordpress/scripts/config/tsconfig.json",
+	"compilerOptions": {
+		"rootDir": "src",
+		"declarationDir": "build/types"
+	},
+	"include": ["src/**/*"],
+	"exclude": ["build/**/*"]
+}

package/templates/advanced/webpack.config.js.mustache

@@ -0,0 +1,85 @@
+const fs = require("fs");
+const path = require("path");
+const defaultConfig = require("@wordpress/scripts/config/webpack.config");
+
+class TypiaManifestAssetPlugin {
+	apply(compiler) {
+		compiler.hooks.thisCompilation.tap("TypiaManifestAssetPlugin", (compilation) => {
+			compilation.hooks.processAssets.tap(
+				{
+					name: "TypiaManifestAssetPlugin",
+					stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_ADDITIONS,
+				},
+				() => {
+					for (const entry of getManifestEntries()) {
+						if (compilation.getAsset(entry.outputPath)) {
+							continue;
+						}
+
+						compilation.emitAsset(
+							entry.outputPath,
+							new compiler.webpack.sources.RawSource(fs.readFileSync(entry.inputPath)),
+						);
+					}
+				},
+			);
+		});
+	}
+}
+
+function getManifestEntries() {
+	const entries = [];
+	const rootManifestPath = path.resolve(process.cwd(), "typia.manifest.json");
+
+	if (fs.existsSync(rootManifestPath)) {
+		entries.push({
+			inputPath: rootManifestPath,
+			outputPath: "typia.manifest.json",
+		});
+	}
+
+	const srcDir = path.resolve(process.cwd(), "src");
+	if (!fs.existsSync(srcDir)) {
+		return entries;
+	}
+
+	for (const inputPath of findManifestFiles(srcDir)) {
+		entries.push({
+			inputPath,
+			outputPath: path.relative(srcDir, inputPath),
+		});
+	}
+
+	return entries;
+}
+
+function findManifestFiles(directory) {
+	const manifestFiles = [];
+
+	for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+		const entryPath = path.join(directory, entry.name);
+
+		if (entry.isDirectory()) {
+			manifestFiles.push(...findManifestFiles(entryPath));
+			continue;
+		}
+		if (entry.isFile() && entry.name === "typia.manifest.json") {
+			manifestFiles.push(entryPath);
+		}
+	}
+
+	return manifestFiles;
+}
+
+module.exports = async () => {
+	const { default: UnpluginTypia } = await import("@typia/unplugin/webpack");
+
+	return {
+		...defaultConfig,
+		plugins: [
+			UnpluginTypia(),
+			...(defaultConfig.plugins || []),
+			new TypiaManifestAssetPlugin(),
+		],
+	};
+};

package/templates/basic/package.json.mustache

@@ -0,0 +1,39 @@
+{
+  "name": "{{slug}}",
+  "version": "0.1.0",
+  "packageManager": "bun@1.3.10",
+  "description": "{{description}}",
+  "author": "{{author}}",
+  "license": "GPL-2.0-or-later",
+  "main": "build/index.js",
+  "scripts": {
+    "sync-types": "tsx scripts/sync-types-to-block-json.ts",
+    "prebuild": "bun run sync-types",
+    "build": "wp-scripts build",
+    "start": "bun run sync-types && wp-scripts start",
+    "dev": "bun run start",
+    "lint:js": "wp-scripts lint-js",
+    "lint:css": "wp-scripts lint-style",
+    "lint": "bun run lint:js && bun run lint:css",
+    "format": "wp-scripts format"
+  },
+  "devDependencies": {
+    "ajv": "^8.18.0",
+    "@types/wordpress__block-editor": "^11.5.17",
+    "@types/wordpress__blocks": "^12.5.18",
+    "@types/wordpress__components": "^23.8.0",
+    "@wordpress/browserslist-config": "^6.42.0",
+    "@wordpress/scripts": "^30.22.0",
+    "@typia/unplugin": "^12.0.1",
+    "tsx": "^4.20.5",
+    "typescript": "^5.9.2",
+    "typia": "^12.0.1"
+  },
+  "dependencies": {
+    "@wordpress/block-editor": "^15.2.0",
+    "@wordpress/blocks": "^15.2.0",
+    "@wordpress/components": "^30.2.0",
+    "@wordpress/element": "^6.29.0",
+    "@wordpress/i18n": "^6.2.0"
+  }
+}