@wp-typia/project-tools 0.15.0 → 0.15.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wp-typia/project-tools",
-  "version": "0.15.0",
+  "version": "0.15.2",
   "description": "Project orchestration and programmatic tooling for wp-typia",
   "packageManager": "bun@1.3.11",
   "type": "module",
@@ -26,9 +26,9 @@
     "package.json"
   ],
   "scripts": {
-    "build": "bun run --filter @wp-typia/block-runtime build && rm -rf dist && tsc -p tsconfig.runtime.json",
-    "test": "bun run --filter @wp-typia/block-runtime build && bun run build && bun test tests/*.test.ts",
-    "test:coverage": "bun run --filter @wp-typia/block-runtime build && bun run build && bun test tests/*.test.ts --coverage --coverage-reporter=lcov --coverage-dir=coverage",
+    "build": "bun run --filter @wp-typia/api-client build && bun run --filter @wp-typia/block-runtime build && rm -rf dist && tsc -p tsconfig.runtime.json",
+    "test": "bun run build && bun test tests/*.test.ts",
+    "test:coverage": "bun run build && bun test tests/*.test.ts --coverage --coverage-reporter=lcov --coverage-dir=coverage",
     "clean": "rm -rf dist",
     "prepack": "bun run build"
   },
@@ -61,14 +61,15 @@
     "bun": ">=1.3.11"
   },
   "dependencies": {
-    "@wp-typia/api-client": "^0.4.0",
-    "@wp-typia/block-runtime": "^0.4.0",
-    "@wp-typia/rest": "^0.3.4",
-    "@wp-typia/block-types": "^0.2.0",
+    "@wp-typia/api-client": "^0.4.2",
+    "@wp-typia/block-runtime": "^0.4.2",
+    "@wp-typia/rest": "^0.3.5",
+    "@wp-typia/block-types": "^0.2.1",
     "mustache": "^4.2.0",
     "npm-package-arg": "^13.0.0",
     "semver": "^7.7.3",
     "tar": "^7.4.3",
+    "typia": "^12.0.1",
     "typescript": "^5.9.2"
   },
   "devDependencies": {

package/templates/_shared/compound/core/scripts/add-compound-child.ts.mustache

@@ -2,14 +2,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 
-const PARENT_BLOCK_NAME = '{{namespace}}/{{slugKebabCase}}';
-const PARENT_BLOCK_NAMESPACE = '{{namespace}}';
-const PARENT_BLOCK_SLUG = '{{slugKebabCase}}';
-const PARENT_BLOCK_TITLE = {{titleJson}};
-const PARENT_TYPE_NAME = '{{pascalCase}}';
-const PARENT_STYLE_IMPORT = '../{{slugKebabCase}}/style.scss';
 const PROJECT_ROOT = process.cwd();
-const TEXT_DOMAIN = '{{textDomain}}';
 
 const ALLOWED_CHILD_MARKER = '// add-child: insert new allowed child block names here';
 const BLOCK_CONFIG_MARKER = '// add-child: insert new block config entries here';
@@ -22,6 +15,16 @@ type StarterManifestDocument = {
 	sourceType: string;
 };
 
+type CompoundParentConfig = {
+	blockName: string;
+	namespace: string;
+	slug: string;
+	styleImport: string;
+	textDomain: string;
+	title: string;
+	typeName: string;
+};
+
 function parseArgs() {
 	const args = process.argv.slice( 2 );
 	const parsed: {
@@ -81,6 +84,26 @@ function toTitleCase( input: string ): string {
 		.join( ' ' );
 }
 
+function readJsonFile( filePath: string ): Record< string, unknown > {
+	let parsed: unknown;
+
+	try {
+		parsed = JSON.parse( fs.readFileSync( filePath, 'utf8' ) );
+	} catch ( error ) {
+		const errorMessage = error instanceof Error ? error.message : String( error );
+		throw new Error(
+			`Unable to parse JSON from ${ filePath }: ${ errorMessage }`,
+			{ cause: error instanceof Error ? error : undefined }
+		);
+	}
+
+	if ( ! parsed || typeof parsed !== 'object' || Array.isArray( parsed ) ) {
+		throw new Error( `${ filePath } must contain a JSON object.` );
+	}
+
+	return parsed as Record< string, unknown >;
+}
+
 function resolveValidatedNamespace( value: string ): string {
 	const normalizedNamespace = toKebabCase( value );
 
@@ -101,6 +124,79 @@ function resolveValidatedBlockSlug( value: string ): string {
 	return normalizedSlug;
 }
 
+function resolveCompoundParentConfig(): CompoundParentConfig {
+	const blocksRoot = path.join( PROJECT_ROOT, 'src', 'blocks' );
+
+	if ( ! fs.existsSync( blocksRoot ) ) {
+		throw new Error(
+			'This command expects a compound scaffold with src/blocks/<parent>/children.ts and scripts/block-config.ts.'
+		);
+	}
+
+	const parentCandidates = fs
+		.readdirSync( blocksRoot, { withFileTypes: true } )
+		.filter( ( entry ) => entry.isDirectory() )
+		.map( ( entry ) => path.join( blocksRoot, entry.name ) )
+		.filter( ( candidateDir ) =>
+			fs.existsSync( path.join( candidateDir, 'children.ts' ) )
+		);
+
+	if ( parentCandidates.length !== 1 ) {
+		throw new Error(
+			`Unable to resolve the compound parent block. Expected exactly one src/blocks/<parent>/children.ts entry, found ${ parentCandidates.length }.`
+		);
+	}
+
+	const parentDir = parentCandidates[ 0 ];
+	const parentSlug = resolveValidatedBlockSlug( path.basename( parentDir ) );
+	const blockJsonPath = path.join( parentDir, 'block.json' );
+
+	if ( ! fs.existsSync( blockJsonPath ) ) {
+		throw new Error( `Unable to resolve ${ blockJsonPath } for the compound parent block.` );
+	}
+
+	const blockJson = readJsonFile( blockJsonPath );
+	const blockName = typeof blockJson.name === 'string' ? blockJson.name.trim() : '';
+	const separatorIndex = blockName.indexOf( '/' );
+
+	if ( separatorIndex <= 0 || separatorIndex === blockName.length - 1 ) {
+		throw new Error(
+			`The parent block metadata at ${ blockJsonPath } must declare a valid "name" like "namespace/slug".`
+		);
+	}
+
+	const namespace = resolveValidatedNamespace( blockName.slice( 0, separatorIndex ) );
+	const title =
+		typeof blockJson.title === 'string' && blockJson.title.trim().length > 0
+			? blockJson.title.trim()
+			: toTitleCase( parentSlug );
+	const textDomain =
+		typeof blockJson.textdomain === 'string' &&
+		blockJson.textdomain.trim().length > 0
+			? blockJson.textdomain.trim()
+			: parentSlug;
+
+	return {
+		blockName,
+		namespace,
+		slug: parentSlug,
+		styleImport: `../${ parentSlug }/style.scss`,
+		textDomain,
+		title,
+		typeName: toPascalCase( parentSlug ),
+	};
+}
+
+const {
+	blockName: PARENT_BLOCK_NAME,
+	namespace: PARENT_BLOCK_NAMESPACE,
+	slug: PARENT_BLOCK_SLUG,
+	styleImport: PARENT_STYLE_IMPORT,
+	textDomain: TEXT_DOMAIN,
+	title: PARENT_BLOCK_TITLE,
+	typeName: PARENT_TYPE_NAME,
+} = resolveCompoundParentConfig();
+
 function buildBlockCssClassName( namespace: string, slug: string ): string {
 	const normalizedSlug = resolveValidatedBlockSlug( slug );
 	const normalizedNamespace =

package/templates/_shared/persistence/core/src/api-validators.ts.mustache

@@ -5,11 +5,17 @@ import {
 	type ValidationResult,
 } from '@wp-typia/api-client';
 import type {
+	{{pascalCase}}BootstrapQuery,
+	{{pascalCase}}BootstrapResponse,
 	{{pascalCase}}StateQuery,
 	{{pascalCase}}StateResponse,
 	{{pascalCase}}WriteStateRequest,
 } from './api-types';
 
+const validateBootstrapQuery =
+	typia.createValidate< {{pascalCase}}BootstrapQuery >();
+const validateBootstrapResponse =
+	typia.createValidate< {{pascalCase}}BootstrapResponse >();
 const validateStateQuery = typia.createValidate< {{pascalCase}}StateQuery >();
 const validateWriteStateRequest =
 	typia.createValidate< {{pascalCase}}WriteStateRequest >();
@@ -17,6 +23,14 @@ const validateStateResponse =
 	typia.createValidate< {{pascalCase}}StateResponse >();
 
 export const apiValidators = {
+	bootstrapQuery: (
+		input: unknown
+	): ValidationResult< {{pascalCase}}BootstrapQuery > =>
+		toValidationResult( validateBootstrapQuery( input ) ),
+	bootstrapResponse: (
+		input: unknown
+	): ValidationResult< {{pascalCase}}BootstrapResponse > =>
+		toValidationResult( validateBootstrapResponse( input ) ),
 	stateQuery: (
 		input: unknown
 	): ValidationResult< {{pascalCase}}StateQuery > =>

package/templates/_shared/persistence/core/src/api.ts.mustache

@@ -1,5 +1,6 @@
 import {
 	callEndpoint,
+	type ApiEndpoint as RestApiEndpoint,
 } from '@wp-typia/rest';
 
 import {
@@ -17,17 +18,35 @@ import {
 	type PersistenceTransportOptions,
 } from './transport';
 
-export const bootstrapEndpoint = {
-	...get{{pascalCase}}BootstrapEndpoint,
-};
+function createRestEndpoint< Req, Res >(
+	endpoint: {
+		method: RestApiEndpoint< Req, Res >[ 'method' ];
+		path: string;
+		validateRequest: RestApiEndpoint< Req, Res >[ 'validateRequest' ];
+		validateResponse: RestApiEndpoint< Req, Res >[ 'validateResponse' ];
+	}
+): RestApiEndpoint< Req, Res > {
+	// Strip generator-only helper fields so the runtime client only sees the
+	// canonical RestApiEndpoint surface it expects.
+	return {
+		method: endpoint.method,
+		path: endpoint.path,
+		validateRequest: endpoint.validateRequest,
+		validateResponse: endpoint.validateResponse,
+	};
+}
+
+export const bootstrapEndpoint = createRestEndpoint(
+	get{{pascalCase}}BootstrapEndpoint
+);
 
-export const stateEndpoint = {
-	...get{{pascalCase}}StateEndpoint,
-};
+export const stateEndpoint = createRestEndpoint(
+	get{{pascalCase}}StateEndpoint
+);
 
-export const writeStateEndpoint = {
-	...write{{pascalCase}}StateEndpoint,
-};
+export const writeStateEndpoint = createRestEndpoint(
+	write{{pascalCase}}StateEndpoint
+);
 
 export function fetchState(
 	request: {{pascalCase}}StateQuery,

package/templates/_shared/persistence/core/src/interactivity.ts.mustache

@@ -7,6 +7,9 @@ import type {
 	{{pascalCase}}Context,
 	{{pascalCase}}State,
 } from './types';
+import type {
+	{{pascalCase}}WriteStateRequest,
+} from './api-types';
 
 function hasExpiredPublicWriteToken(
 	expiresAt?: number
@@ -123,6 +126,7 @@ const { actions, state } = store( '{{slugKebabCase}}', {
 			let bootstrapSucceeded = false;
 			let lastBootstrapError =
 				'Unable to initialize write access';
+			const includeRestNonce = {{isAuthenticatedPersistencePolicy}};
 
 			for ( let attempt = 1; attempt <= BOOTSTRAP_MAX_ATTEMPTS; attempt += 1 ) {
 				try {
@@ -156,6 +160,8 @@ const { actions, state } = store( '{{slugKebabCase}}', {
 							? result.data.publicWriteToken
 							: '';
 					clientState.writeNonce =
+						includeRestNonce &&
+						'restNonce' in result.data &&
 						typeof result.data.restNonce === 'string' &&
 						result.data.restNonce.length > 0
 							? result.data.restNonce
@@ -231,20 +237,20 @@ const { actions, state } = store( '{{slugKebabCase}}', {
 			context.error = '';
 
 			try {
-				const result = await writeState( {
+				const request = {
 					delta: 1,
 					postId: context.postId,
-					publicWriteRequestId:
-						context.persistencePolicy === 'public'
-							? generatePublicWriteRequestId()
-							: undefined,
-					publicWriteToken:
-						context.persistencePolicy === 'public' &&
-						clientState.writeToken.length > 0
-							? clientState.writeToken
-							: undefined,
 					resourceKey: context.resourceKey,
-				}, {
+				} as {{pascalCase}}WriteStateRequest;
+				if ( {{isPublicPersistencePolicy}} ) {
+					request.publicWriteRequestId =
+						generatePublicWriteRequestId() as {{pascalCase}}WriteStateRequest[ 'publicWriteRequestId' ];
+					if ( clientState.writeToken.length > 0 ) {
+						request.publicWriteToken =
+							clientState.writeToken as {{pascalCase}}WriteStateRequest[ 'publicWriteToken' ];
+					}
+				}
+				const result = await writeState( request, {
 					restNonce:
 						clientState.writeNonce.length > 0
 							? clientState.writeNonce

package/templates/interactivity/src/block.json.mustache

@@ -68,6 +68,7 @@
 	},
 	"textdomain": "{{textDomain}}",
 	"editorScript": "file:./index.js",
+	"editorStyle": "file:./index.css",
 	"style": "file:./style-index.css",
 	"viewScriptModule": "file:./interactivity.js"
 }

package/templates/interactivity/src/editor.scss.mustache

@@ -0,0 +1,8 @@
+/**
+ * {{title}} Block Editor Styles
+ */
+
+.{{cssClassName}} {
+	outline: 1px dashed #ddd;
+	outline-offset: -1px;
+}

package/templates/interactivity/src/index.tsx.mustache

@@ -9,6 +9,7 @@ import {
 import Edit from './edit';
 import Save from './save';
 import metadata from './block.json';
+import './editor.scss';
 import './style.scss';
 
 import type { {{pascalCase}}Attributes } from './types';

package/templates/persistence/src/edit.tsx.mustache

@@ -66,15 +66,15 @@ export default function Edit( {
 		validateEditorUpdate
 	);
 	const alignmentValue = editorFields.getStringValue(
-		attributes,
+		attributes as unknown as Record< string, unknown >,
 		'alignment',
 		'left'
 	);
 	const persistencePolicy = '{{persistencePolicy}}';
-	const persistencePolicyDescription =
-		persistencePolicy === 'authenticated'
-			? __( 'Writes require a logged-in user and a valid REST nonce.', '{{textDomain}}' )
-			: __( 'Anonymous writes use signed short-lived public tokens, per-request ids, and coarse rate limiting.', '{{textDomain}}' );
+	const persistencePolicyDescription = __(
+		{{persistencePolicyDescriptionJson}},
+		'{{textDomain}}'
+	);
 
 	return (
 		<>
@@ -91,7 +91,7 @@ export default function Edit( {
 			</BlockControls>
 			<InspectorControls>
 				<InspectorFromManifest
-					attributes={ attributes }
+					attributes={ attributes as unknown as Record< string, unknown > }
 					fieldLookup={ editorFields }
 					onChange={ updateField }
 					paths={ [ 'alignment', 'isVisible', 'showCount', 'buttonLabel' ] }