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

package/dist/index.mjs

@@ -3,6 +3,10 @@ import { z as z4 } from "@elementor/schema";
 
 // src/utils/create-prop-utils.ts
 import { z } from "@elementor/schema";
+var SCHEMA_CACHE = /* @__PURE__ */ new Map();
+function getPropSchemaFromCache(key) {
+  return SCHEMA_CACHE.get(key);
+}
 function createPropUtils(key, valueSchema) {
   const schema = z.strictObject({
     $$type: z.literal(key),
@@ -37,13 +41,15 @@ function createPropUtils(key, valueSchema) {
     }
     return prop.value;
   }
-  return {
+  const propUtil = {
     extract,
     isValid,
     create,
     schema,
     key
   };
+  SCHEMA_CACHE.set(key, propUtil);
+  return propUtil;
 }
 function createArrayPropUtils(key, valueSchema, overrideKey) {
   return createPropUtils(overrideKey || `${key}-array`, z.array(valueSchema));
@@ -228,7 +234,6 @@ var linkPropTypeUtil = createPropUtils(
   "link",
   z20.strictObject({
     destination: unknownChildrenSchema,
-    label: unknownChildrenSchema,
     isTargetBlank: unknownChildrenSchema
   })
 );
@@ -261,6 +266,7 @@ var backgroundPropTypeUtil = createPropUtils(
   "background",
   z23.strictObject({
     color: unknownChildrenSchema,
+    clip: unknownChildrenSchema,
     "background-overlay": unknownChildrenSchema
   })
 );
@@ -317,24 +323,48 @@ var gradientColorStopPropTypeUtil = createPropUtils(
   z27.array(colorStopPropTypeUtil.schema)
 );
 
-// src/prop-types/position.ts
+// src/prop-types/date-time.ts
 import { z as z28 } from "@elementor/schema";
+var DateTimePropTypeUtil = createPropUtils(
+  "date-time",
+  z28.strictObject({
+    date: unknownChildrenSchema,
+    time: unknownChildrenSchema
+  })
+);
+
+// src/prop-types/position.ts
+import { z as z29 } from "@elementor/schema";
 var positionPropTypeUtil = createPropUtils(
   "object-position",
-  z28.strictObject({
+  z29.strictObject({
     x: unknownChildrenSchema,
     y: unknownChildrenSchema
   })
 );
 
+// src/prop-types/query.ts
+import { z as z30 } from "@elementor/schema";
+var queryPropTypeUtil = createPropUtils(
+  "query",
+  z30.strictObject({
+    id: unknownChildrenSchema,
+    label: unknownChildrenSchema
+  })
+);
+
+// src/prop-types/html.ts
+import { z as z31 } from "@elementor/schema";
+var htmlPropTypeUtil = createPropUtils("html", z31.string().nullable());
+
 // src/prop-types/filter-prop-types/filter.ts
-import { z as z34 } from "@elementor/schema";
+import { z as z37 } from "@elementor/schema";
 
 // src/prop-types/filter-prop-types/drop-shadow-filter.ts
-import { z as z29 } from "@elementor/schema";
+import { z as z32 } from "@elementor/schema";
 var dropShadowFilterPropTypeUtil = createPropUtils(
   "drop-shadow",
-  z29.object({
+  z32.object({
     xAxis: unknownChildrenSchema,
     yAxis: unknownChildrenSchema,
     blur: unknownChildrenSchema,
@@ -343,37 +373,37 @@ var dropShadowFilterPropTypeUtil = createPropUtils(
 );
 
 // src/prop-types/filter-prop-types/filter-functions/blur-filter.ts
-import { z as z30 } from "@elementor/schema";
+import { z as z33 } from "@elementor/schema";
 var blurFilterPropTypeUtil = createPropUtils(
   "blur",
-  z30.strictObject({
+  z33.strictObject({
     size: unknownChildrenSchema
   })
 );
 
 // src/prop-types/filter-prop-types/filter-functions/color-tone-filter.ts
-import { z as z31 } from "@elementor/schema";
+import { z as z34 } from "@elementor/schema";
 var colorToneFilterPropTypeUtil = createPropUtils(
   "color-tone",
-  z31.strictObject({
+  z34.strictObject({
     size: unknownChildrenSchema
   })
 );
 
 // src/prop-types/filter-prop-types/filter-functions/hue-rotate-filter.ts
-import { z as z32 } from "@elementor/schema";
+import { z as z35 } from "@elementor/schema";
 var hueRotateFilterPropTypeUtil = createPropUtils(
   "hue-rotate",
-  z32.strictObject({
+  z35.strictObject({
     size: unknownChildrenSchema
   })
 );
 
 // src/prop-types/filter-prop-types/filter-functions/intensity-filter.ts
-import { z as z33 } from "@elementor/schema";
+import { z as z36 } from "@elementor/schema";
 var intensityFilterPropTypeUtil = createPropUtils(
   "intensity",
-  z33.strictObject({
+  z36.strictObject({
     size: unknownChildrenSchema
   })
 );
@@ -381,9 +411,9 @@ var intensityFilterPropTypeUtil = createPropUtils(
 // src/prop-types/filter-prop-types/filter.ts
 var cssFilterFunctionPropUtil = createPropUtils(
   "css-filter-func",
-  z34.object({
+  z37.object({
     func: stringPropTypeUtil.schema,
-    args: z34.union([
+    args: z37.union([
       blurFilterPropTypeUtil.schema,
       intensityFilterPropTypeUtil.schema,
       colorToneFilterPropTypeUtil.schema,
@@ -392,13 +422,13 @@ var cssFilterFunctionPropUtil = createPropUtils(
     ])
   })
 );
-var filterPropTypeUtil = createPropUtils("filter", z34.array(cssFilterFunctionPropUtil.schema));
+var filterPropTypeUtil = createPropUtils("filter", z37.array(cssFilterFunctionPropUtil.schema));
 
 // src/prop-types/transform-prop-types/transform.ts
-import { z as z35 } from "@elementor/schema";
+import { z as z38 } from "@elementor/schema";
 var transformPropTypeUtil = createPropUtils(
   "transform",
-  z35.strictObject({
+  z38.strictObject({
     "transform-functions": unknownChildrenSchema,
     "transform-origin": unknownChildrenSchema,
     perspective: unknownChildrenSchema,
@@ -407,10 +437,10 @@ var transformPropTypeUtil = createPropUtils(
 );
 
 // src/prop-types/transform-prop-types/transform-functions.ts
-import { z as z40 } from "@elementor/schema";
+import { z as z43 } from "@elementor/schema";
 
 // src/prop-types/transform-prop-types/transform-functions/move-transform.ts
-import { z as z36 } from "@elementor/schema";
+import { z as z39 } from "@elementor/schema";
 
 // src/prop-types/transform-prop-types/types.ts
 var TransformFunctionKeys = {
@@ -423,7 +453,7 @@ var TransformFunctionKeys = {
 // src/prop-types/transform-prop-types/transform-functions/move-transform.ts
 var moveTransformPropTypeUtil = createPropUtils(
   TransformFunctionKeys.move,
-  z36.strictObject({
+  z39.strictObject({
     x: unknownChildrenSchema,
     y: unknownChildrenSchema,
     z: unknownChildrenSchema
@@ -431,10 +461,10 @@ var moveTransformPropTypeUtil = createPropUtils(
 );
 
 // src/prop-types/transform-prop-types/transform-functions/rotate-transform.ts
-import { z as z37 } from "@elementor/schema";
+import { z as z40 } from "@elementor/schema";
 var rotateTransformPropTypeUtil = createPropUtils(
   TransformFunctionKeys.rotate,
-  z37.strictObject({
+  z40.strictObject({
     x: unknownChildrenSchema,
     y: unknownChildrenSchema,
     z: unknownChildrenSchema
@@ -442,10 +472,10 @@ var rotateTransformPropTypeUtil = createPropUtils(
 );
 
 // src/prop-types/transform-prop-types/transform-functions/scale-transform.ts
-import { z as z38 } from "@elementor/schema";
+import { z as z41 } from "@elementor/schema";
 var scaleTransformPropTypeUtil = createPropUtils(
   TransformFunctionKeys.scale,
-  z38.strictObject({
+  z41.strictObject({
     x: numberPropTypeUtil.schema.nullable(),
     y: numberPropTypeUtil.schema.nullable(),
     z: numberPropTypeUtil.schema.nullable()
@@ -453,10 +483,10 @@ var scaleTransformPropTypeUtil = createPropUtils(
 );
 
 // src/prop-types/transform-prop-types/transform-functions/skew-transform.ts
-import { z as z39 } from "@elementor/schema";
+import { z as z42 } from "@elementor/schema";
 var skewTransformPropTypeUtil = createPropUtils(
   TransformFunctionKeys.skew,
-  z39.strictObject({
+  z42.strictObject({
     x: unknownChildrenSchema,
     y: unknownChildrenSchema
   })
@@ -464,13 +494,13 @@ var skewTransformPropTypeUtil = createPropUtils(
 
 // src/prop-types/transform-prop-types/transform-functions.ts
 var filterTypes = moveTransformPropTypeUtil.schema.or(scaleTransformPropTypeUtil.schema).or(rotateTransformPropTypeUtil.schema).or(skewTransformPropTypeUtil.schema);
-var transformFunctionsPropTypeUtil = createPropUtils("transform-functions", z40.array(filterTypes));
+var transformFunctionsPropTypeUtil = createPropUtils("transform-functions", z43.array(filterTypes));
 
 // src/prop-types/transform-prop-types/transform-origin.ts
-import { z as z41 } from "@elementor/schema";
+import { z as z44 } from "@elementor/schema";
 var transformOriginPropTypeUtil = createPropUtils(
   "transform-origin",
-  z41.strictObject({
+  z44.strictObject({
     x: unknownChildrenSchema,
     y: unknownChildrenSchema,
     z: unknownChildrenSchema
@@ -478,25 +508,345 @@ var transformOriginPropTypeUtil = createPropUtils(
 );
 
 // src/prop-types/transform-prop-types/perspective-origin.ts
-import { z as z42 } from "@elementor/schema";
+import { z as z45 } from "@elementor/schema";
 var perspectiveOriginPropTypeUtil = createPropUtils(
   "perspective-origin",
-  z42.strictObject({
+  z45.strictObject({
     x: unknownChildrenSchema,
     y: unknownChildrenSchema
   })
 );
 
 // src/prop-types/filter-prop-types/backdrop-filter.ts
-import { z as z43 } from "@elementor/schema";
+import { z as z46 } from "@elementor/schema";
 var backdropFilterPropTypeUtil = createPropUtils(
   "backdrop-filter",
-  z43.array(cssFilterFunctionPropUtil.schema)
+  z46.array(cssFilterFunctionPropUtil.schema)
 );
 
+// src/utils/adjust-llm-prop-value-schema.ts
+var ensureNotNull = (v, fallback) => v === null ? fallback : v;
+var adjustLlmPropValueSchema = (value, forceKey) => {
+  const clone = structuredClone(value);
+  if (typeof clone === "string") {
+    return stringPropTypeUtil.create(clone);
+  }
+  if (typeof clone === "number") {
+    return numberPropTypeUtil.create(clone);
+  }
+  if (clone && typeof clone === "object") {
+    if (Array.isArray(clone)) {
+      return clone.map((item) => adjustLlmPropValueSchema(item, forceKey));
+    }
+    const transformablePropValue = clone;
+    if (forceKey) {
+      transformablePropValue.$$type = forceKey;
+    }
+    if (!transformablePropValue.$$type) {
+      throw new Error("Missing $$type in property: " + JSON.stringify(transformablePropValue));
+    }
+    if (!("value" in transformablePropValue)) {
+      throw new Error("Missing value property in PropValue: " + JSON.stringify(transformablePropValue));
+    }
+    switch (transformablePropValue.$$type) {
+      case "size": {
+        const { value: rawSizePropValue } = transformablePropValue;
+        const unit = typeof rawSizePropValue.unit === "string" ? rawSizePropValue.unit : ensureNotNull(stringPropTypeUtil.extract(rawSizePropValue.unit), "px");
+        const size = typeof rawSizePropValue.size === "string" || typeof rawSizePropValue.size === "number" ? rawSizePropValue.size : ensureNotNull(
+          stringPropTypeUtil.extract(rawSizePropValue.size),
+          numberPropTypeUtil.extract(rawSizePropValue.size)
+        );
+        return {
+          $$type: "size",
+          value: {
+            unit,
+            size
+          }
+        };
+      }
+    }
+    if (typeof transformablePropValue.value === "object") {
+      if (Array.isArray(transformablePropValue.value)) {
+        transformablePropValue.value = adjustLlmPropValueSchema(
+          transformablePropValue.value,
+          void 0
+        );
+      } else {
+        const { value: objectValue } = transformablePropValue;
+        const clonedObject = clone;
+        clonedObject.value = {};
+        Object.keys(objectValue).forEach((key) => {
+          const childProp = objectValue[key];
+          clonedObject.value[key] = adjustLlmPropValueSchema(
+            childProp,
+            void 0
+          );
+        });
+      }
+    }
+  }
+  return clone;
+};
+
+// src/utils/llm-schema-to-props.ts
+function jsonSchemaToPropType(schema, key = schema.key) {
+  const meta = {};
+  if (schema.description) {
+    meta.description = schema.description;
+  }
+  if (schema.anyOf && Array.isArray(schema.anyOf)) {
+    return convertJsonSchemaToUnionPropType(schema, meta);
+  }
+  if (schema.type === "object" && schema.properties) {
+    return convertJsonSchemaToObjectPropType(schema, meta, key);
+  }
+  if (schema.type === "array" && schema.items) {
+    return convertJsonSchemaToArrayPropType(schema, meta, key);
+  }
+  return convertJsonSchemaToPlainPropType(schema, meta, key);
+}
+function convertJsonSchemaToPlainPropType(schema, meta, key = schema.key) {
+  const settings = {};
+  let propKey = key || "string";
+  if (schema.type === "number") {
+    propKey = "number";
+  } else if (schema.type === "boolean") {
+    propKey = "boolean";
+  } else if (schema.type === "string") {
+    propKey = "string";
+  }
+  if (Array.isArray(schema.enum)) {
+    settings.enum = schema.enum;
+  }
+  return {
+    kind: "plain",
+    key: propKey,
+    settings,
+    meta
+  };
+}
+function convertJsonSchemaToUnionPropType(schema, meta) {
+  const propTypes = {};
+  if (!schema.anyOf || !Array.isArray(schema.anyOf)) {
+    throw new Error("Invalid anyOf schema");
+  }
+  for (const variantSchema of schema.anyOf) {
+    if (variantSchema.type === "object" && variantSchema.properties && variantSchema.properties.$$type && variantSchema.properties.value) {
+      const typeProperty = variantSchema.properties.$$type;
+      let typeKey;
+      if (typeProperty.enum && Array.isArray(typeProperty.enum) && typeProperty.enum.length > 0) {
+        typeKey = typeProperty.enum[0];
+      } else {
+        continue;
+      }
+      const valuePropType = convertJsonSchemaToPropType(variantSchema.properties.value);
+      propTypes[typeKey] = valuePropType;
+    }
+  }
+  return {
+    kind: "union",
+    prop_types: propTypes,
+    settings: {},
+    meta
+  };
+}
+function convertJsonSchemaToObjectPropType(schema, meta, key = schema.key) {
+  const shape = {};
+  if (!schema.properties) {
+    return {
+      kind: "object",
+      key,
+      shape: {},
+      settings: {},
+      meta
+    };
+  }
+  const requiredFields = Array.isArray(schema.required) ? schema.required : [];
+  for (const [propKey, propSchema] of Object.entries(schema.properties)) {
+    const subPropType = convertJsonSchemaToPropType(propSchema, key);
+    if (requiredFields.includes(propKey)) {
+      subPropType.settings = {
+        ...subPropType.settings,
+        required: true
+      };
+    }
+    shape[propKey] = subPropType;
+  }
+  return {
+    kind: "object",
+    key: key || "object",
+    shape,
+    settings: {},
+    meta
+  };
+}
+function convertJsonSchemaToArrayPropType(schema, meta, key = schema.key) {
+  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
+  };
+}
+function convertJsonSchemaToPropType(schema, key) {
+  return jsonSchemaToPropType(schema, key);
+}
+
+// src/utils/props-to-llm-schema.ts
+function propTypeToJsonSchema(propType) {
+  const description = propType.meta?.description;
+  const schema = {};
+  if (description) {
+    schema.description = description;
+  }
+  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, baseSchema) {
+  const schema = { ...baseSchema };
+  const key = propType.key.toLowerCase();
+  switch (key) {
+    case "number":
+      schema.type = "number";
+      break;
+    case "boolean":
+      schema.type = "boolean";
+      break;
+    default:
+      schema.type = "string";
+  }
+  if (Array.isArray(propType.settings?.enum)) {
+    schema.enum = propType.settings.enum;
+  }
+  return schema;
+}
+function convertUnionPropType(propType, baseSchema) {
+  const schema = structuredClone(baseSchema);
+  const propTypes = propType.prop_types || {};
+  const schemas = [];
+  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, baseSchema) {
+  const schema = structuredClone(baseSchema);
+  schema.type = "object";
+  schema.properties = {};
+  const required = [];
+  const shape = propType.shape || {};
+  for (const [key, subPropType] of Object.entries(shape)) {
+    const propSchema = convertPropTypeToJsonSchema(subPropType);
+    if (subPropType.settings?.required === true) {
+      required.push(key);
+    }
+    schema.properties[key] = propSchema;
+  }
+  if (required.length > 0) {
+    schema.required = required;
+  }
+  return schema;
+}
+function convertArrayPropType(propType, baseSchema) {
+  const schema = structuredClone(baseSchema);
+  schema.type = "array";
+  const itemPropType = propType.item_prop_type;
+  if (itemPropType) {
+    schema.items = convertPropTypeToJsonSchema(itemPropType);
+  }
+  return schema;
+}
+function convertPropTypeToJsonSchema(propType) {
+  return propTypeToJsonSchema(propType);
+}
+var nonConfigurablePropKeys = ["_cssid", "classes", "attributes"];
+function isPropKeyConfigurable(propKey) {
+  return !nonConfigurablePropKeys.includes(propKey);
+}
+function configurableKeys(schema) {
+  return Object.keys(schema).filter(isPropKeyConfigurable);
+}
+
+// src/utils/is-transformable.ts
+import { z as z47 } from "@elementor/schema";
+var transformableSchema = z47.object({
+  $$type: z47.string(),
+  value: z47.any(),
+  disabled: z47.boolean().optional()
+});
+var isTransformable = (value) => {
+  return transformableSchema.safeParse(value).success;
+};
+
+// src/utils/filter-empty-values.ts
+var filterEmptyValues = (value) => {
+  if (isEmpty(value)) {
+    return null;
+  }
+  if (Array.isArray(value)) {
+    return value.map(filterEmptyValues).filter((item) => !isEmpty(item));
+  }
+  if (typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, val]) => [key, filterEmptyValues(val)]).filter(([, val]) => !isEmpty(val))
+    );
+  }
+  return value;
+};
+var isEmpty = (value) => {
+  if (value && isTransformable(value)) {
+    return isEmpty(value.value);
+  }
+  return isNullish(value) || isNullishArray(value) || isNullishObject(value);
+};
+var isNullish = (value) => value === null || value === void 0 || value === "";
+var isNullishArray = (value) => Array.isArray(value) && value.every(isEmpty);
+var isNullishObject = (value) => {
+  return typeof value === "object" && isNullishArray(Object.values(value));
+};
+
 // src/utils/merge-props.ts
 function mergeProps(current, updates) {
-  const props = structuredClone(current);
+  let props = {};
+  if (!Array.isArray(current)) {
+    props = structuredClone(current);
+  }
   Object.entries(updates).forEach(([key, value]) => {
     if (value === null || value === void 0) {
       delete props[key];
@@ -507,27 +857,23 @@ function mergeProps(current, updates) {
   return props;
 }
 
-// src/utils/is-transformable.ts
-import { z as z44 } from "@elementor/schema";
-var transformableSchema = z44.object({
-  $$type: z44.string(),
-  value: z44.any(),
-  disabled: z44.boolean().optional()
-});
-var isTransformable = (value) => {
-  return transformableSchema.safeParse(value).success;
-};
-
 // src/utils/prop-dependency-utils.ts
 function isDependencyMet(dependency, values) {
   if (!dependency?.terms.length) {
-    return true;
+    return { isMet: true };
   }
   const { relation, terms } = dependency;
   const method = getRelationMethod(relation);
-  return terms[method](
-    (term) => isDependency(term) ? isDependencyMet(term, values) : evaluateTerm(term, extractValue(term.path, values)?.value)
-  );
+  const failingDependencies = [];
+  const isMet = terms[method]((term) => {
+    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 };
 }
 function evaluateTerm(term, actualValue) {
   const { value: valueToCompare, operator } = term;
@@ -590,34 +936,19 @@ function isDependency(term) {
   return "relation" in term;
 }
 
-// src/utils/filter-empty-values.ts
-var filterEmptyValues = (value) => {
-  if (isEmpty(value)) {
-    return null;
-  }
-  if (Array.isArray(value)) {
-    return value.map(filterEmptyValues).filter((item) => !isEmpty(item));
-  }
-  if (typeof value === "object") {
-    return Object.fromEntries(
-      Object.entries(value).map(([key, val]) => [key, filterEmptyValues(val)]).filter(([, val]) => !isEmpty(val))
-    );
-  }
-  return value;
-};
-var isEmpty = (value) => {
-  if (value && isTransformable(value)) {
-    return isEmpty(value.value);
-  }
-  return isNullish(value) || isNullishArray(value) || isNullishObject(value);
-};
-var isNullish = (value) => value === null || value === void 0 || value === "";
-var isNullishArray = (value) => Array.isArray(value) && value.every(isEmpty);
-var isNullishObject = (value) => {
-  return typeof value === "object" && isNullishArray(Object.values(value));
+// src/index.ts
+var Schema = {
+  jsonSchemaToPropType,
+  propTypeToJsonSchema,
+  adjustLlmPropValueSchema,
+  isPropKeyConfigurable,
+  nonConfigurablePropKeys,
+  configurableKeys
 };
 export {
   CLASSES_PROP_KEY,
+  DateTimePropTypeUtil,
+  Schema,
   backdropFilterPropTypeUtil,
   backgroundColorOverlayPropTypeUtil,
   backgroundGradientOverlayPropTypeUtil,
@@ -646,7 +977,9 @@ export {
   filterEmptyValues,
   filterPropTypeUtil,
   flexPropTypeUtil,
+  getPropSchemaFromCache,
   gradientColorStopPropTypeUtil,
+  htmlPropTypeUtil,
   hueRotateFilterPropTypeUtil,
   imageAttachmentIdPropType,
   imagePropTypeUtil,
@@ -664,6 +997,7 @@ export {
   numberPropTypeUtil,
   perspectiveOriginPropTypeUtil,
   positionPropTypeUtil,
+  queryPropTypeUtil,
   rotateTransformPropTypeUtil,
   scaleTransformPropTypeUtil,
   selectionSizePropTypeUtil,