rsuite 5.75.0 → 6.0.0-canary-20241227

package/cjs/Form/hooks/useFormValidate.js

@@ -4,28 +4,24 @@
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 exports.__esModule = true;
 exports.default = useFormValidate;
-var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutPropertiesLoose"));
-var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
 var _react = require("react");
 var _omit = _interopRequireDefault(require("lodash/omit"));
 var _set = _interopRequireDefault(require("lodash/set"));
 var _hooks = require("../../internals/hooks");
 var _utils = require("../../FormControl/utils");
-function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
-function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 function useFormValidate(_formError, props) {
-  var formValue = props.formValue,
-    getCombinedModel = props.getCombinedModel,
-    onCheck = props.onCheck,
-    onError = props.onError,
-    nestedField = props.nestedField;
-  var _useControlled = (0, _hooks.useControlled)(_formError, {}),
-    realFormError = _useControlled[0],
-    setFormError = _useControlled[1];
-  var checkOptions = {
+  const {
+    formValue,
+    getCombinedModel,
+    onCheck,
+    onError,
+    nestedField
+  } = props;
+  const [realFormError, setFormError] = (0, _hooks.useControlled)(_formError, {});
+  const checkOptions = {
     nestedObject: nestedField
   };
-  var realFormErrorRef = (0, _react.useRef)(realFormError);
+  const realFormErrorRef = (0, _react.useRef)(realFormError);
   realFormErrorRef.current = realFormError;
 
   /**
@@ -33,13 +29,13 @@ function useFormValidate(_formError, props) {
    * The error message after verification is returned in the callback.
    * @param callback
    */
-  var check = (0, _hooks.useEventCallback)(function (callback) {
-    var formError = {};
-    var errorCount = 0;
-    var model = getCombinedModel();
-    var _checkField = function checkField(key, type, value, formErrorObj) {
+  const check = (0, _hooks.useEventCallback)(callback => {
+    const formError = {};
+    let errorCount = 0;
+    const model = getCombinedModel();
+    const checkField = (key, type, value, formErrorObj) => {
       model.setSchemaOptionsForAllType(formValue || {});
-      var checkResult = type.check(value, formValue, key);
+      const checkResult = type.check(value, formValue, key);
       if (checkResult.hasError === true) {
         errorCount += 1;
         formErrorObj[key] = (checkResult === null || checkResult === void 0 ? void 0 : checkResult.errorMessage) || checkResult;
@@ -47,20 +43,18 @@ function useFormValidate(_formError, props) {
 
       // 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];
+        Object.entries(type.objectTypeSchemaSpec).forEach(_ref => {
+          let [nestedKey, nestedType] = _ref;
           formErrorObj[key] = formErrorObj[key] || {
             object: {}
           };
-          _checkField(nestedKey, nestedType, value === null || value === void 0 ? void 0 : value[nestedKey], 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);
+    Object.entries(model.getSchemaSpec()).forEach(_ref2 => {
+      let [key, type] = _ref2;
+      checkField(key, type, formValue[key], formError);
     });
     setFormError(formError);
     onCheck === null || onCheck === void 0 || onCheck(formError);
@@ -71,10 +65,12 @@ function useFormValidate(_formError, props) {
     }
     return true;
   });
-  var checkFieldForNextValue = (0, _hooks.useEventCallback)(function (fieldName, nextValue, callback) {
-    var model = getCombinedModel();
-    var resultOfCurrentField = model.checkForField(fieldName, nextValue, checkOptions);
-    var nextFormError = (0, _extends2.default)({}, realFormError);
+  const checkFieldForNextValue = (0, _hooks.useEventCallback)((fieldName, nextValue, callback) => {
+    const model = getCombinedModel();
+    const resultOfCurrentField = model.checkForField(fieldName, nextValue, checkOptions);
+    let nextFormError = {
+      ...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,
@@ -90,18 +86,19 @@ function useFormValidate(_formError, props) {
       }
       return !resultOfCurrentField.hasError;
     } else {
-      var allResults = model.getCheckResult();
-      var hasError = false;
-      Object.keys(allResults).forEach(function (key) {
-        var currentResult = allResults[key];
+      const allResults = model.getCheckResult();
+      let hasError = false;
+      Object.keys(allResults).forEach(key => {
+        const currentResult = allResults[key];
         if (currentResult.hasError) {
           nextFormError[key] = currentResult.errorMessage || currentResult;
           hasError = true;
         } else {
           // eslint-disable-next-line @typescript-eslint/no-unused-vars
-          var _nextFormError = nextFormError,
-            _ = _nextFormError[key],
-            rest = (0, _objectWithoutPropertiesLoose2.default)(_nextFormError, [key].map(_toPropertyKey));
+          const {
+            [key]: _,
+            ...rest
+          } = nextFormError;
           nextFormError = rest;
         }
       });
@@ -119,25 +116,25 @@ function useFormValidate(_formError, props) {
    * @param fieldName
    * @param callback
    */
-  var checkForField = (0, _hooks.useEventCallback)(function (fieldName, callback) {
+  const checkForField = (0, _hooks.useEventCallback)((fieldName, callback) => {
     return checkFieldForNextValue(fieldName, formValue || {}, callback);
   });
 
   /**
    * Check form data asynchronously and return a Promise
    */
-  var checkAsync = (0, _hooks.useEventCallback)(function () {
-    var promises = [];
-    var keys = [];
-    var model = getCombinedModel();
-    Object.keys(model.getSchemaSpec()).forEach(function (key) {
+  const checkAsync = (0, _hooks.useEventCallback)(() => {
+    const promises = [];
+    const keys = [];
+    const model = getCombinedModel();
+    Object.keys(model.getSchemaSpec()).forEach(key => {
       keys.push(key);
       promises.push(model.checkForFieldAsync(key, formValue || {}, checkOptions));
     });
-    return Promise.all(promises).then(function (values) {
-      var formError = {};
-      var errorCount = 0;
-      for (var i = 0; i < values.length; i++) {
+    return Promise.all(promises).then(values => {
+      const formError = {};
+      let errorCount = 0;
+      for (let i = 0; i < values.length; i++) {
         if (values[i].hasError) {
           errorCount += 1;
           formError[keys[i]] = values[i].errorMessage;
@@ -150,14 +147,16 @@ function useFormValidate(_formError, props) {
       }
       return {
         hasError: errorCount > 0,
-        formError: formError
+        formError
       };
     });
   });
-  var checkFieldAsyncForNextValue = (0, _hooks.useEventCallback)(function (fieldName, nextValue) {
-    var model = getCombinedModel();
-    return model.checkForFieldAsync(fieldName, nextValue, checkOptions).then(function (resultOfCurrentField) {
-      var nextFormError = (0, _extends2.default)({}, realFormError);
+  const checkFieldAsyncForNextValue = (0, _hooks.useEventCallback)((fieldName, nextValue) => {
+    const model = getCombinedModel();
+    return model.checkForFieldAsync(fieldName, nextValue, checkOptions).then(resultOfCurrentField => {
+      let nextFormError = {
+        ...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,
@@ -173,18 +172,19 @@ function useFormValidate(_formError, props) {
         }
         return resultOfCurrentField;
       } else {
-        var allResults = model.getCheckResult();
-        var hasError = false;
-        Object.keys(allResults).forEach(function (key) {
-          var currentResult = allResults[key];
+        const allResults = model.getCheckResult();
+        let hasError = false;
+        Object.keys(allResults).forEach(key => {
+          const currentResult = allResults[key];
           if (currentResult.hasError) {
             nextFormError[key] = currentResult.errorMessage || currentResult;
             hasError = true;
           } else {
             // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            var _nextFormError2 = nextFormError,
-              _ = _nextFormError2[key],
-              rest = (0, _objectWithoutPropertiesLoose2.default)(_nextFormError2, [key].map(_toPropertyKey));
+            const {
+              [key]: _,
+              ...rest
+            } = nextFormError;
             nextFormError = rest;
           }
         });
@@ -202,43 +202,43 @@ function useFormValidate(_formError, props) {
    * Asynchronously check form fields and return Promise
    * @param fieldName
    */
-  var checkForFieldAsync = (0, _hooks.useEventCallback)(function (fieldName) {
+  const checkForFieldAsync = (0, _hooks.useEventCallback)(fieldName => {
     return checkFieldAsyncForNextValue(fieldName, formValue || {});
   });
-  var onRemoveError = (0, _react.useCallback)(function (name) {
+  const onRemoveError = (0, _react.useCallback)(name => {
     /**
      * when this function is called when the children component is unmount,
      * it's an old render frame so use Ref to get future error
      */
-    var formError = (0, _omit.default)(realFormErrorRef.current, [nestedField ? (0, _utils.nameToPath)(name) : name]);
+    const formError = (0, _omit.default)(realFormErrorRef.current, [nestedField ? (0, _utils.nameToPath)(name) : name]);
     realFormErrorRef.current = formError;
     setFormError(formError);
     onCheck === null || onCheck === void 0 || onCheck(formError);
     return formError;
   }, [nestedField, onCheck, setFormError]);
-  var cleanErrors = (0, _hooks.useEventCallback)(function () {
+  const cleanErrors = (0, _hooks.useEventCallback)(() => {
     setFormError({});
   });
-  var resetErrors = (0, _hooks.useEventCallback)(function (formError) {
+  const resetErrors = (0, _hooks.useEventCallback)(function (formError) {
     if (formError === void 0) {
       formError = {};
     }
     setFormError(formError);
   });
-  var cleanErrorForField = (0, _hooks.useEventCallback)(function (fieldName) {
+  const cleanErrorForField = (0, _hooks.useEventCallback)(fieldName => {
     setFormError((0, _omit.default)(realFormError, [nestedField ? (0, _utils.nameToPath)(fieldName) : fieldName]));
   });
   return {
     formError: realFormError,
-    check: check,
-    checkForField: checkForField,
-    checkFieldForNextValue: checkFieldForNextValue,
-    checkAsync: checkAsync,
-    checkForFieldAsync: checkForFieldAsync,
-    checkFieldAsyncForNextValue: checkFieldAsyncForNextValue,
-    cleanErrors: cleanErrors,
-    resetErrors: resetErrors,
-    cleanErrorForField: cleanErrorForField,
-    onRemoveError: onRemoveError
+    check,
+    checkForField,
+    checkFieldForNextValue,
+    checkAsync,
+    checkForFieldAsync,
+    checkFieldAsyncForNextValue,
+    cleanErrors,
+    resetErrors,
+    cleanErrorForField,
+    onRemoveError
   };
 }

package/cjs/Form/hooks/useFormValue.js

@@ -4,45 +4,48 @@
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 exports.__esModule = true;
 exports.default = useFormValue;
-var _extends3 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
 var _react = require("react");
 var _omit = _interopRequireDefault(require("lodash/omit"));
 var _set = _interopRequireDefault(require("lodash/set"));
 var _hooks = require("../../internals/hooks");
 function useFormValue(controlledValue, props) {
-  var formDefaultValue = props.formDefaultValue,
-    nestedField = props.nestedField;
-  var _useControlled = (0, _hooks.useControlled)(controlledValue, formDefaultValue),
-    formValue = _useControlled[0],
-    setFormValue = _useControlled[1];
-  var realFormValueRef = (0, _react.useRef)(formValue);
+  const {
+    formDefaultValue,
+    nestedField
+  } = props;
+  const [formValue, setFormValue] = (0, _hooks.useControlled)(controlledValue, formDefaultValue);
+  const realFormValueRef = (0, _react.useRef)(formValue);
   realFormValueRef.current = formValue;
-  var setFieldValue = (0, _react.useCallback)(function (fieldName, fieldValue) {
-    var _extends2;
-    var nextFormError = nestedField ? (0, _set.default)((0, _extends3.default)({}, formValue), fieldName, fieldValue) : (0, _extends3.default)({}, formValue, (_extends2 = {}, _extends2[fieldName] = fieldValue, _extends2));
+  const setFieldValue = (0, _react.useCallback)((fieldName, fieldValue) => {
+    const nextFormError = nestedField ? (0, _set.default)({
+      ...formValue
+    }, fieldName, fieldValue) : {
+      ...formValue,
+      [fieldName]: fieldValue
+    };
     setFormValue(nextFormError);
     return nextFormError;
   }, [formValue, nestedField, setFormValue]);
-  var onRemoveValue = (0, _react.useCallback)(function (name) {
+  const onRemoveValue = (0, _react.useCallback)(name => {
     /**
      * when this function is called when the children component is unmount,
      * it's an old render frame so use Ref to get future value
      */
-    var formValue = (0, _omit.default)(realFormValueRef.current, [name]);
+    const formValue = (0, _omit.default)(realFormValueRef.current, [name]);
     realFormValueRef.current = formValue;
     setFormValue(formValue);
     return formValue;
   }, [setFormValue]);
-  var resetFormValue = (0, _react.useCallback)(function (nextValue) {
-    var value = nextValue || formDefaultValue;
+  const resetFormValue = (0, _react.useCallback)(nextValue => {
+    const value = nextValue || formDefaultValue;
     setFormValue(value);
     return value;
   }, [formDefaultValue, setFormValue]);
   return {
-    formValue: formValue,
-    setFormValue: setFormValue,
-    setFieldValue: setFieldValue,
-    onRemoveValue: onRemoveValue,
-    resetFormValue: resetFormValue
+    formValue,
+    setFormValue,
+    setFieldValue,
+    onRemoveValue,
+    resetFormValue
   };
 }

package/cjs/Form/hooks/useSchemaModel.js

@@ -28,16 +28,17 @@ var _react = require("react");
  * ```
  */
 function unflattenSchemaObject(schema) {
-  var result = {};
-  var $type = Symbol('schema-type');
-  Object.keys(schema).forEach(function (key) {
+  const result = {};
+  const $type = Symbol('schema-type');
+  Object.keys(schema).forEach(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);
+      const keys = key.split('.');
+      const lastKey = keys.pop() || '';
+      let current = result;
+      keys.forEach(subKey => {
+        current[subKey] = current[subKey] || {
+          [$type]: 'object-type'
+        };
         current = current[subKey];
       });
       current[lastKey] = schema[key];
@@ -46,7 +47,7 @@ function unflattenSchemaObject(schema) {
     }
   });
   function convertToShape(obj) {
-    Object.keys(obj).forEach(function (key) {
+    Object.keys(obj).forEach(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];
@@ -58,42 +59,39 @@ function unflattenSchemaObject(schema) {
   return convertToShape(result);
 }
 function useSchemaModel(formModel, nestedField) {
-  var subRulesRef = (0, _react.useRef)([]);
-  var pushFieldRule = (0, _react.useCallback)(function (name, fieldRule) {
+  const subRulesRef = (0, _react.useRef)([]);
+  const pushFieldRule = (0, _react.useCallback)((name, fieldRule) => {
     subRulesRef.current.push({
-      name: name,
-      fieldRule: fieldRule
+      name,
+      fieldRule
     });
   }, []);
-  var removeFieldRule = (0, _react.useCallback)(function (name) {
-    var index = subRulesRef.current.findIndex(function (v) {
-      return v.name === name;
-    });
+  const removeFieldRule = (0, _react.useCallback)(name => {
+    const index = subRulesRef.current.findIndex(v => v.name === name);
     subRulesRef.current.splice(index, 1);
   }, []);
-  var getCombinedModel = (0, _react.useCallback)(function () {
-    var realSubRules = subRulesRef.current.filter(function (v) {
-      return Boolean(v.fieldRule.current);
-    });
+  const getCombinedModel = (0, _react.useCallback)(() => {
+    const realSubRules = subRulesRef.current.filter(v => Boolean(v.fieldRule.current));
 
     // If there is no sub rule, return the original form model
     if (realSubRules.length === 0) {
       return formModel;
     }
-    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);
-    }, {});
+    const subRuleObject = realSubRules.map(_ref => {
+      let {
+        name,
+        fieldRule
+      } = _ref;
+      return {
+        [name]: fieldRule.current
+      };
+    }).reduce((a, b) => Object.assign(a, b), {});
     return _schemaTyped.SchemaModel.combine(formModel, (0, _schemaTyped.SchemaModel)(nestedField ? unflattenSchemaObject(subRuleObject) : subRuleObject));
   }, [formModel, nestedField]);
   return {
-    getCombinedModel: getCombinedModel,
-    pushFieldRule: pushFieldRule,
-    removeFieldRule: removeFieldRule
+    getCombinedModel,
+    pushFieldRule,
+    removeFieldRule
   };
 }
 var _default = exports.default = useSchemaModel;

package/cjs/FormControl/FormControl.d.ts

@@ -47,7 +47,7 @@ export interface FormControlProps<P = any, ValueType = any> extends WithAsProps,
 interface FormControlComponent extends React.FC<FormControlProps> {
     <Accepter extends React.ElementType = typeof Input>(props: FormControlProps & {
         accepter?: Accepter;
-    } & React.ComponentPropsWithRef<Accepter>): React.ReactElement | null;
+    } & React.ComponentPropsWithRef<Accepter>): any;
 }
 /**
  * The `<Form.Control>` component is used to wrap the components that need to be validated.