@flowerforce/flower-react 3.7.2 → 4.0.1-beta.0

package/dist/index.esm.js

@@ -1,122 +1,103 @@
-import React, { createContext, PureComponent, memo, useRef, useState, useMemo, Children, useEffect, useContext, useCallback } from 'react';
+import React, { useEffect, memo, useRef, useState, useMemo, Children, useContext, useCallback } from 'react';
 import _keyBy from 'lodash/keyBy';
-import { CoreUtils, FlowerCoreReducers, FlowerStateUtils, Selectors, devtoolState, Emitter, MatchRules } from '@flowerforce/flower-core';
+import { FlowUtils, FlowerCoreBaseReducers, REDUCER_NAME, FlowerCoreStateSelectors, FlowerStateUtils, Emitter, devtoolState } from '@flowerforce/flower-core';
+import { FlowerReactProvider, FlowerReactContext } from '@flowerforce/flower-react-context';
 import _get from 'lodash/get';
-import { createSlice, configureStore } from '@reduxjs/toolkit';
+import { reducerData, ReduxFlowerProvider, flowerDataActions, middlewares } from '@flowerforce/flower-react-store';
+export { createApi } from '@flowerforce/flower-react-store';
+import { createSlice, configureStore, combineReducers, createAction } 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';
+import { useHistoryContext } from '@flowerforce/flower-react-history-context';
+export { HistoryContextProvider } from '@flowerforce/flower-react-history-context';
+import { FlowerRule } from '@flowerforce/flower-react-shared';
+import set from 'lodash/set';
 
