@wp-typia/project-tools 0.11.1

package/templates/_shared/compound/core/webpack.config.js.mustache

@@ -0,0 +1,141 @@
+const fs = require( 'fs' );
+const path = require( 'path' );
+const defaultConfig = require( '@wordpress/scripts/config/webpack.config' );
+
+const STATIC_METADATA_FILENAMES = new Set( [
+	'block.json',
+	'render.php',
+	'typia.openapi.json',
+	'typia.manifest.json',
+	'typia-migration-registry.php',
+	'typia.schema.json',
+	'typia-validator.php',
+] );
+
+function isMetadataAsset( filename ) {
+	return (
+		STATIC_METADATA_FILENAMES.has( filename ) ||
+		filename.endsWith( '.schema.json' ) ||
+		filename.endsWith( '.openapi.json' )
+	);
+}
+
+function getBlockDirs() {
+	const blocksRoot = path.resolve( process.cwd(), 'src/blocks' );
+
+	if ( ! fs.existsSync( blocksRoot ) ) {
+		return [];
+	}
+
+	return fs
+		.readdirSync( blocksRoot, { withFileTypes: true } )
+		.filter( ( entry ) => entry.isDirectory() )
+		.map( ( entry ) => ( {
+			dir: path.join( blocksRoot, entry.name ),
+			slug: entry.name,
+		} ) );
+}
+
+function getMetadataEntries() {
+	const entries = [];
+	const rootMigrationRegistryPath = path.resolve(
+		process.cwd(),
+		'typia-migration-registry.php'
+	);
+
+	if ( fs.existsSync( rootMigrationRegistryPath ) ) {
+		entries.push( {
+			inputPath: rootMigrationRegistryPath,
+			outputPath: 'typia-migration-registry.php',
+		} );
+	}
+
+	for ( const blockDir of getBlockDirs() ) {
+		for ( const inputPath of findMetadataFiles( blockDir.dir ) ) {
+			entries.push( {
+				inputPath,
+				outputPath: path.join(
+					'blocks',
+					blockDir.slug,
+					path.relative( blockDir.dir, inputPath )
+				),
+			} );
+		}
+	}
+
+	return entries;
+}
+
+function findMetadataFiles( directory ) {
+	const metadataFiles = [];
+
+	for ( const entry of fs.readdirSync( directory, {
+		withFileTypes: true,
+	} ) ) {
+		const entryPath = path.join( directory, entry.name );
+
+		if ( entry.isDirectory() ) {
+			metadataFiles.push( ...findMetadataFiles( entryPath ) );
+			continue;
+		}
+
+		if ( entry.isFile() && isMetadataAsset( entry.name ) ) {
+			metadataFiles.push( entryPath );
+		}
+	}
+
+	return metadataFiles;
+}
+
+function getEditorEntries() {
+	return Object.fromEntries(
+		getBlockDirs().map( ( blockDir ) => [
+			`blocks/${ blockDir.slug }/index`,
+			path.join( blockDir.dir, 'index.tsx' ),
+		] )
+	);
+}
+
+function getOptionalModuleEntries() {
+	const entries = [];
+
+	for ( const blockDir of getBlockDirs() ) {
+		for ( const filename of [
+			'interactivity.ts',
+			'interactivity.js',
+			'view.ts',
+			'view.js',
+		] ) {
+			const entryPath = path.join( blockDir.dir, filename );
+			if ( ! fs.existsSync( entryPath ) ) {
+				continue;
+			}
+
+			entries.push( [
+				`blocks/${ blockDir.slug }/${ filename.replace(
+					/\.[^.]+$/,
+					''
+				) }`,
+				entryPath,
+			] );
+		}
+	}
+
+	return Object.fromEntries( entries );
+}
+
+module.exports = async () => {
+	const { createTypiaWebpackConfig } = await import( '@wp-typia/block-runtime/blocks' );
+
+	return createTypiaWebpackConfig( {
+		defaultConfig,
+		fs,
+		path,
+		getArtifactEntries: getMetadataEntries,
+		getEditorEntries,
+		getOptionalModuleEntries,
+		importTypiaWebpackPlugin: () => import( '@typia/unplugin/webpack' ),
+		moduleEntriesMode: 'replace',
+		nonModuleEntriesMode: 'replace',
+	} );
+};

