@flowerforce/flower-core 4.0.1-beta.0 → 4.0.1-beta.10

package/dist/index.esm.js

@@ -30,7 +30,7 @@ const devtoolState = {};
 const FlowerStateUtils = {
     getAllData: (state) => state &&
         Object.entries(state ?? {}).reduce((acc, [k, v]) => ({ ...acc, [k]: v?.data ?? v }), {}),
-    selectFlowerFormNode: (name) => (state) => _get(state, name),
+    selectFlowerDataNode: (name) => (state) => _get(state, name),
     makeSelectCurrentNextRules: (name) => (state) => {
         const nextRules = _get(state, [name, 'nextRules']);
         const currentNodeId = FlowerStateUtils.makeSelectCurrentNodeId(name)(state);
@@ -42,24 +42,107 @@ const FlowerStateUtils = {
         return _get(subState, ['current']) || startId;
     },
     makeSelectNodeErrors: (name) => (state) => {
-        const form = FlowerStateUtils.selectFlowerFormNode(name)(state);
-        return createFormData(form);
+        const data = FlowerStateUtils.selectFlowerDataNode(name)(state);
+        return generateData(data);
     }
 };
-const createFormData = (form) => {
-    const validationErrors = form && form.errors;
+const generateData = (data) => {
+    const validationErrors = data && data.errors;
     const allErrors = Object.values(validationErrors || {});
     return {
-        isSubmitted: form?.isSubmitted || false,
-        isDirty: Object.values(form?.dirty || {}).some(Boolean) || false,
-        hasFocus: form?.hasFocus,
-        errors: form?.errors,
-        customErrors: form?.customErrors,
-        isValidating: form?.isValidating,
+        isSubmitted: data?.isSubmitted || false,
+        isDirty: Object.values(data?.dirty || {}).some(Boolean) || false,
+        hasFocus: data?.hasFocus,
+        errors: data?.errors,
+        customErrors: data?.customErrors,
+        isValidating: data?.isValidating,
         isValid: allErrors.flat().length === 0
     };
 };
 
+class AbacEngine {
+    constructor(rules = []) {
+        // compile string conditions once
+        this.rules = (rules || [])
+            .map((r) => {
+            let conditionFn = undefined;
+            if (r.condition) {
+                try {
+                    // NOTE: uses new Function -> ensure rules.json is trusted by the app owner
+                    conditionFn = new Function('subject', 'resource', 'action', 'environment', `return (${r.condition});`);
+                }
+                catch (err) {
+                    console.error('ABAC: failed to compile rule condition', r.id, err);
+                }
+            }
+            return { ...r, conditionFn };
+        })
+            .sort((a, b) => (a.priority ?? 100) - (b.priority ?? 100));
+    }
+    decide(ctx) {
+        let anyPermit = false;
+        for (const r of this.rules) {
+            const matchesAction = Array.isArray(r.action)
+                ? r.action.includes(ctx.action)
+                : r.action === ctx.action || r.action === '*';
+            if (!matchesAction)
+                continue;
+            let matches = true;
+            if (r.conditionFn) {
+                try {
+                    matches = !!r.conditionFn(ctx.subject, ctx.resource, ctx.action, ctx.environment);
+                }
+                catch (err) {
+                    matches = false;
+                    console.error(`ABAC: rule ${r.id} threw while evaluating`, err);
+                }
+            }
+            if (!matches)
+                continue;
+            if (r.effect === 'Deny') {
+                // deny-overrides
+                return 'Deny';
+            }
+            if (r.effect === 'Permit') {
+                anyPermit = true;
+            }
+        }
+        return anyPermit ? 'Permit' : 'Deny';
+    }
+    // utility: checks multiple actions and returns those allowed
+    allowedActions(ctxBase, actions) {
+        return actions.filter((a) => this.decide({ ...ctxBase, action: a }) === 'Permit');
+    }
+}
+
+let engine = null;
+let rawRules = null;
+let currentSubject = null;
+function initAbac(rules) {
+    engine = new AbacEngine(rules);
+    rawRules = rules;
+}
+function getAbacEngine() {
+    if (!engine)
+        console.warn('ABAC engine non inizializzato');
+    return engine;
+}
+function getRawRules() {
+    return rawRules;
+}
+function isAbacInitialized() {
+    return engine !== null;
+}
+function setSubject(subject) {
+    currentSubject = subject;
+}
+function getSubject() {
+    return currentSubject;
+}
+function clearSubject() {
+    currentSubject = null;
+}
+
 const EMPTY_STRING_REGEXP = /^\s*$/;
 /**
  * Defines a utility object named rulesMatcherUtils, which contains various helper functions used for processing rules and data in a rule-matching context.
@@ -83,6 +166,11 @@ const rulesMatcherUtils = {
         if (!operators[op]) {
             throw new Error(`Error missing operator:${op}`);
         }
+        if (op === '$can') {
+            const subject = getSubject();
+            const valid = operators['$can'](subject ?? {}, _get(value, 'action'), _get(value, 'resource'));
+            return { valid, name: `${pathWithPrefix}___${name || op}` };
+        }
         const valid = operators[op] && operators[op](valueForKey, valueRef, opt, data);
         return { valid, name: `${pathWithPrefix}___${name || op}` };
     },
@@ -240,6 +328,11 @@ const rulesMatcherUtils = {
  * Defines a set of comparison operators used for matching rules against user input.
  */
 const operators = {
+    $can: (subject, action, resource) => getAbacEngine()?.decide({
+        subject: subject ?? {},
+        action,
+        resource
+    }) === 'Permit',
     $exists: (a, b) => !rulesMatcherUtils.isEmpty(a) === b,
     $eq: (a, b) => a === b,
     $ne: (a, b) => a !== b,
@@ -265,19 +358,19 @@ const operators = {
         .some((c) => c instanceof RegExp ? c.test(a) : new RegExp(c, opt).test(a))
 };
 
-const rulesMatcher = (rules, formValue = {}, apply = true, options) => {
+const rulesMatcher = (rules, dataValue = {}, apply = true, options) => {
     if (!rules)
         return [apply];
     // if (typeof rules !== 'object' && !Array.isArray(rules)) {
     //   throw new Error('Rules accept only array or object');
     // }
     if (typeof rules === 'function') {
-        return [rules(formValue) === apply];
+        return [rules(dataValue) === apply];
     }
     const conditions = Array.isArray(rules)
         ? { $and: rules }
         : rules;
-    const valid = rulesMatcherUtils.checkRule(conditions, formValue, options ?? {});
+    const valid = rulesMatcherUtils.checkRule(conditions, dataValue, options ?? {});
     return [valid === apply];
 };
 
@@ -302,9 +395,6 @@ const flattenRules = (ob) => {
     }
     return result;
 };
-const getRulesExists = (rules) => {
-    return Object.keys(rules).length ? FlowUtils.mapEdge(rules) : undefined;
-};
 const FlowUtils = {
     generateRulesName: (nextRules) => {
         return nextRules.reduce((acc, inc) => {
@@ -361,23 +451,6 @@ const FlowUtils = {
         return res;
     },
     makeRules: (rules) => Object.entries(rules).reduce((acc2, [k, v]) => [...acc2, { nodeId: k, rules: v }], []),
-    // TODO: This function is strictly related to React nodes, could make sense to move it in the flower-react folder
-    generateNodesForFlowerJson: (nodes) => nodes
-        .filter((e) => !!_get(e, 'props.id'))
-        .map((e) => {
-        const rules = FlowUtils.makeRules(e.props.to ?? {});
-        const nextRules = getRulesExists(rules);
-        const children = e.props.data?.children;
-        return {
-            nodeId: e.props.id,
-            nodeType: e.type.displayName || e.props.as || 'FlowerNode',
-            nodeTitle: _get(e.props, 'data.title'),
-            children,
-            nextRules,
-            retain: e.props.retain,
-            disabled: e.props.disabled
-        };
-    }),
     allEqual: (arr, arr2) => arr.length === arr2.length && arr.every((v) => arr2.includes(v)),
     findValidRule: (nextRules, value, prefix) => find(nextRules, (rule) => {
         // fix per evitare di entrare in un nodo senza regole, ma con un name,
@@ -404,7 +477,7 @@ const FlowUtils = {
     })
 };
 
-const FormUtils = {
+const DataUtils = {
     cleanPath: (name, char = '^') => _trimStart(name, char),
     getPath: (idValue) => {
         if (!idValue) {
@@ -418,9 +491,9 @@ const FormUtils = {
             };
         }
         if (idValue.indexOf('^') === 0) {
-            const [formName, ...rest] = FormUtils.cleanPath(idValue).split('.');
+            const [rootName, ...rest] = DataUtils.cleanPath(idValue).split('.');
             return {
-                formName,
+                rootName,
                 path: rest
             };
         }
@@ -435,7 +508,7 @@ const FormUtils = {
  */
 const CoreUtils = {
     ...FlowUtils,
-    ...FormUtils
+    ...DataUtils
 };
 
 const { generateNodes, hasNode, makeObjectRules, generateRulesName, findValidRule } = CoreUtils;
@@ -648,7 +721,7 @@ const FlowerCoreBaseReducers = {
             payload: { name: flowName, node: nextNumberNode }
         });
     },
-    prev: (state, { payload }) => {
+    back: (state, { payload }) => {
         const { name, flowName } = payload;
         FlowerCoreBaseReducers.historyPop(state, {
             type: 'historyPop',
@@ -672,75 +745,65 @@ const FlowerCoreBaseReducers = {
 };
 
 const { getPath } = CoreUtils;
-/**
- * formName => FlowerForm
- * initialData => FlowerForm
- * fieldName => FlowerField
- * fieldValue => FlowerField
- * errors => FlowerField
- * customErrors => FlowerField
- * fieldTouched => FlowerField
- * fieldDirty => FlowerField
- * fieldHasFocus => FlowerField
- */
 const FlowerCoreDataReducers = {
-    setFormTouched: (state, { payload }) => {
-        if (!_get(state, typeof payload === 'string' ? payload : payload.formName)) {
+    setFormSubmitted: (state, { payload }) => {
+        const rootPath = typeof payload === 'string' ? payload : payload.rootName;
+        if (!_get(state, [rootPath])) {
             return state;
         }
-        _set(state, typeof payload === 'string' ? payload : payload.formName, true);
+        _set(state, [rootPath, 'isSubmitted'], true);
         return state;
     },
-    formAddCustomErrors: (state, { payload }) => {
-        _set(state, [payload.formName, 'customErrors', payload.id], payload.errors);
+    addCustomDataErrors: (state, { payload }) => {
+        _set(state, [payload.rootName, 'customErrors', payload.id], payload.errors);
     },
-    formAddErrors: (state, { payload }) => {
-        _set(state, [payload.formName, 'errors', payload.id], payload.errors);
+    addDataErrors: (state, { payload }) => {
+        _set(state, [payload.rootName, 'errors', payload.id], payload.errors);
     },
-    formRemoveErrors: (state, { payload }) => {
-        _unset(state, [payload.formName, 'errors', payload.id]);
-        _unset(state, [payload.formName, 'customErrors', payload.id]);
-        _unset(state, [payload.formName, 'isValidating']);
+    removeDataErrors: (state, { payload }) => {
+        _unset(state, [payload.rootName, 'errors', payload.id]);
+        _unset(state, [payload.rootName, 'customErrors', payload.id]);
+        _unset(state, [payload.rootName, 'isValidating']);
     },
-    formFieldTouch: (state, { payload }) => {
-        _set(state, [payload.formName, 'touches', payload.id], payload.touched);
+    fieldTouch: (state, { payload }) => {
+        _set(state, [payload.rootName, 'touches', payload.id], payload.touched);
     },
-    formFieldDirty: (state, { payload }) => {
-        _set(state, [payload.formName, 'dirty', payload.id], payload.dirty);
+    fieldDirty: (state, { payload }) => {
+        _set(state, [payload.rootName, 'dirty', payload.id], payload.dirty);
     },
-    formFieldFocus: (state, { payload }) => {
+    fieldFocus: (state, { payload }) => {
         if (!payload.focused) {
-            _unset(state, [payload.formName, 'hasFocus']);
+            _unset(state, [payload.rootName, 'hasFocus']);
             return;
         }
-        _set(state, [payload.formName, 'hasFocus'], payload.id);
+        _set(state, [payload.rootName, 'hasFocus'], payload.id);
     },
     addData: (state, { payload }) => {
-        const prevData = _get(state, [payload.formName, 'data'], {});
-        _set(state, [payload.formName, 'data'], { ...prevData, ...payload.value });
+        const prevData = _get(state, [payload.rootName, 'data'], {});
+        _set(state, [payload.rootName, 'data'], { ...prevData, ...payload.value });
     },
     addDataByPath: (state, { payload }) => {
         const { path: newpath } = getPath(payload.id);
         if (payload.id && payload.id.length) {
-            _set(state, [payload.formName, 'data', ...newpath], payload.value);
+            _set(state, [payload.rootName, 'data', ...newpath], payload.value);
             if (payload && payload.dirty) {
-                _set(state, [payload.formName, 'dirty', payload.id], payload.dirty);
+                _set(state, [payload.rootName, 'dirty', payload.id], payload.dirty);
             }
         }
     },
     // TODO usato al momento solo il devtool
     replaceData: /* istanbul ignore next */ (state, { payload }) => {
         /* istanbul ignore next */
-        _set(state, [payload.formName, 'data'], payload.value);
+        _set(state, [payload.rootName, 'data'], payload.value);
     },
     unsetData: (state, { payload }) => {
-        _unset(state, [payload.formName, 'data', ...payload.id]);
+        _unset(state, [payload.rootName, 'data', ...payload.id]);
     },
-    setFormIsValidating: (state, { payload }) => {
-        _set(state, [payload.formName, 'isValidating'], payload.isValidating);
+    setIsDataValidating: (state, { payload }) => {
+        _set(state, [payload.rootName, 'isValidating'], payload.isValidating);
     },
-    resetForm: (state, { payload: { formName, initialData } }) => {
-        const touchedFields = _get(state, [formName, 'errors'], {});
+    resetData: (state, { payload: { rootName, initialData } }) => {
+        const touchedFields = _get(state, [rootName, 'errors'], {});
         const newStateData = initialData
             ? Object.keys(touchedFields).reduce((acc, key) => {
                 const { path } = getPath(key);
@@ -749,13 +812,13 @@ const FlowerCoreDataReducers = {
                 return acc;
             }, {})
             : {};
-        _set(state, [formName, 'data'], newStateData);
-        _unset(state, [formName, 'touches']);
-        _unset(state, [formName, 'dirty']);
-        _unset(state, [formName, 'isSubmitted']);
+        _set(state, [rootName, 'data'], newStateData);
+        _unset(state, [rootName, 'touches']);
+        _unset(state, [rootName, 'dirty']);
+        _unset(state, [rootName, 'isSubmitted']);
     },
-    initForm: (state, { payload: { formName, initialData } }) => {
-        _set(state, [formName, 'data'], initialData);
+    initData: (state, { payload: { rootName, initialData } }) => {
+        _set(state, [rootName, 'data'], initialData);
     }
 };
 
@@ -764,8 +827,6 @@ const FlowerCoreReducers = { ...FlowerCoreBaseReducers, ...FlowerCoreDataReducer
 const FlowerCoreStateBaseSelectors = {
     selectGlobal: (state) => state && state[REDUCER_NAME.FLOWER_FLOW],
     selectFlower: (name) => (state) => _get(state, [name]),
-    // selectFlowerFormNode: (id) => (state) =>
-    //   _get(state, [REDUCER_NAME.FLOWER_DATA, id]),
     selectFlowerHistory: (flower) => _get(flower, ['history'], []),
     makeSelectNodesIds: (flower) => _get(flower, ['nodes']),
     makeSelectStartNodeId: (flower) => _get(flower, ['startId']),
@@ -794,24 +855,24 @@ const FlowerCoreStateBaseSelectors = {
 
 const FlowerCoreStateDataSelectors = {
     selectGlobalReducerByName: (name) => (state) => state[name] ?? state[REDUCER_NAME.FLOWER_DATA][name],
-    selectGlobalForm: (state) => {
+    selectGlobalData: (state) => {
         return state && state[REDUCER_NAME.FLOWER_DATA];
     },
     // getDataByFlow: (flower) => _get(flower, 'data') ?? {},
     getDataFromState: (id) => (data) => (id === '*' ? data : _get(data, id)),
-    makeSelectNodeFormSubmitted: (form) => form && form.isSubmitted,
-    makeSelectNodeFormFieldTouched: (id) => (form) => form && form.touches && form.touches[id],
-    makeSelectNodeFormFieldFocused: (id) => (form) => {
-        return form && form.hasFocus === id ? id : undefined;
-    },
-    makeSelectNodeFormFieldDirty: (id) => (form) => form && form.dirty && form.dirty[id],
-    makeSelectNodeErrors: createFormData,
-    makeSelectFieldError: (name, id, validate) => (data, form) => {
-        const customErrors = Object.entries((form && form.customErrors) || {})
+    makeSelectNodeDataSubmitted: (data) => data && data.isSubmitted,
+    makeSelectNodeDataFieldTouched: (id) => (data) => data && data.touches && data.touches[id],
+    makeSelectNodeDataFieldFocused: (id) => (data) => {
+        return data && data.hasFocus === id ? id : undefined;
+    },
+    makeSelectNodeDataFieldDirty: (id) => (data) => data && data.dirty && data.dirty[id],
+    makeSelectNodeErrors: generateData,
+    makeSelectFieldError: (name, id, validate) => (globalData, data) => {
+        const customErrors = Object.entries((data && data.customErrors) || {})
             .filter(([k]) => k === id)
             .map(([, v]) => v)
             .flat();
-        if (!validate || !data)
+        if (!validate || !globalData)
             return [];
         const errors = validate.filter((rule) => {
             if (!rule)
@@ -819,7 +880,7 @@ const FlowerCoreStateDataSelectors = {
             if (!rule.rules)
                 return true;
             const transformSelf = CoreUtils.mapKeysDeepLodash(rule.rules, (v, key) => key === '$self' ? id : key);
-            const [hasError] = rulesMatcher(transformSelf, data, false, {
+            const [hasError] = rulesMatcher(transformSelf, globalData, false, {
                 prefix: name
             });
             return hasError;
@@ -827,8 +888,8 @@ const FlowerCoreStateDataSelectors = {
         const result = errors.map((r) => (r && r.message) || 'error');
         return [...customErrors, ...(result.length === 0 ? [] : result)];
     },
-    selectorRulesDisabled: (id, rules, keys, flowName, value) => (data, form) => {
-        const newState = { ...data, ...value, $form: form };
+    selectorRulesDisabled: (id, rules, keys, flowName, value) => (globalData, data) => {
+        const newState = { ...globalData, ...value, $data: data, $form: data };
         const state = Object.assign(newState, id ? { $self: _get(newState, [flowName, ...id.split('.')]) } : {});
         if (!rules)
             return false;
@@ -853,4 +914,4 @@ const FlowerCoreStateSelectors = {
     ...FlowerCoreStateDataSelectors
 };
 
-export { CoreUtils, Emitter, FlowUtils, FlowerCoreBaseReducers, FlowerCoreDataReducers, FlowerCoreReducers, FlowerCoreStateBaseSelectors, FlowerCoreStateDataSelectors, FlowerCoreStateSelectors, FlowerStateUtils, FormUtils, REDUCER_NAME, createFormData, devtoolState, flattenRules, rulesMatcher, rulesMatcherUtils };
+export { AbacEngine, CoreUtils, DataUtils, Emitter, FlowUtils, FlowerCoreBaseReducers, FlowerCoreDataReducers, FlowerCoreReducers, FlowerCoreStateBaseSelectors, FlowerCoreStateDataSelectors, FlowerCoreStateSelectors, FlowerStateUtils, REDUCER_NAME, clearSubject, devtoolState, flattenRules, generateData, getAbacEngine, getRawRules, getSubject, initAbac, isAbacInitialized, rulesMatcher, rulesMatcherUtils, setSubject };

package/dist/src/ABAC/abacEngine.d.ts

@@ -0,0 +1,32 @@
+export type Action = string;
+export type Subject = Record<string, any>;
+export type Resource = Record<string, any>;
+export type Environment = Record<string, any>;
+export type AbacCtx = {
+    subject: Subject;
+    resource?: Resource;
+    action: Action;
+    environment?: Environment;
+};
+export type RuleInput = {
+    id: string;
+    description?: string;
+    effect: 'Permit' | 'Deny';
+    priority?: number;
+    action?: string | string[];
+    /**
+     * condition: string JS expression that returns boolean.
+     * It can reference `subject`, `resource`, `action`, `environment`.
+     * Example: "action === 'read' && (!resource.confidential || resource.ownerID === subject.id)"
+     */
+    condition?: string;
+};
+export type CompiledRule = RuleInput & {
+    conditionFn?: (subject: Subject, resource?: Resource, action?: Action, environment?: Environment) => boolean;
+};
+export declare class AbacEngine {
+    private rules;
+    constructor(rules?: RuleInput[]);
+    decide(ctx: AbacCtx): 'Permit' | 'Deny';
+    allowedActions(ctxBase: Omit<AbacCtx, 'action'>, actions: Action[]): string[];
+}

package/dist/src/ABAC/abacSingleton.d.ts

@@ -0,0 +1,8 @@
+import { AbacEngine, RuleInput, Subject } from './abacEngine';
+export declare function initAbac(rules: RuleInput[]): void;
+export declare function getAbacEngine(): AbacEngine | null;
+export declare function getRawRules(): RuleInput[] | null;
+export declare function isAbacInitialized(): boolean;
+export declare function setSubject(subject: Subject): void;
+export declare function getSubject(): Subject | null;
+export declare function clearSubject(): void;

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

@@ -0,0 +1,2 @@
+export * from './abacEngine';
+export * from './abacSingleton';

package/dist/src/index.d.ts

@@ -3,4 +3,5 @@ export * from './constants';
 export * from './utils';
 export * from './rules-matcher';
 export * from './state-manager';
+export * from './ABAC';
 export type * from './interfaces';

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

@@ -1,5 +1,6 @@
 export declare enum RulesOperators {
     $exists = "$exists",
+    $can = "$can",
     $eq = "$eq",
     $ne = "$ne",
     $gt = "$gt",
@@ -26,6 +27,15 @@ export type Edge<T = object> = {
         rules: RulesObject<T>;
     };
 };
+export type NodeConfig = {
+    nodeId: string | undefined;
+    nodeType: string;
+    nodeTitle: string;
+    children: Node['children'];
+    nextRules: ReturnType<MapEdge> | undefined;
+    retain: boolean;
+    disabled: boolean;
+};
 export type Node = {
     nodeId: string | undefined;
     nodeType: string;
@@ -76,7 +86,7 @@ export type RulesObject<T> = RulesValuesType<T> | {
 export type CleanPath = (name: string, char?: string) => string;
 export type GetPath = (idValue?: string) => {
     path: string | string[];
-    formName?: string;
+    rootName?: string;
 };
 export type AllEqual = (...args: Array<number | string | boolean>[]) => boolean;
 export type FindValidRule<T = Rules<RulesObject<any>>> = (nextRules: {
@@ -93,22 +103,12 @@ 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[]) => {
+export type MakeObjectRules = (nodes: NodeConfig[]) => {
     [x: string]: Node['nextRules'];
 };
-export type GenerateNodes = (nodes: Node[]) => {
-    [x: string]: Omit<Node, 'nextRules'>;
+export type GenerateNodes = (nodes: NodeConfig[]) => {
+    [x: string]: Partial<Node>;
 };
 export type MapKeysDeepLodash = (obj: Record<string, any>, cb: (...args: any) => any, isRecursive?: boolean) => Record<string, any>;
 export type GenerateRulesName = (nextRules: RulesWithName[]) => {
@@ -176,13 +176,6 @@ export interface FlowUtilitiesFunctions {
      * @returns
      */
     makeRules: MakeRules;
-    /**
-     * Generates nodes for a flower JSON structure, extracting rules and other properties.
-     * @param nodes
-     *
-     * @returns
-     */
-    generateNodesForFlowerJson: GenerateNodesForFlowerJson;
     /**
      * Checks if two arrays are equal in length and have the same elements.
      * @param arr
@@ -201,7 +194,7 @@ export interface FlowUtilitiesFunctions {
      */
     findValidRule: FindValidRule;
 }
-export interface FormUtilitiesFunctions {
+export interface DataUtilitiesFunctions {
     /**
      * Removes specified characters from the beginning of a string (default char -> '^').
      * @param name
@@ -218,6 +211,6 @@ export interface FormUtilitiesFunctions {
      */
     getPath: GetPath;
 }
-export interface CoreUtilitiesFunctions extends FormUtilitiesFunctions, FlowUtilitiesFunctions {
+export interface CoreUtilitiesFunctions extends DataUtilitiesFunctions, FlowUtilitiesFunctions {
 }
 export {};