-const _context = createContext({});
-const context = _context;
-const Provider = _context.Provider;
-const Consumer = _context.Consumer;
-
-// eslint-disable-next-line import/prefer-default-export
-const convertElements = (nodes) => {
-    const res = CoreUtils.generateNodesForFlowerJson(nodes);
-    return res;
+const getRulesExists = (rules) => {
+    return Object.keys(rules).length ? FlowUtils.mapEdge(rules) : undefined;
 };
+function hasDisplayName(type) {
+    return (!!type &&
+        typeof type === 'object' &&
+        'displayName' in type &&
+        typeof type.displayName === 'string');
+}
+const generateNodesForFlowerJson = (nodes) => nodes
+    .filter((child) => typeof child === 'object' && child !== null && 'props' in child)
+    .filter((e) => !!_get(e, 'props.id'))
+    .map((e) => {
+    const rules = FlowUtils.makeRules(e.props.to ?? {});
+    const nextRules = getRulesExists(rules);
+    const children = e.props.data?.children;
+    const nodeType = hasDisplayName(e.type)
+        ? e.type.displayName
+        : e.props.as || 'FlowerNode';
+    return {
+        nodeId: e.props.id,
+        nodeType,
+        nodeTitle: _get(e.props, 'data.title'),
+        children,
+        nextRules,
+        retain: e.props.retain,
+        disabled: e.props.disabled
+    };
+});
 
 const flowerReducer = createSlice({
-    name: 'flower',
+    name: REDUCER_NAME.FLOWER_FLOW,
     initialState: {},
-    reducers: FlowerCoreReducers
+    reducers: FlowerCoreBaseReducers
 });
-const { actions } = flowerReducer;
+const flowerActions = flowerReducer.actions;
+const flowerFlowReducer = flowerReducer.reducer;
 const reducerFlower = {
-    flower: flowerReducer.reducer
+    [REDUCER_NAME.FLOWER_FLOW]: flowerFlowReducer
+};
+const flowerReducers = {
+    ...reducerFlower,
+    ...reducerData
 };
 
-const { getAllData: mapData } = FlowerStateUtils;
-const { selectGlobal } = Selectors;
-const selectFlower = (name) => createSelector(selectGlobal, Selectors.selectFlower(name));
-const selectFlowerFormNode = (name, id) => createSelector(selectFlower(name), Selectors.selectFlowerFormNode(id));
-const selectFlowerHistory = (name) => createSelector(selectFlower(name), Selectors.selectFlowerHistory);
-const makeSelectNodesIds = (name) => createSelector(selectFlower(name), Selectors.makeSelectNodesIds);
-const makeSelectStartNodeId = (name) => createSelector(selectFlower(name), Selectors.makeSelectStartNodeId);
-const makeSelectCurrentNodeId = (name) => createSelector(selectFlower(name), makeSelectStartNodeId(name), Selectors.makeSelectCurrentNodeId);
-const makeSelectPrevNodeRetain = (name) => createSelector(makeSelectNodesIds(name), selectFlowerHistory(name), makeSelectCurrentNodeId(name), Selectors.makeSelectPrevNodeRetain);
-const makeSelectCurrentNodeDisabled = (name) => createSelector(makeSelectNodesIds(name), makeSelectCurrentNodeId(name), Selectors.makeSelectCurrentNodeDisabled);
-// dati nel flow selezionato
-const getDataByFlow = (name) => createSelector(selectFlower(name), Selectors.getDataByFlow);
-// 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 makeSelectNodeFieldFocused = (name, currentNodeId, fieldId) => createSelector(selectFlowerFormNode(name, currentNodeId), Selectors.makeSelectNodeFormFieldFocused(fieldId));
-const makeSelectNodeFieldDirty = (name, currentNodeId, fieldId) => createSelector(selectFlowerFormNode(name, currentNodeId), Selectors.makeSelectNodeFormFieldDirty(fieldId));
-const makeSelectNodeFormSubmitted = (name, currentNodeId) => createSelector(selectFlowerFormNode(name, currentNodeId), Selectors.makeSelectNodeFormSubmitted);
-const getAllData = createSelector(selectGlobal, mapData);
-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
-const reduxContext = createContext(null);
-const useDispatch = createDispatchHook(reduxContext);
-const useSelector = createSelectorHook(reduxContext);
-const useStore = createStoreHook(reduxContext);
-const store = ({ enableDevtool }) => configureStore({
-    reducer: reducerFlower,
-    devTools: enableDevtool ? { name: 'flower' } : false
+const { selectGlobal, selectGlobalData } = FlowerCoreStateSelectors;
+const selectFlower = (name) => createSelector(selectGlobal, FlowerCoreStateSelectors.selectFlower(name));
+const selectFlowerData = selectGlobalData;
+const selectFlowerDataNode = (name) => createSelector(selectFlowerData, (data) => {
+    return data[name];
 });
-class FlowerProvider extends PureComponent {
-    constructor(props) {
-        super(props);
-        this.store = store({ enableDevtool: props.enableReduxDevtool });
-    }
-    render() {
-        const { children } = this.props;
-        return (React.createElement(Provider$1, { context: reduxContext, store: this.store }, children));
-    }
-}
+const selectFlowerHistory = (name) => createSelector(selectFlower(name), FlowerCoreStateSelectors.selectFlowerHistory);
+const makeSelectNodesIds = (name) => createSelector(selectFlower(name), FlowerCoreStateSelectors.makeSelectNodesIds);
+const makeSelectStartNodeId = (name) => createSelector(selectFlower(name), FlowerCoreStateSelectors.makeSelectStartNodeId);
+const makeSelectCurrentNodeId = (name) => createSelector(selectFlower(name), makeSelectStartNodeId(name), FlowerCoreStateSelectors.makeSelectCurrentNodeId);
+const makeSelectIsCurrentNode = (name) => createSelector(selectFlower(name), makeSelectCurrentNodeId(name), (flower, current) => flower.nodes[current]);
+const makeSelectPrevNodeRetain = (name) => createSelector(makeSelectNodesIds(name), selectFlowerHistory(name), makeSelectCurrentNodeId(name), FlowerCoreStateSelectors.makeSelectPrevNodeRetain);
+const makeSelectCurrentNodeDisabled = (name) => createSelector(makeSelectNodesIds(name), makeSelectCurrentNodeId(name), FlowerCoreStateSelectors.makeSelectCurrentNodeDisabled);
+// dati nel flow selezionato
+const makeSelectData = (name) => createSelector(selectFlowerDataNode(name), (data) => data?.data ?? {});
+createSelector(selectGlobalData, FlowerStateUtils.getAllData);
 
-/* eslint-disable no-undef */
-/* eslint-disable no-underscore-dangle */
-/**
- * FlowerClient
- */
-const FlowerClient = ({ children, name, destroyOnUnmount = true, startId = null, initialData = {}, initialState = {} }) => {
-    const flowName = name;
-    const dispatch = useDispatch();
-    const one = useRef(false);
-    const [wsDevtools, setWsDevtools] = useState(devtoolState && _get(devtoolState, '__FLOWER_DEVTOOLS_INITIALIZED__', false));
-    // TODO rivedere il giro, potremmo fare le trasformazioni in CoreUtils.generateNodesForFlowerJson
-    // eslint-disable-next-line react-hooks/exhaustive-deps, max-len
-    const nodes = useMemo(() => convertElements(Children.toArray(children)), [children]);
-    const nodeById = useMemo(() => _keyBy(Children.toArray(children), 'props.id'), [children]);
-    const isInitialized = useSelector(makeSelectStartNodeId(name));
-    const history = useSelector(selectFlowerHistory(name));
-    const current = useSelector(makeSelectCurrentNodeId(flowName));
-    const isDisabled = useSelector(makeSelectCurrentNodeDisabled(flowName));
-    const prevFlowerNodeId = useSelector(makeSelectPrevNodeRetain(flowName));
-    const store = useStore();
+const useInitNodes = ({ one, nodes, name, startId, persist = false, initialData, initialState = {} }) => {
+    const { dispatch } = ReduxFlowerProvider.getReduxHooks();
     useEffect(() => {
         if (nodes.length > 0 && one.current === false) {
             one.current = true;
-            dispatch(actions.initNodes({
-                name: flowName,
-                // @ts-expect-error FIX ME
+            dispatch(flowerActions.initNodes({
+                name,
                 nodes,
                 startId: startId ?? '',
-                persist: destroyOnUnmount === false,
-                initialData,
+                persist,
                 initialState
             }));
         }
-    }, [
-        dispatch,
-        flowName,
-        nodes,
-        startId,
-        initialData,
-        destroyOnUnmount,
-        initialState
-    ]);
+        if (initialData) {
+            dispatch(flowerDataActions.initData({
+                rootName: name,
+                initialData: initialData ?? {}
+            }));
+        }
+    }, [dispatch, name, nodes, startId, initialData, initialState, persist]);
+};
+
+const useInitDevtools = ({ devtoolState, setWsDevtools, flowName, }) => {
+    const { dispatch } = ReduxFlowerProvider.getReduxHooks();
     useEffect(() => {
         /* istanbul ignore next */
         const eventCb = (msg) => {
@@ -127,14 +108,14 @@ const FlowerClient = ({ children, name, destroyOnUnmount = true, startId = null,
                 setWsDevtools(true);
             }
             if (msg.action === 'SELECTED_NODE' && msg.name === flowName) {
-                dispatch(actions.setCurrentNode({ name: msg.name, node: msg.id }));
-            }
-            if (msg.action === 'REPLACE_DATA' && msg.name === flowName) {
-                dispatch(actions.replaceData({ flowName: msg.name, value: msg.data }));
-            }
-            if (msg.action === 'ADD_DATA' && msg.name === flowName) {
-                dispatch(actions.addData({ flowName: msg.name, value: msg.data }));
+                dispatch(flowerActions.setCurrentNode({ name: msg.name, node: msg.id }));
             }
+            // if (msg.action === 'REPLACE_DATA' && msg.name === flowName) {
+            //   dispatch(actions.replaceData({ flowName: msg.name, value: msg.data }))
+            // }
+            // if (msg.action === 'ADD_DATA' && msg.name === flowName) {
+            //   dispatch(actions.addData({ flowName: msg.name, value: msg.data }))
+            // }
         };
         /* istanbul ignore next */
         if (devtoolState && _get(devtoolState, '__FLOWER_DEVTOOLS__')) {
@@ -147,13 +128,22 @@ const FlowerClient = ({ children, name, destroyOnUnmount = true, startId = null,
             }
         };
     }, [dispatch, flowName]);
+};
+
+const useDestroyFlow = ({ flowName, one, persist }) => {
+    const { dispatch } = ReduxFlowerProvider.getReduxHooks();
     useEffect(() => () => {
-        // unmount function
-        if (destroyOnUnmount && one.current === true) {
+        if (persist)
+            return;
+        if (one.current === true) {
             one.current = false;
-            dispatch(actions.destroy({ name: flowName }));
+            dispatch(flowerActions.destroy({ name: flowName }));
         }
-    }, [dispatch, flowName, destroyOnUnmount]);
+    }, [dispatch, flowName, persist]);
+};
+
+const useClientInitEvent = ({ flowName, isInitialized, wsDevtools }) => {
+    const { store } = ReduxFlowerProvider.getReduxHooks();
     useEffect(() => {
         /* istanbul ignore next */
         if (isInitialized &&
@@ -169,7 +159,11 @@ const FlowerClient = ({ children, name, destroyOnUnmount = true, startId = null,
                 getState: store.getState
             });
         }
-    }, [dispatch, flowName, wsDevtools, isInitialized, store]);
+    }, [flowName, wsDevtools, isInitialized, store]);
+};
+const useSetHistoryEvent = ({ flowName, isInitialized, wsDevtools }) => {
+    const { useSelector } = ReduxFlowerProvider.getReduxHooks();
+    const history = useSelector(selectFlowerHistory(flowName));
     useEffect(() => {
         /* istanbul ignore next */
         if (isInitialized &&
@@ -183,7 +177,9 @@ const FlowerClient = ({ children, name, destroyOnUnmount = true, startId = null,
                 history
             });
         }
-    }, [dispatch, flowName, history, wsDevtools, isInitialized]);
+    }, [flowName, history, wsDevtools, isInitialized]);
+};
+const useSetCurrentEvent = ({ current, flowName, isInitialized, wsDevtools }) => {
     useEffect(() => {
         if (!current)
             return;
@@ -203,6 +199,9 @@ const FlowerClient = ({ children, name, destroyOnUnmount = true, startId = null,
             });
         }
     }, [flowName, current, wsDevtools, isInitialized]);
+};
+const useFlowerNavigateEvent = ({ current, flowName, isInitialized, wsDevtools, isDisabled }) => {
+    const { dispatch } = ReduxFlowerProvider.getReduxHooks();
     useEffect(() => {
         if (!current)
             return;
@@ -210,7 +209,7 @@ const FlowerClient = ({ children, name, destroyOnUnmount = true, startId = null,
         if (!isInitialized)
             return;
         if (isDisabled) {
-            dispatch({ type: 'flower/next', payload: { flowName, disabled: true } });
+            dispatch({ type: `${REDUCER_NAME.FLOWER_FLOW}/next`, payload: { flowName, disabled: true } });
             // eslint-disable-next-line no-underscore-dangle, no-undef
             /* istanbul ignore next */
             if (wsDevtools &&
@@ -242,43 +241,72 @@ const FlowerClient = ({ children, name, destroyOnUnmount = true, startId = null,
                 time: new Date()
             });
         }
-    }, [
-        dispatch,
-        flowName,
+    }, [dispatch, flowName, current, isDisabled, wsDevtools, isInitialized]);
+};
+
+const useSelectorsClient = (flowName) => {
+    const { useSelector } = ReduxFlowerProvider.getReduxHooks();
+    const isInitialized = useSelector(makeSelectStartNodeId(flowName));
+    const current = useSelector(makeSelectCurrentNodeId(flowName));
+    const isDisabled = useSelector(makeSelectCurrentNodeDisabled(flowName));
+    const prevFlowerNodeId = useSelector(makeSelectPrevNodeRetain(flowName));
+    return {
+        isInitialized,
         current,
         isDisabled,
-        store,
-        wsDevtools,
-        isInitialized
-    ]);
+        prevFlowerNodeId
+    };
+};
+
+/*
+ * FlowerClient
+ */
+const FlowerClient = ({ children, name, destroyOnUnmount = true, persist = false, startId = null, initialState = {}, initialData }) => {
+    const flowName = name;
+    const _persist = persist || !destroyOnUnmount;
+    const one = useRef(false);
+    const [wsDevtools, setWsDevtools] = useState(devtoolState && _get(devtoolState, '__FLOWER_DEVTOOLS_INITIALIZED__', false));
+    const nodes = useMemo(() => generateNodesForFlowerJson(Children.toArray(children)), [children]);
+    const nodeById = useMemo(() => _keyBy(Children.toArray(children), 'props.id'), [children]);
+    const { current, isDisabled, isInitialized, prevFlowerNodeId } = useSelectorsClient(flowName);
+    useInitNodes({
+        name,
+        nodes,
+        one,
+        initialData,
+        initialState,
+        persist: _persist,
+        startId
+    });
+    useDestroyFlow({ flowName, one, persist: _persist });
+    useInitDevtools({ devtoolState, setWsDevtools, flowName });
+    useClientInitEvent({ flowName, isInitialized, wsDevtools });
+    useSetHistoryEvent({ flowName, isInitialized, wsDevtools });
+    useSetCurrentEvent({ current, flowName, isInitialized, wsDevtools });
+    useFlowerNavigateEvent({
+        current,
+        flowName,
+        isDisabled,
+        isInitialized,
+        wsDevtools
+    });
     const currentNodeId = prevFlowerNodeId || current;
     const contextValues = useMemo(() => ({
-        flowName,
-        initialData,
+        name: flowName,
         currentNode: current
-    }), [flowName, initialData, current]);
+    }), [flowName, current]);
     const prevContextValues = useMemo(() => ({
-        flowName,
-        initialData,
+        name: flowName,
         currentNode: currentNodeId
-    }), [flowName, initialData, currentNodeId]);
+    }), [flowName, currentNodeId]);
     return isInitialized ? (React.createElement(React.Fragment, null,
-        React.createElement(Provider, { value: prevContextValues }, nodeById[currentNodeId]),
-        React.createElement(Provider, { value: contextValues }, !isDisabled && current !== currentNodeId && nodeById[current]))) : null;
-};
-const component$c = memo(FlowerClient);
-
-const FlowerNode = ({ children, onEnter, onExit }) => {
-    useEffect(() => {
-        onEnter?.();
-        return () => {
-            onExit?.();
-        };
-    }, [onEnter, onExit]);
-    return children;
+        React.createElement(FlowerReactProvider, { value: prevContextValues }, nodeById[currentNodeId]),
+        React.createElement(FlowerReactProvider, { value: contextValues }, !isDisabled && current !== currentNodeId && nodeById[current]))) : null;
 };
