@flowerforce/flower-core 3.1.1 → 3.1.2-beta.1

package/dist/src/CoreUtils.d.ts

@@ -1,3 +1,6 @@
 import { CoreUtilitiesFunctions } from './interfaces/CoreInterface';
 export declare const flattenRules: (ob: Record<string, any>) => Record<string, any>;
+/**
+ * Defines a collection of utility functions for processing rules, nodes and graph-like structures
+ */
 export declare const CoreUtils: CoreUtilitiesFunctions;

package/dist/src/FlowerCoreStateFunctions.d.ts

@@ -1,2 +1,5 @@
 import { ReducersFunctions } 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 FlowerCoreReducers: ReducersFunctions;

package/dist/src/index.d.ts

@@ -5,3 +5,5 @@ export { FlowerCoreStateSelectors as Selectors } from './FlowerCoreStateSelector
 export { CoreUtils } from './CoreUtils';
 export { MatchRules } from './RulesMatcher';
 export * from './interfaces';
+declare const devtoolState: {};
+export { devtoolState };

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

@@ -113,18 +113,105 @@ export type GenerateRulesName = (nextRules: RulesWithName[]) => {
     [X: string]: string;
 };
 export interface CoreUtilitiesFunctions {
+    /**
+     *
+     * Generates rule names from a set of rules.
+     * @param nextRules
+     *
+     * @returns
+     *
+     */
     generateRulesName: GenerateRulesName;
+    /**
+     * Recursively maps keys of an object using a callback function.
+     * @param obj
+     * @param cb
+     * @param isRecursive
+     *
+     * @returns
+     */
     mapKeysDeepLodash: MapKeysDeepLodash;
+    /**
+     * Generates a object of nodes from an array of nodes, using nodeId as keys
+     * @param nodes
+     * @returns
+     */
     generateNodes: GenerateNodes;
+    /**
+     * Converts nodes into an object with node IDs as keys and their respective rules as values.
+     * @param nodes
+     *
+     * @returns
+     */
     makeObjectRules: MakeObjectRules;
+    /**
+     * Checks if a node exists within a specific state.
+     * @param state
+     * @param name
+     * @param node
+     *
+     * @returns
+     */
     hasNode: HasNode;
+    /**
+     * Checks if a set of rules is empty.
+     * @param rules
+     *
+     * @returns
+     */
     isEmptyRules: IsEmptyRules;
+    /**
+     * Maps edges and sorts them moving empty rules to the bottom.
+     * @param nextNode
+     *
+     * @returns
+     */
     mapEdge: MapEdge;
+    /**
+     * Converts a rules object into an array of rule objects.
+     * @param rules
+     *
+     * @returns
+     */
     makeRules: MakeRules;
+    /**
+     * Generates nodes for a flower JSON structure, extracting rules and other properties.
+     * @param nodes
+     *
+     * @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
+     * @param arr2
+     *
+     * @returns
+     */
     allEqual: AllEqual;
+    /**
+     * Finds the first valid rule for a given value within a set of rules.
+     * @param nextRules
+     * @param value
+     * @param prefix
+     *
+     * @returns
+     */
     findValidRule: FindValidRule;
 }
 export {};

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

