@wp-typia/project-tools 0.18.0 → 0.19.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wp-typia/project-tools",
-  "version": "0.18.0",
+  "version": "0.19.1",
   "description": "Project orchestration and programmatic tooling for wp-typia",
   "packageManager": "bun@1.3.11",
   "type": "module",
@@ -37,6 +37,11 @@
       "import": "./dist/runtime/cli-scaffold.js",
       "default": "./dist/runtime/cli-scaffold.js"
     },
+    "./compound-inner-blocks": {
+      "types": "./dist/runtime/compound-inner-blocks.d.ts",
+      "import": "./dist/runtime/compound-inner-blocks.js",
+      "default": "./dist/runtime/compound-inner-blocks.js"
+    },
     "./cli-templates": {
       "types": "./dist/runtime/cli-templates.d.ts",
       "import": "./dist/runtime/cli-templates.js",
@@ -62,6 +67,11 @@
       "import": "./dist/runtime/schema-core.js",
       "default": "./dist/runtime/schema-core.js"
     },
+    "./temp-roots": {
+      "types": "./dist/runtime/temp-roots.d.ts",
+      "import": "./dist/runtime/temp-roots.js",
+      "default": "./dist/runtime/temp-roots.js"
+    },
     "./workspace-project": {
       "types": "./dist/runtime/workspace-project.d.ts",
       "import": "./dist/runtime/workspace-project.js",
@@ -86,7 +96,7 @@
     "test:migration-planning": "bun run build && bun test tests/migration-init.test.ts tests/migration-config.test.ts tests/migration-plan-wizard.test.ts",
     "test:migration-execution": "bun run build && bun test tests/migration-scaffold-diff.test.ts tests/migration-doctor.test.ts tests/migration-fixtures-fuzz.test.ts",
     "test:project-tools": "bun run test:scaffold-core && bun run test:workspace && bun run test:compound && bun run test:migration-planning && bun run test:migration-execution",
-    "test:coverage": "bun run build && bun test tests/*.test.ts --coverage --coverage-reporter=lcov --coverage-dir=coverage",
+    "test:coverage": "bun run build && bun run --filter wp-typia build && bun test tests/*.test.ts --coverage --coverage-reporter=lcov --coverage-dir=coverage",
     "clean": "rm -rf dist",
     "prepublishOnly": "bun run build"
   },

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

@@ -28,25 +28,45 @@ type CompoundParentConfig = {
 };
 
 type ExistingCompoundChild = {
+	ancestorBlockNames: string[];
 	blockJsonPath: string;
 	blockName: string;
+	container: boolean;
+	directAllowedBlocks: string[];
 	folderSlug: string;
 	key: string;
+	parentBlockNames: string[];
+	placement: 'nested' | 'root';
+	supportsInserter: boolean;
+	title: string;
 };
 
 type ParsedArgs = {
 	ancestorValues: string[];
 	container: boolean;
+	dryRun: boolean;
 	inserter?: 'hidden' | 'visible';
 	slug?: string;
 	title?: string;
 };
 
