@rjsf/utils 6.0.0-beta.9 → 6.0.0

package/dist/{index.js → index.cjs}

@@ -35,10 +35,13 @@ __export(index_exports, {
   ALL_OF_KEY: () => ALL_OF_KEY,
   ANY_OF_KEY: () => ANY_OF_KEY,
   CONST_KEY: () => CONST_KEY,
+  DEFAULT_ID_PREFIX: () => DEFAULT_ID_PREFIX,
+  DEFAULT_ID_SEPARATOR: () => DEFAULT_ID_SEPARATOR,
   DEFAULT_KEY: () => DEFAULT_KEY,
   DEFINITIONS_KEY: () => DEFINITIONS_KEY,
   DEPENDENCIES_KEY: () => DEPENDENCIES_KEY,
   DISCRIMINATOR_PATH: () => DISCRIMINATOR_PATH,
+  DateElement: () => DateElement,
   ENUM_KEY: () => ENUM_KEY,
   ERRORS_KEY: () => ERRORS_KEY,
   ErrorSchemaBuilder: () => ErrorSchemaBuilder,
@@ -46,6 +49,7 @@ __export(index_exports, {
   ID_KEY: () => ID_KEY,
   IF_KEY: () => IF_KEY,
   ITEMS_KEY: () => ITEMS_KEY,
+  JSON_SCHEMA_DRAFT_2019_09: () => JSON_SCHEMA_DRAFT_2019_09,
   JSON_SCHEMA_DRAFT_2020_12: () => JSON_SCHEMA_DRAFT_2020_12,
   JUNK_OPTION_ID: () => JUNK_OPTION_ID,
   LOOKUP_MAP_NAME: () => LOOKUP_MAP_NAME,
@@ -68,6 +72,7 @@ __export(index_exports, {
   allowAdditionalItems: () => allowAdditionalItems,
   ariaDescribedByIds: () => ariaDescribedByIds,
   asNumber: () => asNumber,
+  bracketNameGenerator: () => bracketNameGenerator,
   buttonId: () => buttonId,
   canExpand: () => canExpand,
   createErrorHandler: () => createErrorHandler,
@@ -76,6 +81,7 @@ __export(index_exports, {
   dateRangeOptions: () => dateRangeOptions,
   deepEquals: () => deepEquals,
   descriptionId: () => descriptionId,
+  dotNotationNameGenerator: () => dotNotationNameGenerator,
   englishStringTranslator: () => englishStringTranslator,
   enumOptionsDeselectValue: () => enumOptionsDeselectValue,
   enumOptionsIndexForValue: () => enumOptionsIndexForValue,
@@ -113,8 +119,10 @@ __export(index_exports, {
   isCustomWidget: () => isCustomWidget,
   isFilesArray: () => isFilesArray,
   isFixedItems: () => isFixedItems,
+  isFormDataAvailable: () => isFormDataAvailable,
   isMultiSelect: () => isMultiSelect,
   isObject: () => isObject,
+  isRootSchema: () => isRootSchema,
   isSelect: () => isSelect,
   labelValue: () => labelValue,
   localToUTC: () => localToUTC,
@@ -123,6 +131,7 @@ __export(index_exports, {
   mergeObjects: () => mergeObjects,
   mergeSchemas: () => mergeSchemas,
   optionId: () => optionId,
+  optionalControlsId: () => optionalControlsId,
   optionsList: () => optionsList,
   orderProperties: () => orderProperties,
   pad: () => pad,
@@ -133,16 +142,21 @@ __export(index_exports, {
   sanitizeDataForNewSchema: () => sanitizeDataForNewSchema,
   schemaParser: () => schemaParser,
   schemaRequiresTrueValue: () => schemaRequiresTrueValue,
+  shallowEquals: () => shallowEquals,
   shouldRender: () => shouldRender,
+  shouldRenderOptionalField: () => shouldRenderOptionalField,
   sortedJSONStringify: () => sortedJSONStringify,
   titleId: () => titleId,
   toConstant: () => toConstant,
   toDateString: () => toDateString,
   toErrorList: () => toErrorList,
   toErrorSchema: () => toErrorSchema,
-  toIdSchema: () => toIdSchema,
+  toFieldPathId: () => toFieldPathId,
   toPathSchema: () => toPathSchema,
   unwrapErrorHandler: () => unwrapErrorHandler,
+  useAltDateWidgetProps: () => useAltDateWidgetProps,
+  useDeepCompareMemo: () => useDeepCompareMemo,
+  useFileWidgetProps: () => useFileWidgetProps,
   utcToLocal: () => utcToLocal,
   validationDataMerge: () => validationDataMerge,
   withIdRefPrefix: () => withIdRefPrefix
@@ -217,6 +231,8 @@ var REQUIRED_KEY = "required";
 var SUBMIT_BTN_OPTIONS_KEY = "submitButtonOptions";
 var REF_KEY = "$ref";
 var SCHEMA_KEY = "$schema";
+var DEFAULT_ID_PREFIX = "root";
+var DEFAULT_ID_SEPARATOR = "_";
 var DISCRIMINATOR_PATH = ["discriminator", "propertyName"];
 var FORM_CONTEXT_NAME = "formContext";
 var LOOKUP_MAP_NAME = "layoutGridLookupMap";
@@ -226,10 +242,14 @@ var UI_FIELD_KEY = "ui:field";
 var UI_WIDGET_KEY = "ui:widget";
 var UI_OPTIONS_KEY = "ui:options";
 var UI_GLOBAL_OPTIONS_KEY = "ui:globalOptions";
+var JSON_SCHEMA_DRAFT_2019_09 = "https://json-schema.org/draft/2019-09/schema";
 var JSON_SCHEMA_DRAFT_2020_12 = "https://json-schema.org/draft/2020-12/schema";
 
 // src/getUiOptions.ts
 function getUiOptions(uiSchema = {}, globalOptions = {}) {
+  if (!uiSchema) {
+    return { ...globalOptions };
+  }
   return Object.keys(uiSchema).filter((key) => key.indexOf("ui:") === 0).reduce(
     (options, key) => {
       const value = uiSchema[key];
@@ -328,7 +348,16 @@ function findEmbeddedSchemaRecursive(schema, ref) {
     return schema;
   }
   for (const subSchema of Object.values(schema)) {
-    if ((0, import_isObject3.default)(subSchema)) {
+    if (Array.isArray(subSchema)) {
+      for (const item of subSchema) {
+        if ((0, import_isObject3.default)(item)) {
+          const result = findEmbeddedSchemaRecursive(item, ref);
+          if (result !== void 0) {
+            return result;
+          }
+        }
+      }
+    } else if ((0, import_isObject3.default)(subSchema)) {
       const result = findEmbeddedSchemaRecursive(subSchema, ref);
       if (result !== void 0) {
         return result;
@@ -337,6 +366,23 @@ function findEmbeddedSchemaRecursive(schema, ref) {
   }
   return void 0;
 }
+function makeAllReferencesAbsolute(schema, baseURI) {
+  const currentURI = (0, import_get.default)(schema, ID_KEY, baseURI);
+  if (REF_KEY in schema) {
+    schema = { ...schema, [REF_KEY]: import_fast_uri.default.resolve(currentURI, schema[REF_KEY]) };
+  }
+  for (const [key, subSchema] of Object.entries(schema)) {
+    if (Array.isArray(subSchema)) {
+      schema = {
+        ...schema,
+        [key]: subSchema.map((item) => (0, import_isObject3.default)(item) ? makeAllReferencesAbsolute(item, currentURI) : item)
+      };
+    } else if ((0, import_isObject3.default)(subSchema)) {
+      schema = { ...schema, [key]: makeAllReferencesAbsolute(subSchema, currentURI) };
+    }
+  }
+  return schema;
+}
 function splitKeyElementFromObject(key, object) {
   const value = object[key];
   const remaining = (0, import_omit.default)(object, [key]);
@@ -382,7 +428,11 @@ function findSchemaDefinitionRecursive($ref, rootSchema = {}, recurseList = [],
     const [remaining, theRef] = splitKeyElementFromObject(REF_KEY, current);
     const subSchema = findSchemaDefinitionRecursive(theRef, rootSchema, [...recurseList, ref], baseURI);
     if (Object.keys(remaining).length > 0) {
-      return { ...remaining, ...subSchema };
+      if (rootSchema[SCHEMA_KEY] === JSON_SCHEMA_DRAFT_2019_09 || rootSchema[SCHEMA_KEY] === JSON_SCHEMA_DRAFT_2020_12) {
+        return { [ALL_OF_KEY]: [remaining, subSchema] };
+      } else {
+        return { ...remaining, ...subSchema };
+      }
     }
     return subSchema;
   }
@@ -550,7 +600,7 @@ function getFirstMatchingOption(validator, formData, options, rootSchema, discri
 
 // src/schema/retrieveSchema.ts
 var import_isEmpty2 = __toESM(require("lodash/isEmpty"), 1);
-function retrieveSchema(validator, schema, rootSchema = {}, rawFormData, experimental_customMergeAllOf) {
+function retrieveSchema(validator, schema, rootSchema = {}, rawFormData, experimental_customMergeAllOf, resolveAnyOfOrOneOfRefs = false) {
   return retrieveSchemaInternal(
     validator,
     schema,
@@ -558,7 +608,8 @@ function retrieveSchema(validator, schema, rootSchema = {}, rawFormData, experim
     rawFormData,
     void 0,
     void 0,
-    experimental_customMergeAllOf
+    experimental_customMergeAllOf,
+    resolveAnyOfOrOneOfRefs
   )[0];
 }
 function resolveCondition(validator, schema, rootSchema, expandAllBranches, recurseList, formData, experimental_customMergeAllOf) {
@@ -647,14 +698,16 @@ function getMatchingPatternProperties(schema, key) {
     {}
   );
 }
-function resolveSchema(validator, schema, rootSchema, expandAllBranches, recurseList, formData, experimental_customMergeAllOf) {
+function resolveSchema(validator, schema, rootSchema, expandAllBranches, recurseList, formData, experimental_customMergeAllOf, resolveAnyOfOrOneOfRefs) {
   const updatedSchemas = resolveReference(
     validator,
     schema,
     rootSchema,
     expandAllBranches,
     recurseList,
-    formData
+    formData,
+    experimental_customMergeAllOf,
+    resolveAnyOfOrOneOfRefs
   );
   if (updatedSchemas.length > 1 || updatedSchemas[0] !== schema) {
     return updatedSchemas;
@@ -666,7 +719,8 @@ function resolveSchema(validator, schema, rootSchema, expandAllBranches, recurse
       rootSchema,
       expandAllBranches,
       recurseList,
-      formData
+      formData,
+      experimental_customMergeAllOf
     );
     return resolvedSchemas.flatMap((s) => {
       return retrieveSchemaInternal(
@@ -680,7 +734,7 @@ function resolveSchema(validator, schema, rootSchema, expandAllBranches, recurse
       );
     });
   }
-  if (ALL_OF_KEY in schema && Array.isArray(schema.allOf)) {
+  if (ALL_OF_KEY in schema && Array.isArray(schema[ALL_OF_KEY])) {
     const allOfSchemaElements = schema.allOf.map(
       (allOfSubschema) => retrieveSchemaInternal(
         validator,
@@ -700,8 +754,8 @@ function resolveSchema(validator, schema, rootSchema, expandAllBranches, recurse
   }
   return [schema];
 }
-function resolveReference(validator, schema, rootSchema, expandAllBranches, recurseList, formData, experimental_customMergeAllOf) {
-  const updatedSchema = resolveAllReferences(schema, rootSchema, recurseList);
+function resolveReference(validator, schema, rootSchema, expandAllBranches, recurseList, formData, experimental_customMergeAllOf, resolveAnyOfOrOneOfRefs) {
+  const updatedSchema = resolveAllReferences(schema, rootSchema, recurseList, void 0, resolveAnyOfOrOneOfRefs);
   if (updatedSchema !== schema) {
     return retrieveSchemaInternal(
       validator,
@@ -710,12 +764,13 @@ function resolveReference(validator, schema, rootSchema, expandAllBranches, recu
       formData,
       expandAllBranches,
       recurseList,
-      experimental_customMergeAllOf
+      experimental_customMergeAllOf,
+      resolveAnyOfOrOneOfRefs
     );
   }
   return [schema];
 }
-function resolveAllReferences(schema, rootSchema, recurseList, baseURI) {
+function resolveAllReferences(schema, rootSchema, recurseList, baseURI, resolveAnyOfOrOneOfRefs) {
   if (!isObject(schema)) {
     return schema;
   }
@@ -738,7 +793,7 @@ function resolveAllReferences(schema, rootSchema, recurseList, baseURI) {
       resolvedSchema[PROPERTIES_KEY],
       (result, value, key) => {
         const childList = [...recurseList];
-        result[key] = resolveAllReferences(value, rootSchema, childList, baseURI);
+        result[key] = resolveAllReferences(value, rootSchema, childList, baseURI, resolveAnyOfOrOneOfRefs);
         childrenLists.push(childList);
       },
       {}
@@ -749,9 +804,28 @@ function resolveAllReferences(schema, rootSchema, recurseList, baseURI) {
   if (ITEMS_KEY in resolvedSchema && !Array.isArray(resolvedSchema.items) && typeof resolvedSchema.items !== "boolean") {
     resolvedSchema = {
       ...resolvedSchema,
-      items: resolveAllReferences(resolvedSchema.items, rootSchema, recurseList, baseURI)
+      items: resolveAllReferences(resolvedSchema.items, rootSchema, recurseList, baseURI, resolveAnyOfOrOneOfRefs)
     };
   }
+  if (resolveAnyOfOrOneOfRefs) {
+    let key;
+    let schemas;
+    if (ANY_OF_KEY in schema && Array.isArray(schema[ANY_OF_KEY])) {
+      key = ANY_OF_KEY;
+      schemas = resolvedSchema[ANY_OF_KEY];
+    } else if (ONE_OF_KEY in schema && Array.isArray(schema[ONE_OF_KEY])) {
+      key = ONE_OF_KEY;
+      schemas = resolvedSchema[ONE_OF_KEY];
+    }
+    if (key && schemas) {
+      resolvedSchema = {
+        ...resolvedSchema,
+        [key]: schemas.map(
+          (s) => resolveAllReferences(s, rootSchema, recurseList, baseURI, resolveAnyOfOrOneOfRefs)
+        )
+      };
+    }
+  }
   return deepEquals(schema, resolvedSchema) ? schema : resolvedSchema;
 }
 function stubExistingAdditionalProperties(validator, theSchema, rootSchema, aFormData, experimental_customMergeAllOf) {
@@ -769,7 +843,7 @@ function stubExistingAdditionalProperties(validator, theSchema, rootSchema, aFor
       if (!(0, import_isEmpty2.default)(matchingProperties)) {
         schema.properties[key] = retrieveSchema(
           validator,
-          { allOf: Object.values(matchingProperties) },
+          { [ALL_OF_KEY]: Object.values(matchingProperties) },
           rootSchema,
           (0, import_get5.default)(formData, [key]),
           experimental_customMergeAllOf
@@ -779,12 +853,12 @@ function stubExistingAdditionalProperties(validator, theSchema, rootSchema, aFor
       }
     }
     if (ADDITIONAL_PROPERTIES_KEY in schema && schema.additionalProperties !== false) {
-      let additionalProperties = {};
+      let additionalProperties;
       if (typeof schema.additionalProperties !== "boolean") {
         if (REF_KEY in schema.additionalProperties) {
           additionalProperties = retrieveSchema(
             validator,
-            { $ref: (0, import_get5.default)(schema.additionalProperties, [REF_KEY]) },
+            { [REF_KEY]: (0, import_get5.default)(schema.additionalProperties, [REF_KEY]) },
             rootSchema,
             formData,
             experimental_customMergeAllOf
@@ -811,7 +885,7 @@ function stubExistingAdditionalProperties(validator, theSchema, rootSchema, aFor
   });
   return schema;
 }
-function retrieveSchemaInternal(validator, schema, rootSchema, rawFormData, expandAllBranches = false, recurseList = [], experimental_customMergeAllOf) {
+function retrieveSchemaInternal(validator, schema, rootSchema, rawFormData, expandAllBranches = false, recurseList = [], experimental_customMergeAllOf, resolveAnyOfOrOneOfRefs) {
   if (!isObject(schema)) {
     return [{}];
   }
@@ -822,7 +896,8 @@ function retrieveSchemaInternal(validator, schema, rootSchema, rawFormData, expa
     expandAllBranches,
     recurseList,
     rawFormData,
-    experimental_customMergeAllOf
+    experimental_customMergeAllOf,
+    resolveAnyOfOrOneOfRefs
   );
   return resolvedSchemas.flatMap((s) => {
     let resolvedSchema = s;
@@ -1379,8 +1454,19 @@ function mergeDefaultsWithFormData(defaults, formData, mergeExtraArrayDefaults =
       const keyValue = (0, import_get10.default)(formData, key);
       const keyExistsInDefaults = isObject(defaults) && key in defaults;
       const keyExistsInFormData = key in formData;
+      const keyDefault = (0, import_get10.default)(defaults, key) ?? {};
+      const defaultValueIsNestedObject = keyExistsInDefaults && Object.entries(keyDefault).some(([, v]) => isObject(v));
+      const keyDefaultIsObject = keyExistsInDefaults && isObject((0, import_get10.default)(defaults, key));
+      const keyHasFormDataObject = keyExistsInFormData && isObject(keyValue);
+      if (keyDefaultIsObject && keyHasFormDataObject && !defaultValueIsNestedObject) {
+        acc2[key] = {
+          ...(0, import_get10.default)(defaults, key),
+          ...keyValue
+        };
+        return acc2;
+      }
       acc2[key] = mergeDefaultsWithFormData(
-        defaults ? (0, import_get10.default)(defaults, key) : {},
+        (0, import_get10.default)(defaults, key),
         keyValue,
         mergeExtraArrayDefaults,
         defaultSupercedesUndefined,
@@ -1391,7 +1477,7 @@ function mergeDefaultsWithFormData(defaults, formData, mergeExtraArrayDefaults =
       return acc2;
     }, acc);
   }
-  if (defaultSupercedesUndefined && (!(0, import_isNil.default)(defaults) && (0, import_isNil.default)(formData) || typeof formData === "number" && isNaN(formData)) || overrideFormDataWithDefaults && !(0, import_isNil.default)(formData)) {
+  if (defaultSupercedesUndefined && (!(defaults === void 0) && (0, import_isNil.default)(formData) || typeof formData === "number" && isNaN(formData)) || overrideFormDataWithDefaults && !(0, import_isNil.default)(formData)) {
     return defaults;
   }
   return formData;
@@ -1538,10 +1624,19 @@ function getInnerSchemaForArrayItem(schema, additionalItems = 0 /* Ignore */, id
   }
   return {};
 }
+function computeDefaultBasedOnSchemaTypeAndDefaults(schema, computedDefault) {
+  const { default: schemaDefault, type } = schema;
+  const shouldReturnNullAsDefault = Array.isArray(type) && type.includes("null") && (0, import_isEmpty4.default)(computedDefault) && schemaDefault === null;
+  return shouldReturnNullAsDefault ? null : computedDefault;
+}
 function maybeAddDefaultToObject(obj, key, computedDefault, includeUndefinedValues, isParentRequired, requiredFields = [], experimental_defaultFormStateBehavior = {}, isConst = false) {
   const { emptyObjectFields = "populateAllDefaults" } = experimental_defaultFormStateBehavior;
-  if (includeUndefinedValues || isConst) {
+  if (includeUndefinedValues === true || isConst) {
     obj[key] = computedDefault;
+  } else if (includeUndefinedValues === "excludeObjectChildren") {
+    if (!isObject(computedDefault) || !(0, import_isEmpty4.default)(computedDefault)) {
+      obj[key] = computedDefault;
+    }
   } else if (emptyObjectFields !== "skipDefaults") {
     const isSelfOrParentRequired = isParentRequired === void 0 ? requiredFields.includes(key) : isParentRequired;
     if (isObject(computedDefault)) {
@@ -1573,7 +1668,8 @@ function computeDefaults(validator, rawSchema, computeDefaultsProps = {}) {
     experimental_defaultFormStateBehavior = void 0,
     experimental_customMergeAllOf = void 0,
     required,
-    shouldMergeDefaultsIntoFormData = false
+    shouldMergeDefaultsIntoFormData = false,
+    initialDefaultsGenerated
   } = computeDefaultsProps;
   let formData = isObject(rawFormData) ? rawFormData : {};
   const schema = isObject(rawSchema) ? rawSchema : {};
@@ -1581,7 +1677,7 @@ function computeDefaults(validator, rawSchema, computeDefaultsProps = {}) {
   let schemaToCompute = null;
   let experimental_dfsb_to_compute = experimental_defaultFormStateBehavior;
   let updatedRecurseList = _recurseList;
-  if (schema[CONST_KEY] && experimental_defaultFormStateBehavior?.constAsDefaults !== "never" && !constIsAjvDataReference(schema)) {
+  if (schema[CONST_KEY] !== void 0 && experimental_defaultFormStateBehavior?.constAsDefaults !== "never" && !constIsAjvDataReference(schema)) {
     defaults = schema[CONST_KEY];
   } else if (isObject(defaults) && isObject(schema.default)) {
     defaults = mergeObjects(defaults, schema.default);
@@ -1676,9 +1772,10 @@ function computeDefaults(validator, rawSchema, computeDefaultsProps = {}) {
       experimental_defaultFormStateBehavior: experimental_dfsb_to_compute,
       experimental_customMergeAllOf,
       parentDefaults: defaults,
-      rawFormData: formData,
+      rawFormData: rawFormData ?? formData,
       required,
-      shouldMergeDefaultsIntoFormData
+      shouldMergeDefaultsIntoFormData,
+      initialDefaultsGenerated
     });
   }
   if (defaults === void 0) {
@@ -1730,7 +1827,8 @@ function getObjectDefaults(validator, rawSchema, {
   experimental_defaultFormStateBehavior = void 0,
   experimental_customMergeAllOf = void 0,
   required,
-  shouldMergeDefaultsIntoFormData
+  shouldMergeDefaultsIntoFormData,
+  initialDefaultsGenerated
 } = {}, defaults) {
   {
     const formData = isObject(rawFormData) ? rawFormData : {};
@@ -1751,7 +1849,8 @@ function getObjectDefaults(validator, rawSchema, {
           parentDefaults: (0, import_get12.default)(defaults, [key]),
           rawFormData: (0, import_get12.default)(formData, [key]),
           required: retrievedSchema.required?.includes(key),
-          shouldMergeDefaultsIntoFormData
+          shouldMergeDefaultsIntoFormData,
+          initialDefaultsGenerated
         });
         maybeAddDefaultToObject(
           acc,
@@ -1767,7 +1866,7 @@ function getObjectDefaults(validator, rawSchema, {
       },
       {}
     );
-    if (retrievedSchema.additionalProperties) {
+    if (retrievedSchema.additionalProperties && !initialDefaultsGenerated) {
       const additionalPropertiesSchema = isObject(retrievedSchema.additionalProperties) ? retrievedSchema.additionalProperties : {};
       const keys2 = /* @__PURE__ */ new Set();
       if (isObject(defaults)) {
@@ -1788,7 +1887,8 @@ function getObjectDefaults(validator, rawSchema, {
           parentDefaults: (0, import_get12.default)(defaults, [key]),
           rawFormData: (0, import_get12.default)(formData, [key]),
           required: retrievedSchema.required?.includes(key),
-          shouldMergeDefaultsIntoFormData
+          shouldMergeDefaultsIntoFormData,
+          initialDefaultsGenerated
         });
         maybeAddDefaultToObject(
           objectDefaults,
@@ -1800,7 +1900,7 @@ function getObjectDefaults(validator, rawSchema, {
         );
       });
     }
-    return objectDefaults;
+    return computeDefaultBasedOnSchemaTypeAndDefaults(rawSchema, objectDefaults);
   }
 }
 function getArrayDefaults(validator, rawSchema, {
@@ -1810,7 +1910,9 @@ function getArrayDefaults(validator, rawSchema, {
   experimental_defaultFormStateBehavior = void 0,
   experimental_customMergeAllOf = void 0,
   required,
-  shouldMergeDefaultsIntoFormData
+  requiredAsRoot = false,
+  shouldMergeDefaultsIntoFormData,
+  initialDefaultsGenerated
 } = {}, defaults) {
   const schema = rawSchema;
   const arrayMinItemsStateBehavior = experimental_defaultFormStateBehavior?.arrayMinItems ?? {};
@@ -1831,7 +1933,8 @@ function getArrayDefaults(validator, rawSchema, {
         experimental_customMergeAllOf,
         parentDefaults: item,
         required,
-        shouldMergeDefaultsIntoFormData
+        shouldMergeDefaultsIntoFormData,
+        initialDefaultsGenerated
       });
     });
   }
@@ -1849,7 +1952,8 @@ function getArrayDefaults(validator, rawSchema, {
           rawFormData: item,
           parentDefaults: (0, import_get12.default)(defaults, [idx]),
           required,
-          shouldMergeDefaultsIntoFormData
+          shouldMergeDefaultsIntoFormData,
+          initialDefaultsGenerated
         });
       });
       const mergeExtraDefaults = (ignoreMinItemsFlagSet && required || isPopulateAll) && arrayMergeExtraDefaults;
@@ -1865,25 +1969,29 @@ function getArrayDefaults(validator, rawSchema, {
       return defaults ? defaults : void 0;
     }
   }
+  let arrayDefault;
   const defaultsLength = Array.isArray(defaults) ? defaults.length : 0;
   if (!schema.minItems || isMultiSelect(validator, schema, rootSchema, experimental_customMergeAllOf) || computeSkipPopulate(validator, schema, rootSchema) || schema.minItems <= defaultsLength) {
-    return defaults ? defaults : emptyDefault;
-  }
-  const defaultEntries = defaults || [];
-  const fillerSchema = getInnerSchemaForArrayItem(schema, 1 /* Invert */);
-  const fillerDefault = fillerSchema.default;
-  const fillerEntries = new Array(schema.minItems - defaultsLength).fill(
-    computeDefaults(validator, fillerSchema, {
-      parentDefaults: fillerDefault,
-      rootSchema,
-      _recurseList,
-      experimental_defaultFormStateBehavior,
-      experimental_customMergeAllOf,
-      required,
-      shouldMergeDefaultsIntoFormData
-    })
-  );
-  return defaultEntries.concat(fillerEntries);
+    arrayDefault = defaults || !required && !requiredAsRoot ? defaults : emptyDefault;
+  } else {
+    const defaultEntries = defaults || [];
+    const fillerSchema = getInnerSchemaForArrayItem(schema, 1 /* Invert */);
+    const fillerDefault = fillerSchema.default;
+    const fillerEntries = Array.from(
+      { length: schema.minItems - defaultsLength },
+      () => computeDefaults(validator, fillerSchema, {
+        parentDefaults: fillerDefault,
+        rootSchema,
+        _recurseList,
+        experimental_defaultFormStateBehavior,
+        experimental_customMergeAllOf,
+        required,
+        shouldMergeDefaultsIntoFormData
+      })
+    );
+    arrayDefault = defaultEntries.concat(fillerEntries);
+  }
+  return computeDefaultBasedOnSchemaTypeAndDefaults(rawSchema, arrayDefault);
 }
 function getDefaultBasedOnSchemaType(validator, rawSchema, computeDefaultsProps = {}, defaults) {
   switch (getSchemaType(rawSchema)) {
@@ -1896,7 +2004,7 @@ function getDefaultBasedOnSchemaType(validator, rawSchema, computeDefaultsProps
     }
   }
 }
-function getDefaultFormState(validator, theSchema, formData, rootSchema, includeUndefinedValues = false, experimental_defaultFormStateBehavior, experimental_customMergeAllOf) {
+function getDefaultFormState(validator, theSchema, formData, rootSchema, includeUndefinedValues = false, experimental_defaultFormStateBehavior, experimental_customMergeAllOf, initialDefaultsGenerated) {
   if (!isObject(theSchema)) {
     throw new Error("Invalid schema: " + theSchema);
   }
@@ -1907,8 +2015,16 @@ function getDefaultFormState(validator, theSchema, formData, rootSchema, include
     experimental_defaultFormStateBehavior,
     experimental_customMergeAllOf,
     rawFormData: formData,
-    shouldMergeDefaultsIntoFormData: true
+    shouldMergeDefaultsIntoFormData: true,
+    initialDefaultsGenerated,
+    requiredAsRoot: true
   });
+  if (schema.type !== "object" && isObject(schema.default)) {
+    return {
+      ...defaults,
+      ...formData
+    };
+  }
   if (isObject(formData) || Array.isArray(formData)) {
     const { mergeDefaultsIntoFormData } = experimental_defaultFormStateBehavior || {};
     const defaultSupercedesUndefined = mergeDefaultsIntoFormData === "useDefaultIfFormDataUndefined";
@@ -1965,10 +2081,10 @@ function getDisplayLabel(validator, schema, uiSchema = {}, rootSchema, globalOpt
   if (schemaType === "object") {
     displayLabel = false;
   }
-  if (schemaType === "boolean" && !uiSchema[UI_WIDGET_KEY]) {
+  if (schemaType === "boolean" && uiSchema && !uiSchema[UI_WIDGET_KEY]) {
     displayLabel = false;
   }
-  if (uiSchema[UI_FIELD_KEY]) {
+  if (uiSchema && uiSchema[UI_FIELD_KEY]) {
     displayLabel = false;
   }
   return displayLabel;
@@ -2107,80 +2223,8 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
   return newFormData;
 }
 
-// src/schema/toIdSchema.ts
-var import_get14 = __toESM(require("lodash/get"), 1);
-function toIdSchemaInternal(validator, schema, idPrefix, idSeparator, id, rootSchema, formData, _recurseList = [], experimental_customMergeAllOf) {
-  const $id = id || idPrefix;
-  const idSchema = { $id };
-  if (typeof schema === "object") {
-    if (REF_KEY in schema || DEPENDENCIES_KEY in schema || ALL_OF_KEY in schema) {
-      const _schema = retrieveSchema(validator, schema, rootSchema, formData, experimental_customMergeAllOf);
-      const sameSchemaIndex = _recurseList.findIndex((item) => deepEquals(item, _schema));
-      if (sameSchemaIndex === -1) {
-        return toIdSchemaInternal(
-          validator,
-          _schema,
-          idPrefix,
-          idSeparator,
-          id,
-          rootSchema,
-          formData,
-          _recurseList.concat(_schema),
-          experimental_customMergeAllOf
-        );
-      }
-    }
-    if (ITEMS_KEY in schema && !(0, import_get14.default)(schema, [ITEMS_KEY, REF_KEY])) {
-      return toIdSchemaInternal(
-        validator,
-        (0, import_get14.default)(schema, ITEMS_KEY),
-        idPrefix,
-        idSeparator,
-        id,
-        rootSchema,
-        formData,
-        _recurseList,
-        experimental_customMergeAllOf
-      );
-    }
-    if (getSchemaType(schema) === "object" && PROPERTIES_KEY in schema) {
-      for (const name in schema.properties) {
-        const field = schema[PROPERTIES_KEY][name];
-        const fieldId = idSchema[ID_KEY] + idSeparator + name;
-        idSchema[name] = toIdSchemaInternal(
-          validator,
-          field,
-          idPrefix,
-          idSeparator,
-          fieldId,
-          rootSchema,
-          // It's possible that formData is not an object -- this can happen if an
-          // array item has just been added, but not populated with data yet
-          (0, import_get14.default)(formData, [name]),
-          _recurseList,
-          experimental_customMergeAllOf
-        );
-      }
-    }
-  }
-  return idSchema;
-}
-function toIdSchema(validator, schema, id, rootSchema, formData, idPrefix = "root", idSeparator = "_", experimental_customMergeAllOf) {
-  return toIdSchemaInternal(
-    validator,
-    schema,
-    idPrefix,
-    idSeparator,
-    id,
-    rootSchema,
-    formData,
-    void 0,
-    experimental_customMergeAllOf
-  );
-}
-
 // src/schema/toPathSchema.ts
-var import_get15 = __toESM(require("lodash/get"), 1);
+var import_get14 = __toESM(require("lodash/get"), 1);
 var import_set2 = __toESM(require("lodash/set"), 1);
 function toPathSchemaInternal(validator, schema, name, rootSchema, formData, _recurseList = [], experimental_customMergeAllOf) {
   if (REF_KEY in schema || DEPENDENCIES_KEY in schema || ALL_OF_KEY in schema) {
@@ -2273,7 +2317,7 @@ function toPathSchemaInternal(validator, schema, name, rootSchema, formData, _re
     }
   } else if (PROPERTIES_KEY in schema) {
     for (const property in schema.properties) {
-      const field = (0, import_get15.default)(schema, [PROPERTIES_KEY, property], {});
+      const field = (0, import_get14.default)(schema, [PROPERTIES_KEY, property], {});
       pathSchema[property] = toPathSchemaInternal(
         validator,
         field,
@@ -2281,7 +2325,7 @@ function toPathSchemaInternal(validator, schema, name, rootSchema, formData, _re
         rootSchema,
         // It's possible that formData is not an object -- this can happen if an
         // array item has just been added, but not populated with data yet
-        (0, import_get15.default)(formData, [property]),
+        (0, import_get14.default)(formData, [property]),
         _recurseList,
         experimental_customMergeAllOf
       );
@@ -2294,6 +2338,7 @@ function toPathSchema(validator, schema, name = "", rootSchema, formData, experi
 }
 
 // src/createSchemaUtils.ts
+var import_get15 = __toESM(require("lodash/get"), 1);
 var SchemaUtils = class {
   /** Constructs the `SchemaUtils` instance with the given `validator` and `rootSchema` stored as instance variables
    *
@@ -2303,11 +2348,22 @@ var SchemaUtils = class {
    * @param [experimental_customMergeAllOf] - Optional function that allows for custom merging of `allOf` schemas
    */
   constructor(validator, rootSchema, experimental_defaultFormStateBehavior, experimental_customMergeAllOf) {
-    this.rootSchema = rootSchema;
+    if (rootSchema && rootSchema[SCHEMA_KEY] === JSON_SCHEMA_DRAFT_2020_12) {
+      this.rootSchema = makeAllReferencesAbsolute(rootSchema, (0, import_get15.default)(rootSchema, ID_KEY, "#"));
+    } else {
+      this.rootSchema = rootSchema;
+    }
     this.validator = validator;
     this.experimental_defaultFormStateBehavior = experimental_defaultFormStateBehavior;
     this.experimental_customMergeAllOf = experimental_customMergeAllOf;
   }
+  /** Returns the `rootSchema` in the `SchemaUtilsType`
+   *
+   * @returns - The `rootSchema`
+   */
+  getRootSchema() {
+    return this.rootSchema;
+  }
   /** Returns the `ValidatorType` in the `SchemaUtilsType`
    *
    * @returns - The `ValidatorType`
@@ -2380,9 +2436,10 @@ var SchemaUtils = class {
    * @param [includeUndefinedValues=false] - Optional flag, if true, cause undefined values to be added as defaults.
    *          If "excludeObjectChildren", pass `includeUndefinedValues` as false when computing defaults for any nested
    *          object properties.
+   * @param initialDefaultsGenerated - Indicates whether or not initial defaults have been generated
    * @returns - The resulting `formData` with all the defaults provided
    */
-  getDefaultFormState(schema, formData, includeUndefinedValues = false) {
+  getDefaultFormState(schema, formData, includeUndefinedValues = false, initialDefaultsGenerated) {
     return getDefaultFormState(
       this.validator,
       schema,
@@ -2390,7 +2447,8 @@ var SchemaUtils = class {
       this.rootSchema,
       includeUndefinedValues,
       this.experimental_defaultFormStateBehavior,
-      this.experimental_customMergeAllOf
+      this.experimental_customMergeAllOf,
+      initialDefaultsGenerated
     );
   }
   /** Determines whether the combination of `schema` and `uiSchema` properties indicates that the label for the `schema`
@@ -2489,15 +2547,17 @@ var SchemaUtils = class {
    *
    * @param schema - The schema for which retrieving a schema is desired
    * @param [rawFormData] - The current formData, if any, to assist retrieving a schema
+   * @param [resolveAnyOfOrOneOfRefs] - Optional flag indicating whether to resolved refs in anyOf/oneOf lists
    * @returns - The schema having its conditions, additional properties, references and dependencies resolved
    */
-  retrieveSchema(schema, rawFormData) {
+  retrieveSchema(schema, rawFormData, resolveAnyOfOrOneOfRefs) {
     return retrieveSchema(
       this.validator,
       schema,
       this.rootSchema,
       rawFormData,
-      this.experimental_customMergeAllOf
+      this.experimental_customMergeAllOf,
+      resolveAnyOfOrOneOfRefs
     );
   }
   /** Sanitize the `data` associated with the `oldSchema` so it is considered appropriate for the `newSchema`. If the
@@ -2521,27 +2581,6 @@ var SchemaUtils = class {
       this.experimental_customMergeAllOf
     );
   }
-  /** Generates an `IdSchema` object for the `schema`, recursively
-   *
-   * @param schema - The schema for which the display label flag is desired
-   * @param [id] - The base id for the schema
-   * @param [formData] - The current formData, if any, onto which to provide any missing defaults
-   * @param [idPrefix='root'] - The prefix to use for the id
-   * @param [idSeparator='_'] - The separator to use for the path segments in the id
-   * @returns - The `IdSchema` object for the `schema`
-   */
-  toIdSchema(schema, id, formData, idPrefix = "root", idSeparator = "_") {
-    return toIdSchema(
-      this.validator,
-      schema,
-      id,
-      this.rootSchema,
-      formData,
-      idPrefix,
-      idSeparator,
-      this.experimental_customMergeAllOf
-    );
-  }
   /** Generates an `PathSchema` object for the `schema`, recursively
    *
    * @param schema - The schema for which the display label flag is desired
@@ -2627,6 +2666,31 @@ function dateRangeOptions(start, stop) {
   return options;
 }
 
+// src/shallowEquals.ts
+function shallowEquals(a, b) {
+  if (Object.is(a, b)) {
+    return true;
+  }
+  if (a == null || b == null) {
+    return false;
+  }
+  if (typeof a !== "object" || typeof b !== "object") {
+    return false;
+  }
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length) {
+    return false;
+  }
+  for (let i = 0; i < keysA.length; i++) {
+    const key = keysA[i];
+    if (!Object.prototype.hasOwnProperty.call(b, key) || !Object.is(a[key], b[key])) {
+      return false;
+    }
+  }
+  return true;
+}
+
 // src/replaceStringParameters.ts
 function replaceStringParameters(inputString, params) {
   let output = inputString;
@@ -2794,6 +2858,29 @@ var ErrorSchemaBuilder = class {
   }
 };
 
+// src/getChangedFields.ts
+var import_keys = __toESM(require("lodash/keys"), 1);
+var import_pickBy = __toESM(require("lodash/pickBy"), 1);
+var import_isPlainObject2 = __toESM(require("lodash/isPlainObject"), 1);
+var import_get17 = __toESM(require("lodash/get"), 1);
+var import_difference = __toESM(require("lodash/difference"), 1);
+function getChangedFields(a, b) {
+  const aIsPlainObject = (0, import_isPlainObject2.default)(a);
+  const bIsPlainObject = (0, import_isPlainObject2.default)(b);
+  if (a === b || !aIsPlainObject && !bIsPlainObject) {
+    return [];
+  }
+  if (aIsPlainObject && !bIsPlainObject) {
+    return (0, import_keys.default)(a);
+  } else if (!aIsPlainObject && bIsPlainObject) {
+    return (0, import_keys.default)(b);
+  } else {
+    const unequalFields = (0, import_keys.default)((0, import_pickBy.default)(a, (value, key) => !deepEquals(value, (0, import_get17.default)(b, key))));
+    const diffFields = (0, import_difference.default)((0, import_keys.default)(b), (0, import_keys.default)(a));
+    return [...unequalFields, ...diffFields];
+  }
+}
+
 // src/getDateElementProps.ts
 function getDateElementProps(date, time, yearRange = [1900, (/* @__PURE__ */ new Date()).getFullYear() + 2], format = "YMD") {
   const { day, month, year, hour, minute, second } = date;
@@ -2902,10 +2989,10 @@ function getTemplate(name, registry, uiOptions = {}) {
 }
 
 // src/getTestIds.ts
-var import_nanoid = require("nanoid");
-var import_get17 = __toESM(require("lodash/get"), 1);
+var import_get18 = __toESM(require("lodash/get"), 1);
+var import_uniqueId = __toESM(require("lodash/uniqueId"), 1);
 function getTestIds() {
-  if (typeof process === "undefined" || (0, import_get17.default)(process, "env.NODE_ENV") !== "test") {
+  if (typeof process === "undefined" || (0, import_get18.default)(process, "env.NODE_ENV") !== "test") {
     return {};
   }
   const ids = /* @__PURE__ */ new Map();
@@ -2914,7 +3001,7 @@ function getTestIds() {
     {
       get(_obj, prop) {
         if (!ids.has(prop)) {
-          ids.set(prop, (0, import_nanoid.nanoid)());
+          ids.set(prop, (0, import_uniqueId.default)("test-id-"));
         }
         return ids.get(prop);
       }
@@ -2925,7 +3012,7 @@ function getTestIds() {
 // src/getWidget.tsx
 var import_react = require("react");
 var import_react_is = __toESM(require("react-is"), 1);
-var import_get18 = __toESM(require("lodash/get"), 1);
+var import_get19 = __toESM(require("lodash/get"), 1);
 var import_set4 = __toESM(require("lodash/set"), 1);
 var import_jsx_runtime = require("react/jsx-runtime");
 var widgetMap = {
@@ -2981,7 +3068,7 @@ var widgetMap = {
   }
 };
 function mergeWidgetOptions(AWidget) {
-  let MergedWidget = (0, import_get18.default)(AWidget, "MergedWidget");
+  let MergedWidget = (0, import_get19.default)(AWidget, "MergedWidget");
   if (!MergedWidget) {
     const defaultOptions = AWidget.defaultProps && AWidget.defaultProps.options || {};
     MergedWidget = ({ options, ...props }) => {
@@ -2997,7 +3084,7 @@ function getWidget(schema, widget, registeredWidgets = {}) {
     return mergeWidgetOptions(widget);
   }
   if (typeof widget !== "string") {
-    throw new Error(`Unsupported widget definition: ${typeof widget}`);
+    throw new Error(`Unsupported widget definition: ${typeof widget} in schema: ${JSON.stringify(schema)}`);
   }
   if (widget in registeredWidgets) {
     const registeredWidget = registeredWidgets[widget];
@@ -3005,14 +3092,14 @@ function getWidget(schema, widget, registeredWidgets = {}) {
   }
   if (typeof type === "string") {
     if (!(type in widgetMap)) {
-      throw new Error(`No widget for type '${type}'`);
+      throw new Error(`No widget for type '${type}' in schema: ${JSON.stringify(schema)}`);
     }
     if (widget in widgetMap[type]) {
       const registeredWidget = registeredWidgets[widgetMap[type][widget]];
       return getWidget(schema, registeredWidget, registeredWidgets);
     }
   }
-  throw new Error(`No widget '${widget}' for type '${type}'`);
+  throw new Error(`No widget '${widget}' for type '${type}' in schema: ${JSON.stringify(schema)}`);
 }
 
 // src/hashForSchema.ts
@@ -3082,6 +3169,31 @@ function optionId(id, optionIndex) {
 function buttonId(id, btn) {
   return idGenerator(id, btn);
 }
+function optionalControlsId(id, element) {
+  return idGenerator(id, `optional${element}`);
+}
+
+// src/isFormDataAvailable.ts
+var import_isNil3 = __toESM(require("lodash/isNil"), 1);
+var import_isEmpty5 = __toESM(require("lodash/isEmpty"), 1);
+var import_isObject11 = __toESM(require("lodash/isObject"), 1);
+function isFormDataAvailable(formData) {
+  return !(0, import_isNil3.default)(formData) && (!(0, import_isObject11.default)(formData) || Array.isArray(formData) || !(0, import_isEmpty5.default)(formData));
+}
+
+// src/isRootSchema.ts
+var import_isEqual2 = __toESM(require("lodash/isEqual"), 1);
+function isRootSchema(registry, schemaToCompare) {
+  const { rootSchema, schemaUtils } = registry;
+  if ((0, import_isEqual2.default)(schemaToCompare, rootSchema)) {
+    return true;
+  }
+  if (REF_KEY in rootSchema) {
+    const resolvedSchema = schemaUtils.retrieveSchema(rootSchema);
+    return (0, import_isEqual2.default)(schemaToCompare, resolvedSchema);
+  }
+  return false;
+}
 
 // src/labelValue.ts
 function labelValue(label, hideLabel, fallback) {
@@ -3094,14 +3206,14 @@ function localToUTC(dateString) {
 }
 
 // src/lookupFromFormContext.ts
-var import_get19 = __toESM(require("lodash/get"), 1);
+var import_get20 = __toESM(require("lodash/get"), 1);
 var import_has6 = __toESM(require("lodash/has"), 1);
 function lookupFromFormContext(regOrFc, toLookup, fallback) {
   const lookupPath = [LOOKUP_MAP_NAME];
   if ((0, import_has6.default)(regOrFc, FORM_CONTEXT_NAME)) {
     lookupPath.unshift(FORM_CONTEXT_NAME);
   }
-  return (0, import_get19.default)(regOrFc, [...lookupPath, toLookup], fallback);
+  return (0, import_get20.default)(regOrFc, [...lookupPath, toLookup], fallback);
 }
 
 // src/orderProperties.ts
@@ -3182,11 +3294,40 @@ function schemaRequiresTrueValue(schema) {
 }
 
 // src/shouldRender.ts
-function shouldRender(component, nextProps, nextState) {
+function shouldRender(component, nextProps, nextState, updateStrategy = "customDeep") {
+  if (updateStrategy === "always") {
+    return true;
+  }
+  if (updateStrategy === "shallow") {
+    const { props: props2, state: state2 } = component;
+    return !shallowEquals(props2, nextProps) || !shallowEquals(state2, nextState);
+  }
   const { props, state } = component;
   return !deepEquals(props, nextProps) || !deepEquals(state, nextState);
 }
 
+// src/shouldRenderOptionalField.ts
+var import_isObject12 = __toESM(require("lodash/isObject"), 1);
+var import_uniq2 = __toESM(require("lodash/uniq"), 1);
+function getSchemaTypesForXxxOf(schemas) {
+  const allTypes = (0, import_uniq2.default)(
+    schemas.map((s) => (0, import_isObject12.default)(s) ? getSchemaType(s) : void 0).flat().filter((t) => t !== void 0)
+  );
+  return allTypes.length === 1 ? allTypes[0] : allTypes;
+}
+function shouldRenderOptionalField(registry, schema, required, uiSchema) {
+  const { enableOptionalDataFieldForType = [] } = getUiOptions(uiSchema, registry.globalUiOptions);
+  let schemaType;
+  if (ANY_OF_KEY in schema && Array.isArray(schema[ANY_OF_KEY])) {
+    schemaType = getSchemaTypesForXxxOf(schema[ANY_OF_KEY]);
+  } else if (ONE_OF_KEY in schema && Array.isArray(schema[ONE_OF_KEY])) {
+    schemaType = getSchemaTypesForXxxOf(schema[ONE_OF_KEY]);
+  } else {
+    schemaType = getSchemaType(schema);
+  }
+  return !isRootSchema(registry, schema) && !required && !!schemaType && !Array.isArray(schemaType) && !!enableOptionalDataFieldForType.find((val) => val === schemaType);
+}
+
 // src/toDateString.ts
 function toDateString(dateObject, time = true) {
   const { year, month, day, hour = 0, minute = 0, second = 0 } = dateObject;
@@ -3196,7 +3337,7 @@ function toDateString(dateObject, time = true) {
 }
 
 // src/toErrorList.ts
-var import_isPlainObject2 = __toESM(require("lodash/isPlainObject"), 1);
+var import_isPlainObject3 = __toESM(require("lodash/isPlainObject"), 1);
 function toErrorList(errorSchema, fieldPath = []) {
   if (!errorSchema) {
     return [];
@@ -3217,7 +3358,7 @@ function toErrorList(errorSchema, fieldPath = []) {
   return Object.keys(errorSchema).reduce((acc, key) => {
     if (key !== ERRORS_KEY) {
       const childSchema = errorSchema[key];
-      if ((0, import_isPlainObject2.default)(childSchema)) {
+      if ((0, import_isPlainObject3.default)(childSchema)) {
         acc = acc.concat(toErrorList(childSchema, [...fieldPath, key]));
       }
     }
@@ -3244,15 +3385,28 @@ function toErrorSchema(errors) {
   return builder.ErrorSchema;
 }
 
+// src/toFieldPathId.ts
+function toFieldPathId(fieldPath, globalFormOptions, parentPath, isMultiValue) {
+  const basePath = Array.isArray(parentPath) ? parentPath : parentPath?.path;
+  const childPath = fieldPath === "" ? [] : [fieldPath];
+  const path = basePath ? basePath.concat(...childPath) : childPath;
+  const id = [globalFormOptions.idPrefix, ...path].join(globalFormOptions.idSeparator);
+  let name;
+  if (globalFormOptions.nameGenerator && path.length > 0) {
+    name = globalFormOptions.nameGenerator(path, globalFormOptions.idPrefix, isMultiValue);
+  }
+  return { path, [ID_KEY]: id, ...name !== void 0 && { name } };
+}
+
 // src/unwrapErrorHandler.ts
-var import_isPlainObject3 = __toESM(require("lodash/isPlainObject"), 1);
+var import_isPlainObject4 = __toESM(require("lodash/isPlainObject"), 1);
 function unwrapErrorHandler(errorHandler) {
   return Object.keys(errorHandler).reduce((acc, key) => {
     if (key === "addError") {
       return acc;
     } else {
       const childSchema = errorHandler[key];
-      if ((0, import_isPlainObject3.default)(childSchema)) {
+      if ((0, import_isPlainObject4.default)(childSchema)) {
         return {
           ...acc,
           [key]: unwrapErrorHandler(childSchema)
@@ -3263,6 +3417,209 @@ function unwrapErrorHandler(errorHandler) {
   }, {});
 }
 
+// src/useAltDateWidgetProps.tsx
+var import_react2 = require("react");
+var import_jsx_runtime2 = require("react/jsx-runtime");
+function readyForChange(state) {
+  return Object.values(state).every((value) => value !== -1);
+}
+function DateElement(props) {
+  const {
+    className = "form-control",
+    type,
+    range,
+    value,
+    select,
+    rootId,
+    name,
+    disabled,
+    readonly,
+    autofocus,
+    registry,
+    onBlur,
+    onFocus
+  } = props;
+  const id = `${rootId}_${type}`;
+  const { SelectWidget } = registry.widgets;
+  const onChange = (0, import_react2.useCallback)((value2) => select(type, value2), [select, type]);
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+    SelectWidget,
+    {
+      schema: { type: "integer" },
+      id,
+      name,
+      className,
+      options: { enumOptions: dateRangeOptions(range[0], range[1]) },
+      placeholder: type,
+      value,
+      disabled,
+      readonly,
+      autofocus,
+      onChange,
+      onBlur,
+      onFocus,
+      registry,
+      label: "",
+      "aria-describedby": ariaDescribedByIds(rootId)
+    }
+  );
+}
+function useAltDateWidgetProps(props) {
+  const { time = false, disabled = false, readonly = false, options, onChange, value } = props;
+  const [state, setState] = (0, import_react2.useState)(parseDateString(value, time));
+  (0, import_react2.useEffect)(() => {
+    setState(parseDateString(value, time));
+  }, [time, value]);
+  const handleChange = (0, import_react2.useCallback)(
+    (property, value2) => {
+      const nextState = {
+        ...state,
+        [property]: typeof value2 === "undefined" ? -1 : value2
+      };
+      if (readyForChange(nextState)) {
+        onChange(toDateString(nextState, time));
+      } else {
+        setState(nextState);
+      }
+    },
+    [state, onChange, time]
+  );
+  const handleClear = (0, import_react2.useCallback)(
+    (event) => {
+      event.preventDefault();
+      if (disabled || readonly) {
+        return;
+      }
+      onChange(void 0);
+    },
+    [disabled, readonly, onChange]
+  );
+  const handleSetNow = (0, import_react2.useCallback)(
+    (event) => {
+      event.preventDefault();
+      if (disabled || readonly) {
+        return;
+      }
+      const nextState = parseDateString((/* @__PURE__ */ new Date()).toJSON(), time);
+      onChange(toDateString(nextState, time));
+    },
+    [disabled, readonly, time, onChange]
+  );
+  const elements = (0, import_react2.useMemo)(
+    () => getDateElementProps(
+      state,
+      time,
+      options.yearsRange,
+      options.format
+    ),
+    [state, time, options.yearsRange, options.format]
+  );
+  return { elements, handleChange, handleClear, handleSetNow };
+}
+
+// src/useDeepCompareMemo.ts
+var import_react3 = require("react");
+var import_isEqual3 = __toESM(require("lodash/isEqual"), 1);
+function useDeepCompareMemo(newValue) {
+  const valueRef = (0, import_react3.useRef)(newValue);
+  if (!(0, import_isEqual3.default)(newValue, valueRef.current)) {
+    valueRef.current = newValue;
+  }
+  return valueRef.current;
+}
+
+// src/useFileWidgetProps.ts
+var import_react4 = require("react");
+function addNameToDataURL(dataURL, name) {
+  return dataURL.replace(";base64", `;name=${encodeURIComponent(name)};base64`);
+}
+function processFile(file) {
+  const { name, size, type } = file;
+  return new Promise((resolve, reject) => {
+    const reader = new window.FileReader();
+    reader.onerror = reject;
+    reader.onload = (event) => {
+      if (typeof event.target?.result === "string") {
+        resolve({
+          dataURL: addNameToDataURL(event.target.result, name),
+          name,
+          size,
+          type
+        });
+      } else {
+        resolve({
+          dataURL: null,
+          name,
+          size,
+          type
+        });
+      }
+    };
+    reader.readAsDataURL(file);
+  });
+}
+function processFiles(files) {
+  return Promise.all(Array.from(files).map(processFile));
+}
+function extractFileInfo(dataURLs) {
+  return dataURLs.reduce((acc, dataURL) => {
+    if (!dataURL) {
+      return acc;
+    }
+    try {
+      const { blob, name } = dataURItoBlob(dataURL);
+      return [
+        ...acc,
+        {
+          dataURL,
+          name,
+          size: blob.size,
+          type: blob.type
+        }
+      ];
+    } catch {
+      return acc;
+    }
+  }, []);
+}
+function useFileWidgetProps(value, onChange, multiple = false) {
+  const values = (0, import_react4.useMemo)(() => {
+    if (multiple && value) {
+      return Array.isArray(value) ? value : [value];
+    }
+    return [];
+  }, [value, multiple]);
+  const filesInfo = (0, import_react4.useMemo)(
+    () => Array.isArray(value) ? extractFileInfo(value) : extractFileInfo([value || ""]),
+    [value]
+  );
+  const handleChange = (0, import_react4.useCallback)(
+    (files) => {
+      processFiles(files).then((filesInfoEvent) => {
+        const newValue = filesInfoEvent.map((fileInfo) => fileInfo.dataURL || null);
+        if (multiple) {
+          onChange(values.concat(...newValue));
+        } else {
+          onChange(newValue[0]);
+        }
+      });
+    },
+    [values, multiple, onChange]
+  );
+  const handleRemove = (0, import_react4.useCallback)(
+    (index) => {
+      if (multiple) {
+        const newValue = values.filter((_, i) => i !== index);
+        onChange(newValue);
+      } else {
+        onChange(void 0);
+      }
+    },
+    [values, multiple, onChange]
+  );
+  return { filesInfo, handleChange, handleRemove };
+}
+
 // src/utcToLocal.ts
 function utcToLocal(jsonDate) {
   if (!jsonDate) {
@@ -3280,23 +3637,27 @@ function utcToLocal(jsonDate) {
 }
 
 // src/validationDataMerge.ts
-var import_isEmpty5 = __toESM(require("lodash/isEmpty"), 1);
-function validationDataMerge(validationData, additionalErrorSchema) {
+var import_isEmpty6 = __toESM(require("lodash/isEmpty"), 1);
+function validationDataMerge(validationData, additionalErrorSchema, preventDuplicates = false) {
   if (!additionalErrorSchema) {
     return validationData;
   }
   const { errors: oldErrors, errorSchema: oldErrorSchema } = validationData;
   let errors = toErrorList(additionalErrorSchema);
   let errorSchema = additionalErrorSchema;
-  if (!(0, import_isEmpty5.default)(oldErrorSchema)) {
-    errorSchema = mergeObjects(oldErrorSchema, additionalErrorSchema, true);
+  if (!(0, import_isEmpty6.default)(oldErrorSchema)) {
+    errorSchema = mergeObjects(
+      oldErrorSchema,
+      additionalErrorSchema,
+      preventDuplicates ? "preventDuplicates" : true
+    );
     errors = [...oldErrors].concat(errors);
   }
   return { errorSchema, errors };
 }
 
 // src/withIdRefPrefix.ts
-var import_isObject11 = __toESM(require("lodash/isObject"), 1);
+var import_isObject13 = __toESM(require("lodash/isObject"), 1);
 function withIdRefPrefixObject(node) {
   for (const key in node) {
     const realObj = node;
@@ -3319,34 +3680,31 @@ function withIdRefPrefix(schemaNode) {
   if (Array.isArray(schemaNode)) {
     return withIdRefPrefixArray([...schemaNode]);
   }
-  if ((0, import_isObject11.default)(schemaNode)) {
+  if ((0, import_isObject13.default)(schemaNode)) {
     return withIdRefPrefixObject({ ...schemaNode });
   }
   return schemaNode;
 }
 
-// src/getChangedFields.ts
-var import_keys = __toESM(require("lodash/keys"), 1);
-var import_pickBy = __toESM(require("lodash/pickBy"), 1);
-var import_isPlainObject4 = __toESM(require("lodash/isPlainObject"), 1);
-var import_get20 = __toESM(require("lodash/get"), 1);
-var import_difference = __toESM(require("lodash/difference"), 1);
-function getChangedFields(a, b) {
-  const aIsPlainObject = (0, import_isPlainObject4.default)(a);
-  const bIsPlainObject = (0, import_isPlainObject4.default)(b);
-  if (a === b || !aIsPlainObject && !bIsPlainObject) {
-    return [];
+// src/nameGenerators.ts
+var bracketNameGenerator = (path, idPrefix, isMultiValue) => {
+  if (!path || path.length === 0) {
+    return idPrefix;
   }
-  if (aIsPlainObject && !bIsPlainObject) {
-    return (0, import_keys.default)(a);
-  } else if (!aIsPlainObject && bIsPlainObject) {
-    return (0, import_keys.default)(b);
-  } else {
-    const unequalFields = (0, import_keys.default)((0, import_pickBy.default)(a, (value, key) => !deepEquals(value, (0, import_get20.default)(b, key))));
-    const diffFields = (0, import_difference.default)((0, import_keys.default)(b), (0, import_keys.default)(a));
-    return [...unequalFields, ...diffFields];
+  const baseName = path.reduce((acc, pathUnit, index) => {
+    if (index === 0) {
+      return `${idPrefix}[${String(pathUnit)}]`;
+    }
+    return `${acc}[${String(pathUnit)}]`;
+  }, "");
+  return isMultiValue ? `${baseName}[]` : baseName;
+};
+var dotNotationNameGenerator = (path, idPrefix, _isMultiValue) => {
+  if (!path || path.length === 0) {
+    return idPrefix;
   }
-}
+  return `${idPrefix}.${path.map(String).join(".")}`;
+};
 
 // src/enums.ts
 var TranslatableString = /* @__PURE__ */ ((TranslatableString2) => {
@@ -3370,6 +3728,11 @@ var TranslatableString = /* @__PURE__ */ ((TranslatableString2) => {
   TranslatableString2["PreviewLabel"] = "Preview";
   TranslatableString2["DecrementAriaLabel"] = "Decrease value by 1";
   TranslatableString2["IncrementAriaLabel"] = "Increase value by 1";
+  TranslatableString2["OptionalObjectAdd"] = "Add data for optional field";
+  TranslatableString2["OptionalObjectRemove"] = "Remove data for optional field";
+  TranslatableString2["OptionalObjectEmptyMsg"] = "No data for optional field";
+  TranslatableString2["Type"] = "Type";
+  TranslatableString2["Value"] = "Value";
   TranslatableString2["UnknownFieldType"] = "Unknown field type %1";
   TranslatableString2["OptionPrefix"] = "Option %1";
   TranslatableString2["TitleOptionPrefix"] = "%1 option %2";
@@ -3503,4 +3866,4 @@ function schemaParser(rootSchema) {
   parseSchema(validator, recurseList, rootSchema, rootSchema);
   return validator.getSchemaMap();
 }
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.cjs.map