@elementor/editor-props 4.1.0 → 4.2.0-839

package/src/prop-types/time-string.ts

@@ -0,0 +1,7 @@
+import { z } from '@elementor/schema';
+
+import { createPropUtils } from '../utils/create-prop-utils';
+
+export const timeStringPropTypeUtil = createPropUtils( 'time-string', z.string() );
+
+export type TimeStringPropValue = z.infer< typeof timeStringPropTypeUtil.schema >;

package/src/utils/is-overridable.ts

@@ -0,0 +1,26 @@
+import { type TransformablePropValue } from '../types';
+import { isTransformable } from './is-transformable';
+
+type OverridableInner = {
+	override_key: string;
+	origin_value: TransformablePropValue< string >;
+};
+
+export type OverridableTransformable = TransformablePropValue< 'overridable', OverridableInner >;
+
+export function isOverridable( value: unknown ): value is OverridableTransformable {
+	return isTransformable( value ) && value.$$type === 'overridable';
+}
+
+export function rewrapOverridableValue(
+	existing: OverridableTransformable,
+	newInner: TransformablePropValue< string >
+): OverridableTransformable {
+	return {
+		...existing,
+		value: {
+			...existing.value,
+			origin_value: newInner,
+		},
+	};
+}

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

@@ -5,6 +5,7 @@ import {
 	type PropValue,
 	type TransformablePropValue,
 } from '../types';
+import { isOverridable } from './is-overridable';
 import { isTransformable } from './is-transformable';
 
 type ParsedTerm = DependencyTerm;
@@ -113,24 +114,51 @@ function getRelationMethod( relation: Relation ) {
 	}
 }
 
+export type ExtractValueOptions = {
+	unwrapOverridableLeaf?: boolean;
+};
+
 export function extractValue(
 	path: string[],
 	elementValues: PropValue,
-	nestedPath: string[] = []
-): TransformablePropValue< PropKey > | null {
+	nestedPath: string[] = [],
+	options: ExtractValueOptions = {}
+) {
+	const { unwrapOverridableLeaf = true } = options;
+
 	const extractedValue = path.reduce( ( acc, key, index ) => {
-		const value = acc?.[ key as keyof typeof acc ] as PropValue | null;
+		const value = acc?.[ key as keyof typeof acc ] as PropValue;
+
+		if ( index === path.length - 1 ) {
+			return value;
+		}
+
+		if ( isOverridable( value ) ) {
+			const inner = value.value.origin_value;
+
+			return isTransformable( inner ) ? inner.value ?? null : inner;
+		}
+
+		if ( isTransformable( value ) ) {
+			return value.value ?? null;
+		}
 
-		return index !== path.length - 1 && isTransformable( value ) ? value.value ?? null : value;
+		return value;
 	}, elementValues ) as TransformablePropValue< PropKey >;
 
+	let resolved = extractedValue;
+
+	if ( unwrapOverridableLeaf && resolved && isOverridable( resolved ) ) {
+		resolved = resolved.value.origin_value ?? null;
+	}
+
 	if ( ! nestedPath?.length ) {
-		return extractedValue;
+		return resolved;
 	}
 
 	const nestedValue = nestedPath.reduce(
 		( acc: Record< string, unknown >, key ) => acc?.[ key ] as Record< string, unknown >,
-		extractedValue?.value as Record< string, unknown >
+		resolved?.value as Record< string, unknown >
 	);
 
 	return {

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

@@ -186,38 +186,17 @@ 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 isPropKeyConfigurable( propKey: string, propType?: PropType ): boolean {
+	if ( ! nonConfigurablePropKeys.includes( propKey ) ) {
+		return true;
+	}
+	return !! ( ! Array.isArray( propType?.meta ) && propType?.meta?.llm_configurable );
 }
 
 export function configurableKeys( schema: PropsSchema ): string[] {
-	return Object.keys( schema ).filter( isPropKeyConfigurable );
+	return Object.keys( schema ).filter( ( key ) => isPropKeyConfigurable( key, schema[ key ] ) );
 }
 
 export function enrichWithIntention(