@elementor/editor-canvas 4.3.0-993 → 4.3.0-995

package/src/composition-builder/utils/__tests__/required-children-enforcer.test.ts

@@ -1,79 +0,0 @@
-import { type V1ElementConfig } from '@elementor/editor-elements';
-
-import { RequiredChildrenEnforcer } from '../required-children-enforcer';
-
-describe( 'RequiredChildrenEnforcer', () => {
-	const FULL_FORM_DIRECT_CHILD_COUNT = 3;
-
-	const createWidgetsCache = (): Record< string, V1ElementConfig > => ( {
-		'e-form': {
-			title: 'Form',
-			controls: {},
-			elType: 'widget',
-			default_children: [
-				{
-					elType: 'e-form-success-message',
-					meta: { required: true },
-					elements: [],
-				},
-				{
-					elType: 'e-form-error-message',
-					meta: { required: true },
-					elements: [],
-				},
-				{
-					elType: 'widget',
-					widgetType: 'e-form-input',
-					elements: [],
-				},
-			],
-		} as V1ElementConfig,
-		'e-form-input': { title: 'Input', controls: {}, elType: 'widget' } as V1ElementConfig,
-		'e-form-success-message': {
-			title: 'Success',
-			controls: {},
-			elType: 'e-form-success-message',
-		} as V1ElementConfig,
-		'e-form-error-message': {
-			title: 'Error',
-			controls: {},
-			elType: 'e-form-error-message',
-		} as V1ElementConfig,
-	} );
-
-	it( 'throws when required direct children are missing', () => {
-		// Arrange
-		const xml = new DOMParser().parseFromString( '<e-form><e-form-input /></e-form>', 'application/xml' );
-		const enforcer = new RequiredChildrenEnforcer( 'e-form', createWidgetsCache() );
-
-		// Act & Assert
-		expect( () => enforcer.enforce( xml ) ).toThrow(
-			/Missing required direct child element tag\(s\): e-form-success-message, e-form-error-message/
-		);
-	} );
-
-	it( 'throws when only some required direct children exist', () => {
-		// Arrange
-		const xml = new DOMParser().parseFromString( '<e-form><e-form-success-message /></e-form>', 'application/xml' );
-		const enforcer = new RequiredChildrenEnforcer( 'e-form', createWidgetsCache() );
-
-		// Act & Assert
-		expect( () => enforcer.enforce( xml ) ).toThrow(
-			/Missing required direct child element tag\(s\): e-form-error-message/
-		);
-	} );
-
-	it( 'does not throw when all required direct children exist', () => {
-		// Arrange
-		const xmlStr = '<e-form><e-form-success-message /><e-form-error-message /><e-form-input /></e-form>';
-		const xml = new DOMParser().parseFromString( xmlStr, 'application/xml' );
-		const enforcer = new RequiredChildrenEnforcer( 'e-form', createWidgetsCache() );
-
-		// Act
-		expect( () => enforcer.enforce( xml ) ).not.toThrow();
-
-		// Assert
-		const form = xml.querySelector( 'e-form' );
-		expect( form?.children.length ).toBe( FULL_FORM_DIRECT_CHILD_COUNT );
-	} );
-} );

package/src/composition-builder/utils/__tests__/required-default-child-tags.test.ts

@@ -1,35 +0,0 @@
-import { type V1ElementConfig } from '@elementor/editor-elements';
-
-import { getRequiredDefaultChildTypes } from '../required-default-child-tags';
-
-describe( 'required-default-child-tags', () => {
-	it( 'returns XML tag names for default children marked meta.required', () => {
-		// Arrange
-		const config = {
-			title: 'Form',
-			controls: {},
-			default_children: [
-				{
-					elType: 'e-form-success-message',
-					meta: { required: true },
-					elements: [],
-				},
-				{
-					elType: 'widget',
-					widgetType: 'e-form-input',
-					meta: { required: true },
-				},
-				{
-					elType: 'e-form-label',
-					elements: [],
-				},
-			],
-		} as unknown as V1ElementConfig;
-
-		// Act
-		const tags = getRequiredDefaultChildTypes( config );
-
-		// Assert
-		expect( tags ).toEqual( [ 'e-form-success-message', 'e-form-input' ] );
-	} );
-} );

