@rjsf/utils 6.4.1 → 6.5.0

package/dist/index.cjs

@@ -85,6 +85,9 @@ __export(index_exports, {
   descriptionId: () => descriptionId,
   dotNotationNameGenerator: () => dotNotationNameGenerator,
   englishStringTranslator: () => englishStringTranslator,
+  enumOptionSelectedValue: () => enumOptionSelectedValue,
+  enumOptionValueDecoder: () => enumOptionValueDecoder,
+  enumOptionValueEncoder: () => enumOptionValueEncoder,
   enumOptionsDeselectValue: () => enumOptionsDeselectValue,
   enumOptionsIndexForValue: () => enumOptionsIndexForValue,
   enumOptionsIsSelected: () => enumOptionsIsSelected,
@@ -92,7 +95,6 @@ __export(index_exports, {
   enumOptionsValueForIndex: () => enumOptionsValueForIndex,
   errorId: () => errorId,
   examplesId: () => examplesId,
-  expandUiSchemaDefinitions: () => expandUiSchemaDefinitions,
   findFieldInSchema: () => findFieldInSchema,
   findSchemaDefinition: () => findSchemaDefinition,
   findSelectedOptionInXxxOf: () => findSelectedOptionInXxxOf,
@@ -107,6 +109,7 @@ __export(index_exports, {
   getFromSchema: () => getFromSchema,
   getInputProps: () => getInputProps,
   getOptionMatchingSimpleDiscriminator: () => getOptionMatchingSimpleDiscriminator,
+  getOptionValueFormat: () => getOptionValueFormat,
   getSchemaType: () => getSchemaType,
   getSubmitButtonOptions: () => getSubmitButtonOptions,
   getTemplate: () => getTemplate,
@@ -143,6 +146,7 @@ __export(index_exports, {
   pad: () => pad,
   parseDateString: () => parseDateString,
   rangeSpec: () => rangeSpec,
+  removeOptionalEmptyObjects: () => removeOptionalEmptyObjects,
   replaceStringParameters: () => replaceStringParameters,
   resolveUiSchema: () => resolveUiSchema,
   retrieveSchema: () => retrieveSchema,
@@ -2836,6 +2840,36 @@ function englishStringTranslator(stringToTranslate, params) {
   return replaceStringParameters(stringToTranslate, params);
 }
 
+// src/enumOptionsIsSelected.ts
+function enumOptionsIsSelected(value, selected) {
+  if (Array.isArray(selected)) {
+    return selected.some((sel) => deepEquals(sel, value));
+  }
+  return deepEquals(selected, value);
+}
+
+// src/enumOptionsIndexForValue.ts
+function enumOptionsIndexForValue(value, allEnumOptions = [], multiple = false) {
+  const selectedIndexes = allEnumOptions.map((opt, index) => enumOptionsIsSelected(opt.value, value) ? String(index) : void 0).filter((opt) => typeof opt !== "undefined");
+  if (!multiple) {
+    return selectedIndexes[0];
+  }
+  return selectedIndexes;
+}
+
+// src/enumOptionSelectedValue.ts
+function enumOptionSelectedValue(value, enumOptions, multiple, format = "indexed", emptyValue) {
+  const isEmpty9 = typeof value === "undefined" || multiple && Array.isArray(value) && value.length < 1 || !multiple && value === emptyValue;
+  if (isEmpty9) {
+    return emptyValue;
+  }
+  if (format === "realValue") {
+    return multiple ? value.map(String) : String(value);
+  }
+  const indexes = enumOptionsIndexForValue(value, enumOptions, multiple);
+  return typeof indexes === "undefined" ? emptyValue : indexes;
+}
+
 // src/enumOptionsValueForIndex.ts
 function enumOptionsValueForIndex(valueIndex, allEnumOptions = [], emptyValue) {
   if (Array.isArray(valueIndex)) {
@@ -2846,37 +2880,60 @@ function enumOptionsValueForIndex(valueIndex, allEnumOptions = [], emptyValue) {
   return option ? option.value : emptyValue;
 }
 
-// src/enumOptionsDeselectValue.ts
-function enumOptionsDeselectValue(valueIndex, selected, allEnumOptions = []) {
-  const value = enumOptionsValueForIndex(valueIndex, allEnumOptions);
-  if (Array.isArray(selected)) {
-    return selected.filter((v) => !deepEquals(v, value));
+// src/enumOptionValueDecoder.ts
+function decodeSingle(value, enumOptions, emptyValue) {
+  if (value === "" || !Array.isArray(enumOptions)) {
+    return emptyValue;
   }
-  return deepEquals(value, selected) ? void 0 : selected;
+  const match = enumOptions.find((opt) => String(opt.value) === value);
+  if (match) {
+    return match.value;
+  }
+  const index = Number(value);
+  if (!isNaN(index) && index >= 0 && index < enumOptions.length) {
+    return enumOptions[index].value;
+  }
+  return emptyValue;
+}
+function enumOptionValueDecoder(value, enumOptions, format = "indexed", emptyValue) {
+  if (format !== "realValue") {
+    return enumOptionsValueForIndex(value, enumOptions, emptyValue);
+  }
+  if (Array.isArray(value)) {
+    return value.map((v) => decodeSingle(v, enumOptions, emptyValue));
+  }
+  return decodeSingle(value, enumOptions, emptyValue);
 }
 
-// src/enumOptionsIsSelected.ts
-function enumOptionsIsSelected(value, selected) {
-  if (Array.isArray(selected)) {
-    return selected.some((sel) => deepEquals(sel, value));
+// src/enumOptionValueEncoder.ts
+var import_isNil2 = __toESM(require("lodash/isNil"), 1);
+function enumOptionValueEncoder(value, index, format = "indexed") {
+  if (format !== "realValue") {
+    return String(index);
   }
-  return deepEquals(selected, value);
+  if ((0, import_isNil2.default)(value)) {
+    return "";
+  }
+  if (typeof value === "object") {
+    return String(index);
+  }
+  return String(value);
 }
 
-// src/enumOptionsIndexForValue.ts
-function enumOptionsIndexForValue(value, allEnumOptions = [], multiple = false) {
-  const selectedIndexes = allEnumOptions.map((opt, index) => enumOptionsIsSelected(opt.value, value) ? String(index) : void 0).filter((opt) => typeof opt !== "undefined");
-  if (!multiple) {
-    return selectedIndexes[0];
+// src/enumOptionsDeselectValue.ts
+function enumOptionsDeselectValue(valueIndex, selected, allEnumOptions = []) {
+  const value = enumOptionsValueForIndex(valueIndex, allEnumOptions);
+  if (Array.isArray(selected)) {
+    return selected.filter((v) => !deepEquals(v, value));
   }
-  return selectedIndexes;
+  return deepEquals(value, selected) ? void 0 : selected;
 }
 
 // src/enumOptionsSelectValue.ts
-var import_isNil2 = __toESM(require("lodash/isNil"), 1);
+var import_isNil3 = __toESM(require("lodash/isNil"), 1);
 function enumOptionsSelectValue(valueIndex, selected, allEnumOptions = []) {
   const value = enumOptionsValueForIndex(valueIndex, allEnumOptions);
-  if (!(0, import_isNil2.default)(value)) {
+  if (!(0, import_isNil3.default)(value)) {
     const index = allEnumOptions.findIndex((opt) => value === opt.value);
     const all = allEnumOptions.map(({ value: val }) => val);
     const updated = selected.slice(0, index).concat(value, selected.slice(index));
@@ -3069,6 +3126,14 @@ function getInputProps(schema, defaultType, options = {}, autoDefaultStepAny = t
       }
     }
   }
+  if (["date", "datetime-local", "time", "week", "month"].includes(inputProps.type)) {
+    if (schema.formatMinimum !== void 0) {
+      inputProps.min = schema.formatMinimum;
+    }
+    if (schema.formatMaximum !== void 0) {
+      inputProps.max = schema.formatMaximum;
+    }
+  }
   if (options.autocomplete) {
     inputProps.autoComplete = options.autocomplete;
   }
@@ -3078,6 +3143,11 @@ function getInputProps(schema, defaultType, options = {}, autoDefaultStepAny = t
   return inputProps;
 }
 
+// src/getOptionValueFormat.ts
+function getOptionValueFormat(options) {
+  return options?.optionValueFormat ?? "indexed";
+}
+
 // src/getSubmitButtonOptions.ts
 var DEFAULT_OPTIONS = {
   props: {
@@ -3298,11 +3368,11 @@ function optionalControlsId(id, element) {
 }
 
 // src/isFormDataAvailable.ts
-var import_isNil3 = __toESM(require("lodash/isNil"), 1);
+var import_isNil4 = __toESM(require("lodash/isNil"), 1);
 var import_isEmpty6 = __toESM(require("lodash/isEmpty"), 1);
 var import_isObject12 = __toESM(require("lodash/isObject"), 1);
 function isFormDataAvailable(formData) {
-  return !(0, import_isNil3.default)(formData) && (!(0, import_isObject12.default)(formData) || Array.isArray(formData) || !(0, import_isEmpty6.default)(formData));
+  return !(0, import_isNil4.default)(formData) && (!(0, import_isObject12.default)(formData) || Array.isArray(formData) || !(0, import_isEmpty6.default)(formData));
 }
 
 // src/isRootSchema.ts
@@ -3341,6 +3411,81 @@ function lookupFromFormContext(regOrFc, toLookup, fallback) {
   return (0, import_get22.default)(regOrFc, [...lookupPath, toLookup], fallback);
 }
 
+// src/removeOptionalEmptyObjects.ts
+var import_isNil5 = __toESM(require("lodash/isNil"), 1);
+function isValueEmpty(value) {
+  if ((0, import_isNil5.default)(value) || value === "") {
+    return true;
+  }
+  if (Array.isArray(value)) {
+    return value.length === 0;
+  }
+  if (isObject(value)) {
+    const obj = value;
+    const keys2 = Object.keys(obj);
+    return keys2.every((key) => isValueEmpty(obj[key]));
+  }
+  return false;
+}
+function removeOptionalEmptyObjects(validator, schema, rootSchema, formData) {
+  if (!isObject(schema)) {
+    return formData;
+  }
+  const resolvedSchema = retrieveSchema(validator, schema, rootSchema, formData);
+  if (Array.isArray(formData)) {
+    const itemsSchema = resolvedSchema.items;
+    if (!itemsSchema) {
+      return formData;
+    }
+    let hasChanges = false;
+    const mapped = formData.map((item, index) => {
+      let itemSchema = itemsSchema;
+      if (Array.isArray(itemsSchema)) {
+        itemSchema = itemsSchema[index] || resolvedSchema.additionalItems || {};
+      }
+      const cleaned = removeOptionalEmptyObjects(validator, itemSchema, rootSchema, item);
+      if (cleaned !== item) {
+        hasChanges = true;
+      }
+      return cleaned === void 0 ? {} : cleaned;
+    });
+    return hasChanges ? mapped : formData;
+  }
+  const { properties, required: requiredFields = [] } = resolvedSchema;
+  if (!isObject(formData) || !properties) {
+    return formData;
+  }
+  const result = {};
+  const data = formData;
+  let hasAnyValue = false;
+  for (const key of Object.keys(data)) {
+    const value = data[key];
+    const propertySchema = properties[key] || {};
+    const isRequired = requiredFields.includes(key);
+    const isObj = isObject(value);
+    const isArr = Array.isArray(value);
+    if ((isObj || isArr) && properties[key]) {
+      const cleaned = removeOptionalEmptyObjects(validator, propertySchema, rootSchema, value);
+      if (!isRequired && isValueEmpty(cleaned)) {
+        continue;
+      }
+      result[key] = cleaned;
+      hasAnyValue = true;
+    } else if (!isRequired && isValueEmpty(value) && properties[key]) {
+      continue;
+    } else {
+      result[key] = value;
+      if (!isValueEmpty(value)) {
+        hasAnyValue = true;
+      }
+    }
+  }
+  if (!hasAnyValue && Object.keys(result).length === 0) {
+    return void 0;
+  }
+  return result;
+}
+
 // src/orderProperties.ts
 function orderProperties(properties, order) {
   if (!Array.isArray(order)) {
@@ -3398,63 +3543,43 @@ function parseDateString(dateString, includeTime = true) {
 }
 
 // src/resolveUiSchema.ts
-var SAME_KEY_KEYWORDS = [ITEMS_KEY, ADDITIONAL_PROPERTIES_KEY];
-var ARRAY_KEYWORDS = [ONE_OF_KEY, ANY_OF_KEY, ALL_OF_KEY];
-function expandUiSchemaDefinitions(currentSchema, uiSchema, registry, visited = /* @__PURE__ */ new Set()) {
-  const { rootSchema, uiSchemaDefinitions: definitions } = registry;
-  let result = { ...uiSchema };
-  let resolvedSchema = currentSchema;
-  const ref = currentSchema[REF_KEY];
-  const isRecursive = ref && visited.has(ref);
-  if (ref) {
-    visited.add(ref);
-    if (definitions && ref in definitions) {
-      result = mergeObjects(definitions[ref], result);
-    }
-    if (isRecursive) {
-      return result;
-    }
-    try {
-      resolvedSchema = findSchemaDefinition(ref, rootSchema);
-    } catch {
-      resolvedSchema = currentSchema;
-    }
+var import_isEmpty7 = __toESM(require("lodash/isEmpty"), 1);
+function resolveUiSchema(schema, localUiSchema, registry) {
+  const ref = schema[RJSF_REF_KEY] ?? schema[REF_KEY];
+  const definitions = registry.uiSchemaDefinitions;
+  const definitionUiSchema = ref && definitions ? definitions[ref] : void 0;
+  let result;
+  if (!definitionUiSchema) {
+    result = localUiSchema || {};
+  } else if (!localUiSchema || (0, import_isEmpty7.default)(localUiSchema)) {
+    result = { ...definitionUiSchema };
+  } else {
+    result = mergeObjects(definitionUiSchema, localUiSchema);
   }
-  const properties = resolvedSchema[PROPERTIES_KEY];
-  if (properties && isObject(properties)) {
-    for (const [propName, propSchema] of Object.entries(properties)) {
-      const propUiSchema = result[propName] || {};
-      const expanded = expandUiSchemaDefinitions(propSchema, propUiSchema, registry, new Set(visited));
-      if (Object.keys(expanded).length > 0) {
-        result[propName] = expanded;
+  if (definitions) {
+    let resolvedSchema = schema;
+    if (ref && schema[REF_KEY] && !schema[RJSF_REF_KEY]) {
+      try {
+        resolvedSchema = findSchemaDefinition(ref, registry.rootSchema);
+      } catch (e) {
+        console.warn("could not resolve $ref in resolveUiSchema:\n", e);
+        return result;
       }
     }
-  }
-  for (const keyword of SAME_KEY_KEYWORDS) {
-    const subSchema = resolvedSchema[keyword];
-    if (subSchema && isObject(subSchema) && !Array.isArray(subSchema)) {
-      const currentUiSchema = result[keyword];
-      if (typeof currentUiSchema !== "function") {
-        const subUiSchema = currentUiSchema || {};
-        const expanded = expandUiSchemaDefinitions(subSchema, subUiSchema, registry, new Set(visited));
-        if (Object.keys(expanded).length > 0) {
-          result[keyword] = expanded;
-        }
+    for (const keyword of [ONE_OF_KEY, ANY_OF_KEY]) {
+      const schemaOptions = resolvedSchema[keyword];
+      if (!Array.isArray(schemaOptions) || schemaOptions.length === 0) {
+        continue;
       }
-    }
-  }
-  for (const keyword of ARRAY_KEYWORDS) {
-    const schemaOptions = resolvedSchema[keyword];
-    if (Array.isArray(schemaOptions) && schemaOptions.length > 0) {
       const currentUiSchemaArray = result[keyword];
       const uiSchemaArray = Array.isArray(currentUiSchemaArray) ? [...currentUiSchemaArray] : [];
       let hasExpanded = false;
       for (let i = 0; i < schemaOptions.length; i++) {
-        const optionSchema = schemaOptions[i];
-        const optionUiSchema = uiSchemaArray[i] || {};
-        const expanded = expandUiSchemaDefinitions(optionSchema, optionUiSchema, registry, new Set(visited));
-        if (Object.keys(expanded).length > 0) {
-          uiSchemaArray[i] = expanded;
+        const option = schemaOptions[i];
+        const optionRef = option?.[RJSF_REF_KEY] ?? option?.[REF_KEY];
+        if (optionRef && optionRef in definitions) {
+          const optionUiSchema = uiSchemaArray[i] || {};
+          uiSchemaArray[i] = mergeObjects(definitions[optionRef], optionUiSchema);
           hasExpanded = true;
         }
       }
@@ -3465,17 +3590,6 @@ function expandUiSchemaDefinitions(currentSchema, uiSchema, registry, visited =
   }
   return result;
 }
-function resolveUiSchema(schema, localUiSchema, registry) {
-  const ref = schema[RJSF_REF_KEY] ?? schema[REF_KEY];
-  const definitionUiSchema = ref ? registry.uiSchemaDefinitions?.[ref] : void 0;
-  if (!definitionUiSchema) {
-    return localUiSchema || {};
-  }
-  if (!localUiSchema || Object.keys(localUiSchema).length === 0) {
-    return { ...definitionUiSchema };
-  }
-  return mergeObjects(definitionUiSchema, localUiSchema);
-}
 
 // src/schemaRequiresTrueValue.ts
 function schemaRequiresTrueValue(schema) {
@@ -3842,7 +3956,7 @@ function utcToLocal(jsonDate) {
 }
 
 // src/validationDataMerge.ts
-var import_isEmpty7 = __toESM(require("lodash/isEmpty"), 1);
+var import_isEmpty8 = __toESM(require("lodash/isEmpty"), 1);
 function validationDataMerge(validationData, additionalErrorSchema, preventDuplicates = false) {
   if (!additionalErrorSchema) {
     return validationData;
@@ -3850,7 +3964,7 @@ function validationDataMerge(validationData, additionalErrorSchema, preventDupli
   const { errors: oldErrors, errorSchema: oldErrorSchema } = validationData;
   let errors = toErrorList(additionalErrorSchema);
   let errorSchema = additionalErrorSchema;
-  if (!(0, import_isEmpty7.default)(oldErrorSchema)) {
+  if (!(0, import_isEmpty8.default)(oldErrorSchema)) {
     errorSchema = mergeObjects(
       oldErrorSchema,
       additionalErrorSchema,