@rjsf/core 6.6.2 → 6.7.0

package/dist/index.cjs

@@ -41,8 +41,8 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/components/Form.tsx
-var import_react27 = require("react");
-var import_utils50 = require("@rjsf/utils");
+var import_react28 = require("react");
+var import_utils52 = require("@rjsf/utils");
 var import_cloneDeep2 = __toESM(require("lodash/cloneDeep"), 1);
 var import_get5 = __toESM(require("lodash/get"), 1);
 var import_isEmpty4 = __toESM(require("lodash/isEmpty"), 1);
@@ -52,7 +52,7 @@ var import_toPath = __toESM(require("lodash/toPath"), 1);
 var import_unset = __toESM(require("lodash/unset"), 1);
 
 // src/getDefaultRegistry.ts
-var import_utils49 = require("@rjsf/utils");
+var import_utils51 = require("@rjsf/utils");
 
 // src/components/fields/ArrayField.tsx
 var import_react = require("react");
@@ -962,10 +962,42 @@ function BooleanField(props) {
 }
 var BooleanField_default = BooleanField;
 
-// src/components/fields/FallbackField.tsx
+// src/components/fields/CyclicSchemaField.tsx
 var import_react3 = require("react");
 var import_utils3 = require("@rjsf/utils");
 var import_jsx_runtime3 = require("react/jsx-runtime");