@@ -6,58 +6,170 @@ export type ActionWithPayload<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' | '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>>>> = {
+    /**
+     * @param state
+     * @param action
+     *
+     * Adds a node to the history of a specific flow if the node exists.
+     *
+     * @returns state
+     */
     historyAdd: ReducerFunctionSign<T, {
         name: string;
         node: string;
     }>;
+    /**
+     * @param state
+     * @param action
+     *
+     * Navigates to a specific node in the history of a flow.
+     *
+     * @returns state
+     */
     historyPrevToNode: ReducerFunctionSign<T, {
         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
+     *
+     * Adds multiple nodes to the history of a flow, starting from a specified index.
+     *
+     * @returns state
+     */
     forceAddHistory: ReducerFunctionSign<T, {
         history: string[];
         name?: string;
         flowName?: string;
     }>;
+    /**
+     * @param state
+     * @param action
+     *
+     * Removes the current node from the history of a flow.
+     *
+     * @returns state
+     */
     historyPop: ReducerFunctionSign<T, {
         name: string;
     }>;
+    /**
+     * @param state
+     * @param action
+     *
+     * Restores the history of a flow to its initial state.
+     *
+     * @returns state
+     */
     restoreHistory: ReducerFunctionSign<T, {
         name: string;
     }>;
+    /**
+     * @param state
+     * @param action
+     *
+     * Replaces the current node in a flow with a specified node.
+     *
+     * @returns state
+     */
     replaceNode: ReducerFunctionSign<T, {
         node: string;
         name?: string;
         flowName?: string;
     }>;
+    /**
+     * @param state
+     * @param action
+     *
+     * Initializes a flow from a specific node.
+     *
+     * @returns state
+     */
     initializeFromNode: ReducerFunctionSign<T, {
         node: string;
         name?: string;
         flowName?: string;
     }>;
+    /**
+     * @param state
+     * @param action
+     *
+     * Resets the history of a flow forcefully.
+     *
+     * @returns state
+     */
     forceResetHistory: ReducerFunctionSign<T, {
         name?: string;
         flowName?: string;
     }>;
+    /**
+     * @param state
+     * @param action
+     *
+     * Destroys a flow by removing it from the state.
+     *
+     * @returns state
+     */
     destroy: ReducerFunctionSign<T, {
         name: string;
     }>;
+    /**
+     * @param state
+     * @param action
+     *
+     * Initializes the nodes of a flow, setting its initial state and generating necessary data structures.
+     *
+     * @returns state
+     */
     initNodes: ReducerFunctionSign<T, {
         name: string;
         startId: string;
         persist: boolean;
         nodes: Node[];
         initialData: any;
+        initialState: {
+            startId?: string;
+            current?: string;
+            history?: string[];
+        };
     }>;
+    /**
+     * @param state
+     * @param action
+     *
+     * Sets the current node of a flow to a specified node.
+     *
+     * @returns state
+     */
     setCurrentNode: ReducerFunctionSign<T, {
         name: string;
         node: string;
     }>;
+    /**
+     * @param state
+     * @param action
+     *
+     * Adds errors to a form node in a flow.
+     *
+     * @returns state
+     */
     formAddErrors: ReducerFunctionSign<T, {
         name: string;
         currentNode: string;
@@ -66,33 +178,89 @@ export type ReducersFunctions<T extends Record<string, any> = Record<string, Flo
             [x: string]: string[];
         } | string[];
     }>;
+    /**
+     * @param state
+     * @param action
+     *
+     * Removes errors from a form node in a flow.
+     *
+     * @returns state
+     */
     formRemoveErrors: ReducerFunctionSign<T, {
         name: string;
         currentNode: string;
         id: string;
     }>;
+    /**
+     * @param state
+     * @param action
+     *
+     * Adds data to a flow.
+     *
+     * @returns state
+     */
     addData: ReducerFunctionSign<T, {
         flowName: string;
         value: T;
     }>;
+    /**
+     * @param state
+     * @param action
+     *
+     * Adds data to a flow at a specific path.
+     *
+     * @returns state
+     */
     addDataByPath: ReducerFunctionSign<T, {
         id: string[];
         flowName: string;
         value: T | string;
     }>;
+    /**
+     * @param state
+     * @param action
+     *
+     * Replaces the data of a flow with new data.
+     *
+     * @returns state
+     */
     replaceData: ReducerFunctionSign<T, {
         flowName: string;
         value: T;
     }>;
+    /**
+     * @param state
+     * @param action
+     *
+     * Unsets data from a flow at a specific path.
+     *
+     * @returns state
+     */
     unsetData: ReducerFunctionSign<T, {
         id: string[] | string;
         flowName: string;
     }>;
+    /**
+     * @param state
+     * @param action
+     *
+     * Sets the "isValidating" state of a form node in a flow.
+     *
+     * @returns state
+     */
     setFormIsValidating: ReducerFunctionSign<T, {
         name: string;
         currentNode: string;
         isValidating?: boolean;
     }>;
+    /**
+     * @param state
+     * @param action
+     *
+     * Handles node transitions in a flow, updating history and form states accordingly.
+     *
+     * @returns state
+     */
     node: ReducerFunctionSign<T, {
         name: string;
         flowName?: string;
@@ -100,25 +268,65 @@ export type ReducersFunctions<T extends Record<string, any> = Record<string, Flo
         node?: string;
         history: string[];
     }>;
+    /**
+     * @param state
+     * @param action
+     *
+     * Navigates to a specific node in the history of a flow.
+     *
+     * @returns state
+     */
     prevToNode: ReducerFunctionSign<T, {
         name?: string;
         flowName?: string;
         node: string;
     }>;
+    /**
+     * @param state
+     * @param action
+     *
+     * Moves to the next node in a flow based on validation rules and current state.
+     *
+     * @returns state
+     */
     next: ReducerFunctionSign<T, {
         name?: string;
         flowName?: string;
         data: T;
         route?: string;
     }>;
+    /**
+     * @param state
+     * @param action
+     *
+     * Moves to the previous node in a flow.
+     *
+     * @returns state
+     */
     prev: ReducerFunctionSign<T, {
         name?: string;
         flowName?: string;
     }>;
+    /**
+     * @param state
+     * @param action
+     *
+     * Return back to the first node and resets history.
+     *
+     * @returns state
+     */
     restart: ReducerFunctionSign<T, {
         name?: string;
         flowName?: string;
     }>;
+    /**
+     * @param state
+     * @param action
+     *
+     * Returns back to the first node, resets history and clean all previous data from flow.
+     *
+     * @returns state
+     */
     reset: ReducerFunctionSign<T, {
         name?: string;
         flowName?: string;

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

@@ -1,6 +1,10 @@
 import { RulesObject } from './CoreInterface';
 import { Flower, Form, INode } from './Store';
 export interface ISelectors {
+    /**
+     * @param state
+     * @returns
+     */
     selectGlobal<T extends Record<string, any>>(state: {
         flower: {
             [x: string]: Flower<T>;
@@ -8,31 +12,97 @@ export interface ISelectors {
     }): {
         [x: string]: Flower<T>;
     };
+    /**
+     * @param name
+     * @returns
+     */
     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
+     */
     selectFlowerHistory<T extends Record<string, any>>(flower: Flower<T>): Array<string>;
+    /**
+     * @param flower
+     * @returns
+     */
     makeSelectNodesIds<T extends Record<string, any>>(flower: Flower<T>): Flower<T>['nodes'];
+    /**
+     * @param flower
+     * @returns
+     */
     makeSelectStartNodeId<T extends Record<string, any>>(flower: Flower<T>): string;
+    /**
+     * @param flower
+     * @param startNodeId
+     * @returns
+     */
     makeSelectCurrentNodeId<T extends Record<string, any>>(flower: Flower<T>, startNodeId: Flower<T>['startId']): string;
+    /**
+     * @param nodes
+     * @param history
+     * @param current
+     * @returns
+     */
     makeSelectPrevNodeRetain<T extends Record<string, any>>(nodes: Flower<T>['nodes'], history: Flower<T>['history'], current: Flower<T>['current']): boolean | string | undefined;
+    /**
+     * @param nodes
+     * @param current
+     * @returns
+     */
     makeSelectCurrentNodeDisabled<T extends Record<string, any>>(nodes: {
         [x: string]: Partial<INode>;
     }, current: Flower<T>['current']): boolean;
+    /**
+     * @param form
+     * @returns
+     */
     makeSelectNodeErrors<T extends Record<string, any>>(form: Form<T> | undefined): {
         touched: boolean;
         errors: any;
         isValid: boolean;
         isValidating?: boolean;
     };
+    /**
+     * @param flower
+     * @returns
+     */
     getDataByFlow<T extends Record<string, any>>(flower: Flower<T>): T;
+    /**
+     * @param id
+     * @returns
+     */
     getDataFromState<T extends Record<string, any>>(id: string | string[]): (data: T) => Partial<T>;
+    /**
+     * @param form
+     * @returns
+     */
     makeSelectNodeFormTouched<T extends Record<string, any>>(form: Form<T>): boolean | undefined;
+    /**
+     * @param name
+     * @param id
+     * @param validate
+     * @returns
+     */
     makeSelectFieldError<T extends Record<string, any>>(name: string, id: string, validate: {
         rules?: RulesObject<any>;
         message?: string;
     }[] | null): (data?: T) => Array<string>;
+    /**
+     * @param id
+     * @param rules
+     * @param keys
+     * @param flowName
+     * @param value
+     * @returns
+     */
     selectorRulesDisabled<T extends Record<string, any>>(id: string, rules: any, keys: string[] | null, flowName: string, value: any): (data: T | undefined, form: {
         touched: boolean;
         errors: any;

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

@@ -1,8 +1,45 @@
 export interface CoreStateUtils {
+    /**
+     * @param state
+     *
+     * Extracts data from all flows in the state object.
+     * It iterates through each flow and retrieves its data property.
+     */
     getAllData<T extends object>(state: T | undefined): Record<string, any> | undefined;
+    /**
+     *
+     * @param name
+     * @param id
+     *
+     * 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>;
+    /**
+     *
+     * @param name
+     *
+     * Creates a selector function that selects the next rules for the current node in a given flow.
+     * It retrieves the next rules from the state
+     */
     makeSelectCurrentNodeId<T extends object>(name: string): (state: T) => string;
+    /**
+     *
+     * @param name
+     *
+     * Creates a selector function that selects the ID of the current node in a given flow.
+     * It first retrieves the sub-state of the specified flow, then checks if there's a current node ID;
+     * if not, it falls back to the start ID.
+     */
     makeSelectCurrentNextRules<T extends object>(name: string): (state: T) => any;
+    /**
+     *
+     * @param name
+     * @param currentNodeId
+     *
+     * Creates a selector function that selects error-related information for a specific node in a given flow.
+     * It retrieves the form node using selectFlowerFormNode, then extracts information about touched state, errors, validation status, and validity.
+     */
     makeSelectNodeErrors<T extends object>(name: string, currentNodeId: string): (state: T) => {
         touched: boolean;
         errors: any;