@flowerforce/flower-core 3.0.0

package/dist/index.esm.js

@@ -0,0 +1,937 @@
+import { get, isBuffer, intersection, trimStart, isPlainObject, mapKeys, mapValues, keyBy, omit, has, isEmpty, find, set, lastIndexOf, slice, last, unset, cloneDeep } from 'lodash';
+import { TinyEmitter } from 'tiny-emitter';
+
+const keyIdentity = key => key;
+const flatten = (target, opts) => {
+  const options = opts ?? {};
+  const safe = get(options, 'safe', false);
+  const maxDepth = get(options, 'maxDepth', 0);
+  const delimiter = get(options, 'delimiter', '.');
+  const transformKey = get(options, 'transformKey', keyIdentity);
+  const output = {};
+  const step = (object, prev, currentDepth) => {
+    const depth = currentDepth || 1;
+    Object.keys(object).forEach(key => {
+      const value = object[key];
+      const isarray = safe && Array.isArray(value);
+      const type = Object.prototype.toString.call(value);
+      const isbuffer = isBuffer(value);
+      const isobject = type === '[object Object]' || type === '[object Array]';
+      const newKey = prev ? prev + delimiter + transformKey(key) : transformKey(key);
+      if (!isarray && !isbuffer && isobject && Object.keys(value).length && (!maxDepth || depth < maxDepth)) {
+        return step(value, newKey, depth + 1);
+      }
+      output[newKey] = value;
+    });
+  };
+  step(target);
+  return output;
+};
+const unflatten = (target, opts) => {
+  const options = opts ?? {};
+  const object = get(options, 'object', false);
+  const overwrite = get(options, 'overwrite', false);
+  const delimiter = get(options, 'delimiter', '.');
+  const transformKey = get(options, 'transformKey', keyIdentity);
+  const result = {};
+  const isbuffer = isBuffer(target);
+  if (isbuffer || Object.prototype.toString.call(target) !== '[object Object]') {
+    return target;
+  }
+  const getkey = key => {
+    const parsedKey = Number(key);
+    return isNaN(parsedKey) || key?.indexOf('.') !== -1 || object ? key : parsedKey;
+  };
+  function addKeys(keyPrefix, recipient, target) {
+    return Object.keys(target).reduce((result, key) => {
+      result[keyPrefix + delimiter + key] = target[key];
+      return result;
+    }, recipient);
+  }
+  function isEmpty(val) {
+    const type = Object.prototype.toString.call(val);
+    const isArray = type === '[object Array]';
+    const isObject = type === '[object Object]';
+    if (!val) {
+      return true;
+    }
+    if (isArray) {
+      return !val.length;
+    }
+    if (isObject) {
+      return !Object.keys(val).length;
+    }
+  }
+  target = Object.keys(target).reduce((result, key) => {
+    const type = Object.prototype.toString.call(target[key]);
+    const isObject = type === '[object Object]' || type === '[object Array]';
+    if (!isObject || isEmpty(target[key])) {
+      result[key] = target[key];
+      return result;
+    }
+    return addKeys(key, result, flatten(target[key], opts));
+  }, {});
+  Object.keys(target).forEach(key => {
+    const split = key.split(delimiter).map(transformKey);
+    let key1 = getkey(split.shift());
+    let key2 = getkey(split[0]);
+    let recipient = result;
+    while (key2 !== undefined) {
+      const recipient_key_1 = key1 && get(recipient, key1);
+      const type = Object.prototype.toString.call(recipient_key_1);
+      const isobject = type === '[object Object]' || type === '[object Array]';
+      if (!overwrite && !isobject && typeof recipient_key_1 !== 'undefined') {
+        return;
+      }
+      if (overwrite && !isobject || !overwrite && recipient_key_1 == null) {
+        recipient[key1] = typeof key2 === 'number' && !object ? [] : {};
+      }
+      recipient = key1 && get(recipient, key1);
+      if (split.length > 0) {
+        key1 = getkey(split.shift());
+        key2 = getkey(split[0]);
+      }
+    }
+    recipient[key1] = unflatten(target[key], opts);
+  });
+  return result;
+};
+const flat = {
+  flatten,
+  unflatten
+};
+
+const Emitter = new TinyEmitter();
+
+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))
+};
+
+const EMPTY_STRING_REGEXP = /^\s*$/;
+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) {
+        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));
+    }
+    const res = rulesMatcherUtils.rule(block, data, options);
+    return res.valid;
+  },
+  getKeys: (rules, options) => {
+    if (!rules) return null;
+    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 rulesMatcher = (rules, formValue = {}, apply = true, options) => {
+  if (!rules) return [apply];
+  const conditions = Array.isArray(rules) ? {
+    $and: rules
+  } : rules;
+  const valid = rulesMatcherUtils.checkRule(conditions, formValue, options ?? {});
+  return [valid === apply];
+};
+const MatchRules = {
+  rulesMatcher,
+  operators,
+  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];
+    }
+  }
+  return result;
+};
+const getRulesExists = rules => {
+  return Object.keys(rules).length ? CoreUtils.mapEdge(rules) : undefined;
+};
+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.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 (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
+    };
+  }
+};
+
+const {
+  generateNodes,
+  hasNode,
+  makeObjectRules,
+  generateRulesName,
+  findValidRule
+} = CoreUtils;
+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) {
+        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) {
+        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;
+    }
+    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 || ''
+      }
+    });
+  },
+  reset: (state, {
+    payload
+  }) => {
+    const {
+      name,
+      flowName
+    } = payload;
+    FlowerCoreReducers.restoreHistory(state, {
+      type: 'restoreHistory',
+      payload: {
+        name: name || flowName || ''
+      }
+    });
+  }
+};
+
+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 (!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;
+  }
+};
+
+var RulesModes;
+(function (RulesModes) {
+  RulesModes["$and"] = "$and";
+  RulesModes["$or"] = "$or";
+})(RulesModes || (RulesModes = {}));
+var RulesOperators$1;
+(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$1 || (RulesOperators$1 = {}));
+
+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 || (RulesOperators = {}));
+
+export { CoreUtils, Emitter, flat as Flat, FlowerCoreReducers, FlowerStateUtils, MatchRules, RulesModes, RulesOperators, FlowerCoreStateSelectors as Selectors };