@rjsf/utils 6.1.2 → 6.2.3

package/dist/utils.esm.js

@@ -1519,7 +1519,7 @@ function computeDefaults(validator, rawSchema, computeDefaultsProps = {}) {
   let updatedRecurseList = _recurseList;
   if (schema[CONST_KEY] !== void 0 && experimental_defaultFormStateBehavior?.constAsDefaults !== "never" && !constIsAjvDataReference(schema)) {
     defaults = schema[CONST_KEY];
-  } else if (isObject(defaults) && isObject(schema.default)) {
+  } else if (isObject(defaults) && isObject(schema.default) && !schema[ANY_OF_KEY] && !schema[ONE_OF_KEY] && !schema[REF_KEY]) {
     defaults = mergeObjects(defaults, schema.default);
   } else if (DEFAULT_KEY in schema && !schema[ANY_OF_KEY] && !schema[ONE_OF_KEY] && !schema[REF_KEY]) {
     defaults = schema.default;
@@ -1529,7 +1529,8 @@ function computeDefaults(validator, rawSchema, computeDefaultsProps = {}) {
       updatedRecurseList = _recurseList.concat(refName);
       schemaToCompute = findSchemaDefinition(refName, rootSchema);
     }
-    if (schemaToCompute && !defaults) {
+    const hasNoExistingData = rawFormData === void 0 || isObject(rawFormData) && isEmpty4(rawFormData);
+    if (schemaToCompute && !defaults && hasNoExistingData) {
       defaults = schema.default;
     }
     if (shouldMergeDefaultsIntoFormData && schemaToCompute && !isObject(rawFormData)) {
@@ -1673,7 +1674,8 @@ function getObjectDefaults(validator, rawSchema, {
   {
     const formData = isObject(rawFormData) ? rawFormData : {};
     const schema = rawSchema;
-    const retrievedSchema = experimental_defaultFormStateBehavior?.allOf === "populateDefaults" && ALL_OF_KEY in schema ? retrieveSchema(validator, schema, rootSchema, formData, experimental_customMergeAllOf) : schema;
+    const shouldRetrieveSchema = experimental_defaultFormStateBehavior?.allOf === "populateDefaults" && ALL_OF_KEY in schema || experimental_defaultFormStateBehavior?.emptyObjectFields !== "skipEmptyDefaults" && IF_KEY in schema;
+    const retrievedSchema = shouldRetrieveSchema ? retrieveSchema(validator, schema, rootSchema, formData, experimental_customMergeAllOf) : schema;
     const parentConst = retrievedSchema[CONST_KEY];
     const objectDefaults = Object.keys(retrievedSchema.properties || {}).reduce(
       (acc, key) => {
@@ -1767,12 +1769,14 @@ function getArrayDefaults(validator, rawSchema, {
   if (Array.isArray(defaults)) {
     defaults = defaults.map((item, idx) => {
       const schemaItem = getInnerSchemaForArrayItem(schema, 2 /* Fallback */, idx);
+      const itemFormData = Array.isArray(rawFormData) ? rawFormData[idx] : void 0;
       return computeDefaults(validator, schemaItem, {
         rootSchema,
         _recurseList,
         experimental_defaultFormStateBehavior,
         experimental_customMergeAllOf,
         parentDefaults: item,
+        rawFormData: itemFormData,
         required,
         shouldMergeDefaultsIntoFormData,
         initialDefaultsGenerated
@@ -1937,8 +1941,175 @@ function getDisplayLabel(validator, schema, uiSchema = {}, rootSchema, globalOpt
   return displayLabel;
 }
 
-// src/schema/sanitizeDataForNewSchema.ts
+// src/schema/omitExtraData.ts
+import pick from "lodash/pick";
+import isEmpty5 from "lodash/isEmpty";
+import get15 from "lodash/get";
+
+// src/schema/toPathSchema.ts
 import get14 from "lodash/get";
+import set2 from "lodash/set";
+function toPathSchemaInternal(validator, schema, name, rootSchema, formData, _recurseList = [], experimental_customMergeAllOf) {
+  if (REF_KEY in schema || DEPENDENCIES_KEY in schema || ALL_OF_KEY in schema || IF_KEY in schema) {
+    const _schema = retrieveSchema(validator, schema, rootSchema, formData, experimental_customMergeAllOf);
+    const sameSchemaIndex = _recurseList.findIndex((item) => deepEquals(item, _schema));
+    if (sameSchemaIndex === -1) {
+      return toPathSchemaInternal(
+        validator,
+        _schema,
+        name,
+        rootSchema,
+        formData,
+        _recurseList.concat(_schema),
+        experimental_customMergeAllOf
+      );
+    }
+  }
+  let pathSchema = {
+    [NAME_KEY]: name.replace(/^\./, "")
+  };
+  if (ONE_OF_KEY in schema || ANY_OF_KEY in schema) {
+    const xxxOf = ONE_OF_KEY in schema ? schema.oneOf : schema.anyOf;
+    const discriminator = getDiscriminatorFieldFromSchema(schema);
+    const index = getClosestMatchingOption(
+      validator,
+      rootSchema,
+      formData,
+      xxxOf,
+      0,
+      discriminator,
+      experimental_customMergeAllOf
+    );
+    const _schema = xxxOf[index];
+    pathSchema = {
+      ...pathSchema,
+      ...toPathSchemaInternal(
+        validator,
+        _schema,
+        name,
+        rootSchema,
+        formData,
+        _recurseList,
+        experimental_customMergeAllOf
+      )
+    };
+  }
+  if (ADDITIONAL_PROPERTIES_KEY in schema && schema[ADDITIONAL_PROPERTIES_KEY] !== false) {
+    set2(pathSchema, RJSF_ADDITIONAL_PROPERTIES_FLAG, true);
+  }
+  if (ITEMS_KEY in schema && Array.isArray(formData)) {
+    const { items: schemaItems, additionalItems: schemaAdditionalItems } = schema;
+    if (Array.isArray(schemaItems)) {
+      formData.forEach((element, i) => {
+        if (schemaItems[i]) {
+          pathSchema[i] = toPathSchemaInternal(
+            validator,
+            schemaItems[i],
+            `${name}.${i}`,
+            rootSchema,
+            element,
+            _recurseList,
+            experimental_customMergeAllOf
+          );
+        } else if (schemaAdditionalItems) {
+          pathSchema[i] = toPathSchemaInternal(
+            validator,
+            schemaAdditionalItems,
+            `${name}.${i}`,
+            rootSchema,
+            element,
+            _recurseList,
+            experimental_customMergeAllOf
+          );
+        } else {
+          console.warn(`Unable to generate path schema for "${name}.${i}". No schema defined for it`);
+        }
+      });
+    } else {
+      formData.forEach((element, i) => {
+        pathSchema[i] = toPathSchemaInternal(
+          validator,
+          schemaItems,
+          `${name}.${i}`,
+          rootSchema,
+          element,
+          _recurseList,
+          experimental_customMergeAllOf
+        );
+      });
+    }
+  } else if (PROPERTIES_KEY in schema) {
+    for (const property in schema.properties) {
+      const field = get14(schema, [PROPERTIES_KEY, property], {});
+      pathSchema[property] = toPathSchemaInternal(
+        validator,
+        field,
+        `${name}.${property}`,
+        rootSchema,
+        // It's possible that formData is not an object -- this can happen if an
+        // array item has just been added, but not populated with data yet
+        get14(formData, [property]),
+        _recurseList,
+        experimental_customMergeAllOf
+      );
+    }
+  }
+  return pathSchema;
+}
+function toPathSchema(validator, schema, name = "", rootSchema, formData, experimental_customMergeAllOf) {
+  return toPathSchemaInternal(validator, schema, name, rootSchema, formData, void 0, experimental_customMergeAllOf);
+}
+
+// src/schema/omitExtraData.ts
+function getUsedFormData(formData, fields) {
+  if (fields.length === 0 && typeof formData !== "object") {
+    return formData;
+  }
+  const data = pick(formData, fields);
+  if (Array.isArray(formData)) {
+    return Object.keys(data).map((key) => data[key]);
+  }
+  return data;
+}
+function getFieldNames(pathSchema, formData) {
+  const formValueHasData = (value, isLeaf) => typeof value !== "object" || isEmpty5(value) || isLeaf && !isEmpty5(value);
+  const getAllPaths = (_obj, acc = [], paths = [[]]) => {
+    const objKeys = Object.keys(_obj);
+    objKeys.forEach((key) => {
+      const data = _obj[key];
+      if (typeof data === "object") {
+        const newPaths = paths.map((path) => [...path, key]);
+        if (data[RJSF_ADDITIONAL_PROPERTIES_FLAG] && data[NAME_KEY] !== "") {
+          acc.push(data[NAME_KEY]);
+        } else {
+          getAllPaths(data, acc, newPaths);
+        }
+      } else if (key === NAME_KEY && data !== "") {
+        paths.forEach((path) => {
+          const formValue = get15(formData, path);
+          const isLeaf = objKeys.length === 1;
+          if (formValueHasData(formValue, isLeaf) || Array.isArray(formValue) && formValue.every((val) => formValueHasData(val, isLeaf))) {
+            acc.push(path);
+          }
+        });
+      }
+    });
+    return acc;
+  };
+  return getAllPaths(pathSchema);
+}
+function omitExtraData(validator, schema, rootSchema = {}, formData) {
+  const retrievedSchema = retrieveSchema(validator, schema, rootSchema, formData);
+  const pathSchema = toPathSchema(validator, retrievedSchema, "", rootSchema, formData);
+  const fieldNames = getFieldNames(pathSchema, formData);
+  const lodashFieldNames = fieldNames.map(
+    (fieldPaths) => Array.isArray(fieldPaths) ? fieldPaths.join(".") : fieldPaths
+  );
+  return getUsedFormData(formData, lodashFieldNames);
+}
+
+// src/schema/sanitizeDataForNewSchema.ts
+import get16 from "lodash/get";
 import has5 from "lodash/has";
 var NO_VALUE = Symbol("no Value");
 function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, data = {}, experimental_customMergeAllOf) {
@@ -1946,19 +2117,19 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
   if (has5(newSchema, PROPERTIES_KEY)) {
     const removeOldSchemaData = {};
     if (has5(oldSchema, PROPERTIES_KEY)) {
-      const properties = get14(oldSchema, PROPERTIES_KEY, {});
+      const properties = get16(oldSchema, PROPERTIES_KEY, {});
       Object.keys(properties).forEach((key) => {
         if (has5(data, key)) {
           removeOldSchemaData[key] = void 0;
         }
       });
     }
-    const keys2 = Object.keys(get14(newSchema, PROPERTIES_KEY, {}));
+    const keys2 = Object.keys(get16(newSchema, PROPERTIES_KEY, {}));
     const nestedData = {};
     keys2.forEach((key) => {
-      const formValue = get14(data, key);
-      let oldKeyedSchema = get14(oldSchema, [PROPERTIES_KEY, key], {});
-      let newKeyedSchema = get14(newSchema, [PROPERTIES_KEY, key], {});
+      const formValue = get16(data, key);
+      let oldKeyedSchema = get16(oldSchema, [PROPERTIES_KEY, key], {});
+      let newKeyedSchema = get16(newSchema, [PROPERTIES_KEY, key], {});
       if (has5(oldKeyedSchema, REF_KEY)) {
         oldKeyedSchema = retrieveSchema(
           validator,
@@ -1977,8 +2148,8 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
           experimental_customMergeAllOf
         );
       }
-      const oldSchemaTypeForKey = get14(oldKeyedSchema, "type");
-      const newSchemaTypeForKey = get14(newKeyedSchema, "type");
+      const oldSchemaTypeForKey = get16(oldKeyedSchema, "type");
+      const newSchemaTypeForKey = get16(newKeyedSchema, "type");
       if (!oldSchemaTypeForKey || oldSchemaTypeForKey === newSchemaTypeForKey) {
         if (has5(removeOldSchemaData, key)) {
           delete removeOldSchemaData[key];
@@ -1996,17 +2167,17 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
             nestedData[key] = itemData;
           }
         } else {
-          const newOptionDefault = get14(newKeyedSchema, "default", NO_VALUE);
-          const oldOptionDefault = get14(oldKeyedSchema, "default", NO_VALUE);
+          const newOptionDefault = get16(newKeyedSchema, "default", NO_VALUE);
+          const oldOptionDefault = get16(oldKeyedSchema, "default", NO_VALUE);
           if (newOptionDefault !== NO_VALUE && newOptionDefault !== formValue) {
             if (oldOptionDefault === formValue) {
               removeOldSchemaData[key] = newOptionDefault;
-            } else if (get14(newKeyedSchema, "readOnly") === true) {
+            } else if (get16(newKeyedSchema, "readOnly") === true) {
               removeOldSchemaData[key] = void 0;
             }
           }
-          const newOptionConst = get14(newKeyedSchema, "const", NO_VALUE);
-          const oldOptionConst = get14(oldKeyedSchema, "const", NO_VALUE);
+          const newOptionConst = get16(newKeyedSchema, "const", NO_VALUE);
+          const oldOptionConst = get16(oldKeyedSchema, "const", NO_VALUE);
           if (newOptionConst !== NO_VALUE && newOptionConst !== formValue) {
             removeOldSchemaData[key] = oldOptionConst === formValue ? newOptionConst : void 0;
           }
@@ -2018,9 +2189,9 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
       ...removeOldSchemaData,
       ...nestedData
     };
-  } else if (get14(oldSchema, "type") === "array" && get14(newSchema, "type") === "array" && Array.isArray(data)) {
-    let oldSchemaItems = get14(oldSchema, "items");
-    let newSchemaItems = get14(newSchema, "items");
+  } else if (get16(oldSchema, "type") === "array" && get16(newSchema, "type") === "array" && Array.isArray(data)) {
+    let oldSchemaItems = get16(oldSchema, "items");
+    let newSchemaItems = get16(newSchema, "items");
     if (typeof oldSchemaItems === "object" && typeof newSchemaItems === "object" && !Array.isArray(oldSchemaItems) && !Array.isArray(newSchemaItems)) {
       if (has5(oldSchemaItems, REF_KEY)) {
         oldSchemaItems = retrieveSchema(
@@ -2040,10 +2211,10 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
           experimental_customMergeAllOf
         );
       }
-      const oldSchemaType = get14(oldSchemaItems, "type");
-      const newSchemaType = get14(newSchemaItems, "type");
+      const oldSchemaType = get16(oldSchemaItems, "type");
+      const newSchemaType = get16(newSchemaItems, "type");
       if (!oldSchemaType || oldSchemaType === newSchemaType) {
-        const maxItems = get14(newSchema, "maxItems", -1);
+        const maxItems = get16(newSchema, "maxItems", -1);
         if (newSchemaType === "object") {
           newFormData = data.reduce((newValue, aValue) => {
             const itemValue = sanitizeDataForNewSchema(
@@ -2070,122 +2241,8 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
   return newFormData;
 }
 
-// src/schema/toPathSchema.ts
-import get15 from "lodash/get";
-import set2 from "lodash/set";
-function toPathSchemaInternal(validator, schema, name, rootSchema, formData, _recurseList = [], experimental_customMergeAllOf) {
-  if (REF_KEY in schema || DEPENDENCIES_KEY in schema || ALL_OF_KEY in schema) {
-    const _schema = retrieveSchema(validator, schema, rootSchema, formData, experimental_customMergeAllOf);
-    const sameSchemaIndex = _recurseList.findIndex((item) => deepEquals(item, _schema));
-    if (sameSchemaIndex === -1) {
-      return toPathSchemaInternal(
-        validator,
-        _schema,
-        name,
-        rootSchema,
-        formData,
-        _recurseList.concat(_schema),
-        experimental_customMergeAllOf
-      );
-    }
-  }
-  let pathSchema = {
-    [NAME_KEY]: name.replace(/^\./, "")
-  };
-  if (ONE_OF_KEY in schema || ANY_OF_KEY in schema) {
-    const xxxOf = ONE_OF_KEY in schema ? schema.oneOf : schema.anyOf;
-    const discriminator = getDiscriminatorFieldFromSchema(schema);
-    const index = getClosestMatchingOption(
-      validator,
-      rootSchema,
-      formData,
-      xxxOf,
-      0,
-      discriminator,
-      experimental_customMergeAllOf
-    );
-    const _schema = xxxOf[index];
-    pathSchema = {
-      ...pathSchema,
-      ...toPathSchemaInternal(
-        validator,
-        _schema,
-        name,
-        rootSchema,
-        formData,
-        _recurseList,
-        experimental_customMergeAllOf
-      )
-    };
-  }
-  if (ADDITIONAL_PROPERTIES_KEY in schema && schema[ADDITIONAL_PROPERTIES_KEY] !== false) {
-    set2(pathSchema, RJSF_ADDITIONAL_PROPERTIES_FLAG, true);
-  }
-  if (ITEMS_KEY in schema && Array.isArray(formData)) {
-    const { items: schemaItems, additionalItems: schemaAdditionalItems } = schema;
-    if (Array.isArray(schemaItems)) {
-      formData.forEach((element, i) => {
-        if (schemaItems[i]) {
-          pathSchema[i] = toPathSchemaInternal(
-            validator,
-            schemaItems[i],
-            `${name}.${i}`,
-            rootSchema,
-            element,
-            _recurseList,
-            experimental_customMergeAllOf
-          );
-        } else if (schemaAdditionalItems) {
-          pathSchema[i] = toPathSchemaInternal(
-            validator,
-            schemaAdditionalItems,
-            `${name}.${i}`,
-            rootSchema,
-            element,
-            _recurseList,
-            experimental_customMergeAllOf
-          );
-        } else {
-          console.warn(`Unable to generate path schema for "${name}.${i}". No schema defined for it`);
-        }
-      });
-    } else {
-      formData.forEach((element, i) => {
-        pathSchema[i] = toPathSchemaInternal(
-          validator,
-          schemaItems,
-          `${name}.${i}`,
-          rootSchema,
-          element,
-          _recurseList,
-          experimental_customMergeAllOf
-        );
-      });
-    }
-  } else if (PROPERTIES_KEY in schema) {
-    for (const property in schema.properties) {
-      const field = get15(schema, [PROPERTIES_KEY, property], {});
-      pathSchema[property] = toPathSchemaInternal(
-        validator,
-        field,
-        `${name}.${property}`,
-        rootSchema,
-        // It's possible that formData is not an object -- this can happen if an
-        // array item has just been added, but not populated with data yet
-        get15(formData, [property]),
-        _recurseList,
-        experimental_customMergeAllOf
-      );
-    }
-  }
-  return pathSchema;
-}
-function toPathSchema(validator, schema, name = "", rootSchema, formData, experimental_customMergeAllOf) {
-  return toPathSchemaInternal(validator, schema, name, rootSchema, formData, void 0, experimental_customMergeAllOf);
-}
-
 // src/createSchemaUtils.ts
-import get16 from "lodash/get";
+import get17 from "lodash/get";
 var SchemaUtils = class {
   /** Constructs the `SchemaUtils` instance with the given `validator` and `rootSchema` stored as instance variables
    *
@@ -2196,7 +2253,7 @@ var SchemaUtils = class {
    */
   constructor(validator, rootSchema, experimental_defaultFormStateBehavior, experimental_customMergeAllOf) {
     if (rootSchema && rootSchema[SCHEMA_KEY] === JSON_SCHEMA_DRAFT_2020_12) {
-      this.rootSchema = makeAllReferencesAbsolute(rootSchema, get16(rootSchema, ID_KEY, "#"));
+      this.rootSchema = makeAllReferencesAbsolute(rootSchema, get17(rootSchema, ID_KEY, "#"));
     } else {
       this.rootSchema = rootSchema;
     }
@@ -2388,6 +2445,18 @@ var SchemaUtils = class {
   isSelect(schema) {
     return isSelect(this.validator, schema, this.rootSchema, this.experimental_customMergeAllOf);
   }
+  /**
+   * The function takes a `schema` and `formData` and returns a copy of the formData with any fields not defined in the schema removed.
+   * This is useful for ensuring that only data that is relevant to the schema is preserved. Objects with `additionalProperties`
+   * keyword set to `true` will not have their extra fields removed.
+   *
+   * @param schema - The schema to use for filtering the `formData`
+   * @param [formData] - The formData to filter
+   * @returns The new form data, with any fields not defined in the schema removed
+   */
+  omitExtraData(schema, formData) {
+    return omitExtraData(this.validator, schema, this.rootSchema, formData);
+  }
   /** Retrieves an expanded schema that has had all of its conditions, additional properties, references and
    * dependencies resolved and merged into the `schema` given a `rawFormData` that is used to do the potentially
    * recursive resolution.
@@ -2610,7 +2679,7 @@ function enumOptionsSelectValue(valueIndex, selected, allEnumOptions = []) {
 
 // src/ErrorSchemaBuilder.ts
 import cloneDeep from "lodash/cloneDeep";
-import get17 from "lodash/get";
+import get18 from "lodash/get";
 import set3 from "lodash/set";
 import setWith from "lodash/setWith";
 var ErrorSchemaBuilder = class {
@@ -2639,7 +2708,7 @@ var ErrorSchemaBuilder = class {
    */
   getOrCreateErrorBlock(pathOfError) {
     const hasPath = Array.isArray(pathOfError) && pathOfError.length > 0 || typeof pathOfError === "string";
-    let errorBlock = hasPath ? get17(this.errorSchema, pathOfError) : this.errorSchema;
+    let errorBlock = hasPath ? get18(this.errorSchema, pathOfError) : this.errorSchema;
     if (!errorBlock && pathOfError) {
       errorBlock = {};
       setWith(this.errorSchema, pathOfError, errorBlock, Object);
@@ -2665,7 +2734,7 @@ var ErrorSchemaBuilder = class {
    */
   addErrors(errorOrList, pathOfError) {
     const errorBlock = this.getOrCreateErrorBlock(pathOfError);
-    let errorsList = get17(errorBlock, ERRORS_KEY);
+    let errorsList = get18(errorBlock, ERRORS_KEY);
     if (!Array.isArray(errorsList)) {
       errorsList = [];
       errorBlock[ERRORS_KEY] = errorsList;
@@ -2709,7 +2778,7 @@ var ErrorSchemaBuilder = class {
 import keys from "lodash/keys";
 import pickBy from "lodash/pickBy";
 import isPlainObject2 from "lodash/isPlainObject";
-import get18 from "lodash/get";
+import get19 from "lodash/get";
 import difference from "lodash/difference";
 function getChangedFields(a, b) {
   const aIsPlainObject = isPlainObject2(a);
@@ -2722,7 +2791,7 @@ function getChangedFields(a, b) {
   } else if (!aIsPlainObject && bIsPlainObject) {
     return keys(b);
   } else {
-    const unequalFields = keys(pickBy(a, (value, key) => !deepEquals(value, get18(b, key))));
+    const unequalFields = keys(pickBy(a, (value, key) => !deepEquals(value, get19(b, key))));
     const diffFields = difference(keys(b), keys(a));
     return [...unequalFields, ...diffFields];
   }
@@ -2836,10 +2905,10 @@ function getTemplate(name, registry, uiOptions = {}) {
 }
 
 // src/getTestIds.ts
-import get19 from "lodash/get";
+import get20 from "lodash/get";
 import uniqueId from "lodash/uniqueId";
 function getTestIds() {
-  if (typeof process === "undefined" || get19(process, "env.NODE_ENV") !== "test") {
+  if (typeof process === "undefined" || get20(process, "env.NODE_ENV") !== "test") {
     return {};
   }
   const ids = /* @__PURE__ */ new Map();
@@ -2859,7 +2928,7 @@ function getTestIds() {
 // src/getWidget.tsx
 import { createElement } from "react";
 import ReactIs from "react-is";
-import get20 from "lodash/get";
+import get21 from "lodash/get";
 import set4 from "lodash/set";
 import { jsx } from "react/jsx-runtime";
 var widgetMap = {
@@ -2915,7 +2984,7 @@ var widgetMap = {
   }
 };
 function mergeWidgetOptions(AWidget) {
-  let MergedWidget = get20(AWidget, "MergedWidget");
+  let MergedWidget = get21(AWidget, "MergedWidget");
   if (!MergedWidget) {
     const defaultOptions = AWidget.defaultProps && AWidget.defaultProps.options || {};
     MergedWidget = ({ options, ...props }) => {
@@ -3022,10 +3091,10 @@ function optionalControlsId(id, element) {
 
 // src/isFormDataAvailable.ts
 import isNil3 from "lodash/isNil";
-import isEmpty5 from "lodash/isEmpty";
+import isEmpty6 from "lodash/isEmpty";
 import isObject4 from "lodash/isObject";
 function isFormDataAvailable(formData) {
-  return !isNil3(formData) && (!isObject4(formData) || Array.isArray(formData) || !isEmpty5(formData));
+  return !isNil3(formData) && (!isObject4(formData) || Array.isArray(formData) || !isEmpty6(formData));
 }
 
 // src/isRootSchema.ts
@@ -3053,14 +3122,14 @@ function localToUTC(dateString) {
 }
 
 // src/lookupFromFormContext.ts
-import get21 from "lodash/get";
+import get22 from "lodash/get";
 import has6 from "lodash/has";
 function lookupFromFormContext(regOrFc, toLookup, fallback) {
   const lookupPath = [LOOKUP_MAP_NAME];
   if (has6(regOrFc, FORM_CONTEXT_NAME)) {
     lookupPath.unshift(FORM_CONTEXT_NAME);
   }
-  return get21(regOrFc, [...lookupPath, toLookup], fallback);
+  return get22(regOrFc, [...lookupPath, toLookup], fallback);
 }
 
 // src/orderProperties.ts
@@ -3484,7 +3553,7 @@ function utcToLocal(jsonDate) {
 }
 
 // src/validationDataMerge.ts
-import isEmpty6 from "lodash/isEmpty";
+import isEmpty7 from "lodash/isEmpty";
 function validationDataMerge(validationData, additionalErrorSchema, preventDuplicates = false) {
   if (!additionalErrorSchema) {
     return validationData;
@@ -3492,7 +3561,7 @@ function validationDataMerge(validationData, additionalErrorSchema, preventDupli
   const { errors: oldErrors, errorSchema: oldErrorSchema } = validationData;
   let errors = toErrorList(additionalErrorSchema);
   let errorSchema = additionalErrorSchema;
-  if (!isEmpty6(oldErrorSchema)) {
+  if (!isEmpty7(oldErrorSchema)) {
     errorSchema = mergeObjects(
       oldErrorSchema,
       additionalErrorSchema,
@@ -3580,6 +3649,7 @@ var TranslatableString = /* @__PURE__ */ ((TranslatableString2) => {
   TranslatableString2["OptionalObjectEmptyMsg"] = "No data for optional field";
   TranslatableString2["Type"] = "Type";
   TranslatableString2["Value"] = "Value";
+  TranslatableString2["ClearButton"] = "clear input";
   TranslatableString2["UnknownFieldType"] = "Unknown field type %1";
   TranslatableString2["OptionPrefix"] = "Option %1";
   TranslatableString2["TitleOptionPrefix"] = "%1 option %2";
@@ -3597,7 +3667,7 @@ var TranslatableString = /* @__PURE__ */ ((TranslatableString2) => {
 import forEach from "lodash/forEach";
 
 // src/parser/ParserValidator.ts
-import get22 from "lodash/get";
+import get23 from "lodash/get";
 var ParserValidator = class {
   /** Construct the ParserValidator for the given `rootSchema`. This `rootSchema` will be stashed in the `schemaMap`
    * first.
@@ -3623,7 +3693,7 @@ var ParserValidator = class {
    * @param hash - The hash value at which to map the schema
    */
   addSchema(schema, hash) {
-    const key = get22(schema, ID_KEY, hash);
+    const key = get23(schema, ID_KEY, hash);
     const identifiedSchema = { ...schema, [ID_KEY]: key };
     const existing = this.schemaMap[key];
     if (!existing) {
@@ -3783,6 +3853,7 @@ export {
   getDefaultFormState,
   getDiscriminatorFieldFromSchema,
   getDisplayLabel,
+  getFieldNames,
   getFirstMatchingOption,
   getFromSchema,
   getInputProps,
@@ -3792,6 +3863,7 @@ export {
   getTemplate,
   getTestIds,
   getUiOptions,
+  getUsedFormData,
   getWidget,
   guessType,
   hasWidget,
@@ -3814,6 +3886,7 @@ export {
   mergeDefaultsWithFormData,
   mergeObjects,
   mergeSchemas,
+  omitExtraData,
   optionId,
   optionalControlsId,
   optionsList,