package/src/composition-builder/utils/required-children-enforcer.ts

@@ -1,56 +0,0 @@
-import { type V1ElementConfig } from '@elementor/editor-elements';
-
-import { type ChildTemplate, getRequiredDefaultChildTemplates } from './required-default-child-tags';
-
-const REQUIRED_CHILD_SCHEMA_HINT =
-	'Use the widget schema resource; under llm_guidance.required_direct_children for V4 widgets.';
-
-export class RequiredChildrenEnforcer {
-	private readonly elementType: string;
-	private readonly requiredTemplates: ChildTemplate[];
-
-	constructor( elementType: string, widgetsCache: Record< string, V1ElementConfig > ) {
-		this.elementType = elementType;
-		this.requiredTemplates = getRequiredDefaultChildTemplates( widgetsCache[ elementType ] );
-	}
-
-	enforce( xml: Document ) {
-		if ( this.requiredTemplates.length === 0 ) {
-			return;
-		}
-
-		const errors: string[] = [];
-
-		for ( const rootNode of Array.from( xml.children ) ) {
-			this.collectMissingRequiredErrors( rootNode, errors );
-		}
-
-		if ( errors.length ) {
-			throw new Error( `${ errors.join( '\n' ) }\n${ REQUIRED_CHILD_SCHEMA_HINT }` );
-		}
-	}
-
-	private collectMissingRequiredErrors( node: Element, errors: string[] ) {
-		if ( node.tagName === this.elementType ) {
-			const existingChildTags = new Set( Array.from( node.children ).map( ( child ) => child.tagName ) );
-			const missingTags = this.requiredTemplates
-				.map( ( child ) => child.widgetType ?? child.elType ?? '' )
-				.filter( ( type ) => type && ! existingChildTags.has( type ) ) as string[];
-
-			if ( missingTags.length ) {
-				const configurationId = node.getAttribute( 'configuration-id' );
-				const location = configurationId
-					? `<${ node.tagName } configuration-id="${ configurationId }">`
-					: `<${ node.tagName }>`;
-
-				errors.push(
-					`${ location } Missing required direct child element tag(s): ${ missingTags.join( ', ' ) }.`
-				);
-			}
-		}
-
-		for ( const childNode of Array.from( node.children ) ) {
-			this.collectMissingRequiredErrors( childNode, errors );
-		}
-	}
-}

package/src/composition-builder/utils/required-default-child-tags.ts

@@ -1,22 +0,0 @@
-import { type V1ElementConfig } from '@elementor/editor-elements';
-
-export type ChildTemplate = {
-	widgetType?: string;
-	elType?: string;
-	meta?: { required?: boolean };
-};
-export function getRequiredDefaultChildTemplates( elementConfig: V1ElementConfig | undefined ): ChildTemplate[] {
-	const defaultChildren = elementConfig?.default_children as ChildTemplate[];
-
-	if ( ! Array.isArray( defaultChildren ) ) {
-		return [];
-	}
-
-	return defaultChildren.filter( ( child ) => child?.meta?.required ?? false );
-}
-
-export function getRequiredDefaultChildTypes( elementConfig: V1ElementConfig | undefined ): string[] {
-	return getRequiredDefaultChildTemplates( elementConfig )
-		.map( ( child ) => child.widgetType ?? child.elType ?? '' )
-		.filter( ( type ) => Boolean( type ) );
-}

package/src/mcp/tools/build-composition/__tests__/xml-leaf-wrapper.test.ts

