@elementor/editor-canvas 4.3.0-991 → 4.3.0-992

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@elementor/editor-canvas",
   "description": "Elementor Editor Canvas",
-  "version": "4.3.0-991",
+  "version": "4.3.0-992",
   "private": false,
   "author": "Elementor Team",
   "homepage": "https://elementor.com/",
@@ -37,26 +37,26 @@
     "react-dom": "^18.3.1"
   },
   "dependencies": {
-    "@elementor/editor": "4.3.0-991",
-    "@elementor/editor-controls": "4.3.0-991",
-    "@elementor/editor-documents": "4.3.0-991",
-    "@elementor/editor-elements": "4.3.0-991",
-    "@elementor/editor-interactions": "4.3.0-991",
-    "@elementor/editor-mcp": "4.3.0-991",
-    "@elementor/editor-notifications": "4.3.0-991",
-    "@elementor/editor-props": "4.3.0-991",
-    "@elementor/editor-responsive": "4.3.0-991",
-    "@elementor/editor-styles": "4.3.0-991",
-    "@elementor/editor-styles-repository": "4.3.0-991",
-    "@elementor/editor-ui": "4.3.0-991",
-    "@elementor/editor-v1-adapters": "4.3.0-991",
-    "@elementor/events": "4.3.0-991",
-    "@elementor/http-client": "4.3.0-991",
-    "@elementor/schema": "4.3.0-991",
-    "@elementor/twing": "4.3.0-991",
+    "@elementor/editor": "4.3.0-992",
+    "@elementor/editor-controls": "4.3.0-992",
+    "@elementor/editor-documents": "4.3.0-992",
+    "@elementor/editor-elements": "4.3.0-992",
+    "@elementor/editor-interactions": "4.3.0-992",
+    "@elementor/editor-mcp": "4.3.0-992",
+    "@elementor/editor-notifications": "4.3.0-992",
+    "@elementor/editor-props": "4.3.0-992",
+    "@elementor/editor-responsive": "4.3.0-992",
+    "@elementor/editor-styles": "4.3.0-992",
+    "@elementor/editor-styles-repository": "4.3.0-992",
+    "@elementor/editor-ui": "4.3.0-992",
+    "@elementor/editor-v1-adapters": "4.3.0-992",
+    "@elementor/events": "4.3.0-992",
+    "@elementor/http-client": "4.3.0-992",
+    "@elementor/schema": "4.3.0-992",
+    "@elementor/twing": "4.3.0-992",
     "@elementor/ui": "1.37.5",
-    "@elementor/utils": "4.3.0-991",
-    "@elementor/wp-media": "4.3.0-991",
+    "@elementor/utils": "4.3.0-992",
+    "@elementor/wp-media": "4.3.0-992",
     "@floating-ui/react": "^0.27.5",
     "@wordpress/i18n": "^5.13.0",
     "dompurify": "^3.2.6"

package/src/mcp/resources/__tests__/available-widgets-resource.test.ts

@@ -0,0 +1,76 @@
+import { httpService } from '@elementor/http-client';
+
+import {
+	AVAILABLE_WIDGETS_URI,
+	AVAILABLE_WIDGETS_URI_V4,
+	initAvailableWidgetsResource,
+} from '../available-widgets-resource';
+
+jest.mock( '@elementor/http-client', () => ( {
+	httpService: jest.fn(),
+} ) );
+
+const mockedHttpService = httpService as jest.MockedFunction< typeof httpService >;
+
+type ResourceHandler = () => Promise< { contents: { text: string }[] } >;
+
+const captureHandlers = () => {
+	const resource = jest.fn();
+	initAvailableWidgetsResource( { resource } as never );
+	return {
+		v4Handler: resource.mock.calls[ 0 ][ 3 ] as ResourceHandler,
+		allHandler: resource.mock.calls[ 1 ][ 3 ] as ResourceHandler,
+	};
+};
+
+describe( 'available-widgets-resource', () => {
+	beforeEach( () => {
+		jest.clearAllMocks();
+	} );
+
+	it( 'fetches all widgets via list-widgets without a version filter', async () => {
+		// Arrange
+		const post = jest.fn().mockResolvedValue( {
+			data: {
+				data: [
+					{ type: 'e-heading', version: 'v4' },
+					{ type: 'legacy-icon', version: 'v3' },
+				],
+			},
+		} );
+		mockedHttpService.mockReturnValue( { post } as never );
+		const { allHandler } = captureHandlers();
+
+		// Act
+		const result = await allHandler();
+
+		// Assert
+		expect( post ).toHaveBeenCalledWith( 'elementor/v1/mcp-proxy', { tool: 'list-widgets', input: {} } );
+		expect( JSON.parse( result.contents[ 0 ].text ) ).toEqual( [
+			{ type: 'e-heading', version: 'v4' },
+			{ type: 'legacy-icon', version: 'v3' },
+		] );
+	} );
+
+	it( 'fetches only v4 widgets via list-widgets with a version filter', async () => {
+		// Arrange
+		const post = jest.fn().mockResolvedValue( { data: { data: [ { type: 'e-heading', version: 'v4' } ] } } );
+		mockedHttpService.mockReturnValue( { post } as never );
+		const { v4Handler } = captureHandlers();
+
+		// Act
+		const result = await v4Handler();
+
+		// Assert
+		expect( post ).toHaveBeenCalledWith( 'elementor/v1/mcp-proxy', {
+			tool: 'list-widgets',
+			input: { version: 'v4' },
+		} );
+		expect( JSON.parse( result.contents[ 0 ].text ) ).toEqual( [ { type: 'e-heading', version: 'v4' } ] );
+	} );
+
+	it( 'exposes the expected resource URIs', () => {
+		expect( AVAILABLE_WIDGETS_URI ).toBe( 'elementor://context/available-widgets' );
+		expect( AVAILABLE_WIDGETS_URI_V4 ).toBe( 'elementor://context/available-widgets/v4' );
+	} );
+} );

package/src/mcp/resources/__tests__/widgets-schema-resource.test.ts

@@ -1,95 +1,98 @@
-import { type V1ElementConfig } from '@elementor/editor-elements';
+import { httpService } from '@elementor/http-client';
 
-import { buildLlmGuidance, enrichPropertiesWithBaseSettingsHints, mergeInstructions } from '../build-llm-guidance';
+jest.mock( '@elementor/http-client', () => ( {
+	httpService: jest.fn(),
+} ) );
 
-const mockEmailBaseSettings = {
-	email: {
-		$$type: 'emails',
-		value: {
-			to: {
-				$$type: 'string-array',
-				value: [ { $$type: 'string', value: 'admin@example.com' } ],
-			},
-			from: { $$type: 'string', value: 'email@example.com' },
-			message: { $$type: 'string', value: '[all-fields]' },
-		},
-	},
-};
+jest.mock( '@elementor/editor-mcp', () => {
+	class MockResourceTemplate {
+		callbacks: { list?: () => Promise< { resources: unknown[] } > };
+		constructor( _uriTemplate: string, callbacks: { list?: () => Promise< { resources: unknown[] } > } ) {
+			this.callbacks = callbacks;
+		}
+	}
+	return { ResourceTemplate: MockResourceTemplate };
+} );
 
-const mockFormWidgetData = {
-	title: 'Form',
-	controls: {},
-	elType: 'widget',
-	meta: { is_container: true },
-	base_settings: mockEmailBaseSettings,
-	atomic_props_schema: {
-		email: { kind: 'object', key: 'emails' },
-		'form-name': { kind: 'string', key: 'string' },
-	},
-} as unknown as V1ElementConfig;
+import { initWidgetsSchemaResource, WIDGET_SCHEMA_URI } from '../widgets-schema-resource';
 
-describe( 'build-llm-guidance', () => {
-	it( 'mergeInstructions combines existing and additional instructions', () => {
-		expect( mergeInstructions( 'First.', 'Second.' ) ).toBe( 'First. Second.' );
-		expect( mergeInstructions( undefined, 'Only.' ) ).toBe( 'Only.' );
-	} );
+const mockedHttpService = httpService as jest.MockedFunction< typeof httpService >;
+
+type ResourceTemplateHandler = (
+	uri: URL,
+	variables: Record< string, string >
+) => Promise< { contents: { text: string }[] } >;
+type ResourceTemplateLike = { callbacks: { list?: () => Promise< { resources: unknown[] } > } };
 
-	it( 'buildLlmGuidance exposes default_settings for widgets with base_settings', () => {
-		const guidance = buildLlmGuidance( mockFormWidgetData, 'e-form', {} );
+const captureHandlers = () => {
+	const resource = jest.fn();
+	initWidgetsSchemaResource( { resource } as never );
+	const call = resource.mock.calls[ 0 ];
+	const template = call[ 1 ] as ResourceTemplateLike;
+	return {
+		list: template.callbacks.list as () => Promise< { resources: unknown[] } >,
+		readHandler: call[ 3 ] as ResourceTemplateHandler,
+	};
+};
 
-		expect( guidance.default_settings ).toEqual( mockEmailBaseSettings );
-		expect( guidance.instructions ).toContain( 'Omit them from elementConfig unless the user explicitly asks' );
-		expect( guidance.can_have_children ).toBe( true );
+describe( 'widgets-schema-resource', () => {
+	beforeEach( () => {
+		jest.clearAllMocks();
 	} );
 
-	it( 'buildLlmGuidance merges style and settings instructions when both exist', () => {
-		const widgetData = {
-			...mockFormWidgetData,
-			base_styles: {
-				'e-form-base': {
-					variants: [
-						{
-							props: {
-								display: { $$type: 'string', value: 'flex' },
-							},
-						},
-					],
-				},
+	it( 'lists widget types fetched from the server via the list-widgets tool', async () => {
+		// Arrange
+		const post = jest.fn().mockResolvedValue( {
+			data: {
+				data: [
+					{ type: 'e-heading', version: 'v4' },
+					{ type: 'e-button', version: 'v4' },
+				],
 			},
-		} as unknown as V1ElementConfig;
+		} );
+		mockedHttpService.mockReturnValue( { post } as never );
+		const { list } = captureHandlers();
 
-		const guidance = buildLlmGuidance( widgetData, 'e-form', {} );
+		// Act
+		const result = await list();
 
-		expect( guidance.default_styles ).toEqual( { display: { $$type: 'string', value: 'flex' } } );
-		expect( guidance.default_settings ).toEqual( mockEmailBaseSettings );
-		expect( guidance.instructions ).toContain( 'default styles' );
-		expect( guidance.instructions ).toContain( 'default settings' );
+		// Assert
+		expect( post ).toHaveBeenCalledWith( 'elementor/v1/mcp-proxy', { tool: 'list-widgets', input: {} } );
+		expect( result.resources ).toEqual( [
+			{ uri: 'elementor://widgets/schema/e-heading', name: 'Widget schema for e-heading' },
+			{ uri: 'elementor://widgets/schema/e-button', name: 'Widget schema for e-button' },
+		] );
 	} );
 
-	it( 'enrichPropertiesWithBaseSettingsHints adds omit guidance to base setting props', () => {
-		const enriched = enrichPropertiesWithBaseSettingsHints(
-			{
-				email: { type: 'object' },
-				'form-name': { type: 'object' },
-			},
-			[ 'email' ]
-		);
+	it( 'reads a single widget schema via the get-widget-schema tool', async () => {
+		// Arrange
+		const post = jest.fn().mockResolvedValue( {
+			data: { data: { type: 'object', properties: { text: { mocked: true } } } },
+		} );
+		mockedHttpService.mockReturnValue( { post } as never );
+		const { readHandler } = captureHandlers();
+		const uri = new URL( 'elementor://widgets/schema/e-heading' );
+
+		// Act
+		const result = await readHandler( uri, { widgetType: 'e-heading' } );
 
-		expect( enriched.email.description ).toContain( 'llm_guidance.default_settings' );
-		expect( enriched[ 'form-name' ].description ).toBeUndefined();
+		// Assert
+		expect( post ).toHaveBeenCalledWith( 'elementor/v1/mcp-proxy', {
+			tool: 'get-widget-schema',
+			input: { widget_type: 'e-heading' },
+		} );
+		expect( JSON.parse( result.contents[ 0 ].text ) ).toEqual( {
+			type: 'object',
+			properties: { text: { mocked: true } },
+		} );
 	} );
-} );
 
-describe( 'widgets-schema-resource base_settings integration', () => {
-	it( 'keeps base setting props in schema while enriching descriptions', () => {
-		const properties = enrichPropertiesWithBaseSettingsHints(
-			{
-				email: { type: 'object', properties: {} },
-			},
-			Object.keys( mockEmailBaseSettings )
-		);
+	it( 'throws when no widget type variable is provided', async () => {
+		// Arrange
+		const { readHandler } = captureHandlers();
+		const uri = new URL( WIDGET_SCHEMA_URI.replace( '{widgetType}', '' ) );
 
-		expect( properties ).toHaveProperty( 'email' );
-		expect( properties.email.description ).toContain( 'omit unless user explicitly requests' );
+		// Act & Assert
+		await expect( readHandler( uri, {} ) ).rejects.toThrow( 'No widget type provided.' );
 	} );
 } );

package/src/mcp/resources/available-widgets-resource.ts

@@ -1,37 +1,42 @@
 import { type MCPRegistryEntry } from '@elementor/editor-mcp';
-import { v1ReadyEvent } from '@elementor/editor-v1-adapters';
+import { type HttpResponse, httpService } from '@elementor/http-client';
 
-import { type AvailableWidget, getAvailableWidgets } from '../utils/element-data-util';
+const MCP_PROXY_URL = 'elementor/v1/mcp-proxy';
 
 export const AVAILABLE_WIDGETS_URI = 'elementor://context/available-widgets';
 export const AVAILABLE_WIDGETS_URI_V4 = 'elementor://context/available-widgets/v4';
 
-export const initAvailableWidgetsResource = ( reg: MCPRegistryEntry ) => {
-	const { resource, sendResourceUpdated } = reg;
+type WidgetSummary = {
+	type: string;
+	version: 'v3' | 'v4';
+	description?: string;
+};
 
-	const buildContents = ( uri: string, filterFunction: ( x: AvailableWidget ) => boolean = () => true ) => {
-		const widgets = getAvailableWidgets().filter( filterFunction );
-		return {
-			contents: [
-				{
-					uri,
-					mimeType: 'application/json',
-					text: JSON.stringify( widgets, null, 2 ),
-				},
-			],
-		};
-	};
+const fetchWidgets = async ( version?: WidgetSummary[ 'version' ] ): Promise< WidgetSummary[] > => {
+	const { data } = await httpService().post< HttpResponse< WidgetSummary[] > >( MCP_PROXY_URL, {
+		tool: 'list-widgets',
+		input: version ? { version } : {},
+	} );
 
-	const notifyResourcesUpdated = () => {
-		sendResourceUpdated( {
-			uri: AVAILABLE_WIDGETS_URI,
-			...buildContents( AVAILABLE_WIDGETS_URI ),
-		} );
-		sendResourceUpdated( {
-			uri: AVAILABLE_WIDGETS_URI_V4,
-			...buildContents( AVAILABLE_WIDGETS_URI_V4, ( w: AvailableWidget ) => w.version === 'v4' ),
-		} );
+	return data.data ?? [];
+};
+
+const buildContents = async ( uri: string, version?: WidgetSummary[ 'version' ] ) => {
+	const widgets = await fetchWidgets( version );
+
+	return {
+		contents: [
+			{
+				uri,
+				mimeType: 'application/json',
+				text: JSON.stringify( widgets, null, 2 ),
+			},
+		],
 	};
+};
+
+export const initAvailableWidgetsResource = ( reg: MCPRegistryEntry ) => {
+	const { resource } = reg;
 
 	resource(
 		'available-widgets-v4',
@@ -39,7 +44,7 @@ export const initAvailableWidgetsResource = ( reg: MCPRegistryEntry ) => {
 		{
 			description: 'All registered v4 version widgets',
 		},
-		async () => buildContents( AVAILABLE_WIDGETS_URI_V4, ( w ) => w.version === 'v4' )
+		async () => buildContents( AVAILABLE_WIDGETS_URI_V4, 'v4' )
 	);
 
 	resource(
@@ -50,18 +55,4 @@ export const initAvailableWidgetsResource = ( reg: MCPRegistryEntry ) => {
 		},
 		async () => buildContents( AVAILABLE_WIDGETS_URI )
 	);
-
-	const eventName = v1ReadyEvent().name;
-
-	const onV1Ready = () => {
-		const widgets = getAvailableWidgets();
-		if ( widgets.length === 0 ) {
-			return;
-		}
-		window.removeEventListener( eventName, onV1Ready );
-		notifyResourcesUpdated();
-	};
-
-	window.addEventListener( eventName, onV1Ready );
-	onV1Ready();
 };

package/src/mcp/resources/widgets-schema-resource.ts

@@ -1,58 +1,5 @@
-import { getWidgetsCache } from '@elementor/editor-elements';
 import { type MCPRegistryEntry, ResourceTemplate } from '@elementor/editor-mcp';
-import {
-	type ArrayPropType,
-	type ObjectPropType,
-	type PropType,
-	Schema,
-	type TransformablePropType,
-	type UnionPropType,
-} from '@elementor/editor-props';
-
-import { hasV3Controls, isWidgetAvailableForLLM } from '../utils/element-data-util';
-import { buildLlmGuidance, enrichPropertiesWithBaseSettingsHints } from './build-llm-guidance';
-
-const V3_LAYOUT_CONTROL_TYPES = new Set( [ 'section', 'tab', 'tabs' ] );
-
-type V3ControlMetadataEntry = {
-	default?: unknown;
-	type?: string;
-	options?: unknown;
-};
-
-function extractV3ControlsMetadata( controls: unknown ): Record< string, V3ControlMetadataEntry > {
-	if ( ! hasV3Controls( controls ) ) {
-		return {};
-	}
-	const result: Record< string, V3ControlMetadataEntry > = {};
-	for ( const [ controlKey, raw ] of Object.entries( controls as Record< string, unknown > ) ) {
-		if ( ! raw || typeof raw !== 'object' ) {
-			continue;
-		}
-		const control = raw as Record< string, unknown >;
-		const controlType = typeof control.type === 'string' ? control.type : undefined;
-		if ( controlType && V3_LAYOUT_CONTROL_TYPES.has( controlType ) ) {
-			continue;
-		}
-		const entry: V3ControlMetadataEntry = {};
-		if ( Object.prototype.hasOwnProperty.call( control, 'default' ) ) {
-			entry.default = control.default;
-		}
-		if ( controlType ) {
-			entry.type = controlType;
-		}
-		if ( Object.prototype.hasOwnProperty.call( control, 'options' ) && control.options !== undefined ) {
-			const options = control.options;
-			if ( options && typeof options === 'object' && ! Array.isArray( options ) ) {
-				entry.options = Object.keys( options as Record< string, unknown > );
-			} else {
-				entry.options = options;
-			}
-		}
-		result[ controlKey ] = entry;
-	}
-	return result;
-}
+import { type HttpResponse, httpService } from '@elementor/http-client';
 
 export const CANVAS_SERVER_NAME = 'editor-canvas';
 
@@ -62,20 +9,43 @@ export const STYLE_SCHEMA_URI = 'elementor://styles/schema/{category}';
 export const BEST_PRACTICES_URI = 'elementor://style/best-practices';
 export const BEST_PRACTICES_FULL_URI = `${ CANVAS_SERVER_NAME }_${ BEST_PRACTICES_URI }`;
 
+const MCP_PROXY_URL = 'elementor/v1/mcp-proxy';
+
+type WidgetSummary = {
+	type: string;
+	version: 'v3' | 'v4';
+	description?: string;
+};
+
+const listWidgetTypes = async (): Promise< string[] > => {
+	const { data } = await httpService().post< HttpResponse< WidgetSummary[] > >( MCP_PROXY_URL, {
+		tool: 'list-widgets',
+		input: {},
+	} );
+
+	return ( data.data ?? [] ).map( ( widget ) => widget.type );
+};
+
+const fetchWidgetSchema = async ( widgetType: string ): Promise< Record< string, unknown > > => {
+	const { data } = await httpService().post< HttpResponse< Record< string, unknown > > >( MCP_PROXY_URL, {
+		tool: 'get-widget-schema',
+		input: { widget_type: widgetType },
+	} );
+
+	return data.data ?? {};
+};
+
 export const initWidgetsSchemaResource = ( reg: MCPRegistryEntry ) => {
 	const { resource } = reg;
 
 	resource(
 		'widget-schema-by-type',
 		new ResourceTemplate( WIDGET_SCHEMA_URI, {
-			list: () => {
-				const cache = getWidgetsCache() || {};
-				const availableWidgets = Object.keys( cache ).filter( ( widgetType ) =>
-					isWidgetAvailableForLLM( cache[ widgetType ] )
-				);
+			list: async () => {
+				const widgetTypes = await listWidgetTypes();
 
 				return {
-					resources: availableWidgets.map( ( widgetType ) => ( {
+					resources: widgetTypes.map( ( widgetType ) => ( {
 						uri: `elementor://widgets/schema/${ widgetType }`,
 						name: 'Widget schema for ' + widgetType,
 					} ) ),
@@ -88,107 +58,22 @@ export const initWidgetsSchemaResource = ( reg: MCPRegistryEntry ) => {
 		async ( uri, variables ) => {
 			const widgetType =
 				typeof variables.widgetType === 'string' ? variables.widgetType : variables.widgetType?.[ 0 ];
-			const widgetData = getWidgetsCache()?.[ widgetType ];
-			if ( ! widgetData ) {
-				throw new Error( `No prop schema found for element type: ${ widgetType }` );
-			}
-			const propSchema = widgetData.atomic_props_schema;
-			if ( ! propSchema ) {
-				if ( ! hasV3Controls( widgetData.controls ) ) {
-					throw new Error( `No prop schema found for element type: ${ widgetType }` );
-				}
-				const controlMetadata = extractV3ControlsMetadata( widgetData.controls );
-				return {
-					contents: [
-						{
-							uri: uri.toString(),
-							mimeType: 'application/json',
-							text: JSON.stringify( {
-								widget_version: 'v3',
-								message:
-									'This widget exists in the editor but has no atomic props schema (V4). Use control_metadata as non-authoritative hints from legacy controls.',
-								fields_note: 'All settings are optional; there is no JSON schema for this widget type.',
-								properties: controlMetadata,
-							} ),
-						},
-					],
-				};
-			}
-			const baseSettingsKeys = Object.keys( widgetData?.base_settings ?? {} );
 
-			const asJson = enrichPropertiesWithBaseSettingsHints(
-				Object.fromEntries(
-					Object.entries( propSchema )
-						.filter( ( [ key, propType ] ) => Schema.isPropKeyConfigurable( key, propType as PropType ) )
-						.map( ( [ key, propType ] ) => [ key, Schema.propTypeToJsonSchema( propType ) ] )
-				),
-				baseSettingsKeys
-			);
-
-			const description =
-				typeof widgetData?.meta?.description === 'string' ? widgetData.meta.description : undefined;
+			if ( ! widgetType ) {
+				throw new Error( 'No widget type provided.' );
+			}
 
-			const allWidgets = getWidgetsCache() || {};
-			const llmGuidance = buildLlmGuidance( widgetData, widgetType, allWidgets );
+			const schema = await fetchWidgetSchema( widgetType );
 
 			return {
 				contents: [
 					{
 						uri: uri.toString(),
 						mimeType: 'application/json',
-						text: JSON.stringify( {
-							type: 'object',
-							properties: asJson,
-							description,
-							llm_guidance: llmGuidance,
-						} ),
+						text: JSON.stringify( schema ),
 					},
 				],
 			};
 		}
 	);
 };
-
-function cleanupPropSchema( propSchema: Record< string, PropType > ): Record< string, PropType > {
-	const result: Record< string, Partial< PropType > > = {};
-	Object.keys( propSchema ).forEach( ( propName ) => {
-		result[ propName ] = cleanupPropType( propSchema[ propName ] );
-	} );
-	return result as Record< string, PropType >;
-}
-function cleanupPropType( propType: PropType & { key?: string } ): Partial< PropType > {
-	const result: Partial< PropType > = {};
-	Object.keys( propType ).forEach( ( property ) => {
-		switch ( property ) {
-			case 'key':
-			case 'kind':
-				( result as Record< string, unknown > )[ property ] = propType[ property ];
-				break;
-			case 'meta':
-			case 'settings':
-				{
-					if ( Object.keys( propType[ property ] || {} ).length > 0 ) {
-						( result as Record< string, unknown > )[ property ] = propType[ property ];
-					}
-				}
-				break;
-		}
-	} );
-	if ( result.kind === 'plain' ) {
-		Object.defineProperty( result, 'kind', { value: 'string' } );
-	} else if ( result.kind === 'array' ) {
-		result.item_prop_type = cleanupPropType( ( propType as ArrayPropType ).item_prop_type ) as PropType;
-	} else if ( result.kind === 'object' ) {
-		const shape = ( propType as ObjectPropType ).shape as Record< string, PropType >;
-		const cleanedShape = cleanupPropSchema( shape );
-		result.shape = cleanedShape;
-	} else if ( result.kind === 'union' ) {
-		const propTypes = ( propType as UnionPropType ).prop_types;
-		const cleanedPropTypes: Record< string, Partial< PropType > > = {};
-		Object.keys( propTypes ).forEach( ( key ) => {
-			cleanedPropTypes[ key ] = cleanupPropType( propTypes[ key ] );
-		} );
-		result.prop_types = cleanedPropTypes as Record< string, TransformablePropType >;
-	}
-	return result;
-}