@elementor/editor-props 3.33.0-99 → 3.35.0-325

package/src/utils/llm-schema-to-props.ts

@@ -0,0 +1,190 @@
+import { type PropsSchema, type PropType } from '../types';
+import { type JsonSchema7 } from './prop-json-schema';
+
+export function jsonSchemaToPropType( schema: JsonSchema7, key = < string >schema.key ): PropType {
+	const meta: Record< string, unknown > = {};
+
+	if ( schema.description ) {
+		meta.description = schema.description;
+	}
+
+	// Handle union types (anyOf)
+	if ( schema.anyOf && Array.isArray( schema.anyOf ) ) {
+		return convertJsonSchemaToUnionPropType( schema, meta );
+	}
+
+	// Handle object types
+	if ( schema.type === 'object' && schema.properties ) {
+		return convertJsonSchemaToObjectPropType( schema, meta, key );
+	}
+
+	// Handle array types
+	if ( schema.type === 'array' && schema.items ) {
+		return convertJsonSchemaToArrayPropType( schema, meta, key );
+	}
+
+	// Handle plain types (string, number, boolean)
+	return convertJsonSchemaToPlainPropType( schema, meta, key );
+}
+
+function convertJsonSchemaToPlainPropType(
+	schema: JsonSchema7,
+	meta: Record< string, unknown >,
+	key = < string >schema.key
+): PropType {
+	const settings: Record< string, unknown > = {};
+
+	// Determine the key based on type
+	let propKey = key || 'string';
+
+	if ( schema.type === 'number' ) {
+		propKey = 'number';
+	} else if ( schema.type === 'boolean' ) {
+		propKey = 'boolean';
+	} else if ( schema.type === 'string' ) {
+		propKey = 'string';
+	}
+
+	// Handle enum values
+	if ( Array.isArray( schema.enum ) ) {
+		settings.enum = schema.enum;
+	}
+
+	return {
+		kind: 'plain',
+		key: propKey,
+		settings,
+		meta,
+	} as PropType;
+}
+
+/**
+ * Converts a JSON Schema anyOf to a union PropType
+ * @param schema
+ * @param meta
+ */
+function convertJsonSchemaToUnionPropType( schema: JsonSchema7, meta: Record< string, unknown > ): PropType {
+	const propTypes: Record< string, PropType > = {};
+
+	if ( ! schema.anyOf || ! Array.isArray( schema.anyOf ) ) {
+		throw new Error( 'Invalid anyOf schema' );
+	}
+
+	// Process each variant in the anyOf array
+	for ( const variantSchema of schema.anyOf ) {
+		// Each variant should be an object with $$type and value properties
+		if (
+			variantSchema.type === 'object' &&
+			variantSchema.properties &&
+			variantSchema.properties.$$type &&
+			variantSchema.properties.value
+		) {
+			const typeProperty = variantSchema.properties.$$type;
+
+			// Extract the type key from the enum
+			let typeKey: string;
+			if ( typeProperty.enum && Array.isArray( typeProperty.enum ) && typeProperty.enum.length > 0 ) {
+				typeKey = typeProperty.enum[ 0 ] as string;
+			} else {
+				continue;
+			}
+
+			// Convert the value schema to a PropType
+			const valuePropType = convertJsonSchemaToPropType( variantSchema.properties.value );
+			propTypes[ typeKey ] = valuePropType;
+		}
+	}
+
+	return {
+		kind: 'union',
+		prop_types: propTypes,
+		settings: {},
+		meta,
+	} as PropType;
+}
+
+function convertJsonSchemaToObjectPropType(
+	schema: JsonSchema7,
+	meta: Record< string, unknown >,
+	key = < string >schema.key
+): PropType {
+	const shape: Record< string, PropType > = {};
+
+	if ( ! schema.properties ) {
+		return {
+			kind: 'object',
+			key,
+			shape: {},
+			settings: {},
+			meta,
+		} as PropType;
+	}
+
+	const requiredFields = Array.isArray( schema.required ) ? schema.required : [];
+
+	// Convert each property
+	for ( const [ propKey, propSchema ] of Object.entries( schema.properties ) ) {
+		const subPropType = convertJsonSchemaToPropType( propSchema, key );
+
+		// Mark as required if it's in the required array
+		if ( requiredFields.includes( propKey ) ) {
+			subPropType.settings = {
+				...subPropType.settings,
+				required: true,
+			};
+		}
+
+		shape[ propKey ] = subPropType;
+	}
+
+	return {
+		kind: 'object',
+		key: key || 'object',
+		shape,
+		settings: {},
+		meta,
+	} as PropType;
+}
+
+function convertJsonSchemaToArrayPropType(
+	schema: JsonSchema7,
+	meta: Record< string, unknown >,
+	key = < string >schema.key
+): PropType {
+	if ( ! schema.items ) {
+		throw new Error( 'Array schema must have items property' );
+	}
+
+	const itemPropType = convertJsonSchemaToPropType( schema.items );
+
+	return {
+		kind: 'array',
+		key: key || 'array',
+		item_prop_type: itemPropType,
+		settings: {},
+		meta,
+	} as PropType;
+}
+
+function convertJsonSchemaToPropType( schema: JsonSchema7, key?: string ): PropType {
+	return jsonSchemaToPropType( schema, key );
+}
+
+/**
+ * Converts a complete JSON Schema object back to a PropsSchema
+ *
+ * @param jsonSchema The JSON Schema to convert
+ */
+export function jsonSchemaToPropsSchema( jsonSchema: JsonSchema7 ): PropsSchema {
+	const propsSchema: PropsSchema = {};
+
+	if ( jsonSchema.type !== 'object' || ! jsonSchema.properties ) {
+		throw new Error( 'Root schema must be an object with properties' );
+	}
+
+	for ( const [ key, propSchema ] of Object.entries( jsonSchema.properties ) ) {
+		propsSchema[ key ] = convertJsonSchemaToPropType( propSchema, key );
+	}
+
+	return propsSchema;
+}