@@ -1,117 +0,0 @@
-import { type V1ElementConfig } from '@elementor/editor-elements';
-
-import { adaptLeafRootParams, type BuildCompositionParams, DIV_BLOCK_TAG, ZERO_SPACING } from '../xml-leaf-wrapper';
-
-const LEAF_WIDGET_TAG = 'e-heading';
-const CONTAINER_TAG = 'e-div-block';
-const DIV_BLOCK_TITLE = 'Div Block';
-
-const makeWidgetsCache = (
-	overrides: Record< string, Partial< V1ElementConfig > > = {}
-): Record< string, V1ElementConfig > =>
-	( {
-		[ LEAF_WIDGET_TAG ]: { title: 'Heading', controls: {}, elType: 'widget' },
-		[ CONTAINER_TAG ]: { title: DIV_BLOCK_TITLE, controls: {}, elType: 'e-div-block' },
-		...overrides,
-	} ) as Record< string, V1ElementConfig >;
-
-const parseXml = ( xml: string ) => new DOMParser().parseFromString( xml, 'application/xml' );
-
-const expectElementAttribute = ( element: Element, attribute: string, value: string ) => {
-	// eslint-disable-next-line jest-dom/prefer-to-have-attribute -- XML Element, not HTMLElement
-	expect( element.getAttribute( attribute ) ).toBe( value );
-};
-
-const makeParams = ( xmlStructure: string, overrides = {} ) =>
-	( {
-		xmlStructure,
-		stylesConfig: {},
-		elementConfig: {},
-		widgetsCache: makeWidgetsCache(),
-		...overrides,
-	} ) as BuildCompositionParams;
-
-describe( 'adaptLeafRootParams', () => {
-	it( 'wraps a leaf widget root in a div-block', () => {
-		// Arrange
-		const params = makeParams( `<${ LEAF_WIDGET_TAG } configuration-id="heading-1" />` );
-
-		// Act
-		const result = adaptLeafRootParams( params );
-
-		// Assert
-		const doc = parseXml( result.xmlStructure );
-		expect( doc.documentElement.tagName ).toBe( DIV_BLOCK_TAG );
-		expect( doc.documentElement.children[ 0 ].tagName ).toBe( LEAF_WIDGET_TAG );
-		expectElementAttribute( doc.documentElement, 'configuration-id', DIV_BLOCK_TITLE );
-	} );
-
-	it( 'preserves existing stylesConfig entries when wrapping', () => {
-		// Arrange
-		const params = makeParams( `<${ LEAF_WIDGET_TAG } configuration-id="heading-1" />`, {
-			stylesConfig: { 'heading-1': { color: 'red' } },
-		} );
-
-		// Act
-		const result = adaptLeafRootParams( params );
-
-		// Assert
-		expect( result.stylesConfig[ 'heading-1' ] ).toEqual( { color: 'red' } );
-	} );
-
-	it( 'does not wrap when root is a container', () => {
-		// Arrange
-		const params = makeParams(
-			`<${ CONTAINER_TAG } configuration-id="container-1"><${ LEAF_WIDGET_TAG } configuration-id="heading-1" /></${ CONTAINER_TAG }>`
-		);
-
-		// Act
-		const result = adaptLeafRootParams( params );
-
-		// Assert
-		expect( result ).toBe( params );
-	} );
-
-	it( 'preserves extra params fields unchanged', () => {
-		// Arrange
-		const params = makeParams( `<${ LEAF_WIDGET_TAG } configuration-id="heading-1" />`, {
-			elementConfig: { 'heading-1': { title: 'Hello' } },
-			stylesConfig: { 'heading-1': { color: 'red' } },
-		} );
-
-		// Act
-		const result = adaptLeafRootParams( params );
-
-		// Assert
-		expect( result.stylesConfig ).toEqual( {
-			'Div Block': {
-				margin: ZERO_SPACING,
-				padding: ZERO_SPACING,
-			},
-			...params.stylesConfig,
-		} );
-	} );
-
-	it( 'preserves leaf element attributes when wrapping', () => {
-		// Arrange
-		const params = makeParams( `<${ LEAF_WIDGET_TAG } configuration-id="heading-1" />` );
-
-		// Act
-		const { xmlStructure } = adaptLeafRootParams( params );
-
-		// Assert
-		const doc = parseXml( xmlStructure );
-		expectElementAttribute( doc.documentElement.children[ 0 ], 'configuration-id', 'heading-1' );
-	} );
-
-	it( 'returns unchanged params for unknown element types', () => {
-		// Arrange
-		const params = makeParams( '<unknown-widget configuration-id="w1" />' );
-
-		// Act
-		const result = adaptLeafRootParams( params );
-
-		// Assert
-		expect( result ).toBe( params );
-	} );
-} );

