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

package/dist/index.cjs.js

@@ -23,864 +23,840 @@ var flat = require('flat');
 const Emitter = new tinyEmitter.TinyEmitter();
 
 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.
+ */
 const rulesMatcherUtils = {
-  isNumber: el => {
-    const num = String(el);
-    return !!num.match(/(^-?|^\d+\.)\d+$/);
-  },
-  rule: (val, data, options) => {
-    const {
-      prefix
-    } = options || {};
-    const path = Object.keys(val)[0];
-    const valueBlock = val;
-    const pathWithPrefix = rulesMatcherUtils.getPath(path, prefix);
-    const valueForKey = _get(data, pathWithPrefix, undefined);
-    const {
-      name
-    } = _get(valueBlock, [path], {}) || {};
-    const {
-      op,
-      value,
-      opt
-    } = rulesMatcherUtils.getDefaultRule(valueBlock[path]);
-    const valueRef = value && String(value).indexOf('$ref:') === 0 ? _get(data, rulesMatcherUtils.getPath(value.replace('$ref:', ''), prefix), undefined) : value;
-    if (!operators[op]) {
-      throw new Error(`Error missing operator:${op}`);
-    }
-    const valid = operators[op] && operators[op](valueForKey, valueRef, opt, data);
-    return {
-      valid,
-      name: `${pathWithPrefix}___${name || op}`
-    };
-  },
-  getKey: (block, keys, options) => {
-    if (Object.prototype.hasOwnProperty.call(block, '$and')) {
-      return block.$and.map(item => rulesMatcherUtils.getKey(item, keys, options));
-    }
-    if (Object.prototype.hasOwnProperty.call(block, '$or')) {
-      return block.$or.map(item => rulesMatcherUtils.getKey(item, keys, options));
-    }
-    const {
-      prefix
-    } = options || {};
-    const path = Object.keys(block)[0];
-    const valueBlock = block;
-    const res = rulesMatcherUtils.getPath(path, prefix);
-    const {
-      value
-    } = rulesMatcherUtils.getDefaultRule(valueBlock[path]);
-    if (value && String(value).indexOf('$ref:') === 0) {
-      keys[rulesMatcherUtils.getPath(value.replace('$ref:', ''), prefix)] = true;
-    }
-    return keys[res] = true;
-  },
-  isDate: v => v instanceof Date,
-  isDefined: v => v !== null && v !== undefined,
-  isObject: v => v === Object(v),
-  isFunction: v => typeof v === 'function',
-  isString: v => typeof v === 'string',
-  getDefaultStringValue: value => {
-    switch (value) {
-      case '$required':
-        return {
-          op: '$exists',
-          value: true
-        };
-      case '$exists':
-        return {
-          op: '$exists',
-          value: true
-        };
-      default:
-        return {
-          op: '$eq',
-          value
-        };
-    }
-  },
-  getTypeOf: value => Array.isArray(value) ? 'array' : rulesMatcherUtils.isNumber(value) ? 'number' : value === null ? null : typeof value,
-  getDefaultRule: value => {
-    const valueType = rulesMatcherUtils.getTypeOf(value);
-    switch (valueType) {
-      case 'number':
-        return {
-          op: '$eq',
-          value
-        };
-      case 'string':
-        return rulesMatcherUtils.getDefaultStringValue(value);
-      case 'boolean':
-        return {
-          op: '$exists',
-          value
-        };
-      case 'array':
-        return {
-          op: '$in',
-          value
-        };
-      case 'object':
-        return {
-          ...value,
-          op: value.op || Object.keys(value)[0],
-          value: value.value || value[Object.keys(value)[0]]
-        };
-      default:
-        return {
-          op: '$eq',
-          value
-        };
-    }
-  },
-  isEmpty: value => {
-    if (!rulesMatcherUtils.isDefined(value)) {
-      return true;
-    }
-    if (rulesMatcherUtils.isFunction(value)) {
-      return false;
-    }
-    if (rulesMatcherUtils.isString(value)) {
-      return EMPTY_STRING_REGEXP.test(value);
-    }
-    if (Array.isArray(value)) {
-      return value.length === 0;
-    }
-    if (rulesMatcherUtils.isDate(value)) {
-      return false;
-    }
-    let attr;
-    if (rulesMatcherUtils.isObject(value)) {
-      for (attr in value) {
+    isNumber: (el) => {
+        const num = String(el);
+        return !!num.match(/(^-?|^\d+\.)\d+$/);
+    },
+    rule: (val, data, options) => {
+        const { prefix } = options || {};
+        const path = Object.keys(val)[0];
+        const valueBlock = val;
+        const pathWithPrefix = rulesMatcherUtils.getPath(path, prefix);
+        const valueForKey = _get(data, pathWithPrefix, undefined);
+        const { name } = _get(valueBlock, [path], {}) || {};
+        const { op, value, opt } = rulesMatcherUtils.getDefaultRule(valueBlock[path]);
+        const valueRef = value && String(value).indexOf('$ref:') === 0
+            ? _get(data, rulesMatcherUtils.getPath(value.replace('$ref:', ''), prefix), undefined)
+            : value;
+        if (!operators[op]) {
+            throw new Error(`Error missing operator:${op}`);
+        }
+        const valid = operators[op] && operators[op](valueForKey, valueRef, opt, data);
+        return { valid, name: `${pathWithPrefix}___${name || op}` };
+    },
+    getKey: (block, keys, options) => {
+        if (Object.prototype.hasOwnProperty.call(block, '$and')) {
+            return block.$and.map((item) => rulesMatcherUtils.getKey(item, keys, options));
+        }
+        if (Object.prototype.hasOwnProperty.call(block, '$or')) {
+            return block.$or.map((item) => rulesMatcherUtils.getKey(item, keys, options));
+        }
+        const { prefix } = options || {};
+        const path = Object.keys(block)[0];
+        const valueBlock = block;
+        const res = rulesMatcherUtils.getPath(path, prefix);
+        const { value } = rulesMatcherUtils.getDefaultRule(valueBlock[path]);
+        if (value && String(value).indexOf('$ref:') === 0) {
+            keys[rulesMatcherUtils.getPath(value.replace('$ref:', ''), prefix)] = true;
+        }
+        return (keys[res] = true);
+    },
+    isDate: (v) => v instanceof Date,
+    isDefined: (v) => v !== null && v !== undefined,
+    isObject: (v) => v === Object(v),
+    isFunction: (v) => typeof v === 'function',
+    isString: (v) => typeof v === 'string',
+    getDefaultStringValue: (value) => {
+        switch (value) {
+            case '$required':
+                return { op: '$exists', value: true };
+            case '$exists':
+                return { op: '$exists', value: true };
+            default:
+                return { op: '$eq', value };
+        }
+    },
+    getTypeOf: (value) => Array.isArray(value)
+        ? 'array'
+        : rulesMatcherUtils.isNumber(value)
+            ? 'number'
+            : value === null
+                ? null
+                : typeof value,
+    getDefaultRule: (value) => {
+        const valueType = rulesMatcherUtils.getTypeOf(value);
+        switch (valueType) {
+            case 'number':
+                return { op: '$eq', value };
+            case 'string':
+                return rulesMatcherUtils.getDefaultStringValue(value);
+            case 'boolean':
+                return { op: '$exists', value };
+            case 'array':
+                return { op: '$in', value };
+            case 'object':
+                return {
+                    ...value,
+                    op: value.op || Object.keys(value)[0],
+                    value: value.value || value[Object.keys(value)[0]]
+                };
+            default:
+                return { op: '$eq', value };
+        }
+    },
+    isEmpty: (value) => {
+        // Null and undefined are empty
+        if (!rulesMatcherUtils.isDefined(value)) {
+            return true;
+        }
+        // functions are non empty
+        if (rulesMatcherUtils.isFunction(value)) {
+            return false;
+        }
+        /*   if (isBool(value)) {
+            return false;
+          }
+         */
+        // Whitespace only strings are empty
+        if (rulesMatcherUtils.isString(value)) {
+            return EMPTY_STRING_REGEXP.test(value);
+        }
+        // For arrays we use the length property
+        if (Array.isArray(value)) {
+            return value.length === 0;
+        }
+        // Dates have no attributes but aren't empty
+        if (rulesMatcherUtils.isDate(value)) {
+            return false;
+        }
+        // If we find at least one property we consider it non empty
+        let attr;
+        if (rulesMatcherUtils.isObject(value)) {
+            for (attr in value) {
+                return false;
+            }
+            return true;
+        }
         return false;
-      }
-      return true;
-    }
-    return false;
-  },
-  forceArray: a => Array.isArray(a) ? a : [a],
-  getPath: (path, prefix) => {
-    if (path.indexOf('^') === 0) {
-      return _trimStart(path, '^');
-    }
-    if (path.indexOf('$') === 0) {
-      return path;
-    }
-    return prefix ? `${prefix}.${path}` : path;
-  },
-  forceNumber: el => {
-    if (Array.isArray(el)) {
-      return el.length;
-    }
-    if (rulesMatcherUtils.isNumber(String(el))) {
-      return parseFloat(String(el));
-    }
-    return 0;
-  },
-  checkRule: (block, data, options) => {
-    if (!Array.isArray(block) && block && Object.prototype.hasOwnProperty.call(block, '$and')) {
-      if (block && block['$and'] && !block['$and'].length) return true;
-      return block['$and'].every(item => rulesMatcherUtils.checkRule(item, data, options));
-    }
-    if (!Array.isArray(block) && block && Object.prototype.hasOwnProperty.call(block, '$or')) {
-      if (block && block['$or'] && !block['$or'].length) return true;
-      return block['$or'].some(item => rulesMatcherUtils.checkRule(item, data, options));
+    },
+    forceArray: (a) => (Array.isArray(a) ? a : [a]),
+    getPath: (path, prefix) => {
+        if (path.indexOf('^') === 0) {
+            return _trimStart(path, '^');
+        }
+        // da verificare se è ancora utilizzato
+        if (path.indexOf('$') === 0) {
+            return path;
+        }
+        return prefix ? `${prefix}.${path}` : path;
+    },
+    // TODO BUG NUMERI CON LETTERE 1asdas o solo
+    forceNumber: (el) => {
+        if (Array.isArray(el)) {
+            return el.length;
+        }
+        if (rulesMatcherUtils.isNumber(String(el))) {
+            return parseFloat(String(el));
+        }
+        // fix perchè un valore false < 1 è true, quindi sbagliato, mentre un valore undefined < 1 è false
+        return 0;
+    },
+    checkRule: (block, data, options) => {
+        if (!Array.isArray(block) &&
+            block &&
+            Object.prototype.hasOwnProperty.call(block, '$and')) {
+            if (block && block['$and'] && !block['$and'].length)
+                return true;
+            return block['$and'].every((item) => rulesMatcherUtils.checkRule(item, data, options));
+        }
+        if (!Array.isArray(block) &&
+            block &&
+            Object.prototype.hasOwnProperty.call(block, '$or')) {
+            if (block && block['$or'] && !block['$or'].length)
+                return true;
+            return block['$or'].some((item) => rulesMatcherUtils.checkRule(item, data, options));
+        }
+        const res = rulesMatcherUtils.rule(block, data, options);
+        return res.valid;
+    },
+    getKeys: (rules, options) => {
+        if (!rules)
+            return null;
+        if (typeof rules == 'function')
+            return [];
+        if (!rulesMatcherUtils
+            .forceArray(rules)
+            .every((r) => rulesMatcherUtils.isObject(r)))
+            return null;
+        const keys = {};
+        const conditions = Array.isArray(rules) ? { $and: rules } : rules;
+        rulesMatcherUtils.getKey(conditions, keys, options ?? {});
+        return Object.keys(keys);
     }
-    const res = rulesMatcherUtils.rule(block, data, options);
-    return res.valid;
-  },
-  getKeys: (rules, options) => {
-    if (!rules) return null;
-    if (typeof rules == 'function') return [];
-    if (!rulesMatcherUtils.forceArray(rules).every(r => rulesMatcherUtils.isObject(r))) return null;
-    const keys = {};
-    const conditions = Array.isArray(rules) ? {
-      $and: rules
-    } : rules;
-    rulesMatcherUtils.getKey(conditions, keys, options ?? {});
-    return Object.keys(keys);
-  }
 };
+/**
+ * Defines a set of comparison operators used for matching rules against user input.
+ */
 const operators = {
-  $exists: (a, b) => !rulesMatcherUtils.isEmpty(a) === b,
-  $eq: (a, b) => a === b,
-  $ne: (a, b) => a !== b,
-  $gt: (a, b) => rulesMatcherUtils.forceNumber(a) > parseFloat(b),
-  $gte: (a, b) => rulesMatcherUtils.forceNumber(a) >= parseFloat(b),
-  $lt: (a, b) => rulesMatcherUtils.forceNumber(a) < parseFloat(b),
-  $lte: (a, b) => rulesMatcherUtils.forceNumber(a) <= parseFloat(b),
-  $strGt: (a, b) => String(a || '').length > parseFloat(b),
-  $strGte: (a, b) => String(a || '').length >= parseFloat(b),
-  $strLt: (a, b) => String(a || '').length < parseFloat(b),
-  $strLte: (a, b) => String(a || '').length <= parseFloat(b),
-  $in: (a, b) => rulesMatcherUtils.forceArray(b).some(c => _intersection(rulesMatcherUtils.forceArray(a), rulesMatcherUtils.forceArray(c)).length),
-  $nin: (a, b) => !rulesMatcherUtils.forceArray(b).some(c => _intersection(rulesMatcherUtils.forceArray(a), rulesMatcherUtils.forceArray(c)).length),
-  $all: (a, b) => rulesMatcherUtils.forceArray(b).every(c => _intersection(rulesMatcherUtils.forceArray(a), rulesMatcherUtils.forceArray(c)).length),
-  $regex: (a, b, opt) => rulesMatcherUtils.forceArray(b).some(c => c instanceof RegExp ? c.test(a) : new RegExp(c, opt).test(a))
+    $exists: (a, b) => !rulesMatcherUtils.isEmpty(a) === b,
+    $eq: (a, b) => a === b,
+    $ne: (a, b) => a !== b,
+    $gt: (a, b) => rulesMatcherUtils.forceNumber(a) > parseFloat(b),
+    $gte: (a, b) => rulesMatcherUtils.forceNumber(a) >= parseFloat(b),
+    $lt: (a, b) => rulesMatcherUtils.forceNumber(a) < parseFloat(b),
+    $lte: (a, b) => rulesMatcherUtils.forceNumber(a) <= parseFloat(b),
+    $strGt: (a, b) => String(a || '').length > parseFloat(b),
+    $strGte: (a, b) => String(a || '').length >= parseFloat(b),
+    $strLt: (a, b) => String(a || '').length < parseFloat(b),
+    $strLte: (a, b) => String(a || '').length <= parseFloat(b),
+    $in: (a, b) => rulesMatcherUtils
+        .forceArray(b)
+        .some((c) => _intersection(rulesMatcherUtils.forceArray(a), rulesMatcherUtils.forceArray(c)).length),
+    $nin: (a, b) => !rulesMatcherUtils
+        .forceArray(b)
+        .some((c) => _intersection(rulesMatcherUtils.forceArray(a), rulesMatcherUtils.forceArray(c)).length),
+    $all: (a, b) => rulesMatcherUtils
+        .forceArray(b)
+        .every((c) => _intersection(rulesMatcherUtils.forceArray(a), rulesMatcherUtils.forceArray(c)).length),
+    $regex: (a, b, opt) => rulesMatcherUtils
+        .forceArray(b)
+        .some((c) => c instanceof RegExp ? c.test(a) : new RegExp(c, opt).test(a))
 };
 
 const rulesMatcher = (rules, formValue = {}, apply = true, options) => {
-  if (!rules) return [apply];
-  if (typeof rules === 'function') {
-    return [rules(formValue) === apply];
-  }
-  const conditions = Array.isArray(rules) ? {
-    $and: rules
-  } : rules;
-  const valid = rulesMatcherUtils.checkRule(conditions, formValue, options ?? {});
-  return [valid === apply];
+    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];
+    }
+    const conditions = Array.isArray(rules)
+        ? { $and: rules }
+        : rules;
+    const valid = rulesMatcherUtils.checkRule(conditions, formValue, options ?? {});
+    return [valid === apply];
 };
 const MatchRules = {
-  rulesMatcher,
-  utils: rulesMatcherUtils
+    rulesMatcher,
+    utils: rulesMatcherUtils
 };
 
