@flowerforce/flower-react 3.0.0

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

@@ -0,0 +1,9 @@
+import React, { PropsWithChildren } from 'react';
+type FlowerClientProps = PropsWithChildren & {
+    name: string;
+    destroyOnUnmount?: boolean;
+    startId?: string | null;
+    initialData?: any;
+};
+declare const component: React.MemoExoticComponent<({ children, name, destroyOnUnmount, startId, initialData }: FlowerClientProps) => React.JSX.Element | null>;
+export default component;

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

@@ -0,0 +1,4 @@
+import React from 'react';
+import { FlowerNodeDefaultProps } from './types/DefaultNode';
+declare const component: React.MemoExoticComponent<({ children, onEnter, onExit }: FlowerNodeDefaultProps) => React.ReactNode>;
+export default component;

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

@@ -0,0 +1,4 @@
+import React from 'react';
+import { FlowerComponentProps } from './types/FlowerComponent';
+declare const component: React.MemoExoticComponent<({ children }: FlowerComponentProps) => React.ReactNode>;
+export default component;

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

@@ -0,0 +1,4 @@
+import React from 'react';
+import { FlowerFieldProps } from './types/FlowerField';
+declare const component: React.MemoExoticComponent<({ id, validate, asyncValidate, asyncDebounce, asyncInitialError, asyncWaitingError, rules, alwaysDisplay, value, children, defaultValue, destroyValue, flowName, onUpdate }: FlowerFieldProps<any>) => React.JSX.Element | (string | number | Iterable<React.ReactNode> | React.JSX.Element)[] | null | undefined>;
+export default component;

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

@@ -0,0 +1,4 @@
+import React from 'react';
+import { FlowerFlowProps } from './types/FlowerFlow';
+declare const component: React.MemoExoticComponent<({ children, onEnter, onExit }: FlowerFlowProps) => React.ReactNode>;
+export default component;

package/dist/src/components/FlowerNavigate/WrapperComponent.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+declare function FlowerNavigateWrapper({ hidden, Component, onNavigate, ...props }: any): any;
+declare const component: React.MemoExoticComponent<typeof FlowerNavigateWrapper>;
+export default component;

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

@@ -0,0 +1,4 @@
+import React from 'react';
+import { FlowerNavigateProps } from '../types/FlowerNavigate';
+declare const component: React.MemoExoticComponent<({ children, flowName: forceFlowName, action, route, node, rules, alwaysDisplay, }: FlowerNavigateProps) => React.JSX.Element | (string | number | Iterable<React.ReactNode> | React.JSX.Element)[] | null | undefined>;
+export default component;

package/dist/src/components/FlowerNavigate/useFlowerNavigate.d.ts

@@ -0,0 +1,7 @@
+import { FlowerNavigateProps } from '../types/FlowerNavigate';
+type UseFlowerNavigateProps = Pick<FlowerNavigateProps, 'flowName' | 'node' | 'route' | 'action'>;
+export declare const useFlowerNavigate: ({ flowName, action, route, node }: UseFlowerNavigateProps) => {
+    onNavigate: () => void;
+    flowName: string | undefined;
+};
+export {};

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

@@ -0,0 +1,4 @@
+import React from 'react';
+import { FlowerNodeProps } from './types/FlowerNode';
+declare const component: React.MemoExoticComponent<({ children, onEnter, onExit }: FlowerNodeProps) => React.ReactNode>;
+export default component;

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

@@ -0,0 +1,4 @@
+import React from 'react';
+import { FlowerRouteProps } from './types/FlowerRoute';
+declare const component: React.MemoExoticComponent<({ autostart, children, onEnter, onExit }: FlowerRouteProps) => React.ReactNode>;
+export default component;

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