+type CompoundChildGraphNode = {
+	blockName: string;
+	container: boolean;
+	directParentBlockName: string;
+	isProspective: boolean;
+	key: string;
+	placement: 'nested' | 'root';
+	supportsInserter: boolean;
+	title: string;
+};
+
 function parseArgs() {
 	const args = process.argv.slice( 2 );
 	const parsed: ParsedArgs = {
 		ancestorValues: [],
 		container: false,
+		dryRun: false,
 	};
 
 	for ( let index = 0; index < args.length; index += 1 ) {
@@ -86,6 +106,11 @@ function parseArgs() {
 			continue;
 		}
 
+		if ( arg === '--dry-run' ) {
+			parsed.dryRun = true;
+			continue;
+		}
+
 		if ( arg === '--inserter' ) {
 			const value = args[ index + 1 ];
 			if ( value !== 'hidden' && value !== 'visible' ) {
@@ -95,6 +120,10 @@ function parseArgs() {
 			index += 1;
 			continue;
 		}
+
+		if ( arg.startsWith( '--' ) ) {
+			throw new Error( `Unknown option: ${ arg }.` );
+		}
 	}
 
 	return parsed;
@@ -395,16 +424,149 @@ function listExistingCompoundChildren(): ExistingCompoundChild[] {
 				return null;
 			}
 
+			const ancestorBlockNames = Array.isArray( blockJson.ancestor )
+				? blockJson.ancestor.filter(
+					( value ): value is string => typeof value === 'string'
+				)
+				: [];
+			const parentBlockNames = Array.isArray( blockJson.parent )
+				? blockJson.parent.filter(
+					( value ): value is string => typeof value === 'string'
+				)
+				: [];
+			const directAllowedBlocks = Array.isArray( blockJson.allowedBlocks )
+				? blockJson.allowedBlocks.filter(
+					( value ): value is string => typeof value === 'string'
+				)
+				: [];
+			const supports =
+				typeof blockJson.supports === 'object' &&
+				blockJson.supports &&
+				! Array.isArray( blockJson.supports )
+					? blockJson.supports
+					: null;
+			const supportsInserter =
+				supports && typeof supports.inserter === 'boolean'
+					? supports.inserter
+					: true;
+			const title =
+				typeof blockJson.title === 'string' &&
+				blockJson.title.trim().length > 0
+					? blockJson.title.trim()
+					: toTitleCase( deriveChildKey( folderSlug ) );
+
 			return {
+				ancestorBlockNames,
 				blockJsonPath,
 				blockName,
+				container: Object.prototype.hasOwnProperty.call(
+					blockJson,
+					'allowedBlocks'
+				),
+				directAllowedBlocks,
 				folderSlug,
 				key: deriveChildKey( folderSlug ),
+				parentBlockNames,
+				placement: ancestorBlockNames.length > 0 ? 'nested' : 'root',
+				supportsInserter,
+				title,
 			} satisfies ExistingCompoundChild;
 		} )
 		.filter( ( child ): child is ExistingCompoundChild => child !== null );
 }
 