package/src/utils/merge-props.ts

@@ -1,7 +1,12 @@
 import type { Props } from '../types';
 
 export function mergeProps( current: Props, updates: Props ) {
-	const props = structuredClone( current );
+	// edge case, the server returns an array instead of an object when empty props because of PHP array / object conversion
+	let props: Props = {};
+
+	if ( ! Array.isArray( current ) ) {
+		props = structuredClone( current );
+	}
 
 	Object.entries( updates ).forEach( ( [ key, value ] ) => {
 		if ( value === null || value === undefined ) {

package/src/utils/prop-dependency-utils.ts

@@ -11,19 +11,32 @@ type ParsedTerm = DependencyTerm;
 
 type Relation = Dependency[ 'relation' ];
 
-export function isDependencyMet( dependency: Dependency | undefined, values: PropValue ): boolean {
+export function isDependencyMet(
+	dependency: Dependency | undefined,
+	values: PropValue
+): { isMet: true } | { isMet: false; failingDependencies: DependencyTerm[] } {
 	if ( ! dependency?.terms.length ) {
-		return true;
+		return { isMet: true };
 	}
 
 	const { relation, terms } = dependency;
 	const method = getRelationMethod( relation );
 
-	return terms[ method ]( ( term: ParsedTerm | Dependency ) =>
-		isDependency( term )
-			? isDependencyMet( term, values )
-			: evaluateTerm( term, extractValue( term.path, values )?.value )
-	);
+	const failingDependencies: DependencyTerm[] = [];
+	const isMet = terms[ method ]( ( term: ParsedTerm | Dependency ) => {
+		const isNestedDependency = isDependency( term );
+		const result = isNestedDependency
+			? isDependencyMet( term, values ).isMet
+			: evaluateTerm( term, extractValue( term.path, values )?.value );
+
+		if ( ! result && ! isNestedDependency ) {
+			failingDependencies.push( term );
+		}
+
+		return result;
+	} );
+
+	return { isMet, failingDependencies };
 }
 
 export function evaluateTerm( term: DependencyTerm, actualValue: unknown ) {

package/src/utils/prop-json-schema.ts

@@ -0,0 +1,17 @@
+export type JsonSchema7 = {
+	type?: string | string[];
+	properties?: Record< string, JsonSchema7 >;
+	items?: JsonSchema7;
+	enum?: unknown[];
+	anyOf?: JsonSchema7[];
+	oneOf?: JsonSchema7[];
+	allOf?: JsonSchema7[];
+	required?: string[];
+	description?: string;
+	default?: unknown;
+	if?: JsonSchema7;
+	then?: JsonSchema7;
+	else?: JsonSchema7;
+	key?: string;
+	[ key: string ]: unknown;
+};

package/src/utils/props-to-llm-schema.ts

@@ -0,0 +1,177 @@
+import { type PropsSchema, type PropType } from '../types';
+import { type JsonSchema7 } from './prop-json-schema';
+
+export function propTypeToJsonSchema( propType: PropType ): JsonSchema7 {
+	const description = propType.meta?.description;
+
+	const schema: JsonSchema7 = {};
+
+	if ( description ) {
+		schema.description = description;
+	}
+
+	// Handle different kinds of prop types
+	switch ( propType.kind ) {
+		case 'plain':
+			return convertPlainPropType( propType, schema );
+		case 'union':
+			return convertUnionPropType( propType, schema );
+		case 'object':
+			return convertObjectPropType( propType, schema );
+		case 'array':
+			return convertArrayPropType( propType, schema );
+		default:
+			return convertPlainPropType( propType, schema );
+	}
+
+	return schema;
+}
+
+function convertPlainPropType( propType: PropType & { kind: 'plain' }, baseSchema: JsonSchema7 ): JsonSchema7 {
+	const schema = { ...baseSchema };
+
+	// Determine type based on key
+	const key = propType.key.toLowerCase();
+
+	switch ( key ) {
+		case 'number':
+			schema.type = 'number';
+			break;
+		case 'boolean':
+			schema.type = 'boolean';
+			break;
+		default:
+			schema.type = 'string';
+	}
+
+	// Handle enum from settings
+	if ( Array.isArray( propType.settings?.enum ) ) {
+		schema.enum = propType.settings.enum;
+	}
+
+	return schema;
+}
+
+/**
+ * Converts a union prop type to JSON Schema ( электричество anyOf)
+ *
+ * @param propType   The union prop type to convert
+ * @param baseSchema Base schema to extend
+ */
+function convertUnionPropType( propType: PropType & { kind: 'union' }, baseSchema: JsonSchema7 ): JsonSchema7 {
+	const schema = structuredClone( baseSchema );
+
+	const propTypes = propType.prop_types || {};
+	const schemas: JsonSchema7[] = [];
+
+	// Convert each prop type in the union
+	for ( const [ typeKey, subPropType ] of Object.entries( propTypes ) ) {
+		const subSchema = convertPropTypeToJsonSchema( subPropType );
+
+		schemas.push( {
+			type: 'object',
+			required: [ '$$type', 'value' ],
+			properties: {
+				$$type: {
+					type: 'string',
+					const: typeKey,
+					description: subPropType.meta?.description,
+					$comment: `Discriminator for union type variant: ${ typeKey }`,
+				},
+				value: subSchema,
+			},
+		} );
+	}
+
+	if ( schemas.length > 0 ) {
+		schema.anyOf = schemas;
+	}
+
+	const propTypeDescription = propType.meta?.description;
+	if ( propTypeDescription ) {
+		schema.description = propTypeDescription;
+	}
+	return schema;
+}
+
+function convertObjectPropType( propType: PropType & { kind: 'object' }, baseSchema: JsonSchema7 ): JsonSchema7 {
+	const schema = structuredClone( baseSchema );
+
+	schema.type = 'object';
+	schema.properties = {};
+
+	const required: string[] = [];
+
+	const shape = propType.shape || {};
+
+	// Convert each property in the object shape
+	for ( const [ key, subPropType ] of Object.entries( shape ) ) {
+		const propSchema = convertPropTypeToJsonSchema( subPropType );
+
+		// Check if this property is required
+		if ( subPropType.settings?.required === true ) {
+			required.push( key );
+		}
+
+		schema.properties[ key ] = propSchema;
+	}
+
+	// Add required array if there are required fields
+	if ( required.length > 0 ) {
+		schema.required = required;
+	}
+
+	return schema;
+}
+
+function convertArrayPropType( propType: PropType & { kind: 'array' }, baseSchema: JsonSchema7 ): JsonSchema7 {
+	const schema = structuredClone( baseSchema );
+
+	schema.type = 'array';
+
+	const itemPropType = propType.item_prop_type;
+
+	if ( itemPropType ) {
+		schema.items = convertPropTypeToJsonSchema( itemPropType );
+	}
+
+	return schema;
+}
+
+function convertPropTypeToJsonSchema( propType: PropType ): JsonSchema7 {
+	return propTypeToJsonSchema( propType );
+}
+
+export function propsSchemaToJsonSchema( schema: PropsSchema ): JsonSchema7 {
+	const jsonSchema: JsonSchema7 = {
+		type: 'object',
+		properties: {},
+	};
+
+	for ( const [ key, propType ] of Object.entries( schema ) ) {
+		// Skip internal properties
+		if ( ! isPropKeyConfigurable( key ) ) {
+			continue;
+		}
+
+		const propSchema = convertPropTypeToJsonSchema( propType );
+		if ( jsonSchema.properties ) {
+			jsonSchema.properties[ key ] = propSchema;
+		}
+
+		// Handle required fields at root level if needed
+		// (typically props are optional unless specified)
+	}
+
+	return jsonSchema;
+}
+
+export const nonConfigurablePropKeys = [ '_cssid', 'classes', 'attributes' ] as readonly string[];
+
+export function isPropKeyConfigurable( propKey: string ): boolean {
+	return ! nonConfigurablePropKeys.includes( propKey );
+}
+
+export function configurableKeys( schema: PropsSchema ): string[] {
+	return Object.keys( schema ).filter( isPropKeyConfigurable );
+}