@wp-typia/create-workspace-template 0.12.0

package/README.md

@@ -0,0 +1,17 @@
+# `@wp-typia/create-workspace-template`
+
+The official empty workspace template for `wp-typia`.
+
+Use it through the canonical CLI:
+
+```bash
+npx wp-typia create my-plugin --template @wp-typia/create-workspace-template
+```
+
+The generated project starts with an empty `src/blocks/*` workspace shell and is designed to grow through:
+
+```bash
+wp-typia add block my-block --template basic
+wp-typia add binding-source hero-data
+wp-typia add hooked-block my-block --anchor core/post-content --position after
+```

package/README.md.mustache

@@ -0,0 +1,39 @@
+# {{title}}
+
+{{description}}
+
+## Workspace
+
+This scaffold is the official empty `wp-typia` workspace shell. It starts with
+an empty `src/blocks/*` inventory and grows through `wp-typia add`.
+
+## First Block
+
+```bash
+wp-typia add block counter-card --template basic
+```
+
+Persistence-ready blocks and compound parent/child blocks can be added later:
+
+```bash
+wp-typia add block counter-card --template persistence --data-storage custom-table --persistence-policy authenticated
+wp-typia add block faq-stack --template compound --data-storage custom-table --persistence-policy public
+```
+
+Variations and patterns can also be added after the first block exists:
+
+```bash
+wp-typia add variation hero-card --block counter-card
+wp-typia add pattern hero-layout
+```
+
+## Development
+
+```bash
+bun run build
+bun run typecheck
+```
+
+If you scaffolded the workspace with `--with-migration-ui`, the migration
+workspace is seeded at `v1` and `wp-typia add block` updates the migration
+config plus current-version snapshots for newly added blocks.

package/languages/.gitkeep

@@ -0,0 +1 @@
+

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@wp-typia/create-workspace-template",
+  "version": "0.12.0",
+  "description": "Official empty wp-typia workspace template package",
+  "packageManager": "bun@1.3.11",
+  "type": "module",
+  "files": [
+    "package.json.mustache",
+    "tsconfig.json.mustache",
+    "webpack.config.js.mustache",
+    "scripts/",
+    "src/",
+    "languages/",
+    "*.php.mustache",
+    "README.md.mustache",
+    "README.md",
+    "package.json"
+  ],
+  "keywords": [
+    "wordpress",
+    "gutenberg",
+    "typia",
+    "workspace",
+    "template",
+    "scaffold"
+  ],
+  "author": "imjlk",
+  "license": "GPL-2.0-or-later",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/imjlk/wp-typia.git",
+    "directory": "packages/create-workspace-template"
+  },
+  "bugs": {
+    "url": "https://github.com/imjlk/wp-typia/issues"
+  },
+  "homepage": "https://github.com/imjlk/wp-typia/tree/main/packages/create-workspace-template#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=20.0.0",
+    "npm": ">=10.0.0",
+    "bun": ">=1.3.11"
+  }
+}

package/package.json.mustache