-const component$b = memo(FlowerNode);
-component$b.displayName = 'FlowerNode';
+const component$8 = memo(FlowerClient);
+component$8.displayName = 'Flower';
+// workaround for let typescript read JSX component as a valid JSX element using react 19(?)
+const Flower = component$8;
 
 const FlowAction = ({ children, onEnter, onExit }) => {
     useEffect(() => {
@@ -287,400 +315,39 @@ const FlowAction = ({ children, onEnter, onExit }) => {
             onExit?.();
         };
     }, [onEnter, onExit]);
-    return children;
+    return React.createElement(React.Fragment, null, children);
 };
-const component$a = React.memo(FlowAction);
-component$a.displayName = 'FlowerAction';
+const component$7 = React.memo(FlowAction);
+component$7.displayName = 'FlowerAction';
+const FlowerAction = component$7;
 
-const FlowerServer = ({ children }) => {
-    return children;
-};
-const component$9 = React.memo(FlowerServer);
-component$9.displayName = 'FlowerServer';
+const _FlowerComponent = ({ children }) => children;
+memo(_FlowerComponent);
 
-const FlowerFlow = ({ children, onEnter, onExit }) => {
+const _FlowerFlow = ({ children, onEnter, onExit }) => {
     useEffect(() => {
         onEnter?.();
         return () => {
             onExit?.();
         };
     }, [onEnter, onExit]);
-    return children;
-};
-const component$8 = React.memo(FlowerFlow);
-component$8.displayName = 'FlowerFlow';
-
-function FlowerStart() {
-    const dispatch = useDispatch();
-    const one = useRef(false);
-    const { flowName, autostart = true, currentNode } = useContext(context);
-    const startNodeId = useSelector(makeSelectStartNodeId(flowName ?? ''));
-    useEffect(() => {
-        if (startNodeId === currentNode && autostart && one.current === false) {
-            one.current = true;
-            dispatch({ type: 'flower/next', payload: { flowName, isStart: true } });
-            // if (global.window
-            //   // eslint-disable-next-line no-underscore-dangle, no-undef
-            //   && global.window.__FLOWER_DEVTOOLS__ && global.window.__FLOWER_DEVTOOLS__AUTO) {
-            //   Emitter.emit('flower-devtool-from-client', {
-            //     source: 'flower-client',
-            //     action: 'START_FLOWER',
-            //     name: flowName,
-            //   });
-            // }
-        }
-    }, [dispatch, autostart, startNodeId, currentNode, flowName]);
-    return null;
-}
-const component$7 = React.memo(FlowerStart);
-component$7.displayName = 'FlowerStart';
-
-const FlowerRoute = ({ autostart = true, children, onEnter, onExit }) => {
-    const dispatch = useDispatch();
-    const one = useRef(false);
-    const { flowName } = useContext(context);
-    useEffect(() => {
-        onEnter?.();
-        return () => {
-            onExit?.();
-        };
-    }, [onEnter, onExit]);
-    useEffect(() => {
-        if (autostart && one.current === false) {
-            one.current = true;
-            dispatch({ type: 'flower/next', payload: { flowName } });
-        }
-    }, [dispatch, flowName, autostart]);
-    return children;
-};
-const component$6 = React.memo(FlowerRoute);
-component$6.displayName = 'FlowerRoute';
-
-const FlowerRule = ({ children, rules, value, alwaysDisplay, flowName, id, onUpdate }) => {
-    const { flowName: flowNameContext, currentNode } = useContext(context);
-    const name = flowName || flowNameContext;
-    const keys = MatchRules.utils.getKeys(rules, { prefix: name });
-    const hidden = useSelector(selectorRulesDisabled(id ?? '', rules, keys ?? [], name ?? '', value, currentNode ?? ''));
-    useEffect(() => {
-        if (onUpdate) {
-            onUpdate(hidden);
-        }
-    }, [hidden, onUpdate]);
-    if (typeof children === 'function') {
-        if (alwaysDisplay && hidden) {
-            return children({ hidden });
-        }
-        if (hidden) {
-            return undefined;
-        }
-        return children({});
-    }
-    if (alwaysDisplay && hidden) {
-        return React.Children.map(children, (child, i) => {
-            if (React.isValidElement(child)) {
-                const { props, type } = child;
-                const Component = type;
-                // eslint-disable-next-line react/jsx-props-no-spreading
-                return Component && React.createElement(Component, { key: i, hidden: true, ...props });
-            }
-            return child;
-        });
-    }
-    return hidden
-        ? undefined
-        : React.Children.map(children, (child, i) => {
-            if (React.isValidElement(child)) {
-                const { props, type } = child;
-                const Component = type;
-                // eslint-disable-next-line react/jsx-props-no-spreading
-                return Component && React.createElement(Component, { key: i, ...props });
-            }
-            return child;
-        });
+    return React.createElement(React.Fragment, null, children);
 };
-const component$5 = React.memo(FlowerRule);
-component$5.displayName = 'FlowerRule';
-
-/* eslint-disable */
-function isIntrinsicElement$1(x) {
-    return typeof x === 'string';
-}
-//TODO make types for wrapper function props
-function Wrapper$1({ Component, id, flowName, currentNode, validate, asyncDebounce = 0, asyncValidate, asyncInitialError, asyncWaitingError, destroyValue, destroyOnHide, onBlur, onFocus, hidden, onUpdate, defaultValue, ...props }) {
-    const dispatch = useDispatch();
-    const [customAsyncErrors, setCustomAsyncErrors] = useState(asyncValidate && asyncInitialError && [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 focused = useSelector(makeSelectNodeFieldFocused(flowName, currentNode, id));
-    const refValue = useRef();
-    const isSubmitted = useSelector(makeSelectNodeFormSubmitted(flowName, currentNode));
-    const allErrors = useMemo(() => hidden ? [] : [...errors, ...(customAsyncErrors || []).filter(Boolean)], [errors, hidden, customAsyncErrors]);
-    const setTouched = useCallback((touched) => {
-        dispatch({
-            type: 'flower/formFieldTouch',
-            payload: {
-                name: flowName,
-                id,
-                currentNode,
-                touched
-            }
-        });
-    }, [dispatch, flowName, currentNode, id]);
-    const setFocus = useCallback((focused) => {
-        dispatch({
-            type: 'flower/formFieldFocus',
-            payload: {
-                name: flowName,
-                id,
-                currentNode,
-                focused
-            }
-        });
-    }, [dispatch, flowName, currentNode, id]);
-    const validateFn = useCallback(async (value) => {
-        if (asyncWaitingError) {
-            setCustomAsyncErrors([asyncWaitingError]);
-        }
-        setIsValidating(true);
-        const state = FlowerStateUtils.getAllData(store);
-        const res = await asyncValidate(value, state, errors);
-        setIsValidating(false);
-        setCustomAsyncErrors(res);
-    }, [asyncWaitingError, errors]);
-    const debouncedValidation = useCallback(debounce(validateFn, asyncDebounce), [
-        validateFn
-    ]);
-    const onChange = useCallback((val) => {
-        if (asyncValidate && asyncWaitingError) {
-            setCustomAsyncErrors([asyncWaitingError]);
-        }
-        dispatch({
-            type: `flower/addDataByPath`,
-            payload: {
-                flowName: flowNameFromPath,
-                id,
-                value: val,
-                dirty: defaultValue ? !isEqual(val, defaultValue) : true
-            }
-        });
-    }, [flowNameFromPath, id, dispatch, setCustomAsyncErrors, asyncValidate, asyncWaitingError]);
-    const onBlurInternal = useCallback((e) => {
-        setTouched(true);
-        setFocus(false);
-        onBlur && onBlur(e);
-    }, [onBlur, setTouched, setFocus]);
-    const onFocusInternal = useCallback((e) => {
-        setFocus(true);
-        onFocus && onFocus(e);
-    }, [onFocus, setFocus]);
-    useEffect(() => {
-        if (hidden)
-            return;
-        if (asyncValidate) {
-            if (refValue.current === value)
-                return;
-            refValue.current = value;
-            const hasValue = !MatchRules.utils.isEmpty(value);
-            if (!hasValue) {
-                setCustomAsyncErrors(asyncInitialError && [asyncInitialError]);
-                setIsValidating(false);
-                return;
-            }
-            setTouched(true);
-            debouncedValidation(value);
-        }
-    }, [asyncValidate, asyncInitialError, value, debouncedValidation, setTouched, hidden]);
-    useEffect(() => {
-        if (onUpdate) {
-            onUpdate(value);
-        }
-    }, [value, onUpdate]);
-    useEffect(() => {
-        dispatch({
-            type: 'flower/formAddErrors',
-            payload: {
-                name: flowName,
-                id,
-                currentNode,
-                errors: allErrors
-            }
-        });
-    }, [id, flowName, allErrors, currentNode, touched]);
-    useEffect(() => {
-        dispatch({
-            type: 'flower/setFormIsValidating',
-            payload: {
-                name: flowName,
-                currentNode,
-                isValidating
-            }
-        });
-    }, [flowName, currentNode, isValidating]);
-    const resetField = useCallback(() => {
-        dispatch({
-            type: 'flower/formFieldTouch',
-            payload: {
-                name: flowName,
-                id,
-                currentNode,
-                touched: false
-            }
-        });
-        dispatch({
-            type: 'flower/formFieldDirty',
-            payload: {
-                name: flowName,
-                id,
-                currentNode,
-                dirty: false
-            }
-        });
-        dispatch({
-            type: 'flower/formRemoveErrors',
-            payload: {
-                name: flowName,
-                id,
-                currentNode
-            }
-        });
-    }, [currentNode, id, flowName]);
-    useEffect(() => {
-        // destroy
-        return () => {
-            if (destroyValue) {
-                dispatch({
-                    type: `flower/unsetData`,
-                    payload: { flowName: flowNameFromPath, id: path }
-                });
-            }
-            resetField();
-        };
-    }, [destroyValue, id, flowNameFromPath, path, resetField]);
-    useEffect(() => {
-        if (hidden) {
-            if (destroyOnHide) {
-                dispatch({
-                    type: `flower/unsetData`,
-                    payload: { flowName: flowNameFromPath, id: path }
-                });
-                resetField();
-            }
-        }
-    }, [destroyOnHide, hidden, flowNameFromPath, path, resetField]);
-    useEffect(() => {
-        if (defaultValue && !dirty && !isEqual(value, defaultValue)) {
-            onChange(defaultValue);
-        }
-    }, [defaultValue, value, dirty, onChange]);
-    const newProps = useMemo(() => ({
-        ...props,
-        id,
-        value,
-        errors: allErrors,
-        hasError: !!allErrors.length,
-        onChange,
-        onBlur: onBlurInternal,
-        onFocus: onFocusInternal,
-        focused: !!focused,
-        touched,
-        dirty,
-        hidden,
-        isValidating,
-        isSubmitted,
-    }), [
-        props,
-        id,
-        value,
-        allErrors,
-        touched,
-        dirty,
-        onChange,
-        onBlurInternal,
-        onFocusInternal,
-        hidden,
-        isValidating,
-        isSubmitted,
-        focused
-    ]);
-    if (typeof Component === 'function') {
-        return Component(newProps);
-    }
-    // TODO si arriva in questa condizione quando si passa un componente primitivo es. div
-    // in questo caso non posso props custom di flower
-    if (isIntrinsicElement$1(Component)) {
-        return React.createElement(Component, { id: id, ...props });
-    }
-    return Component && React.createElement(Component, { ...newProps });
-}
-const FlowerField = ({ id, validate, asyncValidate, asyncDebounce, asyncInitialError, asyncWaitingError, rules, alwaysDisplay, value, children, defaultValue, destroyOnHide, destroyValue, flowName, onUpdate }) => {
-    const { flowName: flowNameContext, currentNode } = useContext(context);
-    const name = flowName || flowNameContext;
-    if (typeof children === 'function') {
-        return (React.createElement(component$5, { alwaysDisplay: alwaysDisplay, rules: rules, value: value, flowName: name, id: id }, ({ hidden }) => (React.createElement(Wrapper$1, { hidden: hidden, id: id, Component: children, flowName: name, currentNode: currentNode, validate: validate, asyncValidate: asyncValidate, asyncDebounce: asyncDebounce, asyncInitialError: asyncInitialError, asyncWaitingError: asyncWaitingError, destroyValue: destroyValue, onUpdate: onUpdate, defaultValue: defaultValue, destroyOnHide: destroyOnHide }))));
-    }
-    return React.Children.map(children, (child, i) => {
-        if (!React.isValidElement(child)) {
-            return child;
-        }
-        const { type, props } = child;
-        const Component = type;
-        return (React.createElement(component$5, { key: i, alwaysDisplay: alwaysDisplay, rules: rules, value: value, flowName: name }, ({ hidden }) => (React.createElement(Wrapper$1, { ...props, hidden: hidden, id: id, Component: Component, flowName: name, currentNode: currentNode, validate: validate, asyncValidate: asyncValidate, asyncDebounce: asyncDebounce, asyncInitialError: asyncInitialError, asyncWaitingError: asyncWaitingError, destroyValue: destroyValue, onUpdate: onUpdate, defaultValue: defaultValue }))));
-    });
-};
-const component$4 = React.memo(FlowerField);
-component$4.displayName = 'FlowerField';
-
-/* eslint-disable */
-//TODO make types for wrapper function
-function Wrapper({ Component, id, flowName, spreadValue, hidden, onUpdate, ...props }) {
-    const { flowNameFromPath = flowName, path } = useMemo(() => CoreUtils.getPath(id), [id]);
-    const value = useSelector(getDataFromState(flowNameFromPath, path));
-    const values = spreadValue && typeof value === 'object' && !Array.isArray(value)
-        ? value
-        : { value };
-    useEffect(() => {
-        if (onUpdate) {
-            onUpdate(value);
-        }
-    }, [onUpdate, value]);
-    return (React.createElement(Component, { id: id, ...props, flowName: flowName, hidden: hidden, ...values }));
-}
-const RenderRules$1 = ({ id, alwaysDisplay, rules, value, Component, spreadValue, flowName, onUpdate, ...props }) => {
-    return (React.createElement(component$5, { alwaysDisplay: alwaysDisplay, rules: rules, value: value, flowName: flowName, id: id }, ({ hidden }) => (React.createElement(Wrapper, { ...props, hidden: hidden, id: id, Component: Component, spreadValue: spreadValue, flowName: flowName, onUpdate: onUpdate }))));
-};
-const FlowerValue = ({ id = '*', rules, alwaysDisplay, value, children, spreadValue, flowName, onUpdate, }) => {
-    const { flowName: flowNameContext } = useContext(context);
-    const name = flowName || flowNameContext;
-    if (typeof children === 'function') {
-        return (React.createElement(RenderRules$1, { id: id, alwaysDisplay: alwaysDisplay, rules: rules, value: value, spreadValue: spreadValue, Component: children, flowName: name, onUpdate: onUpdate }));
-    }
-    return React.Children.map(children, (child, i) => {
-        if (!React.isValidElement(child))
-            return child;
-        const { type, props } = child;
-        const Component = type;
-        // eslint-disable-next-line react/jsx-props-no-spreading
-        return (React.createElement(RenderRules$1, { key: i, id: id, alwaysDisplay: alwaysDisplay, rules: rules, value: value, spreadValue: spreadValue, flowName: name, Component: Component, ...props, onUpdate: onUpdate }));
-    });
-};
-const component$3 = React.memo(FlowerValue);
-component$3.displayName = 'FlowerValue';
+const component$6 = React.memo(_FlowerFlow);
+component$6.displayName = 'FlowerFlow';
+const FlowerFlow = component$6;
 
 const ACTION_TYPES = {
-    back: ['prev', 'prevToNode'],
+    back: ['back', 'prevToNode'],
     jump: ['node', 'node'],
     next: ['next', 'next'],
     restart: ['restart', 'restart'],
     reset: ['reset', 'initializeFromNode']
 };
-const PAYLAOAD_KEYS_NEEDED = {
+const PAYLOAD_KEYS_NEEDED = {
     back: ['node'],
     jump: ['node', 'history'],
-    next: ['node', 'route', 'data'],
+    next: ['node', 'route', 'data', 'dataIn'],
     restart: ['node'],
     reset: ['node', 'initialData']
 };
@@ -696,11 +363,49 @@ const makeActionPayload = (actions, keys) => (flowName, params) => {
         payload
     };
 };
-const makeActionPayloadOnPrev = makeActionPayload(ACTION_TYPES.back, PAYLAOAD_KEYS_NEEDED.back);
-const makeActionPayloadOnReset = makeActionPayload(ACTION_TYPES.reset, PAYLAOAD_KEYS_NEEDED.reset);
-const makeActionPayloadOnNode = makeActionPayload(ACTION_TYPES.jump, PAYLAOAD_KEYS_NEEDED.jump);
-const makeActionPayloadOnNext = makeActionPayload(ACTION_TYPES.next, PAYLAOAD_KEYS_NEEDED.next);
-const makeActionPayloadOnRestart = makeActionPayload(ACTION_TYPES.restart, PAYLAOAD_KEYS_NEEDED.restart);
+const makeActionPayloadOnBack = makeActionPayload(ACTION_TYPES.back, PAYLOAD_KEYS_NEEDED.back);
+const makeActionPayloadOnReset = makeActionPayload(ACTION_TYPES.reset, PAYLOAD_KEYS_NEEDED.reset);
+const makeActionPayloadOnNode = makeActionPayload(ACTION_TYPES.jump, PAYLOAD_KEYS_NEEDED.jump);
+const makeActionPayloadOnNext = makeActionPayload(ACTION_TYPES.next, PAYLOAD_KEYS_NEEDED.next);
+const makeActionPayloadOnRestart = makeActionPayload(ACTION_TYPES.restart, PAYLOAD_KEYS_NEEDED.restart);
+const handleHistoryStackChange = (currentIndex, currentNode, flowName, withUrl) => {
+    const historyNode = `/${flowName}/${currentNode.nodeId}`;
+    if (currentNode.nodeType === 'FlowerAction')
+        return currentIndex;
+    const nextIndex = currentIndex + 1;
+    if (history.state?.index !== nextIndex) {
+        window.history.pushState({
+            index: nextIndex,
+            stack: [...(window.history.state.stack ?? []), historyNode]
+        }, '', withUrl ? historyNode : '');
+    }
+    return nextIndex;
+};
+
+const useHistorySync = ({ backAction, nextAction }) => {
+    const { dispatch } = ReduxFlowerProvider.getReduxHooks();
+    const { index, isActive, setIndex, withUrl } = useHistoryContext();
+    useEffect(() => {
+        if (!isActive)
+            return;
+        const initialIndex = window.history.state?.index ?? 0;
+        setIndex(initialIndex);
+        window.history.replaceState({ index: initialIndex, stack: [...(window.history.state?.stack ?? [])] }, withUrl ? '/' : '', '');
+        const onPopState = (event) => {
+            const newIndex = window.history.state?.index ?? 0;
+            if (newIndex > index) {
+                nextAction();
+            }
+            if (newIndex < index) {
+                backAction();
+            }
+            setIndex(newIndex);
+        };
+        window.addEventListener('popstate', onPopState);
+        return () => window.removeEventListener('popstate', onPopState);
+    }, [dispatch, backAction, nextAction]);
+};
+
 /** This hook allows you to read flow informations, such as the flowName and ID of the current node.
  *
  * It also exposes all the functions to navigate within the flow:
@@ -720,12 +425,19 @@ const makeActionPayloadOnRestart = makeActionPayload(ACTION_TYPES.restart, PAYLA
  * @param {string} name - optional parameter, if flowName exist, name is not used
  */
 const useFlower = ({ flowName: customFlowName, name } = {}) => {
-    const dispatch = useDispatch();
-    const { flowName: flowNameDefault, initialData } = useContext(context);
-    const store = useStore();
+    const { name: flowNameDefault, initialData } = useContext(FlowerReactContext);
+    const { index, isActive, setIndex, withUrl } = useHistoryContext();
+    const { store, dispatch, useSelector } = ReduxFlowerProvider.getReduxHooks();
     const flowName = (customFlowName || name || flowNameDefault);
     const nodeId = useSelector(makeSelectCurrentNodeId(flowName ?? ''));
+    const currentNode = useSelector(makeSelectIsCurrentNode(flowName ?? ''));
     const startId = useSelector(makeSelectStartNodeId(flowName ?? ''));
+    useEffect(() => {
+        if (currentNode.nodeType === 'FlowerAction')
+            return;
+        window.history.replaceState({ ...window.history.state }, '', withUrl ? `/${flowName}/${nodeId}` : '');
+    }, [nodeId, flowName, withUrl, currentNode]);
+    const stack = useMemo(() => window.history.state?.stack?.map((path) => path.split('/')[1]), [window.history.state?.stack]);
     const emitNavigateEvent = useCallback(
     //TODO check this function is needed
     (params) => {
@@ -743,42 +455,61 @@ const useFlower = ({ flowName: customFlowName, name } = {}) => {
         }
     }, [flowName, nodeId]);
     const next = useCallback((param) => {
-        const params = typeof param === 'string' ? { route: param } : { data: param };
+        const params = typeof param === 'string' ? { route: param } : { dataIn: param };
         const { type, payload } = makeActionPayloadOnNext(flowName, params);
         dispatch({
-            type: `flower/${type}`,
-            payload
+            type: `${REDUCER_NAME.FLOWER_FLOW}/${type}`,
+            payload: { ...payload, data: store.getState() }
         });
+        if (isActive) {
+            setIndex(handleHistoryStackChange(index, currentNode, flowName, withUrl));
+        }
         emitNavigateEvent({ type, payload });
-    }, [dispatch, emitNavigateEvent, flowName]);
+    }, [dispatch, emitNavigateEvent, flowName, store]);
+    /**
+     * By doing this, we have a full control over flower navigation from both our buttons and browser back and forward navigation
+     * In order to trigger back correctly, trigger a real history back
+     * If you use replaceState({ index: 2 }) while at index 3,
+     * you visually move to step 2, but the browser still sees you at step 3.
+     * As a result:
+     *  - The browser's Forward button stays disabled
+     *  - No popstate event is triggered
+     *  - The history flow is broken
+     * Use history.back() instead to preserve proper browser navigation.
+     */
+    const interceptBack = () => {
+        window.history.back();
+    };
     const back = useCallback((param) => {
-        const { type, payload } = makeActionPayloadOnPrev(flowName, param);
-        dispatch({ type: `flower/${type}`, payload });
+        const { type, payload } = makeActionPayloadOnBack(isActive ? (stack?.[stack?.length - 1] ?? flowName) : flowName, param);
+        dispatch({
+            type: `${REDUCER_NAME.FLOWER_FLOW}/${type}`,
+            payload
+        });
+        setIndex(index - 1);
         emitNavigateEvent({ type, payload });
-    }, [dispatch, emitNavigateEvent, flowName]);
+    }, [dispatch, emitNavigateEvent, flowName, stack]);
+    useHistorySync({ backAction: back, nextAction: next });
     const restart = useCallback((param) => {
         const { type, payload } = makeActionPayloadOnRestart(flowName, param);
-        dispatch({ type: `flower/${type}`, payload });
+        dispatch({ type: `${REDUCER_NAME.FLOWER_FLOW}/${type}`, payload });
         emitNavigateEvent({ type, payload });
     }, [dispatch, emitNavigateEvent, flowName]);
     const reset = useCallback((param) => {
         const { type, payload } = makeActionPayloadOnReset(flowName, typeof param === 'string'
             ? { node: param, initialData }
-            : {
-                ...param,
-                initialData
-            });
-        dispatch({ type: `flower/${type}`, payload });
+            : { ...param, initialData });
+        dispatch({ type: `${REDUCER_NAME.FLOWER_FLOW}/${type}`, payload });
         emitNavigateEvent({ type, payload });
     }, [dispatch, emitNavigateEvent, flowName, initialData]);
     const jump = useCallback((param) => {
         const { type, payload } = makeActionPayloadOnNode(flowName, param);
-        dispatch({ type: `flower/${type}`, payload });
+        dispatch({ type: `${REDUCER_NAME.FLOWER_FLOW}/${type}`, payload });
         emitNavigateEvent({ type, payload });
     }, [dispatch, emitNavigateEvent, flowName]);
     const getCurrentNodeId = useCallback((customFlowName) => {
         return _get(store.getState(), [
-            'flower',
+            REDUCER_NAME.FLOWER_FLOW,
             customFlowName || flowName,
             'current'
         ]);
@@ -790,7 +521,7 @@ const useFlower = ({ flowName: customFlowName, name } = {}) => {
         startId,
         next,
         jump,
-        back,
+        back: isActive ? interceptBack : back,
         reset,
         restart
     };
@@ -819,7 +550,7 @@ const useFlower = ({ flowName: customFlowName, name } = {}) => {
 //     }
 // );
 const useFlowerNavigate = ({ flowName, action, route, node }) => {
-    const { flowName: flowNameContext } = useContext(context);
+    const { name: flowNameContext } = useContext(FlowerReactContext);
     const name = flowName || flowNameContext;
     const { next, jump, back, reset, restart } = useFlower({ flowName: name });
     const onNavigate = useCallback(() => {
@@ -855,7 +586,7 @@ function isIntrinsicElement(x) {
     return typeof x === 'string';
 }
 //TODO type FlowerNavigateWrapper props
-function FlowerNavigateWrapper({ hidden, Component, onNavigate, ...props }) {
+function _FlowerNavigateWrapper({ hidden, Component, onNavigate, ...props }) {
     const newProps = useMemo(() => ({
         ...props,
         hidden,
@@ -874,136 +605,160 @@ function FlowerNavigateWrapper({ hidden, Component, onNavigate, ...props }) {
     /* istanbul ignore next */
     return Component && React.createElement(Component, { ...newProps });
 }
-const component$2 = React.memo(FlowerNavigateWrapper);
+const component$5 = React.memo(_FlowerNavigateWrapper);
+const FlowerNavigateWrapper = component$5;
 
 /* eslint-disable */
 //TODO type RenderRules props
+// ! Probably in this scenario we must replace `FlowerRule` or refactor `FlowerNavigate`
 const RenderRules = ({ alwaysDisplay, rules, Component, flowName, onNavigate, ...props }) => {
-    return (React.createElement(component$5, { alwaysDisplay: alwaysDisplay, rules: rules, flowName: flowName }, ({ hidden }) => React.createElement(component$2, { ...props, Component: Component, hidden: hidden, onNavigate: onNavigate })));
+    return (React.createElement(FlowerRule, { alwaysDisplay: alwaysDisplay, rules: rules, rootName: flowName }, ({ hidden }) => (React.createElement(FlowerNavigateWrapper, { ...props, Component: Component, hidden: hidden, onNavigate: onNavigate }))));
 };
-const FlowerNavigate = ({ children, flowName: forceFlowName, action, route, node, rules, alwaysDisplay, }) => {
-    const { onNavigate, flowName } = useFlowerNavigate({ flowName: forceFlowName, action, route, node });
+const _FlowerNavigate = ({ children, flowName: forceFlowName, action, route, node, rules, alwaysDisplay }) => {
+    const { onNavigate, flowName } = useFlowerNavigate({
+        flowName: forceFlowName,
+        action,
+        route,
+        node
+    });
     if (typeof children === 'function') {
-        return React.createElement(RenderRules, { alwaysDisplay: alwaysDisplay, rules: rules, Component: children, flowName: flowName, onNavigate: onNavigate });
+        return (React.createElement(RenderRules, { alwaysDisplay: alwaysDisplay, rules: rules, Component: children, flowName: flowName, onNavigate: onNavigate }));
     }
-    return React.Children.map(children, (child, i) => {
+    return (React.createElement(React.Fragment, null, React.Children.map(children, (child, i) => {
         if (!React.isValidElement(child))
             return child;
         const { type, props } = child;
         const Component = type;
-        // eslint-disable-next-line react/jsx-props-no-spreading
-        return React.createElement(RenderRules, { key: i, alwaysDisplay: alwaysDisplay, rules: rules, Component: Component, flowName: flowName, onNavigate: onNavigate, ...props });
-    });
+        return (React.createElement(RenderRules, { key: i, alwaysDisplay: alwaysDisplay, rules: rules, Component: Component, flowName: flowName, onNavigate: onNavigate, ...props }));
+    })));
 };
-const component$1 = React.memo(FlowerNavigate);
-component$1.displayName = 'FlowerNavigate';
+const component$4 = React.memo(_FlowerNavigate);
+component$4.displayName = 'FlowerNavigate';
+const FlowerNavigate = component$4;
 
-const FlowerComponent = ({ children }) => children;
-const component = memo(FlowerComponent);
+const _FlowerNode = ({ children, onEnter, onExit }) => {
+    useEffect(() => {
+        onEnter?.();
+        return () => {
+            onExit?.();
+        };
+    }, [onEnter, onExit]);
+    return React.createElement(React.Fragment, null, children);
+};
+const component$3 = memo(_FlowerNode);
+component$3.displayName = 'FlowerNode';
+const FlowerNode = component$3;
 
-/**  This hook allows you to manage and retrieve information about Forms.
- *
- * It exposes details regarding the form's state and a set of methods for reading and writing within it:
- *
- * - isSubmitted,
- * - isDirty,
- * - errors,
- * - customErrors,
- * - isValid,
- * - isValidating,
- * - getData,
- * - setData,
- * - unsetData,
- * - replaceData,
- * - reset,
- * - setCustomErrors
- * - getFormStatus
- *
- * @param {string} flowName - first optional parameter
- *
- * @param {string} name - alias optional parameter, if flowName exist, name is not used
+const _FlowerRoute = ({ autostart = true, children, onEnter, onExit }) => {
+    const { dispatch } = ReduxFlowerProvider.getReduxHooks();
+    const one = useRef(false);
+    const { name } = useContext(FlowerReactContext);
+    useEffect(() => {
+        onEnter?.();
+        return () => {
+            onExit?.();
+        };
+    }, [onEnter, onExit]);
+    useEffect(() => {
+        if (autostart && one.current === false) {
+            one.current = true;
+            dispatch(flowerActions.next({ flowName: name }));
+        }
+    }, [dispatch, name, autostart]);
+    return React.createElement(React.Fragment, null, children);
+};
+const component$2 = React.memo(_FlowerRoute);
+component$2.displayName = 'FlowerRoute';
+const FlowerRoute = component$2;
+
+const _FlowerServer = ({ children }) => {
+    return React.createElement(React.Fragment, null, children);
+};
+const component$1 = React.memo(_FlowerServer);
+component$1.displayName = 'FlowerServer';
+const FlowerServer = component$1;
+
+function _FlowerStart() {
+    const { dispatch, useSelector } = ReduxFlowerProvider.getReduxHooks();
+    const one = useRef(false);
+    const { name, autostart = true, currentNode } = useContext(FlowerReactContext);
+    const startNodeId = useSelector(makeSelectStartNodeId(name ?? ''));
+    useEffect(() => {
+        if (startNodeId === currentNode && autostart && one.current === false) {
+            one.current = true;
+            dispatch(flowerActions.next({ flowName: name, isStart: true }));
+            // if (global.window
+            //   // eslint-disable-next-line no-underscore-dangle, no-undef
+            //   && global.window.__FLOWER_DEVTOOLS__ && global.window.__FLOWER_DEVTOOLS__AUTO) {
+            //   Emitter.emit('flower-devtool-from-client', {
+            //     source: 'flower-client',
+            //     action: 'START_FLOWER',
+            //     name: flowName,
+            //   });
+            // }
+        }
+    }, [dispatch, autostart, startNodeId, currentNode, name]);
+    return null;
+}
+const component = React.memo(_FlowerStart);
+component.displayName = 'FlowerStart';
+const FlowerStart = component;
+
+const FlowerProvider = ({ children, enableReduxDevtool, configureStore }) => {
+    const { reducer, ...rest } = configureStore ?? {
+        devTools: enableReduxDevtool
+    };
+    return (React.createElement(ReduxFlowerProvider, { configureStore: {
+            reducer: { ...reducerFlower, ...(reducer ?? {}) },
+            ...rest,
+            devTools: enableReduxDevtool ?? rest?.devTools
+        } }, children));
+};
+
+/**
  *
+ * @param {ConfigureStoreOptions} configureStore object to configure store - same structure as redux configureStore options
+ * @param {MiddlewareList} middlewaresBlacklist list of flower middlewares to blacklist
+ * @returns {Store} redux store instance
  */
-const useFlowerForm = ({ flowName: customFlowName, name } = {}) => {
-    const { flowName: flowNameDefault } = useContext(context);
-    const dispatch = useDispatch();
-    const store = useStore();
-    const flowName = customFlowName || name || flowNameDefault || '';
-    const currentNode = useSelector(makeSelectCurrentNodeId(flowName));
-    const { errors, customErrors, isValid, isSubmitted, isDirty, hasFocus, isValidating } = useSelector(makeSelectNodeErrors(flowName, currentNode));
-    const getData = useCallback((path) => {
-        const { flowNameFromPath = flowName, path: newpath } = CoreUtils.getPath(path);
-        return _get(store.getState(), [
-            'flower',
-            flowNameFromPath,
-            'data',
-            ...newpath
-        ]);
-    }, [store, flowName]);
-    const getFormStatus = useCallback((path) => {
-        const { flowNameFromPath = flowName, path: newpath } = CoreUtils.getPath(path);
-        return _get(store.getState(), [
-            'flower',
-            flowNameFromPath,
-            'form',
-            ...newpath
-        ]);
-    }, [store, flowName]);
-    const setDataField = useCallback((id, val, dirty = true) => {
-        const { flowNameFromPath = flowName } = CoreUtils.getPath(id);
-        dispatch(actions.addDataByPath({
-            flowName: flowNameFromPath,
-            id,
-            value: val,
-            dirty
-        }));
-        return;
-    }, [flowName, dispatch]);
-    const setData = useCallback((val, id) => {
-        if (id) {
-            setDataField(id, val);
-            return;
-        }
-        dispatch(actions.addData({ flowName, value: val }));
-    }, [flowName, setDataField, dispatch]);
-    const unsetData = useCallback((path) => {
-        const { flowNameFromPath = flowName, path: newpath } = CoreUtils.getPath(path);
-        dispatch(actions.unsetData({ flowName: flowNameFromPath, id: newpath }));
-    }, [flowName, dispatch]);
-    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
-            }
+const createStoreWithFlower = (configureStore$1, middlewaresBlacklist) => {
+    if (!configureStore$1) {
+        return configureStore({
+            reducer: combineReducers({ ...reducerData, ...reducerFlower }),
+            devTools: true
         });
-    }, [flowName, currentNode, dispatch]);
-    return {
-        isSubmitted,
-        isDirty,
-        hasFocus,
-        errors,
-        customErrors,
-        isValid,
-        isValidating,
-        getData,
-        setData,
-        setDataField,
-        unsetData,
-        replaceData,
-        reset,
-        setCustomErrors,
-        getFormStatus
-    };
+    }
+    const { reducer, ...configOptions } = configureStore$1 ?? {};
+    const combinedReducers = combineReducers({
+        ...reducerData,
+        ...reducerFlower,
+        ...(reducer || {})
+    });
+    const flowerMiddlewares = middlewaresBlacklist && !!middlewaresBlacklist.length
+        ? middlewares.filter((middleware) => !middlewaresBlacklist.includes(middleware.name))
+        : middlewares;
+    return configureStore({
+        reducer: combinedReducers,
+        ...configOptions,
+        middleware: (getDefaultMiddleware) => getDefaultMiddleware().concat(...flowerMiddlewares, ...(configOptions.middleware ?? []))
+    });
+};
+
+const updateAction = (reducerName) => createAction(`${reducerName}/flowerUpdateData`);
+const createSliceWithFlower = (createSliceOptions) => {
+    const { name, reducers } = createSliceOptions;
+    updateAction(name);
+    const slice = createSlice({
+        ...createSliceOptions,
+        reducers: {
+            ...reducers,
+            flowerUpdateData: (state, { payload }) => {
+                const { path, value } = payload;
+                set(state, path, value);
+            }
+        }
+    });
+    return slice;
 };
 
-export { component$c as Flower, component$a as FlowerAction, component as FlowerComponent, context as FlowerContext, Consumer as FlowerContextConsumer, Provider as FlowerContextProvider, component$4 as FlowerField, component$8 as FlowerFlow, component$1 as FlowerNavigate, component$b as FlowerNode, FlowerProvider, component$6 as FlowerRoute, component$5 as FlowerRule, component$9 as FlowerServer, component$7 as FlowerStart, component$3 as FlowerValue, getDataByFlow, useFlower, useFlowerForm, useSelector };
+export { Flower, FlowerAction, FlowerFlow, FlowerNavigate, FlowerNode, FlowerProvider, FlowerRoute, FlowerServer, FlowerStart, createSliceWithFlower, createStoreWithFlower, flowerReducers, makeSelectData, reducerFlower, useFlower, useFlowerNavigate };