@flowerforce/flower-core 3.0.0

package/dist/src/CoreUtils.d.ts

@@ -0,0 +1,3 @@
+import { CoreUtilitiesFunctions } from './interfaces/CoreInterface';
+export declare const flattenRules: (ob: Record<string, any>) => Record<string, any>;
+export declare const CoreUtils: CoreUtilitiesFunctions;

package/dist/src/Emitter.d.ts

@@ -0,0 +1,2 @@
+import { TinyEmitter } from 'tiny-emitter';
+export declare const Emitter: TinyEmitter;

package/dist/src/Flat.d.ts

@@ -0,0 +1,5 @@
+import { Flatten, Unflatten } from './interfaces/FlatInterface';
+export declare const flat: {
+    flatten: Flatten;
+    unflatten: Unflatten;
+};

package/dist/src/FlowerCoreStateFunctions.d.ts

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

package/dist/src/FlowerCoreStateSelectors.d.ts

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

package/dist/src/FlowerCoreStateUtils.d.ts

@@ -0,0 +1,2 @@
+import { CoreStateUtils } from './interfaces/UtilsInterface';
+export declare const FlowerStateUtils: CoreStateUtils;

package/dist/src/RulesMatcher.d.ts

@@ -0,0 +1,5 @@
+export declare const MatchRules: {
+    rulesMatcher: (rules?: Record<string, any> | Record<string, any>[], formValue?: Record<string, any>, apply?: boolean, options?: Record<string, any>) => boolean[];
+    operators: import("./rules-matcher/interface").Operators;
+    utils: import("./rules-matcher/interface").RulesMatcherUtils;
+};

package/dist/src/index.d.ts

@@ -0,0 +1,8 @@
+export { flat as Flat } from './Flat';
+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 * from './interfaces';

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

@@ -0,0 +1,129 @@
+export type Rules<T> = {
+    rules: Rules<T> | string | null | undefined | T;
+};
+export type Edge<T = object> = {
+    source: string;
+    target: string;
+    id?: string;
+    data?: {
+        rules: RulesObject<T>;
+    };
+};
+export type Node = {
+    nodeId: string | undefined;
+    nodeType: string;
+    nodeTitle: string;
+    children: Record<string, any> | Record<string, any>[] | undefined;
+    nextRules: {
+        [x: string]: {
+            rules: RulesObject<any>;
+        } | RulesObject<any>;
+    } | undefined;
+    retain: boolean;
+    disabled: boolean;
+    id: string;
+    props: Record<string, any>;
+    type: Record<string, any>;
+};
+export declare enum RulesModes {
+    $and = "$and",
+    $or = "$or"
+}
+declare enum RulesOperators {
+    $exist = "$exist",
+    $eq = "$eq",
+    $ne = "$ne",
+    $gt = "$gt",
+    $gte = "$gte",
+    $lt = "$lt",
+    $lte = "$lte",
+    $strGt = "$strGt",
+    $strGte = "$strGte",
+    $strLt = "$strLt",
+    $strLte = "$strLte",
+    $in = "$in",
+    $nin = "$nin",
+    $all = "$all",
+    $regex = "$regex"
+}
+type RulesValuesType<T> = {
+    '$form.isValid': boolean;
+} & T;
+type RulesOperatorsInArray<T> = Partial<{
+    [KEY in keyof T]: Partial<{
+        [K in keyof typeof RulesOperators]: T[KEY];
+    }>;
+}>;
+export type RulesByNodeId<T extends Record<string, any>> = {
+    nodeId: string;
+    rules: {
+        rules: RulesObject<T>;
+    } | RulesObject<T> | null;
+};
+type RulesWithName = {
+    nodeId: string;
+    rules: string | {
+        name?: string;
+        rules: RulesObject<any>;
+    };
+};
+export type RulesObject<T> = RulesValuesType<T> | {
+    [K in keyof typeof RulesModes]: Array<RulesOperatorsInArray<RulesValuesType<T>>> | Array<RulesObject<RulesValuesType<T>>>;
+} | Array<Exclude<RulesOperatorsInArray<RulesValuesType<T>>, undefined>>;
+export type CleanPath = (name: string, char?: string) => string;
+export type GetPath = (idValue?: string) => {
+    path: string | string[];
+    flowNameFromPath?: string;
+};
+export type AllEqual = (...args: Array<number | string | boolean>[]) => boolean;
+export type FindValidRule<T = Rules<RulesObject<any>>> = (nextRules: {
+    rules: {
+        rules: T;
+    };
+}, value: Record<string, any>, prefix?: {
+    prefix: string;
+} | string) => T[keyof T] | undefined;
+export type IsEmptyRules<T = {
+    rules: RulesObject<any>;
+} | RulesObject<any>> = (rules: T) => boolean;
+export type MapEdge<K = RulesByNodeId<any>, T = K[]> = (nextNode: T) => Array<K>;
+export type MakeRules<T extends Record<string, any> = {
+    rules: RulesObject<any> | object;
+}> = (rules: T) => Array<RulesByNodeId<T>>;
+export type GetRulesExists = (rules: RulesByNodeId<any>[]) => ReturnType<MapEdge> | undefined;
+export type GenerateNodesForFlowerJson = (nodes: Node[], edges?: Edge[]) => {
+    nodeId: string | undefined;
+    nodeType: string;
+    nodeTitle: string;
+    children: Node['children'];
+    nextRules: ReturnType<GetRulesExists>;
+    retain: boolean;
+    disabled: boolean;
+}[];
+export type HasNode = (state: Record<string, any>, name: string, node: string) => boolean;
+export type MakeObjectRules = (nodes: Node[]) => {
+    [x: string]: Node['nextRules'];
+};
+export type GenerateNodes = (nodes: Node[]) => {
+    [x: string]: Omit<Node, 'nextRules'>;
+};
+export type MapKeysDeepLodash = (obj: Record<string, any>, cb: (...args: any) => any, isRecursive?: boolean) => Record<string, any>;
+export type GenerateRulesName = (nextRules: RulesWithName[]) => {
+    [X: string]: string;
+};
+export interface CoreUtilitiesFunctions {
+    generateRulesName: GenerateRulesName;
+    mapKeysDeepLodash: MapKeysDeepLodash;
+    generateNodes: GenerateNodes;
+    makeObjectRules: MakeObjectRules;
+    hasNode: HasNode;
+    isEmptyRules: IsEmptyRules;
+    mapEdge: MapEdge;
+    makeRules: MakeRules;
+    generateNodesForFlowerJson: GenerateNodesForFlowerJson;
+    cleanPath: CleanPath;
+    getPath: GetPath;
+    allEqual: AllEqual;
+    findValidRule: FindValidRule;
+}
+export {};

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