package/src/mcp/tools/build-composition/prompt.ts

@@ -1,167 +0,0 @@
-import { toolPrompts } from '@elementor/editor-mcp';
-
-import { AVAILABLE_WIDGETS_URI } from '../../resources/available-widgets-resource';
-import { DYNAMIC_TAGS_URI } from '../../resources/dynamic-tags-resource';
-
-export const BUILD_COMPOSITIONS_GUIDE_URI = 'elementor://canvas/tools/build-compositions-guide';
-
-export const generatePrompt = () => {
-	const buildCompositionsToolPrompt = toolPrompts( 'build-compositions' );
-
-	buildCompositionsToolPrompt.description( `
-# RESOURCES (Read before use)
-- [elementor://global-classes] - Check FIRST for reusable classes
-- [elementor://global-variables] - ONLY use variables defined here
-- [${ AVAILABLE_WIDGETS_URI }/v4]
-
-# TOOL SUPPORT
-This tool support v4 elements only
-
-# WORKFLOW
-1. Check/create global classes via "manage-global-classes" tool
-2. Build composition (THIS TOOL) - minimal inline styles
-3. Apply classes via "apply-global-class" tool
-
-# XML STRUCTURE
-- Use widget tags: \`<e-button configuration-id="btn1"></e-button>\`
-- Containers: "e-flexbox", "e-div-block", "e-tabs"
-- Every element needs unique "configuration-id"
-- No attributes, classes, IDs, or text nodes in XML
-
-## NESTED ELEMENTS
-Some elements have internal tree structures (nesting). When using these elements, you MUST build the FULL tree in XML.
-- Check \`llm_guidance.nesting\` in widget schemas for structure requirements
-- \`llm_guidance.required_direct_children\` lists element types that must appear as direct child tags in XML (from widget defaults)
-- \`allowed_child_types\` lists which element types can be nested inside
-- \`allowed_parents\` lists which element types this element can be placed inside
-
-# CONFIGURATION
-- Map configuration-id → elementConfig (props) + style (raw CSS declarations)
-- elementConfig PropValues require \`$$type\` matching schema
-- style is raw CSS (property → value strings); the server converts it to native styles and stores any unconvertible declarations as the element custom CSS
-- NO LINKS in configuration
-- Retry on errors up to 10x
-- Check \`llm_guidance.default_settings\` in widget schemas — omit only keys listed there from elementConfig unless the user explicitly asks to change them
-
-# DYNAMIC TAGS
-- A value can be made dynamic wherever its schema exposes a \`"$$type": "dynamic"\` variant. This may be the property root OR a NESTED field (e.g. an image's \`src\`, not the whole \`image\`).
-- Put the dynamic object EXACTLY at that node, in place of the static variant. The variant's \`name\` lists the allowed tags; read [${ DYNAMIC_TAGS_URI }] for each tag's settings schema.
-- Provide at that node: \`{ "$$type": "dynamic", "value": { "name": "<allowed tag>", "settings": { ... } } }\`
-- Example (image): \`{ "$$type": "image", "value": { "src": { "$$type": "dynamic", "value": { "name": "<image tag>", "settings": { ... } } } } }\`
-- Do NOT send \`group\` (it is resolved automatically). Populate \`settings\` strictly per the tag's schema; use \`{}\` only when it has none.
-
-Note about configuration ids: These names are visible to the end-user, make sure they make sense, related and relevant.
-
-# DESIGN PHILOSOPHY: CONTEXT-DRIVEN CREATIVITY
-
-**Use the user's context aggressively.** Business type, brand personality, target audience, and purpose should drive every design decision. A law firm needs gravitas; a children's app needs playfulness. Don't default to generic.
-
-## SIZING: DEFAULT IS NO SIZE (CRITICAL)
-
-**DO NOT specify height or width unless you have a specific visual reason.**
-
-Flexbox and CSS already handle sizing automatically:
-- Containers grow to fit their content
-- Flex children distribute space via flex properties, not width/height
-- Text elements size to their content
-
-WHEN TO SPECIFY SIZE:
-- min-height on ROOT section for viewport-spanning hero (use min-height, NOT height)
-- max-width for contained content areas (e.g., max-width: 60rem)
-- Explicit aspect ratios for media containers
-
-NEVER SPECIFY:
-- height on nested containers (causes overflow)
-- width on flex children (use flex-basis or gap instead)
-- 100vh on anything except root-level sections
-- Any size "just to be safe" - if unsure, OMIT IT
-
-vh units are VIEWPORT-relative. Nested 100vh inside 100vh = 200vh overflow.
-
-GOOD: \`<e-flexbox>content naturally sizes</e-flexbox>\`
-BAD: \`<e-flexbox style="height:100vh"><e-div-block style="height:100vh">overflow</e-div-block></e-flexbox>\`
-
-## Layout Variety (Break the Template)
-- AVOID: Full-width 100vh hero → three columns → testimonials → CTA (every AI does this)
-- VARY heights: Use auto-height sections with generous padding (6rem+). Let content breathe
-- VARY widths: Not everything spans full width. Use contained sections (max-width: 960px) mixed with edge-to-edge
-- ASYMMETRIC grids: 2:1, 1:3, offset layouts. Avoid equal column widths
-- Negative space as design element: Large margins create focus and sophistication
-- Break alignment intentionally: Offset headings, overlapping elements, broken grids
-
-## Visual Depth & Effects
-- Layer elements: Overlapping cards, text over images, floating elements
-- Subtle shadows with color tint (not pure black): \`box-shadow: 0 20px 60px rgba(<brand-color-here>, 0.15)\`
-- Gradient overlays on images for text readability
-- Border radius variation: Mix sharp (0) and soft (1rem+) corners purposefully
-- Backdrop blur for glassmorphism where appropriate
-- Micro-interactions via CSS: hover transforms, transitions (0.3s ease)
-
-## Typography with Character
-- Display fonts for headlines (from user's brand or contextually appropriate)
-- Size contrast: 4rem+ headlines vs 1rem body. Make hierarchy unmistakable
-- Letter-spacing: Tight for large headlines (-0.02em), loose for small caps (0.1em)
-- Line-height: Tight for headlines (1.1), generous for body (1.6-1.8)
-- Text decoration: Underlines, highlights, gradient text for emphasis
-
-## Color with Purpose
-- Extract palette from user context (brand colors, industry norms, mood)
-- 60-30-10 rule: dominant, secondary, accent
-- Tinted neutrals over pure grays: warm (#faf8f5, #2d2a26) or cool (#f5f7fa, #1e2430)
-- Color blocking: Large colored sections create visual rhythm
-- Gradient directions: Diagonal (135deg, 225deg) feel more dynamic than vertical
-
-## Spacing Strategy
-- Section padding: 6rem-10rem vertical, creating breathing room
-- Rhythm variation: Tight groups (2rem) with generous gaps between (6rem)
-- Use rem/em exclusively for responsive scaling
-- Generous padding on CTAs: min 1rem 2.5rem
-
-# HARD CONSTRAINTS
-- Variables ONLY from [elementor://global-variables] (others throw errors)
-- Avoid SVG widgets unless assets are pre-uploaded
-- Check \`llm_guidance\` in widget schemas (\`default_styles\`, nesting, required children)
-
-# PARAMETERS
-- **xmlStructure**: Valid XML with configuration-id attributes
-- **elementConfig**: configuration-id → widget PropValues
-- **style**: configuration-id → raw CSS declarations (property → value strings; no selectors)
-  ` );
-
-	buildCompositionsToolPrompt.example( `
-Section with heading + button (NO explicit heights - content sizes naturally):
-{
-  xmlStructure: "<e-flexbox configuration-id="Main Section"><e-heading configuration-id="Section Title"></e-heading><e-button configuration-id="Call to Action"></e-button></e-flexbox>",
-  elementConfig: {
-    "section1": { "tag": { "$$type": "string", "value": "section" } }
-  },
-  style: {
-    "Section Title": {
-      "padding": "6rem 4rem",
-      "background": "linear-gradient(135deg, #faf8f5 0%, #f0ebe4 100%)",
-      "font-size": "3.5rem",
-      "color": "#2d2a26"
-    }
-  }
-}
-Note: No height/width specified on any element - flexbox handles layout automatically.
-` );
-
-	buildCompositionsToolPrompt.parameter(
-		'xmlStructure',
-		`Valid XML structure with custom elementor tags and configuration-id attributes.`
-	);
-
-	buildCompositionsToolPrompt.parameter( 'elementConfig', `Record mapping configuration IDs to widget PropValues.` );
-
-	buildCompositionsToolPrompt.parameter(
-		'style',
-		`Record mapping configuration IDs to raw CSS declarations (property → value strings).`
-	);
-
-	buildCompositionsToolPrompt.instruction(
-		`Element IDs in the returned XML represent actual widgets. Use these IDs for subsequent styling or configuration changes.`
-	);
-
-	return buildCompositionsToolPrompt.prompt();
-};

