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

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;
+    formName?: 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 FormUtilitiesFunctions {
+    /**
+     * 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 FormUtilitiesFunctions, FlowUtilitiesFunctions {
+}
 export {};

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

@@ -5,11 +5,14 @@ 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;
+type FormReducerFunctionSign<T extends object, R = object> = (state: Record<string, T>, action: ActionWithPayload<{
+    formName: string;
+} & R>) => Record<string, 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 +37,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 +134,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 +156,244 @@ 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
+     */
+    >;
+};
+export type FormReducersFunctions<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
+     */
+    setFormTouched: FormReducerFunctionSign<T>;
+    /**
+     * @param state
+     * @param action
+     *
+     * Adds errors to a form node in a flow.
+     *
+     * @returns state
+     */
+    formAddCustomErrors: FormReducerFunctionSign<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;
+    formAddErrors: FormReducerFunctionSign<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, {
+    formFieldDirty: FormReducerFunctionSign<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;
+    formFieldTouch: FormReducerFunctionSign<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;
+    formFieldFocus: FormReducerFunctionSign<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;
+    formRemoveErrors: FormReducerFunctionSign<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: FormReducerFunctionSign<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: FormReducerFunctionSign<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: FormReducerFunctionSign<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: FormReducerFunctionSign<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;
+    setFormIsValidating: FormReducerFunctionSign<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;
+    resetForm: FormReducerFunctionSign<T, {
+        formName: string;
         initialData?: Record<string, any>;
-    }
+    }>;
     /**
      * @param state
      * @param action
@@ -397,10 +402,9 @@ export type ReducersFunctions<T extends Record<string, any> = Record<string, Flo
      *
      * @returns state
      */
-    >;
-    resetForm: ReducerFunctionSign<T, {
-        id: string;
-        flowName: string;
+    initForm: FormReducerFunctionSign<T, {
+        formName: 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 {
+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,6 +56,24 @@ export interface ISelectors {
     makeSelectCurrentNodeDisabled<T extends Record<string, any>>(nodes: {
         [x: string]: Partial<INode>;
     }, current: Flower<T>['current']): boolean;
+}
+export interface IFormSelectors {
+    /**
+     * @param state
+     * @returns
+     */
+    selectGlobalReducerByName(name: string): (state: Record<string, Record<string, unknown>>) => Record<string, unknown>;
+    /**
+     * @param state
+     * @returns
+     */
+    selectGlobalForm<T extends Record<string, any>>(state: {
+        [REDUCER_NAME.FLOWER_DATA]: {
+            [x: string]: Form<T>;
+        };
+    }): {
+        [x: string]: Form<T>;
+    };
     /**
      * @param form
      * @returns
@@ -88,11 +102,6 @@ export interface ISelectors {
      * @returns
      */
     makeSelectNodeFormFieldDirty<T extends Record<string, any>>(id: string): (form: Form<T> | undefined) => boolean | undefined;
-    /**
-     * @param flower
-     * @returns
-     */
-    getDataByFlow<T extends Record<string, any>>(flower: Flower<T>): T;
     /**
      * @param id
      * @returns

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 Form<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>;
+    selectFlowerFormNode<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, formValue?: 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';

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

@@ -1,6 +1,5 @@
-import { RulesMatcherUtils } from './interface';
+import { RulesMatcherUtils } from '../interfaces';
 /**
  * Defines a utility object named rulesMatcherUtils, which contains various helper functions used for processing rules and data in a rule-matching context.
  */
-declare const rulesMatcherUtils: RulesMatcherUtils;
-export default rulesMatcherUtils;
+export declare const rulesMatcherUtils: RulesMatcherUtils;

package/dist/src/state-manager/index.d.ts

@@ -0,0 +1,2 @@
+export * from './state-functions';
+export * from './state-selectors';

package/dist/src/state-manager/state-functions/FlowerCoreMergedReducers.d.ts

@@ -0,0 +1,2 @@
+import { CoreReducersFunctions, FormReducersFunctions } from '../../interfaces';
+export declare const FlowerCoreReducers: FormReducersFunctions & CoreReducersFunctions;

package/dist/src/state-manager/state-functions/FlowerCoreStateFunctions.d.ts

@@ -0,0 +1,5 @@
+import { CoreReducersFunctions } from '../../interfaces/ReducerInterface';
+/**
+ * These functions are Redux reducers used in a Flux architecture for managing state transitions and updates in a Flower application.
+ */
+export declare const FlowerCoreBaseReducers: CoreReducersFunctions;

package/dist/src/state-manager/state-functions/FlowerDataStateFunctions.d.ts

@@ -0,0 +1,13 @@
+import { FormReducersFunctions } from '../../interfaces/ReducerInterface';
+/**
+ * formName => FlowerForm
+ * initialData => FlowerForm
+ * fieldName => FlowerField
+ * fieldValue => FlowerField
+ * errors => FlowerField
+ * customErrors => FlowerField
+ * fieldTouched => FlowerField
+ * fieldDirty => FlowerField
+ * fieldHasFocus => FlowerField
+ */
+export declare const FlowerCoreDataReducers: FormReducersFunctions;

package/dist/src/state-manager/state-functions/index.d.ts

@@ -0,0 +1,4 @@
+export type { CoreReducersFunctions, FormReducersFunctions } from '../../interfaces';
+export { FlowerCoreBaseReducers } from './FlowerCoreStateFunctions';
+export { FlowerCoreDataReducers } from './FlowerDataStateFunctions';
+export { FlowerCoreReducers } from './FlowerCoreMergedReducers';

package/dist/src/state-manager/state-selectors/FlowerCoreStateSelectors.d.ts

@@ -0,0 +1,2 @@
+import { IFlowerSelectors } from '../../interfaces/SelectorsInterface';
+export declare const FlowerCoreStateBaseSelectors: IFlowerSelectors;