@@ -0,0 +1,6 @@
+export interface IEmitter {
+    on<F extends (...args: unknown[]) => unknown, C>(name: string, cb: F, ctx?: C): this;
+    once<F extends (...args: unknown[]) => unknown, C>(name: string, cb: F, ctx?: C): this;
+    emit(name: string, opt?: Record<string, any>): this;
+    off<F extends (...args: unknown[]) => unknown>(name: string, cb?: F): this;
+}

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

@@ -0,0 +1,20 @@
+export type KeyIdentity = (key: string) => string;
+export type GetKey = (key?: string) => string | number | undefined;
+interface FlattenOptions {
+    maxDepth: number;
+    safe?: boolean;
+    delimiter?: string;
+    transformKey?: (key: string) => string;
+}
+interface UnflattenOptions extends FlattenOptions {
+    overwrite?: boolean;
+    object?: boolean;
+}
+export type Flatten<T = object> = (target: T, opts?: FlattenOptions) => T;
+export type FlattenStep = (object: {
+    [x: string]: any;
+}, prev?: string, currentDepth?: number) => void;
+export type Unflatten<T = {
+    [x: string]: any;
+}> = (target: T, opts?: UnflattenOptions) => T;
+export {};

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

@@ -0,0 +1,123 @@
+import { Node } from './CoreInterface';
+import { Flower } from './Store';
+export type ActionWithPayload<T> = {
+    type: string;
+    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' | 'node' | 'prevToNode' | 'next' | 'prev' | 'reset';
+export type ReducersFunctions<T extends Record<string, any> = Record<string, Flower<Record<string, any>>>> = {
+    historyAdd: ReducerFunctionSign<T, {
+        name: string;
+        node: string;
+    }>;
+    historyPrevToNode: ReducerFunctionSign<T, {
+        name: string;
+        node: string;
+    } | string>;
+    setFormTouched: ReducerFunctionSign<T, {
+        flowName: string;
+        currentNode: string;
+    } | string>;
+    forceAddHistory: ReducerFunctionSign<T, {
+        history: string[];
+        name?: string;
+        flowName?: string;
+    }>;
+    historyPop: ReducerFunctionSign<T, {
+        name: string;
+    }>;
+    restoreHistory: ReducerFunctionSign<T, {
+        name: string;
+    }>;
+    replaceNode: ReducerFunctionSign<T, {
+        node: string;
+        name?: string;
+        flowName?: string;
+    }>;
+    initializeFromNode: ReducerFunctionSign<T, {
+        node: string;
+        name?: string;
+        flowName?: string;
+    }>;
+    forceResetHistory: ReducerFunctionSign<T, {
+        name?: string;
+        flowName?: string;
+    }>;
+    destroy: ReducerFunctionSign<T, {
+        name: string;
+    }>;
+    initNodes: ReducerFunctionSign<T, {
+        name: string;
+        startId: string;
+        persist: boolean;
+        nodes: Node[];
+        initialData: any;
+    }>;
+    setCurrentNode: ReducerFunctionSign<T, {
+        name: string;
+        node: string;
+    }>;
+    formAddErrors: ReducerFunctionSign<T, {
+        name: string;
+        currentNode: string;
+        id: string;
+        errors: {
+            [x: string]: string[];
+        } | string[];
+    }>;
+    formRemoveErrors: ReducerFunctionSign<T, {
+        name: string;
+        currentNode: string;
+        id: string;
+    }>;
+    addData: ReducerFunctionSign<T, {
+        flowName: string;
+        value: T;
+    }>;
+    addDataByPath: ReducerFunctionSign<T, {
+        id: string[];
+        flowName: string;
+        value: T | string;
+    }>;
+    replaceData: ReducerFunctionSign<T, {
+        flowName: string;
+        value: T;
+    }>;
+    unsetData: ReducerFunctionSign<T, {
+        id: string[] | string;
+        flowName: string;
+    }>;
+    setFormIsValidating: ReducerFunctionSign<T, {
+        name: string;
+        currentNode: string;
+        isValidating?: boolean;
+    }>;
+    node: ReducerFunctionSign<T, {
+        name: string;
+        flowName?: string;
+        nodeId?: string;
+        node?: string;
+        history: string[];
+    }>;
+    prevToNode: ReducerFunctionSign<T, {
+        name?: string;
+        flowName?: string;
+        node: string;
+    }>;
+    next: ReducerFunctionSign<T, {
+        name?: string;
+        flowName?: string;
+        data: T;
+        route?: string;
+    }>;
+    prev: ReducerFunctionSign<T, {
+        name?: string;
+        flowName?: string;
+    }>;
+    reset: ReducerFunctionSign<T, {
+        name?: string;
+        flowName?: string;
+    }>;
+};
+export {};

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

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

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

@@ -0,0 +1,64 @@
+import { RulesByNodeId, RulesModes } from './CoreInterface';
+export declare enum RulesOperators {
+    $exist = "$exist",
+    $eq = "$eq",
+    $ne = "$ne",
+    $gt = "$gt",
+    $gte = "$gte",
+    $lt = "$lt",
+    $lte = "$lte",
+    $strGt = "$strGt",
+    $strGte = "$strGte",
+    $strLt = "$strLt",
+    $strLte = "$strLte",
+    $in = "$in",
+    $nin = "$nin",
+    $all = "$all",
+    $regex = "$regex"
+}
+type RulesValuesType<T> = {
+    '$form.isValid': boolean;
+} & T;
+type RulesOperatorsInArray<T> = Partial<{
+    [KEY in keyof T]: Partial<{
+        [K in keyof typeof RulesOperators]: T[KEY];
+    }>;
+}>;
+export type RulesObject<T> = {
+    [K in keyof typeof RulesModes]: Array<RulesOperatorsInArray<RulesValuesType<T>>> | Array<RulesObject<RulesValuesType<T>>>;
+} | Array<RulesOperatorsInArray<RulesValuesType<T>>>;
+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;
+    current: string;
+    history: string[];
+    nodes: {
+        [x: string]: Node;
+    };
+    nextRules: {
+        [x: string]: RulesByNodeId<T>[];
+    };
+    data: T;
+    form: {
+        [x: string]: Form<T>;
+    };
+}
+export interface Node {
+    nodeId: string;
+    nodeType: string;
+    retain?: boolean;
+    disabled?: boolean;
+}
+export type Form<T> = {
+    touched?: boolean;
+    isValidating?: boolean;
+    errors?: {
+        [K in keyof T]: Array<string>;
+    };
+};
+export {};

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