package/src/mcp/tools/build-composition/schema.ts

@@ -1,42 +0,0 @@
-import { z } from '@elementor/schema';
-
-import { WIDGET_SCHEMA_URI } from '../../resources/widgets-schema-resource';
-
-export const inputSchema = {
-	xmlStructure: z.string().describe( 'The XML structure representing the composition to be built' ),
-	elementConfig: z
-		.record(
-			z.string().describe( 'The configuration id' ),
-			z.record(
-				z.string().describe( 'property name' ),
-				z.any().describe( `The PropValue for the property, refer to ${ WIDGET_SCHEMA_URI }` )
-			)
-		)
-		.describe( 'A record mapping element IDs to their configuration objects. REQUIRED' ),
-	style: z
-		.record(
-			z.string().describe( 'The configuration id' ),
-			z.record(
-				z.string().describe( 'A CSS property name, e.g. "color", "padding".' ),
-				z.string().describe( 'A CSS value, e.g. "6rem 4rem", "#2d2a26".' )
-			)
-		)
-		.describe(
-			'A record mapping element configuration IDs to their raw CSS declarations (property→value). Converted to native styles server-side; any declaration that cannot be converted is stored as the element custom CSS.'
-		)
-		.default( {} ),
-};
-
-export const outputSchema = {
-	errors: z.string().describe( 'Error message if the composition building failed' ).optional(),
-	xmlStructure: z
-		.string()
-		.describe(
-			'The built XML structure as a string. Must use this XML after completion of building the composition, it contains real IDs.'
-		)
-		.optional(),
-	llm_instructions: z
-		.string()
-		.describe( 'Instructions what to do next, Important to follow these instructions!' )
-		.optional(),
-};