@@ -0,0 +1,4 @@
+import React from 'react';
+import { FlowerRuleProps } from './types/FlowerRule';
+declare const component: React.MemoExoticComponent<({ children, rules, value, alwaysDisplay, flowName, id, onUpdate }: FlowerRuleProps) => string | number | boolean | React.ReactElement<any, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | (string | number | Iterable<React.ReactNode> | React.JSX.Element)[] | null | undefined>;
+export default component;

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

@@ -0,0 +1,4 @@
+import React from 'react';
+import { FlowerServerProps } from './types/FlowerServer';
+declare const component: React.MemoExoticComponent<({ children }: FlowerServerProps) => React.ReactNode>;
+export default component;

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

@@ -0,0 +1,4 @@
+import React from 'react';
+declare function FlowerStart(): null;
+declare const component: React.MemoExoticComponent<typeof FlowerStart>;
+export default component;

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

@@ -0,0 +1,4 @@
+import React from 'react';
+import { FlowerValueProps } from './types/FlowerValue';
+declare const component: React.MemoExoticComponent<({ id, rules, alwaysDisplay, value, children, spreadValue, flowName, onUpdate, }: FlowerValueProps) => React.JSX.Element | (string | number | React.JSX.Element | Iterable<React.ReactNode>)[] | null | undefined>;
+export default component;

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

@@ -0,0 +1,8 @@
+export type FlowerNodeDefaultProps = {
+    id: string;
+    to?: Record<string, any>;
+    children?: React.ReactNode;
+    onEnter?: () => void;
+    onExit?: () => void;
+    disabled?: boolean;
+};

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

@@ -0,0 +1,4 @@
+export type FlowerComponentProps = {
+    name: string;
+    children: React.ReactNode;
+};

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

@@ -0,0 +1,30 @@
+import { RulesObject } from '@flowerforce/flower-core';
+export type FlowerFieldProps<T extends Record<string, any>> = {
+    id?: string;
+    children: React.ReactNode | ((props: {
+        id: string;
+        value: any;
+        errors: undefined | string[];
+        hasError: undefined | boolean;
+        onChange: (props: any) => void;
+        onBlur: () => void;
+        isTouched: boolean;
+        hidden: boolean;
+        isValidating: boolean | undefined;
+    }) => React.ReactNode | React.ReactElement | undefined);
+    validate?: Record<string, any>[] | string[];
+    asyncValidate?: (value: any, data?: Record<string, any>, errors?: undefined | string[]) => string[] | undefined | Promise<string[]> | {
+        message: string;
+    }[] | boolean | Promise<boolean>;
+    asyncDebounce?: number;
+    asyncInitialError?: string;
+    asyncWaitingError?: string;
+    rules?: RulesObject<T>;
+    flowName?: string;
+    defaultValue?: unknown;
+    destroyValue?: boolean;
+    value?: any;
+    alwaysDisplay?: boolean;
+    onUpdate?: (value: any) => void;
+    onBlur?: (e: any) => void;
+};

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

@@ -0,0 +1,4 @@
+import { FlowerNodeDefaultProps } from './DefaultNode';
+export type FlowerFlowProps = FlowerNodeDefaultProps & {
+    retain?: boolean;
+};

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

@@ -0,0 +1,26 @@
+import { Route, RouteNode, RoutePrev, RouteReset } from './FlowerNavigate';
+export type UseFlowerProps = {
+    [x in 'name' | 'flowName']?: string;
+};
+export type UseFlowerForm = (options?: UseFlowerProps) => {
+    touched: boolean;
+    errors: Record<string, any>;
+    isValid: boolean;
+    isValidating: boolean | undefined;
+    getData: (path?: string) => any;
+    setData: (value: any, path?: string) => void;
+    unsetData: (path: string) => void;
+    replaceData: (value: any) => void;
+};
+type useFlowerActions = {
+    next: (payload?: Route) => void;
+    back: (payload?: RoutePrev) => void;
+    reset: (payload?: RouteReset) => void;
+    jump: (payload: RouteNode) => void;
+};
+export type UseFlower = (options?: UseFlowerProps) => useFlowerActions & {
+    flowName?: string;
+    nodeId: string;
+};
+export type NavigateFunctionParams = string | Record<string, any>;
+export {};

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