@@ -0,0 +1,12 @@
+export interface CoreStateUtils {
+    getAllData<T extends object>(state: T | undefined): Record<string, any> | undefined;
+    selectFlowerFormNode<T extends object>(name: string, id: string): (state: T) => Record<string, any>;
+    makeSelectCurrentNodeId<T extends object>(name: string): (state: T) => string;
+    makeSelectCurrentNextRules<T extends object>(name: string): (state: T) => any;
+    makeSelectNodeErrors<T extends object>(name: string, currentNodeId: string): (state: T) => {
+        touched: boolean;
+        errors: any;
+        isValid: boolean;
+        isValidating?: boolean;
+    };
+}

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

@@ -0,0 +1,5 @@
+export * from './CoreInterface';
+export * from './ReducerInterface';
+export * from './SelectorsInterface';
+export * from './Store';
+export * from './UtilsInterface';

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

@@ -0,0 +1,64 @@
+import { RulesObject } from '../interfaces/CoreInterface';
+export type CheckTypeOf = (v: any) => boolean;
+export type CheckOperationObj = {
+    op: keyof Operators;
+    value: any;
+    opt?: any;
+};
+export interface RulesMatcherUtils {
+    isNumber: <T>(el: T) => boolean;
+    rule: (block: Record<string, any>, keys: Record<string, any>, options: Record<string, any>) => {
+        valid: boolean;
+        name: string;
+    };
+    getKey: (block: RulesObject<any>, keys: Record<string, any>, options: Record<string, any>) => Record<string, any>;
+    isDate: CheckTypeOf;
+    isDefined: CheckTypeOf;
+    isObject: CheckTypeOf;
+    isFunction: CheckTypeOf;
+    isString: CheckTypeOf;
+    getDefaultStringValue: (value: '$required' | '$exists' | string) => CheckOperationObj;
+    getTypeOf: (value: any) => string | null;
+    getDefaultRule: (value: any) => CheckOperationObj;
+    isEmpty: (value: any) => boolean;
+    forceArray: <T>(value: T) => Array<T>;
+    getPath: (path: string, prefix?: string) => string;
+    forceNumber: <T>(value: T) => number;
+    checkRule: <T extends Record<string, any>>(block: RulesObject<T>, data: T, options: Record<string, any>) => boolean;
+    getKeys: <T extends Record<string, any>>(rules?: T, options?: Record<string, any>) => string[] | null;
+}
+export declare enum OperatorsKeys {
+    $exists = "$exists",
+    $eq = "$eq",
+    $ne = "$ne",
+    $gt = "$gt",
+    $gte = "$gte",
+    $lt = "$lt",
+    $lte = "$lte",
+    $strGt = "$strGt",
+    $strGte = "$strGte",
+    $strLt = "$strLt",
+    $strLte = "$strLte",
+    $in = "$in",
+    $nin = "$nin",
+    $all = "$all",
+    $regex = "$regex"
+}
+export type OperatorsFunction = (a: any, b: any, opt?: any, data?: any) => boolean;
+export type Operators = {
+    $exists: OperatorsFunction;
+    $eq: OperatorsFunction;
+    $ne: OperatorsFunction;
+    $gt: OperatorsFunction;
+    $gte: OperatorsFunction;
+    $lt: OperatorsFunction;
+    $lte: OperatorsFunction;
+    $strGt: OperatorsFunction;
+    $strGte: OperatorsFunction;
+    $strLt: OperatorsFunction;
+    $strLte: OperatorsFunction;
+    $in: OperatorsFunction;
+    $nin: OperatorsFunction;
+    $all: OperatorsFunction;
+    $regex: OperatorsFunction;
+};

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

@@ -0,0 +1,3 @@
+import { Operators } from './interface';
+declare const operators: Operators;
+export default operators;

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

@@ -0,0 +1,3 @@
+import { RulesMatcherUtils } from './interface';
+declare const rulesMatcherUtils: RulesMatcherUtils;
+export default rulesMatcherUtils;

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@flowerforce/flower-core",
+  "version": "3.0.0",
+  "description": "Core functions for flowerJS",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "tsc:noemit": "tsc -p tsconfig.lib.json --noEmit"
+  },
+  "files": [
+    "dist",
+    "!dist/package.json",
+    "LICENSE",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "license": "ISC",
+  "peerDependencies": {
+    "lodash": ">=4"
+  },
+  "devDependencies": {
+    "@types/lodash": "^4.17.1",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.2",
+    "typescript": "^5.4.5"
+  },
+  "dependencies": {
+    "tiny-emitter": "^2.1.0"
+  },
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "module": "./dist/index.esm.js",
+      "import": "./dist/index.cjs.mjs",
+      "default": "./dist/index.cjs.js"
+    }
+  },
+  "module": "./dist/index.esm.js",
+  "main": "./dist/index.cjs.js"
+}