@@ -0,0 +1,53 @@
+{
+  "name": "{{slug}}",
+  "version": "0.1.0",
+  "packageManager": "bun@1.3.11",
+  "description": "{{description}}",
+  "author": "{{author}}",
+  "license": "GPL-2.0-or-later",
+  "scripts": {
+    "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 && node scripts/build-workspace.mjs build",
+    "start": "bun run sync-types && bun run sync-rest && node scripts/build-workspace.mjs start",
+    "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"
+  },
+  "wpTypia": {
+    "projectType": "workspace",
+    "templatePackage": "@wp-typia/create-workspace-template",
+    "namespace": "{{namespace}}",
+    "textDomain": "{{textDomain}}",
+    "phpPrefix": "{{phpPrefix}}"
+  },
+  "devDependencies": {
+    "@wp-typia/api-client": "{{apiClientPackageVersion}}",
+    "@wp-typia/block-runtime": "{{blockRuntimePackageVersion}}",
+    "@wp-typia/block-types": "{{blockTypesPackageVersion}}",
+    "@wp-typia/rest": "{{restPackageVersion}}",
+    "@typia/unplugin": "^12.0.1",
+    "@types/node": "^24.5.2",
+    "@types/wordpress__block-editor": "^11.5.17",
+    "@types/wordpress__blocks": "^12.5.18",
+    "@wordpress/browserslist-config": "^6.42.0",
+    "@wordpress/scripts": "^30.22.0",
+    "ajv": "^8.18.0",
+    "eslint-plugin-jsx-a11y": "^6.10.2",
+    "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/scripts/block-config.ts.mustache

@@ -0,0 +1,43 @@
+export interface WorkspaceBlockConfig {
+	slug: string;
+	attributeTypeName: string;
+	typesFile: string;
+	apiTypesFile?: string;
+	openApiFile?: string;
+	restManifest?: ReturnType<
+		typeof import( '@wp-typia/block-runtime/metadata-core' ).defineEndpointManifest
+	>;
+}
+
+export interface WorkspaceVariationConfig {
+	block: string;
+	file: string;
+	slug: string;
+}
+
+export interface WorkspacePatternConfig {
+	file: string;
+	slug: string;
+}
+
+export interface WorkspaceBindingSourceConfig {
+	editorFile: string;
+	serverFile: string;
+	slug: string;
+}
+
+export const BLOCKS: WorkspaceBlockConfig[] = [
+	// wp-typia add block entries
+];
+
+export const VARIATIONS: WorkspaceVariationConfig[] = [
+	// wp-typia add variation entries
+];
+
+export const PATTERNS: WorkspacePatternConfig[] = [
+	// wp-typia add pattern entries
+];
+
+export const BINDING_SOURCES: WorkspaceBindingSourceConfig[] = [
+	// wp-typia add binding-source entries
+];

package/scripts/build-workspace.mjs.mustache

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
+
+function getBlockRoot() {
+	return path.join( process.cwd(), 'src', 'blocks' );
+}
+
+function getBlockSlugs() {
+	const blockRoot = getBlockRoot();
+	if ( ! fs.existsSync( blockRoot ) ) {
+		return [];
+	}
+
+	return fs
+		.readdirSync( blockRoot, { withFileTypes: true } )
+		.filter( ( entry ) => entry.isDirectory() )
+		.map( ( entry ) => entry.name )
+		.sort();
+}
+
+function hasSharedEditorEntries() {
+	for ( const relativePath of [ 'src/bindings/index.ts', 'src/bindings/index.js' ] ) {
+		if ( fs.existsSync( path.join( process.cwd(), relativePath ) ) ) {
+			return true;
+		}
+	}
+
+	return false;
+}
+
+function ensureEmptyWorkspaceArtifacts() {
+	const buildBlocksDir = path.join( process.cwd(), 'build', 'blocks' );
+	const manifestPath = path.join( process.cwd(), 'build', 'blocks-manifest.php' );
+	fs.rmSync( buildBlocksDir, { force: true, recursive: true } );
+	fs.mkdirSync( buildBlocksDir, { recursive: true } );
+	fs.writeFileSync(
+		manifestPath,
+		"<?php\nreturn array();\n",
+		'utf8'
+	);
+}
+
+function getWpScriptsBin() {
+	return path.join(
+		process.cwd(),
+		'node_modules',
+		'.bin',
+		process.platform === 'win32' ? 'wp-scripts.cmd' : 'wp-scripts'
+	);
+}
+
+function main() {
+	const mode = process.argv[ 2 ] ?? 'build';
+	const passthroughArgs = process.argv.slice( 3 );
+	if ( mode !== 'build' && mode !== 'start' ) {
+		throw new Error( `Unknown workspace build mode: ${ mode }` );
+	}
+
+	const blockSlugs = getBlockSlugs();
+	const hasSharedEntries = hasSharedEditorEntries();
+	if ( blockSlugs.length === 0 && ! hasSharedEntries ) {
+		ensureEmptyWorkspaceArtifacts();
+		console.log(
+			mode === 'start'
+				? 'ℹ️ No workspace blocks are registered yet. Add one with `wp-typia add block <name> --template basic` before starting the watcher.'
+				: 'ℹ️ No workspace blocks are registered yet. Empty workspace build artifacts are up to date.'
+		);
+		return;
+	}
+
+	execFileSync(
+		getWpScriptsBin(),
+		[ mode, '--experimental-modules', '--blocks-manifest', ...passthroughArgs ],
+		{
+			cwd: process.cwd(),
+			stdio: 'inherit',
+		}
+	);
+
+	if ( blockSlugs.length === 0 ) {
+		ensureEmptyWorkspaceArtifacts();
+	}
+}
+
+main();

package/scripts/sync-rest-contracts.ts.mustache

@@ -0,0 +1,124 @@
+/* eslint-disable no-console */
+import path from 'node:path';
+
+import {
+	syncEndpointClient,
+	syncRestOpenApi,
+	syncTypeSchemas,
+} from '@wp-typia/block-runtime/metadata-core';
+
+import { BLOCKS, type WorkspaceBlockConfig } 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;
+}
+
+function isRestEnabledBlock(
+	block: WorkspaceBlockConfig
+): block is WorkspaceBlockConfig & {
+	apiTypesFile: string;
+	openApiFile: string;
+	restManifest: NonNullable< WorkspaceBlockConfig[ 'restManifest' ] >;
+} {
+	return (
+		typeof block.apiTypesFile === 'string' &&
+		typeof block.openApiFile === 'string' &&
+		typeof block.restManifest === 'object' &&
+		block.restManifest !== null
+	);
+}
+
+async function main() {
+	const options = parseCliOptions( process.argv.slice( 2 ) );
+	const restBlocks = BLOCKS.filter( isRestEnabledBlock );
+
+	if ( restBlocks.length === 0 ) {
+		console.log(
+			options.check
+				? 'ℹ️ No REST-enabled workspace blocks are registered yet. `sync-rest --check` is already clean.'
+				: 'ℹ️ No REST-enabled workspace blocks are registered yet.'
+		);
+		return;
+	}
+
+	for ( const block of restBlocks ) {
+		const contracts = block.restManifest.contracts;
+
+		for ( const [ baseName, contract ] of Object.entries( 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,
+				}
+			);
+		}
+
+		await syncRestOpenApi(
+			{
+				manifest: block.restManifest,
+				openApiFile: block.openApiFile,
+				typesFile: block.apiTypesFile,
+			},
+			{
+				check: options.check,
+			}
+		);
+
+		await syncEndpointClient(
+			{
+				clientFile: path.join(
+					'src',
+					'blocks',
+					block.slug,
+					'api-client.ts'
+				),
+				manifest: block.restManifest,
+				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/scripts/sync-types-to-block-json.ts.mustache

@@ -0,0 +1,65 @@
+/* eslint-disable no-console */
+import path from 'node:path';
+
+import { syncBlockMetadata } 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-types flag: ${ argument }` );
+	}
+
+	return options;
+}
+
+async function main() {
+	const options = parseCliOptions( process.argv.slice( 2 ) );
+
+	if ( BLOCKS.length === 0 ) {
+		console.log(
+			options.check
+				? 'ℹ️ No workspace blocks are registered yet. `sync-types --check` is already clean.'
+				: 'ℹ️ No workspace blocks are registered yet. Add one with `wp-typia add block <name> --template basic`.'
+		);
+		return;
+	}
+
+	for ( const block of BLOCKS ) {
+		const baseDir = path.join( 'src', 'blocks', block.slug );
+		const result = await syncBlockMetadata(
+			{
+				blockJsonFile: path.join( baseDir, 'block.json' ),
+				jsonSchemaFile: path.join( baseDir, 'typia.schema.json' ),
+				manifestFile: path.join( baseDir, 'typia.manifest.json' ),
+				openApiFile: path.join( baseDir, 'typia.openapi.json' ),
+				sourceTypeName: block.attributeTypeName,
+				typesFile: block.typesFile,
+			},
+			{
+				check: options.check,
+			}
+		);
+
+		console.log(
+			options.check
+				? `✅ ${ block.slug }: block.json, typia.manifest.json, typia-validator.php, typia.schema.json, and typia.openapi.json are already up to date with the TypeScript types!`
+				: `✅ ${ block.slug }: block.json, typia.manifest.json, typia-validator.php, typia.schema.json, and typia.openapi.json were generated from TypeScript types!`
+		);
+		console.log( '📝 Generated attributes:', result.attributeNames );
+	}
+}
+
+main().catch( ( error ) => {
+	console.error( '❌ Type sync failed:', error );
+	process.exit( 1 );
+} );

package/src/bindings/.gitkeep

@@ -0,0 +1 @@
+

package/src/blocks/.gitkeep

@@ -0,0 +1 @@
+

package/src/collection.ts.mustache

@@ -0,0 +1,14 @@
+import { registerBlockCollection } from '@wordpress/blocks';
+
+const globalScope = globalThis as typeof globalThis & {
+	__wpTypiaCollections?: Record< string, true >;
+};
+
+globalScope.__wpTypiaCollections ??= {};
+
+if ( ! globalScope.__wpTypiaCollections[ '{{namespace}}' ] ) {
+	registerBlockCollection( '{{namespace}}', {
+		title: '{{title}}',
+	} );
+	globalScope.__wpTypiaCollections[ '{{namespace}}' ] = true;
+}

package/src/patterns/.gitkeep

@@ -0,0 +1 @@
+

package/tsconfig.json.mustache

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "lib": ["ES2020", "DOM", "DOM.Iterable"],
+    "jsx": "react-jsx",
+    "strict": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "baseUrl": ".",
+    "types": ["node", "wordpress__block-editor", "wordpress__blocks"]
+  },
+  "include": ["src/**/*", "scripts/**/*"],
+  "exclude": ["node_modules", "build"]
+}

package/webpack.config.js.mustache

@@ -0,0 +1,267 @@
+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.schema.json',
+	'typia-validator.php',
+] );
+
+function isMetadataAsset( filename ) {
+	return (
+		STATIC_METADATA_FILENAMES.has( filename ) ||
+		filename.endsWith( '.schema.json' ) ||
+		filename.endsWith( '.openapi.json' )
+	);
+}
+
+function normalizeScriptModuleAssetSource( source ) {
+	return String( source ).replace(
+		/'dependencies'\s*=>\s*array\([^)]*\)/,
+		"'dependencies' => array()"
+	);
+}
+
+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 = [];
+
+	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 isScriptModuleAsset( assetName ) {
+	return /(^|\/)(interactivity|view)\.asset\.php$/.test( assetName );
+}
+
+function normalizeScriptModuleAssetsInDirectory( directory ) {
+	if ( ! fs.existsSync( directory ) ) {
+		return;
+	}
+
+	for ( const entry of fs.readdirSync( directory, {
+		withFileTypes: true,
+	} ) ) {
+		const entryPath = path.join( directory, entry.name );
+		if ( entry.isDirectory() ) {
+			normalizeScriptModuleAssetsInDirectory( entryPath );
+			continue;
+		}
+		if ( entry.isFile() && isScriptModuleAsset( entryPath ) ) {
+			fs.writeFileSync(
+				entryPath,
+				normalizeScriptModuleAssetSource(
+					fs.readFileSync( entryPath, 'utf8' )
+				)
+			);
+		}
+	}
+}
+
+class MetadataAssetPlugin {
+	apply( compiler ) {
+		compiler.hooks.thisCompilation.tap(
+			'WorkspaceMetadataAssetPlugin',
+			( compilation ) => {
+				compilation.hooks.processAssets.tap(
+					{
+						name: 'WorkspaceMetadataAssetPlugin',
+						stage: compiler.webpack.Compilation
+							.PROCESS_ASSETS_STAGE_ADDITIONS,
+					},
+					() => {
+						for ( const entry of getMetadataEntries() ) {
+							if ( compilation.getAsset( entry.outputPath ) ) {
+								continue;
+							}
+
+							compilation.emitAsset(
+								entry.outputPath,
+								new compiler.webpack.sources.RawSource(
+									fs.readFileSync( entry.inputPath )
+								)
+							);
+						}
+
+						for ( const asset of compilation.getAssets() ) {
+							if ( ! isScriptModuleAsset( asset.name ) ) {
+								continue;
+							}
+
+							compilation.updateAsset(
+								asset.name,
+								new compiler.webpack.sources.RawSource(
+									normalizeScriptModuleAssetSource(
+										asset.source.source()
+									)
+								)
+							);
+						}
+					}
+				);
+			}
+		);
+
+		compiler.hooks.afterEmit.tap(
+			'WorkspaceMetadataAssetPlugin',
+			( compilation ) => {
+				if ( ! compilation.outputOptions.path ) {
+					return;
+				}
+
+				normalizeScriptModuleAssetsInDirectory(
+					compilation.outputOptions.path
+				);
+			}
+		);
+	}
+}
+
+function toWebpackConfigs( config ) {
+	return Array.isArray( config ) ? config : [ config ];
+}
+
+function isModuleConfig( config ) {
+	return config?.output?.module === true;
+}
+
+function getEditorEntries() {
+	return Object.fromEntries(
+		getBlockDirs().map( ( blockDir ) => [
+			`blocks/${ blockDir.slug }/index`,
+			path.join( blockDir.dir, 'index.tsx' ),
+		] )
+	);
+}
+
+function getSharedEditorEntries() {
+	const entries = [];
+
+	for ( const relativePath of [ 'src/bindings/index.ts', 'src/bindings/index.js' ] ) {
+		const entryPath = path.resolve( process.cwd(), relativePath );
+		if ( ! fs.existsSync( entryPath ) ) {
+			continue;
+		}
+
+		entries.push( [ 'bindings/index', entryPath ] );
+		break;
+	}
+
+	return Object.fromEntries( entries );
+}
+
+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 { default: UnpluginTypia } = await import(
+		'@typia/unplugin/webpack'
+	);
+	const resolvedDefaultConfig =
+		typeof defaultConfig === 'function'
+			? await defaultConfig()
+			: defaultConfig;
+	const editorEntries = {
+		...getSharedEditorEntries(),
+		...getEditorEntries(),
+	};
+	const moduleEntries = getOptionalModuleEntries();
+	const configs = toWebpackConfigs( resolvedDefaultConfig ).map(
+		( config ) => ( {
+			...config,
+			entry: async () =>
+				isModuleConfig( config ) ? moduleEntries : editorEntries,
+			resolve: {
+				...( config.resolve || {} ),
+				extensionAlias: {
+					...( config.resolve?.extensionAlias || {} ),
+					'.js': [ '.js', '.ts', '.tsx' ],
+				},
+			},
+			plugins: [
+				UnpluginTypia(),
+				...( config.plugins || [] ),
+				new MetadataAssetPlugin(),
+			],
+		} )
+	);
+
+	return configs.length === 1 ? configs[ 0 ] : configs;
+};

package/{{slugKebabCase}}.php.mustache

@@ -0,0 +1,145 @@
+<?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;
+}
+
+foreach ( glob( __DIR__ . '/src/blocks/*/server.php' ) ?: array() as $server_module ) {
+	require_once $server_module;
+}
+
+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}}_get_blocks_manifest_path() {
+	return __DIR__ . '/build/blocks-manifest.php';
+}
+
+function {{phpPrefix}}_register_blocks_from_manifest_fallback() {
+	$build_root     = {{phpPrefix}}_get_build_root();
+	$manifest_path  = {{phpPrefix}}_get_blocks_manifest_path();
+	$manifest_data  = file_exists( $manifest_path ) ? require $manifest_path : array();
+
+	if ( ! is_array( $manifest_data ) || empty( $manifest_data ) ) {
+		$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 );
+			}
+		}
+		return;
+	}
+
+	foreach ( array_keys( $manifest_data ) as $block_name ) {
+		$block_slug = is_string( $block_name ) && str_contains( $block_name, '/' )
+			? substr( $block_name, strpos( $block_name, '/' ) + 1 )
+			: (string) $block_name;
+		$block_dir  = trailingslashit( $build_root ) . $block_slug;
+
+		if ( file_exists( $block_dir . '/block.json' ) ) {
+			register_block_type( $block_dir );
+		}
+	}
+}
+
+function {{phpPrefix}}_register_blocks() {
+	$build_root    = {{phpPrefix}}_get_build_root();
+	$manifest_path = {{phpPrefix}}_get_blocks_manifest_path();
+
+	if ( ! is_dir( $build_root ) ) {
+		return;
+	}
+
+	if (
+		file_exists( $manifest_path ) &&
+		function_exists( 'wp_register_block_metadata_collection' ) &&
+		function_exists( 'wp_register_block_types_from_metadata_collection' )
+	) {
+		wp_register_block_metadata_collection( $build_root, $manifest_path );
+		wp_register_block_types_from_metadata_collection( $build_root, $manifest_path );
+		return;
+	}
+
+	{{phpPrefix}}_register_blocks_from_manifest_fallback();
+}
+
+function {{phpPrefix}}_register_binding_sources() {
+	foreach ( glob( __DIR__ . '/src/bindings/*/server.php' ) ?: array() as $binding_source_module ) {
+		require_once $binding_source_module;
+	}
+}
+
+function {{phpPrefix}}_enqueue_binding_sources_editor() {
+	$script_path = __DIR__ . '/build/bindings/index.js';
+	$asset_path  = __DIR__ . '/build/bindings/index.asset.php';
+
+	if ( ! file_exists( $script_path ) || ! file_exists( $asset_path ) ) {
+		return;
+	}
+
+	$asset = require $asset_path;
+	if ( ! is_array( $asset ) ) {
+		$asset = array();
+	}
+
+	wp_enqueue_script(
+		'{{slugKebabCase}}-binding-sources',
+		plugins_url( 'build/bindings/index.js', __FILE__ ),
+		isset( $asset['dependencies'] ) && is_array( $asset['dependencies'] ) ? $asset['dependencies'] : array(),
+		isset( $asset['version'] ) ? $asset['version'] : filemtime( $script_path ),
+		true
+	);
+}
+
+function {{phpPrefix}}_register_pattern_category() {
+	if ( function_exists( 'register_block_pattern_category' ) ) {
+		register_block_pattern_category(
+			'{{namespace}}',
+			array(
+				'label' => sprintf(
+					__( '%s Patterns', '{{textDomain}}' ),
+					{{titleJson}}
+				),
+			)
+		);
+	}
+}
+
+function {{phpPrefix}}_register_patterns() {
+	foreach ( glob( __DIR__ . '/src/patterns/*.php' ) ?: array() as $pattern_module ) {
+		require $pattern_module;
+	}
+}
+
+add_action( 'init', '{{phpPrefix}}_load_textdomain' );
+add_action( 'init', '{{phpPrefix}}_register_blocks' );
+add_action( 'init', '{{phpPrefix}}_register_binding_sources', 20 );
+add_action( 'init', '{{phpPrefix}}_register_pattern_category' );
+add_action( 'init', '{{phpPrefix}}_register_patterns', 20 );
+add_action( 'enqueue_block_editor_assets', '{{phpPrefix}}_enqueue_binding_sources_editor' );