package/src/mcp/tools/build-composition/xml-leaf-wrapper.ts

@@ -1,68 +0,0 @@
-import { type V1ElementConfig } from '@elementor/editor-elements';
-
-export const DIV_BLOCK_TAG = 'e-div-block';
-
-export const ZERO_SPACING = {
-	$$type: 'size',
-	value: {
-		size: {
-			$$type: 'number',
-			value: 0,
-		},
-		unit: {
-			$$type: 'string',
-			value: 'px',
-		},
-	},
-};
-
-export type BuildCompositionParams = {
-	xmlStructure: string;
-	stylesConfig: Record< string, Record< string, unknown > >;
-	widgetsCache: Record< string, V1ElementConfig >;
-	elementConfig: Record< string, Record< string, unknown > >;
-	[ key: string ]: unknown;
-};
-
-export function adaptLeafRootParams< T extends BuildCompositionParams >( params: T ): T {
-	const doc = new DOMParser().parseFromString( params.xmlStructure, 'application/xml' );
-	const rootElement = doc.documentElement;
-
-	if ( ! isLeafWidget( rootElement.tagName, params.widgetsCache ) ) {
-		return params;
-	}
-
-	const wrapperConfigId = getDivBlockWrapperConfigId( params.widgetsCache );
-
-	return {
-		...params,
-		xmlStructure: serializeWrapped( doc, rootElement, wrapperConfigId ),
-		stylesConfig: {
-			...params.stylesConfig,
-			[ wrapperConfigId ]: {
-				margin: ZERO_SPACING,
-				padding: ZERO_SPACING,
-				...params.stylesConfig[ wrapperConfigId ],
-			},
-		},
-	};
-}
-
-function getDivBlockWrapperConfigId( widgetsCache: Record< string, V1ElementConfig > ): string {
-	return widgetsCache[ DIV_BLOCK_TAG ]?.title ?? DIV_BLOCK_TAG;
-}
-
-function isLeafWidget( tagName: string, widgetsCache: Record< string, V1ElementConfig > ): boolean {
-	return widgetsCache[ tagName ]?.elType === 'widget';
-}
-
-function serializeWrapped( doc: Document, rootElement: Element, wrapperConfigId: string ): string {
-	const wrapper = doc.createElement( DIV_BLOCK_TAG );
-	wrapper.setAttribute( 'configuration-id', wrapperConfigId );
-	wrapper.appendChild( rootElement.cloneNode( true ) );
-
-	const wrappedDoc = new DOMParser().parseFromString( `<${ DIV_BLOCK_TAG } />`, 'application/xml' );
-	wrappedDoc.replaceChild( wrapper, wrappedDoc.documentElement );
-
-	return new XMLSerializer().serializeToString( wrappedDoc );
-}

