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

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

@@ -45,9 +45,13 @@ 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 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
@@ -399,14 +403,25 @@ 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 [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 touched = useSelector(makeSelectNodeFieldTouched(flowName, currentNode, id));
     const refValue = React.useRef();
     const one = React.useRef();
+    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]);
@@ -466,7 +481,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',
@@ -823,9 +838,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 +851,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(), [
@@ -863,15 +880,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

@@ -43,9 +43,13 @@ 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 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
@@ -397,14 +401,25 @@ 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 [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 touched = useSelector(makeSelectNodeFieldTouched(flowName, currentNode, id));
     const refValue = useRef();
     const one = useRef();
+    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]);
@@ -464,7 +479,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',
@@ -821,9 +836,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 +849,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(), [
@@ -861,15 +878,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/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

@@ -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,89 @@ 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 makeSelectNodeFormTouched: (name: string, currentNodeId: string) => ((state: {
     flower: {
         [x: string]: import("@flowerforce/flower-core").Flower<Record<string, any>>;
@@ -1153,8 +1240,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 +1281,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 +1476,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 +1533,7 @@ export declare const selectorRulesDisabled: (id: string, rules: RulesObject<any>
     }) => {
         touched: boolean;
         errors: any;
+        customErrors: any;
         isValid: boolean;
         isValidating?: boolean | undefined;
     }) & {
@@ -1280,12 +1544,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 +1562,7 @@ export declare const selectorRulesDisabled: (id: string, rules: RulesObject<any>
         lastResult: () => {
             touched: boolean;
             errors: any;
+            customErrors: any;
             isValid: boolean;
             isValidating?: boolean | undefined;
         };
@@ -1374,4 +1641,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, 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.4",
   "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.4",
     "@reduxjs/toolkit": "^2.2.4",
     "lodash": "^4.17.21",
     "react-redux": "^9.1.2",