@flowerforce/flower-core 3.3.1-beta.2 → 4.0.1-beta.1

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

@@ -0,0 +1,5 @@
+export declare enum REDUCER_NAME {
+    FLOWER_FLOW = "FlowerFlow",
+    FLOWER_DATA = "FlowerData"
+}
+export declare const devtoolState: {};

package/dist/src/event-emitter/index.d.ts

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

package/dist/src/index.d.ts

@@ -1,8 +1,6 @@
-export { Emitter } from './Emitter';
-export { FlowerCoreReducers } from './FlowerCoreStateFunctions';
-export { FlowerStateUtils } from './FlowerCoreStateUtils';
-export { FlowerCoreStateSelectors as Selectors } from './FlowerCoreStateSelectors';
-export { CoreUtils } from './CoreUtils';
-export { MatchRules } from './RulesMatcher';
-export { devtoolState } from './devtoolState';
-export * from './interfaces';
+export * from './event-emitter';
+export * from './constants';
+export * from './utils';
+export * from './rules-matcher';
+export * from './state-manager';
+export type * from './interfaces';

package/dist/src/interfaces/CoreInterface.d.ts

@@ -47,6 +47,8 @@ export declare enum RulesModes {
     $or = "$or"
 }
 type RulesValuesType<T> = {
+    '$data.isValid'?: boolean;
+    /** @deprecated use $data.isValid instead */
     '$form.isValid'?: boolean;
 } & T;
 type RulesOperatorsInArray<T> = Partial<{
@@ -74,7 +76,7 @@ export type RulesObject<T> = RulesValuesType<T> | {
 export type CleanPath = (name: string, char?: string) => string;
 export type GetPath = (idValue?: string) => {
     path: string | string[];
-    flowNameFromPath?: string;
+    rootName?: string;
 };
 export type AllEqual = (...args: Array<number | string | boolean>[]) => boolean;
 export type FindValidRule<T = Rules<RulesObject<any>>> = (nextRules: {
@@ -112,7 +114,7 @@ export type MapKeysDeepLodash = (obj: Record<string, any>, cb: (...args: any) =>
 export type GenerateRulesName = (nextRules: RulesWithName[]) => {
     [X: string]: string;
 };
-export interface CoreUtilitiesFunctions {
+export interface FlowUtilitiesFunctions {
     /**
      *
      * Generates rule names from a set of rules.
@@ -181,21 +183,6 @@ export interface CoreUtilitiesFunctions {
      * @returns
      */
     generateNodesForFlowerJson: GenerateNodesForFlowerJson;
-    /**
-     * Removes specified characters from the beginning of a string (default char -> '^').
-     * @param name
-     * @param char
-     *
-     * @returns
-     */
-    cleanPath: CleanPath;
-    /**
-     * Creates a valid path from idValue
-     * @param idValue
-     *
-     * @returns
-     */
-    getPath: GetPath;
     /**
      * Checks if two arrays are equal in length and have the same elements.
      * @param arr
@@ -214,4 +201,23 @@ export interface CoreUtilitiesFunctions {
      */
     findValidRule: FindValidRule;
 }
+export interface DataUtilitiesFunctions {
+    /**
+     * Removes specified characters from the beginning of a string (default char -> '^').
+     * @param name
+     * @param char
+     *
+     * @returns
+     */
+    cleanPath: CleanPath;
+    /**
+     * Creates a valid path from idValue
+     * @param idValue
+     *
+     * @returns
+     */
+    getPath: GetPath;
+}
+export interface CoreUtilitiesFunctions extends DataUtilitiesFunctions, FlowUtilitiesFunctions {
+}
 export {};

package/dist/src/interfaces/ReducerInterface.d.ts

@@ -5,11 +5,7 @@ export type ActionWithPayload<T> = {
     payload: T;
 };
 type ReducerFunctionSign<T extends object, R> = (state: Record<string, Flower<T>>, action: ActionWithPayload<R>) => Record<string, Flower<T>> | void;
-export type ActionsTypes = 'historyAdd' | 'historyPrevToNode' | 'setFormTouched' | 'forceAddHistory' | 'historyPop' | 'restoreHistory' | 'replaceNode' | 'initializeFromNode' | 'forceResetHistory' | 'destroy' | 'initNodes' | 'setCurrentNode' | 'formAddErrors' | 'formRemoveErrors' | 'addData' | 'addDataByPath' | 'replaceData' | 'unsetData' | 'setFormIsValidating' | 'resetForm' | 'formFieldTouch' | 'formFieldFocus' | 'node' | 'prevToNode' | 'next' | 'prev' | 'reset';
-/**
- * These functions are Redux reducers used in a Flux architecture for managing state transitions and updates in a Flower application.
- */
-export type ReducersFunctions<T extends Record<string, any> = Record<string, Flower<Record<string, any>>>> = {
+export type CoreReducersFunctions<T extends Record<string, any> = Record<string, Flower<Record<string, any>>>> = {
     /**
      * @param state
      * @param action
@@ -34,18 +30,6 @@ export type ReducersFunctions<T extends Record<string, any> = Record<string, Flo
         name: string;
         node: string;
     } | string>;
-    /**
-     * @param state
-     * @param action
-     *
-     * Sets the "touched" state of a form node in a flow.
-     *
-     * @returns state
-     */
-    setFormTouched: ReducerFunctionSign<T, {
-        flowName: string;
-        currentNode: string;
-    } | string>;
     /**
      * @param state
      * @param action
@@ -143,7 +127,6 @@ export type ReducersFunctions<T extends Record<string, any> = Record<string, Flo
         startId: string;
         persist: boolean;
         nodes: Node[];
-        initialData: any;
         initialState: {
             startId?: string;
             current?: string;
@@ -166,229 +149,247 @@ export type ReducersFunctions<T extends Record<string, any> = Record<string, Flo
      * @param state
      * @param action
      *
-     * Adds errors to a form node in a flow.
+     * Handles node transitions in a flow, updating history and form states accordingly.
      *
      * @returns state
      */
-    formAddCustomErrors: ReducerFunctionSign<T, {
+    node: ReducerFunctionSign<T, {
         name: string;
-        currentNode: string;
-        id: string;
-        errors: string[];
+        flowName?: string;
+        nodeId?: string;
+        node?: string;
+        history: string[];
     }>;
     /**
      * @param state
      * @param action
      *
-     * Adds errors to a form node in a flow.
+     * Navigates to a specific node in the history of a flow.
      *
      * @returns state
      */
-    formAddErrors: ReducerFunctionSign<T, {
-        name: string;
-        currentNode: string;
-        id: string;
-        errors: {
-            [x: string]: string[];
-        } | string[];
+    prevToNode: ReducerFunctionSign<T, {
+        name?: string;
+        flowName?: string;
+        node: string;
     }>;
     /**
      * @param state
      * @param action
      *
-     * Set dirty form single field
+     * Moves to the next node in a flow based on validation rules and current state.
      *
      * @returns state
      */
-    formFieldDirty: ReducerFunctionSign<T, {
-        name: string;
-        currentNode: string;
-        id: string;
-        dirty?: boolean;
+    next: ReducerFunctionSign<T, {
+        name?: string;
+        flowName?: string;
+        route?: string;
+        data?: Record<string, any>;
+        dataIn?: Record<string, any>;
+        isStart?: boolean;
     }>;
     /**
      * @param state
      * @param action
      *
-     * Set touch form single field
+     * Moves to the previous node in a flow.
      *
      * @returns state
      */
-    formFieldTouch: ReducerFunctionSign<T, {
-        name: string;
-        currentNode: string;
-        id: string;
-        touched?: boolean;
+    prev: ReducerFunctionSign<T, {
+        name?: string;
+        flowName?: string;
     }>;
     /**
      * @param state
      * @param action
      *
-     * Set touch form single field
+     * Return back to the first node and resets history.
      *
      * @returns state
      */
-    formFieldFocus: ReducerFunctionSign<T, {
-        name: string;
-        currentNode: string;
-        id: string;
-        focused?: boolean;
+    restart: ReducerFunctionSign<T, {
+        name?: string;
+        flowName?: string;
     }>;
     /**
      * @param state
      * @param action
      *
-     * Removes errors from a form node in a flow.
+     * Returns back to the first node, resets history and clean all previous data from flow.
      *
      * @returns state
      */
-    formRemoveErrors: ReducerFunctionSign<T, {
-        name: string;
-        currentNode: string;
+    reset: ReducerFunctionSign<T, {
+        name?: string;
+        flowName?: string;
+    }
+    /**
+     * @param state
+     * @param action
+     *
+     * Reset form.
+     *
+     * @returns state
+     */
+    >;
+};
+type DataReducerFunctionSign<T extends object, R = object> = (state: Record<string, T>, action: ActionWithPayload<{
+    rootName: string;
+} & R>) => Record<string, T> | void;
+export type DataReducersFunctions<T extends Record<string, any> = Record<string, Record<string, any>>> = {
+    /**
+     * @param state
+     * @param action
+     *
+     * Sets the "touched" state of a form node in a flow.
+     *
+     * @returns state
+     */
+    setFormSubmitted: DataReducerFunctionSign<T>;
+    /**
+     * @param state
+     * @param action
+     *
+     * Adds errors to a form node in a flow.
+     *
+     * @returns state
+     */
+    addCustomDataErrors: DataReducerFunctionSign<T, {
         id: string;
+        errors: string[];
     }>;
     /**
      * @param state
      * @param action
      *
-     * Adds data to a flow.
+     * Adds errors to a form node in a flow.
      *
      * @returns state
      */
-    addData: ReducerFunctionSign<T, {
-        flowName: string;
-        value: T;
+    addDataErrors: DataReducerFunctionSign<T, {
+        id: string;
+        errors: {
+            [x: string]: string[];
+        } | string[];
     }>;
     /**
      * @param state
      * @param action
      *
-     * Adds data to a flow at a specific path.
+     * Set dirty form single field
      *
      * @returns state
      */
-    addDataByPath: ReducerFunctionSign<T, {
+    fieldDirty: DataReducerFunctionSign<T, {
         id: string;
-        flowName: string;
-        value: T | string;
         dirty?: boolean;
     }>;
     /**
      * @param state
      * @param action
      *
-     * Replaces the data of a flow with new data.
+     * Set touch form single field
      *
      * @returns state
      */
-    replaceData: ReducerFunctionSign<T, {
-        flowName: string;
-        value: T;
+    fieldTouch: DataReducerFunctionSign<T, {
+        id: string;
+        touched?: boolean;
     }>;
     /**
      * @param state
      * @param action
      *
-     * Unsets data from a flow at a specific path.
+     * Set touch form single field
      *
      * @returns state
      */
-    unsetData: ReducerFunctionSign<T, {
-        id: string[] | string;
-        flowName: string;
+    fieldFocus: DataReducerFunctionSign<T, {
+        id: string;
+        focused?: boolean;
     }>;
     /**
      * @param state
      * @param action
      *
-     * Sets the "isValidating" state of a form node in a flow.
+     * Removes errors from a form node in a flow.
      *
      * @returns state
      */
-    setFormIsValidating: ReducerFunctionSign<T, {
-        name: string;
-        currentNode: string;
-        isValidating?: boolean;
+    removeDataErrors: DataReducerFunctionSign<T, {
+        id: string;
     }>;
     /**
      * @param state
      * @param action
      *
-     * Handles node transitions in a flow, updating history and form states accordingly.
+     * Adds data to a flow.
      *
      * @returns state
      */
-    node: ReducerFunctionSign<T, {
-        name: string;
-        flowName?: string;
-        nodeId?: string;
-        node?: string;
-        history: string[];
+    addData: DataReducerFunctionSign<T, {
+        value: T;
     }>;
     /**
      * @param state
      * @param action
      *
-     * Navigates to a specific node in the history of a flow.
+     * Adds data to a flow at a specific path.
      *
      * @returns state
      */
-    prevToNode: ReducerFunctionSign<T, {
-        name?: string;
-        flowName?: string;
-        node: string;
+    addDataByPath: DataReducerFunctionSign<T, {
+        id: string;
+        value: T | string;
+        dirty?: boolean;
     }>;
     /**
      * @param state
      * @param action
      *
-     * Moves to the next node in a flow based on validation rules and current state.
+     * Replaces the data of a flow with new data.
      *
      * @returns state
      */
-    next: ReducerFunctionSign<T, {
-        name?: string;
-        flowName?: string;
-        data: T;
-        route?: string;
+    replaceData: DataReducerFunctionSign<T, {
+        value: T;
     }>;
     /**
      * @param state
      * @param action
      *
-     * Moves to the previous node in a flow.
+     * Unsets data from a flow at a specific path.
      *
      * @returns state
      */
-    prev: ReducerFunctionSign<T, {
-        name?: string;
-        flowName?: string;
+    unsetData: DataReducerFunctionSign<T, {
+        id: string[] | string;
     }>;
     /**
      * @param state
      * @param action
      *
-     * Return back to the first node and resets history.
+     * Sets the "isValidating" state of a form node in a flow.
      *
      * @returns state
      */
-    restart: ReducerFunctionSign<T, {
-        name?: string;
-        flowName?: string;
+    setIsDataValidating: DataReducerFunctionSign<T, {
+        isValidating?: boolean;
     }>;
     /**
      * @param state
      * @param action
      *
-     * Returns back to the first node, resets history and clean all previous data from flow.
+     * Reset form.
      *
      * @returns state
      */
-    reset: ReducerFunctionSign<T, {
-        name?: string;
-        flowName?: string;
+    resetData: DataReducerFunctionSign<T, {
+        rootName: string;
         initialData?: Record<string, any>;
-    }
+    }>;
     /**
      * @param state
      * @param action
@@ -397,10 +398,9 @@ export type ReducersFunctions<T extends Record<string, any> = Record<string, Flo
      *
      * @returns state
      */
-    >;
-    resetForm: ReducerFunctionSign<T, {
-        id: string;
-        flowName: string;
+    initData: DataReducerFunctionSign<T, {
+        rootName: string;
+        initialData: Record<string, any>;
     }>;
 };
 export {};

package/dist/src/{rules-matcher/interface.d.ts → interfaces/RulesMatcherInterface.d.ts}

@@ -1,4 +1,4 @@
-import { RulesObject } from '../interfaces/CoreInterface';
+import { RulesObject } from './CoreInterface';
 export type CheckTypeOf = (v: any) => boolean;
 export type CheckOperationObj = {
     op: keyof Operators;

package/dist/src/interfaces/SelectorsInterface.d.ts

@@ -1,12 +1,13 @@
+import { REDUCER_NAME } from '../constants';
 import { RulesObject } from './CoreInterface';
-import { Flower, Form, INode } from './Store';
-export interface ISelectors {
+import { Flower, Data, INode } from './Store';
+export interface IFlowerSelectors {
     /**
      * @param state
      * @returns
      */
     selectGlobal<T extends Record<string, any>>(state: {
-        flower: {
+        [REDUCER_NAME.FLOWER_FLOW]: {
             [x: string]: Flower<T>;
         };
     }): {
@@ -19,11 +20,6 @@ export interface ISelectors {
     selectFlower<T extends Record<string, any>>(name: string): (state: {
         [x: string]: Flower<T>;
     }) => Flower<T>;
-    /**
-     * @param id
-     * @returns
-     */
-    selectFlowerFormNode<T extends Record<string, any>>(id: string): (state: Flower<T>) => Form<T>;
     /**
      * @param flower
      * @returns
@@ -60,11 +56,29 @@ export interface ISelectors {
     makeSelectCurrentNodeDisabled<T extends Record<string, any>>(nodes: {
         [x: string]: Partial<INode>;
     }, current: Flower<T>['current']): boolean;
+}
+export interface IDataSelectors {
+    /**
+     * @param state
+     * @returns
+     */
+    selectGlobalReducerByName(name: string): (state: Record<string, Record<string, unknown>>) => Record<string, unknown>;
+    /**
+     * @param state
+     * @returns
+     */
+    selectGlobalData<T extends Record<string, any>>(state: {
+        [REDUCER_NAME.FLOWER_DATA]: {
+            [x: string]: Data<T>;
+        };
+    }): {
+        [x: string]: Data<T>;
+    };
     /**
-     * @param form
+     * @param data
      * @returns
      */
-    makeSelectNodeErrors<T extends Record<string, any>>(form: Form<T> | undefined): {
+    makeSelectNodeErrors<T extends Record<string, any>>(data: Data<T> | undefined): {
         isSubmitted: boolean;
         isDirty: boolean;
         hasFocus: string | undefined;
@@ -74,35 +88,30 @@ export interface ISelectors {
         isValidating?: boolean;
     };
     /**
-     * @param form
+     * @param data
      * @returns
      */
-    makeSelectNodeFormFieldTouched<T extends Record<string, any>>(id: string): (form: Form<T> | undefined) => boolean | undefined;
+    makeSelectNodeDataFieldTouched<T extends Record<string, any>>(id: string): (data: Data<T> | undefined) => boolean | undefined;
     /**
-     * @param form
+     * @param data
      * @returns
      */
-    makeSelectNodeFormFieldFocused<T extends Record<string, any>>(id: string): (form: Form<T> | undefined) => string | undefined;
+    makeSelectNodeDataFieldFocused<T extends Record<string, any>>(id: string): (data: Data<T> | undefined) => string | undefined;
     /**
-     * @param form
-     * @returns
-     */
-    makeSelectNodeFormFieldDirty<T extends Record<string, any>>(id: string): (form: Form<T> | undefined) => boolean | undefined;
-    /**
-     * @param flower
+     * @param data
      * @returns
      */
-    getDataByFlow<T extends Record<string, any>>(flower: Flower<T>): T;
+    makeSelectNodeDataFieldDirty<T extends Record<string, any>>(id: string): (data: Data<T> | undefined) => boolean | undefined;
     /**
      * @param id
      * @returns
      */
     getDataFromState<T extends Record<string, any>>(id: string | string[]): (data: T) => Partial<T>;
     /**
-     * @param form
+     * @param data
      * @returns
      */
-    makeSelectNodeFormSubmitted<T extends Record<string, any>>(form: Form<T>): boolean | undefined;
+    makeSelectNodeDataSubmitted<T extends Record<string, any>>(data: Data<T>): boolean | undefined;
     /**
      * @param name
      * @param id
@@ -112,7 +121,7 @@ export interface ISelectors {
     makeSelectFieldError<T extends Record<string, any>>(name: string, id: string, validate: {
         rules?: RulesObject<any>;
         message?: string;
-    }[] | null): (data: T | undefined, form: Form<T>) => Array<string>;
+    }[] | null): (globalData: T | undefined, data: Data<T>) => Array<string>;
     /**
      * @param id
      * @param rules
@@ -121,5 +130,5 @@ export interface ISelectors {
      * @param value
      * @returns
      */
-    selectorRulesDisabled<T extends Record<string, any>>(id: string, rules: any, keys: string[] | null, flowName: string, value: any): (data: T | undefined, form: Form<T>) => boolean;
+    selectorRulesDisabled<T extends Record<string, any>>(id: string, rules: any, keys: string[] | null, flowName: string, value: any): (globalData: T | undefined, data: Data<T>) => boolean;
 }

package/dist/src/interfaces/Store.d.ts

@@ -1,9 +1,4 @@
 import { RulesByNodeId } from './CoreInterface';
-export interface StoreRoot<T extends Record<string, any>> {
-    flower: {
-        [x: string]: Flower<T>;
-    };
-}
 export interface Flower<T extends Record<string, any>> {
     persist: boolean;
     startId: string;
@@ -15,10 +10,6 @@ export interface Flower<T extends Record<string, any>> {
     nextRules: {
         [x: string]: RulesByNodeId<T>[];
     };
-    data: T;
-    form: {
-        [x: string]: Form<T>;
-    };
 }
 export interface INode {
     nodeId: string;
@@ -26,7 +17,7 @@ export interface INode {
     retain?: boolean;
     disabled?: boolean;
 }
-export type Form<T> = {
+export type Data<T extends Record<string, unknown>> = {
     isSubmitted?: boolean;
     isDirty?: boolean;
     hasFocus?: string;
@@ -43,4 +34,5 @@ export type Form<T> = {
     touches?: {
         [K in keyof T]: boolean;
     };
+    data?: T;
 };

package/dist/src/interfaces/UtilsInterface.d.ts

@@ -14,7 +14,7 @@ export interface CoreStateUtils {
      * Selects the form node with a specific ID from a given flow.
      * It returns a selector function that accepts the state as an argument and retrieves the form node
      */
-    selectFlowerFormNode<T extends object>(name: string, id: string): (state: T) => Record<string, any>;
+    selectFlowerDataNode<T extends object>(name: string): (state: T) => Record<string, any>;
     /**
      *
      * @param name

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

@@ -1,5 +1,8 @@
 export * from './CoreInterface';
+export * from './EmitterInterface';
+export * from './FlatInterface';
 export * from './ReducerInterface';
+export * from './RulesMatcherInterface';
 export * from './SelectorsInterface';
 export * from './Store';
 export * from './UtilsInterface';

package/dist/src/rules-matcher/RulesMatcher.d.ts

@@ -0,0 +1,2 @@
+import { FunctionRule } from '../interfaces';
+export declare const rulesMatcher: (rules?: Record<string, any> | Record<string, any>[] | FunctionRule, dataValue?: Record<string, any>, apply?: boolean, options?: Record<string, any>) => boolean[];

package/dist/src/rules-matcher/index.d.ts

@@ -0,0 +1,2 @@
+export { rulesMatcher } from './RulesMatcher';
+export { rulesMatcherUtils } from './utils';