@react-awesome-query-builder/core/cjs/export/jsonLogic.js

User-friendly query builder for React. Core

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.jsonLogicFormat = void 0;
var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
var _stuff = require("../utils/stuff");
var _configUtils = require("../utils/configUtils");
var _configExtend = require("../utils/configExtend");
var _ruleUtils = require("../utils/ruleUtils");
var _defaultUtils = require("../utils/defaultUtils");
var _immutable = require("immutable");
var _pick = _interopRequireDefault(require("lodash/pick"));
function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
// http://jsonlogic.com/

var jsonLogicFormat = exports.jsonLogicFormat = function jsonLogicFormat(item, config) {
  //meta is mutable
  var meta = {
    usedFields: [],
    errors: []
  };
  var extendedConfig = (0, _configExtend.extendConfig)(config, undefined, false);
  var logic = formatItem(item, extendedConfig, meta, false, true);

  // build empty data
  var errors = meta.errors,
    usedFields = meta.usedFields;
  var fieldSeparator = extendedConfig.settings.fieldSeparator;
  var data = {};
  var _iterator = _createForOfIteratorHelper(usedFields),
    _step;
  try {
    for (_iterator.s(); !(_step = _iterator.n()).done;) {
      var ff = _step.value;
      //const fieldSrc = typeof ff === "string" ? "field" : "func";
      var parts = (0, _configUtils.getFieldParts)(ff, config);
      var def = (0, _configUtils.getFieldConfig)(extendedConfig, ff) || {};
      var tmp = data;
      for (var i = 0; i < parts.length; i++) {
        var p = parts[i];
        var pdef = (0, _configUtils.getFieldConfig)(extendedConfig, parts.slice(0, i + 1)) || {};
        if (i != parts.length - 1) {
          if (pdef.type == "!group" && pdef.mode != "struct") {
            if (!tmp[p]) tmp[p] = [{}];
            tmp = tmp[p][0];
          } else {
            if (!tmp[p]) tmp[p] = {};
            tmp = tmp[p];
          }
        } else {
          if (!tmp[p]) tmp[p] = null; // can use def.type for sample values
        }
      }
    }
  } catch (err) {
    _iterator.e(err);
  } finally {
    _iterator.f();
  }
  return {
    errors: errors,
    logic: logic,
    data: data
  };
};
var formatItem = function formatItem(item, config, meta) {
  var _not = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
  var isRoot = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
  var parentField = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : null;
  if (!item) return undefined;
  var type = item.get("type");
  var properties = item.get("properties") || new _immutable.Map();
  var isLocked = properties.get("isLocked");
  var lockedOp = config.settings.jsonLogic.lockedOp;
  var ret;
  if (type === "group" || type === "rule_group") {
    ret = formatGroup(item, config, meta, _not, isRoot, parentField);
  } else if (type === "rule") {
    ret = formatRule(item, config, meta, _not, parentField);
  } else if (type == "switch_group") {
    ret = formatSwitch(item, config, meta, _not);
  } else if (type == "case_group") {
    ret = formatCase(item, config, meta, _not, parentField);
  }
  if (isLocked && ret && lockedOp) {
    ret = (0, _defineProperty2["default"])({}, lockedOp, ret);
  }
  return ret;
};
var formatGroup = function formatGroup(item, config, meta) {
  var _groupOperatorDef, _groupOperatorDef2, _groupOperatorDef3, _reversedGroupOpDef, _reversedGroupOpDef2, _getOneChildOrDescend;
  var _not = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
  var isRoot = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
  var parentField = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : null;
  var type = item.get("type");
  var properties = item.get("properties") || new _immutable.Map();
  var mode = properties.get("mode");
  var children = item.get("children1") || new _immutable.List();
  var field = properties.get("field");
  var fieldDefinition = (0, _configUtils.getFieldConfig)(config, field);
  var conjunction = properties.get("conjunction");
  if (!conjunction) conjunction = (0, _defaultUtils.defaultConjunction)(config);
  var conjunctionDefinition = config.conjunctions[conjunction];
  var conj = (conjunctionDefinition === null || conjunctionDefinition === void 0 ? void 0 : conjunctionDefinition.jsonLogicConj) || conjunction.toLowerCase();
  var origNot = !!properties.get("not");
  var isRuleGroup = type === "rule_group" && !isRoot;
  var isRuleGroupArray = isRuleGroup && mode != "struct";
  var groupField = isRuleGroupArray ? field : parentField;
  var groupOperator = properties.get("operator");
  var groupOperatorDef = groupOperator && (0, _configUtils.getOperatorConfig)(config, groupOperator, field) || null;
  var formattedValue = formatItemValue(config, properties, meta, groupOperator, parentField);
  // Tip: for demo app isGroup0 is true for "Results" and "Cars" with group op in "some", "all", "none"
  // If isGroup0 is false, we should use "reduce"
  var isGroup0 = isRuleGroup && (!groupOperator || ((_groupOperatorDef = groupOperatorDef) === null || _groupOperatorDef === void 0 ? void 0 : _groupOperatorDef.cardinality) == 0);
  var isRuleGroupWithChildren = isRuleGroup && (children === null || children === void 0 ? void 0 : children.size) > 0;
  var isRuleGroupWithoutChildren = isRuleGroup && !(children !== null && children !== void 0 && children.size);

  // rev
  var not = origNot;
  var filterNot = false;
  if (isRuleGroupWithChildren) {
    // for rule_group `not` there should be 2 NOTs: from properties (for children) and from parent group (_not)
    filterNot = origNot;
    not = _not;
  } else {
    if (_not) {
      not = !not;
    }
  }
  var revChildren = false;
  var reversedGroupOp = (_groupOperatorDef2 = groupOperatorDef) === null || _groupOperatorDef2 === void 0 ? void 0 : _groupOperatorDef2.reversedOp;
  var reversedGroupOpDef = (0, _configUtils.getOperatorConfig)(config, reversedGroupOp, field);
  var groupOpNeedsReverse = !((_groupOperatorDef3 = groupOperatorDef) !== null && _groupOperatorDef3 !== void 0 && _groupOperatorDef3.jsonLogic) && !!((_reversedGroupOpDef = reversedGroupOpDef) !== null && _reversedGroupOpDef !== void 0 && _reversedGroupOpDef.jsonLogic);
  var groupOpCanReverse = !!((_reversedGroupOpDef2 = reversedGroupOpDef) !== null && _reversedGroupOpDef2 !== void 0 && _reversedGroupOpDef2.jsonLogic);
  var oneChildType = (_getOneChildOrDescend = (0, _ruleUtils.getOneChildOrDescendant)(item)) === null || _getOneChildOrDescend === void 0 ? void 0 : _getOneChildOrDescend.get("type");
  var canRevChildren = !!config.settings.reverseOperatorsForNot && (!isRuleGroup && not && oneChildType === "rule" || filterNot && (children === null || children === void 0 ? void 0 : children.size) === 1);
  if (canRevChildren) {
    if (isRuleGroupWithChildren) {
      filterNot = !filterNot;
    } else {
      not = !not;
    }
    revChildren = true;
  }
  var canRevGroupOp = not && isRuleGroup && groupOpCanReverse && (!!config.settings.reverseOperatorsForNot || groupOpNeedsReverse);
  if (canRevGroupOp) {
    not = !not;
    var _ref = [reversedGroupOp, groupOperator];
    groupOperator = _ref[0];
    reversedGroupOp = _ref[1];
    var _ref2 = [reversedGroupOpDef, groupOperatorDef];
    groupOperatorDef = _ref2[0];
    reversedGroupOpDef = _ref2[1];
  }
  var list = children.map(function (currentChild) {
    return formatItem(currentChild, config, meta, revChildren, false, groupField);
  }).filter(function (currentChild) {
    return typeof currentChild !== "undefined";
  });

  // allows for unnecessary (ie. empty or only one rule) groups to be exported
  var shouldPreserveGroups = !!config.settings.exportPreserveGroups;
  if (isRuleGroupArray && !isGroup0) {
    // "count" rule can have no "having" children, but should have number value
    if (formattedValue == undefined) return undefined;
  } else {
    if (!list.size && !shouldPreserveGroups) return undefined;
  }

  // I any of these conditions are true then we cannot remove group
  var preserveSingleRuleGroup = isRoot || shouldPreserveGroups || list.size != 1;

  // If preserveSingleRuleGroup is already true then there is no point to even check also if its not a negation group 
  // then this does not matter
  if (!preserveSingleRuleGroup && origNot && !revChildren) {
    // We check all children even thuogh there should be only one in case the formatting of one of them failed.
    // From config we see if exclamation is part of reverse operator definition and if so then we cannot ever remove a negation single 
    // rule group because then this combination would be identical to that reverse operator. see issue #1084
    preserveSingleRuleGroup = children.some(function (currentChild) {
      var _currentChild$get, _config$operators, _config$operators$rev, _config$operators2;
      var op = (_currentChild$get = currentChild.get("properties")) === null || _currentChild$get === void 0 ? void 0 : _currentChild$get.get("operator");
      var revOp = (_config$operators = config["operators"]) === null || _config$operators === void 0 || (_config$operators = _config$operators[op]) === null || _config$operators === void 0 ? void 0 : _config$operators.reversedOp;
      return (_config$operators$rev = (_config$operators2 = config.operators) === null || _config$operators2 === void 0 || (_config$operators2 = _config$operators2[revOp]) === null || _config$operators2 === void 0 ? void 0 : _config$operators2._jsonLogicIsExclamationOp) !== null && _config$operators$rev !== void 0 ? _config$operators$rev : false;
    });
  }
  var filterQuery = {};
  if (preserveSingleRuleGroup) filterQuery[conj] = list.toList().toJS();else filterQuery = list.first();

  // reverse filter
  if (filterNot) {
    filterQuery = {
      "!": filterQuery
    };
  }
  var resultQuery = filterQuery;

  // rule_group (issue #246)
  if (isRuleGroupArray) {
    var _groupOperatorDef4;
    var formattedField = formatField(meta, config, field, parentField);
    var reduceQuery;
    if (!isGroup0) {
      // there is rule for count
      var filter = !list.size ? formattedField : {
        "filter": [formattedField, filterQuery]
      };
      reduceQuery = {
        "reduce": [filter, {
          "+": [1, {
            "var": "accumulator"
          }]
        }, 0]
      };
    }
    var formattedLhs = reduceQuery !== null && reduceQuery !== void 0 ? reduceQuery : formattedField;
    var optionsMap = new _immutable.Map({
      having: filterQuery,
      reduce: reduceQuery,
      groupField: field,
      groupFieldFormatted: formattedField
    });
    // if groupOperator defines its own jsonLogic function, then we should use it (issue #1241)
    if (typeof ((_groupOperatorDef4 = groupOperatorDef) === null || _groupOperatorDef4 === void 0 ? void 0 : _groupOperatorDef4.jsonLogic) === "function") {
      // we should use optionsMap here
      resultQuery = formatLogic(config, properties, formattedLhs, formattedValue, groupOperator, optionsMap, fieldDefinition);
    } else {
      if (isGroup0) {
        // config.settings.groupOperators
        var op = groupOperator || "some";
        resultQuery = (0, _defineProperty2["default"])({}, op, [formattedField, filterQuery]);
      } else {
        resultQuery = formatLogic(config, properties, formattedLhs, formattedValue, groupOperator, null, fieldDefinition);
      }
    }
  }

  // reverse
  if (not) {
    resultQuery = {
      "!": resultQuery
    };
  }
  return resultQuery;
};
var formatRule = function formatRule(item, config, meta) {
  var _operatorDefinition, _operatorDefinition2, _revOperatorDefinitio, _operatorDefinition3, _revOperatorDefinitio2, _revOperatorDefinitio3;
  var _not = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
  var parentField = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null;
  var properties = item.get("properties") || new _immutable.Map();
  var field = properties.get("field");
  var fieldSrc = properties.get("fieldSrc");
  var operator = properties.get("operator");
  var operatorOptions = properties.get("operatorOptions");
  operatorOptions = operatorOptions ? operatorOptions.toJS() : null;
  if (operatorOptions && !Object.keys(operatorOptions).length) operatorOptions = null;
  if (field == null || operator == null) return undefined;
  var fieldDefinition = (0, _configUtils.getFieldConfig)(config, field);
  var operatorDefinition = (0, _configUtils.getOperatorConfig)(config, operator, field);
  var reversedOp = (_operatorDefinition = operatorDefinition) === null || _operatorDefinition === void 0 ? void 0 : _operatorDefinition.reversedOp;
  var revOperatorDefinition = (0, _configUtils.getOperatorConfig)(config, reversedOp, field);

  // check op
  if (!((_operatorDefinition2 = operatorDefinition) !== null && _operatorDefinition2 !== void 0 && _operatorDefinition2.jsonLogic) && !((_revOperatorDefinitio = revOperatorDefinition) !== null && _revOperatorDefinitio !== void 0 && _revOperatorDefinitio.jsonLogic)) {
    meta.errors.push("Operator ".concat(operator, " is not supported"));
    return undefined;
  }

  // try reverse
  var not = _not;
  var opNeedsReverse = !((_operatorDefinition3 = operatorDefinition) !== null && _operatorDefinition3 !== void 0 && _operatorDefinition3.jsonLogic) && !!((_revOperatorDefinitio2 = revOperatorDefinition) !== null && _revOperatorDefinitio2 !== void 0 && _revOperatorDefinitio2.jsonLogic);
  var opCanReverse = !!((_revOperatorDefinitio3 = revOperatorDefinition) !== null && _revOperatorDefinitio3 !== void 0 && _revOperatorDefinitio3.jsonLogic);
  var canRev = opCanReverse && (!!config.settings.reverseOperatorsForNot || opNeedsReverse);
  var needRev = not && canRev || opNeedsReverse;
  if (needRev) {
    not = !not;
    var _ref3 = [reversedOp, operator];
    operator = _ref3[0];
    reversedOp = _ref3[1];
    var _ref4 = [revOperatorDefinition, operatorDefinition];
    operatorDefinition = _ref4[0];
    revOperatorDefinition = _ref4[1];
  }
  var formattedValue = formatItemValue(config, properties, meta, operator, parentField);
  if (formattedValue === undefined) return undefined;
  var formattedField = fieldSrc === "func" ? formatFunc(meta, config, field, parentField) : formatField(meta, config, field, parentField);
  if (formattedField === undefined) return undefined;
  return formatLogic(config, properties, formattedField, formattedValue, operator, operatorOptions, fieldDefinition, not);
};
var formatSwitch = function formatSwitch(item, config, meta) {
  var _not = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
  var children = item.get("children1");
  if (!children) return undefined;
  var cases = children.map(function (currentChild) {
    return formatCase(currentChild, config, meta, _not, null);
  }).filter(function (currentChild) {
    return typeof currentChild !== "undefined";
  }).valueSeq().toArray();
  var filteredCases = [];
  for (var i = 0; i < cases.length; i++) {
    if (i !== cases.length - 1 && !cases[i][0]) {
      meta.errors.push("No condition for case ".concat(i));
    } else {
      filteredCases.push(cases[i]);
      if (i === cases.length - 1 && cases[i][0]) {
        // no default - add null as default
        filteredCases.push([undefined, null]);
      }
    }
  }
  if (!filteredCases.length) return undefined;
  if (filteredCases.length === 1) {
    // only 1 case without condition
    var _filteredCases$ = (0, _slicedToArray2["default"])(filteredCases[0], 2),
      _cond = _filteredCases$[0],
      _defVal = _filteredCases$[1];
    if (_defVal == undefined) _defVal = null;
    return _defVal;
  }
  var ret = {
    "if": []
  };
  var ifArgs = ret["if"];
  var _filteredCases = (0, _slicedToArray2["default"])(filteredCases[filteredCases.length - 1], 2),
    _ = _filteredCases[0],
    defVal = _filteredCases[1];
  for (var _i = 0; _i < filteredCases.length - 1; _i++) {
    var isLastIf = _i === filteredCases.length - 2;
    var _filteredCases$_i = (0, _slicedToArray2["default"])(filteredCases[_i], 2),
      cond = _filteredCases$_i[0],
      value = _filteredCases$_i[1];
    if (value == undefined) value = null;
    if (cond == undefined) cond = true;
    ifArgs.push(cond); // if
    ifArgs.push(value); // then
    if (isLastIf) {
      ifArgs.push(defVal); // else
    } else {
      // elif..
      ifArgs.push({
        "if": []
      });
      ifArgs = ifArgs[ifArgs.length - 1]["if"];
    }
  }
  return ret;
};
var formatCase = function formatCase(item, config, meta) {
  var _not = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
  var parentField = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null;
  var type = item.get("type");
  if (type != "case_group") {
    meta.errors.push("Unexpected child of type ".concat(type, " inside switch"));
    return undefined;
  }
  var properties = item.get("properties") || new _immutable.Map();
  var cond = formatGroup(item, config, meta, _not, parentField);
  var formattedItem = formatItemValue(config, properties, meta, null, parentField, "!case_value");
  return [cond, formattedItem];
};
var formatItemValue = function formatItemValue(config, properties, meta, operator, parentField) {
  var expectedValueType = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : null;
  var field = properties.get("field");
  var iValueSrc = properties.get("valueSrc");
  var iValueType = properties.get("valueType");
  if (expectedValueType == "!case_value" || iValueType && iValueType.get(0) == "case_value") {
    field = "!case_value";
  }
  var fieldDefinition = (0, _configUtils.getFieldConfig)(config, field);
  var operatorDefinition = (0, _configUtils.getOperatorConfig)(config, operator, field);
  var cardinality = (0, _stuff.getOpCardinality)(operatorDefinition);
  var iValue = properties.get("value");
  var asyncListValues = properties.get("asyncListValues");
  if (iValue == undefined) return undefined;
  var valueSrcs = [];
  var valueTypes = [];
  var oldUsedFields = meta.usedFields;
  var fvalue = iValue.map(function (currentValue, ind) {
    var valueSrc = iValueSrc ? iValueSrc.get(ind) : null;
    var valueType = iValueType ? iValueType.get(ind) : null;
    var cValue = (0, _ruleUtils.completeValue)(currentValue, valueSrc, config);
    var widget = (0, _configUtils.getWidgetForFieldOp)(config, field, operator, valueSrc);
    var fieldWidgetDef = (0, _configUtils.getFieldWidgetConfig)(config, field, operator, widget, valueSrc, {
      forExport: true
    });
    var fv = formatValue(meta, config, cValue, valueSrc, valueType, fieldWidgetDef, fieldDefinition, operator, operatorDefinition, parentField, asyncListValues);
    if (fv !== undefined) {
      valueSrcs.push(valueSrc);
      valueTypes.push(valueType);
    }
    return fv;
  });
  var hasUndefinedValues = fvalue.filter(function (v) {
    return v === undefined;
  }).size > 0;
  if (fvalue.size < cardinality || hasUndefinedValues) {
    meta.usedFields = oldUsedFields; // restore
    return undefined;
  }
  return cardinality > 1 ? fvalue.toArray() : cardinality == 1 ? fvalue.first() : null;
};
var formatValue = function formatValue(meta, config, currentValue, valueSrc, valueType, fieldWidgetDef, fieldDef, operator, operatorDef) {
  var parentField = arguments.length > 9 && arguments[9] !== undefined ? arguments[9] : null;
  var asyncListValues = arguments.length > 10 ? arguments[10] : undefined;
  if (currentValue === undefined) return undefined;
  var ret;
  if (valueSrc == "field") {
    ret = formatField(meta, config, currentValue, parentField);
  } else if (valueSrc == "func") {
    ret = formatFunc(meta, config, currentValue, parentField);
  } else if (typeof (fieldWidgetDef === null || fieldWidgetDef === void 0 ? void 0 : fieldWidgetDef.jsonLogic) === "function") {
    var fn = fieldWidgetDef.jsonLogic;
    var args = [currentValue, _objectSpread(_objectSpread({}, fieldDef ? (0, _pick["default"])(fieldDef, ["fieldSettings", "listValues"]) : {}), {}, {
      asyncListValues: asyncListValues
    }),
    //useful options: valueFormat for date/time
    (0, _stuff.omit)(fieldWidgetDef, _stuff.widgetDefKeysToOmit)];
    if (operator) {
      args.push(operator);
      args.push(operatorDef);
    }
    ret = fn.call.apply(fn, [config.ctx].concat(args));
  } else {
    ret = currentValue;
  }
  return ret;
};
var formatFunc = function formatFunc(meta, config, currentValue) {
  var _currentValue$get, _currentValue$get2;
  var parentField = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
  var funcKey = (_currentValue$get = currentValue.get) === null || _currentValue$get === void 0 ? void 0 : _currentValue$get.call(currentValue, "func");
  var args = (_currentValue$get2 = currentValue.get) === null || _currentValue$get2 === void 0 ? void 0 : _currentValue$get2.call(currentValue, "args");
  var funcConfig = (0, _configUtils.getFuncConfig)(config, funcKey);
  var funcParts = (0, _configUtils.getFieldParts)(funcKey, config);
  var funcLastKey = funcParts[funcParts.length - 1];
  if (!funcConfig) {
    meta.errors.push("Func ".concat(funcKey, " is not defined in config"));
    return undefined;
  }
  if (!(funcConfig !== null && funcConfig !== void 0 && funcConfig.jsonLogic)) {
    meta.errors.push("Func ".concat(funcKey, " is not supported"));
    return undefined;
  }
  var formattedArgs = {};
  var gaps = [];
  var missingArgKeys = [];
  for (var argKey in funcConfig.args) {
    var _argValue;
    var argConfig = funcConfig.args[argKey];
    var fieldDef = (0, _configUtils.getFieldConfig)(config, argConfig);
    var defaultValue = argConfig.defaultValue,
      isOptional = argConfig.isOptional;
    var defaultValueSrc = defaultValue !== null && defaultValue !== void 0 && defaultValue.func ? "func" : "value";
    var argVal = args ? args.get(argKey) : undefined;
    var argValue = argVal ? argVal.get("value") : undefined;
    var argValueSrc = argVal ? argVal.get("valueSrc") : undefined;
    if (argValueSrc !== "func" && (_argValue = argValue) !== null && _argValue !== void 0 && _argValue.toJS) {
      // value should not be Immutable
      argValue = argValue.toJS();
    }
    var operator = null;
    var widget = (0, _configUtils.getWidgetForFieldOp)(config, argConfig, operator, argValueSrc);
    var fieldWidgetDef = (0, _configUtils.getFieldWidgetConfig)(config, argConfig, operator, widget, argValueSrc, {
      forExport: true
    });
    var formattedArgVal = formatValue(meta, config, argValue, argValueSrc, argConfig.type, fieldWidgetDef, fieldDef, null, null, parentField);
    if (argValue != undefined && formattedArgVal === undefined) {
      if (argValueSrc != "func")
        // don't triger error if args value is another incomplete function
        meta.errors.push("Can't format value of arg ".concat(argKey, " for func ").concat(funcKey));
      return undefined;
    }
    var formattedDefaultVal = void 0;
    if (formattedArgVal === undefined && !isOptional && defaultValue != undefined) {
      var defaultWidget = (0, _configUtils.getWidgetForFieldOp)(config, argConfig, operator, defaultValueSrc);
      var defaultFieldWidgetDef = (0, _configUtils.getFieldWidgetConfig)(config, argConfig, operator, defaultWidget, defaultValueSrc, {
        forExport: true
      });
      formattedDefaultVal = formatValue(meta, config, defaultValue, defaultValueSrc, argConfig.type, defaultFieldWidgetDef, fieldDef, null, null, parentField);
      if (formattedDefaultVal === undefined) {
        if (defaultValueSrc != "func")
          // don't triger error if args value is another incomplete function
          meta.errors.push("Can't format default value of arg ".concat(argKey, " for func ").concat(funcKey));
        return undefined;
      }
    }
    var finalFormattedVal = formattedArgVal !== null && formattedArgVal !== void 0 ? formattedArgVal : formattedDefaultVal;
    if (finalFormattedVal !== undefined) {
      if (gaps.length) {
        var _iterator2 = _createForOfIteratorHelper(gaps),
          _step2;
        try {
          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
            var missedArgKey = _step2.value;
            formattedArgs[missedArgKey] = undefined;
          }
        } catch (err) {
          _iterator2.e(err);
        } finally {
          _iterator2.f();
        }
        gaps = [];
      }
      formattedArgs[argKey] = finalFormattedVal;
    } else {
      if (!isOptional) missingArgKeys.push(argKey);
      gaps.push(argKey);
    }
  }
  if (missingArgKeys.length) {
    //meta.errors.push(`Missing vals for args ${missingArgKeys.join(", ")} for func ${funcKey}`);
    return undefined; // incomplete
  }
  var formattedArgsArr = Object.values(formattedArgs);
  var ret;
  if (typeof funcConfig.jsonLogic === "function") {
    var fn = funcConfig.jsonLogic;
    var _args = [formattedArgs];
    ret = fn.call.apply(fn, [config.ctx].concat(_args));
  } else {
    var funcName = funcConfig.jsonLogic || funcLastKey;
    var isMethod = !!funcConfig.jsonLogicIsMethod;
    if (isMethod) {
      var obj = formattedArgsArr[0],
        params = formattedArgsArr.slice(1);
      if (params.length) {
        ret = {
          "method": [obj, funcName, params]
        };
      } else {
        ret = {
          "method": [obj, funcName]
        };
      }
    } else {
      ret = (0, _defineProperty2["default"])({}, funcName, formattedArgsArr);
    }
  }
  return ret;
};
var formatField = function formatField(meta, config, field) {
  var parentField = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
  var _config$settings = config.settings,
    fieldSeparator = _config$settings.fieldSeparator,
    jsonLogic = _config$settings.jsonLogic;
  var ret;
  if (field) {
    if (Array.isArray(field)) field = field.join(fieldSeparator);
    var fieldDef = (0, _configUtils.getFieldConfig)(config, field) || {};
    var fieldName = (0, _ruleUtils.formatFieldName)(field, config, meta, parentField);
    var varName = fieldDef.jsonLogicVar || (fieldDef.type == "!group" ? jsonLogic.groupVarKey : "var");
    ret = (0, _defineProperty2["default"])({}, varName, fieldName);
    if (meta.usedFields.indexOf(field) == -1) meta.usedFields.push(field);
  }
  return ret;
};
var buildFnToFormatOp = function buildFnToFormatOp(operator, operatorDefinition, formattedField, formattedValue, expectedType) {
  var formattedOp = operator;
  var cardinality = (0, _stuff.getOpCardinality)(operatorDefinition);
  if (typeof operatorDefinition.jsonLogic == "string") formattedOp = operatorDefinition.jsonLogic;
  var rangeOps = ["<", "<=", ">", ">="];
  var eqOps = ["==", "!="];
  var fn = function fn(field, op, val, opDef, opOpts) {
    if (cardinality == 0 && eqOps.includes(formattedOp)) return (0, _defineProperty2["default"])({}, formattedOp, [formattedField, null]);else if (cardinality == 0) return (0, _defineProperty2["default"])({}, formattedOp, formattedField);
    // else if (cardinality == 1 && eqOps.includes(formattedOp) && ["date", "datetime"].includes(expectedType))
    //   return { [expectedType+formattedOp]: [formattedField, formattedValue] };
    else if (cardinality == 1) return (0, _defineProperty2["default"])({}, formattedOp, [formattedField, formattedValue]);else if (cardinality == 2 && rangeOps.includes(formattedOp)) return (0, _defineProperty2["default"])({}, formattedOp, [formattedValue[0], formattedField, formattedValue[1]]);else return (0, _defineProperty2["default"])({}, formattedOp, [formattedField].concat((0, _toConsumableArray2["default"])(formattedValue)));
  };
  return fn;
};
var formatLogic = function formatLogic(config, properties, formattedField, formattedValue, operator) {
  var _properties$get, _fieldDefinition$type;
  var operatorOptions = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : null;
  var fieldDefinition = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : null;
  var isRev = arguments.length > 7 && arguments[7] !== undefined ? arguments[7] : false;
  var field = properties.get("field");
  //const fieldSrc = properties.get("fieldSrc");
  var firstValueType = (_properties$get = properties.get("valueType")) === null || _properties$get === void 0 ? void 0 : _properties$get.get(0);
  var operatorDefinition = (0, _configUtils.getOperatorConfig)(config, operator, field) || {};
  var expectedType = (_fieldDefinition$type = fieldDefinition === null || fieldDefinition === void 0 ? void 0 : fieldDefinition.type) !== null && _fieldDefinition$type !== void 0 ? _fieldDefinition$type : firstValueType;
  var fn = typeof operatorDefinition.jsonLogic == "function" ? operatorDefinition.jsonLogic : buildFnToFormatOp(operator, operatorDefinition, formattedField, formattedValue, expectedType);
  var args = [formattedField, operator, formattedValue, (0, _stuff.omit)(operatorDefinition, _stuff.opDefKeysToOmit), operatorOptions, fieldDefinition, expectedType, config.settings];
  var ruleQuery = fn.call.apply(fn, [config.ctx].concat(args));
  if (isRev) {
    ruleQuery = {
      "!": ruleQuery
    };
  }
  return ruleQuery;
};