rsuite 5.70.1 → 5.70.3

package/esm/Form/Form.js

@@ -53,7 +53,7 @@ var Form = /*#__PURE__*/React.forwardRef(function (props, ref) {
     onError = props.onError,
     onChange = props.onChange,
     rest = _objectWithoutPropertiesLoose(props, _excluded);
-  var _useSchemaModel = useSchemaModel(formModel),
+  var _useSchemaModel = useSchemaModel(formModel, nestedField),
     getCombinedModel = _useSchemaModel.getCombinedModel,
     pushFieldRule = _useSchemaModel.pushFieldRule,
     removeFieldRule = _useSchemaModel.removeFieldRule;

package/esm/Form/hooks/useFormValidate.d.ts

@@ -6,7 +6,7 @@ export interface FormErrorProps {
     onError?: (formError: any) => void;
     nestedField?: boolean;
 }
-export default function useFormValidate(formError: any, props: FormErrorProps): {
+export default function useFormValidate(_formError: any, props: FormErrorProps): {
     formError: any;
     check: (...args: any[]) => any;
     checkForField: (...args: any[]) => any;

package/esm/Form/hooks/useFormValidate.js

@@ -8,13 +8,13 @@ import omit from 'lodash/omit';
 import set from 'lodash/set';
 import { useControlled, useEventCallback } from "../../internals/hooks/index.js";
 import { nameToPath } from "../../FormControl/utils.js";
-export default function useFormValidate(formError, props) {
+export default function useFormValidate(_formError, props) {
   var formValue = props.formValue,
     getCombinedModel = props.getCombinedModel,
     onCheck = props.onCheck,
     onError = props.onError,
     nestedField = props.nestedField;
-  var _useControlled = useControlled(formError, {}),
+  var _useControlled = useControlled(_formError, {}),
     realFormError = _useControlled[0],
     setFormError = _useControlled[1];
   var checkOptions = {
@@ -32,12 +32,29 @@ export default function useFormValidate(formError, props) {
     var formError = {};
     var errorCount = 0;
     var model = getCombinedModel();
-    Object.keys(model.getSchemaSpec()).forEach(function (key) {
-      var checkResult = model.checkForField(key, formValue || {}, checkOptions);
+    var checkField = function checkField(key, type, value, formErrorObj) {
+      var checkResult = type.check(value);
       if (checkResult.hasError === true) {
         errorCount += 1;
-        formError[key] = (checkResult === null || checkResult === void 0 ? void 0 : checkResult.errorMessage) || checkResult;
+        formErrorObj[key] = (checkResult === null || checkResult === void 0 ? void 0 : checkResult.errorMessage) || checkResult;
+      }
+
+      // Check nested object
+      if (type !== null && type !== void 0 && type.objectTypeSchemaSpec) {
+        Object.entries(type.objectTypeSchemaSpec).forEach(function (_ref) {
+          var nestedKey = _ref[0],
+            nestedType = _ref[1];
+          formErrorObj[key] = formErrorObj[key] || {
+            object: {}
+          };
+          checkField(nestedKey, nestedType, value === null || value === void 0 ? void 0 : value[nestedKey], formErrorObj[key].object);
+        });
       }
+    };
+    Object.entries(model.getSchemaSpec()).forEach(function (_ref2) {
+      var key = _ref2[0],
+        type = _ref2[1];
+      checkField(key, type, formValue[key], formError);
     });
     setFormError(formError);
     onCheck === null || onCheck === void 0 ? void 0 : onCheck(formError);
@@ -51,7 +68,7 @@ export default function useFormValidate(formError, props) {
   var checkFieldForNextValue = useEventCallback(function (fieldName, nextValue, callback) {
     var model = getCombinedModel();
     var resultOfCurrentField = model.checkForField(fieldName, nextValue, checkOptions);
-    var nextFormError = _extends({}, formError);
+    var nextFormError = _extends({}, realFormError);
     /**
      * when using proxy of schema-typed, we need to use getCheckResult to get all errors,
      * but if nestedField is used, it is impossible to distinguish whether the nested object has an error here,
@@ -134,7 +151,7 @@ export default function useFormValidate(formError, props) {
   var checkFieldAsyncForNextValue = useEventCallback(function (fieldName, nextValue) {
     var model = getCombinedModel();
     return model.checkForFieldAsync(fieldName, nextValue, checkOptions).then(function (resultOfCurrentField) {
-      var nextFormError = _extends({}, formError);
+      var nextFormError = _extends({}, realFormError);
       /**
        * when using proxy of schema-typed, we need to use getCheckResult to get all errors,
        * but if nestedField is used, it is impossible to distinguish whether the nested object has an error here,
@@ -203,7 +220,7 @@ export default function useFormValidate(formError, props) {
     setFormError(formError);
   });
   var cleanErrorForField = useEventCallback(function (fieldName) {
-    setFormError(omit(formError, [nestedField ? nameToPath(fieldName) : fieldName]));
+    setFormError(omit(realFormError, [nestedField ? nameToPath(fieldName) : fieldName]));
   });
   return {
     formError: realFormError,

package/esm/Form/hooks/useSchemaModel.d.ts

@@ -1,7 +1,7 @@
 import type { MutableRefObject } from 'react';
 import type { CheckType, Schema } from 'schema-typed';
 export type FieldRuleType = MutableRefObject<CheckType<unknown, any> | undefined>;
-declare function useSchemaModel(formModel: Schema): {
+declare function useSchemaModel(formModel: Schema, nestedField: boolean): {
     getCombinedModel: () => Schema<any, string>;
     pushFieldRule: (name: string, fieldRule: FieldRuleType) => void;
     removeFieldRule: (name: string) => void;

package/esm/Form/hooks/useSchemaModel.js

@@ -1,7 +1,59 @@
 'use client';
-import { SchemaModel } from 'schema-typed';
+import { SchemaModel, ObjectType } from 'schema-typed';
 import { useRef, useCallback } from 'react';
-function useSchemaModel(formModel) {
+/**
+ * Convert a flat schema object to a nested schema object
+ *
+ * @example
+ *
+ * ```js
+ * const schema = {
+ *  'address.city': StringType().isRequired('City is required'),
+ *  'address.street': StringType().isRequired('Street is required')
+ * };
+ *
+ * const result = unflattenSchemaObject(schema);
+ *
+ * // result
+ * {
+ *    address: ObjectType().shape({
+ *      city: StringType().isRequired('City is required'),
+ *      street: StringType().isRequired('Street is required')
+ *    })
+ * }
+ * ```
+ */
+function unflattenSchemaObject(schema) {
+  var result = {};
+  var $type = Symbol('schema-type');
+  Object.keys(schema).forEach(function (key) {
+    if (key.includes('.')) {
+      var keys = key.split('.');
+      var lastKey = keys.pop() || '';
+      var current = result;
+      keys.forEach(function (subKey) {
+        var _ref;
+        current[subKey] = current[subKey] || (_ref = {}, _ref[$type] = 'object-type', _ref);
+        current = current[subKey];
+      });
+      current[lastKey] = schema[key];
+    } else {
+      result[key] = schema[key];
+    }
+  });
+  function convertToShape(obj) {
+    Object.keys(obj).forEach(function (key) {
+      var _obj$key;
+      if (((_obj$key = obj[key]) === null || _obj$key === void 0 ? void 0 : _obj$key[$type]) === 'object-type') {
+        delete obj[key][$type];
+        obj[key] = ObjectType().shape(convertToShape(obj[key]));
+      }
+    });
+    return obj;
+  }
+  return convertToShape(result);
+}
+function useSchemaModel(formModel, nestedField) {
   var subRulesRef = useRef([]);
   var pushFieldRule = useCallback(function (name, fieldRule) {
     subRulesRef.current.push({
@@ -24,15 +76,16 @@ function useSchemaModel(formModel) {
     if (realSubRules.length === 0) {
       return formModel;
     }
-    return SchemaModel.combine(formModel, SchemaModel(realSubRules.map(function (_ref) {
-      var _ref2;
-      var name = _ref.name,
-        fieldRule = _ref.fieldRule;
-      return _ref2 = {}, _ref2[name] = fieldRule.current, _ref2;
+    var subRuleObject = realSubRules.map(function (_ref2) {
+      var _ref3;
+      var name = _ref2.name,
+        fieldRule = _ref2.fieldRule;
+      return _ref3 = {}, _ref3[name] = fieldRule.current, _ref3;
     }).reduce(function (a, b) {
       return Object.assign(a, b);
-    }, {})));
-  }, [formModel]);
+    }, {});
+    return SchemaModel.combine(formModel, SchemaModel(nestedField ? unflattenSchemaObject(subRuleObject) : subRuleObject));
+  }, [formModel, nestedField]);
   return {
     getCombinedModel: getCombinedModel,
     pushFieldRule: pushFieldRule,

package/esm/FormControl/hooks/useField.js

@@ -6,6 +6,10 @@ import set from 'lodash/set';
 import { nameToPath } from "../utils.js";
 function getErrorMessage(error) {
   var _error$array;
+  if (typeof error === 'string') {
+    return error;
+  }
+
   /**
    * When using some components as the field, such as TagInput, and using `ArrayType().of` as the validation rule,
    * the error object won't contain the errorMessage directly. @see https://github.com/rsuite/rsuite/issues/3866

package/esm/Tree/hooks/useFlattenTree.js

@@ -85,8 +85,14 @@ function useFlattenTree(data, options) {
       updateTreeNodeCheckState(value);
       forceUpdate();
     }
+
+    /**
+     * Add a dependency on data, because when loading data asynchronously through getChildren,
+     * data may change and the node status needs to be updated.
+     * @see https://github.com/rsuite/rsuite/issues/3973
+     */
     // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [value]);
+  }, [value, data]);
   return flattenedNodes.current;
 }
 export default useFlattenTree;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rsuite",
-  "version": "5.70.1",
+  "version": "5.70.3",
   "description": "A suite of react components",
   "main": "cjs/index.js",
   "module": "esm/index.js",