package/src/mcp/utils/__tests__/get-composition-target-container.test.ts

@@ -1,59 +0,0 @@
-import { type V1Element } from '@elementor/editor-elements';
-
-import { getCompositionTargetContainer } from '../get-composition-target-container';
-
-const createMockContainer = ( id: string, children?: V1Element[] ): V1Element =>
-	( {
-		id,
-		model: { get: jest.fn(), set: jest.fn(), toJSON: jest.fn() },
-		settings: { get: jest.fn(), set: jest.fn(), toJSON: jest.fn() },
-		children,
-	} ) as unknown as V1Element;
-
-describe( 'getCompositionTargetContainer', () => {
-	it( 'should return first child when document type is elementor_component', () => {
-		// Arrange
-		const firstChild = createMockContainer( 'child-1' );
-		const documentContainer = createMockContainer( 'document', [ firstChild ] );
-
-		// Act
-		const result = getCompositionTargetContainer( documentContainer, 'elementor_component' );
-
-		// Assert
-		expect( result ).toBe( firstChild );
-	} );
-
-	it( 'should return document container when document type is not a component', () => {
-		// Arrange
-		const firstChild = createMockContainer( 'child-1' );
-		const documentContainer = createMockContainer( 'document', [ firstChild ] );
-
-		// Act
-		const result = getCompositionTargetContainer( documentContainer, 'page' );
-
-		// Assert
-		expect( result ).toBe( documentContainer );
-	} );
-
-	it( 'should return document container when document type is undefined', () => {
-		// Arrange
-		const documentContainer = createMockContainer( 'document' );
-
-		// Act
-		const result = getCompositionTargetContainer( documentContainer, undefined );
-
-		// Assert
-		expect( result ).toBe( documentContainer );
-	} );
-
-	it( 'should return document container when component has no children', () => {
-		// Arrange
-		const documentContainer = createMockContainer( 'document' );
-
-		// Act
-		const result = getCompositionTargetContainer( documentContainer, 'elementor_component' );
-
-		// Assert
-		expect( result ).toBe( documentContainer );
-	} );
-} );

package/src/mcp/utils/get-composition-target-container.ts

@@ -1,15 +0,0 @@
-import { COMPONENT_DOCUMENT_TYPE } from '@elementor/editor-documents';
-import { type V1Element } from '@elementor/editor-elements';
-
-export function getCompositionTargetContainer(
-	documentContainer: V1Element,
-	documentType: string | undefined
-): V1Element {
-	const firstChild = documentContainer.children?.[ 0 ];
-
-	if ( documentType === COMPONENT_DOCUMENT_TYPE && firstChild ) {
-		return firstChild;
-	}
-
-	return documentContainer;
-}