@flowerforce/flower-react 3.1.2-beta.3 → 3.1.2-beta.5

package/README.md

@@ -834,7 +834,7 @@ Devtool({
 
 ```jsx
 Devtool({
-  remote: 'passKey',
+  sessionId: 'RANDOM SESSION ID',
   sourceMap: require('./.flower.sourcemap.json')
 })
 ```

package/dist/index.cjs.js

@@ -8,6 +8,7 @@ var toolkit = require('@reduxjs/toolkit');
 var reselect = require('reselect');
 var reactRedux = require('react-redux');
 var debounce = require('lodash/debounce');
+var isEqual = require('lodash/isEqual');
 
 const _context = React.createContext({});
 const context = _context;
@@ -45,9 +46,14 @@ const getDataByFlow = (name) => reselect.createSelector(selectFlower(name), flow
 // selettore per recuperare i dati di un flow specifico e id specifico
 const getDataFromState = (name, id) => reselect.createSelector(getDataByFlow(name), flowerCore.Selectors.getDataFromState(id));
 const makeSelectNodeErrors = (name, currentNodeId) => reselect.createSelector(selectFlowerFormNode(name, currentNodeId), flowerCore.Selectors.makeSelectNodeErrors);
+const makeSelectNodeFieldTouched = (name, currentNodeId, fieldId) => reselect.createSelector(selectFlowerFormNode(name, currentNodeId), flowerCore.Selectors.makeSelectNodeFormFieldTouched(fieldId));
+const makeSelectNodeFieldDirty = (name, currentNodeId, fieldId) => reselect.createSelector(selectFlowerFormNode(name, currentNodeId), flowerCore.Selectors.makeSelectNodeFormFieldDirty(fieldId));
 const makeSelectNodeFormTouched = (name, currentNodeId) => reselect.createSelector(selectFlowerFormNode(name, currentNodeId), flowerCore.Selectors.makeSelectNodeFormTouched);
 const getAllData = reselect.createSelector(selectGlobal, mapData);
-const makeSelectFieldError = (name, id, validate) => reselect.createSelector(getAllData, flowerCore.Selectors.makeSelectFieldError(name, id, validate));
+const selectFlowerFormCurrentNode = (name) => reselect.createSelector(selectFlower(name), makeSelectCurrentNodeId(name), (data, current) => {
+    return _get(data, ['form', current]);
+});
+const makeSelectFieldError = (name, id, validate) => reselect.createSelector(getAllData, selectFlowerFormCurrentNode(name), flowerCore.Selectors.makeSelectFieldError(name, id, validate));
 const selectorRulesDisabled = (id, rules, keys, flowName, value, currentNode) => reselect.createSelector(getAllData, makeSelectNodeErrors(flowName, currentNode), flowerCore.Selectors.selectorRulesDisabled(id, rules, keys, flowName, value));
 
 //TODO check reduxContext type due to remove all any types
@@ -251,11 +257,14 @@ const FlowerClient = ({ children, name, destroyOnUnmount = true, startId = null,
         initialData,
         currentNode: current
     }), [flowName, initialData, current]);
-    return isInitialized ? (React.createElement(Provider, { value: contextValues },
-        prevFlowerNodeId !== current &&
-            typeof prevFlowerNodeId === 'string' &&
-            nodeById[prevFlowerNodeId],
-        !isDisabled && nodeById[current])) : null;
+    const prevContextValues = React.useMemo(() => ({
+        flowName,
+        initialData,
+        currentNode: prevFlowerNodeId
+    }), [flowName, initialData, prevFlowerNodeId]);
+    return isInitialized ? (React.createElement(React.Fragment, null,
+        prevFlowerNodeId !== current && typeof prevFlowerNodeId === 'string' && (React.createElement(Provider, { value: prevContextValues }, nodeById[prevFlowerNodeId])),
+        React.createElement(Provider, { value: contextValues }, !isDisabled && nodeById[current]))) : null;
 };
 const component$c = React.memo(FlowerClient);
 
@@ -399,27 +408,55 @@ function isIntrinsicElement$1(x) {
 //TODO make types for wrapper function props
 function Wrapper$1({ Component, id, flowName, currentNode, validate, asyncDebounce = 0, asyncValidate, asyncInitialError, asyncWaitingError, destroyValue, onBlur = (val) => null, hidden, onUpdate, defaultValue, ...props }) {
     const dispatch = useDispatch();
-    const [touched, setTouched] = React.useState();
-    const [customErrors, setCustomErrors] = React.useState(asyncValidate && [asyncInitialError]);
+    const [customAsyncErrors, setCustomAsyncErrors] = React.useState(asyncValidate && [asyncInitialError]);
     const [isValidating, setIsValidating] = React.useState(undefined);
     const { flowNameFromPath = flowName, path } = React.useMemo(() => flowerCore.CoreUtils.getPath(id), [id]);
     const value = useSelector(getDataFromState(flowNameFromPath, path));
     const errors = useSelector(makeSelectFieldError(flowName, id, validate), flowerCore.CoreUtils.allEqual);
+    const dirty = useSelector(makeSelectNodeFieldDirty(flowName, currentNode, id));
+    const touched = useSelector(makeSelectNodeFieldTouched(flowName, currentNode, id));
     const refValue = React.useRef();
-    const one = React.useRef();
+    const touchedForm = useSelector(makeSelectNodeFormTouched(flowName, currentNode));
+    const allErrors = React.useMemo(() => [...errors, ...(customAsyncErrors || []).filter(Boolean)], [errors, customAsyncErrors]);
+    const setTouched = React.useCallback((touched) => {
+        dispatch({
+            type: 'flower/formFieldTouch',
+            payload: {
+                name: flowName,
+                id,
+                currentNode,
+                touched
+            }
+        });
+    }, [dispatch, flowName, currentNode, id]);
     const validateFn = React.useCallback(async (value) => {
         if (asyncWaitingError) {
-            setCustomErrors([asyncWaitingError]);
+            setCustomAsyncErrors([asyncWaitingError]);
         }
         setIsValidating(true);
         const state = flowerCore.FlowerStateUtils.getAllData(store);
         const res = await asyncValidate(value, state, errors);
         setIsValidating(false);
-        setCustomErrors(res);
+        setCustomAsyncErrors(res);
     }, [asyncWaitingError, errors]);
     const debouncedValidation = React.useCallback(debounce(validateFn, asyncDebounce), [
         validateFn
     ]);
+    const onChange = React.useCallback((val) => {
+        dispatch({
+            type: `flower/addDataByPath`,
+            payload: {
+                flowName: flowNameFromPath,
+                id,
+                value: val,
+                dirty: defaultValue ? !isEqual(val, defaultValue) : true
+            }
+        });
+    }, [flowNameFromPath, id, onBlur, dispatch]);
+    const onBlurInternal = React.useCallback((e) => {
+        setTouched(true);
+        onBlur && onBlur(e);
+    }, [onBlur, setTouched]);
     React.useEffect(() => {
         if (asyncValidate) {
             if (refValue.current === value)
@@ -427,36 +464,20 @@ function Wrapper$1({ Component, id, flowName, currentNode, validate, asyncDeboun
             refValue.current = value;
             const hasValue = !flowerCore.MatchRules.utils.isEmpty(value);
             if (!hasValue) {
-                setCustomErrors([asyncInitialError]);
+                setCustomAsyncErrors([asyncInitialError]);
                 setIsValidating(false);
                 return;
             }
             setTouched(true);
             debouncedValidation(value);
         }
-    }, [asyncValidate, asyncInitialError, value, debouncedValidation]);
-    const touchedForm = useSelector(makeSelectNodeFormTouched(flowName, currentNode));
-    const allErrors = React.useMemo(() => [...errors, ...(customErrors || []).filter(Boolean)], [errors, customErrors]);
+    }, [asyncValidate, asyncInitialError, value, debouncedValidation, setTouched]);
     React.useEffect(() => {
         if (onUpdate) {
             onUpdate(value);
         }
     }, [value, onUpdate]);
-    const onChange = React.useCallback((val) => {
-        dispatch({
-            type: `flower/addDataByPath`,
-            payload: {
-                flowName: flowNameFromPath,
-                id: path,
-                value: val
-            }
-        });
-    }, [flowNameFromPath, path, onBlur, dispatch]);
-    const onBlurInternal = React.useCallback((e) => {
-        setTouched(true);
-        onBlur && onBlur(e);
-    }, [onBlur]);
-    React.useLayoutEffect(() => {
+    React.useEffect(() => {
         dispatch({
             type: 'flower/formAddErrors',
             payload: {
@@ -466,7 +487,7 @@ function Wrapper$1({ Component, id, flowName, currentNode, validate, asyncDeboun
                 errors: allErrors
             }
         });
-    }, [id, flowName, allErrors, currentNode]);
+    }, [id, flowName, allErrors, currentNode, touched]);
     React.useEffect(() => {
         dispatch({
             type: 'flower/setFormIsValidating',
@@ -477,7 +498,7 @@ function Wrapper$1({ Component, id, flowName, currentNode, validate, asyncDeboun
             }
         });
     }, [flowName, currentNode, isValidating]);
-    React.useLayoutEffect(() => {
+    React.useEffect(() => {
         // destroy
         return () => {
             if (destroyValue) {
@@ -495,35 +516,37 @@ function Wrapper$1({ Component, id, flowName, currentNode, validate, asyncDeboun
                 }
             });
         };
-    }, [destroyValue]);
+    }, [destroyValue, id, flowNameFromPath, path, currentNode]);
     React.useEffect(() => {
-        if (defaultValue && !one.current) {
-            one.current = true;
+        if (defaultValue && !dirty && !isEqual(value, defaultValue)) {
             onChange(defaultValue);
         }
-    }, [defaultValue, onChange]);
-    const isTouched = touched || touchedForm;
+    }, [defaultValue, value, dirty, onChange]);
     const newProps = React.useMemo(() => ({
         ...props,
         id,
         value,
-        errors: isTouched && allErrors,
-        hasError: isTouched && !!allErrors.length,
+        errors: allErrors,
+        hasError: !!allErrors.length,
         onChange,
         onBlur: onBlurInternal,
-        isTouched,
+        touched,
+        dirty,
         hidden,
-        isValidating
+        isValidating,
+        touchedForm
     }), [
         props,
         id,
         value,
         allErrors,
-        isTouched,
+        touched,
+        dirty,
         onChange,
         onBlurInternal,
         hidden,
-        isValidating
+        isValidating,
+        touchedForm
     ]);
     if (typeof Component === 'function') {
         return Component(newProps);
@@ -823,9 +846,11 @@ const component = React.memo(FlowerComponent);
  *
  * - replaceData
  *
+ * - unTouched
+ *
  * @param {string} flowName - first optional parameter
  *
- * @param {string} name - optional parameter, if flowName exist, name is not used
+ * @param {string} name - alias optional parameter, if flowName exist, name is not used
  *
  */
 const useFlowerForm = ({ flowName: customFlowName, name } = {}) => {
@@ -834,7 +859,7 @@ const useFlowerForm = ({ flowName: customFlowName, name } = {}) => {
     const store = useStore();
     const flowName = customFlowName || name || flowNameDefault || '';
     const currentNode = useSelector(makeSelectCurrentNodeId(flowName));
-    const { errors, isValid, touched, isValidating } = useSelector(makeSelectNodeErrors(flowName, currentNode));
+    const { errors, customErrors, isValid, touched, isValidating } = useSelector(makeSelectNodeErrors(flowName, currentNode));
     const getData = React.useCallback((path) => {
         const { flowNameFromPath = flowName, path: newpath } = flowerCore.CoreUtils.getPath(path);
         return _get(store.getState(), [
@@ -844,13 +869,14 @@ const useFlowerForm = ({ flowName: customFlowName, name } = {}) => {
             ...newpath
         ]);
     }, [store, flowName]);
-    const setData = React.useCallback((val, path) => {
-        if (path) {
-            const { flowNameFromPath = flowName, path: newpath } = flowerCore.CoreUtils.getPath(path);
+    const setData = React.useCallback((val, id) => {
+        if (id) {
+            const { flowNameFromPath = flowName } = flowerCore.CoreUtils.getPath(id);
             dispatch(actions.addDataByPath({
                 flowName: flowNameFromPath,
-                id: Array.isArray(newpath) ? newpath : [newpath],
-                value: val
+                id,
+                value: val,
+                dirty: true
             }));
             return;
         }
@@ -863,15 +889,32 @@ const useFlowerForm = ({ flowName: customFlowName, name } = {}) => {
     const replaceData = React.useCallback((val) => {
         dispatch(actions.replaceData({ flowName, value: val }));
     }, [flowName, dispatch]);
+    const reset = React.useCallback((nodeId) => {
+        dispatch(actions.resetForm({ flowName, id: nodeId || currentNode }));
+    }, [flowName, currentNode, dispatch]);
+    const setCustomErrors = React.useCallback((field, errors, nodeId) => {
+        dispatch({
+            type: 'flower/formAddCustomErrors',
+            payload: {
+                name: flowName,
+                id: field,
+                currentNode: nodeId || currentNode,
+                errors
+            }
+        });
+    }, [flowName, currentNode, dispatch]);
     return {
         touched,
         errors,
+        customErrors,
         isValid,
         isValidating,
         getData,
         setData,
         unsetData,
-        replaceData
+        replaceData,
+        reset,
+        setCustomErrors
     };
 };
 

package/dist/index.esm.js

@@ -1,4 +1,4 @@
-import React, { createContext, PureComponent, memo, useRef, useState, useMemo, Children, useEffect, useContext, useCallback, useLayoutEffect } from 'react';
+import React, { createContext, PureComponent, memo, useRef, useState, useMemo, Children, useEffect, useContext, useCallback } from 'react';
 import _keyBy from 'lodash/keyBy';
 import { CoreUtils, FlowerCoreReducers, FlowerStateUtils, Selectors, devtoolState, Emitter, MatchRules } from '@flowerforce/flower-core';
 import _get from 'lodash/get';
@@ -6,6 +6,7 @@ import { createSlice, configureStore } from '@reduxjs/toolkit';
 import { createSelector } from 'reselect';
 import { createDispatchHook, createSelectorHook, createStoreHook, Provider as Provider$1 } from 'react-redux';
 import debounce from 'lodash/debounce';
+import isEqual from 'lodash/isEqual';
 
 const _context = createContext({});
 const context = _context;
@@ -43,9 +44,14 @@ const getDataByFlow = (name) => createSelector(selectFlower(name), Selectors.get
 // selettore per recuperare i dati di un flow specifico e id specifico
 const getDataFromState = (name, id) => createSelector(getDataByFlow(name), Selectors.getDataFromState(id));
 const makeSelectNodeErrors = (name, currentNodeId) => createSelector(selectFlowerFormNode(name, currentNodeId), Selectors.makeSelectNodeErrors);
+const makeSelectNodeFieldTouched = (name, currentNodeId, fieldId) => createSelector(selectFlowerFormNode(name, currentNodeId), Selectors.makeSelectNodeFormFieldTouched(fieldId));
+const makeSelectNodeFieldDirty = (name, currentNodeId, fieldId) => createSelector(selectFlowerFormNode(name, currentNodeId), Selectors.makeSelectNodeFormFieldDirty(fieldId));
 const makeSelectNodeFormTouched = (name, currentNodeId) => createSelector(selectFlowerFormNode(name, currentNodeId), Selectors.makeSelectNodeFormTouched);
 const getAllData = createSelector(selectGlobal, mapData);
-const makeSelectFieldError = (name, id, validate) => createSelector(getAllData, Selectors.makeSelectFieldError(name, id, validate));
+const selectFlowerFormCurrentNode = (name) => createSelector(selectFlower(name), makeSelectCurrentNodeId(name), (data, current) => {
+    return _get(data, ['form', current]);
+});
+const makeSelectFieldError = (name, id, validate) => createSelector(getAllData, selectFlowerFormCurrentNode(name), Selectors.makeSelectFieldError(name, id, validate));
 const selectorRulesDisabled = (id, rules, keys, flowName, value, currentNode) => createSelector(getAllData, makeSelectNodeErrors(flowName, currentNode), Selectors.selectorRulesDisabled(id, rules, keys, flowName, value));
 
 //TODO check reduxContext type due to remove all any types
@@ -249,11 +255,14 @@ const FlowerClient = ({ children, name, destroyOnUnmount = true, startId = null,
         initialData,
         currentNode: current
     }), [flowName, initialData, current]);
-    return isInitialized ? (React.createElement(Provider, { value: contextValues },
-        prevFlowerNodeId !== current &&
-            typeof prevFlowerNodeId === 'string' &&
-            nodeById[prevFlowerNodeId],
-        !isDisabled && nodeById[current])) : null;
+    const prevContextValues = useMemo(() => ({
+        flowName,
+        initialData,
+        currentNode: prevFlowerNodeId
+    }), [flowName, initialData, prevFlowerNodeId]);
+    return isInitialized ? (React.createElement(React.Fragment, null,
+        prevFlowerNodeId !== current && typeof prevFlowerNodeId === 'string' && (React.createElement(Provider, { value: prevContextValues }, nodeById[prevFlowerNodeId])),
+        React.createElement(Provider, { value: contextValues }, !isDisabled && nodeById[current]))) : null;
 };
 const component$c = memo(FlowerClient);
 
@@ -397,27 +406,55 @@ function isIntrinsicElement$1(x) {
 //TODO make types for wrapper function props
 function Wrapper$1({ Component, id, flowName, currentNode, validate, asyncDebounce = 0, asyncValidate, asyncInitialError, asyncWaitingError, destroyValue, onBlur = (val) => null, hidden, onUpdate, defaultValue, ...props }) {
     const dispatch = useDispatch();
-    const [touched, setTouched] = useState();
-    const [customErrors, setCustomErrors] = useState(asyncValidate && [asyncInitialError]);
+    const [customAsyncErrors, setCustomAsyncErrors] = useState(asyncValidate && [asyncInitialError]);
     const [isValidating, setIsValidating] = useState(undefined);
     const { flowNameFromPath = flowName, path } = useMemo(() => CoreUtils.getPath(id), [id]);
     const value = useSelector(getDataFromState(flowNameFromPath, path));
     const errors = useSelector(makeSelectFieldError(flowName, id, validate), CoreUtils.allEqual);
+    const dirty = useSelector(makeSelectNodeFieldDirty(flowName, currentNode, id));
+    const touched = useSelector(makeSelectNodeFieldTouched(flowName, currentNode, id));
     const refValue = useRef();
-    const one = useRef();
+    const touchedForm = useSelector(makeSelectNodeFormTouched(flowName, currentNode));
+    const allErrors = useMemo(() => [...errors, ...(customAsyncErrors || []).filter(Boolean)], [errors, customAsyncErrors]);
+    const setTouched = useCallback((touched) => {
+        dispatch({
+            type: 'flower/formFieldTouch',
+            payload: {
+                name: flowName,
+                id,
+                currentNode,
+                touched
+            }
+        });
+    }, [dispatch, flowName, currentNode, id]);
     const validateFn = useCallback(async (value) => {
         if (asyncWaitingError) {
-            setCustomErrors([asyncWaitingError]);
+            setCustomAsyncErrors([asyncWaitingError]);
         }
         setIsValidating(true);
         const state = FlowerStateUtils.getAllData(store);
         const res = await asyncValidate(value, state, errors);
         setIsValidating(false);
-        setCustomErrors(res);
+        setCustomAsyncErrors(res);
     }, [asyncWaitingError, errors]);
     const debouncedValidation = useCallback(debounce(validateFn, asyncDebounce), [
         validateFn
     ]);
+    const onChange = useCallback((val) => {
+        dispatch({
+            type: `flower/addDataByPath`,
+            payload: {
+                flowName: flowNameFromPath,
+                id,
+                value: val,
+                dirty: defaultValue ? !isEqual(val, defaultValue) : true
+            }
+        });
+    }, [flowNameFromPath, id, onBlur, dispatch]);
+    const onBlurInternal = useCallback((e) => {
+        setTouched(true);
+        onBlur && onBlur(e);
+    }, [onBlur, setTouched]);
     useEffect(() => {
         if (asyncValidate) {
             if (refValue.current === value)
@@ -425,36 +462,20 @@ function Wrapper$1({ Component, id, flowName, currentNode, validate, asyncDeboun
             refValue.current = value;
             const hasValue = !MatchRules.utils.isEmpty(value);
             if (!hasValue) {
-                setCustomErrors([asyncInitialError]);
+                setCustomAsyncErrors([asyncInitialError]);
                 setIsValidating(false);
                 return;
             }
             setTouched(true);
             debouncedValidation(value);
         }
-    }, [asyncValidate, asyncInitialError, value, debouncedValidation]);
-    const touchedForm = useSelector(makeSelectNodeFormTouched(flowName, currentNode));
-    const allErrors = useMemo(() => [...errors, ...(customErrors || []).filter(Boolean)], [errors, customErrors]);
+    }, [asyncValidate, asyncInitialError, value, debouncedValidation, setTouched]);
     useEffect(() => {
         if (onUpdate) {
             onUpdate(value);
         }
     }, [value, onUpdate]);
-    const onChange = useCallback((val) => {
-        dispatch({
-            type: `flower/addDataByPath`,
-            payload: {
-                flowName: flowNameFromPath,
-                id: path,
-                value: val
-            }
-        });
-    }, [flowNameFromPath, path, onBlur, dispatch]);
-    const onBlurInternal = useCallback((e) => {
-        setTouched(true);
-        onBlur && onBlur(e);
-    }, [onBlur]);
-    useLayoutEffect(() => {
+    useEffect(() => {
         dispatch({
             type: 'flower/formAddErrors',
             payload: {
@@ -464,7 +485,7 @@ function Wrapper$1({ Component, id, flowName, currentNode, validate, asyncDeboun
                 errors: allErrors
             }
         });
-    }, [id, flowName, allErrors, currentNode]);
+    }, [id, flowName, allErrors, currentNode, touched]);
     useEffect(() => {
         dispatch({
             type: 'flower/setFormIsValidating',
@@ -475,7 +496,7 @@ function Wrapper$1({ Component, id, flowName, currentNode, validate, asyncDeboun
             }
         });
     }, [flowName, currentNode, isValidating]);
-    useLayoutEffect(() => {
+    useEffect(() => {
         // destroy
         return () => {
             if (destroyValue) {
@@ -493,35 +514,37 @@ function Wrapper$1({ Component, id, flowName, currentNode, validate, asyncDeboun
                 }
             });
         };
-    }, [destroyValue]);
+    }, [destroyValue, id, flowNameFromPath, path, currentNode]);
     useEffect(() => {
-        if (defaultValue && !one.current) {
-            one.current = true;
+        if (defaultValue && !dirty && !isEqual(value, defaultValue)) {
             onChange(defaultValue);
         }
-    }, [defaultValue, onChange]);
-    const isTouched = touched || touchedForm;
+    }, [defaultValue, value, dirty, onChange]);
     const newProps = useMemo(() => ({
         ...props,
         id,
         value,
-        errors: isTouched && allErrors,
-        hasError: isTouched && !!allErrors.length,
+        errors: allErrors,
+        hasError: !!allErrors.length,
         onChange,
         onBlur: onBlurInternal,
-        isTouched,
+        touched,
+        dirty,
         hidden,
-        isValidating
+        isValidating,
+        touchedForm
     }), [
         props,
         id,
         value,
         allErrors,
-        isTouched,
+        touched,
+        dirty,
         onChange,
         onBlurInternal,
         hidden,
-        isValidating
+        isValidating,
+        touchedForm
     ]);
     if (typeof Component === 'function') {
         return Component(newProps);
@@ -821,9 +844,11 @@ const component = memo(FlowerComponent);
  *
  * - replaceData
  *
+ * - unTouched
+ *
  * @param {string} flowName - first optional parameter
  *
- * @param {string} name - optional parameter, if flowName exist, name is not used
+ * @param {string} name - alias optional parameter, if flowName exist, name is not used
  *
  */
 const useFlowerForm = ({ flowName: customFlowName, name } = {}) => {
@@ -832,7 +857,7 @@ const useFlowerForm = ({ flowName: customFlowName, name } = {}) => {
     const store = useStore();
     const flowName = customFlowName || name || flowNameDefault || '';
     const currentNode = useSelector(makeSelectCurrentNodeId(flowName));
-    const { errors, isValid, touched, isValidating } = useSelector(makeSelectNodeErrors(flowName, currentNode));
+    const { errors, customErrors, isValid, touched, isValidating } = useSelector(makeSelectNodeErrors(flowName, currentNode));
     const getData = useCallback((path) => {
         const { flowNameFromPath = flowName, path: newpath } = CoreUtils.getPath(path);
         return _get(store.getState(), [
@@ -842,13 +867,14 @@ const useFlowerForm = ({ flowName: customFlowName, name } = {}) => {
             ...newpath
         ]);
     }, [store, flowName]);
-    const setData = useCallback((val, path) => {
-        if (path) {
-            const { flowNameFromPath = flowName, path: newpath } = CoreUtils.getPath(path);
+    const setData = useCallback((val, id) => {
+        if (id) {
+            const { flowNameFromPath = flowName } = CoreUtils.getPath(id);
             dispatch(actions.addDataByPath({
                 flowName: flowNameFromPath,
-                id: Array.isArray(newpath) ? newpath : [newpath],
-                value: val
+                id,
+                value: val,
+                dirty: true
             }));
             return;
         }
@@ -861,15 +887,32 @@ const useFlowerForm = ({ flowName: customFlowName, name } = {}) => {
     const replaceData = useCallback((val) => {
         dispatch(actions.replaceData({ flowName, value: val }));
     }, [flowName, dispatch]);
+    const reset = useCallback((nodeId) => {
+        dispatch(actions.resetForm({ flowName, id: nodeId || currentNode }));
+    }, [flowName, currentNode, dispatch]);
+    const setCustomErrors = useCallback((field, errors, nodeId) => {
+        dispatch({
+            type: 'flower/formAddCustomErrors',
+            payload: {
+                name: flowName,
+                id: field,
+                currentNode: nodeId || currentNode,
+                errors
+            }
+        });
+    }, [flowName, currentNode, dispatch]);
     return {
         touched,
         errors,
+        customErrors,
         isValid,
         isValidating,
         getData,
         setData,
         unsetData,
-        replaceData
+        replaceData,
+        reset,
+        setCustomErrors
     };
 };
 

package/dist/src/components/types/FlowerField.d.ts

@@ -32,7 +32,11 @@ export type FlowerFieldProps<T extends Record<string, any> = Record<string, any>
         /** The function executed to test all the validation rules*/
         onBlur: () => void;
         /** This parameter will notify you whether the form field has been touched */
-        isTouched: boolean;
+        touchedForm: boolean;
+        /** This parameter will notify you whether the form field has been touched */
+        touched: boolean;
+        /** This parameter will notify you whether the form field has been touched */
+        dirty: boolean;
         /** true when some of the display rules are not satisfied, and you have passed true to the "alwaysDisplay" FlowerField's prop*/
         hidden: boolean;
         /** true when you have an async validation in progress */

package/dist/src/components/types/FlowerHooks.d.ts

@@ -7,6 +7,8 @@ export type UseFlowerForm = (options?: UseFlowerProps) => {
     touched: boolean;
     /** An object containing all the form errors */
     errors: Record<string, any>;
+    /** An object containing all the form custom errors */
+    customErrors: Record<string, any>;
     /** This value is set to true when all the validation rules are satisfied and the form is valid*/
     isValid: boolean;
     /** This value is set to true during asynchronous validation.*/
@@ -25,6 +27,10 @@ export type UseFlowerForm = (options?: UseFlowerProps) => {
     path: string) => void;
     /** Use this function to replace a value in the flow's data. */
     replaceData: (value: any) => void;
+    /**Use this function to reset errors form and touched state */
+    reset: (nodeId?: string) => void;
+    /**this function to set a custom error on a specific field */
+    setCustomErrors: (field: string, errors: string[], nodeId?: string) => void;
 };
 type useFlowerActions = {
     /** Use this function to move to the next node inside the flow*/

package/dist/src/components/useFlowerForm.d.ts

@@ -11,9 +11,11 @@ import { UseFlowerForm } from './types/FlowerHooks';
  *
  * - replaceData
  *
+ * - unTouched
+ *
  * @param {string} flowName - first optional parameter
  *
- * @param {string} name - optional parameter, if flowName exist, name is not used
+ * @param {string} name - alias optional parameter, if flowName exist, name is not used
  *
  */
 declare const useFlowerForm: UseFlowerForm;

package/dist/src/selectors.d.ts

@@ -305,22 +305,22 @@ declare const makeSelectPrevNodeRetain: (name: string) => ((state: {
     flower: {
         [x: string]: import("@flowerforce/flower-core").Flower<Record<string, any>>;
     };
-}) => string | boolean | undefined) & {
+}) => string | undefined) & {
     clearCache: () => void;
     resultsCount: () => number;
     resetResultsCount: () => void;
 } & {
     resultFunc: (resultFuncArgs_0: {
         [x: string]: import("@flowerforce/flower-core").INode;
-    }, resultFuncArgs_1: string[], resultFuncArgs_2: string) => string | boolean | undefined;
+    }, resultFuncArgs_1: string[], resultFuncArgs_2: string) => string | undefined;
     memoizedResultFunc: ((resultFuncArgs_0: {
         [x: string]: import("@flowerforce/flower-core").INode;
-    }, resultFuncArgs_1: string[], resultFuncArgs_2: string) => string | boolean | undefined) & {
+    }, resultFuncArgs_1: string[], resultFuncArgs_2: string) => string | undefined) & {
         clearCache: () => void;
         resultsCount: () => number;
         resetResultsCount: () => void;
     };
-    lastResult: () => string | boolean | undefined;
+    lastResult: () => string | undefined;
     dependencies: [((state: {
         flower: {
             [x: string]: import("@flowerforce/flower-core").Flower<Record<string, any>>;
@@ -930,6 +930,7 @@ declare const makeSelectNodeErrors: (name: string, currentNodeId: string) => ((s
 }) => {
     touched: boolean;
     errors: any;
+    customErrors: any;
     isValid: boolean;
     isValidating?: boolean | undefined;
 }) & {
@@ -940,12 +941,14 @@ declare const makeSelectNodeErrors: (name: string, currentNodeId: string) => ((s
     resultFunc: (resultFuncArgs_0: import("@flowerforce/flower-core").Form<Record<string, any>>) => {
         touched: boolean;
         errors: any;
+        customErrors: any;
         isValid: boolean;
         isValidating?: boolean | undefined;
     };
     memoizedResultFunc: ((resultFuncArgs_0: import("@flowerforce/flower-core").Form<Record<string, any>>) => {
         touched: boolean;
         errors: any;
+        customErrors: any;
         isValid: boolean;
         isValidating?: boolean | undefined;
     }) & {
@@ -956,6 +959,7 @@ declare const makeSelectNodeErrors: (name: string, currentNodeId: string) => ((s
     lastResult: () => {
         touched: boolean;
         errors: any;
+        customErrors: any;
         isValid: boolean;
         isValidating?: boolean | undefined;
     };
@@ -1026,6 +1030,172 @@ declare const makeSelectNodeErrors: (name: string, currentNodeId: string) => ((s
     argsMemoize: typeof import("reselect").weakMapMemoize;
     memoize: typeof import("reselect").weakMapMemoize;
 };
+declare const makeSelectNodeFieldTouched: (name: string, currentNodeId: string, fieldId: string) => ((state: {
+    flower: {
+        [x: string]: import("@flowerforce/flower-core").Flower<Record<string, any>>;
+    };
+}) => boolean | undefined) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: import("@flowerforce/flower-core").Form<Record<string, any>>) => boolean | undefined;
+    memoizedResultFunc: ((resultFuncArgs_0: import("@flowerforce/flower-core").Form<Record<string, any>>) => boolean | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean | undefined;
+    dependencies: [((state: {
+        flower: {
+            [x: string]: import("@flowerforce/flower-core").Flower<Record<string, any>>;
+        };
+    }) => import("@flowerforce/flower-core").Form<Record<string, any>>) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: import("@flowerforce/flower-core").Flower<Record<string, any>>) => import("@flowerforce/flower-core").Form<Record<string, any>>;
+        memoizedResultFunc: ((resultFuncArgs_0: import("@flowerforce/flower-core").Flower<Record<string, any>>) => import("@flowerforce/flower-core").Form<Record<string, any>>) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => import("@flowerforce/flower-core").Form<Record<string, any>>;
+        dependencies: [((state: {
+            flower: {
+                [x: string]: import("@flowerforce/flower-core").Flower<Record<string, any>>;
+            };
+        }) => import("@flowerforce/flower-core").Flower<Record<string, any>>) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        } & {
+            resultFunc: (resultFuncArgs_0: {
+                [x: string]: import("@flowerforce/flower-core").Flower<Record<string, any>>;
+            }) => import("@flowerforce/flower-core").Flower<Record<string, any>>;
+            memoizedResultFunc: ((resultFuncArgs_0: {
+                [x: string]: import("@flowerforce/flower-core").Flower<Record<string, any>>;
+            }) => import("@flowerforce/flower-core").Flower<Record<string, any>>) & {
+                clearCache: () => void;
+                resultsCount: () => number;
+                resetResultsCount: () => void;
+            };
+            lastResult: () => import("@flowerforce/flower-core").Flower<Record<string, any>>;
+            dependencies: [<T extends Record<string, any>>(state: {
+                flower: {
+                    [x: string]: import("@flowerforce/flower-core").Flower<T>;
+                };
+            }) => {
+                [x: string]: import("@flowerforce/flower-core").Flower<T>;
+            }];
+            recomputations: () => number;
+            resetRecomputations: () => void;
+            dependencyRecomputations: () => number;
+            resetDependencyRecomputations: () => void;
+        } & {
+            argsMemoize: typeof import("reselect").weakMapMemoize;
+            memoize: typeof import("reselect").weakMapMemoize;
+        }];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+        memoize: typeof import("reselect").weakMapMemoize;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+declare const makeSelectNodeFieldDirty: (name: string, currentNodeId: string, fieldId: string) => ((state: {
+    flower: {
+        [x: string]: import("@flowerforce/flower-core").Flower<Record<string, any>>;
+    };
+}) => boolean | undefined) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: import("@flowerforce/flower-core").Form<Record<string, any>>) => boolean | undefined;
+    memoizedResultFunc: ((resultFuncArgs_0: import("@flowerforce/flower-core").Form<Record<string, any>>) => boolean | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean | undefined;
+    dependencies: [((state: {
+        flower: {
+            [x: string]: import("@flowerforce/flower-core").Flower<Record<string, any>>;
+        };
+    }) => import("@flowerforce/flower-core").Form<Record<string, any>>) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: import("@flowerforce/flower-core").Flower<Record<string, any>>) => import("@flowerforce/flower-core").Form<Record<string, any>>;
+        memoizedResultFunc: ((resultFuncArgs_0: import("@flowerforce/flower-core").Flower<Record<string, any>>) => import("@flowerforce/flower-core").Form<Record<string, any>>) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => import("@flowerforce/flower-core").Form<Record<string, any>>;
+        dependencies: [((state: {
+            flower: {
+                [x: string]: import("@flowerforce/flower-core").Flower<Record<string, any>>;
+            };
+        }) => import("@flowerforce/flower-core").Flower<Record<string, any>>) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        } & {
+            resultFunc: (resultFuncArgs_0: {
+                [x: string]: import("@flowerforce/flower-core").Flower<Record<string, any>>;
+            }) => import("@flowerforce/flower-core").Flower<Record<string, any>>;
+            memoizedResultFunc: ((resultFuncArgs_0: {
+                [x: string]: import("@flowerforce/flower-core").Flower<Record<string, any>>;
+            }) => import("@flowerforce/flower-core").Flower<Record<string, any>>) & {
+                clearCache: () => void;
+                resultsCount: () => number;
+                resetResultsCount: () => void;
+            };
+            lastResult: () => import("@flowerforce/flower-core").Flower<Record<string, any>>;
+            dependencies: [<T extends Record<string, any>>(state: {
+                flower: {
+                    [x: string]: import("@flowerforce/flower-core").Flower<T>;
+                };
+            }) => {
+                [x: string]: import("@flowerforce/flower-core").Flower<T>;
+            }];
+            recomputations: () => number;
+            resetRecomputations: () => void;
+            dependencyRecomputations: () => number;
+            resetDependencyRecomputations: () => void;
+        } & {
+            argsMemoize: typeof import("reselect").weakMapMemoize;
+            memoize: typeof import("reselect").weakMapMemoize;
+        }];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+        memoize: typeof import("reselect").weakMapMemoize;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
 declare const makeSelectNodeFormTouched: (name: string, currentNodeId: string) => ((state: {
     flower: {
         [x: string]: import("@flowerforce/flower-core").Flower<Record<string, any>>;
@@ -1153,8 +1323,8 @@ declare const makeSelectFieldError: (name: string, id: string, validate: any) =>
     resultsCount: () => number;
     resetResultsCount: () => void;
 } & {
-    resultFunc: (resultFuncArgs_0: Record<string, any> | undefined) => string[];
-    memoizedResultFunc: ((resultFuncArgs_0: Record<string, any> | undefined) => string[]) & {
+    resultFunc: (resultFuncArgs_0: Record<string, any> | undefined, resultFuncArgs_1: import("@flowerforce/flower-core").Form<Record<string, any>>) => string[];
+    memoizedResultFunc: ((resultFuncArgs_0: Record<string, any> | undefined, resultFuncArgs_1: import("@flowerforce/flower-core").Form<Record<string, any>>) => string[]) & {
         clearCache: () => void;
         resultsCount: () => number;
         resetResultsCount: () => void;
@@ -1194,6 +1364,180 @@ declare const makeSelectFieldError: (name: string, id: string, validate: any) =>
     } & {
         argsMemoize: typeof import("reselect").weakMapMemoize;
         memoize: typeof import("reselect").weakMapMemoize;
+    }, ((state: {
+        flower: {
+            [x: string]: import("@flowerforce/flower-core").Flower<Record<string, any>>;
+        };
+    }) => import("@flowerforce/flower-core").Form<Record<string, any>>) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: import("@flowerforce/flower-core").Flower<Record<string, any>>, resultFuncArgs_1: string) => import("@flowerforce/flower-core").Form<Record<string, any>>;
+        memoizedResultFunc: ((resultFuncArgs_0: import("@flowerforce/flower-core").Flower<Record<string, any>>, resultFuncArgs_1: string) => import("@flowerforce/flower-core").Form<Record<string, any>>) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => import("@flowerforce/flower-core").Form<Record<string, any>>;
+        dependencies: [((state: {
+            flower: {
+                [x: string]: import("@flowerforce/flower-core").Flower<Record<string, any>>;
+            };
+        }) => import("@flowerforce/flower-core").Flower<Record<string, any>>) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        } & {
+            resultFunc: (resultFuncArgs_0: {
+                [x: string]: import("@flowerforce/flower-core").Flower<Record<string, any>>;
+            }) => import("@flowerforce/flower-core").Flower<Record<string, any>>;
+            memoizedResultFunc: ((resultFuncArgs_0: {
+                [x: string]: import("@flowerforce/flower-core").Flower<Record<string, any>>;
+            }) => import("@flowerforce/flower-core").Flower<Record<string, any>>) & {
+                clearCache: () => void;
+                resultsCount: () => number;
+                resetResultsCount: () => void;
+            };
+            lastResult: () => import("@flowerforce/flower-core").Flower<Record<string, any>>;
+            dependencies: [<T extends Record<string, any>>(state: {
+                flower: {
+                    [x: string]: import("@flowerforce/flower-core").Flower<T>;
+                };
+            }) => {
+                [x: string]: import("@flowerforce/flower-core").Flower<T>;
+            }];
+            recomputations: () => number;
+            resetRecomputations: () => void;
+            dependencyRecomputations: () => number;
+            resetDependencyRecomputations: () => void;
+        } & {
+            argsMemoize: typeof import("reselect").weakMapMemoize;
+            memoize: typeof import("reselect").weakMapMemoize;
+        }, ((state: {
+            flower: {
+                [x: string]: import("@flowerforce/flower-core").Flower<Record<string, any>>;
+            };
+        }) => string) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        } & {
+            resultFunc: (resultFuncArgs_0: import("@flowerforce/flower-core").Flower<Record<string, any>>, resultFuncArgs_1: string) => string;
+            memoizedResultFunc: ((resultFuncArgs_0: import("@flowerforce/flower-core").Flower<Record<string, any>>, resultFuncArgs_1: string) => string) & {
+                clearCache: () => void;
+                resultsCount: () => number;
+                resetResultsCount: () => void;
+            };
+            lastResult: () => string;
+            dependencies: [((state: {
+                flower: {
+                    [x: string]: import("@flowerforce/flower-core").Flower<Record<string, any>>;
+                };
+            }) => import("@flowerforce/flower-core").Flower<Record<string, any>>) & {
+                clearCache: () => void;
+                resultsCount: () => number;
+                resetResultsCount: () => void;
+            } & {
+                resultFunc: (resultFuncArgs_0: {
+                    [x: string]: import("@flowerforce/flower-core").Flower<Record<string, any>>;
+                }) => import("@flowerforce/flower-core").Flower<Record<string, any>>;
+                memoizedResultFunc: ((resultFuncArgs_0: {
+                    [x: string]: import("@flowerforce/flower-core").Flower<Record<string, any>>;
+                }) => import("@flowerforce/flower-core").Flower<Record<string, any>>) & {
+                    clearCache: () => void;
+                    resultsCount: () => number;
+                    resetResultsCount: () => void;
+                };
+                lastResult: () => import("@flowerforce/flower-core").Flower<Record<string, any>>;
+                dependencies: [<T extends Record<string, any>>(state: {
+                    flower: {
+                        [x: string]: import("@flowerforce/flower-core").Flower<T>;
+                    };
+                }) => {
+                    [x: string]: import("@flowerforce/flower-core").Flower<T>;
+                }];
+                recomputations: () => number;
+                resetRecomputations: () => void;
+                dependencyRecomputations: () => number;
+                resetDependencyRecomputations: () => void;
+            } & {
+                argsMemoize: typeof import("reselect").weakMapMemoize;
+                memoize: typeof import("reselect").weakMapMemoize;
+            }, ((state: {
+                flower: {
+                    [x: string]: import("@flowerforce/flower-core").Flower<Record<string, any>>;
+                };
+            }) => string) & {
+                clearCache: () => void;
+                resultsCount: () => number;
+                resetResultsCount: () => void;
+            } & {
+                resultFunc: (resultFuncArgs_0: import("@flowerforce/flower-core").Flower<Record<string, any>>) => string;
+                memoizedResultFunc: ((resultFuncArgs_0: import("@flowerforce/flower-core").Flower<Record<string, any>>) => string) & {
+                    clearCache: () => void;
+                    resultsCount: () => number;
+                    resetResultsCount: () => void;
+                };
+                lastResult: () => string;
+                dependencies: [((state: {
+                    flower: {
+                        [x: string]: import("@flowerforce/flower-core").Flower<Record<string, any>>;
+                    };
+                }) => import("@flowerforce/flower-core").Flower<Record<string, any>>) & {
+                    clearCache: () => void;
+                    resultsCount: () => number;
+                    resetResultsCount: () => void;
+                } & {
+                    resultFunc: (resultFuncArgs_0: {
+                        [x: string]: import("@flowerforce/flower-core").Flower<Record<string, any>>;
+                    }) => import("@flowerforce/flower-core").Flower<Record<string, any>>;
+                    memoizedResultFunc: ((resultFuncArgs_0: {
+                        [x: string]: import("@flowerforce/flower-core").Flower<Record<string, any>>;
+                    }) => import("@flowerforce/flower-core").Flower<Record<string, any>>) & {
+                        clearCache: () => void;
+                        resultsCount: () => number;
+                        resetResultsCount: () => void;
+                    };
+                    lastResult: () => import("@flowerforce/flower-core").Flower<Record<string, any>>;
+                    dependencies: [<T extends Record<string, any>>(state: {
+                        flower: {
+                            [x: string]: import("@flowerforce/flower-core").Flower<T>;
+                        };
+                    }) => {
+                        [x: string]: import("@flowerforce/flower-core").Flower<T>;
+                    }];
+                    recomputations: () => number;
+                    resetRecomputations: () => void;
+                    dependencyRecomputations: () => number;
+                    resetDependencyRecomputations: () => void;
+                } & {
+                    argsMemoize: typeof import("reselect").weakMapMemoize;
+                    memoize: typeof import("reselect").weakMapMemoize;
+                }];
+                recomputations: () => number;
+                resetRecomputations: () => void;
+                dependencyRecomputations: () => number;
+                resetDependencyRecomputations: () => void;
+            } & {
+                argsMemoize: typeof import("reselect").weakMapMemoize;
+                memoize: typeof import("reselect").weakMapMemoize;
+            }];
+            recomputations: () => number;
+            resetRecomputations: () => void;
+            dependencyRecomputations: () => number;
+            resetDependencyRecomputations: () => void;
+        } & {
+            argsMemoize: typeof import("reselect").weakMapMemoize;
+            memoize: typeof import("reselect").weakMapMemoize;
+        }];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+        memoize: typeof import("reselect").weakMapMemoize;
     }];
     recomputations: () => number;
     resetRecomputations: () => void;
@@ -1215,12 +1559,14 @@ export declare const selectorRulesDisabled: (id: string, rules: RulesObject<any>
     resultFunc: (resultFuncArgs_0: Record<string, any> | undefined, resultFuncArgs_1: {
         touched: boolean;
         errors: any;
+        customErrors: any;
         isValid: boolean;
         isValidating?: boolean | undefined;
     }) => boolean;
     memoizedResultFunc: ((resultFuncArgs_0: Record<string, any> | undefined, resultFuncArgs_1: {
         touched: boolean;
         errors: any;
+        customErrors: any;
         isValid: boolean;
         isValidating?: boolean | undefined;
     }) => boolean) & {
@@ -1270,6 +1616,7 @@ export declare const selectorRulesDisabled: (id: string, rules: RulesObject<any>
     }) => {
         touched: boolean;
         errors: any;
+        customErrors: any;
         isValid: boolean;
         isValidating?: boolean | undefined;
     }) & {
@@ -1280,12 +1627,14 @@ export declare const selectorRulesDisabled: (id: string, rules: RulesObject<any>
         resultFunc: (resultFuncArgs_0: import("@flowerforce/flower-core").Form<Record<string, any>>) => {
             touched: boolean;
             errors: any;
+            customErrors: any;
             isValid: boolean;
             isValidating?: boolean | undefined;
         };
         memoizedResultFunc: ((resultFuncArgs_0: import("@flowerforce/flower-core").Form<Record<string, any>>) => {
             touched: boolean;
             errors: any;
+            customErrors: any;
             isValid: boolean;
             isValidating?: boolean | undefined;
         }) & {
@@ -1296,6 +1645,7 @@ export declare const selectorRulesDisabled: (id: string, rules: RulesObject<any>
         lastResult: () => {
             touched: boolean;
             errors: any;
+            customErrors: any;
             isValid: boolean;
             isValidating?: boolean | undefined;
         };
@@ -1374,4 +1724,4 @@ export declare const selectorRulesDisabled: (id: string, rules: RulesObject<any>
     argsMemoize: typeof import("reselect").weakMapMemoize;
     memoize: typeof import("reselect").weakMapMemoize;
 };
-export { selectFlowerHistory, makeSelectNodesIds, makeSelectCurrentNodeId, makeSelectStartNodeId, makeSelectCurrentNodeDisabled, getAllData, getDataByFlow, getDataFromState, makeSelectNodeErrors, makeSelectFieldError, makeSelectNodeFormTouched, makeSelectPrevNodeRetain };
+export { selectFlowerHistory, makeSelectNodesIds, makeSelectCurrentNodeId, makeSelectStartNodeId, makeSelectCurrentNodeDisabled, getAllData, getDataByFlow, getDataFromState, makeSelectNodeErrors, makeSelectNodeFieldTouched, makeSelectNodeFieldDirty, makeSelectFieldError, makeSelectNodeFormTouched, makeSelectPrevNodeRetain };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flowerforce/flower-react",
-  "version": "3.1.2-beta.3",
+  "version": "3.1.2-beta.5",
   "description": "FlowerJS components, hooks and utils for React.",
   "repository": {
     "type": "git",
@@ -34,7 +34,7 @@
     "typescript": "^5.4.5"
   },
   "dependencies": {
-    "@flowerforce/flower-core": "3.1.2-beta.3",
+    "@flowerforce/flower-core": "3.1.2-beta.5",
     "@reduxjs/toolkit": "^2.2.4",
     "lodash": "^4.17.21",
     "react-redux": "^9.1.2",