-const flattenRules = ob => {
-  const result = {};
-  for (const i in ob) {
-    if (ob[i] === null) {
-      result[i] = null;
-    }
-    if (typeof ob[i] === 'object' && !Array.isArray(ob[i]) || Array.isArray(ob[i]) && typeof ob[i][0] === 'object') {
-      const temp = flattenRules(ob[i]);
-      for (const j in temp) {
-        result[i + '*' + j] = temp[j];
-      }
-    } else {
-      result[i] = ob[i];
+/* eslint-disable no-useless-escape */
+// TODO align this set of functions to selectors and reducers functions
+const flattenRules = (ob) => {
+    const result = {};
+    for (const i in ob) {
+        if (ob[i] === null) {
+            result[i] = null;
+        }
+        if ((typeof ob[i] === 'object' && !Array.isArray(ob[i])) ||
+            (Array.isArray(ob[i]) && typeof ob[i][0] === 'object')) {
+            const temp = flattenRules(ob[i]);
+            for (const j in temp) {
+                result[i + '*' + j] = temp[j];
+            }
+        }
+        else {
+            result[i] = ob[i];
+        }
     }
-  }
-  return result;
+    return result;
 };
-const getRulesExists = rules => {
-  return Object.keys(rules).length ? CoreUtils.mapEdge(rules) : undefined;
+// export const searchEmptyKeyRecursively = <T extends object>(
+//   _key: "$and" | "$or",
+//   obj: T
+// ) => {
+//   if (
+//     isEmpty(obj) ||
+//     typeof obj !== "object" ||
+//     Object.keys(obj).length === 0
+//   ) {
+//     return true;
+//   }
+//   if (Object.keys(obj).includes(_key)) {
+//     if (obj[_key] && obj[_key].length === 0) return true;
+//     return Object.keys(obj).map((key) =>
+//       searchEmptyKeyRecursively(_key, obj[key])
+//     );
+//   }
+//   return Object.keys(obj)
+//     .map((key) => searchEmptyKeyRecursively(_key, obj[key]))
+//     .every((v) => v === true);
+// };
+const getRulesExists = (rules) => {
+    return Object.keys(rules).length ? CoreUtils.mapEdge(rules) : undefined;
 };
+/**
+ * Defines a collection of utility functions for processing rules, nodes and graph-like structures
+ */
 const CoreUtils = {
-  generateRulesName: nextRules => {
-    const a = nextRules.reduce((acc, inc) => {
-      const n = typeof inc.rules === 'string' ? inc.rules || '__ERROR_NAME__' : inc.rules?.name || '__ERROR_NAME__';
-      return {
-        ...acc,
-        [n]: inc.nodeId
-      };
-    }, {});
-    return a;
-  },
-  mapKeysDeepLodash: (obj, cb, isRecursive) => {
-    if (!obj && !isRecursive) {
-      return {};
-    }
-    if (!isRecursive) {
-      if (typeof obj === 'string' || typeof obj === 'number' || typeof obj === 'boolean') {
-        return {};
-      }
-    }
-    if (Array.isArray(obj)) {
-      return obj.map(item => CoreUtils.mapKeysDeepLodash(item, cb, true));
-    }
-    if (!isPlainObject(obj)) {
-      return obj;
-    }
-    const result = mapKeys(obj, cb);
-    return mapValues(result, value => CoreUtils.mapKeysDeepLodash(value, cb, true));
-  },
-  generateNodes: nodes => keyBy(nodes.map(s => omit(s, 'nextRules')), 'nodeId'),
-  makeObjectRules: nodes => nodes.reduce((acc, inc) => ({
-    ...acc,
-    [inc.nodeId]: inc.nextRules
-  }), {}),
-  hasNode: (state, name, node) => has(state, [name, 'nodes', node]),
-  isEmptyRules: rules => {
-    if (isEmpty(rules)) return true;
-    if (isEmpty(_get(rules, 'rules'))) return true;
-    if (Object.keys(flattenRules(rules)).every(key => key.endsWith('$and') || key.endsWith('$or'))) {
-      return true;
-    }
-    return false;
-  },
-  mapEdge: nextNode => {
-    const res = nextNode.sort((a, b) => {
-      const x = CoreUtils.isEmptyRules(a.rules);
-      const y = CoreUtils.isEmptyRules(b.rules);
-      return Number(x) - Number(y);
-    });
-    return res;
-  },
-  makeRules: rules => Object.entries(rules).reduce((acc2, [k, v]) => [...acc2, {
-    nodeId: k,
-    rules: v
-  }], []),
-  generateNodesForFlowerJson: nodes => nodes.filter(e => !!_get(e, 'props.id')).map(e => {
-    const rules = CoreUtils.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
-    };
-  }),
-  cleanPath: (name, char = '^') => _trimStart(name, char),
-  getPath: idValue => {
-    if (!idValue) {
-      return {
-        path: []
-      };
-    }
-    if (idValue === '*') {
-      return {
-        path: '*'
-      };
-    }
-    if (idValue.indexOf('^') === 0) {
-      const [flowNameFromPath, ...rest] = CoreUtils.cleanPath(idValue).split('.');
-      return {
-        flowNameFromPath,
-        path: rest
-      };
-    }
-    return {
-      path: idValue.split('.')
-    };
-  },
-  allEqual: (arr, arr2) => arr.length === arr2.length && arr.every(v => arr2.includes(v)),
-  findValidRule: (nextRules, value, prefix) => find(nextRules, rule => {
-    if (typeof rule.rules === 'string') {
-      return false;
-    }
-    if (typeof rule.rules === 'function') {
-      return rule.rules(value);
-    }
-    if (rule.rules === null) {
-      return true;
-    }
-    if (typeof rule.rules?.rules === 'undefined') {
-      return false;
-    }
-    if (typeof rule.rules.rules === 'string') {
-      return false;
-    }
-    const [valid] = MatchRules.rulesMatcher(rule.rules.rules, value, true, {
-      prefix
-    });
-    return valid;
-  })
+    generateRulesName: (nextRules) => {
+        const a = nextRules.reduce((acc, inc) => {
+            const n = typeof inc.rules === 'string'
+                ? inc.rules || '__ERROR_NAME__'
+                : inc.rules?.name || '__ERROR_NAME__';
+            return {
+                ...acc,
+                [n]: inc.nodeId
+            };
+        }, {});
+        return a;
+    },
+    mapKeysDeepLodash: (obj, cb, isRecursive) => {
+        /* istanbul ignore next */
+        if (!obj && !isRecursive) {
+            return {};
+        }
+        if (!isRecursive) {
+            /* istanbul ignore next */
+            if (typeof obj === 'string' ||
+                typeof obj === 'number' ||
+                typeof obj === 'boolean') {
+                return {};
+            }
+        }
+        if (Array.isArray(obj)) {
+            return obj.map((item) => CoreUtils.mapKeysDeepLodash(item, cb, true));
+        }
+        if (!isPlainObject(obj)) {
+            return obj;
+        }
+        const result = mapKeys(obj, cb);
+        return mapValues(result, (value) => CoreUtils.mapKeysDeepLodash(value, cb, true));
+    },
+    generateNodes: (nodes) => keyBy(nodes.map((s) => omit(s, 'nextRules')), 'nodeId'),
+    makeObjectRules: (nodes) => nodes.reduce((acc, inc) => ({ ...acc, [inc.nodeId]: inc.nextRules }), {}),
+    hasNode: (state, name, node) => has(state, [name, 'nodes', node]),
+    isEmptyRules: (rules) => {
+        if (isEmpty(rules))
+            return true;
+        if (isEmpty(_get(rules, 'rules')))
+            return true;
+        if (Object.keys(flattenRules(rules)).every((key) => key.endsWith('$and') || key.endsWith('$or'))) {
+            return true;
+        }
+        return false;
+    },
+    mapEdge: (nextNode) => {
+        const res = nextNode.sort((a, b) => {
+            const x = CoreUtils.isEmptyRules(a.rules);
+            const y = CoreUtils.isEmptyRules(b.rules);
+            return Number(x) - Number(y);
+        });
+        return res;
+    },
+    makeRules: (rules) => Object.entries(rules).reduce((acc2, [k, v]) => [...acc2, { nodeId: k, rules: v }], []),
+    generateNodesForFlowerJson: (nodes) => nodes
+        .filter((e) => !!_get(e, 'props.id'))
+        .map((e) => {
+        const rules = CoreUtils.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
+        };
+    }),
+    cleanPath: (name, char = '^') => _trimStart(name, char),
+    getPath: (idValue) => {
+        if (!idValue) {
+            return {
+                path: []
+            };
+        }
+        if (idValue === '*') {
+            return {
+                path: '*'
+            };
+        }
+        if (idValue.indexOf('^') === 0) {
+            const [flowNameFromPath, ...rest] = CoreUtils.cleanPath(idValue).split('.');
+            return {
+                flowNameFromPath,
+                path: rest
+            };
+        }
+        return {
+            path: idValue.split('.')
+        };
+    },
+    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,
+        // invocando un next() senza paramentri
+        if (typeof rule.rules === 'string') {
+            return false;
+        }
+        if (typeof rule.rules === 'function') {
+            return rule.rules(value);
+        }
+        if (rule.rules === null) {
+            return true;
+        }
+        if (typeof rule.rules?.rules === 'undefined') {
+            return false;
+        }
+        if (typeof rule.rules.rules === 'string') {
+            return false;
+        }
+        const [valid] = MatchRules.rulesMatcher(rule.rules.rules, value, true, {
+            prefix
+        });
+        return valid;
+    })
 };
 
 const FlowerStateUtils = {
-  getAllData: state => state && Object.entries(state ?? {}).reduce((acc, [k, v]) => ({
-    ...acc,
-    [k]: v.data
-  }), {}),
-  selectFlowerFormNode: (name, id) => state => _get(state, [name, 'form', id]),
-  makeSelectCurrentNextRules: name => state => {
-    const nextRules = _get(state, [name, 'nextRules']);
-    const currentNodeId = FlowerStateUtils.makeSelectCurrentNodeId(name)(state);
-    return _get(nextRules, [currentNodeId]);
-  },
-  makeSelectCurrentNodeId: name => state => {
-    const subState = _get(state, [name]);
-    const startId = _get(state, ['startId']);
-    return _get(subState, ['current']) || startId;
-  },
-  makeSelectNodeErrors: (name, currentNodeId) => state => {
-    const form = FlowerStateUtils.selectFlowerFormNode(name, currentNodeId)(state);
-    return {
-      touched: form?.touched || false,
-      errors: form?.errors,
-      isValidating: form?.isValidating,
-      isValid: form && form.errors ? Object.values(form.errors).flat().length === 0 : true
-    };
-  }
+    getAllData: (state) => state &&
+        Object.entries(state ?? {}).reduce((acc, [k, v]) => ({ ...acc, [k]: v.data }), {}),
+    selectFlowerFormNode: (name, id) => (state) => _get(state, [name, 'form', id]),
+    makeSelectCurrentNextRules: (name) => (state) => {
+        const nextRules = _get(state, [name, 'nextRules']);
+        const currentNodeId = FlowerStateUtils.makeSelectCurrentNodeId(name)(state);
+        return _get(nextRules, [currentNodeId]);
+    },
+    makeSelectCurrentNodeId: (name) => (state) => {
+        const subState = _get(state, [name]);
+        const startId = _get(state, ['startId']);
+        return _get(subState, ['current']) || startId;
+    },
+    makeSelectNodeErrors: (name, currentNodeId) => (state) => {
+        const form = FlowerStateUtils.selectFlowerFormNode(name, currentNodeId)(state);
+        return {
+            touched: form?.touched || false,
+            errors: form?.errors,
+            isValidating: form?.isValidating,
+            isValid: form && form.errors
+                ? Object.values(form.errors).flat().length === 0
+                : true
+        };
+    }
 };
 
