@1money/component-ui 0.0.71 → 0.0.74

package/es/components/ProForm/core/hooks/useFormCore.d.ts

@@ -1,3 +1,7 @@
+import type { FormStore } from '../formStore';
 import type { UseFormCoreConfig, UseFormCoreReturn } from '../interface';
-export declare const useFormCore: (config?: UseFormCoreConfig) => UseFormCoreReturn;
+export declare const useFormCore: (config?: UseFormCoreConfig) => UseFormCoreReturn & {
+    store: FormStore;
+    getInitialValues: () => Record<string, unknown>;
+};
 export default useFormCore;

package/es/components/ProForm/core/hooks/useFormCore.js

@@ -1,10 +1,10 @@
 import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
-import { useState, useMemo } from 'react';
+import { useMemo, useRef } from 'react';
 import useEventCallback from '@1money/hooks/useEventCallback';
 import useMemoizedFn from '@1money/hooks/useMemoizedFn';
 import { resolveValue, setNestedValue } from '../pathUtils';
 import { runRulesSync } from '../runRules';
+import { createFormStore } from '../formStore';
 export var useFormCore = function useFormCore() {
   var config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
   var _config$initialValues = config.initialValues,
@@ -14,7 +14,7 @@ export var useFormCore = function useFormCore() {
     onValuesChange = config.onValuesChange,
     onReset = config.onReset,
     _config$size = config.size,
-    size = _config$size === void 0 ? 'middle' : _config$size,
+    size = _config$size === void 0 ? 'large' : _config$size,
     _config$labelAlign = config.labelAlign,
     labelAlign = _config$labelAlign === void 0 ? 'left' : _config$labelAlign,
     _config$disabled = config.disabled,
@@ -25,79 +25,111 @@ export var useFormCore = function useFormCore() {
     requiredMark = _config$requiredMark === void 0 ? true : _config$requiredMark,
     _config$validateTrigg = config.validateTrigger,
     validateTrigger = _config$validateTrigg === void 0 ? 'onChange' : _config$validateTrigg;
-  var _useState = useState(initialValues),
-    _useState2 = _slicedToArray(_useState, 2),
-    values = _useState2[0],
-    setValues = _useState2[1];
-  var _useState3 = useState({}),
-    _useState4 = _slicedToArray(_useState3, 2),
-    errors = _useState4[0],
-    setErrors = _useState4[1];
-  var _useState5 = useState({}),
-    _useState6 = _slicedToArray(_useState5, 2),
-    touched = _useState6[0],
-    setTouched = _useState6[1];
-  var _useState7 = useState({}),
-    _useState8 = _slicedToArray(_useState7, 2),
-    fieldRules = _useState8[0],
-    setFieldRules = _useState8[1];
-  var setFieldValue = useMemoizedFn(function (name, value) {
-    setValues(function (prev) {
-      var newValues = name.includes('.') ? setNestedValue(prev, name, value) : Object.assign(Object.assign({}, prev), _defineProperty({}, name, value));
-      onValuesChange === null || onValuesChange === void 0 ? void 0 : onValuesChange(_defineProperty({}, name, value), newValues);
-      return newValues;
+  // initialValues is MOUNT-ONLY (the documented contract): freeze the first
+  // render's value so resetFields always restores the mount-time defaults,
+  // even when the consumer re-renders with a different (e.g. controlled)
+  // initialValues object.
+  var initialValuesRef = useRef(null);
+  if (initialValuesRef.current === null) {
+    initialValuesRef.current = initialValues;
+  }
+  var mountInitialValues = initialValuesRef.current;
+  // All volatile form state lives in an external store, NOT React state — a
+  // keystroke must never re-render the component that owns the form. Fields
+  // and watchers subscribe with per-field selectors (useStoreSelector); every
+  // mutator below reads the LATEST state via store.getState(), which also
+  // keeps multiple writes in the same tick visible to each other.
+  var storeRef = useRef(null);
+  if (storeRef.current === null) {
+    storeRef.current = createFormStore(mountInitialValues);
+  }
+  var store = storeRef.current;
+  // Live rule registry — ONE stable object mutated in place. Registration must
+  // not trigger renders, and submit-time validation must always read the latest
+  // rules (they can change between renders, e.g. a conditional `required`).
+  var fieldRulesRef = useRef({});
+  var commitValues = useMemoizedFn(function (newValues) {
+    store.setState({
+      values: newValues
     });
+  });
+  var setFieldValue = useMemoizedFn(function (name, value) {
+    var prev = store.getState().values;
+    var newValues = name.includes('.') ? setNestedValue(prev, name, value) : Object.assign(Object.assign({}, prev), _defineProperty({}, name, value));
+    commitValues(newValues);
+    onValuesChange === null || onValuesChange === void 0 ? void 0 : onValuesChange(_defineProperty({}, name, value), newValues);
     if (value !== '' && value !== null && value !== undefined) {
-      setErrors(function (prev) {
-        if (!prev[name]) return prev;
-        var newErrors = Object.assign({}, prev);
+      var errors = store.getState().errors;
+      if (errors[name]) {
+        var newErrors = Object.assign({}, errors);
         delete newErrors[name];
-        return newErrors;
-      });
+        store.setState({
+          errors: newErrors
+        });
+      }
     }
   });
   var setFieldError = useMemoizedFn(function (name, error) {
-    setErrors(function (prev) {
-      if (error === null) {
-        if (!prev[name]) return prev;
-        var newErrors = Object.assign({}, prev);
-        delete newErrors[name];
-        return newErrors;
-      }
-      return Object.assign(Object.assign({}, prev), _defineProperty({}, name, error));
+    var errors = store.getState().errors;
+    if (error === null) {
+      if (!errors[name]) return;
+      var newErrors = Object.assign({}, errors);
+      delete newErrors[name];
+      store.setState({
+        errors: newErrors
+      });
+      return;
+    }
+    if (errors[name] === error) return;
+    store.setState({
+      errors: Object.assign(Object.assign({}, errors), _defineProperty({}, name, error))
     });
   });
-  var registerField = useMemoizedFn(function (name, rules) {
-    setFieldRules(function (prev) {
-      return Object.assign(Object.assign({}, prev), _defineProperty({}, name, rules));
+  var setFieldWarning = useMemoizedFn(function (name, warning) {
+    var warnings = store.getState().warnings;
+    if (warning === null) {
+      if (!warnings[name]) return;
+      var newWarnings = Object.assign({}, warnings);
+      delete newWarnings[name];
+      store.setState({
+        warnings: newWarnings
+      });
+      return;
+    }
+    if (warnings[name] === warning) return;
+    store.setState({
+      warnings: Object.assign(Object.assign({}, warnings), _defineProperty({}, name, warning))
     });
   });
+  var registerField = useMemoizedFn(function (name, rules) {
+    fieldRulesRef.current[name] = rules;
+  });
   var getFieldRules = useMemoizedFn(function (name) {
-    return fieldRules[name];
+    return fieldRulesRef.current[name];
   });
   var unregisterField = useMemoizedFn(function (name) {
-    setFieldRules(function (prev) {
-      var newRules = Object.assign({}, prev);
-      delete newRules[name];
-      return newRules;
-    });
+    delete fieldRulesRef.current[name];
   });
   var validateField = useMemoizedFn(function (name) {
     var rules = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
     var providedValue = arguments.length > 2 ? arguments[2] : undefined;
-    var value = providedValue !== undefined ? providedValue : resolveValue(values, name);
-    var error = runRulesSync(name, value, values, rules);
+    var currentValues = store.getState().values;
+    var value = providedValue !== undefined ? providedValue : resolveValue(currentValues, name);
+    var _runRulesSync = runRulesSync(name, value, currentValues, rules),
+      error = _runRulesSync.error,
+      warning = _runRulesSync.warning;
+    setFieldWarning(name, warning);
     if (error !== null) {
       setFieldError(name, error);
       return false;
     }
-    if (errors[name]) {
+    if (store.getState().errors[name]) {
       setFieldError(name, null);
     }
     return true;
   });
   var validateFields = useMemoizedFn(function () {
-    var fieldsRulesToValidate = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : fieldRules;
+    var fieldsRulesToValidate = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : fieldRulesRef.current;
     var isValid = true;
     Object.keys(fieldsRulesToValidate).forEach(function (name) {
       var rules = fieldsRulesToValidate[name];
@@ -108,26 +140,37 @@ export var useFormCore = function useFormCore() {
     return isValid;
   });
   var handleSubmitInternal = useMemoizedFn(function () {
+    var currentValues = store.getState().values;
+    var currentRules = fieldRulesRef.current;
     var hasErrors = false;
     var newErrors = {};
-    Object.keys(fieldRules).forEach(function (fieldName) {
-      var value = resolveValue(values, fieldName);
-      var error = runRulesSync(fieldName, value, values, fieldRules[fieldName]);
+    var newWarnings = {};
+    Object.keys(currentRules).forEach(function (fieldName) {
+      var value = resolveValue(currentValues, fieldName);
+      var _runRulesSync2 = runRulesSync(fieldName, value, currentValues, currentRules[fieldName]),
+        error = _runRulesSync2.error,
+        warning = _runRulesSync2.warning;
       if (error !== null) {
         newErrors[fieldName] = error;
         hasErrors = true;
       }
+      if (warning !== null) {
+        newWarnings[fieldName] = warning;
+      }
+    });
+    store.setState({
+      errors: newErrors,
+      warnings: newWarnings
     });
-    setErrors(newErrors);
     if (!hasErrors) {
-      onFinish === null || onFinish === void 0 ? void 0 : onFinish(values);
+      onFinish === null || onFinish === void 0 ? void 0 : onFinish(currentValues);
       return {
         success: true,
-        values: values
+        values: currentValues
       };
     } else {
       onFinishFailed === null || onFinishFailed === void 0 ? void 0 : onFinishFailed({
-        values: values,
+        values: currentValues,
         errors: newErrors
       });
       return {
@@ -140,28 +183,33 @@ export var useFormCore = function useFormCore() {
     e === null || e === void 0 ? void 0 : e.preventDefault();
     return handleSubmitInternal();
   });
+  // Pure state API: the imperative resetFields()
+  // never fires onReset. The callback belongs to the reset ACTION layer
+  // (submitter button / native reset event), which fires it exactly once.
   var resetFields = useMemoizedFn(function () {
-    setValues(initialValues);
-    setErrors({});
-    setTouched({});
-    onReset === null || onReset === void 0 ? void 0 : onReset();
+    store.setState({
+      values: mountInitialValues,
+      errors: {},
+      warnings: {},
+      touched: {},
+      validating: {}
+    });
   });
   var handleReset = useEventCallback(function (e) {
     e === null || e === void 0 ? void 0 : e.preventDefault();
     resetFields();
+    onReset === null || onReset === void 0 ? void 0 : onReset();
   });
   var getFieldValue = useMemoizedFn(function (name) {
-    return resolveValue(values, name);
+    return resolveValue(store.getState().values, name);
   });
   var getFieldsValue = useMemoizedFn(function () {
-    return values;
+    return store.getState().values;
   });
   var setFieldsValue = useMemoizedFn(function (newValues) {
-    setValues(function (prev) {
-      var updatedValues = Object.assign(Object.assign({}, prev), newValues);
-      onValuesChange === null || onValuesChange === void 0 ? void 0 : onValuesChange(newValues, updatedValues);
-      return updatedValues;
-    });
+    var updatedValues = Object.assign(Object.assign({}, store.getState().values), newValues);
+    commitValues(updatedValues);
+    onValuesChange === null || onValuesChange === void 0 ? void 0 : onValuesChange(newValues, updatedValues);
   });
   var formInstance = useMemo(function () {
     return {
@@ -174,33 +222,39 @@ export var useFormCore = function useFormCore() {
       validateFields: validateFields
     };
   }, [handleSubmitInternal, resetFields, getFieldValue, getFieldsValue, setFieldsValue, setFieldValue, validateFields]);
-  var coreContextShape = useMemo(function () {
-    return {
-      values: values,
-      errors: errors,
-      touched: touched,
-      formInstance: formInstance,
-      setFieldValue: setFieldValue,
-      setFieldError: setFieldError,
-      validateField: validateField,
-      registerField: registerField,
-      unregisterField: unregisterField,
-      size: size,
-      labelAlign: labelAlign,
-      disabled: disabled,
-      colon: colon,
-      requiredMark: requiredMark,
-      validateTrigger: validateTrigger
-    };
-  }, [values, errors, touched, formInstance, setFieldValue, setFieldError, validateField, registerField, unregisterField, size, labelAlign, disabled, colon, requiredMark, validateTrigger]);
+  // Render-time snapshot — kept for the UseFormCoreReturn contract. Reactive
+  // consumers must go through the store, never through these fields.
+  var state = store.getState();
+  var coreContextShape = {
+    values: state.values,
+    errors: state.errors,
+    warnings: state.warnings,
+    touched: state.touched,
+    formInstance: formInstance,
+    setFieldValue: setFieldValue,
+    setFieldError: setFieldError,
+    setFieldWarning: setFieldWarning,
+    validateField: validateField,
+    registerField: registerField,
+    unregisterField: unregisterField,
+    size: size,
+    labelAlign: labelAlign,
+    disabled: disabled,
+    colon: colon,
+    requiredMark: requiredMark,
+    validateTrigger: validateTrigger
+  };
   return {
-    values: values,
-    errors: errors,
-    touched: touched,
-    fieldRules: fieldRules,
+    values: state.values,
+    errors: state.errors,
+    warnings: state.warnings,
+    touched: state.touched,
+    // Live registry — stable identity, mutated in place by register/unregister.
+    fieldRules: fieldRulesRef.current,
     getFieldRules: getFieldRules,
     setFieldValue: setFieldValue,
     setFieldError: setFieldError,
+    setFieldWarning: setFieldWarning,
     setFieldsValue: setFieldsValue,
     getFieldValue: getFieldValue,
     getFieldsValue: getFieldsValue,
@@ -212,8 +266,12 @@ export var useFormCore = function useFormCore() {
     handleReset: handleReset,
     resetFields: resetFields,
     formInstance: formInstance,
-    coreContextShape: coreContextShape
+    coreContextShape: coreContextShape,
+    store: store,
+    getInitialValues: function getInitialValues() {
+      return mountInitialValues;
+    }
   };
 };
 export default useFormCore;
-//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["components/ProForm/core/src/components/ProForm/core/hooks/useFormCore.ts","components/ProForm/core/hooks/useFormCore.js"],"names":["useState","useMemo","useEventCallback","useMemoizedFn","resolveValue","setNestedValue","runRulesSync","useFormCore","config","arguments","length","undefined","_config$initialValues","initialValues","onFinish","onFinishFailed","onValuesChange","onReset","_config$size","size","_config$labelAlign","labelAlign","_config$disabled","disabled","_config$colon","colon","_config$requiredMark","requiredMark","_config$validateTrigg","validateTrigger","_useState","_useState2","_slicedToArray","values","setValues","_useState3","_useState4","errors","setErrors","_useState5","_useState6","touched","setTouched","_useState7","_useState8","fieldRules","setFieldRules","setFieldValue","name","value","prev","newValues","includes","Object","assign","_defineProperty","newErrors","setFieldError","error","registerField","rules","getFieldRules","unregisterField","newRules","validateField","providedValue","validateFields","fieldsRulesToValidate","isValid","keys","forEach","handleSubmitInternal","hasErrors","fieldName","success","handleSubmit","e","preventDefault","resetFields","handleReset","getFieldValue","getFieldsValue","setFieldsValue","updatedValues","formInstance","submit","coreContextShape"],"mappings":"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","file":"components/ProForm/core/hooks/useFormCore.js","sourcesContent":[null,"import { useState, useMemo } from 'react';\nimport useEventCallback from '@1money/hooks/useEventCallback';\nimport useMemoizedFn from '@1money/hooks/useMemoizedFn';\nimport { resolveValue, setNestedValue } from '../pathUtils';\nimport { runRulesSync } from '../runRules';\nexport const useFormCore = (config = {}) => {\n    const { initialValues = {}, onFinish, onFinishFailed, onValuesChange, onReset, size = 'middle', labelAlign = 'left', disabled = false, colon = true, requiredMark = true, validateTrigger = 'onChange', } = config;\n    const [values, setValues] = useState(initialValues);\n    const [errors, setErrors] = useState({});\n    const [touched, setTouched] = useState({});\n    const [fieldRules, setFieldRules] = useState({});\n    const setFieldValue = useMemoizedFn((name, value) => {\n        setValues((prev) => {\n            const newValues = name.includes('.')\n                ? setNestedValue(prev, name, value)\n                : Object.assign(Object.assign({}, prev), { [name]: value });\n            onValuesChange === null || onValuesChange === void 0 ? void 0 : onValuesChange({ [name]: value }, newValues);\n            return newValues;\n        });\n        if (value !== '' && value !== null && value !== undefined) {\n            setErrors((prev) => {\n                if (!prev[name])\n                    return prev;\n                const newErrors = Object.assign({}, prev);\n                delete newErrors[name];\n                return newErrors;\n            });\n        }\n    });\n    const setFieldError = useMemoizedFn((name, error) => {\n        setErrors((prev) => {\n            if (error === null) {\n                if (!prev[name])\n                    return prev;\n                const newErrors = Object.assign({}, prev);\n                delete newErrors[name];\n                return newErrors;\n            }\n            return Object.assign(Object.assign({}, prev), { [name]: error });\n        });\n    });\n    const registerField = useMemoizedFn((name, rules) => {\n        setFieldRules((prev) => (Object.assign(Object.assign({}, prev), { [name]: rules })));\n    });\n    const getFieldRules = useMemoizedFn((name) => {\n        return fieldRules[name];\n    });\n    const unregisterField = useMemoizedFn((name) => {\n        setFieldRules((prev) => {\n            const newRules = Object.assign({}, prev);\n            delete newRules[name];\n            return newRules;\n        });\n    });\n    const validateField = useMemoizedFn((name, rules = [], providedValue) => {\n        const value = providedValue !== undefined ? providedValue : resolveValue(values, name);\n        const error = runRulesSync(name, value, values, rules);\n        if (error !== null) {\n            setFieldError(name, error);\n            return false;\n        }\n        if (errors[name]) {\n            setFieldError(name, null);\n        }\n        return true;\n    });\n    const validateFields = useMemoizedFn((fieldsRulesToValidate = fieldRules) => {\n        let isValid = true;\n        Object.keys(fieldsRulesToValidate).forEach((name) => {\n            const rules = fieldsRulesToValidate[name];\n            if (!validateField(name, rules)) {\n                isValid = false;\n            }\n        });\n        return isValid;\n    });\n    const handleSubmitInternal = useMemoizedFn(() => {\n        let hasErrors = false;\n        const newErrors = {};\n        Object.keys(fieldRules).forEach((fieldName) => {\n            const value = resolveValue(values, fieldName);\n            const error = runRulesSync(fieldName, value, values, fieldRules[fieldName]);\n            if (error !== null) {\n                newErrors[fieldName] = error;\n                hasErrors = true;\n            }\n        });\n        setErrors(newErrors);\n        if (!hasErrors) {\n            onFinish === null || onFinish === void 0 ? void 0 : onFinish(values);\n            return { success: true, values };\n        }\n        else {\n            onFinishFailed === null || onFinishFailed === void 0 ? void 0 : onFinishFailed({ values, errors: newErrors });\n            return { success: false, errors: newErrors };\n        }\n    });\n    const handleSubmit = useEventCallback((e) => {\n        e === null || e === void 0 ? void 0 : e.preventDefault();\n        return handleSubmitInternal();\n    });\n    const resetFields = useMemoizedFn(() => {\n        setValues(initialValues);\n        setErrors({});\n        setTouched({});\n        onReset === null || onReset === void 0 ? void 0 : onReset();\n    });\n    const handleReset = useEventCallback((e) => {\n        e === null || e === void 0 ? void 0 : e.preventDefault();\n        resetFields();\n    });\n    const getFieldValue = useMemoizedFn((name) => {\n        return resolveValue(values, name);\n    });\n    const getFieldsValue = useMemoizedFn(() => {\n        return values;\n    });\n    const setFieldsValue = useMemoizedFn((newValues) => {\n        setValues((prev) => {\n            const updatedValues = Object.assign(Object.assign({}, prev), newValues);\n            onValuesChange === null || onValuesChange === void 0 ? void 0 : onValuesChange(newValues, updatedValues);\n            return updatedValues;\n        });\n    });\n    const formInstance = useMemo(() => ({\n        submit: handleSubmitInternal,\n        resetFields,\n        getFieldValue,\n        getFieldsValue,\n        setFieldsValue,\n        setFieldValue,\n        validateFields,\n    }), [\n        handleSubmitInternal,\n        resetFields,\n        getFieldValue,\n        getFieldsValue,\n        setFieldsValue,\n        setFieldValue,\n        validateFields,\n    ]);\n    const coreContextShape = useMemo(() => ({\n        values,\n        errors,\n        touched,\n        formInstance,\n        setFieldValue,\n        setFieldError,\n        validateField,\n        registerField,\n        unregisterField,\n        size,\n        labelAlign,\n        disabled,\n        colon,\n        requiredMark,\n        validateTrigger,\n    }), [\n        values,\n        errors,\n        touched,\n        formInstance,\n        setFieldValue,\n        setFieldError,\n        validateField,\n        registerField,\n        unregisterField,\n        size,\n        labelAlign,\n        disabled,\n        colon,\n        requiredMark,\n        validateTrigger,\n    ]);\n    return {\n        values,\n        errors,\n        touched,\n        fieldRules,\n        getFieldRules,\n        setFieldValue,\n        setFieldError,\n        setFieldsValue,\n        getFieldValue,\n        getFieldsValue,\n        validateField,\n        validateFields,\n        registerField,\n        unregisterField,\n        handleSubmit,\n        handleReset,\n        resetFields,\n        formInstance,\n        coreContextShape,\n    };\n};\nexport default useFormCore;"],"sourceRoot":"../../../../../../../../../../../src"}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["components/ProForm/core/src/components/ProForm/core/hooks/useFormCore.ts","components/ProForm/core/hooks/useFormCore.js"],"names":["useMemo","useRef","useEventCallback","useMemoizedFn","resolveValue","setNestedValue","runRulesSync","createFormStore","useFormCore","config","arguments","length","undefined","_config$initialValues","initialValues","onFinish","onFinishFailed","onValuesChange","onReset","_config$size","size","_config$labelAlign","labelAlign","_config$disabled","disabled","_config$colon","colon","_config$requiredMark","requiredMark","_config$validateTrigg","validateTrigger","initialValuesRef","current","mountInitialValues","storeRef","store","fieldRulesRef","commitValues","newValues","setState","values","setFieldValue","name","value","prev","getState","includes","Object","assign","_defineProperty","errors","newErrors","setFieldError","error","setFieldWarning","warning","warnings","newWarnings","registerField","rules","getFieldRules","unregisterField","validateField","providedValue","currentValues","_runRulesSync","validateFields","fieldsRulesToValidate","isValid","keys","forEach","handleSubmitInternal","currentRules","hasErrors","fieldName","_runRulesSync2","success","handleSubmit","e","preventDefault","resetFields","touched","validating","handleReset","getFieldValue","getFieldsValue","setFieldsValue","updatedValues","formInstance","submit","state","coreContextShape","fieldRules","getInitialValues"],"mappings":"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","file":"components/ProForm/core/hooks/useFormCore.js","sourcesContent":[null,"import { useMemo, useRef } from 'react';\nimport useEventCallback from '@1money/hooks/useEventCallback';\nimport useMemoizedFn from '@1money/hooks/useMemoizedFn';\nimport { resolveValue, setNestedValue } from '../pathUtils';\nimport { runRulesSync } from '../runRules';\nimport { createFormStore } from '../formStore';\nexport const useFormCore = (config = {}) => {\n    const { initialValues = {}, onFinish, onFinishFailed, onValuesChange, onReset, size = 'large', labelAlign = 'left', disabled = false, colon = true, requiredMark = true, validateTrigger = 'onChange', } = config;\n    // initialValues is MOUNT-ONLY (the documented contract): freeze the first\n    // render's value so resetFields always restores the mount-time defaults,\n    // even when the consumer re-renders with a different (e.g. controlled)\n    // initialValues object.\n    const initialValuesRef = useRef(null);\n    if (initialValuesRef.current === null) {\n        initialValuesRef.current = initialValues;\n    }\n    const mountInitialValues = initialValuesRef.current;\n    // All volatile form state lives in an external store, NOT React state — a\n    // keystroke must never re-render the component that owns the form. Fields\n    // and watchers subscribe with per-field selectors (useStoreSelector); every\n    // mutator below reads the LATEST state via store.getState(), which also\n    // keeps multiple writes in the same tick visible to each other.\n    const storeRef = useRef(null);\n    if (storeRef.current === null) {\n        storeRef.current = createFormStore(mountInitialValues);\n    }\n    const store = storeRef.current;\n    // Live rule registry — ONE stable object mutated in place. Registration must\n    // not trigger renders, and submit-time validation must always read the latest\n    // rules (they can change between renders, e.g. a conditional `required`).\n    const fieldRulesRef = useRef({});\n    const commitValues = useMemoizedFn((newValues) => {\n        store.setState({ values: newValues });\n    });\n    const setFieldValue = useMemoizedFn((name, value) => {\n        const prev = store.getState().values;\n        const newValues = name.includes('.')\n            ? setNestedValue(prev, name, value)\n            : Object.assign(Object.assign({}, prev), { [name]: value });\n        commitValues(newValues);\n        onValuesChange === null || onValuesChange === void 0 ? void 0 : onValuesChange({ [name]: value }, newValues);\n        if (value !== '' && value !== null && value !== undefined) {\n            const errors = store.getState().errors;\n            if (errors[name]) {\n                const newErrors = Object.assign({}, errors);\n                delete newErrors[name];\n                store.setState({ errors: newErrors });\n            }\n        }\n    });\n    const setFieldError = useMemoizedFn((name, error) => {\n        const errors = store.getState().errors;\n        if (error === null) {\n            if (!errors[name])\n                return;\n            const newErrors = Object.assign({}, errors);\n            delete newErrors[name];\n            store.setState({ errors: newErrors });\n            return;\n        }\n        if (errors[name] === error)\n            return;\n        store.setState({ errors: Object.assign(Object.assign({}, errors), { [name]: error }) });\n    });\n    const setFieldWarning = useMemoizedFn((name, warning) => {\n        const warnings = store.getState().warnings;\n        if (warning === null) {\n            if (!warnings[name])\n                return;\n            const newWarnings = Object.assign({}, warnings);\n            delete newWarnings[name];\n            store.setState({ warnings: newWarnings });\n            return;\n        }\n        if (warnings[name] === warning)\n            return;\n        store.setState({ warnings: Object.assign(Object.assign({}, warnings), { [name]: warning }) });\n    });\n    const registerField = useMemoizedFn((name, rules) => {\n        fieldRulesRef.current[name] = rules;\n    });\n    const getFieldRules = useMemoizedFn((name) => {\n        return fieldRulesRef.current[name];\n    });\n    const unregisterField = useMemoizedFn((name) => {\n        delete fieldRulesRef.current[name];\n    });\n    const validateField = useMemoizedFn((name, rules = [], providedValue) => {\n        const currentValues = store.getState().values;\n        const value = providedValue !== undefined ? providedValue : resolveValue(currentValues, name);\n        const { error, warning } = runRulesSync(name, value, currentValues, rules);\n        setFieldWarning(name, warning);\n        if (error !== null) {\n            setFieldError(name, error);\n            return false;\n        }\n        if (store.getState().errors[name]) {\n            setFieldError(name, null);\n        }\n        return true;\n    });\n    const validateFields = useMemoizedFn((fieldsRulesToValidate = fieldRulesRef.current) => {\n        let isValid = true;\n        Object.keys(fieldsRulesToValidate).forEach((name) => {\n            const rules = fieldsRulesToValidate[name];\n            if (!validateField(name, rules)) {\n                isValid = false;\n            }\n        });\n        return isValid;\n    });\n    const handleSubmitInternal = useMemoizedFn(() => {\n        const currentValues = store.getState().values;\n        const currentRules = fieldRulesRef.current;\n        let hasErrors = false;\n        const newErrors = {};\n        const newWarnings = {};\n        Object.keys(currentRules).forEach((fieldName) => {\n            const value = resolveValue(currentValues, fieldName);\n            const { error, warning } = runRulesSync(fieldName, value, currentValues, currentRules[fieldName]);\n            if (error !== null) {\n                newErrors[fieldName] = error;\n                hasErrors = true;\n            }\n            if (warning !== null) {\n                newWarnings[fieldName] = warning;\n            }\n        });\n        store.setState({ errors: newErrors, warnings: newWarnings });\n        if (!hasErrors) {\n            onFinish === null || onFinish === void 0 ? void 0 : onFinish(currentValues);\n            return { success: true, values: currentValues };\n        }\n        else {\n            onFinishFailed === null || onFinishFailed === void 0 ? void 0 : onFinishFailed({ values: currentValues, errors: newErrors });\n            return { success: false, errors: newErrors };\n        }\n    });\n    const handleSubmit = useEventCallback((e) => {\n        e === null || e === void 0 ? void 0 : e.preventDefault();\n        return handleSubmitInternal();\n    });\n    // Pure state API: the imperative resetFields()\n    // never fires onReset. The callback belongs to the reset ACTION layer\n    // (submitter button / native reset event), which fires it exactly once.\n    const resetFields = useMemoizedFn(() => {\n        store.setState({\n            values: mountInitialValues,\n            errors: {},\n            warnings: {},\n            touched: {},\n            validating: {},\n        });\n    });\n    const handleReset = useEventCallback((e) => {\n        e === null || e === void 0 ? void 0 : e.preventDefault();\n        resetFields();\n        onReset === null || onReset === void 0 ? void 0 : onReset();\n    });\n    const getFieldValue = useMemoizedFn((name) => {\n        return resolveValue(store.getState().values, name);\n    });\n    const getFieldsValue = useMemoizedFn(() => {\n        return store.getState().values;\n    });\n    const setFieldsValue = useMemoizedFn((newValues) => {\n        const updatedValues = Object.assign(Object.assign({}, store.getState().values), newValues);\n        commitValues(updatedValues);\n        onValuesChange === null || onValuesChange === void 0 ? void 0 : onValuesChange(newValues, updatedValues);\n    });\n    const formInstance = useMemo(() => ({\n        submit: handleSubmitInternal,\n        resetFields,\n        getFieldValue,\n        getFieldsValue,\n        setFieldsValue,\n        setFieldValue,\n        validateFields,\n    }), [\n        handleSubmitInternal,\n        resetFields,\n        getFieldValue,\n        getFieldsValue,\n        setFieldsValue,\n        setFieldValue,\n        validateFields,\n    ]);\n    // Render-time snapshot — kept for the UseFormCoreReturn contract. Reactive\n    // consumers must go through the store, never through these fields.\n    const state = store.getState();\n    const coreContextShape = {\n        values: state.values,\n        errors: state.errors,\n        warnings: state.warnings,\n        touched: state.touched,\n        formInstance,\n        setFieldValue,\n        setFieldError,\n        setFieldWarning,\n        validateField,\n        registerField,\n        unregisterField,\n        size,\n        labelAlign,\n        disabled,\n        colon,\n        requiredMark,\n        validateTrigger,\n    };\n    return {\n        values: state.values,\n        errors: state.errors,\n        warnings: state.warnings,\n        touched: state.touched,\n        // Live registry — stable identity, mutated in place by register/unregister.\n        fieldRules: fieldRulesRef.current,\n        getFieldRules,\n        setFieldValue,\n        setFieldError,\n        setFieldWarning,\n        setFieldsValue,\n        getFieldValue,\n        getFieldsValue,\n        validateField,\n        validateFields,\n        registerField,\n        unregisterField,\n        handleSubmit,\n        handleReset,\n        resetFields,\n        formInstance,\n        coreContextShape,\n        store,\n        getInitialValues: () => mountInitialValues,\n    };\n};\nexport default useFormCore;"],"sourceRoot":"../../../../../../../../../../../src"}

package/es/components/ProForm/core/interface.d.ts

@@ -3,13 +3,23 @@ import type { FC, ReactNode } from 'react';
 import type { FormSize, FormLayout, LabelAlign, ValidateStatus, ValidateTrigger } from './constants';
 export type { FormSize, FormLayout, LabelAlign, ValidateStatus, ValidateTrigger, };
 export interface Rule {
+    /** Fails on undefined / null / '' / empty array */
     required?: boolean;
     message?: string;
+    /** For strings: min length; arrays: min item count; numbers: min value */
     min?: number;
+    /** For strings: max length; arrays: max item count; numbers: max value */
     max?: number;
     pattern?: RegExp;
     type?: 'number' | 'email' | 'url';
     enum?: unknown[];
+    /** A failing rule produces a non-blocking warning instead of an error */
+    warningOnly?: boolean;
+    /**
+     * Run this rule only on the given interactive trigger(s); rules without it
+     * follow the form-level validateTrigger. Submit always runs every rule.
+     */
+    validateTrigger?: ValidateTrigger | ValidateTrigger[];
     validator?: (value: unknown, values: Record<string, unknown>) => boolean | string | Promise<boolean | string>;
 }
 export interface FieldProps {
@@ -43,19 +53,24 @@ export interface FormCoreInstance {
     setFieldValue: (name: string, value: unknown) => void;
     validateFields: (fieldsRules?: Record<string, Rule[]>) => boolean;
 }
-/** Full form instance returned by useForm — extends FormCoreInstance with async validation, field helpers, etc. */
-export interface FormInstance {
+/**
+ * Full form instance returned by useForm — extends FormCoreInstance with async
+ * validation, field helpers, etc. `Values` types the whole-form value shape
+ * (defaults to an open record for backward compatibility).
+ */
+export interface FormInstance<Values = Record<string, unknown>> {
     getFieldValue: (name: string) => unknown;
-    getFieldsValue: (nameList?: string[]) => Record<string, unknown>;
+    getFieldsValue: (nameList?: string[]) => Values;
     setFieldValue: (name: string, value: unknown) => void;
-    setFieldsValue: (values: Record<string, unknown>) => void;
+    setFieldsValue: (values: Partial<Values>) => void;
     setFieldError: (name: string, error: string | null) => void;
     setFieldsError: (errors: Record<string, string>) => void;
     resetFields: (fields?: string[]) => void;
-    validateFields: (nameList?: string[]) => Promise<Record<string, unknown>>;
-    submit: (callback?: (values: Record<string, unknown>) => void | Promise<void>) => Promise<Record<string, unknown> | undefined>;
+    validateFields: (nameList?: string[]) => Promise<Values>;
+    submit: (callback?: (values: Values) => void | Promise<void>) => Promise<Values | undefined>;
     getFieldError: (name: string) => string | undefined;
     getFieldsError: (nameList?: string[]) => Record<string, string>;
+    getFieldWarning: (name: string) => string | undefined;
     isFieldTouched: (name: string) => boolean;
     isFieldsTouched: (nameList?: string[], allTouched?: boolean) => boolean;
     isFieldValidating: (name: string) => boolean;
@@ -70,14 +85,14 @@ export interface UseFormOptions {
     validateTrigger?: ValidateTrigger;
     rules?: Record<string, Rule[]>;
 }
-export interface UseFormCoreConfig {
-    initialValues?: Record<string, unknown>;
-    onFinish?: (values: Record<string, unknown>) => void;
+export interface UseFormCoreConfig<Values = Record<string, unknown>> {
+    initialValues?: Partial<Values>;
+    onFinish?: (values: Values) => void;
     onFinishFailed?: (errorInfo: {
-        values: Record<string, unknown>;
+        values: Values;
         errors: Record<string, string>;
     }) => void;
-    onValuesChange?: (changedValues: Record<string, unknown>, allValues: Record<string, unknown>) => void;
+    onValuesChange?: (changedValues: Partial<Values>, allValues: Values) => void;
     onReset?: () => void;
     size?: FormSize;
     labelAlign?: LabelAlign;
@@ -90,10 +105,12 @@ export interface UseFormCoreConfig {
 export interface FormCoreContextShape {
     values: Record<string, unknown>;
     errors: Record<string, string>;
+    warnings: Record<string, string>;
     touched: Record<string, boolean>;
     formInstance: FormCoreInstance;
     setFieldValue: (name: string, value: unknown) => void;
     setFieldError: (name: string, error: string | null) => void;
+    setFieldWarning: (name: string, warning: string | null) => void;
     validateField: (name: string, rules: Rule[], providedValue?: unknown) => boolean;
     registerField: (name: string, rules: Rule[]) => void;
     unregisterField: (name: string) => void;
@@ -105,16 +122,18 @@ export interface FormCoreContextShape {
     validateTrigger: ValidateTrigger;
 }
 /** Config for useForm — accepts all UseFormCoreConfig fields */
-export type UseFormConfig = UseFormCoreConfig;
+export type UseFormConfig<Values = Record<string, unknown>> = UseFormCoreConfig<Values>;
 /** Internal state exposed by useForm for ProForm integration */
 export interface UseFormInternals {
     values: Record<string, unknown>;
     errors: Record<string, string>;
+    warnings: Record<string, string>;
     touched: Record<string, boolean>;
     validating: Record<string, boolean>;
     fieldRules: Record<string, Rule[]>;
     setFieldValue: (name: string, value: unknown) => void;
     setFieldError: (name: string, error: string | null) => void;
+    setFieldWarning: (name: string, warning: string | null) => void;
     validateField: (name: string, rules: Rule[], providedValue?: unknown) => boolean;
     validateFieldAsync: (name: string, value: unknown, rules: Rule[]) => Promise<{
         isValid: boolean;
@@ -133,11 +152,13 @@ export interface UseFormReturn {
 export interface UseFormCoreReturn {
     values: Record<string, unknown>;
     errors: Record<string, string>;
+    warnings: Record<string, string>;
     touched: Record<string, boolean>;
     fieldRules: Record<string, Rule[]>;
     getFieldRules: (name: string) => Rule[] | undefined;
     setFieldValue: (name: string, value: unknown) => void;
     setFieldError: (name: string, error: string | null) => void;
+    setFieldWarning: (name: string, warning: string | null) => void;
     setFieldsValue: (values: Record<string, unknown>) => void;
     getFieldValue: (name: string) => unknown;
     getFieldsValue: () => Record<string, unknown>;

package/es/components/ProForm/core/runRules.d.ts

@@ -1,13 +1,25 @@
-import type { Rule } from './interface';
+import type { Rule, ValidateTrigger } from './interface';
+export interface RuleRunResult {
+    error: string | null;
+    warning: string | null;
+}
 /**
- * Synchronous rule run. Custom validators are invoked but NOT awaited — a
- * promise-returning validator is treated as failing (matches the legacy sync
- * `validateField` behaviour). Returns the first error message, or null.
+ * Filter rules applicable to an interactive trigger. A rule WITHOUT an
+ * explicit `validateTrigger` follows the form-level trigger; a rule WITH one
+ * runs on exactly those trigger(s), regardless of the form-level setting.
+ * Submit-time validation bypasses this filter and runs every rule.
  */
-export declare function runRulesSync(name: string, value: unknown, values: Record<string, unknown>, rules: Rule[]): string | null;
+export declare function filterRulesByTrigger(rules: Rule[], trigger: ValidateTrigger, formTrigger: ValidateTrigger): Rule[];
+/**
+ * Synchronous rule run. A Promise-returning validator CANNOT be evaluated
+ * here — it is deferred (treated as passing for this run; its rejection is
+ * swallowed) and left to the async runs (blur/submit), which always await it.
+ * Failing it instead would mis-report "Validation failed" on every keystroke
+ * for perfectly valid input.
+ */
+export declare function runRulesSync(name: string, value: unknown, values: Record<string, unknown>, rules: Rule[]): RuleRunResult;
 /**
  * Asynchronous rule run. Custom validators are awaited (sync or async). A
- * validator returning `undefined` is treated as passing. Returns the first
- * error message, or null.
+ * validator returning `undefined` is treated as passing.
  */
-export declare function runRulesAsync(name: string, value: unknown, values: Record<string, unknown>, rules: Rule[]): Promise<string | null>;
+export declare function runRulesAsync(name: string, value: unknown, values: Record<string, unknown>, rules: Rule[]): Promise<RuleRunResult>;