package/templates/_shared/compound/core/{{slugKebabCase}}.php.mustache

@@ -0,0 +1,51 @@
+<?php
+/**
+ * Plugin Name:       {{title}}
+ * Description:       {{description}}
+ * Version:           0.1.0
+ * Requires at least: 6.7
+ * Tested up to:      6.9
+ * Requires PHP:      8.0
+ * Author:            {{author}}
+ * License:           GPL-2.0-or-later
+ * License URI:       https://www.gnu.org/licenses/gpl-2.0.html
+ * Text Domain:       {{textDomain}}
+ * Domain Path:       /languages
+ */
+
+if ( ! defined( 'ABSPATH' ) ) {
+	exit;
+}
+
+function {{phpPrefix}}_load_textdomain() {
+	load_plugin_textdomain(
+		'{{textDomain}}',
+		false,
+		dirname( plugin_basename( __FILE__ ) ) . '/languages'
+	);
+}
+
+function {{phpPrefix}}_get_build_root() {
+	return __DIR__ . '/build/blocks';
+}
+
+function {{phpPrefix}}_register_blocks() {
+	$build_root = {{phpPrefix}}_get_build_root();
+	if ( ! is_dir( $build_root ) ) {
+		return;
+	}
+
+	$block_dirs = glob( $build_root . '/*', GLOB_ONLYDIR );
+	if ( ! is_array( $block_dirs ) ) {
+		return;
+	}
+
+	foreach ( $block_dirs as $block_dir ) {
+		if ( file_exists( $block_dir . '/block.json' ) ) {
+			register_block_type( $block_dir );
+		}
+	}
+}
+
+add_action( 'init', '{{phpPrefix}}_load_textdomain' );
+add_action( 'init', '{{phpPrefix}}_register_blocks' );

package/templates/_shared/compound/persistence/package.json.mustache

