@rjsf/utils 6.1.1 → 6.2.3

package/dist/index.cjs

@@ -99,6 +99,7 @@ __export(index_exports, {
   getDefaultFormState: () => getDefaultFormState,
   getDiscriminatorFieldFromSchema: () => getDiscriminatorFieldFromSchema,
   getDisplayLabel: () => getDisplayLabel,
+  getFieldNames: () => getFieldNames,
   getFirstMatchingOption: () => getFirstMatchingOption,
   getFromSchema: () => getFromSchema,
   getInputProps: () => getInputProps,
@@ -108,6 +109,7 @@ __export(index_exports, {
   getTemplate: () => getTemplate,
   getTestIds: () => getTestIds,
   getUiOptions: () => getUiOptions,
+  getUsedFormData: () => getUsedFormData,
   getWidget: () => getWidget,
   guessType: () => guessType,
   hasWidget: () => hasWidget,
@@ -130,6 +132,7 @@ __export(index_exports, {
   mergeDefaultsWithFormData: () => mergeDefaultsWithFormData,
   mergeObjects: () => mergeObjects,
   mergeSchemas: () => mergeSchemas,
+  omitExtraData: () => omitExtraData,
   optionId: () => optionId,
   optionalControlsId: () => optionalControlsId,
   optionsList: () => optionsList,
@@ -334,7 +337,9 @@ var import_transform = __toESM(require("lodash/transform"), 1);
 var import_merge = __toESM(require("lodash/merge"), 1);
 var import_flattenDeep = __toESM(require("lodash/flattenDeep"), 1);
 var import_uniq = __toESM(require("lodash/uniq"), 1);
-var import_json_schema_merge_allof = __toESM(require("json-schema-merge-allof"), 1);
+var import_isEmpty2 = __toESM(require("lodash/isEmpty"), 1);
+var import_json_schema_merge = require("@x0k/json-schema-merge");
+var import_array = require("@x0k/json-schema-merge/lib/array");
 
 // src/findSchemaDefinition.ts
 var import_jsonpointer = __toESM(require("jsonpointer"), 1);
@@ -599,7 +604,6 @@ function getFirstMatchingOption(validator, formData, options, rootSchema, discri
 }
 
 // src/schema/retrieveSchema.ts
-var import_isEmpty2 = __toESM(require("lodash/isEmpty"), 1);
 function retrieveSchema(validator, schema, rootSchema = {}, rawFormData, experimental_customMergeAllOf, resolveAnyOfOrOneOfRefs = false) {
   return retrieveSchemaInternal(
     validator,
@@ -885,6 +889,15 @@ function stubExistingAdditionalProperties(validator, theSchema, rootSchema, aFor
   });
   return schema;
 }
+var { compareSchemaDefinitions, compareSchemaValues } = (0, import_json_schema_merge.createComparator)();
+var { mergeArrayOfSchemaDefinitions } = (0, import_json_schema_merge.createMerger)({
+  intersectJson: (0, import_array.createIntersector)(compareSchemaValues),
+  deduplicateJsonSchemaDef: (0, import_array.createDeduplicator)(compareSchemaDefinitions)
+});
+var shallowAllOfMerge = (0, import_json_schema_merge.createShallowAllOfMerge)(mergeArrayOfSchemaDefinitions);
+function mergeAllOf(schema) {
+  return shallowAllOfMerge(schema);
+}
 function retrieveSchemaInternal(validator, schema, rootSchema, rawFormData, expandAllBranches = false, recurseList = [], experimental_customMergeAllOf, resolveAnyOfOrOneOfRefs) {
   if (!isObject(schema)) {
     return [{}];
@@ -930,12 +943,7 @@ function retrieveSchemaInternal(validator, schema, rootSchema, rawFormData, expa
         if (withContainsSchemas.length) {
           resolvedSchema = { ...resolvedSchema, allOf: withoutContainsSchemas };
         }
-        resolvedSchema = experimental_customMergeAllOf ? experimental_customMergeAllOf(resolvedSchema) : (0, import_json_schema_merge_allof.default)(resolvedSchema, {
-          deep: false,
-          resolvers: {
-            $defs: import_json_schema_merge_allof.default.options.resolvers.definitions
-          }
-        });
+        resolvedSchema = experimental_customMergeAllOf ? experimental_customMergeAllOf(resolvedSchema) : mergeAllOf(resolvedSchema);
         if (withContainsSchemas.length) {
           resolvedSchema.allOf = withContainsSchemas;
         }
@@ -1679,7 +1687,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;
@@ -1689,7 +1697,8 @@ function computeDefaults(validator, rawSchema, computeDefaultsProps = {}) {
       updatedRecurseList = _recurseList.concat(refName);
       schemaToCompute = findSchemaDefinition(refName, rootSchema);
     }
-    if (schemaToCompute && !defaults) {
+    const hasNoExistingData = rawFormData === void 0 || isObject(rawFormData) && (0, import_isEmpty4.default)(rawFormData);
+    if (schemaToCompute && !defaults && hasNoExistingData) {
       defaults = schema.default;
     }
     if (shouldMergeDefaultsIntoFormData && schemaToCompute && !isObject(rawFormData)) {
@@ -1833,7 +1842,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) => {
@@ -1927,12 +1937,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
@@ -2097,8 +2109,175 @@ function getDisplayLabel(validator, schema, uiSchema = {}, rootSchema, globalOpt
   return displayLabel;
 }
 
-// src/schema/sanitizeDataForNewSchema.ts
+// src/schema/omitExtraData.ts
+var import_pick = __toESM(require("lodash/pick"), 1);
+var import_isEmpty5 = __toESM(require("lodash/isEmpty"), 1);
+var import_get15 = __toESM(require("lodash/get"), 1);
+
+// src/schema/toPathSchema.ts
 var import_get14 = __toESM(require("lodash/get"), 1);
+var import_set2 = __toESM(require("lodash/set"), 1);
+function toPathSchemaInternal(validator, schema, name, rootSchema, formData, _recurseList = [], experimental_customMergeAllOf) {
+  if (REF_KEY in schema || DEPENDENCIES_KEY in schema || ALL_OF_KEY in schema || 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) {
+    (0, import_set2.default)(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 = (0, import_get14.default)(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
+        (0, import_get14.default)(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 = (0, import_pick.default)(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" || (0, import_isEmpty5.default)(value) || isLeaf && !(0, import_isEmpty5.default)(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 = (0, import_get15.default)(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
+var import_get16 = __toESM(require("lodash/get"), 1);
 var import_has5 = __toESM(require("lodash/has"), 1);
 var NO_VALUE = Symbol("no Value");
 function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, data = {}, experimental_customMergeAllOf) {
@@ -2106,19 +2285,19 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
   if ((0, import_has5.default)(newSchema, PROPERTIES_KEY)) {
     const removeOldSchemaData = {};
     if ((0, import_has5.default)(oldSchema, PROPERTIES_KEY)) {
-      const properties = (0, import_get14.default)(oldSchema, PROPERTIES_KEY, {});
+      const properties = (0, import_get16.default)(oldSchema, PROPERTIES_KEY, {});
       Object.keys(properties).forEach((key) => {
         if ((0, import_has5.default)(data, key)) {
           removeOldSchemaData[key] = void 0;
         }
       });
     }
-    const keys2 = Object.keys((0, import_get14.default)(newSchema, PROPERTIES_KEY, {}));
+    const keys2 = Object.keys((0, import_get16.default)(newSchema, PROPERTIES_KEY, {}));
     const nestedData = {};
     keys2.forEach((key) => {
-      const formValue = (0, import_get14.default)(data, key);
-      let oldKeyedSchema = (0, import_get14.default)(oldSchema, [PROPERTIES_KEY, key], {});
-      let newKeyedSchema = (0, import_get14.default)(newSchema, [PROPERTIES_KEY, key], {});
+      const formValue = (0, import_get16.default)(data, key);
+      let oldKeyedSchema = (0, import_get16.default)(oldSchema, [PROPERTIES_KEY, key], {});
+      let newKeyedSchema = (0, import_get16.default)(newSchema, [PROPERTIES_KEY, key], {});
       if ((0, import_has5.default)(oldKeyedSchema, REF_KEY)) {
         oldKeyedSchema = retrieveSchema(
           validator,
@@ -2137,8 +2316,8 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
           experimental_customMergeAllOf
         );
       }
-      const oldSchemaTypeForKey = (0, import_get14.default)(oldKeyedSchema, "type");
-      const newSchemaTypeForKey = (0, import_get14.default)(newKeyedSchema, "type");
+      const oldSchemaTypeForKey = (0, import_get16.default)(oldKeyedSchema, "type");
+      const newSchemaTypeForKey = (0, import_get16.default)(newKeyedSchema, "type");
       if (!oldSchemaTypeForKey || oldSchemaTypeForKey === newSchemaTypeForKey) {
         if ((0, import_has5.default)(removeOldSchemaData, key)) {
           delete removeOldSchemaData[key];
@@ -2156,17 +2335,17 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
             nestedData[key] = itemData;
           }
         } else {
-          const newOptionDefault = (0, import_get14.default)(newKeyedSchema, "default", NO_VALUE);
-          const oldOptionDefault = (0, import_get14.default)(oldKeyedSchema, "default", NO_VALUE);
+          const newOptionDefault = (0, import_get16.default)(newKeyedSchema, "default", NO_VALUE);
+          const oldOptionDefault = (0, import_get16.default)(oldKeyedSchema, "default", NO_VALUE);
           if (newOptionDefault !== NO_VALUE && newOptionDefault !== formValue) {
             if (oldOptionDefault === formValue) {
               removeOldSchemaData[key] = newOptionDefault;
-            } else if ((0, import_get14.default)(newKeyedSchema, "readOnly") === true) {
+            } else if ((0, import_get16.default)(newKeyedSchema, "readOnly") === true) {
               removeOldSchemaData[key] = void 0;
             }
           }
-          const newOptionConst = (0, import_get14.default)(newKeyedSchema, "const", NO_VALUE);
-          const oldOptionConst = (0, import_get14.default)(oldKeyedSchema, "const", NO_VALUE);
+          const newOptionConst = (0, import_get16.default)(newKeyedSchema, "const", NO_VALUE);
+          const oldOptionConst = (0, import_get16.default)(oldKeyedSchema, "const", NO_VALUE);
           if (newOptionConst !== NO_VALUE && newOptionConst !== formValue) {
             removeOldSchemaData[key] = oldOptionConst === formValue ? newOptionConst : void 0;
           }
@@ -2178,9 +2357,9 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
       ...removeOldSchemaData,
       ...nestedData
     };
-  } else if ((0, import_get14.default)(oldSchema, "type") === "array" && (0, import_get14.default)(newSchema, "type") === "array" && Array.isArray(data)) {
-    let oldSchemaItems = (0, import_get14.default)(oldSchema, "items");
-    let newSchemaItems = (0, import_get14.default)(newSchema, "items");
+  } else if ((0, import_get16.default)(oldSchema, "type") === "array" && (0, import_get16.default)(newSchema, "type") === "array" && Array.isArray(data)) {
+    let oldSchemaItems = (0, import_get16.default)(oldSchema, "items");
+    let newSchemaItems = (0, import_get16.default)(newSchema, "items");
     if (typeof oldSchemaItems === "object" && typeof newSchemaItems === "object" && !Array.isArray(oldSchemaItems) && !Array.isArray(newSchemaItems)) {
       if ((0, import_has5.default)(oldSchemaItems, REF_KEY)) {
         oldSchemaItems = retrieveSchema(
@@ -2200,10 +2379,10 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
           experimental_customMergeAllOf
         );
       }
-      const oldSchemaType = (0, import_get14.default)(oldSchemaItems, "type");
-      const newSchemaType = (0, import_get14.default)(newSchemaItems, "type");
+      const oldSchemaType = (0, import_get16.default)(oldSchemaItems, "type");
+      const newSchemaType = (0, import_get16.default)(newSchemaItems, "type");
       if (!oldSchemaType || oldSchemaType === newSchemaType) {
-        const maxItems = (0, import_get14.default)(newSchema, "maxItems", -1);
+        const maxItems = (0, import_get16.default)(newSchema, "maxItems", -1);
         if (newSchemaType === "object") {
           newFormData = data.reduce((newValue, aValue) => {
             const itemValue = sanitizeDataForNewSchema(
@@ -2230,122 +2409,8 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
   return newFormData;
 }
 
-// src/schema/toPathSchema.ts
-var import_get15 = __toESM(require("lodash/get"), 1);
-var import_set2 = __toESM(require("lodash/set"), 1);
-function toPathSchemaInternal(validator, schema, name, rootSchema, formData, _recurseList = [], experimental_customMergeAllOf) {
-  if (REF_KEY in schema || DEPENDENCIES_KEY in schema || ALL_OF_KEY in schema) {
-    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) {
-    (0, import_set2.default)(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 = (0, import_get15.default)(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
-        (0, import_get15.default)(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
-var import_get16 = __toESM(require("lodash/get"), 1);
+var import_get17 = __toESM(require("lodash/get"), 1);
 var SchemaUtils = class {
   /** Constructs the `SchemaUtils` instance with the given `validator` and `rootSchema` stored as instance variables
    *
@@ -2356,7 +2421,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, (0, import_get16.default)(rootSchema, ID_KEY, "#"));
+      this.rootSchema = makeAllReferencesAbsolute(rootSchema, (0, import_get17.default)(rootSchema, ID_KEY, "#"));
     } else {
       this.rootSchema = rootSchema;
     }
@@ -2548,6 +2613,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.
@@ -2770,7 +2847,7 @@ function enumOptionsSelectValue(valueIndex, selected, allEnumOptions = []) {
 
 // src/ErrorSchemaBuilder.ts
 var import_cloneDeep = __toESM(require("lodash/cloneDeep"), 1);
-var import_get17 = __toESM(require("lodash/get"), 1);
+var import_get18 = __toESM(require("lodash/get"), 1);
 var import_set3 = __toESM(require("lodash/set"), 1);
 var import_setWith = __toESM(require("lodash/setWith"), 1);
 var ErrorSchemaBuilder = class {
@@ -2799,7 +2876,7 @@ var ErrorSchemaBuilder = class {
    */
   getOrCreateErrorBlock(pathOfError) {
     const hasPath = Array.isArray(pathOfError) && pathOfError.length > 0 || typeof pathOfError === "string";
-    let errorBlock = hasPath ? (0, import_get17.default)(this.errorSchema, pathOfError) : this.errorSchema;
+    let errorBlock = hasPath ? (0, import_get18.default)(this.errorSchema, pathOfError) : this.errorSchema;
     if (!errorBlock && pathOfError) {
       errorBlock = {};
       (0, import_setWith.default)(this.errorSchema, pathOfError, errorBlock, Object);
@@ -2825,7 +2902,7 @@ var ErrorSchemaBuilder = class {
    */
   addErrors(errorOrList, pathOfError) {
     const errorBlock = this.getOrCreateErrorBlock(pathOfError);
-    let errorsList = (0, import_get17.default)(errorBlock, ERRORS_KEY);
+    let errorsList = (0, import_get18.default)(errorBlock, ERRORS_KEY);
     if (!Array.isArray(errorsList)) {
       errorsList = [];
       errorBlock[ERRORS_KEY] = errorsList;
@@ -2869,7 +2946,7 @@ var ErrorSchemaBuilder = class {
 var import_keys = __toESM(require("lodash/keys"), 1);
 var import_pickBy = __toESM(require("lodash/pickBy"), 1);
 var import_isPlainObject2 = __toESM(require("lodash/isPlainObject"), 1);
-var import_get18 = __toESM(require("lodash/get"), 1);
+var import_get19 = __toESM(require("lodash/get"), 1);
 var import_difference = __toESM(require("lodash/difference"), 1);
 function getChangedFields(a, b) {
   const aIsPlainObject = (0, import_isPlainObject2.default)(a);
@@ -2882,7 +2959,7 @@ function getChangedFields(a, b) {
   } else if (!aIsPlainObject && bIsPlainObject) {
     return (0, import_keys.default)(b);
   } else {
-    const unequalFields = (0, import_keys.default)((0, import_pickBy.default)(a, (value, key) => !deepEquals(value, (0, import_get18.default)(b, key))));
+    const unequalFields = (0, import_keys.default)((0, import_pickBy.default)(a, (value, key) => !deepEquals(value, (0, import_get19.default)(b, key))));
     const diffFields = (0, import_difference.default)((0, import_keys.default)(b), (0, import_keys.default)(a));
     return [...unequalFields, ...diffFields];
   }
@@ -2996,10 +3073,10 @@ function getTemplate(name, registry, uiOptions = {}) {
 }
 
 // src/getTestIds.ts
-var import_get19 = __toESM(require("lodash/get"), 1);
+var import_get20 = __toESM(require("lodash/get"), 1);
 var import_uniqueId = __toESM(require("lodash/uniqueId"), 1);
 function getTestIds() {
-  if (typeof process === "undefined" || (0, import_get19.default)(process, "env.NODE_ENV") !== "test") {
+  if (typeof process === "undefined" || (0, import_get20.default)(process, "env.NODE_ENV") !== "test") {
     return {};
   }
   const ids = /* @__PURE__ */ new Map();
@@ -3019,7 +3096,7 @@ function getTestIds() {
 // src/getWidget.tsx
 var import_react = require("react");
 var import_react_is = __toESM(require("react-is"), 1);
-var import_get20 = __toESM(require("lodash/get"), 1);
+var import_get21 = __toESM(require("lodash/get"), 1);
 var import_set4 = __toESM(require("lodash/set"), 1);
 var import_jsx_runtime = require("react/jsx-runtime");
 var widgetMap = {
@@ -3075,7 +3152,7 @@ var widgetMap = {
   }
 };
 function mergeWidgetOptions(AWidget) {
-  let MergedWidget = (0, import_get20.default)(AWidget, "MergedWidget");
+  let MergedWidget = (0, import_get21.default)(AWidget, "MergedWidget");
   if (!MergedWidget) {
     const defaultOptions = AWidget.defaultProps && AWidget.defaultProps.options || {};
     MergedWidget = ({ options, ...props }) => {
@@ -3182,10 +3259,10 @@ function optionalControlsId(id, element) {
 
 // src/isFormDataAvailable.ts
 var import_isNil3 = __toESM(require("lodash/isNil"), 1);
-var import_isEmpty5 = __toESM(require("lodash/isEmpty"), 1);
+var import_isEmpty6 = __toESM(require("lodash/isEmpty"), 1);
 var import_isObject11 = __toESM(require("lodash/isObject"), 1);
 function isFormDataAvailable(formData) {
-  return !(0, import_isNil3.default)(formData) && (!(0, import_isObject11.default)(formData) || Array.isArray(formData) || !(0, import_isEmpty5.default)(formData));
+  return !(0, import_isNil3.default)(formData) && (!(0, import_isObject11.default)(formData) || Array.isArray(formData) || !(0, import_isEmpty6.default)(formData));
 }
 
 // src/isRootSchema.ts
@@ -3213,14 +3290,14 @@ function localToUTC(dateString) {
 }
 
 // src/lookupFromFormContext.ts
-var import_get21 = __toESM(require("lodash/get"), 1);
+var import_get22 = __toESM(require("lodash/get"), 1);
 var import_has6 = __toESM(require("lodash/has"), 1);
 function lookupFromFormContext(regOrFc, toLookup, fallback) {
   const lookupPath = [LOOKUP_MAP_NAME];
   if ((0, import_has6.default)(regOrFc, FORM_CONTEXT_NAME)) {
     lookupPath.unshift(FORM_CONTEXT_NAME);
   }
-  return (0, import_get21.default)(regOrFc, [...lookupPath, toLookup], fallback);
+  return (0, import_get22.default)(regOrFc, [...lookupPath, toLookup], fallback);
 }
 
 // src/orderProperties.ts
@@ -3644,7 +3721,7 @@ function utcToLocal(jsonDate) {
 }
 
 // src/validationDataMerge.ts
-var import_isEmpty6 = __toESM(require("lodash/isEmpty"), 1);
+var import_isEmpty7 = __toESM(require("lodash/isEmpty"), 1);
 function validationDataMerge(validationData, additionalErrorSchema, preventDuplicates = false) {
   if (!additionalErrorSchema) {
     return validationData;
@@ -3652,7 +3729,7 @@ function validationDataMerge(validationData, additionalErrorSchema, preventDupli
   const { errors: oldErrors, errorSchema: oldErrorSchema } = validationData;
   let errors = toErrorList(additionalErrorSchema);
   let errorSchema = additionalErrorSchema;
-  if (!(0, import_isEmpty6.default)(oldErrorSchema)) {
+  if (!(0, import_isEmpty7.default)(oldErrorSchema)) {
     errorSchema = mergeObjects(
       oldErrorSchema,
       additionalErrorSchema,
@@ -3740,6 +3817,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";
@@ -3757,7 +3835,7 @@ var TranslatableString = /* @__PURE__ */ ((TranslatableString2) => {
 var import_forEach = __toESM(require("lodash/forEach"), 1);
 
 // src/parser/ParserValidator.ts
-var import_get22 = __toESM(require("lodash/get"), 1);
+var import_get23 = __toESM(require("lodash/get"), 1);
 var ParserValidator = class {
   /** Construct the ParserValidator for the given `rootSchema`. This `rootSchema` will be stashed in the `schemaMap`
    * first.
@@ -3783,7 +3861,7 @@ var ParserValidator = class {
    * @param hash - The hash value at which to map the schema
    */
   addSchema(schema, hash) {
-    const key = (0, import_get22.default)(schema, ID_KEY, hash);
+    const key = (0, import_get23.default)(schema, ID_KEY, hash);
     const identifiedSchema = { ...schema, [ID_KEY]: key };
     const existing = this.schemaMap[key];
     if (!existing) {