+function CyclicSchemaField(props) {
+  const [expanded, setExpanded] = (0, import_react3.useState)(false);
+  const { name, registry, schema, uiSchema, fieldPathId } = props;
+  const { globalUiOptions } = registry;
+  const uiOptions = (0, import_utils3.getUiOptions)(uiSchema, globalUiOptions);
+  const CyclicSchemaExpandTemplate2 = (0, import_utils3.getTemplate)(
+    "CyclicSchemaExpandTemplate",
+    registry,
+    uiOptions
+  );
+  if (!expanded) {
+    return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+      CyclicSchemaExpandTemplate2,
+      {
+        registry,
+        schema,
+        uiSchema,
+        name,
+        fieldPathId,
+        onExpand: () => setExpanded(true)
+      }
+    );
+  }
+  const { fields: fields2 } = registry;
+  const { SchemaField: SchemaField2 } = fields2;
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(SchemaField2, { ...props, schema: { ...schema, [import_utils3.RJSF_REF_CYCLE_KEY]: false } });
+}
+
+// src/components/fields/FallbackField.tsx
+var import_react4 = require("react");
+var import_utils4 = require("@rjsf/utils");
+var import_jsx_runtime4 = require("react/jsx-runtime");
 function getFallbackTypeSelectionSchema(title) {
   return {
     type: "string",
@@ -1017,13 +1049,13 @@ function FallbackField(props) {
     errorSchema
   } = props;
   const { translateString, fields: fields2, globalFormOptions } = registry;
-  const [type, setType] = (0, import_react3.useState)(getTypeOfFormData(formData));
-  const uiOptions = (0, import_utils3.getUiOptions)(uiSchema);
-  const typeSelectorInnerFieldPathId = (0, import_utils3.useDeepCompareMemo)(
-    (0, import_utils3.toFieldPathId)("__internal_type_selector", globalFormOptions, fieldPathId)
+  const [type, setType] = (0, import_react4.useState)(getTypeOfFormData(formData));
+  const uiOptions = (0, import_utils4.getUiOptions)(uiSchema);
+  const typeSelectorInnerFieldPathId = (0, import_utils4.useDeepCompareMemo)(
+    (0, import_utils4.toFieldPathId)("__internal_type_selector", globalFormOptions, fieldPathId)
   );
-  const schemaTitle = translateString(import_utils3.TranslatableString.Type);
-  const typesOptionSchema = (0, import_react3.useMemo)(() => getFallbackTypeSelectionSchema(schemaTitle), [schemaTitle]);
+  const schemaTitle = translateString(import_utils4.TranslatableString.Type);
+  const typesOptionSchema = (0, import_react4.useMemo)(() => getFallbackTypeSelectionSchema(schemaTitle), [schemaTitle]);
   const onTypeChange = (newType) => {
     if (newType != null) {
       setType(newType);
@@ -1031,26 +1063,26 @@ function FallbackField(props) {
     }
   };
   if (!globalFormOptions.useFallbackUiForUnsupportedType) {
-    const { reason = translateString(import_utils3.TranslatableString.UnknownFieldType, [String(schema.type)]) } = props;
-    const UnsupportedFieldTemplate = (0, import_utils3.getTemplate)(
+    const { reason = translateString(import_utils4.TranslatableString.UnknownFieldType, [String(schema.type)]) } = props;
+    const UnsupportedFieldTemplate = (0, import_utils4.getTemplate)(
       "UnsupportedFieldTemplate",
       registry,
       uiOptions
     );
-    return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(UnsupportedFieldTemplate, { schema, fieldPathId, reason, registry });
+    return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(UnsupportedFieldTemplate, { schema, fieldPathId, reason, registry });
   }
-  const FallbackFieldTemplate2 = (0, import_utils3.getTemplate)(
+  const FallbackFieldTemplate2 = (0, import_utils4.getTemplate)(
     "FallbackFieldTemplate",
     registry,
     uiOptions
   );
   const { SchemaField: SchemaField2 } = fields2;
-  return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
     FallbackFieldTemplate2,
     {
       schema,
       registry,
-      typeSelector: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+      typeSelector: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
         SchemaField2,
         {
           fieldPathId: typeSelectorInnerFieldPathId,
@@ -1066,15 +1098,15 @@ function FallbackField(props) {
           readonly,
           required
         },
-        formData ? (0, import_utils3.hashObject)(formData) : "__empty__"
+        formData ? (0, import_utils4.hashObject)(formData) : "__empty__"
       ),
-      schemaField: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+      schemaField: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
         SchemaField2,
         {
           ...props,
           schema: {
             type,
-            title: translateString(import_utils3.TranslatableString.Value),
+            title: translateString(import_utils4.TranslatableString.Value),
             ...type === "object" && { additionalProperties: true }
           }
         }
@@ -1084,7 +1116,7 @@ function FallbackField(props) {
 }
 
 // src/components/fields/LayoutGridField.tsx
-var import_utils4 = require("@rjsf/utils");
+var import_utils5 = require("@rjsf/utils");
 var import_each = __toESM(require("lodash/each"), 1);
 var import_flatten = __toESM(require("lodash/flatten"), 1);
 var import_get = __toESM(require("lodash/get"), 1);
@@ -1100,8 +1132,8 @@ var import_isString = __toESM(require("lodash/isString"), 1);
 var import_isUndefined = __toESM(require("lodash/isUndefined"), 1);
 var import_last = __toESM(require("lodash/last"), 1);
 var import_set2 = __toESM(require("lodash/set"), 1);
-var import_jsx_runtime4 = require("react/jsx-runtime");
-var import_react4 = require("react");
+var import_jsx_runtime5 = require("react/jsx-runtime");
+var import_react5 = require("react");
 var LOOKUP_REGEX = /^\$lookup=(.+)/;
 var LAYOUT_GRID_UI_OPTION = "layoutGrid";
 var LAYOUT_GRID_OPTION = `ui:${LAYOUT_GRID_UI_OPTION}`;
@@ -1111,25 +1143,25 @@ function getNonNullishValue(value, fallback) {
 function isNumericIndex(str) {
   return /^\d+?$/.test(str);
 }
-var LAYOUT_GRID_FIELD_TEST_IDS = (0, import_utils4.getTestIds)();
+var LAYOUT_GRID_FIELD_TEST_IDS = (0, import_utils5.getTestIds)();
 function computeFieldUiSchema(field, uiProps, uiSchema, schemaReadonly, forceReadonly) {
-  const globalUiOptions = (0, import_get.default)(uiSchema, [import_utils4.UI_GLOBAL_OPTIONS_KEY], {});
+  const globalUiOptions = (0, import_get.default)(uiSchema, [import_utils5.UI_GLOBAL_OPTIONS_KEY], {});
   const localUiSchema = (0, import_get.default)(uiSchema, field);
-  const localUiOptions = { ...(0, import_get.default)(localUiSchema, [import_utils4.UI_OPTIONS_KEY], {}), ...uiProps, ...globalUiOptions };
+  const localUiOptions = { ...(0, import_get.default)(localUiSchema, [import_utils5.UI_OPTIONS_KEY], {}), ...uiProps, ...globalUiOptions };
   const fieldUiSchema = { ...localUiSchema };
   if (!(0, import_isEmpty.default)(localUiOptions)) {
-    (0, import_set2.default)(fieldUiSchema, [import_utils4.UI_OPTIONS_KEY], localUiOptions);
+    (0, import_set2.default)(fieldUiSchema, [import_utils5.UI_OPTIONS_KEY], localUiOptions);
   }
   if (!(0, import_isEmpty.default)(globalUiOptions)) {
-    (0, import_set2.default)(fieldUiSchema, [import_utils4.UI_GLOBAL_OPTIONS_KEY], globalUiOptions);
+    (0, import_set2.default)(fieldUiSchema, [import_utils5.UI_GLOBAL_OPTIONS_KEY], globalUiOptions);
   }
-  let { readonly: uiReadonly } = (0, import_utils4.getUiOptions)(fieldUiSchema);
+  let { readonly: uiReadonly } = (0, import_utils5.getUiOptions)(fieldUiSchema);
   if (forceReadonly === true || (0, import_isUndefined.default)(uiReadonly) && schemaReadonly === true) {
     uiReadonly = true;
-    if ((0, import_has.default)(localUiOptions, import_utils4.READONLY_KEY)) {
-      (0, import_set2.default)(fieldUiSchema, [import_utils4.UI_OPTIONS_KEY, import_utils4.READONLY_KEY], true);
+    if ((0, import_has.default)(localUiOptions, import_utils5.READONLY_KEY)) {
+      (0, import_set2.default)(fieldUiSchema, [import_utils5.UI_OPTIONS_KEY, import_utils5.READONLY_KEY], true);
     } else {
-      (0, import_set2.default)(fieldUiSchema, `ui:${import_utils4.READONLY_KEY}`, true);
+      (0, import_set2.default)(fieldUiSchema, `ui:${import_utils5.READONLY_KEY}`, true);
     }
   }
   return { fieldUiSchema, uiReadonly };
@@ -1156,7 +1188,7 @@ function findChildrenAndProps(layoutGridSchema, schemaKey, registry) {
     children = elements;
     if (toMapClassNames) {
       const classes = toMapClassNames.split(" ");
-      const className = classes.map((ele) => (0, import_utils4.lookupFromFormContext)(registry, ele, ele)).join(" ");
+      const className = classes.map((ele) => (0, import_utils5.lookupFromFormContext)(registry, ele, ele)).join(" ");
       gridProps = { ...otherProps, className };
     } else {
       gridProps = otherProps;
@@ -1170,9 +1202,9 @@ function findChildrenAndProps(layoutGridSchema, schemaKey, registry) {
 function computeArraySchemasIfPresent(schema, fieldPathId, potentialIndex) {
   let rawSchema;
   let resultPathId = fieldPathId;
-  if (isNumericIndex(potentialIndex) && schema && schema?.type === "array" && (0, import_has.default)(schema, import_utils4.ITEMS_KEY)) {
+  if (isNumericIndex(potentialIndex) && schema && schema?.type === "array" && (0, import_has.default)(schema, import_utils5.ITEMS_KEY)) {
     const index = Number(potentialIndex);
-    const items = schema[import_utils4.ITEMS_KEY];
+    const items = schema[import_utils5.ITEMS_KEY];
     if (Array.isArray(items)) {
       if (index > items.length) {
         rawSchema = (0, import_last.default)(items);
@@ -1183,7 +1215,7 @@ function computeArraySchemasIfPresent(schema, fieldPathId, potentialIndex) {
       rawSchema = items;
     }
     resultPathId = {
-      [import_utils4.ID_KEY]: fieldPathId[import_utils4.ID_KEY],
+      [import_utils5.ID_KEY]: fieldPathId[import_utils5.ID_KEY],
       path: [...fieldPathId.path.slice(0, fieldPathId.path.length - 1), index]
     };
   }
@@ -1199,13 +1231,13 @@ function getSchemaDetailsForField(registry, dottedPath, initialSchema, formData,
   let innerData = formData;
   let isReadonly = schema.readOnly;
   parts.forEach((part) => {
-    fieldPathId = (0, import_utils4.toFieldPathId)(part, globalFormOptions, fieldPathId);
-    if ((0, import_has.default)(schema, import_utils4.PROPERTIES_KEY)) {
-      rawSchema = (0, import_get.default)(schema, [import_utils4.PROPERTIES_KEY, part], {});
-    } else if (schema && ((0, import_has.default)(schema, import_utils4.ONE_OF_KEY) || (0, import_has.default)(schema, import_utils4.ANY_OF_KEY))) {
-      const xxx = (0, import_has.default)(schema, import_utils4.ONE_OF_KEY) ? import_utils4.ONE_OF_KEY : import_utils4.ANY_OF_KEY;
+    fieldPathId = (0, import_utils5.toFieldPathId)(part, globalFormOptions, fieldPathId);
+    if ((0, import_has.default)(schema, import_utils5.PROPERTIES_KEY)) {
+      rawSchema = (0, import_get.default)(schema, [import_utils5.PROPERTIES_KEY, part], {});
+    } else if (schema && ((0, import_has.default)(schema, import_utils5.ONE_OF_KEY) || (0, import_has.default)(schema, import_utils5.ANY_OF_KEY))) {
+      const xxx = (0, import_has.default)(schema, import_utils5.ONE_OF_KEY) ? import_utils5.ONE_OF_KEY : import_utils5.ANY_OF_KEY;
       const selectedSchema = schemaUtils.findSelectedOptionInXxxOf(schema, part, xxx, innerData);
-      rawSchema = (0, import_get.default)(selectedSchema, [import_utils4.PROPERTIES_KEY, part], {});
+      rawSchema = (0, import_get.default)(selectedSchema, [import_utils5.PROPERTIES_KEY, part], {});
     } else {
       const result = computeArraySchemasIfPresent(schema, fieldPathId, part);
       rawSchema = result.rawSchema ?? {};
@@ -1221,24 +1253,24 @@ function getSchemaDetailsForField(registry, dottedPath, initialSchema, formData,
     schema = void 0;
   }
   if (schema && leafPath) {
-    if (schema && ((0, import_has.default)(schema, import_utils4.ONE_OF_KEY) || (0, import_has.default)(schema, import_utils4.ANY_OF_KEY))) {
-      const xxx = (0, import_has.default)(schema, import_utils4.ONE_OF_KEY) ? import_utils4.ONE_OF_KEY : import_utils4.ANY_OF_KEY;
+    if (schema && ((0, import_has.default)(schema, import_utils5.ONE_OF_KEY) || (0, import_has.default)(schema, import_utils5.ANY_OF_KEY))) {
+      const xxx = (0, import_has.default)(schema, import_utils5.ONE_OF_KEY) ? import_utils5.ONE_OF_KEY : import_utils5.ANY_OF_KEY;
       schema = schemaUtils.findSelectedOptionInXxxOf(schema, leafPath, xxx, innerData);
     }
-    fieldPathId = (0, import_utils4.toFieldPathId)(leafPath, globalFormOptions, fieldPathId);
+    fieldPathId = (0, import_utils5.toFieldPathId)(leafPath, globalFormOptions, fieldPathId);
     isRequired2 = schema !== void 0 && Array.isArray(schema.required) && (0, import_includes.default)(schema.required, leafPath);
     const result = computeArraySchemasIfPresent(schema, fieldPathId, leafPath);
     if (result.rawSchema) {
       schema = result.rawSchema;
       fieldPathId = result.fieldPathId;
     } else {
-      schema = (0, import_get.default)(schema, [import_utils4.PROPERTIES_KEY, leafPath]);
+      schema = (0, import_get.default)(schema, [import_utils5.PROPERTIES_KEY, leafPath]);
       schema = schema ? schemaUtils.retrieveSchema(schema) : schema;
     }
     isReadonly = getNonNullishValue(schema?.readOnly, isReadonly);
-    if (schema && ((0, import_has.default)(schema, import_utils4.ONE_OF_KEY) || (0, import_has.default)(schema, import_utils4.ANY_OF_KEY))) {
-      const xxx = (0, import_has.default)(schema, import_utils4.ONE_OF_KEY) ? import_utils4.ONE_OF_KEY : import_utils4.ANY_OF_KEY;
-      const discriminator = (0, import_utils4.getDiscriminatorFieldFromSchema)(schema);
+    if (schema && ((0, import_has.default)(schema, import_utils5.ONE_OF_KEY) || (0, import_has.default)(schema, import_utils5.ANY_OF_KEY))) {
+      const xxx = (0, import_has.default)(schema, import_utils5.ONE_OF_KEY) ? import_utils5.ONE_OF_KEY : import_utils5.ANY_OF_KEY;
+      const discriminator = (0, import_utils5.getDiscriminatorFieldFromSchema)(schema);
       optionsInfo = { options: schema[xxx], hasDiscriminator: !!discriminator };
     }
   }
@@ -1247,7 +1279,7 @@ function getSchemaDetailsForField(registry, dottedPath, initialSchema, formData,
 function getCustomRenderComponent(render, registry) {
   let customRenderer = render;
   if ((0, import_isString.default)(customRenderer)) {
-    customRenderer = (0, import_utils4.lookupFromFormContext)(registry, customRenderer);
+    customRenderer = (0, import_utils5.lookupFromFormContext)(registry, customRenderer);
   }
   if ((0, import_isFunction.default)(customRenderer)) {
     return customRenderer;
@@ -1271,14 +1303,14 @@ function computeUIComponentPropsFromGridSchema(registry, gridSchema) {
           const match = LOOKUP_REGEX.exec(prop);
           if (Array.isArray(match) && match.length > 1) {
             const lookupName = match[1];
-            uiProps[key] = (0, import_utils4.lookupFromFormContext)(registry, lookupName, lookupName);
+            uiProps[key] = (0, import_utils5.lookupFromFormContext)(registry, lookupName, lookupName);
           }
         }
       });
     }
     UIComponent = getCustomRenderComponent(render, registry);
     if (!innerName && UIComponent) {
-      rendered = /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(UIComponent, { ...innerProps, "data-testid": LAYOUT_GRID_FIELD_TEST_IDS.uiComponent });
+      rendered = /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(UIComponent, { ...innerProps, "data-testid": LAYOUT_GRID_FIELD_TEST_IDS.uiComponent });
     }
   }
   return { name, UIComponent, uiProps, rendered };
@@ -1288,11 +1320,11 @@ function LayoutGridFieldChildren(props) {
   const { registry, schema: rawSchema, formData } = layoutGridFieldProps;
   const { schemaUtils } = registry;
   const schema = schemaUtils.retrieveSchema(rawSchema, formData);
-  return childrenLayoutGridSchemaId.map((layoutGridSchema) => /* @__PURE__ */ (0, import_react4.createElement)(
+  return childrenLayoutGridSchemaId.map((layoutGridSchema) => /* @__PURE__ */ (0, import_react5.createElement)(
     LayoutGridField,
     {
       ...layoutGridFieldProps,
-      key: `layoutGrid-${(0, import_utils4.hashObject)(layoutGridSchema)}`,
+      key: `layoutGrid-${(0, import_utils5.hashObject)(layoutGridSchema)}`,
       schema,
       layoutGridSchema
     }
@@ -1305,7 +1337,7 @@ function LayoutGridCondition(props) {
   const { operator, field = "", value } = gridProps;
   const fieldData = (0, import_get.default)(formData, field, null);
   if (conditionMatches(operator, fieldData, value)) {
-    return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(LayoutGridFieldChildren, { ...layoutGridFieldProps, childrenLayoutGridSchemaId: children });
+    return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(LayoutGridFieldChildren, { ...layoutGridFieldProps, childrenLayoutGridSchemaId: children });
   }
   return null;
 }
@@ -1313,34 +1345,34 @@ function LayoutGridCol(props) {
   const { layoutGridSchema, ...layoutGridFieldProps } = props;
   const { registry, uiSchema } = layoutGridFieldProps;
   const { children, gridProps } = findChildrenAndProps(layoutGridSchema, "ui:col" /* COLUMN */, registry);
-  const uiOptions = (0, import_utils4.getUiOptions)(uiSchema);
-  const GridTemplate2 = (0, import_utils4.getTemplate)("GridTemplate", registry, uiOptions);
-  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(GridTemplate2, { column: true, "data-testid": LAYOUT_GRID_FIELD_TEST_IDS.col, ...gridProps, children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(LayoutGridFieldChildren, { ...layoutGridFieldProps, childrenLayoutGridSchemaId: children }) });
+  const uiOptions = (0, import_utils5.getUiOptions)(uiSchema);
+  const GridTemplate2 = (0, import_utils5.getTemplate)("GridTemplate", registry, uiOptions);
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(GridTemplate2, { column: true, "data-testid": LAYOUT_GRID_FIELD_TEST_IDS.col, ...gridProps, children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(LayoutGridFieldChildren, { ...layoutGridFieldProps, childrenLayoutGridSchemaId: children }) });
 }
 function LayoutGridColumns(props) {
   const { layoutGridSchema, ...layoutGridFieldProps } = props;
   const { registry, uiSchema } = layoutGridFieldProps;
   const { children, gridProps } = findChildrenAndProps(layoutGridSchema, "ui:columns" /* COLUMNS */, registry);
-  const uiOptions = (0, import_utils4.getUiOptions)(uiSchema);
-  const GridTemplate2 = (0, import_utils4.getTemplate)("GridTemplate", registry, uiOptions);
-  return children.map((child) => /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+  const uiOptions = (0, import_utils5.getUiOptions)(uiSchema);
+  const GridTemplate2 = (0, import_utils5.getTemplate)("GridTemplate", registry, uiOptions);
+  return children.map((child) => /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
     GridTemplate2,
     {
       column: true,
       "data-testid": LAYOUT_GRID_FIELD_TEST_IDS.col,
       ...gridProps,
-      children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(LayoutGridFieldChildren, { ...layoutGridFieldProps, childrenLayoutGridSchemaId: [child] })
+      children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(LayoutGridFieldChildren, { ...layoutGridFieldProps, childrenLayoutGridSchemaId: [child] })
     },
-    `column-${(0, import_utils4.hashObject)(child)}`
+    `column-${(0, import_utils5.hashObject)(child)}`
   ));
 }
 function LayoutGridRow(props) {
   const { layoutGridSchema, ...layoutGridFieldProps } = props;
   const { registry, uiSchema } = layoutGridFieldProps;
   const { children, gridProps } = findChildrenAndProps(layoutGridSchema, "ui:row" /* ROW */, registry);
-  const uiOptions = (0, import_utils4.getUiOptions)(uiSchema);
-  const GridTemplate2 = (0, import_utils4.getTemplate)("GridTemplate", registry, uiOptions);
-  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(GridTemplate2, { ...gridProps, "data-testid": LAYOUT_GRID_FIELD_TEST_IDS.row, children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(LayoutGridFieldChildren, { ...layoutGridFieldProps, childrenLayoutGridSchemaId: children }) });
+  const uiOptions = (0, import_utils5.getUiOptions)(uiSchema);
+  const GridTemplate2 = (0, import_utils5.getTemplate)("GridTemplate", registry, uiOptions);
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(GridTemplate2, { ...gridProps, "data-testid": LAYOUT_GRID_FIELD_TEST_IDS.row, children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(LayoutGridFieldChildren, { ...layoutGridFieldProps, childrenLayoutGridSchemaId: children }) });
 }
 function LayoutGridFieldComponent(props) {
   const {
@@ -1370,14 +1402,14 @@ function LayoutGridFieldComponent(props) {
     optionsInfo,
     fieldPathId: fieldIdSchema
   } = getSchemaDetailsForField(registry, name, initialSchema, formData, fieldPathId);
-  const memoFieldPathId = (0, import_utils4.useDeepCompareMemo)(fieldIdSchema);
+  const memoFieldPathId = (0, import_utils5.useDeepCompareMemo)(fieldIdSchema);
   if (uiComponentProps.rendered) {
     return uiComponentProps.rendered;
   }
   if (schema) {
     const Field = optionsInfo?.hasDiscriminator ? LayoutMultiSchemaField2 : SchemaField2;
     const { fieldUiSchema, uiReadonly } = computeFieldUiSchema(name, uiProps, uiSchema, isReadonly, readonly);
-    return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+    return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
       Field,
       {
         "data-testid": optionsInfo?.hasDiscriminator ? LAYOUT_GRID_FIELD_TEST_IDS.layoutMultiSchemaField : LAYOUT_GRID_FIELD_TEST_IDS.field,
@@ -1399,7 +1431,7 @@ function LayoutGridFieldComponent(props) {
     );
   }
   if (UIComponent) {
-    return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+    return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
       UIComponent,
       {
         "data-testid": LAYOUT_GRID_FIELD_TEST_IDS.uiComponent,
@@ -1424,49 +1456,49 @@ function LayoutGridFieldComponent(props) {
 function LayoutGridField(props) {
   const { uiSchema } = props;
   let { layoutGridSchema } = props;
-  const uiOptions = (0, import_utils4.getUiOptions)(uiSchema);
+  const uiOptions = (0, import_utils5.getUiOptions)(uiSchema);
   if (!layoutGridSchema && LAYOUT_GRID_UI_OPTION in uiOptions && (0, import_isObject3.default)(uiOptions[LAYOUT_GRID_UI_OPTION])) {
     layoutGridSchema = uiOptions[LAYOUT_GRID_UI_OPTION];
   }
   if ((0, import_isObject3.default)(layoutGridSchema)) {
     if ("ui:row" /* ROW */ in layoutGridSchema) {
-      return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(LayoutGridRow, { ...props, layoutGridSchema });
+      return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(LayoutGridRow, { ...props, layoutGridSchema });
     }
     if ("ui:col" /* COLUMN */ in layoutGridSchema) {
-      return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(LayoutGridCol, { ...props, layoutGridSchema });
+      return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(LayoutGridCol, { ...props, layoutGridSchema });
     }
     if ("ui:columns" /* COLUMNS */ in layoutGridSchema) {
-      return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(LayoutGridColumns, { ...props, layoutGridSchema });
+      return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(LayoutGridColumns, { ...props, layoutGridSchema });
     }
     if ("ui:condition" /* CONDITION */ in layoutGridSchema) {
-      return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(LayoutGridCondition, { ...props, layoutGridSchema });
+      return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(LayoutGridCondition, { ...props, layoutGridSchema });
     }
   }
-  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(LayoutGridFieldComponent, { ...props, gridSchema: layoutGridSchema });
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(LayoutGridFieldComponent, { ...props, gridSchema: layoutGridSchema });
 }
 LayoutGridField.TEST_IDS = LAYOUT_GRID_FIELD_TEST_IDS;
 
 // src/components/fields/LayoutHeaderField.tsx
-var import_utils5 = require("@rjsf/utils");
-var import_jsx_runtime5 = require("react/jsx-runtime");
+var import_utils6 = require("@rjsf/utils");
+var import_jsx_runtime6 = require("react/jsx-runtime");
 function LayoutHeaderField(props) {
   const { fieldPathId, title, schema, uiSchema, required, registry, name } = props;
-  const options = (0, import_utils5.getUiOptions)(uiSchema, registry.globalUiOptions);
+  const options = (0, import_utils6.getUiOptions)(uiSchema, registry.globalUiOptions);
   const { title: uiTitle } = options;
   const { title: schemaTitle } = schema;
   const fieldTitle = uiTitle || title || schemaTitle || name;
   if (!fieldTitle) {
     return null;
   }
-  const TitleFieldTemplate = (0, import_utils5.getTemplate)(
+  const TitleFieldTemplate = (0, import_utils6.getTemplate)(
     "TitleFieldTemplate",
     registry,
     options
   );
-  return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+  return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
     TitleFieldTemplate,
     {
-      id: (0, import_utils5.titleId)(fieldPathId),
+      id: (0, import_utils6.titleId)(fieldPathId),
       title: fieldTitle,
       required,
       schema,
@@ -1477,33 +1509,33 @@ function LayoutHeaderField(props) {
 }
 
 // src/components/fields/LayoutMultiSchemaField.tsx
-var import_react5 = require("react");
-var import_utils6 = require("@rjsf/utils");
+var import_react6 = require("react");
+var import_utils7 = require("@rjsf/utils");
 var import_get2 = __toESM(require("lodash/get"), 1);
 var import_has2 = __toESM(require("lodash/has"), 1);
 var import_isEmpty2 = __toESM(require("lodash/isEmpty"), 1);
 var import_noop = __toESM(require("lodash/noop"), 1);
 var import_omit = __toESM(require("lodash/omit"), 1);
 var import_set3 = __toESM(require("lodash/set"), 1);
-var import_jsx_runtime6 = require("react/jsx-runtime");
+var import_jsx_runtime7 = require("react/jsx-runtime");
 function getSelectedOption(options, selectorField, value) {
   const defaultValue = "!@#!@$@#$!@$#";
   const schemaOptions = options.map(({ schema }) => schema);
   return schemaOptions.find((option) => {
-    const selector = (0, import_get2.default)(option, [import_utils6.PROPERTIES_KEY, selectorField]);
-    const result = (0, import_get2.default)(selector, import_utils6.DEFAULT_KEY, (0, import_get2.default)(selector, import_utils6.CONST_KEY, defaultValue));
+    const selector = (0, import_get2.default)(option, [import_utils7.PROPERTIES_KEY, selectorField]);
+    const result = (0, import_get2.default)(selector, import_utils7.DEFAULT_KEY, (0, import_get2.default)(selector, import_utils7.CONST_KEY, defaultValue));
     return result === value;
   });
 }
 function computeEnumOptions(schema, options, schemaUtils, uiSchema, formData) {
   const realOptions = options.map((opt) => schemaUtils.retrieveSchema(opt, formData));
   let tempSchema = schema;
-  if ((0, import_has2.default)(schema, import_utils6.ONE_OF_KEY)) {
-    tempSchema = { ...schema, [import_utils6.ONE_OF_KEY]: realOptions };
-  } else if ((0, import_has2.default)(schema, import_utils6.ANY_OF_KEY)) {
-    tempSchema = { ...schema, [import_utils6.ANY_OF_KEY]: realOptions };
+  if ((0, import_has2.default)(schema, import_utils7.ONE_OF_KEY)) {
+    tempSchema = { ...schema, [import_utils7.ONE_OF_KEY]: realOptions };
+  } else if ((0, import_has2.default)(schema, import_utils7.ANY_OF_KEY)) {
+    tempSchema = { ...schema, [import_utils7.ANY_OF_KEY]: realOptions };
   }
-  const enumOptions = (0, import_utils6.optionsList)(tempSchema, uiSchema);
+  const enumOptions = (0, import_utils7.optionsList)(tempSchema, uiSchema);
   if (!enumOptions) {
     throw new Error(`No enumOptions were computed from the schema ${JSON.stringify(tempSchema)}`);
   }
@@ -1530,16 +1562,16 @@ function LayoutMultiSchemaField(props) {
     hideError = false
   } = props;
   const { widgets: widgets2, schemaUtils, globalUiOptions } = registry;
-  const [enumOptions, setEnumOptions] = (0, import_react5.useState)(computeEnumOptions(schema, options, schemaUtils, uiSchema, formData));
-  const id = (0, import_get2.default)(fieldPathId, import_utils6.ID_KEY);
-  const discriminator = (0, import_utils6.getDiscriminatorFieldFromSchema)(schema);
-  const FieldErrorTemplate2 = (0, import_utils6.getTemplate)("FieldErrorTemplate", registry, options);
-  const FieldTemplate2 = (0, import_utils6.getTemplate)("FieldTemplate", registry, options);
-  const schemaHash = (0, import_utils6.hashObject)(schema);
-  const optionsHash = (0, import_utils6.hashObject)(options);
-  const uiSchemaHash = uiSchema ? (0, import_utils6.hashObject)(uiSchema) : "";
-  const formDataHash = formData ? (0, import_utils6.hashObject)(formData) : "";
-  (0, import_react5.useEffect)(() => {
+  const [enumOptions, setEnumOptions] = (0, import_react6.useState)(computeEnumOptions(schema, options, schemaUtils, uiSchema, formData));
+  const id = (0, import_get2.default)(fieldPathId, import_utils7.ID_KEY);
+  const discriminator = (0, import_utils7.getDiscriminatorFieldFromSchema)(schema);
+  const FieldErrorTemplate2 = (0, import_utils7.getTemplate)("FieldErrorTemplate", registry, options);
+  const FieldTemplate2 = (0, import_utils7.getTemplate)("FieldTemplate", registry, options);
+  const schemaHash = (0, import_utils7.hashObject)(schema);
+  const optionsHash = (0, import_utils7.hashObject)(options);
+  const uiSchemaHash = uiSchema ? (0, import_utils7.hashObject)(uiSchema) : "";
+  const formDataHash = formData ? (0, import_utils7.hashObject)(formData) : "";
+  (0, import_react6.useEffect)(() => {
     setEnumOptions(computeEnumOptions(schema, options, schemaUtils, uiSchema, formData));
   }, [schemaHash, optionsHash, schemaUtils, uiSchemaHash, formDataHash]);
   const {
@@ -1549,18 +1581,18 @@ function LayoutMultiSchemaField(props) {
     optionsSchemaSelector: selectorField = discriminator,
     hideError: uiSchemaHideError,
     ...uiOptions
-  } = (0, import_utils6.getUiOptions)(uiSchema);
+  } = (0, import_utils7.getUiOptions)(uiSchema);
   if (!selectorField) {
     throw new Error("No selector field provided for the LayoutMultiSchemaField");
   }
   const selectedOption = (0, import_get2.default)(formData, selectorField);
-  let optionSchema = (0, import_get2.default)(enumOptions[0]?.schema, [import_utils6.PROPERTIES_KEY, selectorField], {});
+  let optionSchema = (0, import_get2.default)(enumOptions[0]?.schema, [import_utils7.PROPERTIES_KEY, selectorField], {});
   const option = getSelectedOption(enumOptions, selectorField, selectedOption);
   optionSchema = optionSchema?.type ? optionSchema : { ...optionSchema, type: option?.type || baseType };
-  const Widget = (0, import_utils6.getWidget)(optionSchema, widget, widgets2);
+  const Widget = (0, import_utils7.getWidget)(optionSchema, widget, widgets2);
   const hideFieldError = uiSchemaHideError === void 0 ? hideError : Boolean(uiSchemaHideError);
-  const rawErrors = (0, import_get2.default)(errorSchema, [import_utils6.ERRORS_KEY], []);
-  const fieldErrorSchema = (0, import_omit.default)(errorSchema, [import_utils6.ERRORS_KEY]);
+  const rawErrors = (0, import_get2.default)(errorSchema, [import_utils7.ERRORS_KEY], []);
+  const fieldErrorSchema = (0, import_omit.default)(errorSchema, [import_utils7.ERRORS_KEY]);
   const displayLabel = schemaUtils.getDisplayLabel(schema, uiSchema, globalUiOptions);
   const onOptionChange = (opt) => {
     if (disabled || readonly) {
@@ -1578,8 +1610,8 @@ function LayoutMultiSchemaField(props) {
     onChange(newFormData, fieldPathId.path, void 0, id);
   };
   const widgetOptions = { enumOptions, ...uiOptions };
-  const errors = !hideFieldError && rawErrors.length > 0 ? /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(FieldErrorTemplate2, { fieldPathId, schema, errors: rawErrors, registry }) : void 0;
-  return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
+  const errors = !hideFieldError && rawErrors.length > 0 ? /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(FieldErrorTemplate2, { fieldPathId, schema, errors: rawErrors, registry }) : void 0;
+  return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
     FieldTemplate2,
     {
       fieldPathId,
@@ -1597,7 +1629,7 @@ function LayoutMultiSchemaField(props) {
       onKeyRename: import_noop.default,
       onKeyRenameBlur: import_noop.default,
       onRemoveProperty: import_noop.default,
-      children: /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
+      children: /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
         Widget,
         {
           id,
@@ -1629,230 +1661,192 @@ function LayoutMultiSchemaField(props) {
 }
 
 // src/components/fields/MultiSchemaField.tsx
-var import_react6 = require("react");
-var import_utils7 = require("@rjsf/utils");
+var import_react7 = require("react");
+var import_utils8 = require("@rjsf/utils");
 var import_get3 = __toESM(require("lodash/get"), 1);
 var import_isEmpty3 = __toESM(require("lodash/isEmpty"), 1);
 var import_omit2 = __toESM(require("lodash/omit"), 1);
-var import_jsx_runtime7 = require("react/jsx-runtime");
-var AnyOfField = class extends import_react6.Component {
-  /** Flag to skip the formData-change-driven option recalculation when the user just selected an option.
-   * Set to true in the setState callback of onOptionChange (after onChange is called), consumed and reset in
-   * componentDidUpdate. This prevents the matching-option recalculation from overriding a user's explicit choice
-   * when getDefaultFormState populates undefined properties that make deepEquals see a false formData change.
-   */
-  skipNextOptionRecalculation = false;
-  /** Constructs an `AnyOfField` with the given `props` to initialize the initially selected option in state
-   *
-   * @param props - The `FieldProps` for this template
-   */
-  constructor(props) {
-    super(props);
-    const {
-      formData,
-      options,
-      registry: { schemaUtils }
-    } = this.props;
-    const retrievedOptions = options.map((opt) => schemaUtils.retrieveSchema(opt, formData));
-    this.state = {
-      retrievedOptions,
-      selectedOption: this.getMatchingOption(0, formData, retrievedOptions)
-    };
-  }
-  /** React lifecycle method that is called when the props and/or state for this component is updated. It recomputes the
-   * currently selected option based on the overall `formData`
-   *
-   * @param prevProps - The previous `FieldProps` for this template
-   * @param prevState - The previous `AnyOfFieldState` for this template
-   */
-  componentDidUpdate(prevProps, prevState) {
-    const { formData, options, fieldPathId } = this.props;
-    const { selectedOption } = this.state;
-    let newState = this.state;
-    if (!(0, import_utils7.deepEquals)(prevProps.options, options)) {
-      const {
-        registry: { schemaUtils }
-      } = this.props;
-      const retrievedOptions = options.map((opt) => schemaUtils.retrieveSchema(opt, formData));
-      newState = { selectedOption, retrievedOptions };
+var import_jsx_runtime8 = require("react/jsx-runtime");
+function AnyOfField(props) {
+  const {
+    name,
+    disabled = false,
+    errorSchema = {},
+    formData,
+    fieldPathId,
+    onBlur,
+    onChange,
+    onFocus,
+    options,
+    readonly,
+    registry,
+    required = false,
+    schema,
+    uiSchema
+  } = props;
+  const { schemaUtils } = registry;
+  const formDataHash = (0, import_utils8.hashObject)(formData ?? null);
+  const retrievedOptions = (0, import_react7.useMemo)(
+    () => options.map((opt) => schemaUtils.retrieveSchema(opt, formData)),
+    // oxlint-disable-next-line react-hooks/exhaustive-deps -- formDataHash is the value-stable proxy for formData
+    [options, schemaUtils, formDataHash]
+  );
+  const [selectedOption, setSelectedOption] = (0, import_react7.useState)(() => {
+    const discriminator = (0, import_utils8.getDiscriminatorFieldFromSchema)(schema);
+    return schemaUtils.getClosestMatchingOption(formData, retrievedOptions, 0, discriminator);
+  });
+  const skipNextOptionRecalculation = (0, import_react7.useRef)(false);
+  const prevFormDataRef = (0, import_react7.useRef)(formData);
+  const prevFieldIdRef = (0, import_react7.useRef)(fieldPathId.$id);
+  (0, import_react7.useEffect)(() => {
+    const prevFormData = prevFormDataRef.current;
+    const prevFieldId = prevFieldIdRef.current;
+    prevFormDataRef.current = formData;
+    prevFieldIdRef.current = fieldPathId.$id;
+    if (!(0, import_utils8.deepEquals)(formData, prevFormData) && fieldPathId.$id === prevFieldId) {
+      if (skipNextOptionRecalculation.current) {
+        skipNextOptionRecalculation.current = false;
+        return;
+      }
+      const discriminator = (0, import_utils8.getDiscriminatorFieldFromSchema)(schema);
+      const matchingOption = schemaUtils.getClosestMatchingOption(
+        formData,
+        retrievedOptions,
+        selectedOption,
+        discriminator
+      );
+      if (matchingOption !== selectedOption) {
+        setSelectedOption(matchingOption);
+      }
     }
-    if (!(0, import_utils7.deepEquals)(formData, prevProps.formData) && fieldPathId.$id === prevProps.fieldPathId.$id) {
-      if (this.skipNextOptionRecalculation) {
-        this.skipNextOptionRecalculation = false;
-      } else {
-        const { retrievedOptions } = newState;
-        const matchingOption = this.getMatchingOption(selectedOption, formData, retrievedOptions);
-        if (prevState && matchingOption !== selectedOption) {
-          newState = { selectedOption: matchingOption, retrievedOptions };
-        }
+  });
+  const fieldId = `${fieldPathId.$id}${schema.oneOf ? "__oneof_select" : "__anyof_select"}`;
+  const onOptionChange = (0, import_react7.useCallback)(
+    (option2) => {
+      if (disabled || readonly) {
+        return;
       }
+      const intOption = option2 !== void 0 ? parseInt(option2, 10) : -1;
+      if (intOption === selectedOption) {
+        return;
+      }
+      const newOption = intOption >= 0 ? retrievedOptions[intOption] : void 0;
+      const oldOption = selectedOption >= 0 ? retrievedOptions[selectedOption] : void 0;
+      let newFormData = schemaUtils.sanitizeDataForNewSchema(newOption, oldOption, formData);
+      if (newOption) {
+        newFormData = schemaUtils.getDefaultFormState(newOption, newFormData, "excludeObjectChildren");
+      }
+      setSelectedOption(intOption);
+      skipNextOptionRecalculation.current = true;
+      onChange(newFormData, fieldPathId.path, void 0, fieldId);
+    },
+    // setSelectedOption is stable (guaranteed by useState); skipNextOptionRecalculation is a ref
+    [selectedOption, retrievedOptions, disabled, readonly, schemaUtils, formData, fieldPathId, onChange, fieldId]
+  );
+  const { widgets: widgets2, fields: fields2, translateString, globalUiOptions } = registry;
+  const { SchemaField: SchemaFieldComponent } = fields2;
+  const MultiSchemaFieldTemplate2 = (0, import_utils8.getTemplate)(
+    "MultiSchemaFieldTemplate",
+    registry,
+    globalUiOptions
+  );
+  const isOptionalRender = (0, import_utils8.shouldRenderOptionalField)(registry, schema, required, uiSchema);
+  const hasFormData = (0, import_utils8.isFormDataAvailable)(formData);
+  const {
+    widget = "select",
+    placeholder,
+    autofocus,
+    autocomplete,
+    title = schema.title,
+    ...uiOptions
+  } = (0, import_utils8.getUiOptions)(uiSchema, globalUiOptions);
+  const Widget = (0, import_utils8.getWidget)({ type: "number" }, widget, widgets2);
+  const rawErrors = (0, import_get3.default)(errorSchema, import_utils8.ERRORS_KEY, []);
+  const fieldErrorSchema = (0, import_omit2.default)(errorSchema, [import_utils8.ERRORS_KEY]);
+  const displayLabel = schemaUtils.getDisplayLabel(schema, uiSchema, globalUiOptions);
+  const option = selectedOption >= 0 ? retrievedOptions[selectedOption] || null : null;
+  let optionSchema;
+  if (option) {
+    const { required: schemaRequired, type: schemaType } = schema;
+    const parentProps = {};
+    if (schemaRequired) {
+      parentProps.required = schemaRequired;
     }
-    if (newState !== this.state) {
-      this.setState(newState);
+    if (schemaType !== void 0 && !("type" in option)) {
+      parentProps.type = schemaType;
     }
+    optionSchema = Object.keys(parentProps).length > 0 ? (0, import_utils8.mergeSchemas)(parentProps, option) : option;
   }
-  /** Determines the best matching option for the given `formData` and `options`.
-   *
-   * @param formData - The new formData
-   * @param options - The list of options to choose from
-   * @return - The index of the `option` that best matches the `formData`
-   */
-  getMatchingOption(selectedOption, formData, options) {
-    const {
-      schema,
-      registry: { schemaUtils }
-    } = this.props;
-    const discriminator = (0, import_utils7.getDiscriminatorFieldFromSchema)(schema);
-    const option = schemaUtils.getClosestMatchingOption(formData, options, selectedOption, discriminator);
-    return option;
-  }
-  /** Callback handler to remember what the currently selected option is. In addition to that the `formData` is updated
-   * to remove properties that are not part of the newly selected option schema, and then the updated data is passed to
-   * the `onChange` handler.
-   *
-   * @param option - The new option value being selected
-   */
-  onOptionChange = (option) => {
-    const { selectedOption, retrievedOptions } = this.state;
-    const { disabled = false, formData, onChange, readonly = false, registry, fieldPathId } = this.props;
-    if (disabled || readonly) {
-      return;
-    }
-    const { schemaUtils } = registry;
-    const intOption = option !== void 0 ? parseInt(option, 10) : -1;
-    if (intOption === selectedOption) {
-      return;
+  let optionsUiSchema = [];
+  if (import_utils8.ONE_OF_KEY in schema && uiSchema && import_utils8.ONE_OF_KEY in uiSchema) {
+    if (Array.isArray(uiSchema[import_utils8.ONE_OF_KEY])) {
+      optionsUiSchema = uiSchema[import_utils8.ONE_OF_KEY];
+    } else {
+      console.warn(`uiSchema.oneOf is not an array for "${title || name}"`);
     }
-    const newOption = intOption >= 0 ? retrievedOptions[intOption] : void 0;
-    const oldOption = selectedOption >= 0 ? retrievedOptions[selectedOption] : void 0;
-    let newFormData = schemaUtils.sanitizeDataForNewSchema(newOption, oldOption, formData);
-    if (newOption) {
-      newFormData = schemaUtils.getDefaultFormState(newOption, newFormData, "excludeObjectChildren");
+  } else if (import_utils8.ANY_OF_KEY in schema && uiSchema && import_utils8.ANY_OF_KEY in uiSchema) {
+    if (Array.isArray(uiSchema[import_utils8.ANY_OF_KEY])) {
+      optionsUiSchema = uiSchema[import_utils8.ANY_OF_KEY];
+    } else {
+      console.warn(`uiSchema.anyOf is not an array for "${title || name}"`);
     }
-    this.setState({ selectedOption: intOption }, () => {
-      this.skipNextOptionRecalculation = true;
-      onChange(newFormData, fieldPathId.path, void 0, this.getFieldId());
-    });
-  };
-  getFieldId() {
-    const { fieldPathId, schema } = this.props;
-    return `${fieldPathId.$id}${schema.oneOf ? "__oneof_select" : "__anyof_select"}`;
   }
-  /** Renders the `AnyOfField` selector along with a `SchemaField` for the value of the `formData`
-   */
-  render() {
-    const {
-      name,
-      disabled = false,
-      errorSchema = {},
-      formData,
+  let optionUiSchema = uiSchema;
+  if (selectedOption >= 0 && optionsUiSchema.length > selectedOption) {
+    optionUiSchema = optionsUiSchema[selectedOption];
+  }
+  const translateEnum = title ? import_utils8.TranslatableString.TitleOptionPrefix : import_utils8.TranslatableString.OptionPrefix;
+  const translateParams = title ? [title] : [];
+  const enumOptions = retrievedOptions.map((opt, index) => {
+    const { title: uiTitle = opt.title } = (0, import_utils8.getUiOptions)(optionsUiSchema[index]);
+    return {
+      label: uiTitle || translateString(translateEnum, translateParams.concat(String(index + 1))),
+      value: index
+    };
+  });
+  const selector = !isOptionalRender || hasFormData ? /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+    Widget,
+    {
+      id: fieldId,
+      name: `${name}${schema.oneOf ? "__oneof_select" : "__anyof_select"}`,
+      schema: { type: "number", default: 0 },
+      onChange: onOptionChange,
       onBlur,
       onFocus,
-      readonly,
-      required = false,
-      registry,
-      schema,
-      uiSchema
-    } = this.props;
-    const { widgets: widgets2, fields: fields2, translateString, globalUiOptions, schemaUtils } = registry;
-    const { SchemaField: SchemaFieldComponent } = fields2;
-    const MultiSchemaFieldTemplate2 = (0, import_utils7.getTemplate)(
-      "MultiSchemaFieldTemplate",
+      disabled: disabled || (0, import_isEmpty3.default)(enumOptions),
+      multiple: false,
+      rawErrors,
+      errorSchema: fieldErrorSchema,
+      value: selectedOption >= 0 ? selectedOption : void 0,
+      options: { enumOptions, ...uiOptions },
       registry,
-      globalUiOptions
-    );
-    const isOptionalRender = (0, import_utils7.shouldRenderOptionalField)(registry, schema, required, uiSchema);
-    const hasFormData = (0, import_utils7.isFormDataAvailable)(formData);
-    const { selectedOption, retrievedOptions } = this.state;
-    const {
-      widget = "select",
       placeholder,
-      autofocus,
       autocomplete,
-      title = schema.title,
-      ...uiOptions
-    } = (0, import_utils7.getUiOptions)(uiSchema, globalUiOptions);
-    const Widget = (0, import_utils7.getWidget)({ type: "number" }, widget, widgets2);
-    const rawErrors = (0, import_get3.default)(errorSchema, import_utils7.ERRORS_KEY, []);
-    const fieldErrorSchema = (0, import_omit2.default)(errorSchema, [import_utils7.ERRORS_KEY]);
-    const displayLabel = schemaUtils.getDisplayLabel(schema, uiSchema, globalUiOptions);
-    const option = selectedOption >= 0 ? retrievedOptions[selectedOption] || null : null;
-    let optionSchema;
-    if (option) {
-      const { required: schemaRequired } = schema;
-      optionSchema = schemaRequired ? (0, import_utils7.mergeSchemas)({ required: schemaRequired }, option) : option;
-    }
-    let optionsUiSchema = [];
-    if (import_utils7.ONE_OF_KEY in schema && uiSchema && import_utils7.ONE_OF_KEY in uiSchema) {
-      if (Array.isArray(uiSchema[import_utils7.ONE_OF_KEY])) {
-        optionsUiSchema = uiSchema[import_utils7.ONE_OF_KEY];
-      } else {
-        console.warn(`uiSchema.oneOf is not an array for "${title || name}"`);
-      }
-    } else if (import_utils7.ANY_OF_KEY in schema && uiSchema && import_utils7.ANY_OF_KEY in uiSchema) {
-      if (Array.isArray(uiSchema[import_utils7.ANY_OF_KEY])) {
-        optionsUiSchema = uiSchema[import_utils7.ANY_OF_KEY];
-      } else {
-        console.warn(`uiSchema.anyOf is not an array for "${title || name}"`);
-      }
+      autofocus,
+      label: title ?? name,
+      hideLabel: !displayLabel,
+      readonly
     }
-    let optionUiSchema = uiSchema;
-    if (selectedOption >= 0 && optionsUiSchema.length > selectedOption) {
-      optionUiSchema = optionsUiSchema[selectedOption];
+  ) : void 0;
+  const optionsSchemaField = optionSchema && optionSchema.type !== "null" && /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(SchemaFieldComponent, { ...props, schema: optionSchema, uiSchema: optionUiSchema }) || null;
+  return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+    MultiSchemaFieldTemplate2,
+    {
+      schema,
+      registry,
+      uiSchema,
+      selector,
+      optionSchemaField: optionsSchemaField
     }
-    const translateEnum = title ? import_utils7.TranslatableString.TitleOptionPrefix : import_utils7.TranslatableString.OptionPrefix;
-    const translateParams = title ? [title] : [];
-    const enumOptions = retrievedOptions.map((opt, index) => {
-      const { title: uiTitle = opt.title } = (0, import_utils7.getUiOptions)(optionsUiSchema[index]);
-      return {
-        label: uiTitle || translateString(translateEnum, translateParams.concat(String(index + 1))),
-        value: index
-      };
-    });
-    const selector = !isOptionalRender || hasFormData ? /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
-      Widget,
-      {
-        id: this.getFieldId(),
-        name: `${name}${schema.oneOf ? "__oneof_select" : "__anyof_select"}`,
-        schema: { type: "number", default: 0 },
-        onChange: this.onOptionChange,
-        onBlur,
-        onFocus,
-        disabled: disabled || (0, import_isEmpty3.default)(enumOptions),
-        multiple: false,
-        rawErrors,
-        errorSchema: fieldErrorSchema,
-        value: selectedOption >= 0 ? selectedOption : void 0,
-        options: { enumOptions, ...uiOptions },
-        registry,
-        placeholder,
-        autocomplete,
-        autofocus,
-        label: title ?? name,
-        hideLabel: !displayLabel,
-        readonly
-      }
-    ) : void 0;
-    const optionsSchemaField = optionSchema && optionSchema.type !== "null" && /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(SchemaFieldComponent, { ...this.props, schema: optionSchema, uiSchema: optionUiSchema }) || null;
-    return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
-      MultiSchemaFieldTemplate2,
-      {
-        schema,
-        registry,
-        uiSchema,
-        selector,
-        optionSchemaField: optionsSchemaField
-      }
-    );
-  }
-};
+  );
+}
 var MultiSchemaField_default = AnyOfField;
 
 // src/components/fields/NullField.tsx
-var import_react7 = require("react");
+var import_react8 = require("react");
 function NullField(props) {
   const { formData, onChange, fieldPathId } = props;
-  (0, import_react7.useEffect)(() => {
+  (0, import_react8.useEffect)(() => {
     if (formData === void 0) {
       onChange(null, fieldPathId.path);
     }
@@ -1862,21 +1856,21 @@ function NullField(props) {
 var NullField_default = NullField;
 
 // src/components/fields/NumberField.tsx
-var import_react8 = require("react");
-var import_utils8 = require("@rjsf/utils");
-var import_jsx_runtime8 = require("react/jsx-runtime");
+var import_react9 = require("react");
+var import_utils9 = require("@rjsf/utils");
+var import_jsx_runtime9 = require("react/jsx-runtime");
 var trailingCharMatcherWithPrefix = /\.([0-9]*0)*$/;
 var trailingCharMatcher = /[0.]0*$/;
 function NumberField(props) {
   const { registry, onChange, formData, value: initialValue } = props;
-  const [lastValue, setLastValue] = (0, import_react8.useState)(initialValue);
+  const [lastValue, setLastValue] = (0, import_react9.useState)(initialValue);
   const { StringField: StringField2 } = registry.fields;
   let value = formData;
-  const handleChange = (0, import_react8.useCallback)(
+  const handleChange = (0, import_react9.useCallback)(
     (newValue, path, errorSchema, id) => {
       setLastValue(newValue);
       const normalizedValue = `${newValue}`.startsWith(".") ? `0${newValue}` : newValue;
-      const processed = typeof normalizedValue === "string" && normalizedValue.match(trailingCharMatcherWithPrefix) ? (0, import_utils8.asNumber)(normalizedValue.replace(trailingCharMatcher, "")) : (0, import_utils8.asNumber)(normalizedValue);
+      const processed = typeof normalizedValue === "string" && trailingCharMatcherWithPrefix.exec(normalizedValue) ? (0, import_utils9.asNumber)(normalizedValue.replace(trailingCharMatcher, "")) : (0, import_utils9.asNumber)(normalizedValue);
       onChange(processed, path, errorSchema, id);
     },
     [onChange]
@@ -1887,25 +1881,25 @@ function NumberField(props) {
       value = lastValue;
     }
   }
-  return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(StringField2, { ...props, formData: value, onChange: handleChange });
+  return /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(StringField2, { ...props, formData: value, onChange: handleChange });
 }
 var NumberField_default = NumberField;
 
 // src/components/fields/ObjectField.tsx
-var import_react9 = require("react");
-var import_utils9 = require("@rjsf/utils");
+var import_react10 = require("react");
+var import_utils10 = require("@rjsf/utils");
 var import_get4 = __toESM(require("lodash/get"), 1);
 var import_has3 = __toESM(require("lodash/has"), 1);
 var import_isObject4 = __toESM(require("lodash/isObject"), 1);
 var import_set4 = __toESM(require("lodash/set"), 1);
-var import_react10 = require("markdown-to-jsx/react");
+var import_react11 = require("markdown-to-jsx/react");
 
 // src/components/constants.ts
 var ADDITIONAL_PROPERTY_KEY_REMOVE = /* @__PURE__ */ Symbol("remove-this-key");
 var IS_RESET = /* @__PURE__ */ Symbol("reset");
 
 // src/components/fields/ObjectField.tsx
-var import_jsx_runtime9 = require("react/jsx-runtime");
+var import_jsx_runtime10 = require("react/jsx-runtime");
 function isRequired(schema, name) {
   return Array.isArray(schema.required) && schema.required.includes(name);
 }
@@ -1923,7 +1917,7 @@ function getDefaultValue(translateString, type) {
       return {};
     case "string":
     default:
-      return translateString(import_utils9.TranslatableString.NewStringDefault);
+      return translateString(import_utils10.TranslatableString.NewStringDefault);
   }
 }
 function ObjectFieldPropertyFn(props) {
@@ -1946,13 +1940,13 @@ function ObjectFieldPropertyFn(props) {
     handleRemoveProperty,
     addedByAdditionalProperties
   } = props;
-  const [wasPropertyKeyModified, setWasPropertyKeyModified] = (0, import_react9.useState)(false);
+  const [wasPropertyKeyModified, setWasPropertyKeyModified] = (0, import_react10.useState)(false);
   const { globalFormOptions, fields: fields2 } = registry;
   const { SchemaField: SchemaField2 } = fields2;
-  const innerFieldIdPathId = (0, import_utils9.useDeepCompareMemo)(
-    (0, import_utils9.toFieldPathId)(propertyName, globalFormOptions, fieldPathId.path)
+  const innerFieldIdPathId = (0, import_utils10.useDeepCompareMemo)(
+    (0, import_utils10.toFieldPathId)(propertyName, globalFormOptions, fieldPathId.path)
   );
-  const onPropertyChange = (0, import_react9.useCallback)(
+  const onPropertyChange = (0, import_react10.useCallback)(
     (value, path, newErrorSchema, id) => {
       let normalizedValue = value;
       if (value === void 0 && addedByAdditionalProperties) {
@@ -1962,7 +1956,7 @@ function ObjectFieldPropertyFn(props) {
     },
     [onChange, addedByAdditionalProperties]
   );
-  const onKeyRename = (0, import_react9.useCallback)(
+  const onKeyRename = (0, import_react10.useCallback)(
     (value) => {
       if (propertyName !== value) {
         setWasPropertyKeyModified(true);
@@ -1971,7 +1965,7 @@ function ObjectFieldPropertyFn(props) {
     },
     [propertyName, handleKeyRename]
   );
-  const onKeyRenameBlur = (0, import_react9.useCallback)(
+  const onKeyRenameBlur = (0, import_react10.useCallback)(
     (event) => {
       const {
         target: { value }
@@ -1980,10 +1974,10 @@ function ObjectFieldPropertyFn(props) {
     },
     [onKeyRename]
   );
-  const onRemoveProperty = (0, import_react9.useCallback)(() => {
+  const onRemoveProperty = (0, import_react10.useCallback)(() => {
     handleRemoveProperty(propertyName);
   }, [propertyName, handleRemoveProperty]);
-  return /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(
+  return /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(
     SchemaField2,
     {
       name: propertyName,
@@ -2007,7 +2001,7 @@ function ObjectFieldPropertyFn(props) {
     }
   );
 }
-var ObjectFieldProperty = (0, import_react9.memo)(ObjectFieldPropertyFn);
+var ObjectFieldProperty = (0, import_react10.memo)(ObjectFieldPropertyFn);
 function ObjectField(props) {
   const {
     schema: rawSchema,
@@ -2028,24 +2022,24 @@ function ObjectField(props) {
   } = props;
   const { fields: fields2, schemaUtils, translateString, globalUiOptions } = registry;
   const { OptionalDataControlsField: OptionalDataControlsField2 } = fields2;
-  const formDataRef = (0, import_react9.useRef)(formData);
+  const formDataRef = (0, import_react10.useRef)(formData);
   formDataRef.current = formData;
-  const schema = (0, import_react9.useMemo)(
+  const schema = (0, import_react10.useMemo)(
     () => schemaUtils.retrieveSchema(rawSchema, formData, true),
     [schemaUtils, rawSchema, formData]
   );
-  const uiOptions = (0, import_react9.useMemo)(() => (0, import_utils9.getUiOptions)(uiSchema, globalUiOptions), [uiSchema, globalUiOptions]);
+  const uiOptions = (0, import_react10.useMemo)(() => (0, import_utils10.getUiOptions)(uiSchema, globalUiOptions), [uiSchema, globalUiOptions]);
   const { properties: schemaProperties = {} } = schema;
   const childFieldPathId = props.childFieldPathId ?? fieldPathId;
-  const lastRenamedProperty = (0, import_react9.useRef)({ previousKey: "", currentKey: void 0 });
+  const lastRenamedProperty = (0, import_react10.useRef)({ previousKey: "", currentKey: void 0 });
   const templateTitle = uiOptions.title ?? schema.title ?? title ?? name;
   const description = uiOptions.description ?? schema.description;
-  const renderOptionalField = (0, import_utils9.shouldRenderOptionalField)(registry, schema, required, uiSchema);
-  const hasFormData = (0, import_utils9.isFormDataAvailable)(formData);
+  const renderOptionalField = (0, import_utils10.shouldRenderOptionalField)(registry, schema, required, uiSchema);
+  const hasFormData = (0, import_utils10.isFormDataAvailable)(formData);
   let orderedProperties = [];
-  const getAvailableKey = (0, import_react9.useCallback)(
+  const getAvailableKey = (0, import_react10.useCallback)(
     (preferredKey, existingFormData) => {
-      const { duplicateKeySuffixSeparator = "-" } = (0, import_utils9.getUiOptions)(uiSchema, globalUiOptions);
+      const { duplicateKeySuffixSeparator = "-" } = (0, import_utils10.getUiOptions)(uiSchema, globalUiOptions);
       let index = 0;
       let newKey = preferredKey;
       while ((0, import_has3.default)(existingFormData, newKey)) {
@@ -2056,7 +2050,7 @@ function ObjectField(props) {
     },
     [uiSchema, globalUiOptions]
   );
-  const onAddProperty = (0, import_react9.useCallback)(() => {
+  const onAddProperty = (0, import_react10.useCallback)(() => {
     if (!(schema.additionalProperties || schema.patternProperties)) {
       return;
     }
@@ -2073,13 +2067,13 @@ function ObjectField(props) {
         constValue = schema.additionalProperties.const;
         defaultValue = schema.additionalProperties.default;
         let apSchema = schema.additionalProperties;
-        if (import_utils9.REF_KEY in apSchema) {
-          apSchema = schemaUtils.retrieveSchema({ [import_utils9.REF_KEY]: apSchema[import_utils9.REF_KEY] }, formData);
+        if (import_utils10.REF_KEY in apSchema) {
+          apSchema = schemaUtils.retrieveSchema({ [import_utils10.REF_KEY]: apSchema[import_utils10.REF_KEY] }, formData);
           type = apSchema.type;
           constValue = apSchema.const;
-          defaultValue = apSchema.default;
+          defaultValue = schemaUtils.getDefaultFormState(apSchema, defaultValue);
         }
-        if (!type && (import_utils9.ANY_OF_KEY in apSchema || import_utils9.ONE_OF_KEY in apSchema)) {
+        if (!type && (import_utils10.ANY_OF_KEY in apSchema || import_utils10.ONE_OF_KEY in apSchema)) {
           type = "object";
         }
       }
@@ -2092,7 +2086,7 @@ function ObjectField(props) {
     }
     onChange(newFormData, childFieldPathId.path);
   }, [formData, onChange, translateString, schemaUtils, childFieldPathId, getAvailableKey, schema]);
-  const handleKeyRename = (0, import_react9.useCallback)(
+  const handleKeyRename = (0, import_react10.useCallback)(
     (oldKey, newKey) => {
       if (oldKey !== newKey) {
         const currentFormData = formDataRef.current;
@@ -2116,13 +2110,13 @@ function ObjectField(props) {
     },
     [onChange, childFieldPathId, getAvailableKey]
   );
-  const handleRemoveProperty = (0, import_react9.useCallback)(
+  const handleRemoveProperty = (0, import_react10.useCallback)(
     (key) => {
       onChange(ADDITIONAL_PROPERTY_KEY_REMOVE, [...childFieldPathId.path, key]);
     },
     [onChange, childFieldPathId]
   );
-  const getStableKey = (0, import_react9.useCallback)((property) => {
+  const getStableKey = (0, import_react10.useCallback)((property) => {
     if (lastRenamedProperty.current.currentKey === property) {
       return lastRenamedProperty.current.previousKey;
     }
@@ -2131,30 +2125,32 @@ function ObjectField(props) {
   if (!renderOptionalField || hasFormData) {
     try {
       const properties = Object.keys(schemaProperties);
-      orderedProperties = (0, import_utils9.orderProperties)(properties, uiOptions.order);
+      orderedProperties = (0, import_utils10.orderProperties)(properties, uiOptions.order);
     } catch (err) {
-      return /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)("div", { children: [
-        /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("p", { className: "rjsf-config-error", style: { color: "red" }, children: /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(import_react10.Markdown, { options: { disableParsingRawHTML: true }, children: translateString(import_utils9.TranslatableString.InvalidObjectField, [name || "root", err.message]) }) }),
-        /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("pre", { children: JSON.stringify(schema) })
+      return /* @__PURE__ */ (0, import_jsx_runtime10.jsxs)("div", { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("p", { className: "rjsf-config-error", style: { color: "red" }, children: /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(import_react11.Markdown, { options: { disableParsingRawHTML: true }, children: translateString(import_utils10.TranslatableString.InvalidObjectField, [name || "root", err.message]) }) }),
+        /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("pre", { children: JSON.stringify(schema) })
       ] });
     }
   }
-  const Template = (0, import_utils9.getTemplate)("ObjectFieldTemplate", registry, uiOptions);
-  const optionalDataControl = renderOptionalField ? /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(OptionalDataControlsField2, { ...props, fieldPathId: childFieldPathId, schema }) : void 0;
+  const Template = (0, import_utils10.getTemplate)("ObjectFieldTemplate", registry, uiOptions);
+  const optionalDataControl = renderOptionalField ? /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(OptionalDataControlsField2, { ...props, fieldPathId: childFieldPathId, schema }) : void 0;
   const templateProps = {
     // getDisplayLabel() always returns false for object types, so just check the `uiOptions.label`
     title: uiOptions.label === false ? "" : templateTitle,
     description: uiOptions.label === false ? void 0 : description,
     properties: orderedProperties.map((propertyName) => {
-      const addedByAdditionalProperties = (0, import_has3.default)(schema, [import_utils9.PROPERTIES_KEY, propertyName, import_utils9.ADDITIONAL_PROPERTY_FLAG]);
+      const addedByAdditionalProperties = Boolean(
+        schema.properties?.[propertyName]?.[import_utils10.ADDITIONAL_PROPERTY_FLAG]
+      );
       const fieldUiSchema = addedByAdditionalProperties ? uiSchema.additionalProperties : uiSchema[propertyName];
-      const hidden = (0, import_utils9.getUiOptions)(fieldUiSchema).widget === "hidden";
-      const content = /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(
+      const hidden = (0, import_utils10.getUiOptions)(fieldUiSchema).widget === "hidden";
+      const content = /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(
         ObjectFieldProperty,
         {
           propertyName,
           required: isRequired(schema, propertyName),
-          schema: (0, import_get4.default)(schema, [import_utils9.PROPERTIES_KEY, propertyName], {}),
+          schema: (0, import_get4.default)(schema, [import_utils10.PROPERTIES_KEY, propertyName], {}),
           uiSchema: fieldUiSchema,
           errorSchema: (0, import_get4.default)(errorSchema, [propertyName]),
           fieldPathId: childFieldPathId,
@@ -2193,12 +2189,12 @@ function ObjectField(props) {
     optionalDataControl,
     className: renderOptionalField ? "rjsf-optional-object-field" : void 0
   };
-  return /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(Template, { ...templateProps, onAddProperty });
+  return /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(Template, { ...templateProps, onAddProperty });
 }
 
 // src/components/fields/OptionalDataControlsField.tsx
-var import_utils10 = require("@rjsf/utils");
-var import_jsx_runtime10 = require("react/jsx-runtime");
+var import_utils11 = require("@rjsf/utils");
+var import_jsx_runtime11 = require("react/jsx-runtime");
 function OptionalDataControlsField(props) {
   const {
     schema,
@@ -2212,38 +2208,38 @@ function OptionalDataControlsField(props) {
     registry
   } = props;
   const { globalUiOptions = {}, schemaUtils, translateString } = registry;
-  const uiOptions = (0, import_utils10.getUiOptions)(uiSchema, globalUiOptions);
-  const OptionalDataControlsTemplate2 = (0, import_utils10.getTemplate)(
+  const uiOptions = (0, import_utils11.getUiOptions)(uiSchema, globalUiOptions);
+  const OptionalDataControlsTemplate2 = (0, import_utils11.getTemplate)(
     "OptionalDataControlsTemplate",
     registry,
     uiOptions
   );
-  const hasFormData = (0, import_utils10.isFormDataAvailable)(formData);
+  const hasFormData = (0, import_utils11.isFormDataAvailable)(formData);
   let id;
   let label;
   let onAddClick;
   let onRemoveClick;
   if (disabled || readonly) {
-    id = (0, import_utils10.optionalControlsId)(fieldPathId, "Msg");
-    label = hasFormData ? void 0 : translateString(import_utils10.TranslatableString.OptionalObjectEmptyMsg);
+    id = (0, import_utils11.optionalControlsId)(fieldPathId, "Msg");
+    label = hasFormData ? void 0 : translateString(import_utils11.TranslatableString.OptionalObjectEmptyMsg);
   } else {
-    const labelEnum = hasFormData ? import_utils10.TranslatableString.OptionalObjectRemove : import_utils10.TranslatableString.OptionalObjectAdd;
+    const labelEnum = hasFormData ? import_utils11.TranslatableString.OptionalObjectRemove : import_utils11.TranslatableString.OptionalObjectAdd;
     label = translateString(labelEnum);
     if (hasFormData) {
-      id = (0, import_utils10.optionalControlsId)(fieldPathId, "Remove");
+      id = (0, import_utils11.optionalControlsId)(fieldPathId, "Remove");
       onRemoveClick = () => onChange(void 0, fieldPathId.path, errorSchema);
     } else {
-      id = (0, import_utils10.optionalControlsId)(fieldPathId, "Add");
+      id = (0, import_utils11.optionalControlsId)(fieldPathId, "Add");
       onAddClick = () => {
         let newFormData = schemaUtils.getDefaultFormState(schema, formData, "excludeObjectChildren");
         if (newFormData === void 0) {
-          newFormData = (0, import_utils10.getSchemaType)(schema) === "array" ? [] : {};
+          newFormData = (0, import_utils11.getSchemaType)(schema) === "array" ? [] : {};
         }
         onChange(newFormData, fieldPathId.path, errorSchema);
       };
     }
   }
-  return label && /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(
+  return label && /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(
     OptionalDataControlsTemplate2,
     {
       id,
@@ -2258,11 +2254,11 @@ function OptionalDataControlsField(props) {
 }
 
 // src/components/fields/SchemaField.tsx
-var import_react11 = require("react");
-var import_utils11 = require("@rjsf/utils");
+var import_react12 = require("react");
+var import_utils12 = require("@rjsf/utils");
 var import_isObject5 = __toESM(require("lodash/isObject"), 1);
 var import_omit3 = __toESM(require("lodash/omit"), 1);
-var import_jsx_runtime11 = require("react/jsx-runtime");
+var import_jsx_runtime12 = require("react/jsx-runtime");
 var COMPONENT_TYPES = {
   array: "ArrayField",
   boolean: "BooleanField",
@@ -2274,21 +2270,21 @@ var COMPONENT_TYPES = {
 };
 function getFieldComponent(schema, uiOptions, registry) {
   const { field } = uiOptions;
-  const { fields: fields2 } = registry;
+  const { fields: fields2, schemaUtils } = registry;
   if (typeof field === "function") {
     return field;
   }
   if (typeof field === "string" && field in fields2) {
     return fields2[field];
   }
-  const schemaType = (0, import_utils11.getSchemaType)(schema);
+  const schemaType = (0, import_utils12.getSchemaType)(schema);
   const type = Array.isArray(schemaType) ? schemaType[0] : schemaType || "";
   const schemaId = schema.$id;
   let componentName = COMPONENT_TYPES[type];
   if (schemaId && schemaId in fields2) {
     componentName = schemaId;
   }
-  if (!componentName && (schema.anyOf || schema.oneOf)) {
+  if ((schema.anyOf || schema.oneOf) && !schemaUtils.isSelect(schema) && componentName !== "ObjectField") {
     return () => null;
   }
   return componentName in fields2 ? fields2[componentName] : fields2.FallbackField;
@@ -2310,26 +2306,29 @@ function SchemaFieldRender(props) {
     wasPropertyKeyModified = false
   } = props;
   const { schemaUtils, globalFormOptions, globalUiOptions, fields: fields2 } = registry;
-  const { AnyOfField: _AnyOfField, OneOfField: _OneOfField } = fields2;
-  const uiSchema = (0, import_utils11.resolveUiSchema)(_schema, _uiSchema, registry);
-  const uiOptions = (0, import_utils11.getUiOptions)(uiSchema, globalUiOptions);
-  const FieldTemplate2 = (0, import_utils11.getTemplate)("FieldTemplate", registry, uiOptions);
-  const DescriptionFieldTemplate = (0, import_utils11.getTemplate)(
-    "DescriptionFieldTemplate",
-    registry,
-    uiOptions
-  );
-  const FieldHelpTemplate2 = (0, import_utils11.getTemplate)("FieldHelpTemplate", registry, uiOptions);
-  const FieldErrorTemplate2 = (0, import_utils11.getTemplate)("FieldErrorTemplate", registry, uiOptions);
-  const schema = schemaUtils.retrieveSchema(_schema, formData);
-  const fieldId = fieldPathId[import_utils11.ID_KEY];
-  const handleFieldComponentChange = (0, import_react11.useCallback)(
+  const { AnyOfField: _AnyOfField, OneOfField: _OneOfField, CyclicSchemaField: CyclicSchemaField2 } = fields2;
+  const fieldId = fieldPathId[import_utils12.ID_KEY];
+  const handleFieldComponentChange = (0, import_react12.useCallback)(
     (newFormData, path, newErrorSchema, id2) => {
       const theId = id2 || fieldId;
       return onChange(newFormData, path, newErrorSchema, theId);
     },
     [fieldId, onChange]
   );
+  if (_schema[import_utils12.RJSF_REF_CYCLE_KEY]) {
+    return /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(CyclicSchemaField2, { ...props });
+  }
+  const uiSchema = (0, import_utils12.resolveUiSchema)(_schema, _uiSchema, registry);
+  const uiOptions = (0, import_utils12.getUiOptions)(uiSchema, globalUiOptions);
+  const FieldTemplate2 = (0, import_utils12.getTemplate)("FieldTemplate", registry, uiOptions);
+  const DescriptionFieldTemplate = (0, import_utils12.getTemplate)(
+    "DescriptionFieldTemplate",
+    registry,
+    uiOptions
+  );
+  const FieldHelpTemplate2 = (0, import_utils12.getTemplate)("FieldHelpTemplate", registry, uiOptions);
+  const FieldErrorTemplate2 = (0, import_utils12.getTemplate)("FieldErrorTemplate", registry, uiOptions);
+  const schema = schemaUtils.retrieveSchema(_schema, formData);
   const FieldComponent = getFieldComponent(schema, uiOptions, registry);
   const isDeprecated = Boolean(schema.deprecated);
   const deprecatedHandling = isDeprecated ? uiOptions.deprecatedHandling ?? "label" : void 0;
@@ -2346,34 +2345,34 @@ function SchemaFieldRender(props) {
   let XxxOfField;
   let XxxOfOptions;
   let fieldPathIdProps = { fieldPathId };
-  if ((import_utils11.ANY_OF_KEY in schema || import_utils11.ONE_OF_KEY in schema) && !isReplacingAnyOrOneOf && !schemaUtils.isSelect(schema)) {
-    if (schema[import_utils11.ANY_OF_KEY]) {
+  if ((import_utils12.ANY_OF_KEY in schema || import_utils12.ONE_OF_KEY in schema) && !isReplacingAnyOrOneOf && !schemaUtils.isSelect(schema)) {
+    if (schema[import_utils12.ANY_OF_KEY]) {
       XxxOfField = _AnyOfField;
-      XxxOfOptions = schema[import_utils11.ANY_OF_KEY].map(
+      XxxOfOptions = schema[import_utils12.ANY_OF_KEY].map(
         (xxxOfSchema) => schemaUtils.retrieveSchema((0, import_isObject5.default)(xxxOfSchema) ? xxxOfSchema : {}, formData)
       );
-    } else if (schema[import_utils11.ONE_OF_KEY]) {
+    } else if (schema[import_utils12.ONE_OF_KEY]) {
       XxxOfField = _OneOfField;
-      XxxOfOptions = schema[import_utils11.ONE_OF_KEY].map(
+      XxxOfOptions = schema[import_utils12.ONE_OF_KEY].map(
         (xxxOfSchema) => schemaUtils.retrieveSchema((0, import_isObject5.default)(xxxOfSchema) ? xxxOfSchema : {}, formData)
       );
     }
-    const isOptionalRender = (0, import_utils11.shouldRenderOptionalField)(registry, schema, required, uiSchema);
-    const hasFormData = (0, import_utils11.isFormDataAvailable)(formData);
+    const isOptionalRender = (0, import_utils12.shouldRenderOptionalField)(registry, schema, required, uiSchema);
+    const hasFormData = (0, import_utils12.isFormDataAvailable)(formData);
     displayLabel = displayLabel && (!isOptionalRender || hasFormData);
     fieldPathIdProps = {
       childFieldPathId: fieldPathId,
       // The main FieldComponent will add `XxxOf` onto the fieldPathId to avoid duplication with the rendering of the
       // same FieldComponent by the `XxxOfField`
-      fieldPathId: (0, import_utils11.toFieldPathId)("XxxOf", globalFormOptions, fieldPathId)
+      fieldPathId: (0, import_utils12.toFieldPathId)("XxxOf", globalFormOptions, fieldPathId)
     };
   }
   const { __errors, ...fieldErrorSchema } = errorSchema || {};
   const fieldUiSchema = (0, import_omit3.default)(uiSchema, ["ui:classNames", "classNames", "ui:style"]);
-  if (import_utils11.UI_OPTIONS_KEY in fieldUiSchema) {
-    fieldUiSchema[import_utils11.UI_OPTIONS_KEY] = (0, import_omit3.default)(fieldUiSchema[import_utils11.UI_OPTIONS_KEY], ["classNames", "style"]);
+  if (import_utils12.UI_OPTIONS_KEY in fieldUiSchema) {
+    fieldUiSchema[import_utils12.UI_OPTIONS_KEY] = (0, import_omit3.default)(fieldUiSchema[import_utils12.UI_OPTIONS_KEY], ["classNames", "style"]);
   }
-  const field = /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(
+  const field = /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(
     FieldComponent,
     {
       ...props,
@@ -2389,27 +2388,27 @@ function SchemaFieldRender(props) {
       rawErrors: __errors
     }
   );
-  const id = fieldPathId[import_utils11.ID_KEY];
+  const id = fieldPathId[import_utils12.ID_KEY];
   let label;
   if (wasPropertyKeyModified) {
     label = name;
   } else {
-    label = import_utils11.ADDITIONAL_PROPERTY_FLAG in schema ? name : uiOptions.title || props.schema.title || schema.title || props.title || name;
+    label = import_utils12.ADDITIONAL_PROPERTY_FLAG in schema ? name : uiOptions.title || props.schema.title || schema.title || props.title || name;
   }
   if (deprecatedHandling === "label") {
-    label = registry.translateString(import_utils11.TranslatableString.DeprecatedLabel, [label]);
+    label = registry.translateString(import_utils12.TranslatableString.DeprecatedLabel, [label]);
   }
   const description = uiOptions.description || props.schema.description || schema.description || "";
   const { help } = uiOptions;
   const hidden = uiOptions.widget === "hidden" || deprecatedHandling === "hide";
-  const classNames = ["rjsf-field", `rjsf-field-${(0, import_utils11.getSchemaType)(schema)}`];
+  const classNames = ["rjsf-field", `rjsf-field-${(0, import_utils12.getSchemaType)(schema)}`];
   if (!hideError && __errors && __errors.length > 0) {
     classNames.push("rjsf-field-error");
   }
   if (uiOptions.classNames) {
     classNames.push(uiOptions.classNames);
   }
-  const helpComponent = /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(
+  const helpComponent = /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(
     FieldHelpTemplate2,
     {
       help,
@@ -2420,7 +2419,7 @@ function SchemaFieldRender(props) {
       registry
     }
   );
-  const errorsComponent = hideError || XxxOfField && !schemaUtils.isSelect(schema) ? void 0 : /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(
+  const errorsComponent = hideError || XxxOfField && !schemaUtils.isSelect(schema) ? void 0 : /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(
     FieldErrorTemplate2,
     {
       errors: __errors,
@@ -2432,10 +2431,10 @@ function SchemaFieldRender(props) {
     }
   );
   const fieldProps = {
-    description: /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(
+    description: /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(
       DescriptionFieldTemplate,
       {
-        id: (0, import_utils11.descriptionId)(id),
+        id: (0, import_utils12.descriptionId)(id),
         description,
         schema,
         uiSchema,
@@ -2467,9 +2466,9 @@ function SchemaFieldRender(props) {
     uiSchema,
     registry
   };
-  return /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(FieldTemplate2, { ...fieldProps, children: /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(import_jsx_runtime11.Fragment, { children: [
+  return /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(FieldTemplate2, { ...fieldProps, children: /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)(import_jsx_runtime12.Fragment, { children: [
     field,
-    XxxOfField && /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(
+    XxxOfField && /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(
       XxxOfField,
       {
         name,
@@ -2491,24 +2490,22 @@ function SchemaFieldRender(props) {
     )
   ] }) });
 }
-var SchemaField = class extends import_react11.Component {
-  shouldComponentUpdate(nextProps) {
-    const {
-      registry: { globalFormOptions }
-    } = this.props;
-    const { experimental_componentUpdateStrategy = "customDeep" } = globalFormOptions;
-    return (0, import_utils11.shouldRender)(this, nextProps, this.state, experimental_componentUpdateStrategy);
+var SchemaField = (0, import_react12.memo)(SchemaFieldRender, (prevProps, nextProps) => {
+  const { experimental_componentUpdateStrategy = "customDeep" } = nextProps.registry.globalFormOptions;
+  if (experimental_componentUpdateStrategy === "always") {
+    return false;
   }
-  render() {
-    return /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(SchemaFieldRender, { ...this.props });
+  if (experimental_componentUpdateStrategy === "shallow") {
+    return (0, import_utils12.shallowEquals)(prevProps, nextProps);
   }
-};
+  return (0, import_utils12.deepEquals)(prevProps, nextProps);
+});
 var SchemaField_default = SchemaField;
 
 // src/components/fields/StringField.tsx
-var import_react12 = require("react");
-var import_utils12 = require("@rjsf/utils");
-var import_jsx_runtime12 = require("react/jsx-runtime");
+var import_react13 = require("react");
+var import_utils13 = require("@rjsf/utils");
+var import_jsx_runtime13 = require("react/jsx-runtime");
 function StringField(props) {
   const {
     schema,
@@ -2530,20 +2527,20 @@ function StringField(props) {
   } = props;
   const { title: schemaTitle, format } = schema;
   const { widgets: widgets2, schemaUtils, globalUiOptions } = registry;
-  const enumOptions = schemaUtils.isSelect(schema) ? (0, import_utils12.optionsList)(schema, uiSchema) : void 0;
+  const enumOptions = schemaUtils.isSelect(schema) ? (0, import_utils13.optionsList)(schema, uiSchema) : void 0;
   let defaultWidget = enumOptions ? "select" : "text";
-  if (format && (0, import_utils12.hasWidget)(schema, format, widgets2)) {
+  if (format && (0, import_utils13.hasWidget)(schema, format, widgets2)) {
     defaultWidget = format;
   }
-  const { widget = defaultWidget, placeholder = "", title: uiTitle, ...options } = (0, import_utils12.getUiOptions)(uiSchema);
+  const { widget = defaultWidget, placeholder = "", title: uiTitle, ...options } = (0, import_utils13.getUiOptions)(uiSchema);
   const displayLabel = schemaUtils.getDisplayLabel(schema, uiSchema, globalUiOptions);
   const label = uiTitle ?? title ?? schemaTitle ?? name;
-  const Widget = (0, import_utils12.getWidget)(schema, widget, widgets2);
-  const onWidgetChange = (0, import_react12.useCallback)(
+  const Widget = (0, import_utils13.getWidget)(schema, widget, widgets2);
+  const onWidgetChange = (0, import_react13.useCallback)(
     (value, errorSchema, id) => onChange(value, fieldPathId.path, errorSchema, id),
     [onChange, fieldPathId]
   );
-  return /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(
+  return /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(
     Widget,
     {
       options: { ...options, enumOptions },
@@ -2578,6 +2575,7 @@ function fields() {
     ArrayField,
     // ArrayField falls back to SchemaField if ArraySchemaField is not defined, which it isn't by default
     BooleanField: BooleanField_default,
+    CyclicSchemaField,
     FallbackField,
     LayoutGridField,
     LayoutHeaderField,
@@ -2594,24 +2592,24 @@ function fields() {
 var fields_default = fields;
 
 // src/components/templates/ArrayFieldDescriptionTemplate.tsx
-var import_utils13 = require("@rjsf/utils");
-var import_jsx_runtime13 = require("react/jsx-runtime");
+var import_utils14 = require("@rjsf/utils");
+var import_jsx_runtime14 = require("react/jsx-runtime");
 function ArrayFieldDescriptionTemplate(props) {
   const { fieldPathId, description, registry, schema, uiSchema } = props;
-  const options = (0, import_utils13.getUiOptions)(uiSchema, registry.globalUiOptions);
+  const options = (0, import_utils14.getUiOptions)(uiSchema, registry.globalUiOptions);
   const { label: displayLabel = true } = options;
   if (!description || !displayLabel) {
     return null;
   }
-  const DescriptionFieldTemplate = (0, import_utils13.getTemplate)(
+  const DescriptionFieldTemplate = (0, import_utils14.getTemplate)(
     "DescriptionFieldTemplate",
     registry,
     options
   );
-  return /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(
+  return /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(
     DescriptionFieldTemplate,
     {
-      id: (0, import_utils13.descriptionId)(fieldPathId),
+      id: (0, import_utils14.descriptionId)(fieldPathId),
       description,
       schema,
       uiSchema,
@@ -2621,8 +2619,8 @@ function ArrayFieldDescriptionTemplate(props) {
 }
 
 // src/components/templates/ArrayFieldItemButtonsTemplate.tsx
-var import_utils14 = require("@rjsf/utils");
-var import_jsx_runtime14 = require("react/jsx-runtime");
+var import_utils15 = require("@rjsf/utils");
+var import_jsx_runtime15 = require("react/jsx-runtime");
 function ArrayFieldItemButtonsTemplate(props) {
   const {
     disabled,
@@ -2640,11 +2638,11 @@ function ArrayFieldItemButtonsTemplate(props) {
     uiSchema
   } = props;
   const { CopyButton: CopyButton2, MoveDownButton: MoveDownButton2, MoveUpButton: MoveUpButton2, RemoveButton: RemoveButton2 } = registry.templates.ButtonTemplates;
-  return /* @__PURE__ */ (0, import_jsx_runtime14.jsxs)(import_jsx_runtime14.Fragment, { children: [
-    (hasMoveUp || hasMoveDown) && /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(
+  return /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)(import_jsx_runtime15.Fragment, { children: [
+    (hasMoveUp || hasMoveDown) && /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(
       MoveUpButton2,
       {
-        id: (0, import_utils14.buttonId)(fieldPathId, "moveUp"),
+        id: (0, import_utils15.buttonId)(fieldPathId, "moveUp"),
         className: "rjsf-array-item-move-up",
         disabled: disabled || readonly || !hasMoveUp,
         onClick: onMoveUpItem,
@@ -2652,10 +2650,10 @@ function ArrayFieldItemButtonsTemplate(props) {
         registry
       }
     ),
-    (hasMoveUp || hasMoveDown) && /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(
+    (hasMoveUp || hasMoveDown) && /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(
       MoveDownButton2,
       {
-        id: (0, import_utils14.buttonId)(fieldPathId, "moveDown"),
+        id: (0, import_utils15.buttonId)(fieldPathId, "moveDown"),
         className: "rjsf-array-item-move-down",
         disabled: disabled || readonly || !hasMoveDown,
         onClick: onMoveDownItem,
@@ -2663,10 +2661,10 @@ function ArrayFieldItemButtonsTemplate(props) {
         registry
       }
     ),
-    hasCopy && /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(
+    hasCopy && /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(
       CopyButton2,
       {
-        id: (0, import_utils14.buttonId)(fieldPathId, "copy"),
+        id: (0, import_utils15.buttonId)(fieldPathId, "copy"),
         className: "rjsf-array-item-copy",
         disabled: disabled || readonly,
         onClick: onCopyItem,
@@ -2674,10 +2672,10 @@ function ArrayFieldItemButtonsTemplate(props) {
         registry
       }
     ),
-    hasRemove && /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(
+    hasRemove && /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(
       RemoveButton2,
       {
-        id: (0, import_utils14.buttonId)(fieldPathId, "remove"),
+        id: (0, import_utils15.buttonId)(fieldPathId, "remove"),
         className: "rjsf-array-item-remove",
         disabled: disabled || readonly,
         onClick: onRemoveItem,
@@ -2689,12 +2687,12 @@ function ArrayFieldItemButtonsTemplate(props) {
 }
 
 // src/components/templates/ArrayFieldItemTemplate.tsx
-var import_utils15 = require("@rjsf/utils");
-var import_jsx_runtime15 = require("react/jsx-runtime");
+var import_utils16 = require("@rjsf/utils");
+var import_jsx_runtime16 = require("react/jsx-runtime");
 function ArrayFieldItemTemplate(props) {
   const { children, className, buttonsProps, displayLabel, hasDescription, hasToolbar, registry, uiSchema } = props;
-  const uiOptions = (0, import_utils15.getUiOptions)(uiSchema);
-  const ArrayFieldItemButtonsTemplate2 = (0, import_utils15.getTemplate)(
+  const uiOptions = (0, import_utils16.getUiOptions)(uiSchema);
+  const ArrayFieldItemButtonsTemplate2 = (0, import_utils16.getTemplate)(
     "ArrayFieldItemButtonsTemplate",
     registry,
     uiOptions
@@ -2708,15 +2706,15 @@ function ArrayFieldItemTemplate(props) {
   const margin = hasDescription ? 31 : 9;
   const containerStyle = { display: "flex", alignItems: displayLabel ? "center" : "baseline" };
   const toolbarStyle = { display: "flex", justifyContent: "flex-end", marginTop: displayLabel ? `${margin}px` : 0 };
-  return /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)("div", { className, style: containerStyle, children: [
-    /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("div", { className: hasToolbar ? "col-xs-9 col-md-10 col-xl-11" : "col-xs-12", children }),
-    hasToolbar && /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("div", { className: "col-xs-3 col-md-2 col-xl-1 array-item-toolbox", children: /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("div", { className: "btn-group", style: toolbarStyle, children: /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(ArrayFieldItemButtonsTemplate2, { ...buttonsProps, style: btnStyle }) }) })
+  return /* @__PURE__ */ (0, import_jsx_runtime16.jsxs)("div", { className, style: containerStyle, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime16.jsx)("div", { className: hasToolbar ? "col-xs-9 col-md-10 col-xl-11" : "col-xs-12", children }),
+    hasToolbar && /* @__PURE__ */ (0, import_jsx_runtime16.jsx)("div", { className: "col-xs-3 col-md-2 col-xl-1 array-item-toolbox", children: /* @__PURE__ */ (0, import_jsx_runtime16.jsx)("div", { className: "btn-group", style: toolbarStyle, children: /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(ArrayFieldItemButtonsTemplate2, { ...buttonsProps, style: btnStyle }) }) })
   ] });
 }
 
 // src/components/templates/ArrayFieldTemplate.tsx
-var import_utils16 = require("@rjsf/utils");
-var import_jsx_runtime16 = require("react/jsx-runtime");
+var import_utils17 = require("@rjsf/utils");
+var import_jsx_runtime17 = require("react/jsx-runtime");
 function ArrayFieldTemplate(props) {
   const {
     canAdd,
@@ -2733,13 +2731,13 @@ function ArrayFieldTemplate(props) {
     schema,
     title
   } = props;
-  const uiOptions = (0, import_utils16.getUiOptions)(uiSchema);
-  const ArrayFieldDescriptionTemplate2 = (0, import_utils16.getTemplate)(
+  const uiOptions = (0, import_utils17.getUiOptions)(uiSchema);
+  const ArrayFieldDescriptionTemplate2 = (0, import_utils17.getTemplate)(
     "ArrayFieldDescriptionTemplate",
     registry,
     uiOptions
   );
-  const ArrayFieldTitleTemplate2 = (0, import_utils16.getTemplate)(
+  const ArrayFieldTitleTemplate2 = (0, import_utils17.getTemplate)(
     "ArrayFieldTitleTemplate",
     registry,
     uiOptions
@@ -2748,8 +2746,8 @@ function ArrayFieldTemplate(props) {
   const {
     ButtonTemplates: { AddButton: AddButton2 }
   } = registry.templates;
-  return /* @__PURE__ */ (0, import_jsx_runtime16.jsxs)("fieldset", { className, id: fieldPathId.$id, children: [
-    /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(
+  return /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)("fieldset", { className, id: fieldPathId.$id, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(
       ArrayFieldTitleTemplate2,
       {
         fieldPathId,
@@ -2761,7 +2759,7 @@ function ArrayFieldTemplate(props) {
         optionalDataControl: showOptionalDataControlInTitle ? optionalDataControl : void 0
       }
     ),
-    /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(
+    /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(
       ArrayFieldDescriptionTemplate2,
       {
         fieldPathId,
@@ -2772,11 +2770,11 @@ function ArrayFieldTemplate(props) {
       }
     ),
     !showOptionalDataControlInTitle ? optionalDataControl : void 0,
-    /* @__PURE__ */ (0, import_jsx_runtime16.jsx)("div", { className: "row array-item-list", children: items }),
-    canAdd && /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(
+    /* @__PURE__ */ (0, import_jsx_runtime17.jsx)("div", { className: "row array-item-list", children: items }),
+    canAdd && /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(
       AddButton2,
       {
-        id: (0, import_utils16.buttonId)(fieldPathId, "add"),
+        id: (0, import_utils17.buttonId)(fieldPathId, "add"),
         className: "rjsf-array-item-add",
         onClick: onAddClick,
         disabled: disabled || readonly,
@@ -2788,24 +2786,24 @@ function ArrayFieldTemplate(props) {
 }
 
 // src/components/templates/ArrayFieldTitleTemplate.tsx
-var import_utils17 = require("@rjsf/utils");
-var import_jsx_runtime17 = require("react/jsx-runtime");
+var import_utils18 = require("@rjsf/utils");
+var import_jsx_runtime18 = require("react/jsx-runtime");
 function ArrayFieldTitleTemplate(props) {
   const { fieldPathId, title, schema, uiSchema, required, registry, optionalDataControl } = props;
-  const options = (0, import_utils17.getUiOptions)(uiSchema, registry.globalUiOptions);
+  const options = (0, import_utils18.getUiOptions)(uiSchema, registry.globalUiOptions);
   const { label: displayLabel = true } = options;
   if (!title || !displayLabel) {
     return null;
   }
-  const TitleFieldTemplate = (0, import_utils17.getTemplate)(
+  const TitleFieldTemplate = (0, import_utils18.getTemplate)(
     "TitleFieldTemplate",
     registry,
     options
   );
-  return /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(
+  return /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(
     TitleFieldTemplate,
     {
-      id: (0, import_utils17.titleId)(fieldPathId),
+      id: (0, import_utils18.titleId)(fieldPathId),
       title,
       required,
       schema,
@@ -2817,12 +2815,12 @@ function ArrayFieldTitleTemplate(props) {
 }
 
 // src/components/templates/BaseInputTemplate.tsx
-var import_react13 = require("react");
-var import_utils19 = require("@rjsf/utils");
+var import_react14 = require("react");
+var import_utils20 = require("@rjsf/utils");
 
 // src/components/SchemaExamples.tsx
-var import_utils18 = require("@rjsf/utils");
-var import_jsx_runtime18 = (
+var import_utils19 = require("@rjsf/utils");
+var import_jsx_runtime19 = (
   // oxlint-disable-next-line jsx-a11y/control-has-associated-label
   require("react/jsx-runtime")
 );
@@ -2832,13 +2830,13 @@ function SchemaExamples(props) {
   if (!Array.isArray(examples)) {
     return null;
   }
-  return /* @__PURE__ */ (0, import_jsx_runtime18.jsx)("datalist", { id: (0, import_utils18.examplesId)(id), children: examples.concat(
+  return /* @__PURE__ */ (0, import_jsx_runtime19.jsx)("datalist", { id: (0, import_utils19.examplesId)(id), children: examples.concat(
     schemaDefault !== void 0 && !examples.map(String).includes(String(schemaDefault)) ? [schemaDefault] : []
-  ).map((example) => /* @__PURE__ */ (0, import_jsx_runtime18.jsx)("option", { value: example }, String(example))) }, `datalist_${id}`);
+  ).map((example) => /* @__PURE__ */ (0, import_jsx_runtime19.jsx)("option", { value: example }, String(example))) }, `datalist_${id}`);
 }
 
 // src/components/templates/BaseInputTemplate.tsx
-var import_jsx_runtime19 = require("react/jsx-runtime");
+var import_jsx_runtime20 = require("react/jsx-runtime");
 function BaseInputTemplate(props) {
   const {
     id,
@@ -2872,7 +2870,7 @@ function BaseInputTemplate(props) {
   }
   const inputProps = {
     ...rest,
-    ...(0, import_utils19.getInputProps)(schema, type, options)
+    ...(0, import_utils20.getInputProps)(schema, type, options)
   };
   let inputValue;
   if (inputProps.type === "number" || inputProps.type === "integer") {
@@ -2880,19 +2878,16 @@ function BaseInputTemplate(props) {
   } else {
     inputValue = value == null ? "" : value;
   }
-  const handleChange = (0, import_react13.useCallback)(
+  const handleChange = (0, import_react14.useCallback)(
     ({ target: { value: newValue } }) => onChange(newValue === "" ? options.emptyValue : newValue),
     [onChange, options]
   );
-  const handleBlur = (0, import_react13.useCallback)(
-    ({ target }) => onBlur(id, target && target.value),
-    [onBlur, id]
-  );
-  const handleFocus = (0, import_react13.useCallback)(
-    ({ target }) => onFocus(id, target && target.value),
+  const handleBlur = (0, import_react14.useCallback)(({ target }) => onBlur(id, target?.value), [onBlur, id]);
+  const handleFocus = (0, import_react14.useCallback)(
+    ({ target }) => onFocus(id, target?.value),
     [onFocus, id]
   );
-  const handleClear = (0, import_react13.useCallback)(
+  const handleClear = (0, import_react14.useCallback)(
     (e) => {
       e.preventDefault();
       e.stopPropagation();
@@ -2900,8 +2895,8 @@ function BaseInputTemplate(props) {
     },
     [onChange, options.emptyValue]
   );
-  return /* @__PURE__ */ (0, import_jsx_runtime19.jsxs)(import_jsx_runtime19.Fragment, { children: [
-    /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(
+  return /* @__PURE__ */ (0, import_jsx_runtime20.jsxs)(import_jsx_runtime20.Fragment, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(
       "input",
       {
         id,
@@ -2912,59 +2907,59 @@ function BaseInputTemplate(props) {
         autoFocus: autofocus,
         value: inputValue,
         ...inputProps,
-        list: schema.examples ? (0, import_utils19.examplesId)(id) : void 0,
+        list: schema.examples ? (0, import_utils20.examplesId)(id) : void 0,
         onChange: onChangeOverride || handleChange,
         onBlur: handleBlur,
         onFocus: handleFocus,
-        "aria-describedby": (0, import_utils19.ariaDescribedByIds)(id, !!schema.examples)
+        "aria-describedby": (0, import_utils20.ariaDescribedByIds)(id, !!schema.examples)
       }
     ),
-    options.allowClearTextInputs && !readonly && !disabled && inputValue && /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(ClearButton2, { registry, onClick: handleClear }),
-    /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(SchemaExamples, { id, schema })
+    options.allowClearTextInputs && !readonly && !disabled && inputValue && /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(ClearButton2, { registry, onClick: handleClear }),
+    /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(SchemaExamples, { id, schema })
   ] });
 }
 
 // src/components/templates/ButtonTemplates/AddButton.tsx
-var import_utils21 = require("@rjsf/utils");
+var import_utils22 = require("@rjsf/utils");
 
 // src/components/templates/ButtonTemplates/IconButton.tsx
-var import_react14 = require("react");
-var import_utils20 = require("@rjsf/utils");
-var import_jsx_runtime20 = require("react/jsx-runtime");
+var import_react15 = require("react");
+var import_utils21 = require("@rjsf/utils");
+var import_jsx_runtime21 = require("react/jsx-runtime");
 function IconButtonFn(props) {
   const { iconType = "default", icon, className, uiSchema, registry, ...otherProps } = props;
-  return /* @__PURE__ */ (0, import_jsx_runtime20.jsx)("button", { type: "button", className: `btn btn-${iconType} ${className}`, ...otherProps, children: /* @__PURE__ */ (0, import_jsx_runtime20.jsx)("i", { className: `glyphicon glyphicon-${icon}` }) });
+  return /* @__PURE__ */ (0, import_jsx_runtime21.jsx)("button", { type: "button", className: `btn btn-${iconType} ${className}`, ...otherProps, children: /* @__PURE__ */ (0, import_jsx_runtime21.jsx)("i", { className: `glyphicon glyphicon-${icon}` }) });
 }
-var IconButton = (0, import_react14.memo)(IconButtonFn);
+var IconButton = (0, import_react15.memo)(IconButtonFn);
 var IconButton_default = IconButton;
 function CopyButtonFn(props) {
   const {
     registry: { translateString }
   } = props;
-  return /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(IconButton, { title: translateString(import_utils20.TranslatableString.CopyButton), ...props, icon: "copy" });
+  return /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(IconButton, { title: translateString(import_utils21.TranslatableString.CopyButton), ...props, icon: "copy" });
 }
-var CopyButton = (0, import_react14.memo)(CopyButtonFn);
+var CopyButton = (0, import_react15.memo)(CopyButtonFn);
 function MoveDownButtonFn(props) {
   const {
     registry: { translateString }
   } = props;
-  return /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(IconButton, { title: translateString(import_utils20.TranslatableString.MoveDownButton), ...props, icon: "arrow-down" });
+  return /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(IconButton, { title: translateString(import_utils21.TranslatableString.MoveDownButton), ...props, icon: "arrow-down" });
 }
-var MoveDownButton = (0, import_react14.memo)(MoveDownButtonFn);
+var MoveDownButton = (0, import_react15.memo)(MoveDownButtonFn);
 function MoveUpButtonFn(props) {
   const {
     registry: { translateString }
   } = props;
-  return /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(IconButton, { title: translateString(import_utils20.TranslatableString.MoveUpButton), ...props, icon: "arrow-up" });
+  return /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(IconButton, { title: translateString(import_utils21.TranslatableString.MoveUpButton), ...props, icon: "arrow-up" });
 }
-var MoveUpButton = (0, import_react14.memo)(MoveUpButtonFn);
+var MoveUpButton = (0, import_react15.memo)(MoveUpButtonFn);
 function RemoveButtonFn(props) {
   const {
     registry: { translateString }
   } = props;
-  return /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(IconButton, { title: translateString(import_utils20.TranslatableString.RemoveButton), ...props, iconType: "danger", icon: "remove" });
+  return /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(IconButton, { title: translateString(import_utils21.TranslatableString.RemoveButton), ...props, iconType: "danger", icon: "remove" });
 }
-var RemoveButton = (0, import_react14.memo)(RemoveButtonFn);
+var RemoveButton = (0, import_react15.memo)(RemoveButtonFn);
 function ClearButtonFn({
   id,
   className,
@@ -2974,14 +2969,14 @@ function ClearButtonFn({
   ...props
 }) {
   const { translateString } = registry;
-  return /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(
+  return /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(
     IconButton,
     {
       id,
       iconType: "default",
       icon: "remove",
       className: "btn-clear col-xs-12",
-      title: translateString(import_utils20.TranslatableString.ClearButton),
+      title: translateString(import_utils21.TranslatableString.ClearButton),
       onClick,
       disabled,
       registry,
@@ -2989,10 +2984,10 @@ function ClearButtonFn({
     }
   );
 }
-var ClearButton = (0, import_react14.memo)(ClearButtonFn);
+var ClearButton = (0, import_react15.memo)(ClearButtonFn);
 
 // src/components/templates/ButtonTemplates/AddButton.tsx
-var import_jsx_runtime21 = require("react/jsx-runtime");
+var import_jsx_runtime22 = require("react/jsx-runtime");
 function AddButton({
   id,
   className,
@@ -3001,18 +2996,18 @@ function AddButton({
   registry
 }) {
   const { translateString } = registry;
-  return /* @__PURE__ */ (0, import_jsx_runtime21.jsx)("div", { className: "row", children: /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(
+  return /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("div", { className: "row", children: /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(
     "p",
     {
       className: `col-xs-4 col-sm-2 col-lg-1 col-xs-offset-8 col-sm-offset-10 col-lg-offset-11 text-right ${className}`,
-      children: /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(
+      children: /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(
         IconButton_default,
         {
           id,
           iconType: "info",
           icon: "plus",
           className: "btn-add col-xs-12",
-          title: translateString(import_utils21.TranslatableString.AddButton),
+          title: translateString(import_utils22.TranslatableString.AddButton),
           onClick,
           disabled,
           registry
@@ -3023,14 +3018,14 @@ function AddButton({
 }
 
 // src/components/templates/ButtonTemplates/SubmitButton.tsx
-var import_utils22 = require("@rjsf/utils");
-var import_jsx_runtime22 = require("react/jsx-runtime");
+var import_utils23 = require("@rjsf/utils");
+var import_jsx_runtime23 = require("react/jsx-runtime");
 function SubmitButton({ uiSchema }) {
-  const { submitText, norender, props: submitButtonProps = {} } = (0, import_utils22.getSubmitButtonOptions)(uiSchema);
+  const { submitText, norender, props: submitButtonProps = {} } = (0, import_utils23.getSubmitButtonOptions)(uiSchema);
   if (norender) {
     return null;
   }
-  return /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("div", { children: /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("button", { type: "submit", ...submitButtonProps, className: `btn btn-info ${submitButtonProps.className || ""}`, children: submitText }) });
+  return /* @__PURE__ */ (0, import_jsx_runtime23.jsx)("div", { children: /* @__PURE__ */ (0, import_jsx_runtime23.jsx)("button", { type: "submit", ...submitButtonProps, className: `btn btn-info ${submitButtonProps.className || ""}`, children: submitText }) });
 }
 
 // src/components/templates/ButtonTemplates/index.ts
@@ -3047,58 +3042,83 @@ function buttonTemplates() {
 }
 var ButtonTemplates_default = buttonTemplates;
 
+// src/components/templates/CyclicSchemaExpandTemplate.tsx
+var import_utils24 = require("@rjsf/utils");
+var import_jsx_runtime24 = require("react/jsx-runtime");
+function CyclicSchemaExpandTemplate(props) {
+  const { name, fieldPathId, registry, onExpand } = props;
+  const { translateString } = registry;
+  const buttonId5 = `${fieldPathId[import_utils24.ID_KEY]}-button`;
+  return /* @__PURE__ */ (0, import_jsx_runtime24.jsxs)("div", { style: { marginTop: "1rem" }, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime24.jsx)("div", { className: "text-danger", children: translateString(import_utils24.TranslatableString.CycleDetected, [name]) }),
+    /* @__PURE__ */ (0, import_jsx_runtime24.jsxs)("div", { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(
+        "button",
+        {
+          id: buttonId5,
+          type: "button",
+          className: "btn btn-sm btn-warning",
+          onClick: () => onExpand(fieldPathId[import_utils24.ID_KEY]),
+          children: translateString(import_utils24.TranslatableString.ExpandButton)
+        }
+      ),
+      " "
+    ] })
+  ] });
+}
+
 // src/components/RichDescription.tsx
-var import_utils23 = require("@rjsf/utils");
-var import_react15 = require("markdown-to-jsx/react");
-var import_jsx_runtime23 = require("react/jsx-runtime");
-var TEST_IDS = (0, import_utils23.getTestIds)();
+var import_utils25 = require("@rjsf/utils");
+var import_react16 = require("markdown-to-jsx/react");
+var import_jsx_runtime25 = require("react/jsx-runtime");
+var TEST_IDS = (0, import_utils25.getTestIds)();
 function RichDescription({ description, registry, uiSchema = {} }) {
   const { globalUiOptions } = registry;
-  const uiOptions = (0, import_utils23.getUiOptions)(uiSchema, globalUiOptions);
+  const uiOptions = (0, import_utils25.getUiOptions)(uiSchema, globalUiOptions);
   if (uiOptions.enableMarkdownInDescription && typeof description === "string") {
-    return /* @__PURE__ */ (0, import_jsx_runtime23.jsx)(import_react15.Markdown, { options: { disableParsingRawHTML: true }, "data-testid": TEST_IDS.markdown, children: description });
+    return /* @__PURE__ */ (0, import_jsx_runtime25.jsx)(import_react16.Markdown, { options: { disableParsingRawHTML: true }, "data-testid": TEST_IDS.markdown, children: description });
   }
   return description;
 }
 RichDescription.TEST_IDS = TEST_IDS;
 
 // src/components/templates/DescriptionField.tsx
-var import_jsx_runtime24 = require("react/jsx-runtime");
+var import_jsx_runtime26 = require("react/jsx-runtime");
 function DescriptionField(props) {
   const { id, description, registry, uiSchema } = props;
   if (!description) {
     return null;
   }
-  return /* @__PURE__ */ (0, import_jsx_runtime24.jsx)("div", { id, className: "field-description", children: /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(RichDescription, { description, registry, uiSchema }) });
+  return /* @__PURE__ */ (0, import_jsx_runtime26.jsx)("div", { id, className: "field-description", children: /* @__PURE__ */ (0, import_jsx_runtime26.jsx)(RichDescription, { description, registry, uiSchema }) });
 }
 
 // src/components/templates/ErrorList.tsx
-var import_utils24 = require("@rjsf/utils");
-var import_jsx_runtime25 = require("react/jsx-runtime");
+var import_utils26 = require("@rjsf/utils");
+var import_jsx_runtime27 = require("react/jsx-runtime");
 function ErrorList({
   errors,
   registry
 }) {
   const { translateString } = registry;
-  return /* @__PURE__ */ (0, import_jsx_runtime25.jsxs)("div", { className: "panel panel-danger errors", children: [
-    /* @__PURE__ */ (0, import_jsx_runtime25.jsx)("div", { className: "panel-heading", children: /* @__PURE__ */ (0, import_jsx_runtime25.jsx)("h3", { className: "panel-title", children: translateString(import_utils24.TranslatableString.ErrorsLabel) }) }),
-    /* @__PURE__ */ (0, import_jsx_runtime25.jsx)("ul", { className: "list-group", children: errors.map((error, i) => (
+  return /* @__PURE__ */ (0, import_jsx_runtime27.jsxs)("div", { className: "panel panel-danger errors", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime27.jsx)("div", { className: "panel-heading", children: /* @__PURE__ */ (0, import_jsx_runtime27.jsx)("h3", { className: "panel-title", children: translateString(import_utils26.TranslatableString.ErrorsLabel) }) }),
+    /* @__PURE__ */ (0, import_jsx_runtime27.jsx)("ul", { className: "list-group", children: errors.map((error, i) => (
       // oxlint-disable-next-line react/no-array-index-key
-      /* @__PURE__ */ (0, import_jsx_runtime25.jsx)("li", { className: "list-group-item text-danger", children: error.stack }, i)
+      /* @__PURE__ */ (0, import_jsx_runtime27.jsx)("li", { className: "list-group-item text-danger", children: error.stack }, i)
     )) })
   ] });
 }
 
 // src/components/templates/FallbackFieldTemplate.tsx
-var import_utils25 = require("@rjsf/utils");
-var import_jsx_runtime26 = require("react/jsx-runtime");
+var import_utils27 = require("@rjsf/utils");
+var import_jsx_runtime28 = require("react/jsx-runtime");
 function FallbackFieldTemplate(props) {
   const { schema, registry, typeSelector, schemaField } = props;
-  const MultiSchemaFieldTemplate2 = (0, import_utils25.getTemplate)(
+  const MultiSchemaFieldTemplate2 = (0, import_utils27.getTemplate)(
     "MultiSchemaFieldTemplate",
     registry
   );
-  return /* @__PURE__ */ (0, import_jsx_runtime26.jsx)(
+  return /* @__PURE__ */ (0, import_jsx_runtime28.jsx)(
     MultiSchemaFieldTemplate2,
     {
       selector: typeSelector,
@@ -3110,8 +3130,8 @@ function FallbackFieldTemplate(props) {
 }
 
 // src/components/templates/FieldErrorTemplate.tsx
-var import_utils26 = require("@rjsf/utils");
-var import_jsx_runtime27 = (
+var import_utils28 = require("@rjsf/utils");
+var import_jsx_runtime29 = (
   // oxlint-disable-next-line react/no-array-index-key
   require("react/jsx-runtime")
 );
@@ -3120,75 +3140,75 @@ function FieldErrorTemplate(props) {
   if (errors.length === 0) {
     return null;
   }
-  const id = (0, import_utils26.errorId)(fieldPathId);
-  return /* @__PURE__ */ (0, import_jsx_runtime27.jsx)("div", { children: /* @__PURE__ */ (0, import_jsx_runtime27.jsx)("ul", { id, className: "error-detail bs-callout bs-callout-info", children: errors.filter((elem) => !!elem).map((error, index) => /* @__PURE__ */ (0, import_jsx_runtime27.jsx)("li", { className: "text-danger", children: error }, index)) }) });
+  const id = (0, import_utils28.errorId)(fieldPathId);
+  return /* @__PURE__ */ (0, import_jsx_runtime29.jsx)("div", { children: /* @__PURE__ */ (0, import_jsx_runtime29.jsx)("ul", { id, className: "error-detail bs-callout bs-callout-info", children: errors.filter((elem) => !!elem).map((error, index) => /* @__PURE__ */ (0, import_jsx_runtime29.jsx)("li", { className: "text-danger", children: error }, index)) }) });
 }
 
 // src/components/templates/FieldHelpTemplate.tsx
-var import_utils28 = require("@rjsf/utils");
+var import_utils30 = require("@rjsf/utils");
 
 // src/components/RichHelp.tsx
-var import_utils27 = require("@rjsf/utils");
-var import_react16 = require("markdown-to-jsx/react");
-var import_jsx_runtime28 = require("react/jsx-runtime");
-var TEST_IDS2 = (0, import_utils27.getTestIds)();
+var import_utils29 = require("@rjsf/utils");
+var import_react17 = require("markdown-to-jsx/react");
+var import_jsx_runtime30 = require("react/jsx-runtime");
+var TEST_IDS2 = (0, import_utils29.getTestIds)();
 function RichHelp({
   help,
   registry,
   uiSchema = {}
 }) {
   const { globalUiOptions } = registry;
-  const uiOptions = (0, import_utils27.getUiOptions)(uiSchema, globalUiOptions);
+  const uiOptions = (0, import_utils29.getUiOptions)(uiSchema, globalUiOptions);
   if (uiOptions.enableMarkdownInHelp && typeof help === "string") {
-    return /* @__PURE__ */ (0, import_jsx_runtime28.jsx)(import_react16.Markdown, { options: { disableParsingRawHTML: true }, "data-testid": TEST_IDS2.markdown, children: help });
+    return /* @__PURE__ */ (0, import_jsx_runtime30.jsx)(import_react17.Markdown, { options: { disableParsingRawHTML: true }, "data-testid": TEST_IDS2.markdown, children: help });
   }
   return help;
 }
 RichHelp.TEST_IDS = TEST_IDS2;
 
 // src/components/templates/FieldHelpTemplate.tsx
-var import_jsx_runtime29 = require("react/jsx-runtime");
+var import_jsx_runtime31 = require("react/jsx-runtime");
 function FieldHelpTemplate(props) {
   const { fieldPathId, help, uiSchema, registry } = props;
   if (!help) {
     return null;
   }
-  return /* @__PURE__ */ (0, import_jsx_runtime29.jsx)("div", { id: (0, import_utils28.helpId)(fieldPathId), className: "help-block", children: /* @__PURE__ */ (0, import_jsx_runtime29.jsx)(RichHelp, { help, registry, uiSchema }) });
+  return /* @__PURE__ */ (0, import_jsx_runtime31.jsx)("div", { id: (0, import_utils30.helpId)(fieldPathId), className: "help-block", children: /* @__PURE__ */ (0, import_jsx_runtime31.jsx)(RichHelp, { help, registry, uiSchema }) });
 }
 
 // src/components/templates/FieldTemplate/FieldTemplate.tsx
-var import_utils29 = require("@rjsf/utils");
+var import_utils31 = require("@rjsf/utils");
 
 // src/components/templates/FieldTemplate/Label.tsx
-var import_jsx_runtime30 = require("react/jsx-runtime");
+var import_jsx_runtime32 = require("react/jsx-runtime");
 var REQUIRED_FIELD_SYMBOL = "*";
 function Label(props) {
   const { label, required, id } = props;
   if (!label) {
     return null;
   }
-  return /* @__PURE__ */ (0, import_jsx_runtime30.jsxs)("label", { className: "control-label", htmlFor: id, children: [
+  return /* @__PURE__ */ (0, import_jsx_runtime32.jsxs)("label", { className: "control-label", htmlFor: id, children: [
     label,
-    required && /* @__PURE__ */ (0, import_jsx_runtime30.jsx)("span", { className: "required", children: REQUIRED_FIELD_SYMBOL })
+    required && /* @__PURE__ */ (0, import_jsx_runtime32.jsx)("span", { className: "required", children: REQUIRED_FIELD_SYMBOL })
   ] });
 }
 
 // src/components/templates/FieldTemplate/FieldTemplate.tsx
-var import_jsx_runtime31 = require("react/jsx-runtime");
+var import_jsx_runtime33 = require("react/jsx-runtime");
 function FieldTemplate(props) {
   const { id, label, children, errors, help, description, hidden, required, displayLabel, registry, uiSchema } = props;
-  const uiOptions = (0, import_utils29.getUiOptions)(uiSchema);
-  const WrapIfAdditionalTemplate2 = (0, import_utils29.getTemplate)(
+  const uiOptions = (0, import_utils31.getUiOptions)(uiSchema);
+  const WrapIfAdditionalTemplate2 = (0, import_utils31.getTemplate)(
     "WrapIfAdditionalTemplate",
     registry,
     uiOptions
   );
   if (hidden) {
-    return /* @__PURE__ */ (0, import_jsx_runtime31.jsx)("div", { className: "hidden", children });
+    return /* @__PURE__ */ (0, import_jsx_runtime33.jsx)("div", { className: "hidden", children });
   }
   const isCheckbox = uiOptions.widget === "checkbox";
-  return /* @__PURE__ */ (0, import_jsx_runtime31.jsxs)(WrapIfAdditionalTemplate2, { ...props, children: [
-    displayLabel && !isCheckbox && /* @__PURE__ */ (0, import_jsx_runtime31.jsx)(Label, { label, required, id }),
+  return /* @__PURE__ */ (0, import_jsx_runtime33.jsxs)(WrapIfAdditionalTemplate2, { ...props, children: [
+    displayLabel && !isCheckbox && /* @__PURE__ */ (0, import_jsx_runtime33.jsx)(Label, { label, required, id }),
     displayLabel && description ? description : null,
     children,
     errors,
@@ -3200,25 +3220,25 @@ function FieldTemplate(props) {
 var FieldTemplate_default = FieldTemplate;
 
 // src/components/templates/GridTemplate.tsx
-var import_jsx_runtime32 = require("react/jsx-runtime");
+var import_jsx_runtime34 = require("react/jsx-runtime");
 function GridTemplate(props) {
   const { children, column, className, ...rest } = props;
-  return /* @__PURE__ */ (0, import_jsx_runtime32.jsx)("div", { className, ...rest, children });
+  return /* @__PURE__ */ (0, import_jsx_runtime34.jsx)("div", { className, ...rest, children });
 }
 
 // src/components/templates/MultiSchemaFieldTemplate.tsx
-var import_jsx_runtime33 = require("react/jsx-runtime");
+var import_jsx_runtime35 = require("react/jsx-runtime");
 function MultiSchemaFieldTemplate(props) {
   const { selector, optionSchemaField } = props;
-  return /* @__PURE__ */ (0, import_jsx_runtime33.jsxs)("div", { className: "panel panel-default panel-body", children: [
-    /* @__PURE__ */ (0, import_jsx_runtime33.jsx)("div", { className: "form-group", children: selector }),
+  return /* @__PURE__ */ (0, import_jsx_runtime35.jsxs)("div", { className: "panel panel-default panel-body", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime35.jsx)("div", { className: "form-group", children: selector }),
     optionSchemaField
   ] });
 }
 
 // src/components/templates/ObjectFieldTemplate.tsx
-var import_utils30 = require("@rjsf/utils");
-var import_jsx_runtime34 = require("react/jsx-runtime");
+var import_utils32 = require("@rjsf/utils");
+var import_jsx_runtime36 = require("react/jsx-runtime");
 function ObjectFieldTemplate(props) {
   const {
     className,
@@ -3236,9 +3256,9 @@ function ObjectFieldTemplate(props) {
     title,
     uiSchema
   } = props;
-  const options = (0, import_utils30.getUiOptions)(uiSchema);
-  const TitleFieldTemplate = (0, import_utils30.getTemplate)("TitleFieldTemplate", registry, options);
-  const DescriptionFieldTemplate = (0, import_utils30.getTemplate)(
+  const options = (0, import_utils32.getUiOptions)(uiSchema);
+  const TitleFieldTemplate = (0, import_utils32.getTemplate)("TitleFieldTemplate", registry, options);
+  const DescriptionFieldTemplate = (0, import_utils32.getTemplate)(
     "DescriptionFieldTemplate",
     registry,
     options
@@ -3251,11 +3271,11 @@ function ObjectFieldTemplate(props) {
   const {
     ButtonTemplates: { AddButton: AddButton2 }
   } = registry.templates;
-  return /* @__PURE__ */ (0, import_jsx_runtime34.jsxs)("fieldset", { className, id: fieldPathId.$id, children: [
-    title && /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(
+  return /* @__PURE__ */ (0, import_jsx_runtime36.jsxs)("fieldset", { className, id: fieldPathId.$id, children: [
+    title && /* @__PURE__ */ (0, import_jsx_runtime36.jsx)(
       TitleFieldTemplate,
       {
-        id: (0, import_utils30.titleId)(fieldPathId),
+        id: (0, import_utils32.titleId)(fieldPathId),
         title,
         required,
         schema,
@@ -3264,10 +3284,10 @@ function ObjectFieldTemplate(props) {
         optionalDataControl: showOptionalDataControlInTitle ? optionalDataControl : void 0
       }
     ),
-    description && /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(
+    description && /* @__PURE__ */ (0, import_jsx_runtime36.jsx)(
       DescriptionFieldTemplate,
       {
-        id: (0, import_utils30.descriptionId)(fieldPathId),
+        id: (0, import_utils32.descriptionId)(fieldPathId),
         description,
         schema,
         uiSchema,
@@ -3276,10 +3296,10 @@ function ObjectFieldTemplate(props) {
     ),
     !showOptionalDataControlInTitle ? optionalDataControl : void 0,
     properties.map((prop) => prop.content),
-    (0, import_utils30.canExpand)(schema, uiSchema, formData) && /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(
+    (0, import_utils32.canExpand)(schema, uiSchema, formData) && /* @__PURE__ */ (0, import_jsx_runtime36.jsx)(
       AddButton2,
       {
-        id: (0, import_utils30.buttonId)(fieldPathId, "add"),
+        id: (0, import_utils32.buttonId)(fieldPathId, "add"),
         className: "rjsf-object-property-expand",
         onClick: onAddProperty,
         disabled: disabled || readonly,
@@ -3291,11 +3311,11 @@ function ObjectFieldTemplate(props) {
 }
 
 // src/components/templates/OptionalDataControlsTemplate.tsx
-var import_jsx_runtime35 = require("react/jsx-runtime");
+var import_jsx_runtime37 = require("react/jsx-runtime");
 function OptionalDataControlsTemplate(props) {
   const { id, registry, label, onAddClick, onRemoveClick } = props;
   if (onAddClick) {
-    return /* @__PURE__ */ (0, import_jsx_runtime35.jsx)(
+    return /* @__PURE__ */ (0, import_jsx_runtime37.jsx)(
       IconButton_default,
       {
         id,
@@ -3308,7 +3328,7 @@ function OptionalDataControlsTemplate(props) {
     );
   }
   if (onRemoveClick) {
-    return /* @__PURE__ */ (0, import_jsx_runtime35.jsx)(
+    return /* @__PURE__ */ (0, import_jsx_runtime37.jsx)(
       IconButton_default,
       {
         id,
@@ -3320,48 +3340,48 @@ function OptionalDataControlsTemplate(props) {
       }
     );
   }
-  return /* @__PURE__ */ (0, import_jsx_runtime35.jsx)("em", { id, children: label });
+  return /* @__PURE__ */ (0, import_jsx_runtime37.jsx)("em", { id, children: label });
 }
 
 // src/components/templates/TitleField.tsx
-var import_jsx_runtime36 = require("react/jsx-runtime");
+var import_jsx_runtime38 = require("react/jsx-runtime");
 var REQUIRED_FIELD_SYMBOL2 = "*";
 function TitleField(props) {
   const { id, title, required, optionalDataControl } = props;
-  return /* @__PURE__ */ (0, import_jsx_runtime36.jsxs)("legend", { id, children: [
+  return /* @__PURE__ */ (0, import_jsx_runtime38.jsxs)("legend", { id, children: [
     title,
-    required && /* @__PURE__ */ (0, import_jsx_runtime36.jsx)("span", { className: "required", children: REQUIRED_FIELD_SYMBOL2 }),
-    optionalDataControl && /* @__PURE__ */ (0, import_jsx_runtime36.jsx)("span", { className: "pull-right", style: { marginBottom: "2px" }, children: optionalDataControl })
+    required && /* @__PURE__ */ (0, import_jsx_runtime38.jsx)("span", { className: "required", children: REQUIRED_FIELD_SYMBOL2 }),
+    optionalDataControl && /* @__PURE__ */ (0, import_jsx_runtime38.jsx)("span", { className: "pull-right", style: { marginBottom: "2px" }, children: optionalDataControl })
   ] });
 }
 
 // src/components/templates/UnsupportedField.tsx
-var import_utils31 = require("@rjsf/utils");
-var import_react17 = require("markdown-to-jsx/react");
-var import_jsx_runtime37 = require("react/jsx-runtime");
+var import_utils33 = require("@rjsf/utils");
+var import_react18 = require("markdown-to-jsx/react");
+var import_jsx_runtime39 = require("react/jsx-runtime");
 function UnsupportedField(props) {
   const { schema, fieldPathId, reason, registry } = props;
   const { translateString } = registry;
-  let translateEnum = import_utils31.TranslatableString.UnsupportedField;
+  let translateEnum = import_utils33.TranslatableString.UnsupportedField;
   const translateParams = [];
-  if (fieldPathId && fieldPathId.$id) {
-    translateEnum = import_utils31.TranslatableString.UnsupportedFieldWithId;
+  if (fieldPathId?.$id) {
+    translateEnum = import_utils33.TranslatableString.UnsupportedFieldWithId;
     translateParams.push(fieldPathId.$id);
   }
   if (reason) {
-    translateEnum = translateEnum === import_utils31.TranslatableString.UnsupportedField ? import_utils31.TranslatableString.UnsupportedFieldWithReason : import_utils31.TranslatableString.UnsupportedFieldWithIdAndReason;
+    translateEnum = translateEnum === import_utils33.TranslatableString.UnsupportedField ? import_utils33.TranslatableString.UnsupportedFieldWithReason : import_utils33.TranslatableString.UnsupportedFieldWithIdAndReason;
     translateParams.push(reason);
   }
-  return /* @__PURE__ */ (0, import_jsx_runtime37.jsxs)("div", { className: "unsupported-field", children: [
-    /* @__PURE__ */ (0, import_jsx_runtime37.jsx)("p", { children: /* @__PURE__ */ (0, import_jsx_runtime37.jsx)(import_react17.Markdown, { options: { disableParsingRawHTML: true }, children: translateString(translateEnum, translateParams) }) }),
-    schema && /* @__PURE__ */ (0, import_jsx_runtime37.jsx)("pre", { children: JSON.stringify(schema, null, 2) })
+  return /* @__PURE__ */ (0, import_jsx_runtime39.jsxs)("div", { className: "unsupported-field", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime39.jsx)("p", { children: /* @__PURE__ */ (0, import_jsx_runtime39.jsx)(import_react18.Markdown, { options: { disableParsingRawHTML: true }, children: translateString(translateEnum, translateParams) }) }),
+    schema && /* @__PURE__ */ (0, import_jsx_runtime39.jsx)("pre", { children: JSON.stringify(schema, null, 2) })
   ] });
 }
 var UnsupportedField_default = UnsupportedField;
 
 // src/components/templates/WrapIfAdditionalTemplate.tsx
-var import_utils32 = require("@rjsf/utils");
-var import_jsx_runtime38 = require("react/jsx-runtime");
+var import_utils34 = require("@rjsf/utils");
+var import_jsx_runtime40 = require("react/jsx-runtime");
 function WrapIfAdditionalTemplate(props) {
   const {
     id,
@@ -3384,8 +3404,8 @@ function WrapIfAdditionalTemplate(props) {
   } = props;
   const { templates: templates2, translateString } = registry;
   const { RemoveButton: RemoveButton2 } = templates2.ButtonTemplates;
-  const keyLabel = translateString(import_utils32.TranslatableString.KeyLabel, [label]);
-  const additional = import_utils32.ADDITIONAL_PROPERTY_FLAG in schema;
+  const keyLabel = translateString(import_utils34.TranslatableString.KeyLabel, [label]);
+  const additional = import_utils34.ADDITIONAL_PROPERTY_FLAG in schema;
   const hasDescription = !!rawDescription;
   const classNamesList = ["form-group", classNames];
   if (!hideError && rawErrors && rawErrors.length > 0) {
@@ -3393,14 +3413,14 @@ function WrapIfAdditionalTemplate(props) {
   }
   const uiClassNames = classNamesList.join(" ").trim();
   if (!additional) {
-    return /* @__PURE__ */ (0, import_jsx_runtime38.jsx)("div", { className: uiClassNames, style, children });
+    return /* @__PURE__ */ (0, import_jsx_runtime40.jsx)("div", { className: uiClassNames, style, children });
   }
   const margin = hasDescription ? 46 : 26;
-  return /* @__PURE__ */ (0, import_jsx_runtime38.jsx)("div", { className: uiClassNames, style, children: /* @__PURE__ */ (0, import_jsx_runtime38.jsxs)("div", { className: "row", children: [
-    /* @__PURE__ */ (0, import_jsx_runtime38.jsx)("div", { className: "col-xs-5 form-additional", children: /* @__PURE__ */ (0, import_jsx_runtime38.jsxs)("div", { className: "form-group", children: [
-      displayLabel && /* @__PURE__ */ (0, import_jsx_runtime38.jsx)(Label, { label: keyLabel, required, id: `${id}-key` }),
-      displayLabel && rawDescription && /* @__PURE__ */ (0, import_jsx_runtime38.jsx)("div", { children: "\xA0" }),
-      /* @__PURE__ */ (0, import_jsx_runtime38.jsx)(
+  return /* @__PURE__ */ (0, import_jsx_runtime40.jsx)("div", { className: uiClassNames, style, children: /* @__PURE__ */ (0, import_jsx_runtime40.jsxs)("div", { className: "row", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime40.jsx)("div", { className: "col-xs-5 form-additional", children: /* @__PURE__ */ (0, import_jsx_runtime40.jsxs)("div", { className: "form-group", children: [
+      displayLabel && /* @__PURE__ */ (0, import_jsx_runtime40.jsx)(Label, { label: keyLabel, required, id: `${id}-key` }),
+      displayLabel && rawDescription && /* @__PURE__ */ (0, import_jsx_runtime40.jsx)("div", { children: "\xA0" }),
+      /* @__PURE__ */ (0, import_jsx_runtime40.jsx)(
         "input",
         {
           className: "form-control",
@@ -3412,11 +3432,11 @@ function WrapIfAdditionalTemplate(props) {
         label
       )
     ] }) }),
-    /* @__PURE__ */ (0, import_jsx_runtime38.jsx)("div", { className: "form-additional form-group col-xs-5", children }),
-    /* @__PURE__ */ (0, import_jsx_runtime38.jsx)("div", { className: "col-xs-2", style: { marginTop: displayLabel ? `${margin}px` : void 0 }, children: /* @__PURE__ */ (0, import_jsx_runtime38.jsx)(
+    /* @__PURE__ */ (0, import_jsx_runtime40.jsx)("div", { className: "form-additional form-group col-xs-5", children }),
+    /* @__PURE__ */ (0, import_jsx_runtime40.jsx)("div", { className: "col-xs-2", style: { marginTop: displayLabel ? `${margin}px` : void 0 }, children: /* @__PURE__ */ (0, import_jsx_runtime40.jsx)(
       RemoveButton2,
       {
-        id: (0, import_utils32.buttonId)(id, "remove"),
+        id: (0, import_utils34.buttonId)(id, "remove"),
         className: "rjsf-object-property-remove btn-block",
         style: { border: "0" },
         disabled: disabled || readonly,
@@ -3438,6 +3458,7 @@ function templates() {
     ArrayFieldTitleTemplate,
     ButtonTemplates: ButtonTemplates_default(),
     BaseInputTemplate,
+    CyclicSchemaExpandTemplate,
     DescriptionFieldTemplate: DescriptionField,
     ErrorListTemplate: ErrorList,
     FallbackFieldTemplate,
@@ -3456,28 +3477,28 @@ function templates() {
 var templates_default = templates;
 
 // src/components/widgets/AltDateTimeWidget.tsx
-var import_jsx_runtime39 = require("react/jsx-runtime");
+var import_jsx_runtime41 = require("react/jsx-runtime");
 function AltDateTimeWidget({
   time = true,
   ...props
 }) {
   const { AltDateWidget: AltDateWidget2 } = props.registry.widgets;
-  return /* @__PURE__ */ (0, import_jsx_runtime39.jsx)(AltDateWidget2, { time, ...props });
+  return /* @__PURE__ */ (0, import_jsx_runtime41.jsx)(AltDateWidget2, { time, ...props });
 }
 var AltDateTimeWidget_default = AltDateTimeWidget;
 
 // src/components/widgets/AltDateWidget.tsx
-var import_utils33 = require("@rjsf/utils");
-var import_jsx_runtime40 = require("react/jsx-runtime");
+var import_utils35 = require("@rjsf/utils");
+var import_jsx_runtime42 = require("react/jsx-runtime");
 function AltDateWidget(props) {
   const { disabled = false, readonly = false, autofocus = false, options, id, name, registry, onBlur, onFocus } = props;
   const { translateString } = registry;
-  const { elements, handleChange, handleClear, handleSetNow } = (0, import_utils33.useAltDateWidgetProps)(props);
-  return /* @__PURE__ */ (0, import_jsx_runtime40.jsxs)("ul", { className: "list-inline", children: [
+  const { elements, handleChange, handleClear, handleSetNow } = (0, import_utils35.useAltDateWidgetProps)(props);
+  return /* @__PURE__ */ (0, import_jsx_runtime42.jsxs)("ul", { className: "list-inline", children: [
     elements.map((elemProps, i) => (
       // oxlint-disable-next-line react/no-array-index-key
-      /* @__PURE__ */ (0, import_jsx_runtime40.jsx)("li", { className: "list-inline-item", children: /* @__PURE__ */ (0, import_jsx_runtime40.jsx)(
-        import_utils33.DateElement,
+      /* @__PURE__ */ (0, import_jsx_runtime42.jsx)("li", { className: "list-inline-item", children: /* @__PURE__ */ (0, import_jsx_runtime42.jsx)(
+        import_utils35.DateElement,
         {
           rootId: id,
           name,
@@ -3492,16 +3513,16 @@ function AltDateWidget(props) {
         }
       ) }, i)
     )),
-    (options.hideNowButton !== "undefined" ? !options.hideNowButton : true) && /* @__PURE__ */ (0, import_jsx_runtime40.jsx)("li", { className: "list-inline-item", children: /* @__PURE__ */ (0, import_jsx_runtime40.jsx)("button", { type: "button", className: "btn btn-info btn-now", onClick: handleSetNow, children: translateString(import_utils33.TranslatableString.NowLabel) }) }),
-    (options.hideClearButton !== "undefined" ? !options.hideClearButton : true) && /* @__PURE__ */ (0, import_jsx_runtime40.jsx)("li", { className: "list-inline-item", children: /* @__PURE__ */ (0, import_jsx_runtime40.jsx)("button", { type: "button", className: "btn btn-warning btn-clear", onClick: handleClear, children: translateString(import_utils33.TranslatableString.ClearLabel) }) })
+    (options.hideNowButton !== "undefined" ? !options.hideNowButton : true) && /* @__PURE__ */ (0, import_jsx_runtime42.jsx)("li", { className: "list-inline-item", children: /* @__PURE__ */ (0, import_jsx_runtime42.jsx)("button", { type: "button", className: "btn btn-info btn-now", onClick: handleSetNow, children: translateString(import_utils35.TranslatableString.NowLabel) }) }),
+    (options.hideClearButton !== "undefined" ? !options.hideClearButton : true) && /* @__PURE__ */ (0, import_jsx_runtime42.jsx)("li", { className: "list-inline-item", children: /* @__PURE__ */ (0, import_jsx_runtime42.jsx)("button", { type: "button", className: "btn btn-warning btn-clear", onClick: handleClear, children: translateString(import_utils35.TranslatableString.ClearLabel) }) })
   ] });
 }
 var AltDateWidget_default = AltDateWidget;
 
 // src/components/widgets/CheckboxesWidget.tsx
-var import_react18 = require("react");
-var import_utils34 = require("@rjsf/utils");
-var import_jsx_runtime41 = require("react/jsx-runtime");
+var import_react19 = require("react");
+var import_utils36 = require("@rjsf/utils");
+var import_jsx_runtime43 = require("react/jsx-runtime");
 function CheckboxesWidget({
   id,
   disabled,
@@ -3515,55 +3536,55 @@ function CheckboxesWidget({
   htmlName
 }) {
   const { inline = false, enumOptions, enumDisabled, emptyValue } = options;
-  const optionValueFormat = (0, import_utils34.getOptionValueFormat)(options);
+  const optionValueFormat = (0, import_utils36.getOptionValueFormat)(options);
   const checkboxesValues = Array.isArray(value) ? value : [value];
-  const handleBlur = (0, import_react18.useCallback)(
-    ({ target }) => onBlur(id, (0, import_utils34.enumOptionValueDecoder)(target && target.value, enumOptions, optionValueFormat, emptyValue)),
+  const handleBlur = (0, import_react19.useCallback)(
+    ({ target }) => onBlur(id, (0, import_utils36.enumOptionValueDecoder)(target?.value, enumOptions, optionValueFormat, emptyValue)),
     [onBlur, id, enumOptions, emptyValue, optionValueFormat]
   );
-  const handleFocus = (0, import_react18.useCallback)(
-    ({ target }) => onFocus(id, (0, import_utils34.enumOptionValueDecoder)(target && target.value, enumOptions, optionValueFormat, emptyValue)),
+  const handleFocus = (0, import_react19.useCallback)(
+    ({ target }) => onFocus(id, (0, import_utils36.enumOptionValueDecoder)(target?.value, enumOptions, optionValueFormat, emptyValue)),
     [onFocus, id, enumOptions, emptyValue, optionValueFormat]
   );
-  return /* @__PURE__ */ (0, import_jsx_runtime41.jsx)("div", { className: "checkboxes", id, children: Array.isArray(enumOptions) && enumOptions.map((option, index) => {
-    const checked = (0, import_utils34.enumOptionsIsSelected)(option.value, checkboxesValues);
+  return /* @__PURE__ */ (0, import_jsx_runtime43.jsx)("div", { className: "checkboxes", id, children: Array.isArray(enumOptions) && enumOptions.map((option, index) => {
+    const checked = (0, import_utils36.enumOptionsIsSelected)(option.value, checkboxesValues);
     const itemDisabled = Array.isArray(enumDisabled) && enumDisabled.includes(option.value);
     const disabledCls = disabled || itemDisabled || readonly ? "disabled" : "";
     const handleChange = (event) => {
       if (event.target.checked) {
-        onChange((0, import_utils34.enumOptionsSelectValue)(index, checkboxesValues, enumOptions));
+        onChange((0, import_utils36.enumOptionsSelectValue)(index, checkboxesValues, enumOptions));
       } else {
-        onChange((0, import_utils34.enumOptionsDeselectValue)(index, checkboxesValues, enumOptions));
+        onChange((0, import_utils36.enumOptionsDeselectValue)(index, checkboxesValues, enumOptions));
       }
     };
-    const checkbox = /* @__PURE__ */ (0, import_jsx_runtime41.jsxs)("span", { children: [
-      /* @__PURE__ */ (0, import_jsx_runtime41.jsx)(
+    const checkbox = /* @__PURE__ */ (0, import_jsx_runtime43.jsxs)("span", { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime43.jsx)(
         "input",
         {
           type: "checkbox",
-          id: (0, import_utils34.optionId)(id, index),
+          id: (0, import_utils36.optionId)(id, index),
           name: htmlName || id,
           checked,
-          value: (0, import_utils34.enumOptionValueEncoder)(option.value, index, optionValueFormat),
+          value: (0, import_utils36.enumOptionValueEncoder)(option.value, index, optionValueFormat),
           disabled: disabled || itemDisabled || readonly,
           autoFocus: autofocus && index === 0,
           onChange: handleChange,
           onBlur: handleBlur,
           onFocus: handleFocus,
-          "aria-describedby": (0, import_utils34.ariaDescribedByIds)(id)
+          "aria-describedby": (0, import_utils36.ariaDescribedByIds)(id)
         }
       ),
-      /* @__PURE__ */ (0, import_jsx_runtime41.jsx)("span", { children: option.label })
+      /* @__PURE__ */ (0, import_jsx_runtime43.jsx)("span", { children: option.label })
     ] });
-    return inline ? /* @__PURE__ */ (0, import_jsx_runtime41.jsx)("label", { className: `checkbox-inline ${disabledCls}`, children: checkbox }, String(option.value)) : /* @__PURE__ */ (0, import_jsx_runtime41.jsx)("div", { className: `checkbox ${disabledCls}`, children: /* @__PURE__ */ (0, import_jsx_runtime41.jsx)("label", { children: checkbox }) }, String(option.value));
+    return inline ? /* @__PURE__ */ (0, import_jsx_runtime43.jsx)("label", { className: `checkbox-inline ${disabledCls}`, children: checkbox }, String(option.value)) : /* @__PURE__ */ (0, import_jsx_runtime43.jsx)("div", { className: `checkbox ${disabledCls}`, children: /* @__PURE__ */ (0, import_jsx_runtime43.jsx)("label", { children: checkbox }) }, String(option.value));
   }) });
 }
 var CheckboxesWidget_default = CheckboxesWidget;
 
 // src/components/widgets/CheckboxWidget.tsx
-var import_react19 = require("react");
-var import_utils35 = require("@rjsf/utils");
-var import_jsx_runtime42 = require("react/jsx-runtime");
+var import_react20 = require("react");
+var import_utils37 = require("@rjsf/utils");
+var import_jsx_runtime44 = require("react/jsx-runtime");
 function CheckboxWidget({
   schema,
   uiSchema,
@@ -3581,40 +3602,40 @@ function CheckboxWidget({
   registry,
   htmlName
 }) {
-  const DescriptionFieldTemplate = (0, import_utils35.getTemplate)(
+  const DescriptionFieldTemplate = (0, import_utils37.getTemplate)(
     "DescriptionFieldTemplate",
     registry,
     options
   );
-  const required = (0, import_utils35.schemaRequiresTrueValue)(schema);
-  const handleChange = (0, import_react19.useCallback)(
+  const required = (0, import_utils37.schemaRequiresTrueValue)(schema);
+  const handleChange = (0, import_react20.useCallback)(
     (event) => onChange(event.target.checked),
     [onChange]
   );
-  const handleBlur = (0, import_react19.useCallback)(
+  const handleBlur = (0, import_react20.useCallback)(
     (event) => onBlur(id, event.target.checked),
     [onBlur, id]
   );
-  const handleFocus = (0, import_react19.useCallback)(
+  const handleFocus = (0, import_react20.useCallback)(
     (event) => onFocus(id, event.target.checked),
     [onFocus, id]
   );
-  const uiOptions = (0, import_utils35.getUiOptions)(uiSchema);
+  const uiOptions = (0, import_utils37.getUiOptions)(uiSchema);
   const isCheckboxWidget = uiOptions.widget === "checkbox";
   const description = isCheckboxWidget ? void 0 : options.description ?? schema.description;
-  return /* @__PURE__ */ (0, import_jsx_runtime42.jsxs)("div", { className: `checkbox ${disabled || readonly ? "disabled" : ""}`, children: [
-    !hideLabel && description && /* @__PURE__ */ (0, import_jsx_runtime42.jsx)(
+  return /* @__PURE__ */ (0, import_jsx_runtime44.jsxs)("div", { className: `checkbox ${disabled || readonly ? "disabled" : ""}`, children: [
+    !hideLabel && description && /* @__PURE__ */ (0, import_jsx_runtime44.jsx)(
       DescriptionFieldTemplate,
       {
-        id: (0, import_utils35.descriptionId)(id),
+        id: (0, import_utils37.descriptionId)(id),
         description,
         schema,
         uiSchema,
         registry
       }
     ),
-    /* @__PURE__ */ (0, import_jsx_runtime42.jsxs)("label", { children: [
-      /* @__PURE__ */ (0, import_jsx_runtime42.jsx)(
+    /* @__PURE__ */ (0, import_jsx_runtime44.jsxs)("label", { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime44.jsx)(
         "input",
         {
           type: "checkbox",
@@ -3627,65 +3648,65 @@ function CheckboxWidget({
           onChange: handleChange,
           onBlur: handleBlur,
           onFocus: handleFocus,
-          "aria-describedby": (0, import_utils35.ariaDescribedByIds)(id)
+          "aria-describedby": (0, import_utils37.ariaDescribedByIds)(id)
         }
       ),
-      (0, import_utils35.labelValue)(/* @__PURE__ */ (0, import_jsx_runtime42.jsx)("span", { children: label }), hideLabel)
+      (0, import_utils37.labelValue)(/* @__PURE__ */ (0, import_jsx_runtime44.jsx)("span", { children: label }), hideLabel)
     ] })
   ] });
 }
 var CheckboxWidget_default = CheckboxWidget;
 
 // src/components/widgets/ColorWidget.tsx
-var import_utils36 = require("@rjsf/utils");
-var import_jsx_runtime43 = require("react/jsx-runtime");
+var import_utils38 = require("@rjsf/utils");
+var import_jsx_runtime45 = require("react/jsx-runtime");
 function ColorWidget(props) {
   const { disabled, readonly, options, registry } = props;
-  const BaseInputTemplate2 = (0, import_utils36.getTemplate)("BaseInputTemplate", registry, options);
-  return /* @__PURE__ */ (0, import_jsx_runtime43.jsx)(BaseInputTemplate2, { type: "color", ...props, disabled: disabled || readonly });
+  const BaseInputTemplate2 = (0, import_utils38.getTemplate)("BaseInputTemplate", registry, options);
+  return /* @__PURE__ */ (0, import_jsx_runtime45.jsx)(BaseInputTemplate2, { type: "color", ...props, disabled: disabled || readonly });
 }
 
 // src/components/widgets/DateTimeWidget.tsx
-var import_utils37 = require("@rjsf/utils");
-var import_jsx_runtime44 = require("react/jsx-runtime");
+var import_utils39 = require("@rjsf/utils");
+var import_jsx_runtime46 = require("react/jsx-runtime");
 function DateTimeWidget(props) {
   const { onChange, value, options, registry } = props;
-  const BaseInputTemplate2 = (0, import_utils37.getTemplate)("BaseInputTemplate", registry, options);
-  return /* @__PURE__ */ (0, import_jsx_runtime44.jsx)(
+  const BaseInputTemplate2 = (0, import_utils39.getTemplate)("BaseInputTemplate", registry, options);
+  return /* @__PURE__ */ (0, import_jsx_runtime46.jsx)(
     BaseInputTemplate2,
     {
       type: "datetime-local",
       ...props,
-      value: (0, import_utils37.utcToLocal)(value),
-      onChange: (newValue) => onChange((0, import_utils37.localToUTC)(newValue))
+      value: (0, import_utils39.utcToLocal)(value),
+      onChange: (newValue) => onChange((0, import_utils39.localToUTC)(newValue))
     }
   );
 }
 
 // src/components/widgets/DateWidget.tsx
-var import_react20 = require("react");
-var import_utils38 = require("@rjsf/utils");
-var import_jsx_runtime45 = require("react/jsx-runtime");
+var import_react21 = require("react");
+var import_utils40 = require("@rjsf/utils");
+var import_jsx_runtime47 = require("react/jsx-runtime");
 function DateWidget(props) {
   const { onChange, options, registry } = props;
-  const BaseInputTemplate2 = (0, import_utils38.getTemplate)("BaseInputTemplate", registry, options);
-  const handleChange = (0, import_react20.useCallback)((value) => onChange(value || void 0), [onChange]);
-  return /* @__PURE__ */ (0, import_jsx_runtime45.jsx)(BaseInputTemplate2, { type: "date", ...props, onChange: handleChange });
+  const BaseInputTemplate2 = (0, import_utils40.getTemplate)("BaseInputTemplate", registry, options);
+  const handleChange = (0, import_react21.useCallback)((value) => onChange(value || void 0), [onChange]);
+  return /* @__PURE__ */ (0, import_jsx_runtime47.jsx)(BaseInputTemplate2, { type: "date", ...props, onChange: handleChange });
 }
 
 // src/components/widgets/EmailWidget.tsx
-var import_utils39 = require("@rjsf/utils");
-var import_jsx_runtime46 = require("react/jsx-runtime");
+var import_utils41 = require("@rjsf/utils");
+var import_jsx_runtime48 = require("react/jsx-runtime");
 function EmailWidget(props) {
   const { options, registry } = props;
-  const BaseInputTemplate2 = (0, import_utils39.getTemplate)("BaseInputTemplate", registry, options);
-  return /* @__PURE__ */ (0, import_jsx_runtime46.jsx)(BaseInputTemplate2, { type: "email", ...props });
+  const BaseInputTemplate2 = (0, import_utils41.getTemplate)("BaseInputTemplate", registry, options);
+  return /* @__PURE__ */ (0, import_jsx_runtime48.jsx)(BaseInputTemplate2, { type: "email", ...props });
 }
 
 // src/components/widgets/FileWidget.tsx
-var import_utils40 = require("@rjsf/utils");
-var import_react21 = require("markdown-to-jsx/react");
-var import_jsx_runtime47 = require("react/jsx-runtime");
+var import_utils42 = require("@rjsf/utils");
+var import_react22 = require("markdown-to-jsx/react");
+var import_jsx_runtime49 = require("react/jsx-runtime");
 function FileInfoPreview({
   fileInfo,
   registry
@@ -3695,13 +3716,13 @@ function FileInfoPreview({
   if (!dataURL) {
     return null;
   }
-  const previewLabel = translateString(import_utils40.TranslatableString.PreviewLabel);
+  const previewLabel = translateString(import_utils42.TranslatableString.PreviewLabel);
   if (["image/jpeg", "image/png"].includes(type)) {
-    return /* @__PURE__ */ (0, import_jsx_runtime47.jsx)("img", { src: dataURL, alt: previewLabel, style: { maxWidth: "100%" }, className: "file-preview" });
+    return /* @__PURE__ */ (0, import_jsx_runtime49.jsx)("img", { src: dataURL, alt: previewLabel, style: { maxWidth: "100%" }, className: "file-preview" });
   }
-  return /* @__PURE__ */ (0, import_jsx_runtime47.jsxs)(import_jsx_runtime47.Fragment, { children: [
+  return /* @__PURE__ */ (0, import_jsx_runtime49.jsxs)(import_jsx_runtime49.Fragment, { children: [
     " ",
-    /* @__PURE__ */ (0, import_jsx_runtime47.jsx)("a", { download: `preview-${name}`, href: dataURL, className: "file-download", children: previewLabel })
+    /* @__PURE__ */ (0, import_jsx_runtime49.jsx)("a", { download: `preview-${name}`, href: dataURL, className: "file-download", children: previewLabel })
   ] });
 }
 function FilesInfo({
@@ -3715,31 +3736,31 @@ function FilesInfo({
     return null;
   }
   const { translateString } = registry;
-  const { RemoveButton: RemoveButton2 } = (0, import_utils40.getTemplate)("ButtonTemplates", registry, options);
-  return /* @__PURE__ */ (0, import_jsx_runtime47.jsx)("ul", { className: "file-info", children: filesInfo.map((fileInfo, key) => {
+  const { RemoveButton: RemoveButton2 } = (0, import_utils42.getTemplate)("ButtonTemplates", registry, options);
+  return /* @__PURE__ */ (0, import_jsx_runtime49.jsx)("ul", { className: "file-info", children: filesInfo.map((fileInfo, key) => {
     const { name, size, type } = fileInfo;
     const handleRemove = () => onRemove(key);
     return (
       // oxlint-disable-next-line react/no-array-index-key
-      /* @__PURE__ */ (0, import_jsx_runtime47.jsxs)("li", { children: [
-        /* @__PURE__ */ (0, import_jsx_runtime47.jsx)(import_react21.Markdown, { children: translateString(import_utils40.TranslatableString.FilesInfo, [name, type, String(size)]) }),
-        preview && /* @__PURE__ */ (0, import_jsx_runtime47.jsx)(FileInfoPreview, { fileInfo, registry }),
-        /* @__PURE__ */ (0, import_jsx_runtime47.jsx)(RemoveButton2, { onClick: handleRemove, registry })
+      /* @__PURE__ */ (0, import_jsx_runtime49.jsxs)("li", { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(import_react22.Markdown, { children: translateString(import_utils42.TranslatableString.FilesInfo, [name, type, String(size)]) }),
+        preview && /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(FileInfoPreview, { fileInfo, registry }),
+        /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(RemoveButton2, { onClick: handleRemove, registry })
       ] }, key)
     );
   }) });
 }
 function FileWidget(props) {
   const { disabled, readonly, required, multiple, onChange, value, options, registry } = props;
-  const { filesInfo, handleChange, handleRemove } = (0, import_utils40.useFileWidgetProps)(value, onChange, multiple);
-  const BaseInputTemplate2 = (0, import_utils40.getTemplate)("BaseInputTemplate", registry, options);
+  const { filesInfo, handleChange, handleRemove } = (0, import_utils42.useFileWidgetProps)(value, onChange, multiple);
+  const BaseInputTemplate2 = (0, import_utils42.getTemplate)("BaseInputTemplate", registry, options);
   const handleOnChangeEvent = (event) => {
     if (event.target.files) {
       void handleChange(event.target.files);
     }
   };
-  return /* @__PURE__ */ (0, import_jsx_runtime47.jsxs)("div", { children: [
-    /* @__PURE__ */ (0, import_jsx_runtime47.jsx)(
+  return /* @__PURE__ */ (0, import_jsx_runtime49.jsxs)("div", { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(
       BaseInputTemplate2,
       {
         ...props,
@@ -3751,7 +3772,7 @@ function FileWidget(props) {
         accept: options.accept ? String(options.accept) : void 0
       }
     ),
-    /* @__PURE__ */ (0, import_jsx_runtime47.jsx)(
+    /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(
       FilesInfo,
       {
         filesInfo,
@@ -3766,29 +3787,29 @@ function FileWidget(props) {
 var FileWidget_default = FileWidget;
 
 // src/components/widgets/HiddenWidget.tsx
-var import_jsx_runtime48 = require("react/jsx-runtime");
+var import_jsx_runtime50 = require("react/jsx-runtime");
 function HiddenWidget({
   id,
   value,
   htmlName
 }) {
-  return /* @__PURE__ */ (0, import_jsx_runtime48.jsx)("input", { type: "hidden", id, name: htmlName || id, value: typeof value === "undefined" ? "" : value });
+  return /* @__PURE__ */ (0, import_jsx_runtime50.jsx)("input", { type: "hidden", id, name: htmlName || id, value: typeof value === "undefined" ? "" : value });
 }
 var HiddenWidget_default = HiddenWidget;
 
 // src/components/widgets/PasswordWidget.tsx
-var import_utils41 = require("@rjsf/utils");
-var import_jsx_runtime49 = require("react/jsx-runtime");
+var import_utils43 = require("@rjsf/utils");
+var import_jsx_runtime51 = require("react/jsx-runtime");
 function PasswordWidget(props) {
   const { options, registry } = props;
-  const BaseInputTemplate2 = (0, import_utils41.getTemplate)("BaseInputTemplate", registry, options);
-  return /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(BaseInputTemplate2, { type: "password", ...props });
+  const BaseInputTemplate2 = (0, import_utils43.getTemplate)("BaseInputTemplate", registry, options);
+  return /* @__PURE__ */ (0, import_jsx_runtime51.jsx)(BaseInputTemplate2, { type: "password", ...props });
 }
 
 // src/components/widgets/RadioWidget.tsx
-var import_react22 = require("react");
-var import_utils42 = require("@rjsf/utils");
-var import_jsx_runtime50 = require("react/jsx-runtime");
+var import_react23 = require("react");
+var import_utils44 = require("@rjsf/utils");
+var import_jsx_runtime52 = require("react/jsx-runtime");
 function RadioWidget({
   options,
   value,
@@ -3803,47 +3824,47 @@ function RadioWidget({
   htmlName
 }) {
   const { enumOptions, enumDisabled, inline, emptyValue } = options;
-  const optionValueFormat = (0, import_utils42.getOptionValueFormat)(options);
-  const handleBlur = (0, import_react22.useCallback)(
-    ({ target }) => onBlur(id, (0, import_utils42.enumOptionValueDecoder)(target && target.value, enumOptions, optionValueFormat, emptyValue)),
+  const optionValueFormat = (0, import_utils44.getOptionValueFormat)(options);
+  const handleBlur = (0, import_react23.useCallback)(
+    ({ target }) => onBlur(id, (0, import_utils44.enumOptionValueDecoder)(target?.value, enumOptions, optionValueFormat, emptyValue)),
     [onBlur, enumOptions, emptyValue, id, optionValueFormat]
   );
-  const handleFocus = (0, import_react22.useCallback)(
-    ({ target }) => onFocus(id, (0, import_utils42.enumOptionValueDecoder)(target && target.value, enumOptions, optionValueFormat, emptyValue)),
+  const handleFocus = (0, import_react23.useCallback)(
+    ({ target }) => onFocus(id, (0, import_utils44.enumOptionValueDecoder)(target?.value, enumOptions, optionValueFormat, emptyValue)),
     [onFocus, enumOptions, emptyValue, id, optionValueFormat]
   );
-  return /* @__PURE__ */ (0, import_jsx_runtime50.jsx)("div", { className: "field-radio-group", id, role: "radiogroup", children: Array.isArray(enumOptions) && enumOptions.map((option, i) => {
-    const checked = (0, import_utils42.enumOptionsIsSelected)(option.value, value);
+  return /* @__PURE__ */ (0, import_jsx_runtime52.jsx)("div", { className: "field-radio-group", id, role: "radiogroup", children: Array.isArray(enumOptions) && enumOptions.map((option, i) => {
+    const checked = (0, import_utils44.enumOptionsIsSelected)(option.value, value);
     const itemDisabled = Array.isArray(enumDisabled) && enumDisabled.includes(option.value);
     const disabledCls = disabled || itemDisabled || readonly ? "disabled" : "";
     const handleChange = () => onChange(option.value);
-    const radio = /* @__PURE__ */ (0, import_jsx_runtime50.jsxs)("span", { children: [
-      /* @__PURE__ */ (0, import_jsx_runtime50.jsx)(
+    const radio = /* @__PURE__ */ (0, import_jsx_runtime52.jsxs)("span", { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime52.jsx)(
         "input",
         {
           type: "radio",
-          id: (0, import_utils42.optionId)(id, i),
+          id: (0, import_utils44.optionId)(id, i),
           checked,
           name: htmlName || id,
           required,
-          value: (0, import_utils42.enumOptionValueEncoder)(option.value, i, optionValueFormat),
+          value: (0, import_utils44.enumOptionValueEncoder)(option.value, i, optionValueFormat),
           disabled: disabled || itemDisabled || readonly,
           autoFocus: autofocus && i === 0,
           onChange: handleChange,
           onBlur: handleBlur,
           onFocus: handleFocus,
-          "aria-describedby": (0, import_utils42.ariaDescribedByIds)(id)
+          "aria-describedby": (0, import_utils44.ariaDescribedByIds)(id)
         }
       ),
-      /* @__PURE__ */ (0, import_jsx_runtime50.jsx)("span", { children: option.label })
+      /* @__PURE__ */ (0, import_jsx_runtime52.jsx)("span", { children: option.label })
     ] });
-    return inline ? /* @__PURE__ */ (0, import_jsx_runtime50.jsx)("label", { className: `radio-inline ${disabledCls}`, children: radio }, String(option.value)) : /* @__PURE__ */ (0, import_jsx_runtime50.jsx)("div", { className: `radio ${disabledCls}`, children: /* @__PURE__ */ (0, import_jsx_runtime50.jsx)("label", { children: radio }) }, String(option.value));
+    return inline ? /* @__PURE__ */ (0, import_jsx_runtime52.jsx)("label", { className: `radio-inline ${disabledCls}`, children: radio }, String(option.value)) : /* @__PURE__ */ (0, import_jsx_runtime52.jsx)("div", { className: `radio ${disabledCls}`, children: /* @__PURE__ */ (0, import_jsx_runtime52.jsx)("label", { children: radio }) }, String(option.value));
   }) });
 }
 var RadioWidget_default = RadioWidget;
 
 // src/components/widgets/RangeWidget.tsx
-var import_jsx_runtime51 = require("react/jsx-runtime");
+var import_jsx_runtime53 = require("react/jsx-runtime");
 function RangeWidget(props) {
   const {
     value,
@@ -3851,15 +3872,15 @@ function RangeWidget(props) {
       templates: { BaseInputTemplate: BaseInputTemplate2 }
     }
   } = props;
-  return /* @__PURE__ */ (0, import_jsx_runtime51.jsxs)("div", { className: "field-range-wrapper", children: [
-    /* @__PURE__ */ (0, import_jsx_runtime51.jsx)(BaseInputTemplate2, { type: "range", ...props }),
-    /* @__PURE__ */ (0, import_jsx_runtime51.jsx)("span", { className: "range-view", children: value })
+  return /* @__PURE__ */ (0, import_jsx_runtime53.jsxs)("div", { className: "field-range-wrapper", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime53.jsx)(BaseInputTemplate2, { type: "range", ...props }),
+    /* @__PURE__ */ (0, import_jsx_runtime53.jsx)("span", { className: "range-view", children: value })
   ] });
 }
 
 // src/components/widgets/RatingWidget.tsx
-var import_react23 = require("react");
-var import_jsx_runtime52 = require("react/jsx-runtime");
+var import_react24 = require("react");
+var import_jsx_runtime54 = require("react/jsx-runtime");
 function RatingWidget({
   id,
   value,
@@ -3877,7 +3898,7 @@ function RatingWidget({
   const { stars = 5, shape = "star" } = options;
   const numStars = schema.maximum ? Math.min(schema.maximum, 5) : Math.min(Math.max(stars, 1), 5);
   const min = schema.minimum || 0;
-  const handleStarClick = (0, import_react23.useCallback)(
+  const handleStarClick = (0, import_react24.useCallback)(
     (starValue) => {
       if (!disabled && !readonly) {
         onChange(starValue);
@@ -3885,7 +3906,7 @@ function RatingWidget({
     },
     [onChange, disabled, readonly]
   );
-  const handleFocus = (0, import_react23.useCallback)(
+  const handleFocus = (0, import_react24.useCallback)(
     (event) => {
       if (onFocus) {
         const starValue = Number(event.target.dataset.value);
@@ -3894,7 +3915,7 @@ function RatingWidget({
     },
     [onFocus, id]
   );
-  const handleBlur = (0, import_react23.useCallback)(
+  const handleBlur = (0, import_react24.useCallback)(
     (event) => {
       if (onBlur) {
         const starValue = Number(event.target.dataset.value);
@@ -3909,7 +3930,7 @@ function RatingWidget({
     }
     return isFilled ? "\u2605" : "\u2606";
   };
-  return /* @__PURE__ */ (0, import_jsx_runtime52.jsxs)(
+  return /* @__PURE__ */ (0, import_jsx_runtime54.jsxs)(
     "div",
     {
       className: "rating-widget",
@@ -3922,7 +3943,7 @@ function RatingWidget({
         [...Array(numStars)].map((_, index) => {
           const starValue = min + index;
           const isFilled = starValue <= value;
-          return /* @__PURE__ */ (0, import_jsx_runtime52.jsx)(
+          return /* @__PURE__ */ (0, import_jsx_runtime54.jsx)(
             "span",
             {
               onClick: () => handleStarClick(starValue),
@@ -3945,7 +3966,7 @@ function RatingWidget({
             index
           );
         }),
-        /* @__PURE__ */ (0, import_jsx_runtime52.jsx)(
+        /* @__PURE__ */ (0, import_jsx_runtime54.jsx)(
           "input",
           {
             type: "hidden",
@@ -3963,12 +3984,9 @@ function RatingWidget({
 }
 
 // src/components/widgets/SelectWidget.tsx
-var import_react24 = require("react");
-var import_utils43 = require("@rjsf/utils");
-var import_jsx_runtime53 = (
-  // oxlint-disable-next-line jsx-a11y/no-autofocus
-  require("react/jsx-runtime")
-);
+var import_react25 = require("react");
+var import_utils45 = require("@rjsf/utils");
+var import_jsx_runtime55 = require("react/jsx-runtime");
 function getValue(event, multiple) {
   if (multiple) {
     return Array.from(event.target.options).slice().filter((o) => o.selected).map((o) => o.value);
@@ -3989,76 +4007,92 @@ function SelectWidget({
   onBlur,
   onFocus,
   placeholder,
-  htmlName
+  htmlName,
+  registry,
+  uiSchema
 }) {
   const { enumOptions, enumDisabled, emptyValue: optEmptyVal } = options;
   const emptyValue = multiple ? [] : "";
-  const optionValueFormat = (0, import_utils43.getOptionValueFormat)(options);
-  const handleFocus = (0, import_react24.useCallback)(
+  const optionValueFormat = (0, import_utils45.getOptionValueFormat)(options);
+  const handleFocus = (0, import_react25.useCallback)(
     (event) => {
       const newValue = getValue(event, multiple);
-      return onFocus(id, (0, import_utils43.enumOptionValueDecoder)(newValue, enumOptions, optionValueFormat, optEmptyVal));
+      return onFocus(id, (0, import_utils45.enumOptionValueDecoder)(newValue, enumOptions, optionValueFormat, optEmptyVal));
     },
     [onFocus, id, multiple, enumOptions, optEmptyVal, optionValueFormat]
   );
-  const handleBlur = (0, import_react24.useCallback)(
+  const handleBlur = (0, import_react25.useCallback)(
     (event) => {
       const newValue = getValue(event, multiple);
-      return onBlur(id, (0, import_utils43.enumOptionValueDecoder)(newValue, enumOptions, optionValueFormat, optEmptyVal));
+      return onBlur(id, (0, import_utils45.enumOptionValueDecoder)(newValue, enumOptions, optionValueFormat, optEmptyVal));
     },
     [onBlur, id, multiple, enumOptions, optEmptyVal, optionValueFormat]
   );
-  const handleChange = (0, import_react24.useCallback)(
+  const handleChange = (0, import_react25.useCallback)(
     (event) => {
       const newValue = getValue(event, multiple);
-      return onChange((0, import_utils43.enumOptionValueDecoder)(newValue, enumOptions, optionValueFormat, optEmptyVal));
+      return onChange((0, import_utils45.enumOptionValueDecoder)(newValue, enumOptions, optionValueFormat, optEmptyVal));
     },
     [onChange, multiple, enumOptions, optEmptyVal, optionValueFormat]
   );
-  const selectValue = (0, import_utils43.enumOptionSelectedValue)(value, enumOptions, multiple, optionValueFormat, emptyValue);
+  const selectValue = (0, import_utils45.enumOptionSelectedValue)(value, enumOptions, multiple, optionValueFormat, emptyValue);
   const showPlaceholderOption = !multiple && schema.default === void 0;
-  return /* @__PURE__ */ (0, import_jsx_runtime53.jsxs)(
-    "select",
-    {
-      id,
-      name: htmlName || id,
-      multiple,
-      className: "form-control",
-      value: selectValue,
-      required,
-      disabled: disabled || readonly,
-      autoFocus: autofocus,
-      onBlur: handleBlur,
-      onFocus: handleFocus,
-      onChange: handleChange,
-      "aria-describedby": (0, import_utils43.ariaDescribedByIds)(id),
-      children: [
-        showPlaceholderOption && /* @__PURE__ */ (0, import_jsx_runtime53.jsx)("option", { value: "", children: placeholder }),
-        Array.isArray(enumOptions) && enumOptions.map(({ value: enumValue, label: enumLabel }, i) => {
-          const isDisabled = enumDisabled && enumDisabled.includes(enumValue);
-          return /* @__PURE__ */ (0, import_jsx_runtime53.jsx)(
-            "option",
-            {
-              value: (0, import_utils43.enumOptionValueEncoder)(enumValue, i, optionValueFormat),
-              disabled: isDisabled,
-              children: enumLabel
-            },
-            String(enumValue)
-          );
-        })
-      ]
-    }
-  );
+  (0, import_utils45.logUnsupportedDefaultForEnum)(id, schema, enumOptions, multiple);
+  return /* @__PURE__ */ (0, import_jsx_runtime55.jsxs)(import_jsx_runtime55.Fragment, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime55.jsx)(
+      import_utils45.SelectedOptionDescription,
+      {
+        id,
+        multiple,
+        options,
+        registry,
+        uiSchema,
+        value
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime55.jsxs)(
+      "select",
+      {
+        id,
+        name: htmlName || id,
+        multiple,
+        className: "form-control",
+        value: selectValue,
+        required,
+        disabled: disabled || readonly,
+        autoFocus: autofocus,
+        onBlur: handleBlur,
+        onFocus: handleFocus,
+        onChange: handleChange,
+        "aria-describedby": (0, import_utils45.ariaDescribedByIds)(id),
+        children: [
+          showPlaceholderOption && /* @__PURE__ */ (0, import_jsx_runtime55.jsx)("option", { value: "", children: placeholder }),
+          Array.isArray(enumOptions) && enumOptions.map(({ value: enumValue, label: enumLabel }, i) => {
+            const isDisabled = enumDisabled && enumDisabled.includes(enumValue);
+            return /* @__PURE__ */ (0, import_jsx_runtime55.jsx)(
+              "option",
+              {
+                value: (0, import_utils45.enumOptionValueEncoder)(enumValue, i, optionValueFormat),
+                disabled: isDisabled,
+                children: enumLabel
+              },
+              String(enumValue)
+            );
+          })
+        ]
+      }
+    )
+  ] });
 }
 var SelectWidget_default = SelectWidget;
 
 // src/components/widgets/TextareaWidget.tsx
-var import_react25 = require("react");
-var import_utils44 = require("@rjsf/utils");
-var import_jsx_runtime54 = require("react/jsx-runtime");
+var import_react26 = require("react");
+var import_utils46 = require("@rjsf/utils");
+var import_jsx_runtime56 = require("react/jsx-runtime");
 function TextareaWidget({
   id,
-  options = {},
+  options,
   placeholder,
   value,
   required,
@@ -4070,19 +4104,19 @@ function TextareaWidget({
   onFocus,
   htmlName
 }) {
-  const handleChange = (0, import_react25.useCallback)(
+  const handleChange = (0, import_react26.useCallback)(
     ({ target: { value: newValue } }) => onChange(newValue === "" ? options.emptyValue : newValue),
     [onChange, options.emptyValue]
   );
-  const handleBlur = (0, import_react25.useCallback)(
-    ({ target }) => onBlur(id, target && target.value),
+  const handleBlur = (0, import_react26.useCallback)(
+    ({ target }) => onBlur(id, target?.value),
     [onBlur, id]
   );
-  const handleFocus = (0, import_react25.useCallback)(
-    ({ target }) => onFocus(id, target && target.value),
+  const handleFocus = (0, import_react26.useCallback)(
+    ({ target }) => onFocus(id, target?.value),
     [id, onFocus]
   );
-  return /* @__PURE__ */ (0, import_jsx_runtime54.jsx)(
+  return /* @__PURE__ */ (0, import_jsx_runtime56.jsx)(
     "textarea",
     {
       id,
@@ -4098,48 +4132,48 @@ function TextareaWidget({
       onBlur: handleBlur,
       onFocus: handleFocus,
       onChange: handleChange,
-      "aria-describedby": (0, import_utils44.ariaDescribedByIds)(id)
+      "aria-describedby": (0, import_utils46.ariaDescribedByIds)(id)
     }
   );
 }
 var TextareaWidget_default = TextareaWidget;
 
 // src/components/widgets/TextWidget.tsx
-var import_utils45 = require("@rjsf/utils");
-var import_jsx_runtime55 = require("react/jsx-runtime");
+var import_utils47 = require("@rjsf/utils");
+var import_jsx_runtime57 = require("react/jsx-runtime");
 function TextWidget(props) {
   const { options, registry } = props;
-  const BaseInputTemplate2 = (0, import_utils45.getTemplate)("BaseInputTemplate", registry, options);
-  return /* @__PURE__ */ (0, import_jsx_runtime55.jsx)(BaseInputTemplate2, { ...props });
+  const BaseInputTemplate2 = (0, import_utils47.getTemplate)("BaseInputTemplate", registry, options);
+  return /* @__PURE__ */ (0, import_jsx_runtime57.jsx)(BaseInputTemplate2, { ...props });
 }
 
 // src/components/widgets/TimeWidget.tsx
-var import_react26 = require("react");
-var import_utils46 = require("@rjsf/utils");
-var import_jsx_runtime56 = require("react/jsx-runtime");
+var import_react27 = require("react");
+var import_utils48 = require("@rjsf/utils");
+var import_jsx_runtime58 = require("react/jsx-runtime");
 function TimeWidget(props) {
   const { onChange, options, registry } = props;
-  const BaseInputTemplate2 = (0, import_utils46.getTemplate)("BaseInputTemplate", registry, options);
-  const handleChange = (0, import_react26.useCallback)((value) => onChange(value ? `${value}:00` : void 0), [onChange]);
-  return /* @__PURE__ */ (0, import_jsx_runtime56.jsx)(BaseInputTemplate2, { type: "time", ...props, onChange: handleChange });
+  const BaseInputTemplate2 = (0, import_utils48.getTemplate)("BaseInputTemplate", registry, options);
+  const handleChange = (0, import_react27.useCallback)((value) => onChange(value ? `${value}:00` : void 0), [onChange]);
+  return /* @__PURE__ */ (0, import_jsx_runtime58.jsx)(BaseInputTemplate2, { type: "time", ...props, onChange: handleChange });
 }
 
 // src/components/widgets/UpDownWidget.tsx
-var import_utils47 = require("@rjsf/utils");
-var import_jsx_runtime57 = require("react/jsx-runtime");
+var import_utils49 = require("@rjsf/utils");
+var import_jsx_runtime59 = require("react/jsx-runtime");
 function UpDownWidget(props) {
   const { options, registry } = props;
-  const BaseInputTemplate2 = (0, import_utils47.getTemplate)("BaseInputTemplate", registry, options);
-  return /* @__PURE__ */ (0, import_jsx_runtime57.jsx)(BaseInputTemplate2, { type: "number", ...props });
+  const BaseInputTemplate2 = (0, import_utils49.getTemplate)("BaseInputTemplate", registry, options);
+  return /* @__PURE__ */ (0, import_jsx_runtime59.jsx)(BaseInputTemplate2, { type: "number", ...props });
 }
 
 // src/components/widgets/URLWidget.tsx
-var import_utils48 = require("@rjsf/utils");
-var import_jsx_runtime58 = require("react/jsx-runtime");
+var import_utils50 = require("@rjsf/utils");
+var import_jsx_runtime60 = require("react/jsx-runtime");
 function URLWidget(props) {
   const { options, registry } = props;
-  const BaseInputTemplate2 = (0, import_utils48.getTemplate)("BaseInputTemplate", registry, options);
-  return /* @__PURE__ */ (0, import_jsx_runtime58.jsx)(BaseInputTemplate2, { type: "url", ...props });
+  const BaseInputTemplate2 = (0, import_utils50.getTemplate)("BaseInputTemplate", registry, options);
+  return /* @__PURE__ */ (0, import_jsx_runtime60.jsx)(BaseInputTemplate2, { type: "url", ...props });
 }
 
 // src/components/widgets/index.ts
@@ -4177,24 +4211,24 @@ function getDefaultRegistry() {
     widgets: widgets_default(),
     rootSchema: {},
     formContext: {},
-    translateString: import_utils49.englishStringTranslator,
+    translateString: import_utils51.englishStringTranslator,
     globalFormOptions: {
-      idPrefix: import_utils49.DEFAULT_ID_PREFIX,
-      idSeparator: import_utils49.DEFAULT_ID_SEPARATOR,
+      idPrefix: import_utils51.DEFAULT_ID_PREFIX,
+      idSeparator: import_utils51.DEFAULT_ID_SEPARATOR,
       useFallbackUiForUnsupportedType: false
     }
   };
 }
 
 // src/components/Form.tsx
-var import_jsx_runtime59 = require("react/jsx-runtime");
+var import_jsx_runtime61 = require("react/jsx-runtime");
 function toIChangeEvent(state, status) {
   return {
     ...(0, import_pick.default)(state, ["schema", "uiSchema", "fieldPathId", "schemaUtils", "formData", "edit", "errors", "errorSchema"]),
     ...status !== void 0 && { status }
   };
 }
-var Form = class _Form extends import_react27.Component {
+var Form = class _Form extends import_react28.Component {
   /** The ref used to hold the `form` element, this needs to be `any` because `tagName` or `_internalFormWrapper` can
    * provide any possible type here
    */
@@ -4221,10 +4255,10 @@ var Form = class _Form extends import_react27.Component {
       };
       let { errors, errorSchema } = baseErrors;
       if (props.extraErrors) {
-        ({ errors, errorSchema } = (0, import_utils50.validationDataMerge)(baseErrors, props.extraErrors));
+        ({ errors, errorSchema } = (0, import_utils52.validationDataMerge)(baseErrors, props.extraErrors));
       }
       if (state.customErrors) {
-        ({ errors, errorSchema } = (0, import_utils50.validationDataMerge)(
+        ({ errors, errorSchema } = (0, import_utils52.validationDataMerge)(
           { errors, errorSchema },
           state.customErrors.ErrorSchema,
           true
@@ -4251,10 +4285,10 @@ var Form = class _Form extends import_react27.Component {
       ...this.getStateFromProps(props, formData, void 0, void 0, void 0, true),
       prevExtraErrors: props.extraErrors
     };
-    if (onChange && !(0, import_utils50.deepEquals)(this.state.formData, formData)) {
+    if (onChange && !(0, import_utils52.deepEquals)(this.state.formData, formData)) {
       onChange(toIChangeEvent(this.state));
     }
-    this.formElement = (0, import_react27.createRef)();
+    this.formElement = (0, import_react28.createRef)();
   }
   /**
    * `getSnapshotBeforeUpdate` is a React lifecycle method that is invoked right before the most recently rendered
@@ -4275,12 +4309,12 @@ var Form = class _Form extends import_react27.Component {
    *        with a flag indicating that an update is not necessary.
    */
   getSnapshotBeforeUpdate(prevProps, prevState) {
-    if (!(0, import_utils50.deepEquals)(this.props, prevProps)) {
-      const formDataChangedFields = (0, import_utils50.getChangedFields)(this.props.formData, prevProps.formData);
-      const stateDataChangedFields = (0, import_utils50.getChangedFields)(this.props.formData, this.state.formData);
-      const isSchemaChanged = !(0, import_utils50.deepEquals)(prevProps.schema, this.props.schema);
-      const isFormDataChanged = formDataChangedFields.length > 0 || !(0, import_utils50.deepEquals)(prevProps.formData, this.props.formData);
-      const isStateDataChanged = stateDataChangedFields.length > 0 || !(0, import_utils50.deepEquals)(this.state.formData, this.props.formData);
+    if (!(0, import_utils52.deepEquals)(this.props, prevProps)) {
+      const formDataChangedFields = (0, import_utils52.getChangedFields)(this.props.formData, prevProps.formData);
+      const stateDataChangedFields = (0, import_utils52.getChangedFields)(this.props.formData, this.state.formData);
+      const isSchemaChanged = !(0, import_utils52.deepEquals)(prevProps.schema, this.props.schema);
+      const isFormDataChanged = formDataChangedFields.length > 0 || !(0, import_utils52.deepEquals)(prevProps.formData, this.props.formData);
+      const isStateDataChanged = stateDataChangedFields.length > 0 || !(0, import_utils52.deepEquals)(this.state.formData, this.props.formData);
       const nextState = this.getStateFromProps(
         this.props,
         this.props.formData,
@@ -4293,7 +4327,7 @@ var Form = class _Form extends import_react27.Component {
         // Skip live validation for this request if no form data has changed from the last state
         !isStateDataChanged
       );
-      const shouldUpdate = !(0, import_utils50.deepEquals)(nextState, prevState);
+      const shouldUpdate = !(0, import_utils52.deepEquals)(nextState, prevState);
       return { nextState, shouldUpdate };
     }
     return { shouldUpdate: false };
@@ -4313,13 +4347,13 @@ var Form = class _Form extends import_react27.Component {
   componentDidUpdate(_, prevState, snapshot) {
     if (snapshot.shouldUpdate) {
       const { nextState } = snapshot;
-      const nextStateDiffersFromProps = !(0, import_utils50.deepEquals)(nextState.formData, this.props.formData);
+      const nextStateDiffersFromProps = !(0, import_utils52.deepEquals)(nextState.formData, this.props.formData);
       const wasProcessingUserChange = this.isProcessingUserChange;
       this.isProcessingUserChange = false;
       if (wasProcessingUserChange && nextStateDiffersFromProps) {
         return;
       }
-      if (nextStateDiffersFromProps && !(0, import_utils50.deepEquals)(nextState.formData, prevState.formData) && this.props.onChange) {
+      if (nextStateDiffersFromProps && !(0, import_utils52.deepEquals)(nextState.formData, prevState.formData) && this.props.onChange) {
         this.props.onChange(toIChangeEvent(nextState));
       }
       this.setState(nextState);
@@ -4356,7 +4390,7 @@ var Form = class _Form extends import_react27.Component {
       experimental_defaultFormStateBehavior,
       experimental_customMergeAllOf
     )) {
-      schemaUtils = (0, import_utils50.createSchemaUtils)(
+      schemaUtils = (0, import_utils52.createSchemaUtils)(
         validator2,
         schema,
         experimental_defaultFormStateBehavior,
@@ -4381,21 +4415,21 @@ var Form = class _Form extends import_react27.Component {
         false,
         state.initialDefaultsGenerated
       );
-      const formHash = shouldSanitize ? (0, import_utils50.hashObject)({ formData }) : "";
+      const formHash = shouldSanitize ? (0, import_utils52.hashObject)({ formData }) : "";
       computedRetrievedSchema = this.updateRetrievedSchema(
         retrievedSchema ?? schemaUtils.retrieveSchema(rootSchema, formData)
       );
-      if (shouldSanitize && !preventInfiniteSanitize.includes(formHash) && !(0, import_utils50.deepEquals)(computedRetrievedSchema, state.retrievedSchema)) {
+      if (shouldSanitize && !preventInfiniteSanitize.includes(formHash) && !(0, import_utils52.deepEquals)(computedRetrievedSchema, state.retrievedSchema)) {
         const sanitizedFormData = schemaUtils.sanitizeDataForNewSchema(
           computedRetrievedSchema,
           state.retrievedSchema,
           formData
         );
-        wasSanitized = !(0, import_utils50.deepEquals)(sanitizedFormData, formData);
+        wasSanitized = !(0, import_utils52.deepEquals)(sanitizedFormData, formData);
         if (wasSanitized) {
           formData = sanitizedFormData;
           defaultsFormData = sanitizedFormData;
-          const sanitizedFormHash = (0, import_utils50.hashObject)({ formData: sanitizedFormData });
+          const sanitizedFormHash = (0, import_utils52.hashObject)({ formData: sanitizedFormData });
           wasSanitized = !preventInfiniteSanitize.includes(sanitizedFormHash);
           preventInfiniteSanitize.push(sanitizedFormHash);
         }
@@ -4448,7 +4482,7 @@ var Form = class _Form extends import_react27.Component {
           acc[key] = void 0;
           return acc;
         }, {});
-        schemaValidationErrorSchema = (0, import_utils50.mergeObjects)(
+        schemaValidationErrorSchema = (0, import_utils52.mergeObjects)(
           currentErrors.errorSchema,
           newErrorSchema,
           "preventDuplicates"
@@ -4460,8 +4494,8 @@ var Form = class _Form extends import_react27.Component {
       errorSchema = mergedErrors.errorSchema;
     }
     const newRegistry = _Form.getRegistry(props, rootSchema, schemaUtils);
-    const registry = (0, import_utils50.deepEquals)(state.registry, newRegistry) ? state.registry : newRegistry;
-    const fieldPathId = state.fieldPathId && state.fieldPathId?.[import_utils50.ID_KEY] === registry.globalFormOptions.idPrefix ? state.fieldPathId : (0, import_utils50.toFieldPathId)("", registry.globalFormOptions);
+    const registry = (0, import_utils52.deepEquals)(state.registry, newRegistry) ? state.registry : newRegistry;
+    const fieldPathId = state.fieldPathId && state.fieldPathId?.[import_utils52.ID_KEY] === registry.globalFormOptions.idPrefix ? state.fieldPathId : (0, import_utils52.toFieldPathId)("", registry.globalFormOptions);
     const nextState = {
       schemaUtils,
       schema: rootSchema,
@@ -4487,7 +4521,7 @@ var Form = class _Form extends import_react27.Component {
    */
   shouldComponentUpdate(nextProps, nextState) {
     const { experimental_componentUpdateStrategy = "customDeep" } = this.props;
-    return (0, import_utils50.shouldRender)(this, nextProps, nextState, experimental_componentUpdateStrategy);
+    return (0, import_utils52.shouldRender)(this, nextProps, nextState, experimental_componentUpdateStrategy);
   }
   /** Validates the `formData` against the `schema` using the `altSchemaUtils` (if provided otherwise it uses the
    * `schemaUtils` in the state), returning the results.
@@ -4501,15 +4535,16 @@ var Form = class _Form extends import_react27.Component {
     const schemaUtils = altSchemaUtils || this.state.schemaUtils;
     const { customValidate, transformErrors, uiSchema } = this.props;
     const validationSchema = retrievedSchema ?? schema;
-    return schemaUtils.getValidator().validateFormData(formData, validationSchema, customValidate, transformErrors, uiSchema);
+    const validationFormData = formData ? JSON.parse(JSON.stringify(formData)) : void 0;
+    return schemaUtils.getValidator().validateFormData(validationFormData, validationSchema, customValidate, transformErrors, uiSchema);
   }
   /** Renders any errors contained in the `state` in using the `ErrorList`, if not disabled by `showErrorList`. */
   renderErrors(registry) {
     const { errors, errorSchema, schema, uiSchema } = this.state;
-    const options = (0, import_utils50.getUiOptions)(uiSchema);
-    const ErrorListTemplate = (0, import_utils50.getTemplate)("ErrorListTemplate", registry, options);
-    if (errors && errors.length) {
-      return /* @__PURE__ */ (0, import_jsx_runtime59.jsx)(
+    const options = (0, import_utils52.getUiOptions)(uiSchema);
+    const ErrorListTemplate = (0, import_utils52.getTemplate)("ErrorListTemplate", registry, options);
+    if (errors?.length) {
+      return /* @__PURE__ */ (0, import_jsx_runtime61.jsx)(
         ErrorListTemplate,
         {
           errors,
@@ -4533,12 +4568,12 @@ var Form = class _Form extends import_react27.Component {
   static mergeErrors(schemaValidation, extraErrors, customErrors) {
     let { errorSchema, errors } = schemaValidation;
     if (extraErrors) {
-      const merged = (0, import_utils50.validationDataMerge)(schemaValidation, extraErrors);
+      const merged = (0, import_utils52.validationDataMerge)(schemaValidation, extraErrors);
       errorSchema = merged.errorSchema;
       errors = merged.errors;
     }
     if (customErrors) {
-      const merged = (0, import_utils50.validationDataMerge)({ errors, errorSchema }, customErrors.ErrorSchema, true);
+      const merged = (0, import_utils52.validationDataMerge)({ errors, errorSchema }, customErrors.ErrorSchema, true);
       errorSchema = merged.errorSchema;
       errors = merged.errors;
     }
@@ -4563,7 +4598,7 @@ var Form = class _Form extends import_react27.Component {
     const { errors } = schemaValidation;
     let { errorSchema } = schemaValidation;
     if (mergeIntoOriginalErrorSchema) {
-      errorSchema = (0, import_utils50.mergeObjects)(
+      errorSchema = (0, import_utils52.mergeObjects)(
         originalErrorSchema,
         schemaValidation.errorSchema,
         "preventDuplicates"
@@ -4581,7 +4616,7 @@ var Form = class _Form extends import_react27.Component {
    * @deprecated - To be removed as an exported `Form` function in a future release; there isn't a planned replacement
    */
   // oxlint-disable-next-line class-methods-use-this, typescript/no-deprecated
-  getUsedFormData = (formData, fields2) => (0, import_utils50.getUsedFormData)(formData, fields2);
+  getUsedFormData = (formData, fields2) => (0, import_utils52.getUsedFormData)(formData, fields2);
   /** Returns the list of field names from inspecting the `pathSchema` as well as using the `formData`
    *
    * @param pathSchema - The `PathSchema` object for the form
@@ -4589,7 +4624,7 @@ var Form = class _Form extends import_react27.Component {
    * @deprecated - To be removed as an exported `Form` function in a future release; there isn't a planned replacement
    */
   // oxlint-disable-next-line class-methods-use-this, typescript/no-deprecated
-  getFieldNames = (pathSchema, formData) => (0, import_utils50.getFieldNames)(pathSchema, formData);
+  getFieldNames = (pathSchema, formData) => (0, import_utils52.getFieldNames)(pathSchema, formData);
   /** Returns the `formData` after filtering to remove any extra data not in a form field
    *
    * @param formData - The data for the `Form`
@@ -4611,8 +4646,8 @@ var Form = class _Form extends import_react27.Component {
   setFieldValue = (fieldPath, newValue) => {
     const { registry } = this.state;
     const path = Array.isArray(fieldPath) ? fieldPath : fieldPath.split(".");
-    const fieldPathId = (0, import_utils50.toFieldPathId)("", registry.globalFormOptions, path);
-    this.onChange(newValue, path, void 0, fieldPathId[import_utils50.ID_KEY]);
+    const fieldPathId = (0, import_utils52.toFieldPathId)("", registry.globalFormOptions, path);
+    this.onChange(newValue, path, void 0, fieldPathId[import_utils52.ID_KEY]);
   };
   /** Pushes the given change information into the `pendingChanges` array and then calls `processPendingChanges()` if
    * the array only contains a single pending change.
@@ -4651,14 +4686,14 @@ var Form = class _Form extends import_react27.Component {
     const rootPathId = fieldPathId.path[0] || "";
     const isRootPath = !path || path.length === 0 || path.length === 1 && path[0] === rootPathId;
     let formData = isRootPath ? newValue : (0, import_cloneDeep2.default)(oldFormData);
-    const hasOnlyUndefinedValues = (0, import_utils50.isObject)(formData) && Object.keys(formData).length > 0 && Object.values(formData).every((v) => v === void 0);
+    const hasOnlyUndefinedValues = (0, import_utils52.isObject)(formData) && Object.keys(formData).length > 0 && Object.values(formData).every((v) => v === void 0);
     const wasPreviouslyNull = oldFormData === null || oldFormData === void 0;
     const inputForDefaults = hasOnlyUndefinedValues && wasPreviouslyNull ? void 0 : formData;
-    if ((0, import_utils50.isObject)(formData) || Array.isArray(formData)) {
+    if ((0, import_utils52.isObject)(formData) || Array.isArray(formData)) {
+      let plainLeafWasCleared = false;
       if (newValue === ADDITIONAL_PROPERTY_KEY_REMOVE) {
         (0, import_unset.default)(formData, path);
       } else if (!isRootPath) {
-        let unsetPath = false;
         let valueForPath = newValue;
         if (newValue === void 0) {
           const lastSegment = path[path.length - 1];
@@ -4667,19 +4702,19 @@ var Form = class _Form extends import_react27.Component {
           } else {
             const { field } = schemaUtils.findFieldInSchema(schema, path, oldFormData);
             const leaf = field;
-            const isOneOfOrAnyOfLeaf = leaf && (import_utils50.ONE_OF_KEY in leaf || import_utils50.ANY_OF_KEY in leaf);
+            const isOneOfOrAnyOfLeaf = leaf && (import_utils52.ONE_OF_KEY in leaf || import_utils52.ANY_OF_KEY in leaf);
             if (!isOneOfOrAnyOfLeaf && leaf !== void 0) {
-              unsetPath = true;
+              plainLeafWasCleared = true;
             }
           }
         }
-        if (unsetPath) {
-          (0, import_unset.default)(formData, path);
+        if (plainLeafWasCleared) {
+          (0, import_set5.default)(formData, path, void 0);
         } else {
           (0, import_set5.default)(formData, path, valueForPath);
         }
       }
-      const shouldSanitize = retrievedSchema && !isRootPath && !(0, import_utils50.isObject)(newValue) && !Array.isArray(newValue) && !disabled && !readonly;
+      const shouldSanitize = retrievedSchema && !isRootPath && !(0, import_utils52.isObject)(newValue) && !Array.isArray(newValue) && !disabled && !readonly;
       const newState = this.getStateFromProps(
         this.props,
         inputForDefaults,
@@ -4691,6 +4726,9 @@ var Form = class _Form extends import_react27.Component {
       );
       formData = newState.formData;
       retrievedSchema = newState.retrievedSchema;
+      if (plainLeafWasCleared && formData) {
+        (0, import_set5.default)(formData, path, void 0);
+      }
     }
     const mustValidate = !noValidate && (liveValidate === true || liveValidate === "onChange");
     let state = { formData, retrievedSchema };
@@ -4710,10 +4748,10 @@ var Form = class _Form extends import_react27.Component {
         }
       } else {
         if (!customErrors) {
-          customErrors = new import_utils50.ErrorSchemaBuilder();
+          customErrors = new import_utils52.ErrorSchemaBuilder();
         }
         if (isRootPath) {
-          const pathErrors = (0, import_get5.default)(newErrorSchema, import_utils50.ERRORS_KEY);
+          const pathErrors = (0, import_get5.default)(newErrorSchema, import_utils52.ERRORS_KEY);
           if (pathErrors) {
             customErrors.setErrors(pathErrors);
           }
@@ -4721,7 +4759,7 @@ var Form = class _Form extends import_react27.Component {
           (0, import_set5.default)(customErrors.ErrorSchema, path, newErrorSchema);
         }
       }
-    } else if (customErrors && (0, import_get5.default)(customErrors.ErrorSchema, [...path, import_utils50.ERRORS_KEY])) {
+    } else if (customErrors && (0, import_get5.default)(customErrors.ErrorSchema, [...path, import_utils52.ERRORS_KEY])) {
       customErrors.clearErrors(path);
     }
     if (mustValidate && this.pendingChanges.length === 1) {
@@ -4761,7 +4799,7 @@ var Form = class _Form extends import_react27.Component {
    * @returns The new retrieved schema if it has changed, else the old retrieved schema.
    */
   updateRetrievedSchema(retrievedSchema) {
-    const isTheSame = (0, import_utils50.deepEquals)(retrievedSchema, this.state?.retrievedSchema);
+    const isTheSame = (0, import_utils52.deepEquals)(retrievedSchema, this.state?.retrievedSchema);
     return isTheSame ? this.state.retrievedSchema : retrievedSchema;
   }
   /**
@@ -4790,7 +4828,7 @@ var Form = class _Form extends import_react27.Component {
       initialDefaultsGenerated: false,
       customErrors: void 0
     };
-    this.setState(state, () => onChange && onChange(toIChangeEvent({ ...this.state, ...state })));
+    this.setState(state, () => onChange?.(toIChangeEvent({ ...this.state, ...state })));
   };
   /** Callback function to handle when a field on the form is blurred. Calls the `onBlur` callback for the `Form` if it
    * was provided. Also runs any live validation and/or live omit operations if the flags indicate they should happen
@@ -4829,7 +4867,7 @@ var Form = class _Form extends import_react27.Component {
       const hasChanges = Object.keys(state).filter((key) => !key.startsWith("schemaValidation")).some((key) => {
         const oldData = (0, import_get5.default)(this.state, key);
         const newData = (0, import_get5.default)(state, key);
-        return !(0, import_utils50.deepEquals)(oldData, newData);
+        return !(0, import_utils52.deepEquals)(oldData, newData);
       });
       this.setState(state, () => {
         if (onChange && hasChanges) {
@@ -4871,7 +4909,7 @@ var Form = class _Form extends import_react27.Component {
     }
     if (noValidate || this.validateFormWithFormData(newFormData)) {
       const errorSchema = extraErrors || {};
-      const errors = extraErrors ? (0, import_utils50.toErrorList)(extraErrors) : [];
+      const errors = extraErrors ? (0, import_utils52.toErrorList)(extraErrors) : [];
       this.setState(
         {
           formData: newFormData,
@@ -4898,8 +4936,8 @@ var Form = class _Form extends import_react27.Component {
     const {
       uiSchema = {},
       experimental_componentUpdateStrategy,
-      idSeparator = import_utils50.DEFAULT_ID_SEPARATOR,
-      idPrefix = import_utils50.DEFAULT_ID_PREFIX,
+      idSeparator = import_utils52.DEFAULT_ID_SEPARATOR,
+      idPrefix = import_utils52.DEFAULT_ID_PREFIX,
       nameGenerator,
       useFallbackUiForUnsupportedType = false
     } = props;
@@ -4931,9 +4969,9 @@ var Form = class _Form extends import_react27.Component {
       formContext: props.formContext || formContext,
       schemaUtils,
       translateString: customTranslateString || translateString,
-      globalUiOptions: uiSchema[import_utils50.UI_GLOBAL_OPTIONS_KEY],
+      globalUiOptions: uiSchema[import_utils52.UI_GLOBAL_OPTIONS_KEY],
       globalFormOptions: _Form.getGlobalFormOptions(props),
-      uiSchemaDefinitions: uiSchema[import_utils50.UI_DEFINITIONS_KEY] ?? {}
+      uiSchemaDefinitions: uiSchema[import_utils52.UI_DEFINITIONS_KEY] ?? {}
     };
   }
   /** Provides a function that can be used to programmatically submit the `Form` */
@@ -4967,7 +5005,7 @@ var Form = class _Form extends import_react27.Component {
     if (!field) {
       field = this.formElement.current.querySelector(`input[id^="${elementId}"], button[id^="${elementId}"]`);
     }
-    if (field && field.length) {
+    if (field?.length) {
       field = field[0];
     }
     if (field) {
@@ -5067,12 +5105,12 @@ var Form = class _Form extends import_react27.Component {
     const { SubmitButton: SubmitButton2 } = registry.templates.ButtonTemplates;
     const as = _internalFormWrapper ? tagName : void 0;
     const FormTag = _internalFormWrapper || tagName || "form";
-    let { [import_utils50.SUBMIT_BTN_OPTIONS_KEY]: submitOptions = {} } = (0, import_utils50.getUiOptions)(uiSchema);
+    let { [import_utils52.SUBMIT_BTN_OPTIONS_KEY]: submitOptions = {} } = (0, import_utils52.getUiOptions)(uiSchema);
     if (disabled) {
       submitOptions = { ...submitOptions, props: { ...submitOptions.props, disabled: true } };
     }
-    const submitUiSchema = { [import_utils50.UI_OPTIONS_KEY]: { [import_utils50.SUBMIT_BTN_OPTIONS_KEY]: submitOptions } };
-    return /* @__PURE__ */ (0, import_jsx_runtime59.jsxs)(
+    const submitUiSchema = { [import_utils52.UI_OPTIONS_KEY]: { [import_utils52.SUBMIT_BTN_OPTIONS_KEY]: submitOptions } };
+    return /* @__PURE__ */ (0, import_jsx_runtime61.jsxs)(
       FormTag,
       {
         className: className || "rjsf",
@@ -5090,7 +5128,7 @@ var Form = class _Form extends import_react27.Component {
         ref: this.formElement,
         children: [
           showErrorList === "top" && this.renderErrors(registry),
-          /* @__PURE__ */ (0, import_jsx_runtime59.jsx)(
+          /* @__PURE__ */ (0, import_jsx_runtime61.jsx)(
             SchemaFieldComponent,
             {
               name: "",
@@ -5107,7 +5145,7 @@ var Form = class _Form extends import_react27.Component {
               readonly
             }
           ),
-          children || /* @__PURE__ */ (0, import_jsx_runtime59.jsx)(SubmitButton2, { uiSchema: submitUiSchema, registry }),
+          children || /* @__PURE__ */ (0, import_jsx_runtime61.jsx)(SubmitButton2, { uiSchema: submitUiSchema, registry }),
           showErrorList === "bottom" && this.renderErrors(registry)
         ]
       }
@@ -5116,15 +5154,15 @@ var Form = class _Form extends import_react27.Component {
 };
 
 // src/getTestRegistry.tsx
-var import_utils51 = require("@rjsf/utils");
+var import_utils53 = require("@rjsf/utils");
 var import_validator_ajv8 = __toESM(require("@rjsf/validator-ajv8"), 1);
 function getTestRegistry(rootSchema, fields2 = {}, templates2 = {}, widgets2 = {}, formContext = {}, globalFormOptions = {
-  idPrefix: import_utils51.DEFAULT_ID_PREFIX,
-  idSeparator: import_utils51.DEFAULT_ID_SEPARATOR,
+  idPrefix: import_utils53.DEFAULT_ID_PREFIX,
+  idSeparator: import_utils53.DEFAULT_ID_SEPARATOR,
   useFallbackUiForUnsupportedType: false
 }) {
   const defaults = getDefaultRegistry();
-  const schemaUtils = (0, import_utils51.createSchemaUtils)(import_validator_ajv8.default, rootSchema);
+  const schemaUtils = (0, import_utils53.createSchemaUtils)(import_validator_ajv8.default, rootSchema);
   return {
     fields: { ...defaults.fields, ...fields2 },
     templates: { ...defaults.templates, ...templates2 },
@@ -5132,16 +5170,16 @@ function getTestRegistry(rootSchema, fields2 = {}, templates2 = {}, widgets2 = {
     formContext,
     rootSchema,
     schemaUtils,
-    translateString: import_utils51.englishStringTranslator,
+    translateString: import_utils53.englishStringTranslator,
     globalFormOptions
   };
 }
 
 // src/withTheme.tsx
-var import_react28 = require("react");
-var import_jsx_runtime60 = require("react/jsx-runtime");
+var import_react29 = require("react");
+var import_jsx_runtime62 = require("react/jsx-runtime");
 function withTheme(themeProps) {
-  return (0, import_react28.forwardRef)(
+  return (0, import_react29.forwardRef)(
     ({ fields: propFields, widgets: propWidgets, templates: propTemplates, ...directProps }, ref) => {
       const fields2 = { ...themeProps?.fields, ...propFields };
       const widgets2 = { ...themeProps?.widgets, ...propWidgets };
@@ -5153,7 +5191,7 @@ function withTheme(themeProps) {
           ...propTemplates?.ButtonTemplates
         }
       };
-      return /* @__PURE__ */ (0, import_jsx_runtime60.jsx)(
+      return /* @__PURE__ */ (0, import_jsx_runtime62.jsx)(
         Form,
         {
           ...themeProps,