+function buildCompoundChildGraphMap(
+	existingChildren: ExistingCompoundChild[]
+): Map< string, ExistingCompoundChild > {
+	return new Map(
+		existingChildren.map( ( child ) => [ child.blockName, child ] )
+	);
+}
+
+function resolveDirectParentBlockName( child: ExistingCompoundChild ): string {
+	return (
+		child.ancestorBlockNames[ child.ancestorBlockNames.length - 1 ] ??
+		child.parentBlockNames[ 0 ] ??
+		PARENT_BLOCK_NAME
+	);
+}
+
+function validateExistingCompoundChildGraph(
+	existingChildren: ExistingCompoundChild[]
+) {
+	const seenKeys = new Set< string >();
+	const seenBlockNames = new Set< string >();
+	const childByBlockName = buildCompoundChildGraphMap( existingChildren );
+
+	for ( const child of existingChildren ) {
+		if ( seenKeys.has( child.key ) ) {
+			throw new Error(
+				`Existing compound child graph is invalid: child key "${ child.key }" is declared more than once.`
+			);
+		}
+
+		if ( seenBlockNames.has( child.blockName ) ) {
+			throw new Error(
+				`Existing compound child graph is invalid: ${ child.blockName } is declared more than once.`
+			);
+		}
+
+		seenKeys.add( child.key );
+		seenBlockNames.add( child.blockName );
+
+		if ( child.ancestorBlockNames.length === 0 ) {
+			if ( child.parentBlockNames.length === 0 ) {
+				throw new Error(
+					`Existing compound child graph is invalid: ${ child.blockName } must declare a parent block.`
+				);
+			}
+			continue;
+		}
+
+		for ( let index = 0; index < child.ancestorBlockNames.length; index += 1 ) {
+			const ancestorBlockName = child.ancestorBlockNames[ index ];
+			const ancestorChild = childByBlockName.get( ancestorBlockName );
+
+			if ( ! ancestorChild ) {
+				throw new Error(
+					`Existing compound child graph is invalid: ${ child.blockName } references missing ancestor ${ ancestorBlockName }.`
+				);
+			}
+
+			if ( ! ancestorChild.container ) {
+				throw new Error(
+					`Existing compound child graph is invalid: ${ ancestorChild.blockName } is not declared as a container child but has nested descendants.`
+				);
+			}
+
+			const expectedAncestorRoute = child.ancestorBlockNames.slice( 0, index );
+			const ancestorRouteMatches =
+				ancestorChild.ancestorBlockNames.length === expectedAncestorRoute.length &&
+				expectedAncestorRoute.every(
+					( expectedAncestorBlockName, expectedIndex ) =>
+						ancestorChild.ancestorBlockNames[ expectedIndex ] ===
+						expectedAncestorBlockName
+				);
+
+			if ( ! ancestorRouteMatches ) {
+				throw new Error(
+					`Existing compound child graph is invalid: ${ ancestorChild.blockName } is not on the declared ancestor route for ${ child.blockName }.`
+				);
+			}
+
+			const nextBlockName =
+				child.ancestorBlockNames[ index + 1 ] ?? child.blockName;
+			if ( ancestorChild.directAllowedBlocks.includes( nextBlockName ) ) {
+				continue;
+			}
+
+			throw new Error(
+				`Existing compound child graph is invalid: ${ ancestorChild.blockName } does not currently allow ${ nextBlockName } as a direct child.`
+			);
+		}
+	}
+}
+
 function resolveExistingCompoundChild(
 	value: string,
 	existingChildren: ExistingCompoundChild[]
@@ -457,14 +619,8 @@ function validateAncestorChain(
 	for ( let index = 0; index < ancestorChain.length - 1; index += 1 ) {
 		const currentAncestor = ancestorChain[ index ];
 		const nextAncestor = ancestorChain[ index + 1 ];
-		const blockJson = readBlockJsonDocument( currentAncestor.blockJsonPath );
-		const allowedBlocks = Array.isArray( blockJson.allowedBlocks )
-			? blockJson.allowedBlocks.filter(
-				( value ): value is string => typeof value === 'string'
-			)
-			: [];
-
-		if ( allowedBlocks.includes( nextAncestor.blockName ) ) {
+
+		if ( currentAncestor.directAllowedBlocks.includes( nextAncestor.blockName ) ) {
 			continue;
 		}
 
@@ -474,6 +630,22 @@ function validateAncestorChain(
 	}
 }
 
+function validateNestedAncestorTarget( ancestorChain: ExistingCompoundChild[] ) {
+	const directAncestor = ancestorChain[ ancestorChain.length - 1 ];
+
+	if ( ! directAncestor ) {
+		return;
+	}
+
+	if ( directAncestor.container ) {
+		return;
+	}
+
+	throw new Error(
+		`Cannot nest descendants under ${ directAncestor.blockName } because it is not declared as a container child. Re-add that child with --container or target an existing container child.`
+	);
+}
+
 function findCompoundChildSpecSource(
 	childrenRegistrySource: string,
 	childKey: string
@@ -528,6 +700,86 @@ function validateAncestorInstantiability(
 	}
 }
 
+function formatProjectRelativePath( filePath: string ): string {
+	return path.relative( PROJECT_ROOT, filePath ) || '.';
+}
+
+function buildCompoundChildGraphNodes(
+	existingChildren: ExistingCompoundChild[],
+	prospectiveChild: CompoundChildGraphNode
+): CompoundChildGraphNode[] {
+	return [
+		...existingChildren.map( ( child ) => ( {
+			blockName: child.blockName,
+			container: child.container,
+			directParentBlockName: resolveDirectParentBlockName( child ),
+			isProspective: false,
+			key: child.key,
+			placement: child.placement,
+			supportsInserter: child.supportsInserter,
+			title: child.title,
+		} ) ),
+		prospectiveChild,
+	];
+}
+
+function renderCompoundChildGraphPreview(
+	graphNodes: CompoundChildGraphNode[],
+	plannedWritePaths: string[],
+	options: {
+		dryRun: boolean;
+	}
+): string {
+	const childrenByParent = new Map< string, CompoundChildGraphNode[] >();
+
+	for ( const graphNode of graphNodes ) {
+		const existingChildren = childrenByParent.get( graphNode.directParentBlockName ) ?? [];
+		existingChildren.push( graphNode );
+		childrenByParent.set( graphNode.directParentBlockName, existingChildren );
+	}
+
+	const renderChildLines = (
+		parentBlockName: string,
+		indent: string
+	): string[] => {
+		const directChildren = [ ...( childrenByParent.get( parentBlockName ) ?? [] ) ].sort(
+			( left, right ) => left.key.localeCompare( right.key )
+		);
+
+		return directChildren.flatMap( ( child ) => {
+			const labels = [
+				child.isProspective ? 'new' : 'existing',
+				child.placement === 'root' ? 'root' : 'nested',
+				child.container ? 'container' : 'leaf',
+				child.supportsInserter ? 'visible' : 'hidden',
+			];
+			const line = `${ indent }- ${ child.key } -> ${ child.blockName } [${ labels.join( ', ' ) }]`;
+			return [ line, ...renderChildLines( child.blockName, `${ indent }  ` ) ];
+		} );
+	};
+
+	return [
+		'Compound child graph preview',
+		`Parent block: ${ PARENT_BLOCK_NAME }`,
+		...renderChildLines( PARENT_BLOCK_NAME, '' ),
+		'',
+		'Planned writes',
+		...plannedWritePaths.map( ( plannedWritePath ) => `- ${ plannedWritePath }` ),
+		options.dryRun ? '' : '',
+		options.dryRun
+			? 'Dry run only; no files were written.'
+			: 'Applying these updates now.',
+	]
+		.filter( ( line, index, lines ) => {
+			if ( line.length > 0 ) {
+				return true;
+			}
+
+			return index > 0 && lines[ index - 1 ].length > 0;
+		} )
+		.join( '\n' );
+}
+
 function updateAllowedBlocks(
 	filePath: string,
 	blockName: string
@@ -756,8 +1008,7 @@ import { __ } from '@wordpress/i18n';
 
 import metadata from './block-metadata';
 import {
-\tgetChildAllowedBlocks,
-\tgetChildTemplate,
+\tgetChildInnerBlocksPropsOptions,
 \thasNestedChildBlocks,
 } from '../${ PARENT_BLOCK_SLUG }/children';
 import { useTypiaValidation } from './hooks';
@@ -768,6 +1019,14 @@ import {
 } from './validators';
 
 type EditProps = BlockEditProps< ${ childTypeName } >;
+type CompoundInnerBlocksProps = Parameters< typeof InnerBlocks >[ 0 ] & {
+\tdefaultBlock?: [ string, Record< string, unknown > ];
+\tdirectInsert?: boolean;
+};
+
+const TypedInnerBlocks = InnerBlocks as unknown as (
+\tprops: CompoundInnerBlocksProps
+) => ReturnType< typeof InnerBlocks >;
 
 export default function Edit( {
 \tattributes,
@@ -778,8 +1037,9 @@ export default function Edit( {
 \t\tattributes,
 \t\tvalidate${ childInterfaceName }
 \t);
-\tconst nestedAllowedBlocks = getChildAllowedBlocks( metadata.name );
-\tconst nestedTemplate = getChildTemplate( metadata.name );
+\tconst nestedInnerBlocksPropsOptions = getChildInnerBlocksPropsOptions(
+\t\tmetadata.name
+\t);
 \tconst showsNestedChildren = hasNestedChildBlocks( metadata.name );
 
 \treturn (
@@ -809,11 +1069,8 @@ export default function Edit( {
 \t\t\t) }
 \t\t\t{ showsNestedChildren && (
 \t\t\t\t<div className="${ childCssClassName }__children">
-\t\t\t\t\t<InnerBlocks
-\t\t\t\t\t\tallowedBlocks={ nestedAllowedBlocks }
-\t\t\t\t\t\trenderAppender={ InnerBlocks.ButtonBlockAppender }
-\t\t\t\t\t\ttemplate={ nestedTemplate }
-\t\t\t\t\t\ttemplateLock={ false }
+\t\t\t\t\t<TypedInnerBlocks
+\t\t\t\t\t\t{ ...( nestedInnerBlocksPropsOptions ?? {} ) }
 \t\t\t\t\t/>
 \t\t\t\t</div>
 \t\t\t) }
@@ -936,6 +1193,7 @@ function main() {
 	const {
 		ancestorValues,
 		container,
+		dryRun,
 		inserter,
 		slug,
 		title,
@@ -947,6 +1205,7 @@ function main() {
 	}
 
 	const existingChildren = listExistingCompoundChildren();
+	validateExistingCompoundChildGraph( existingChildren );
 	const ancestorChain = ensureUniqueAncestorChain(
 		ancestorValues.map( ( value ) =>
 			resolveExistingCompoundChild( value, existingChildren )
@@ -984,7 +1243,7 @@ function main() {
 	}
 
 	validateAncestorInstantiability( childrenFile, ancestorChain );
-
+	validateNestedAncestorTarget( ancestorChain );
 	const supportsInserter =
 		inserter === 'visible'
 			? true
@@ -994,6 +1253,47 @@ function main() {
 	const placement = ancestorChain.length > 0 ? 'nested' : 'root';
 	const seedTemplate = supportsInserter || container || ancestorChain.length > 0;
 	const directAllowedBlocks: string[] = [];
+	const directAncestor = ancestorChain[ ancestorChain.length - 1 ];
+	const plannedWritePaths = [
+		formatProjectRelativePath( path.join( childDir, 'block.json' ) ),
+		formatProjectRelativePath( path.join( childDir, 'types.ts' ) ),
+		formatProjectRelativePath( path.join( childDir, 'typia.manifest.json' ) ),
+		formatProjectRelativePath( path.join( childDir, 'block-metadata.ts' ) ),
+		formatProjectRelativePath( path.join( childDir, 'manifest-document.ts' ) ),
+		formatProjectRelativePath( path.join( childDir, 'manifest-defaults-document.ts' ) ),
+		formatProjectRelativePath( path.join( childDir, 'hooks.ts' ) ),
+		formatProjectRelativePath( path.join( childDir, 'validators.ts' ) ),
+		formatProjectRelativePath( path.join( childDir, 'edit.tsx' ) ),
+		formatProjectRelativePath( path.join( childDir, 'save.tsx' ) ),
+		formatProjectRelativePath( path.join( childDir, 'index.tsx' ) ),
+		formatProjectRelativePath( childrenFile ),
+		formatProjectRelativePath( blockConfigFile ),
+		formatProjectRelativePath(
+			placement === 'root' ? PARENT_BLOCK_JSON_PATH : directAncestor.blockJsonPath
+		),
+	];
+
+	console.log(
+		renderCompoundChildGraphPreview(
+			buildCompoundChildGraphNodes( existingChildren, {
+				blockName: childBlockName,
+				container,
+				directParentBlockName:
+					directAncestor?.blockName ?? PARENT_BLOCK_NAME,
+				isProspective: true,
+				key: normalizedSlug,
+				placement,
+				supportsInserter,
+				title: childTitle,
+			} ),
+			plannedWritePaths,
+			{ dryRun }
+		)
+	);
+
+	if ( dryRun ) {
+		return;
+	}
 
 	fs.mkdirSync( childDir, { recursive: true } );