@@ -0,0 +1,50 @@
+{
+  "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": {
+    "add-child": "tsx scripts/add-compound-child.ts",
+    "sync-types": "tsx scripts/sync-types-to-block-json.ts",
+    "sync-rest": "tsx scripts/sync-rest-contracts.ts",
+    "build": "bun run sync-types --check && bun run sync-rest --check && wp-scripts build --experimental-modules",
+    "start": "bun run sync-types && bun run sync-rest && wp-scripts start --experimental-modules",
+    "dev": "bun run start",
+    "typecheck": "bun run sync-types --check && bun run sync-rest --check && tsc --noEmit",
+    "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": {
+		"@wp-typia/block-runtime": "{{blockRuntimePackageVersion}}",
+		"@wp-typia/api-client": "{{apiClientPackageVersion}}",
+		"@wp-typia/block-types": "{{blockTypesPackageVersion}}",
+    "@wp-typia/rest": "{{restPackageVersion}}",
+    "@typia/unplugin": "^12.0.1",
+    "@wordpress/browserslist-config": "^6.42.0",
+    "@wordpress/scripts": "^30.22.0",
+    "@types/react": "^19.2.2",
+    "@types/react-dom": "^19.2.2",
+    "@types/wordpress__block-editor": "^11.5.17",
+    "@types/wordpress__blocks": "^12.5.18",
+    "ajv": "^8.18.0",
+    "eslint-plugin-jsx-a11y": "^6.10.2",
+    "prettier": "2.8.8",
+    "tsx": "^4.20.5",
+    "typescript": "^5.9.2",
+    "typia": "^12.0.1"
+  },
+  "dependencies": {
+    "@wordpress/api-fetch": "^7.42.0",
+    "@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",
+    "@wordpress/interactivity": "^6.29.0"
+  }
+}

package/templates/_shared/compound/persistence/scripts/block-config.ts.mustache

@@ -0,0 +1,59 @@
+import { defineEndpointManifest } from '@wp-typia/block-runtime/metadata-core';
+
+export const BLOCKS = [
+	{
+		apiTypesFile: 'src/blocks/{{slugKebabCase}}/api-types.ts',
+		attributeTypeName: '{{pascalCase}}Attributes',
+		restManifest: defineEndpointManifest( {
+			contracts: {
+				'state-query': {
+					sourceTypeName: '{{pascalCase}}StateQuery',
+				},
+				'write-state-request': {
+					sourceTypeName: '{{pascalCase}}WriteStateRequest',
+				},
+				'state-response': {
+					sourceTypeName: '{{pascalCase}}StateResponse',
+				},
+			},
+			endpoints: [
+				{
+					auth: 'public',
+					method: 'GET',
+					operationId: 'get{{pascalCase}}State',
+					path: '/{{namespace}}/v1/{{slugKebabCase}}/state',
+					queryContract: 'state-query',
+					responseContract: 'state-response',
+					summary: 'Read the current persisted state.',
+					tags: [ '{{title}}' ],
+				},
+				{
+					auth: '{{restWriteAuthIntent}}',
+					bodyContract: 'write-state-request',
+					method: 'POST',
+					operationId: 'write{{pascalCase}}State',
+					path: '/{{namespace}}/v1/{{slugKebabCase}}/state',
+					responseContract: 'state-response',
+					summary: 'Write the current persisted state.',
+					tags: [ '{{title}}' ],
+					wordpressAuth: {
+						mechanism: '{{restWriteAuthMechanism}}',
+					},
+				},
+			],
+			info: {
+				title: '{{title}} REST API',
+				version: '1.0.0',
+			},
+		} ),
+		openApiFile: 'src/blocks/{{slugKebabCase}}/api.openapi.json',
+		slug: '{{slugKebabCase}}',
+		typesFile: 'src/blocks/{{slugKebabCase}}/types.ts',
+	},
+	{
+		slug: '{{slugKebabCase}}-item',
+		attributeTypeName: '{{pascalCase}}ItemAttributes',
+		typesFile: 'src/blocks/{{slugKebabCase}}-item/types.ts',
+	},
+	// add-child: insert new block config entries here
+] as const;

package/templates/_shared/compound/persistence/scripts/sync-rest-contracts.ts.mustache

@@ -0,0 +1,101 @@
+/* eslint-disable no-console */
+import path from 'node:path';
+
+import {
+	syncEndpointClient,
+	syncRestOpenApi,
+	syncTypeSchemas,
+} from '@wp-typia/block-runtime/metadata-core';
+
+import { BLOCKS } from './block-config';
+
+function parseCliOptions( argv: string[] ) {
+	const options = {
+		check: false,
+	};
+
+	for ( const argument of argv ) {
+		if ( argument === '--check' ) {
+			options.check = true;
+			continue;
+		}
+
+		throw new Error( `Unknown sync-rest flag: ${ argument }` );
+	}
+
+	return options;
+}
+
+async function main() {
+	const options = parseCliOptions( process.argv.slice( 2 ) );
+
+	for ( const block of BLOCKS ) {
+		if (
+			! ( 'apiTypesFile' in block ) ||
+			! block.apiTypesFile ||
+			! ( 'restManifest' in block ) ||
+			! block.restManifest
+		) {
+			continue;
+		}
+
+		for ( const [ baseName, contract ] of Object.entries( block.restManifest.contracts ) ) {
+			await syncTypeSchemas( {
+				jsonSchemaFile: path.join(
+					'src',
+					'blocks',
+					block.slug,
+					'api-schemas',
+					`${ baseName }.schema.json`
+				),
+				openApiFile: path.join(
+					'src',
+					'blocks',
+					block.slug,
+					'api-schemas',
+					`${ baseName }.openapi.json`
+				),
+				sourceTypeName: contract.sourceTypeName,
+				typesFile: block.apiTypesFile,
+			}, {
+				check: options.check,
+			} );
+		}
+
+		if ( block.restManifest.endpoints.length > 0 ) {
+			await syncEndpointClient( {
+				clientFile: path.join(
+					'src',
+					'blocks',
+					block.slug,
+					'api-client.ts'
+				),
+				manifest: block.restManifest,
+				typesFile: block.apiTypesFile,
+			}, {
+				check: options.check,
+			} );
+
+			if ( block.openApiFile ) {
+				await syncRestOpenApi( {
+					manifest: block.restManifest,
+					openApiFile: block.openApiFile,
+					typesFile: block.apiTypesFile,
+				}, {
+					check: options.check,
+				} );
+			}
+		}
+	}
+
+	console.log(
+		options.check
+			? '✅ REST contract schemas, portable API clients, and endpoint-aware OpenAPI documents are already up to date with the TypeScript types!'
+			: '✅ REST contract schemas, portable API clients, and endpoint-aware OpenAPI documents generated from TypeScript types!'
+	);
+}
+
+main().catch( ( error ) => {
+	console.error( '❌ REST contract sync failed:', error );
+	process.exit( 1 );
+} );

package/templates/_shared/compound/persistence/src/blocks/{{slugKebabCase}}/api-types.ts.mustache

@@ -0,0 +1,21 @@
+import { tags } from 'typia';
+
+export interface {{pascalCase}}StateQuery {
+	postId: number & tags.Type< 'uint32' >;
+	resourceKey: string & tags.MinLength< 1 > & tags.MaxLength< 100 >;
+}
+
+export interface {{pascalCase}}WriteStateRequest {
+	postId: number & tags.Type< 'uint32' >;
+	{{publicWriteRequestIdDeclaration}}
+	publicWriteToken?: string & tags.MinLength< 1 > & tags.MaxLength< 512 >;
+	resourceKey: string & tags.MinLength< 1 > & tags.MaxLength< 100 >;
+	delta?: number & tags.Minimum< 1 > & tags.Type< 'uint32' > & tags.Default< 1 >;
+}
+
+export interface {{pascalCase}}StateResponse {
+	postId: number & tags.Type< 'uint32' >;
+	resourceKey: string & tags.MinLength< 1 > & tags.MaxLength< 100 >;
+	count: number & tags.Minimum< 0 > & tags.Type< 'uint32' >;
+	storage: ( 'post-meta' | 'custom-table' );
+}

package/templates/_shared/compound/persistence/src/blocks/{{slugKebabCase}}/api-validators.ts.mustache

@@ -0,0 +1,32 @@
+import typia from 'typia';
+
+import {
+	toValidationResult,
+	type ValidationResult,
+} from '@wp-typia/api-client';
+import type {
+	{{pascalCase}}StateQuery,
+	{{pascalCase}}StateResponse,
+	{{pascalCase}}WriteStateRequest,
+} from './api-types';
+
+const validateStateQuery = typia.createValidate< {{pascalCase}}StateQuery >();
+const validateWriteStateRequest =
+	typia.createValidate< {{pascalCase}}WriteStateRequest >();
+const validateStateResponse =
+	typia.createValidate< {{pascalCase}}StateResponse >();
+
+export const apiValidators = {
+	stateQuery: (
+		input: unknown
+	): ValidationResult< {{pascalCase}}StateQuery > =>
+		toValidationResult( validateStateQuery( input ) ),
+	stateResponse: (
+		input: unknown
+	): ValidationResult< {{pascalCase}}StateResponse > =>
+		toValidationResult( validateStateResponse( input ) ),
+	writeStateRequest: (
+		input: unknown
+	): ValidationResult< {{pascalCase}}WriteStateRequest > =>
+		toValidationResult( validateWriteStateRequest( input ) ),
+};

package/templates/_shared/compound/persistence/src/blocks/{{slugKebabCase}}/api.ts.mustache

@@ -0,0 +1,68 @@
+import {
+	callEndpoint,
+	resolveRestRouteUrl,
+} from '@wp-typia/rest';
+
+import {
+	type {{pascalCase}}StateQuery,
+	type {{pascalCase}}WriteStateRequest,
+} from './api-types';
+import {
+	get{{pascalCase}}StateEndpoint,
+	write{{pascalCase}}StateEndpoint,
+} from './api-client';
+
+export function resolveRestNonce( fallback?: string ): string | undefined {
+	if ( typeof fallback === 'string' && fallback.length > 0 ) {
+		return fallback;
+	}
+
+	if ( typeof window === 'undefined' ) {
+		return undefined;
+	}
+
+	const wpApiSettings = ( window as typeof window & {
+		wpApiSettings?: { nonce?: string };
+	} ).wpApiSettings;
+
+	return typeof wpApiSettings?.nonce === 'string' && wpApiSettings.nonce.length > 0
+		? wpApiSettings.nonce
+		: undefined;
+}
+
+export const stateEndpoint = {
+	...get{{pascalCase}}StateEndpoint,
+	buildRequestOptions: () => ( {
+		url: resolveRestRouteUrl( get{{pascalCase}}StateEndpoint.path ),
+	} ),
+};
+
+export const writeStateEndpoint = {
+	...write{{pascalCase}}StateEndpoint,
+	buildRequestOptions: () => ( {
+		url: resolveRestRouteUrl( write{{pascalCase}}StateEndpoint.path ),
+	} ),
+};
+
+export function fetchState(
+	request: {{pascalCase}}StateQuery
+) {
+	return callEndpoint( stateEndpoint, request );
+}
+
+export function writeState(
+	request: {{pascalCase}}WriteStateRequest,
+	restNonce?: string
+) {
+	const nonce = resolveRestNonce( restNonce );
+
+	return callEndpoint( writeStateEndpoint, request, {
+		requestOptions: nonce
+			? {
+					headers: {
+						'X-WP-Nonce': nonce,
+					},
+				}
+			: undefined,
+	} );
+}

package/templates/_shared/compound/persistence/src/blocks/{{slugKebabCase}}/block.json.mustache

@@ -0,0 +1,52 @@
+{
+	"$schema": "https://schemas.wp.org/trunk/block.json",
+	"apiVersion": 3,
+	"name": "{{namespace}}/{{slugKebabCase}}",
+	"version": "{{blockMetadataVersion}}",
+	"title": {{titleJson}},
+	"category": "{{category}}",
+	"icon": "{{icon}}",
+	"description": "{{description}}",
+	"example": {},
+	"supports": {
+		"html": false,
+		"anchor": true,
+		"className": true,
+		"interactivity": true
+	},
+	"attributes": {
+		"heading": {
+			"type": "string",
+			"source": "html",
+			"selector": ".{{cssClassName}}__heading",
+			"default": {{titleJson}}
+		},
+		"intro": {
+			"type": "string",
+			"source": "html",
+			"selector": ".{{cssClassName}}__intro",
+			"default": "Add and reorder internal items inside this compound block."
+		},
+		"showDividers": {
+			"type": "boolean",
+			"default": true
+		},
+		"showCount": {
+			"type": "boolean",
+			"default": true
+		},
+		"buttonLabel": {
+			"type": "string",
+			"default": "Persist Count"
+		},
+		"resourceKey": {
+			"type": "string",
+			"default": ""
+		}
+	},
+	"textdomain": "{{textDomain}}",
+	"editorScript": "file:./index.js",
+	"style": "file:./style-index.css",
+	"viewScriptModule": "file:./interactivity.js",
+	"render": "file:./render.php"
+}