@flowerforce/flower-react 4.0.11-beta.0 → 4.0.11-beta.2

package/dist/index.esm.js

@@ -1,20 +1,46 @@
-import React, { memo, useRef, useState, useMemo, Children, useEffect, useContext, useCallback } from 'react';
+import React, { useEffect, memo, useRef, useState, useMemo, Children, useContext, useCallback, createContext } from 'react';
 import _keyBy from 'lodash/keyBy';
-import { CoreUtils, FlowerCoreBaseReducers, REDUCER_NAME, FlowerCoreStateSelectors, FlowerStateUtils, devtoolState, Emitter } from '@flowerforce/flower-core';
+import { FlowUtils, FlowerCoreBaseReducers, REDUCER_NAME, FlowerCoreStateSelectors, FlowerStateUtils, Emitter, devtoolState, isAbacInitialized, getRawRules, initAbac, getSubject, getAbacEngine } from '@flowerforce/flower-core';
 import { FlowerReactProvider, FlowerReactContext } from '@flowerforce/flower-react-context';
 import _get from 'lodash/get';
-import { createSlice, configureStore, combineReducers, createAction } 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 { 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';
 
-// 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: REDUCER_NAME.FLOWER_FLOW,
@@ -41,60 +67,37 @@ const selectFlowerHistory = (name) => createSelector(selectFlower(name), FlowerC
 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, initialState = {}, initialData }) => {
-    const flowName = name;
-    const { dispatch, store, useSelector } = ReduxFlowerProvider.getReduxHooks();
-    const one = useRef(false);
-    const [wsDevtools, setWsDevtools] = useState(devtoolState && _get(devtoolState, '__FLOWER_DEVTOOLS_INITIALIZED__', false));
-    // TODO could make that transformation in CoreUtils.generateNodesForFlowerJson
-    // eslint-disable-next-line react-hooks/exhaustive-deps, max-len
-    const nodes = useMemo(
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    () => 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 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(flowerActions.initNodes({
-                name: flowName,
-                // @ts-expect-error FIX ME
+                name,
                 nodes,
                 startId: startId ?? '',
-                persist: destroyOnUnmount === false,
+                persist,
                 initialState
             }));
-            if (initialData) {
-                dispatch(flowerDataActions.initData({
-                    rootName: flowName,
-                    initialData: initialData ?? {}
-                }));
-            }
         }
-    }, [
-        dispatch,
-        flowName,
-        nodes,
-        startId,
-        destroyOnUnmount,
-        initialState,
-        initialData
-    ]);
+        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) => {
@@ -108,12 +111,10 @@ const FlowerClient = ({ children, name, destroyOnUnmount = true, startId = null,
                 dispatch(flowerActions.setCurrentNode({ name: msg.name, node: msg.id }));
             }
             // if (msg.action === 'REPLACE_DATA' && msg.name === flowName) {
-            //   dispatch(
-            //     formActions.replaceData({ flowName: msg.name, value: msg.data })
-            //   )
+            //   dispatch(actions.replaceData({ flowName: msg.name, value: msg.data }))
             // }
             // if (msg.action === 'ADD_DATA' && msg.name === flowName) {
-            //   dispatch(formActions.addData({ flowName: msg.name, value: msg.data }))
+            //   dispatch(actions.addData({ flowName: msg.name, value: msg.data }))
             // }
         };
         /* istanbul ignore next */
@@ -127,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(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 &&
@@ -149,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 &&
@@ -163,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;
@@ -183,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;
@@ -190,7 +209,10 @@ const FlowerClient = ({ children, name, destroyOnUnmount = true, startId = null,
         if (!isInitialized)
             return;
         if (isDisabled) {
-            dispatch(flowerActions.next({ flowName }));
+            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 &&
@@ -213,7 +235,7 @@ const FlowerClient = ({ children, name, destroyOnUnmount = true, startId = null,
             devtoolState &&
             _get(devtoolState, '__FLOWER_DEVTOOLS__')) {
             if (isInitialized === current)
-                return; // salto il primo event
+                return; // salto il primo evento
             Emitter.emit('flower-devtool-from-client', {
                 source: 'flower-client',
                 action: 'SET_SELECTED',
@@ -222,15 +244,55 @@ 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,
+        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,
-        store,
-        wsDevtools,
-        isInitialized
-    ]);
+        isInitialized,
+        wsDevtools
+    });
     const currentNodeId = prevFlowerNodeId || current;
     const contextValues = useMemo(() => ({
         name: flowName,
@@ -244,10 +306,10 @@ const FlowerClient = ({ children, name, destroyOnUnmount = true, startId = null,
         React.createElement(FlowerReactProvider, { value: prevContextValues }, nodeById[currentNodeId]),
         React.createElement(FlowerReactProvider, { value: contextValues }, !isDisabled && current !== currentNodeId && nodeById[current]))) : null;
 };
-const component$9 = memo(FlowerClient);
-component$9.displayName = 'Flower';
+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$9;
+const Flower = component$8;
 
 const FlowAction = ({ children, onEnter, onExit }) => {
     useEffect(() => {
@@ -258,13 +320,12 @@ const FlowAction = ({ children, onEnter, onExit }) => {
     }, [onEnter, onExit]);
     return React.createElement(React.Fragment, null, children);
 };
-const component$8 = React.memo(FlowAction);
-component$8.displayName = 'FlowerAction';
-const FlowerAction = component$8;
+const component$7 = React.memo(FlowAction);
+component$7.displayName = 'FlowerAction';
+const FlowerAction = component$7;
 
 const _FlowerComponent = ({ children }) => children;
-const component$7 = memo(_FlowerComponent);
-const FlowerComponent = component$7;
+memo(_FlowerComponent);
 
 const _FlowerFlow = ({ children, onEnter, onExit }) => {
     useEffect(() => {
@@ -310,6 +371,43 @@ const makeActionPayloadOnReset = makeActionPayload(ACTION_TYPES.reset, PAYLOAD_K
 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.
  *
@@ -331,10 +429,18 @@ const makeActionPayloadOnRestart = makeActionPayload(ACTION_TYPES.restart, PAYLO
  */
 const useFlower = ({ flowName: customFlowName, name } = {}) => {
     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) => {
@@ -356,18 +462,37 @@ const useFlower = ({ flowName: customFlowName, name } = {}) => {
         const { type, payload } = makeActionPayloadOnNext(flowName, params);
         dispatch({
             type: `${REDUCER_NAME.FLOWER_FLOW}/${type}`,
-            payload: {
-                ...payload,
-                data: store.getState()
-            }
+            payload: { ...payload, data: store.getState() }
         });
+        if (isActive) {
+            setIndex(handleHistoryStackChange(index, currentNode, flowName, withUrl));
+        }
         emitNavigateEvent({ type, payload });
     }, [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 } = makeActionPayloadOnBack(flowName, param);
-        dispatch({ type: `${REDUCER_NAME.FLOWER_FLOW}/${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: `${REDUCER_NAME.FLOWER_FLOW}/${type}`, payload });
@@ -376,10 +501,7 @@ const useFlower = ({ flowName: customFlowName, name } = {}) => {
     const reset = useCallback((param) => {
         const { type, payload } = makeActionPayloadOnReset(flowName, typeof param === 'string'
             ? { node: param, initialData }
-            : {
-                ...param,
-                initialData
-            });
+            : { ...param, initialData });
         dispatch({ type: `${REDUCER_NAME.FLOWER_FLOW}/${type}`, payload });
         emitNavigateEvent({ type, payload });
     }, [dispatch, emitNavigateEvent, flowName, initialData]);
@@ -402,7 +524,7 @@ const useFlower = ({ flowName: customFlowName, name } = {}) => {
         startId,
         next,
         jump,
-        back,
+        back: isActive ? interceptBack : back,
         reset,
         restart
     };
@@ -642,4 +764,73 @@ const createSliceWithFlower = (createSliceOptions) => {
     return slice;
 };
 
-export { Flower, FlowerAction, FlowerComponent, FlowerFlow, FlowerNavigate, FlowerNode, FlowerProvider, FlowerRoute, FlowerServer, FlowerStart, createSliceWithFlower, createStoreWithFlower, flowerReducers, makeSelectData, reducerFlower, useFlower, useFlowerNavigate };
+const AbacContext = createContext({
+    can: () => false,
+    allowedActions: () => [],
+    loaded: false,
+    rawRules: null
+});
+const AbacProvider = ({ children, rules, rulesPath, fetchOptions, denyByDefault = true }) => {
+    const [loaded, setLoaded] = useState(isAbacInitialized());
+    const [localRawRules, setLocalRawRules] = useState(getRawRules());
+    useEffect(() => {
+        if (rules) {
+            initAbac(rules);
+            setLocalRawRules(rules);
+            setLoaded(true);
+            return;
+        }
+        if (!rulesPath) {
+            setLoaded(false);
+            setLocalRawRules(null);
+            return;
+        }
+        let mounted = true;
+        const init = async () => {
+            try {
+                const res = await fetch(rulesPath, fetchOptions);
+                if (!res.ok)
+                    throw new Error(`HTTP ${res.status}`);
+                const json = (await res.json());
+                if (!mounted)
+                    return;
+                initAbac(json);
+                setLocalRawRules(json);
+                setLoaded(true);
+            }
+            catch (err) {
+                console.error('ABAC: failed to load rules from', rulesPath, err);
+                setLocalRawRules(null);
+                setLoaded(false);
+            }
+        };
+        init();
+        return () => {
+            mounted = false;
+        };
+    }, [rules, rulesPath, fetchOptions]);
+    const can = useCallback((ctx) => {
+        if (!isAbacInitialized())
+            return !denyByDefault;
+        const subject = getSubject();
+        return (getAbacEngine()?.decide({ subject: subject ?? {}, ...ctx }) === 'Permit');
+    }, []);
+    const allowedActions = useCallback((resource, actions = ['read', 'create', 'update', 'delete']) => {
+        if (!isAbacInitialized())
+            return denyByDefault ? [] : actions.slice();
+        const subject = getSubject();
+        return getAbacEngine()?.allowedActions({ subject: subject ?? {}, resource, environment: undefined }, actions);
+    }, []);
+    const value = useMemo(() => ({
+        can,
+        allowedActions,
+        loaded,
+        rawRules: localRawRules
+    }), [loaded, localRawRules]);
+    return React.createElement(AbacContext.Provider, { value: value }, children);
+};
+function useAbac() {
+    return useContext(AbacContext);
+}
+
+export { AbacProvider, Flower, FlowerAction, FlowerFlow, FlowerNavigate, FlowerNode, FlowerProvider, FlowerRoute, FlowerServer, FlowerStart, createSliceWithFlower, createStoreWithFlower, flowerReducers, makeSelectData, reducerFlower, useAbac, useFlower, useFlowerNavigate };

package/dist/src/abacProvider/abacProvider.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+import { RuleInput, AbacCtx, Resource, Action } from '@flowerforce/flower-core';
+type AbacProviderProps = {
+    children: React.ReactNode;
+    rules?: RuleInput[];
+    rulesPath?: string;
+    fetchOptions?: RequestInit;
+    denyByDefault?: boolean;
+};
+type AbacContextValue = {
+    can: (args: Omit<AbacCtx, 'subject'>) => boolean;
+    allowedActions: (resource: Resource | undefined, actions?: Action[]) => Action[] | undefined;
+    loaded: boolean;
+    rawRules?: RuleInput[] | null;
+};
+export declare const AbacProvider: React.FC<AbacProviderProps>;
+export declare function useAbac(): AbacContextValue;
+export {};

package/dist/src/abacProvider/index.d.ts

@@ -0,0 +1 @@
+export * from './abacProvider';

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

@@ -1,15 +1,3 @@
-import React, { PropsWithChildren } from 'react';
-type FlowerInitialState = {
-    startId?: string;
-    current?: string;
-    history?: string[];
-};
-type FlowerClientProps = PropsWithChildren<{
-    name: string;
-    destroyOnUnmount?: boolean;
-    startId?: string | null;
-    initialState?: FlowerInitialState;
-    initialData?: Record<string, unknown>;
-}>;
-export declare const Flower: ({ children, name, destroyOnUnmount, startId, initialState, initialData }: FlowerClientProps) => React.JSX.Element | null;
-export {};
+import React from 'react';
+import { FlowerClientProps } from '../types/Flower';
+export declare const Flower: ({ children, name, destroyOnUnmount, persist, startId, initialState, initialData }: FlowerClientProps) => React.JSX.Element | null;

package/dist/src/components/hooks/eventsHandlers.d.ts

@@ -0,0 +1,5 @@
+import { UseClientInitEventProps, UseFlowerNavigateEventProps, UseSetCurrentEventProps, UseSetHistoryEventProps } from './types';
+export declare const useClientInitEvent: ({ flowName, isInitialized, wsDevtools }: UseClientInitEventProps) => void;
+export declare const useSetHistoryEvent: ({ flowName, isInitialized, wsDevtools }: UseSetHistoryEventProps) => void;
+export declare const useSetCurrentEvent: ({ current, flowName, isInitialized, wsDevtools }: UseSetCurrentEventProps) => void;
+export declare const useFlowerNavigateEvent: ({ current, flowName, isInitialized, wsDevtools, isDisabled }: UseFlowerNavigateEventProps) => void;

package/dist/src/components/hooks/index.d.ts

@@ -0,0 +1,5 @@
+export * from './useInitNodes';
+export * from './useInitDevtools';
+export * from './useDestroyFlow';
+export * from './eventsHandlers';
+export * from './useSelectorsClient';

package/dist/src/components/hooks/types/index.d.ts

@@ -0,0 +1,29 @@
+import { NodeConfig } from '@flowerforce/flower-core';
+import { FlowerClientProps } from '../../../types/Flower';
+import { MutableRefObject } from 'react';
+export type UseClientInitEventProps = {
+    isInitialized: string;
+    wsDevtools: boolean;
+    flowName: string;
+};
+export type UseSetHistoryEventProps = UseClientInitEventProps;
+export type UseSetCurrentEventProps = UseClientInitEventProps & {
+    current: string;
+};
+export type UseFlowerNavigateEventProps = UseSetCurrentEventProps & {
+    isDisabled: boolean;
+};
+export type UseDestroyFlowProps = {
+    one: MutableRefObject<boolean>;
+    persist: boolean;
+    flowName: string;
+};
+export type UseInitDevtoolsProps = {
+    devtoolState: Object;
+    flowName: string;
+    setWsDevtools: (value: boolean) => void;
+};
+export type UseInitNodesProps = {
+    one: MutableRefObject<boolean>;
+    nodes: NodeConfig[];
+} & Omit<FlowerClientProps, 'destroyOnUnmount'>;

package/dist/src/components/hooks/useBrowserNavigationSync.d.ts

@@ -0,0 +1,12 @@
+import { useFlowerActions } from '../../types';
+/**
+ * Hook centralizzato per sincronizzare la navigazione browser con Redux
+ * @param {function} backAction - Azione Redux da chiamare quando si fa "indietro"
+ * @param {function} nextAction - Azione Redux da chiamare quando si fa "avanti"
+ */
+type UseHistorySyncProps = {
+    backAction: () => ReturnType<useFlowerActions['back']>;
+    nextAction: () => ReturnType<useFlowerActions['next']>;
+};
+export declare const useHistorySync: ({ backAction, nextAction }: UseHistorySyncProps) => void;
+export {};

package/dist/src/components/hooks/useDestroyFlow.d.ts

@@ -0,0 +1,2 @@
+import { UseDestroyFlowProps } from './types';
+export declare const useDestroyFlow: ({ flowName, one, persist }: UseDestroyFlowProps) => void;

package/dist/src/components/hooks/useInitDevtools.d.ts

@@ -0,0 +1,2 @@
+import { UseInitDevtoolsProps } from './types';
+export declare const useInitDevtools: ({ devtoolState, setWsDevtools, flowName }: UseInitDevtoolsProps) => void;

package/dist/src/components/hooks/useInitNodes.d.ts

@@ -0,0 +1,2 @@
+import { UseInitNodesProps } from './types';
+export declare const useInitNodes: ({ one, nodes, name, startId, persist, initialData, initialState }: UseInitNodesProps) => void;

package/dist/src/components/hooks/useSelectorsClient.d.ts

@@ -0,0 +1,6 @@
+export declare const useSelectorsClient: (flowName: string) => {
+    isInitialized: string;
+    current: string;
+    isDisabled: boolean;
+    prevFlowerNodeId: string | undefined;
+};

package/dist/src/components/useFlower/utils.d.ts

@@ -1,3 +1,4 @@
+import { INode } from '@flowerforce/flower-core';
 export declare const makeActionPayloadOnBack: (flowName: string | undefined, params: any) => {
     type: string;
     payload: Record<string, any>;
@@ -18,3 +19,4 @@ export declare const makeActionPayloadOnRestart: (flowName: string | undefined,
     type: string;
     payload: Record<string, any>;
 };
+export declare const handleHistoryStackChange: (currentIndex: number, currentNode: INode, flowName: string, withUrl?: boolean) => number;