@@ -0,0 +1,37 @@
+import { RulesObject } from '@flowerforce/flower-core';
+export type Route = string | Record<string, any>;
+export type RouteNode = string | {
+    node: string;
+    flowName?: string;
+    history?: string[];
+};
+export type RouteReset = string | {
+    node: string;
+    flowName?: string;
+};
+export type RoutePrev = string | {
+    node: string;
+    flowName?: string;
+};
+export type FlowerNavigateProps = {
+    flowName?: string | undefined;
+    children: React.ReactNode | ((props: Record<string, any>) => React.ReactNode | React.ReactElement | undefined);
+    rules?: RulesObject<Record<string, any>> | Record<string, RulesObject<any>>;
+    alwaysDisplay?: boolean;
+} & ({
+    action?: 'next';
+    node?: undefined;
+    route?: Route;
+} | {
+    action?: 'back';
+    node?: RoutePrev;
+    route?: undefined;
+} | {
+    action?: 'reset';
+    node?: RouteReset;
+    route?: undefined;
+} | {
+    action?: 'jump';
+    node?: RouteNode;
+    route?: undefined;
+});

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

@@ -0,0 +1,4 @@
+import { FlowerNodeDefaultProps } from './DefaultNode';
+export type FlowerNodeProps = FlowerNodeDefaultProps & {
+    retain?: boolean;
+};

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

@@ -0,0 +1,13 @@
+import { ThunkMiddleware, Tuple, configureStore } from '@reduxjs/toolkit';
+import { Flower } from '@flowerforce/flower-core';
+import { UnknownAction } from 'redux';
+export interface FlowerProviderInterface {
+    render(): JSX.Element;
+}
+export type FlowerProviderProps = ReturnType<typeof configureStore<{
+    flower: Record<string, Flower<any>>;
+}, UnknownAction, Tuple<[
+    ThunkMiddleware<{
+        flower: Record<string, Flower<any>>;
+    }, UnknownAction>
+]>>>;

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

@@ -0,0 +1,8 @@
+export type FlowerRouteProps = {
+    id: string;
+    autostart?: boolean;
+    to?: Record<string, any>;
+    children?: React.ReactNode;
+    onEnter?: () => void;
+    onExit?: () => void;
+};

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

@@ -0,0 +1,12 @@
+import { RulesObject } from '@flowerforce/flower-core';
+export type FlowerRuleProps = {
+    id?: string;
+    value?: any;
+    rules?: RulesObject<any>;
+    flowName?: string;
+    alwaysDisplay?: boolean;
+    onUpdate?: (hidden: boolean) => void;
+    children?: React.ReactNode | ((props: {
+        hidden?: boolean;
+    }) => React.ReactNode | React.ReactElement | undefined);
+};

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

@@ -0,0 +1,7 @@
+import { FlowerNodeProps } from './FlowerNode';
+export type FlowerServerProps = {
+    action?: {
+        type: string;
+        props?: Record<string, any>;
+    };
+} & FlowerNodeProps;

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

@@ -0,0 +1,11 @@
+import { RulesObject } from '@flowerforce/flower-core';
+export type FlowerValueProps = {
+    id?: string;
+    value?: any;
+    rules?: RulesObject<any>;
+    children: React.ReactNode | ((props: Record<string, any>) => React.ReactNode | React.ReactElement | undefined);
+    spreadValue?: boolean;
+    flowName?: string;
+    alwaysDisplay?: boolean;
+    onUpdate?: (value: any) => void;
+};

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

@@ -0,0 +1,3 @@
+import { UseFlower } from './types/FlowerHooks';
+declare const useFlower: UseFlower;
+export default useFlower;

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