-const {
-  generateNodes,
-  hasNode,
-  makeObjectRules,
-  generateRulesName,
-  findValidRule
-} = CoreUtils;
+const { generateNodes, hasNode, makeObjectRules, generateRulesName, findValidRule } = CoreUtils;
+/**
+ * These functions are Redux reducers used in a Flux architecture for managing state transitions and updates in a Flower application.
+ */
 const FlowerCoreReducers = {
-  historyAdd: (state, {
-    payload
-  }) => {
-    if (hasNode(state, payload.name, payload.node)) {
-      state[payload.name].history.push(payload.node);
-      _set(state, [payload.name, 'current'], payload.node);
-    }
-    return state;
-  },
-  historyPrevToNode: (state, {
-    payload
-  }) => {
-    const history = _get(state[typeof payload === 'string' ? payload : payload.name], ['history'], []);
-    const lastIndex = lastIndexOf(history, typeof payload === 'string' ? payload : payload.node);
-    if (lastIndex >= 0) {
-      const newHistory = _slice(history, 0, lastIndex + 1);
-      _set(state, [typeof payload === 'string' ? payload : payload.name, 'history'], newHistory);
-      _set(state, [typeof payload === 'string' ? payload : payload.name, 'current'], typeof payload === 'string' ? payload : payload.node);
-    }
-    return state;
-  },
-  setFormTouched: (state, {
-    payload
-  }) => {
-    if (!_get(state, [typeof payload === 'string' ? payload : payload.flowName, 'nodes', typeof payload === 'string' ? payload : payload.currentNode])) {
-      return state;
-    }
-    _set(state, [typeof payload === 'string' ? payload : payload.flowName, 'form', typeof payload === 'string' ? payload : payload.currentNode, 'touched'], true);
-    return state;
-  },
-  forceAddHistory: (state, {
-    payload
-  }) => {
-    const {
-      name,
-      flowName,
-      history
-    } = payload;
-    const key = name || flowName || '' || '';
-    const resultHistory = history.slice(1, -1);
-    state[key].history.push(...resultHistory);
-    return state;
-  },
-  historyPop: (state, {
-    payload
-  }) => {
-    const container = _get(state, [payload.name]);
-    const startId = _get(container, ['startId']);
-    const history = _get(container, ['history']);
-    const originHistory = [..._get(container, ['history'], [])];
-    if (originHistory.length < 2) {
-      _set(state, [payload.name, 'current'], startId);
-      _set(state, [payload.name, 'history'], [startId]);
-      return state;
-    }
-    history.pop();
-    const total = originHistory.length - 2;
-    for (let index = total; index > 0; index--) {
-      const curr = originHistory[index];
-      const nodeType = _get(container, ['nodes', curr, 'nodeType']);
-      const nodeDisabled = _get(container, ['nodes', curr, 'disabled']);
-      if (nodeDisabled || nodeType === 'FlowerAction' || nodeType === 'FlowerServer' || !nodeType) {
+    historyAdd: (state, { payload }) => {
+        if (hasNode(state, payload.name, payload.node)) {
+            state[payload.name].history.push(payload.node);
+            _set(state, [payload.name, 'current'], payload.node);
+        }
+        return state;
+    },
+    historyPrevToNode: (state, { payload }) => {
+        const history = _get(state[typeof payload === 'string' ? payload : payload.name], ['history'], []);
+        const lastIndex = lastIndexOf(history, typeof payload === 'string' ? payload : payload.node);
+        // se passo un nodo che non esiste
+        if (lastIndex >= 0) {
+            const newHistory = _slice(history, 0, lastIndex + 1);
+            _set(state, [typeof payload === 'string' ? payload : payload.name, 'history'], newHistory);
+            _set(state, [typeof payload === 'string' ? payload : payload.name, 'current'], typeof payload === 'string' ? payload : payload.node);
+        }
+        return state;
+    },
+    setFormTouched: (state, { payload }) => {
+        if (!_get(state, [
+            typeof payload === 'string' ? payload : payload.flowName,
+            'nodes',
+            typeof payload === 'string' ? payload : payload.currentNode
+        ])) {
+            return state;
+        }
+        _set(state, [
+            typeof payload === 'string' ? payload : payload.flowName,
+            'form',
+            typeof payload === 'string' ? payload : payload.currentNode,
+            'touched'
+        ], true);
+        return state;
+    },
+    // TODO check internal logic and use case
+    /* istanbul ignore next */
+    forceAddHistory: (state, { payload }) => {
+        const { name, flowName, history } = payload;
+        const key = name || flowName || '' || '';
+        const resultHistory = history.slice(1, -1);
+        state[key].history.push(...resultHistory);
+        return state;
+    },
+    historyPop: (state, { payload }) => {
+        const container = _get(state, [payload.name]);
+        const startId = _get(container, ['startId']);
+        const history = _get(container, ['history']);
+        const originHistory = [..._get(container, ['history'], [])];
+        if (originHistory.length < 2) {
+            _set(state, [payload.name, 'current'], startId);
+            _set(state, [payload.name, 'history'], [startId]);
+            return state;
+        }
+        // elimino lo node corrente
         history.pop();
-      } else {
-        break;
-      }
-    }
-    const lastId = _last(history);
-    _set(state, [payload.name, 'current'], lastId);
-    return state;
-  },
-  restoreHistory: (state, {
-    payload
-  }) => {
-    const startId = _get(state, [payload.name, 'startId']);
-    _set(state, [payload.name, 'current'], startId);
-    _set(state, [payload.name, 'history'], [startId]);
-    return state;
-  },
-  replaceNode: (state, {
-    payload
-  }) => {
-    const {
-      name,
-      flowName,
-      node
-    } = payload;
-    if (hasNode(state, name || flowName || '', node)) {
-      _set(state, [name || flowName || '', 'current'], node);
-      _set(state, [name || flowName || '', 'history'], [node]);
-    }
-    return state;
-  },
-  initializeFromNode: (state, {
-    payload
-  }) => {
-    const {
-      name,
-      flowName,
-      node
-    } = payload;
-    if (hasNode(state, name || flowName || '', node)) {
-      _set(state, [name || flowName || '', 'startId'], node);
-      _set(state, [name || flowName || '', 'current'], node);
-      _set(state, [name || flowName || '', 'history'], [node]);
-    }
-    return state;
-  },
-  forceResetHistory: (state, {
-    payload
-  }) => {
-    const {
-      name,
-      flowName
-    } = payload;
-    if (!name && !flowName) return state;
-    _set(state, [name || flowName || '', 'history'], []);
-    return state;
-  },
-  destroy: (state, {
-    payload
-  }) => {
-    _set(state, [payload.name], {});
-  },
-  initNodes: (state, {
-    payload
-  }) => {
-    if (payload.persist && _get(state, [payload.name, 'persist'])) return;
-    const startId = payload.startId || _get(payload, 'nodes.0.nodeId');
-    if (!startId) {
-      console.warn('Flower is empty');
-      return;
-    }
-    _set(state, payload.name, {
-      persist: payload.persist,
-      startId,
-      current: startId,
-      history: [startId],
-      nodes: generateNodes(payload.nodes),
-      nextRules: makeObjectRules(payload.nodes),
-      data: payload.initialData
-    });
-  },
-  setCurrentNode: (state, {
-    payload
-  }) => {
-    if (hasNode(state, payload.name, payload.node)) {
-      const startId = _get(state, [payload.name, 'startId']);
-      if (payload.node === startId) {
+        const total = originHistory.length - 2;
+        // eslint-disable-next-line no-plusplus
+        for (let index = total; index > 0; index--) {
+            const curr = originHistory[index];
+            const nodeType = _get(container, ['nodes', curr, 'nodeType']);
+            const nodeDisabled = _get(container, ['nodes', curr, 'disabled']);
+            if (nodeDisabled ||
+                nodeType === 'FlowerAction' ||
+                nodeType === 'FlowerServer' ||
+                !nodeType) {
+                history.pop();
+            }
+            else {
+                break;
+            }
+        }
+        const lastId = _last(history);
+        _set(state, [payload.name, 'current'], lastId);
+        return state;
+    },
+    restoreHistory: (state, { payload }) => {
+        const startId = _get(state, [payload.name, 'startId']);
         _set(state, [payload.name, 'current'], startId);
         _set(state, [payload.name, 'history'], [startId]);
-      } else {
-        _set(state, [payload.name, 'current'], payload.node);
-      }
-    }
-  },
-  formAddErrors: (state, {
-    payload
-  }) => {
-    _set(state, [payload.name, 'form', payload.currentNode, 'errors', payload.id], payload.errors);
-  },
-  formRemoveErrors: (state, {
-    payload
-  }) => {
-    _unset(state, [payload.name, 'form', payload.currentNode, 'errors', payload.id]);
-    _unset(state, [payload.name, 'form', payload.currentNode, 'isValidating']);
-  },
-  addData: (state, {
-    payload
-  }) => {
-    const prevData = _get(state, [payload.flowName, 'data']);
-    _set(state, [payload.flowName, 'data'], {
-      ...prevData,
-      ...payload.value
-    });
-  },
-  addDataByPath: (state, {
-    payload
-  }) => {
-    if (payload.id && payload.id.length) {
-      _set(state, [payload.flowName, 'data', ...payload.id], payload.value);
-    }
-  },
-  replaceData: (state, {
-    payload
-  }) => {
-    _set(state, [payload.flowName, 'data'], payload.value);
-  },
-  unsetData: (state, {
-    payload
-  }) => {
-    _unset(state, [payload.flowName, 'data', ...payload.id]);
-  },
-  setFormIsValidating: (state, {
-    payload
-  }) => {
-    _set(state, [payload.name, 'form', payload.currentNode, 'isValidating'], payload.isValidating);
-  },
-  node: (state, {
-    payload
-  }) => {
-    const {
-      name,
-      history
-    } = payload;
-    const node = payload.nodeId || payload.node || '';
-    const flowName = name || payload.flowName || '';
-    const startNode = _get(state, [payload.name, 'startId']);
-    const currentNodeId = _get(state, [payload.name, 'current'], startNode);
-    FlowerCoreReducers.setFormTouched(state, {
-      type: 'setFormTouched',
-      payload: {
-        flowName,
-        currentNode: currentNodeId
-      }
-    });
-    if (global.window && _get(global.window, '__FLOWER_DEVTOOLS__') && history) {
-      FlowerCoreReducers.forceAddHistory(state, {
-        type: 'forceAddHistory',
-        payload: {
-          name,
-          flowName,
-          history
-        }
-      });
-    }
-    FlowerCoreReducers.historyAdd(state, {
-      type: 'historyAdd',
-      payload: {
-        name: name || flowName || '',
-        node
-      }
-    });
-  },
-  prevToNode: (state, {
-    payload
-  }) => {
-    const {
-      node,
-      name,
-      flowName
-    } = payload;
-    FlowerCoreReducers.historyPrevToNode(state, {
-      type: 'historyPrevToNode',
-      payload: {
-        name: name || flowName || '',
-        node
-      }
-    });
-  },
-  next: (state, {
-    payload
-  }) => {
-    const {
-      name,
-      data = {},
-      route
-    } = payload;
-    const flowName = name || payload.flowName || '';
-    const currentNodeId = FlowerStateUtils.makeSelectCurrentNodeId(flowName)(state);
-    const currentNextRules = FlowerStateUtils.makeSelectCurrentNextRules(flowName)(state);
-    const form = FlowerStateUtils.makeSelectNodeErrors(flowName, currentNodeId)(state);
-    const clonedData = _cloneDeep(FlowerStateUtils.getAllData(state));
-    const stateWithNodeData = {
-      $in: data,
-      $form: form,
-      ...clonedData
-    };
-    FlowerCoreReducers.setFormTouched(state, {
-      type: 'setFormTouched',
-      payload: {
-        flowName,
-        currentNode: currentNodeId
-      }
-    });
-    if (!currentNextRules) {
-      return;
-    }
-    if (route) {
-      const rulesByName = generateRulesName(currentNextRules);
-      if (!rulesByName[route]) {
-        return;
-      }
-      FlowerCoreReducers.historyAdd(state, {
-        type: 'historyAdd',
-        payload: {
-          name: flowName,
-          node: rulesByName[route]
-        }
-      });
-      return;
-    }
-    const validRule = findValidRule(currentNextRules, stateWithNodeData, flowName);
-    const nextNumberNode = _get(validRule, 'nodeId');
-    if (!nextNumberNode) {
-      return;
+        return state;
+    },
+    replaceNode: (state, { payload }) => {
+        const { name, flowName, node } = payload;
+        // non ancora implementanto nell'hook useFlower
+        /* istanbul ignore next */
+        if (hasNode(state, name || flowName || '', node)) {
+            _set(state, [name || flowName || '', 'current'], node);
+            _set(state, [name || flowName || '', 'history'], [node]);
+        }
+        /* istanbul ignore next */
+        return state;
+    },
+    /* istanbul ignore next */
+    initializeFromNode: (state, { payload }) => {
+        const { name, flowName, node } = payload;
+        if (hasNode(state, name || flowName || '', node)) {
+            _set(state, [name || flowName || '', 'startId'], node);
+            _set(state, [name || flowName || '', 'current'], node);
+            _set(state, [name || flowName || '', 'history'], [node]);
+        }
+        return state;
+    },
+    /* istanbul ignore next */
+    forceResetHistory: (state, { payload }) => {
+        const { name, flowName } = payload;
+        if (!name && !flowName)
+            return state;
+        _set(state, [name || flowName || '', 'history'], []);
+        return state;
+    },
+    destroy: (state, { payload }) => {
+        _set(state, [payload.name], {});
+    },
+    initNodes: (state, { payload }) => {
+        if (payload.persist && _get(state, [payload.name, 'persist']))
+            return;
+        const startId = payload.startId ||
+            _get(payload, 'initialState.startId') ||
+            _get(payload, 'nodes.0.nodeId');
+        // TODO non verificato, controllo precendente che non lo permette
+        /* istanbul ignore next */
+        if (!startId) {
+            // eslint-disable-next-line no-console
+            console.warn('Flower is empty');
+            return;
+        }
+        const current = _get(payload, 'initialState.current') || startId;
+        const history = _get(payload, 'initialState.history') || [startId];
+        _set(state, payload.name, {
+            persist: payload.persist,
+            startId,
+            current,
+            history,
+            nodes: generateNodes(payload.nodes),
+            nextRules: makeObjectRules(payload.nodes),
+            data: payload.initialData
+        });
+    },
+    // TODO usato solo da flower su vscode
+    setCurrentNode: /* istanbul ignore next */ (state, { payload }) => {
+        /* istanbul ignore next */
+        if (hasNode(state, payload.name, payload.node)) {
+            const startId = _get(state, [payload.name, 'startId']);
+            if (payload.node === startId) {
+                _set(state, [payload.name, 'current'], startId);
+                _set(state, [payload.name, 'history'], [startId]);
+            }
+            else {
+                _set(state, [payload.name, 'current'], payload.node);
+            }
+        }
+    },
+    formAddErrors: (state, { payload }) => {
+        _set(state, [payload.name, 'form', payload.currentNode, 'errors', payload.id], payload.errors);
+    },
+    formRemoveErrors: (state, { payload }) => {
+        _unset(state, [
+            payload.name,
+            'form',
+            payload.currentNode,
+            'errors',
+            payload.id
+        ]);
+        _unset(state, [payload.name, 'form', payload.currentNode, 'isValidating']);
+    },
+    addData: (state, { payload }) => {
+        const prevData = _get(state, [payload.flowName, 'data']);
+        _set(state, [payload.flowName, 'data'], { ...prevData, ...payload.value });
+    },
+    addDataByPath: (state, { payload }) => {
+        if (payload.id && payload.id.length) {
+            _set(state, [payload.flowName, 'data', ...payload.id], payload.value);
+        }
+    },
+    // TODO usato al momento solo il devtool
+    replaceData: /* istanbul ignore next */ (state, { payload }) => {
+        /* istanbul ignore next */
+        _set(state, [payload.flowName, 'data'], payload.value);
+    },
+    unsetData: (state, { payload }) => {
+        _unset(state, [payload.flowName, 'data', ...payload.id]);
+    },
+    setFormIsValidating: (state, { payload }) => {
+        _set(state, [payload.name, 'form', payload.currentNode, 'isValidating'], payload.isValidating);
+    },
+    node: (state, { payload }) => {
+        const { name, history } = payload;
+        const node = payload.nodeId || payload.node || '';
+        const flowName = name || payload.flowName || '';
+        const startNode = _get(state, [payload.name, 'startId']);
+        const currentNodeId = _get(state, [payload.name, 'current'], startNode);
+        FlowerCoreReducers.setFormTouched(state, {
+            type: 'setFormTouched',
+            payload: { flowName, currentNode: currentNodeId }
+        });
+        /* istanbul ignore next */
+        // eslint-disable-next-line no-underscore-dangle
+        if (devtoolState && _get(devtoolState, '__FLOWER_DEVTOOLS__') && history) {
+            FlowerCoreReducers.forceAddHistory(state, {
+                type: 'forceAddHistory',
+                payload: {
+                    name,
+                    flowName,
+                    history
+                }
+            });
+        }
+        FlowerCoreReducers.historyAdd(state, {
+            type: 'historyAdd',
+            payload: { name: name || flowName || '', node }
+        });
+    },
+    prevToNode: (state, { payload }) => {
+        const { node, name, flowName } = payload;
+        FlowerCoreReducers.historyPrevToNode(state, {
+            type: 'historyPrevToNode',
+            payload: { name: name || flowName || '', node }
+        });
+    },
+    next: (state, { payload }) => {
+        const { name, data = {}, route } = payload;
+        const flowName = name || payload.flowName || '';
+        const currentNodeId = FlowerStateUtils.makeSelectCurrentNodeId(flowName)(state);
+        const currentNextRules = FlowerStateUtils.makeSelectCurrentNextRules(flowName)(state);
+        const form = FlowerStateUtils.makeSelectNodeErrors(flowName, currentNodeId)(state);
+        const clonedData = _cloneDeep(FlowerStateUtils.getAllData(state));
+        const stateWithNodeData = {
+            $in: data,
+            $form: form,
+            ...clonedData
+        };
+        FlowerCoreReducers.setFormTouched(state, {
+            type: 'setFormTouched',
+            payload: { flowName, currentNode: currentNodeId }
+        });
+        if (!currentNextRules) {
+            return;
+        }
+        if (route) {
+            const rulesByName = generateRulesName(currentNextRules);
+            if (!rulesByName[route]) {
+                return;
+            }
+            FlowerCoreReducers.historyAdd(state, {
+                type: 'historyAdd',
+                payload: { name: flowName, node: rulesByName[route] }
+            });
+            return;
+        }
+        const validRule = findValidRule(currentNextRules, stateWithNodeData, flowName);
+        const nextNumberNode = _get(validRule, 'nodeId');
+        if (!nextNumberNode) {
+            return;
+        }
+        FlowerCoreReducers.historyAdd(state, {
+            type: 'historyAdd',
+            payload: { name: flowName, node: nextNumberNode }
+        });
+    },
+    prev: (state, { payload }) => {
+        const { name, flowName } = payload;
+        FlowerCoreReducers.historyPop(state, {
+            type: 'historyPop',
+            payload: { name: name || flowName || '' }
+        });
+    },
+    restart: (state, { payload }) => {
+        const { name, flowName } = payload;
+        FlowerCoreReducers.restoreHistory(state, {
+            type: 'restoreHistory',
+            payload: { name: name || flowName || '' }
+        });
+    },
+    reset: (state, { payload }) => {
+        const { name, flowName, initialData } = payload;
+        FlowerCoreReducers.restoreHistory(state, {
+            type: 'restoreHistory',
+            payload: { name: name || flowName || '' }
+        });
+        _set(state, [name || flowName || '', 'form'], {});
+        _set(state, [name || flowName || '', 'data'], initialData);
     }
-    FlowerCoreReducers.historyAdd(state, {
-      type: 'historyAdd',
-      payload: {
-        name: flowName,
-        node: nextNumberNode
-      }
-    });
-  },
-  prev: (state, {
-    payload
-  }) => {
-    const {
-      name,
-      flowName
-    } = payload;
-    FlowerCoreReducers.historyPop(state, {
-      type: 'historyPop',
-      payload: {
-        name: name || flowName || ''
-      }
-    });
-  },
-  restart: (state, {
-    payload
-  }) => {
-    const {
-      name,
-      flowName
-    } = payload;
-    FlowerCoreReducers.restoreHistory(state, {
-      type: 'restoreHistory',
-      payload: {
-        name: name || flowName || ''
-      }
-    });
-  },
-  reset: (state, {
-    payload
-  }) => {
-    const {
-      name,
-      flowName,
-      initialData
-    } = payload;
-    FlowerCoreReducers.restoreHistory(state, {
-      type: 'restoreHistory',
-      payload: {
-        name: name || flowName || ''
-      }
-    });
-    _set(state, [name || flowName || '', 'form'], {});
-    _set(state, [name || flowName || '', 'data'], initialData);
-  }
 };
 
 const FlowerCoreStateSelectors = {
-  selectGlobal: state => state && state.flower,
-  selectFlower: name => state => _get(state, [name]),
-  selectFlowerFormNode: id => state => _get(state, ['form', id]),
-  selectFlowerHistory: flower => _get(flower, ['history'], []),
-  makeSelectNodesIds: flower => _get(flower, ['nodes']),
-  makeSelectStartNodeId: flower => _get(flower, ['startId']),
-  getDataByFlow: flower => _get(flower, ['data']) ?? {},
-  getDataFromState: id => data => id === '*' ? data : _get(data, id),
-  makeSelectNodeFormTouched: form => form && form.touched,
-  makeSelectCurrentNodeId: (flower, startNodeId) => _get(flower, ['current']) || startNodeId,
-  makeSelectCurrentNodeDisabled: (nodes, current) => !!_get(nodes, [current, 'disabled']),
-  makeSelectPrevNodeRetain: (nodes, history, current) => {
-    if (!nodes) return;
-    const prevFlowerNode = [...history].reverse().find(el => {
-      const {
-        nodeType,
-        retain
-      } = nodes[el];
-      return nodeType === 'FlowerNode' || retain;
-    });
-    if (nodes[current].nodeType === 'FlowerNode' || nodes[current].retain) return;
-    if (!prevFlowerNode) return;
-    if (nodes[prevFlowerNode] && nodes[prevFlowerNode].disabled) return;
-    return nodes[prevFlowerNode] && nodes[prevFlowerNode].retain && prevFlowerNode;
-  },
-  makeSelectNodeErrors: form => {
-    return {
-      touched: form?.touched || false,
-      errors: form?.errors,
-      isValidating: form?.isValidating,
-      isValid: form && form.errors ? Object.values(form.errors).flat().length === 0 : true
-    };
-  },
-  makeSelectFieldError: (name, id, validate) => data => {
-    if (!validate || !data) return [];
-    const errors = validate.filter(rule => {
-      if (!rule) return true;
-      if (!rule.rules) return true;
-      const transformSelf = CoreUtils.mapKeysDeepLodash(rule.rules, (v, key) => key === '$self' ? id : key);
-      const [hasError] = MatchRules.rulesMatcher(transformSelf, data, false, {
-        prefix: name
-      });
-      return hasError;
-    });
-    const result = errors.map(r => r && r.message || 'error');
-    return result.length === 0 ? [] : result;
-  },
-  selectorRulesDisabled: (id, rules, keys, flowName, value) => (data, form) => {
-    const newState = {
-      ...data,
-      ...value,
-      $form: form
-    };
-    const state = Object.assign(newState, id ? {
-      $self: _get(newState, [flowName, ...id.split('.')])
-    } : {});
-    if (!rules) return false;
-    if (typeof rules === 'function') {
-      return !rules(state);
+    selectGlobal: (state) => state && state.flower,
+    selectFlower: (name) => (state) => _get(state, [name]),
+    selectFlowerFormNode: (id) => (state) => _get(state, ['form', id]),
+    selectFlowerHistory: (flower) => _get(flower, ['history'], []),
+    makeSelectNodesIds: (flower) => _get(flower, ['nodes']),
+    makeSelectStartNodeId: (flower) => _get(flower, ['startId']),
+    getDataByFlow: (flower) => _get(flower, ['data']) ?? {},
+    getDataFromState: (id) => (data) => (id === '*' ? data : _get(data, id)),
+    makeSelectNodeFormTouched: (form) => form && form.touched,
+    makeSelectCurrentNodeId: (flower, startNodeId) => _get(flower, ['current']) || startNodeId,
+    makeSelectCurrentNodeDisabled: (nodes, current) => !!_get(nodes, [current, 'disabled']),
+    makeSelectPrevNodeRetain: (nodes, history, current) => {
+        if (!nodes)
+            return;
+        const prevFlowerNode = [...history].reverse().find((el) => {
+            const { nodeType, retain } = nodes[el];
+            return nodeType === 'FlowerNode' || retain;
+        });
+        // eslint-disable-next-line consistent-return
+        if (nodes[current].nodeType === 'FlowerNode' || nodes[current].retain)
+            return;
+        if (!prevFlowerNode)
+            return;
+        if (nodes[prevFlowerNode] && nodes[prevFlowerNode].disabled)
+            return;
+        // eslint-disable-next-line consistent-return
+        return (nodes[prevFlowerNode] && nodes[prevFlowerNode].retain && prevFlowerNode);
+    },
+    makeSelectNodeErrors: (form) => {
+        return {
+            touched: form?.touched || false,
+            errors: form?.errors,
+            isValidating: form?.isValidating,
+            isValid: form && form.errors
+                ? Object.values(form.errors).flat().length === 0
+                : true
+        };
+    },
+    makeSelectFieldError: (name, id, validate) => (data) => {
+        if (!validate || !data)
+            return [];
+        const errors = validate.filter((rule) => {
+            if (!rule)
+                return true;
+            if (!rule.rules)
+                return true;
+            const transformSelf = CoreUtils.mapKeysDeepLodash(rule.rules, (v, key) => key === '$self' ? id : key);
+            const [hasError] = MatchRules.rulesMatcher(transformSelf, data, false, {
+                prefix: name
+            });
+            return hasError;
+        });
+        const result = errors.map((r) => (r && r.message) || 'error');
+        return result.length === 0 ? [] : result;
+    },
+    selectorRulesDisabled: (id, rules, keys, flowName, value) => (data, form) => {
+        const newState = { ...data, ...value, $form: form };
+        const state = Object.assign(newState, id ? { $self: _get(newState, [flowName, ...id.split('.')]) } : {});
+        if (!rules)
+            return false;
+        if (typeof rules === 'function') {
+            return !rules(state);
+        }
+        if (!keys)
+            return false;
+        const res = keys.reduce((acc, inc) => {
+            const k = inc;
+            return Object.assign(acc, { [k]: _get(state, k) });
+        }, {});
+        const [disabled] = MatchRules.rulesMatcher(rules, { ...flat.unflatten(res) }, false, { prefix: flowName });
+        return disabled;
     }
-    if (!keys) return false;
-    const res = keys.reduce((acc, inc) => {
-      const k = inc;
-      return Object.assign(acc, {
-        [k]: _get(state, k)
-      });
-    }, {});
-    const [disabled] = MatchRules.rulesMatcher(rules, {
-      ...flat.unflatten(res)
-    }, false, {
-      prefix: flowName
-    });
-    return disabled;
-  }
 };
 
 exports.RulesModes = void 0;
 (function (RulesModes) {
-  RulesModes["$and"] = "$and";
-  RulesModes["$or"] = "$or";
+    RulesModes["$and"] = "$and";
+    RulesModes["$or"] = "$or";
 })(exports.RulesModes || (exports.RulesModes = {}));
 var RulesOperators;
 (function (RulesOperators) {
-  RulesOperators["$exist"] = "$exist";
-  RulesOperators["$eq"] = "$eq";
-  RulesOperators["$ne"] = "$ne";
-  RulesOperators["$gt"] = "$gt";
-  RulesOperators["$gte"] = "$gte";
-  RulesOperators["$lt"] = "$lt";
-  RulesOperators["$lte"] = "$lte";
-  RulesOperators["$strGt"] = "$strGt";
-  RulesOperators["$strGte"] = "$strGte";
-  RulesOperators["$strLt"] = "$strLt";
-  RulesOperators["$strLte"] = "$strLte";
-  RulesOperators["$in"] = "$in";
-  RulesOperators["$nin"] = "$nin";
-  RulesOperators["$all"] = "$all";
-  RulesOperators["$regex"] = "$regex";
+    RulesOperators["$exist"] = "$exist";
+    RulesOperators["$eq"] = "$eq";
+    RulesOperators["$ne"] = "$ne";
+    RulesOperators["$gt"] = "$gt";
+    RulesOperators["$gte"] = "$gte";
+    RulesOperators["$lt"] = "$lt";
+    RulesOperators["$lte"] = "$lte";
+    RulesOperators["$strGt"] = "$strGt";
+    RulesOperators["$strGte"] = "$strGte";
+    RulesOperators["$strLt"] = "$strLt";
+    RulesOperators["$strLte"] = "$strLte";
+    RulesOperators["$in"] = "$in";
+    RulesOperators["$nin"] = "$nin";
+    RulesOperators["$all"] = "$all";
+    RulesOperators["$regex"] = "$regex";
 })(RulesOperators || (RulesOperators = {}));
 
 exports.RulesOperators = void 0;
 (function (RulesOperators) {
-  RulesOperators["$exist"] = "$exist";
-  RulesOperators["$eq"] = "$eq";
-  RulesOperators["$ne"] = "$ne";
-  RulesOperators["$gt"] = "$gt";
-  RulesOperators["$gte"] = "$gte";
-  RulesOperators["$lt"] = "$lt";
-  RulesOperators["$lte"] = "$lte";
-  RulesOperators["$strGt"] = "$strGt";
-  RulesOperators["$strGte"] = "$strGte";
-  RulesOperators["$strLt"] = "$strLt";
-  RulesOperators["$strLte"] = "$strLte";
-  RulesOperators["$in"] = "$in";
-  RulesOperators["$nin"] = "$nin";
-  RulesOperators["$all"] = "$all";
-  RulesOperators["$regex"] = "$regex";
+    RulesOperators["$exist"] = "$exist";
+    RulesOperators["$eq"] = "$eq";
+    RulesOperators["$ne"] = "$ne";
+    RulesOperators["$gt"] = "$gt";
+    RulesOperators["$gte"] = "$gte";
+    RulesOperators["$lt"] = "$lt";
+    RulesOperators["$lte"] = "$lte";
+    RulesOperators["$strGt"] = "$strGt";
+    RulesOperators["$strGte"] = "$strGte";
+    RulesOperators["$strLt"] = "$strLt";
+    RulesOperators["$strLte"] = "$strLte";
+    RulesOperators["$in"] = "$in";
+    RulesOperators["$nin"] = "$nin";
+    RulesOperators["$all"] = "$all";
+    RulesOperators["$regex"] = "$regex";
 })(exports.RulesOperators || (exports.RulesOperators = {}));
 
+const devtoolState = {};
+
 exports.CoreUtils = CoreUtils;
 exports.Emitter = Emitter;
 exports.FlowerCoreReducers = FlowerCoreReducers;
 exports.FlowerStateUtils = FlowerStateUtils;
 exports.MatchRules = MatchRules;
 exports.Selectors = FlowerCoreStateSelectors;
+exports.devtoolState = devtoolState;