@@ -0,0 +1,3 @@
+import { UseFlowerForm } from './types/FlowerHooks';
+declare const useFlowerForm: UseFlowerForm;
+export default useFlowerForm;

package/dist/src/context.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+export type FlowerContext = {
+    flowName?: string | undefined;
+    currentNode?: string | undefined;
+    autostart?: boolean | undefined;
+};
+export declare const context: React.Context<FlowerContext>;
+export declare const Provider: React.Provider<FlowerContext>;
+export declare const Consumer: React.Consumer<FlowerContext>;

package/dist/src/index.d.ts

@@ -0,0 +1,20 @@
+export { Consumer as FlowerContextConsumer } from './context';
+export { Provider as FlowerContextProvider } from './context';
+export { context as FlowerContext } from './context';
+export { default as Flower } from './components/Flower';
+export { default as FlowerNode } from './components/FlowerNode';
+export { default as FlowerAction } from './components/FlowerAction';
+export { default as FlowerServer } from './components/FlowerServer';
+export { default as FlowerFlow } from './components/FlowerFlow';
+export { default as FlowerStart } from './components/FlowerStart';
+export { default as FlowerRoute } from './components/FlowerRoute';
+export { default as FlowerRule } from './components/FlowerRule';
+export { default as FlowerField } from './components/FlowerField';
+export { default as FlowerValue } from './components/FlowerValue';
+export { default as FlowerNavigate } from './components/FlowerNavigate';
+export { default as FlowerComponent } from './components/FlowerComponent';
+export { default as useFlower } from './components/useFlower';
+export { default as useFlowerForm } from './components/useFlowerForm';
+export { default as FlowerProvider } from './provider';
+export { getDataByFlow } from './selectors';
+export { useSelector } from './provider';

package/dist/src/provider.d.ts

@@ -0,0 +1,19 @@
+import React, { PropsWithChildren, Component } from 'react';
+import { Action } from '@reduxjs/toolkit';
+import { FlowerProviderProps } from './components/types/FlowerProvider';
+export declare const useDispatch: import("react-redux").UseDispatch<import("redux").Dispatch<Action>>;
+export declare const useSelector: import("react-redux").UseSelector<unknown>;
+export declare const useStore: import("react-redux").UseStore<import("redux").Store<any, Action, {}>>;
+export declare const store: import("@reduxjs/toolkit").EnhancedStore<{
+    flower: Record<string, import("packages/flower-core/dist/src").Flower<Record<string, any>>>;
+}, import("redux").UnknownAction, import("@reduxjs/toolkit").Tuple<[import("redux").StoreEnhancer<{
+    dispatch: import("redux-thunk").ThunkDispatch<{
+        flower: Record<string, import("packages/flower-core/dist/src").Flower<Record<string, any>>>;
+    }, undefined, import("redux").UnknownAction>;
+}>, import("redux").StoreEnhancer]>>;
+declare class FlowerProvider extends Component<PropsWithChildren, FlowerProviderProps> {
+    private store;
+    constructor(props: PropsWithChildren);
+    render(): React.JSX.Element;
+}
+export default FlowerProvider;

package/dist/src/reducer.d.ts

@@ -0,0 +1,7 @@
+import { Flower } from '@flowerforce/flower-core';
+declare const flowerReducer: import("@reduxjs/toolkit").Slice<Record<string, Flower<Record<string, any>>>, import("@flowerforce/flower-core").ReducersFunctions, "flower", "flower", import("@reduxjs/toolkit").SliceSelectors<Record<string, Flower<Record<string, any>>>>>;
+export declare const actions: import("@reduxjs/toolkit").CaseReducerActions<import("@flowerforce/flower-core").ReducersFunctions, "flower">;
+export declare const reducerFlower: {
+    flower: import("redux").Reducer<Record<string, Flower<Record<string, any>>>>;
+};
+export default flowerReducer;