@react-awesome-query-builder/core/cjs/import/spel/convert.js

User-friendly query builder for React. Core

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
var _typeof = require("@babel/runtime/helpers/typeof");
Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.convertToTree = exports.convertCaseValueConcat = exports.convertCaseValue = exports.convertArg = void 0;
var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
var _builder = require("./builder");
var _postprocess = require("./postprocess");
var _conv = require("./conv");
var Utils = _interopRequireWildcard(require("../../utils"));
function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { "default": e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n["default"] = e, t && t.set(e, n), n; }
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; }
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; }
var _Utils$OtherUtils = Utils.OtherUtils,
  isJsonCompatible = _Utils$OtherUtils.isJsonCompatible,
  isObject = _Utils$OtherUtils.isObject,
  uuid = _Utils$OtherUtils.uuid,
  logger = _Utils$OtherUtils.logger;
var _Utils$ConfigUtils = Utils.ConfigUtils,
  getFieldConfig = _Utils$ConfigUtils.getFieldConfig,
  getFuncConfig = _Utils$ConfigUtils.getFuncConfig,
  normalizeField = _Utils$ConfigUtils.normalizeField,
  iterateFuncs = _Utils$ConfigUtils.iterateFuncs,
  getWidgetForFieldOp = _Utils$ConfigUtils.getWidgetForFieldOp;

// spel type => raqb type
var SpelPrimitiveTypes = {
  number: "number",
  string: "text",
  "boolean": "boolean",
  "null": "null" // should not be
};
// spel class => raqb type
var SpelPrimitiveClasses = {
  String: "text"
};
var ListValueType = "multiselect";
var _convertToTree = exports.convertToTree = function convertToTree(spel, conv, config, meta) {
  var _spel$_groupField;
  var parentSpel = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null;
  if (!spel) return undefined;
  spel._groupField = (_spel$_groupField = spel._groupField) !== null && _spel$_groupField !== void 0 ? _spel$_groupField : parentSpel === null || parentSpel === void 0 ? void 0 : parentSpel._groupField;
  var res,
    canParseAsArg = true;
  if (spel.type.indexOf("op-") === 0 || spel.type === "matches") {
    res = _convertOp(spel, conv, config, meta, parentSpel);
  } else if (spel.type == "!aggr") {
    var _groupFilter;
    var groupFieldValue = _convertToTree(spel.source, conv, config, meta, spel);
    spel._groupField = groupFieldValue === null || groupFieldValue === void 0 ? void 0 : groupFieldValue.value;
    var groupFilter = _convertToTree(spel.filter, conv, config, meta, spel);
    if (((_groupFilter = groupFilter) === null || _groupFilter === void 0 ? void 0 : _groupFilter.type) == "rule") {
      groupFilter = (0, _builder.wrapInDefaultConj)(groupFilter, config, spel.filter.not);
    }
    res = {
      groupFilter: groupFilter,
      groupFieldValue: groupFieldValue
    };
    if (!parentSpel) {
      // !aggr can't be in root, it should be compared with something
      res = undefined;
      meta.errors.push("Unexpected !aggr in root");
      canParseAsArg = false;
    }
  } else if (spel.type == "ternary") {
    var children1 = {};
    spel.val.forEach(function (v) {
      var _v = (0, _slicedToArray2["default"])(v, 2),
        cond = _v[0],
        val = _v[1];
      var convCond = _convertToTree(cond, conv, config, meta, spel);
      var convVal = convertCaseValue(val, conv, config, meta, spel);
      var caseI = (0, _builder.buildCase)(convCond, convVal, conv, config, meta, spel);
      if (caseI) {
        children1[caseI.id] = caseI;
      }
    });
    res = {
      type: "switch_group",
      id: uuid(),
      children1: children1,
      properties: {}
    };
  }
  if (!res && canParseAsArg) {
    res = _convertArg(spel, conv, config, meta, parentSpel);
  }
  if (res && !res.type && !parentSpel) {
    // res is not a rule, it's value at root
    // try to parse whole `"1"` as ternary
    var convVal = convertCaseValue(spel, conv, config, meta);
    var sw = (0, _builder.buildSimpleSwitch)(convVal, conv, config, meta);
    if (sw) {
      res = sw;
    } else {
      res = undefined;
      meta.errors.push("Can't convert rule of type ".concat(spel.type, ", it looks like var/literal"));
    }
  }
  return res;
};
var _convertOp = function convertOp(spel, conv, config, meta) {
  var parentSpel = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null;
  var res;
  var op = spel.type.startsWith("op-") ? spel.type.slice("op-".length) : spel.type;

  // unary
  var isUnary = (op == "minus" || op == "plus") && spel.children.length == 1;
  if (isUnary) {
    var negative = spel.negative;
    if (op == "minus") {
      negative = !negative;
    }
    spel.children[0].negative = negative;
    return _convertToTree(spel.children[0], conv, config, meta, parentSpel);
  }

  // between
  var isBetweenNormal = op == "and" && spel.children.length == 2 && spel.children[0].type == "op-ge" && spel.children[1].type == "op-le";
  var isBetweenRev = op == "or" && spel.children.length == 2 && spel.children[0].type == "op-lt" && spel.children[1].type == "op-gt";
  var isBetween = isBetweenNormal || isBetweenRev;
  if (isBetween) {
    var _spel$children$0$chil = (0, _slicedToArray2["default"])(spel.children[0].children, 2),
      left = _spel$children$0$chil[0],
      from = _spel$children$0$chil[1];
    var _spel$children$1$chil = (0, _slicedToArray2["default"])(spel.children[1].children, 2),
      right = _spel$children$1$chil[0],
      to = _spel$children$1$chil[1];
    var isSameSource = compareArgs(left, right, spel, conv, config, meta, parentSpel);
    if (isSameSource) {
      var _fromValue = from.val;
      var _toValue = to.val;
      var oneSpel = {
        type: "op-between",
        children: [left, from, to],
        not: isBetweenRev
      };
      oneSpel._groupField = parentSpel === null || parentSpel === void 0 ? void 0 : parentSpel._groupField;
      return _convertOp(oneSpel, conv, config, meta, parentSpel);
    }
  }

  // find op
  var opKeys = conv.operators[op];
  if (op == "eq" && spel.children[1].type == "null") {
    opKeys = ["is_null"];
  } else if (op == "ne" && spel.children[1].type == "null") {
    opKeys = ["is_not_null"];
  } else if (op == "le" && spel.children[1].type == "string" && spel.children[1].val == "") {
    opKeys = ["is_empty"];
  } else if (op == "gt" && spel.children[1].type == "string" && spel.children[1].val == "") {
    opKeys = ["is_not_empty"];
  } else if (op == "between") {
    opKeys = ["between"];
  }

  // convert children
  var convertChildren = function convertChildren() {
    var _newChildren;
    var newChildren = spel.children.map(function (child) {
      return _convertToTree(child, conv, config, meta, spel);
    });
    if (newChildren.length >= 2 && ((_newChildren = newChildren) === null || _newChildren === void 0 || (_newChildren = _newChildren[0]) === null || _newChildren === void 0 ? void 0 : _newChildren.type) == "!compare") {
      newChildren = newChildren[0].children;
    }
    return newChildren;
  };
  if (op == "and" || op == "or") {
    var children1 = {};
    var vals = convertChildren();
    vals.forEach(function (v) {
      if (v) {
        var id = uuid();
        v.id = id;
        if (v.type != undefined) {
          children1[id] = v;
        } else {
          meta.errors.push("Bad item in AND/OR: ".concat(JSON.stringify(v)));
        }
      }
    });
    res = {
      type: "group",
      id: uuid(),
      children1: children1,
      properties: {
        conjunction: conv.conjunctions[op],
        not: spel.not
      }
    };
  } else if (opKeys) {
    var _fieldObj$groupFieldV, _convertedArgs, _opConfig;
    var _vals = convertChildren();
    var fieldObj = _vals[0];
    var convertedArgs = _vals.slice(1);
    var groupField = fieldObj === null || fieldObj === void 0 || (_fieldObj$groupFieldV = fieldObj.groupFieldValue) === null || _fieldObj$groupFieldV === void 0 ? void 0 : _fieldObj$groupFieldV.value;
    var opArg = (_convertedArgs = convertedArgs) === null || _convertedArgs === void 0 ? void 0 : _convertedArgs[0];
    var opKey = opKeys[0];
    if (opKeys.length > 1) {
      var _vals$, _vals$2;
      var valueType = ((_vals$ = _vals[0]) === null || _vals$ === void 0 ? void 0 : _vals$.valueType) || ((_vals$2 = _vals[1]) === null || _vals$2 === void 0 ? void 0 : _vals$2.valueType);
      //todo: it's naive, use valueType
      var field = fieldObj === null || fieldObj === void 0 ? void 0 : fieldObj.value;
      var widgets = opKeys.map(function (op) {
        return {
          op: op,
          widget: getWidgetForFieldOp(config, field, op)
        };
      });
      if (op == "eq" || op == "ne") {
        var ws = widgets.find(function (_ref) {
          var op = _ref.op,
            widget = _ref.widget;
          return widget && widget != "field";
        });
        if (ws) {
          opKey = ws.op;
        }
      } else {
        logger.warn("[spel] Spel operator ".concat(op, " can be mapped to ").concat(opKeys, "."), "widgets:", widgets, "vals:", _vals, "valueType=", valueType);
      }
    }

    // some/all/none
    if (fieldObj !== null && fieldObj !== void 0 && fieldObj.groupFieldValue) {
      if (opArg && opArg.groupFieldValue && opArg.groupFieldValue.valueSrc == "field" && opArg.groupFieldValue.value == groupField) {
        // group.?[...].size() == group.size()
        opKey = "all";
        convertedArgs = [];
      } else if (opKey == "equal" && opArg.valueSrc == "value" && opArg.valueType == "number" && opArg.value == 0) {
        opKey = "none";
        convertedArgs = [];
      } else if (opKey == "greater" && opArg.valueSrc == "value" && opArg.valueType == "number" && opArg.value == 0) {
        opKey = "some";
        convertedArgs = [];
      }
    }
    var opConfig = config.operators[opKey];
    var reversedOpConfig = config.operators[(_opConfig = opConfig) === null || _opConfig === void 0 ? void 0 : _opConfig.reversedOp];
    var opNeedsReverse = spel.not && ["between"].includes(opKey);
    var opCanReverse = !!reversedOpConfig;
    var canRev = opCanReverse && (!!config.settings.reverseOperatorsForNot || opNeedsReverse);
    var needRev = spel.not && canRev || opNeedsReverse;
    if (needRev) {
      opKey = opConfig.reversedOp;
      opConfig = config.operators[opKey];
      spel.not = !spel.not;
    }
    var needWrapWithNot = !!spel.not;
    spel.not = false; // handled with needWrapWithNot

    if (!fieldObj) {
      // LHS can't be parsed
    } else if (fieldObj.groupFieldValue) {
      // 1. group
      if (fieldObj.groupFieldValue.valueSrc != "field") {
        meta.errors.push("Expected group field ".concat(JSON.stringify(fieldObj)));
      }
      res = (0, _builder.buildRuleGroup)(fieldObj, opKey, convertedArgs, config, meta);
    } else {
      // 2. not group
      if (fieldObj.valueSrc != "field" && fieldObj.valueSrc != "func") {
        meta.errors.push("Expected field/func at LHS, but got ".concat(JSON.stringify(fieldObj)));
      }
      var _field = fieldObj.value;
      res = (0, _builder.buildRule)(config, meta, _field, opKey, convertedArgs, spel);
    }
    if (needWrapWithNot) {
      if (res.type !== "group") {
        res = (0, _builder.wrapInDefaultConj)(res, config, true);
      } else {
        res.properties.not = !res.properties.not;
      }
    }
  } else {
    if (!parentSpel) {
      // try to parse whole `"str" + prop + #var` as ternary
      var convVal = convertCaseValue(spel, conv, config, meta);
      res = (0, _builder.buildSimpleSwitch)(convVal, conv, config, meta);
    }
    // if (!res) {
    //   meta.errors.push(`Can't convert op ${op}`);
    // }
  }
  return res;
};
var _convertArg = exports.convertArg = function convertArg(spel, conv, config, meta) {
  var _spel$_groupField2, _config$settings$case;
  var parentSpel = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null;
  if (spel == undefined) return undefined;
  var fieldSeparator = config.settings.fieldSeparator;
  spel._groupField = (_spel$_groupField2 = spel._groupField) !== null && _spel$_groupField2 !== void 0 ? _spel$_groupField2 : parentSpel === null || parentSpel === void 0 ? void 0 : parentSpel._groupField;
  if (spel.type == "variable" || spel.type == "property") {
    // normal field
    var field = normalizeField(config, spel.val, spel._groupField);
    var fieldConfig = getFieldConfig(config, field);
    var isVariable = spel.type == "variable";
    return {
      valueSrc: "field",
      valueType: fieldConfig === null || fieldConfig === void 0 ? void 0 : fieldConfig.type,
      isVariable: isVariable,
      value: field
    };
  } else if (spel.type == "compound") {
    // complex field
    var parts = (0, _postprocess.convertPath)(spel.children, meta);
    if (parts) {
      var _spel$children;
      var _field2 = normalizeField(config, parts.join(fieldSeparator), spel._groupField);
      var _fieldConfig = getFieldConfig(config, _field2);
      var _isVariable = ((_spel$children = spel.children) === null || _spel$children === void 0 || (_spel$children = _spel$children[0]) === null || _spel$children === void 0 ? void 0 : _spel$children.type) == "variable";
      return {
        valueSrc: "field",
        valueType: _fieldConfig === null || _fieldConfig === void 0 ? void 0 : _fieldConfig.type,
        isVariable: _isVariable,
        value: _field2
      };
    } else {
      // it's not complex field
    }
  } else if (SpelPrimitiveTypes[spel.type]) {
    var value = spel.val;
    var valueType = SpelPrimitiveTypes[spel.type];
    if (spel.negative) {
      value = -value;
    }
    return {
      valueSrc: "value",
      valueType: valueType,
      value: value
    };
  } else if (spel.type == "!new" && SpelPrimitiveClasses[spel.cls.at(-1)]) {
    var args = spel.args.map(function (v) {
      return _convertArg(v, conv, config, meta, spel);
    });
    var _value = args === null || args === void 0 ? void 0 : args[0];
    var _valueType = SpelPrimitiveClasses[spel.cls.at(-1)];
    return _objectSpread(_objectSpread({}, _value), {}, {
      valueType: _valueType
    });
  } else if (spel.type == "list") {
    var _values$;
    var values = spel.val.map(function (v) {
      return _convertArg(v, conv, config, meta, spel);
    });
    var _itemType = values.length ? (_values$ = values[0]) === null || _values$ === void 0 ? void 0 : _values$.valueType : null;
    var _value2 = values.map(function (v) {
      return v === null || v === void 0 ? void 0 : v.value;
    });
    var _valueType2 = ListValueType;
    return {
      valueSrc: "value",
      valueType: _valueType2,
      value: _value2
    };
  } else if (spel.type === "op-plus" && (parentSpel === null || parentSpel === void 0 ? void 0 : parentSpel.type) === "ternary" && ((_config$settings$case = config.settings.caseValueField) === null || _config$settings$case === void 0 ? void 0 : _config$settings$case.type) === "case_value") {
    /**
     * @deprecated
     */
    return convertCaseValueConcat(spel, conv, config, meta);
  }
  var maybe = convertFunc(spel, conv, config, meta, parentSpel);
  if (maybe !== undefined) {
    return maybe;
  }
  meta.errors.push("Can't convert arg of type ".concat(spel.type));
  return undefined;
};
var convertFunc = function convertFunc(spel, conv, config, meta) {
  var _fsigns$;
  var parentSpel = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null;
  // Build signatures
  var convertFuncArg = function convertFuncArg(v) {
    return _convertToTree(v, conv, config, meta, spel);
  };
  var fsigns = (0, _conv.buildFuncSignatures)(spel);
  var firstSign = fsigns === null || fsigns === void 0 || (_fsigns$ = fsigns[0]) === null || _fsigns$ === void 0 ? void 0 : _fsigns$.s;
  if (fsigns.length) logger.debug("Signatures for ", spel, ":", firstSign, fsigns);

  // 1. Try to parse as value
  var maybeValue = convertFuncToValue(spel, conv, config, meta, parentSpel, fsigns, convertFuncArg);
  if (maybeValue !== undefined) return maybeValue;

  // 2. Try to parse as op
  var maybeOp = convertFuncToOp(spel, conv, config, meta, parentSpel, fsigns, convertFuncArg);
  if (maybeOp !== undefined) return maybeOp;

  // 3. Try to parse as func
  var funcKey, funcConfig, argsObj;
  // try func signature matching
  var _iterator = _createForOfIteratorHelper(fsigns),
    _step;
  try {
    var _loop = function _loop() {
      var _step$value = _step.value,
        s = _step$value.s,
        params = _step$value.params;
      var funcKeys = conv.funcs[s];
      if (funcKeys) {
        // todo: here we can check arg types, if we have function overloading
        funcKey = funcKeys[0];
        funcConfig = getFuncConfig(config, funcKey);
        var _funcConfig2 = funcConfig,
          spelFunc = _funcConfig2.spelFunc;
        var argsArr = params.map(convertFuncArg);
        var argsOrder = (0, _toConsumableArray2["default"])(spelFunc.matchAll(/\${(\w+)}/g)).map(function (_ref2) {
          var _ref3 = (0, _slicedToArray2["default"])(_ref2, 2),
            _ = _ref3[0],
            k = _ref3[1];
          return k;
        });
        argsObj = Object.fromEntries(argsOrder.map(function (argKey, i) {
          return [argKey, argsArr[i]];
        }));
        return 1; // break
      }
    };
    for (_iterator.s(); !(_step = _iterator.n()).done;) {
      if (_loop()) break;
    }
    // try `spelImport`
  } catch (err) {
    _iterator.e(err);
  } finally {
    _iterator.f();
  }
  if (!funcKey) {
    var _iterator2 = _createForOfIteratorHelper(iterateFuncs(config)),
      _step2;
    try {
      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
        var _step2$value = (0, _slicedToArray2["default"])(_step2.value, 2),
          f = _step2$value[0],
          fc = _step2$value[1];
        if (fc.spelImport) {
          var parsed = void 0;
          try {
            parsed = fc.spelImport.call(config.ctx, spel);
          } catch (e) {
            logger.debug("Error while using spelImport for ".concat(f), e);
            // can't be parsed
          }
          if (parsed) {
            var _funcConfig;
            funcKey = f;
            funcConfig = getFuncConfig(config, funcKey);
            argsObj = {};
            for (var argKey in parsed) {
              argsObj[argKey] = convertFuncArg(parsed[argKey]);
            }

            // Special case to distinct date and datetime
            var isOk = true;
            var funcType = (_funcConfig = funcConfig) === null || _funcConfig === void 0 ? void 0 : _funcConfig.returnType;
            if (["date", "datetime"].includes(funcType)) {
              var _funcConfig$args;
              var dateArgsKeys = Object.keys((_funcConfig$args = funcConfig.args) !== null && _funcConfig$args !== void 0 ? _funcConfig$args : []).filter(function (k) {
                return ["date", "datetime"].includes(funcConfig.args[k].type);
              });
              var _iterator3 = _createForOfIteratorHelper(dateArgsKeys),
                _step3;
              try {
                for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
                  var _argsObj$k;
                  var k = _step3.value;
                  var argConfig = funcConfig.args[k];
                  var expectedType = argConfig.type;
                  var realType = (_argsObj$k = argsObj[k]) === null || _argsObj$k === void 0 ? void 0 : _argsObj$k.valueType;
                  if (realType && realType != expectedType) {
                    isOk = false;
                  }
                }
              } catch (err) {
                _iterator3.e(err);
              } finally {
                _iterator3.f();
              }
            }
            if (isOk) {
              break;
            }
          }
        }
      }
    } catch (err) {
      _iterator2.e(err);
    } finally {
      _iterator2.f();
    }
  }

  // final convert
  if (funcKey) {
    var funcArgs = {};
    for (var _argKey in funcConfig.args) {
      var _argConfig = funcConfig.args[_argKey];
      var argVal = argsObj[_argKey];
      if (argVal === undefined) {
        argVal = _argConfig === null || _argConfig === void 0 ? void 0 : _argConfig.defaultValue;
        if (argVal === undefined) {
          if (_argConfig !== null && _argConfig !== void 0 && _argConfig.isOptional) {
            //ignore
          } else {
            meta.errors.push("No value for arg ".concat(_argKey, " of func ").concat(funcKey));
            return undefined;
          }
        } else {
          var _argVal;
          argVal = {
            value: argVal,
            valueSrc: (_argVal = argVal) !== null && _argVal !== void 0 && _argVal.func ? "func" : "value",
            valueType: _argConfig.type
          };
        }
      }
      if (argVal) funcArgs[_argKey] = argVal;
    }
    return {
      valueSrc: "func",
      value: {
        func: funcKey,
        args: funcArgs
      },
      valueType: funcConfig.returnType
    };
  }
  var methodName = spel.methodName;
  if (methodName) {
    meta.errors.push("Signature ".concat(firstSign, " - failed to convert"));
  }
  return undefined;
};
var convertFuncToValue = function convertFuncToValue(spel, conv, config, meta, parentSpel, fsigns, convertFuncArg) {
  var errs, foundSign, foundWidget;
  var candidates = [];
  for (var w in config.widgets) {
    var widgetDef = config.widgets[w];
    var spelImportFuncs = widgetDef.spelImportFuncs;
    if (spelImportFuncs) {
      for (var i = 0; i < spelImportFuncs.length; i++) {
        var fj = spelImportFuncs[i];
        if (isObject(fj)) {
          var bag = {};
          if (isJsonCompatible(fj, spel, bag)) {
            for (var k in bag) {
              bag[k] = convertFuncArg(bag[k]);
            }
            candidates.push({
              s: "widgets.".concat(w, ".spelImportFuncs[").concat(i, "]"),
              w: w,
              argsObj: bag
            });
          }
        }
      }
    }
  }
  var _iterator4 = _createForOfIteratorHelper(fsigns),
    _step4;
  try {
    for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
      var _step4$value = _step4.value,
        _s = _step4$value.s,
        params = _step4$value.params;
      var found = conv.valueFuncs[_s] || [];
      var _iterator5 = _createForOfIteratorHelper(found),
        _step5;
      try {
        var _loop2 = function _loop2() {
          var _step5$value = _step5.value,
            w = _step5$value.w,
            argsOrder = _step5$value.argsOrder;
          var argsArr = params.map(convertFuncArg);
          var argsObj = Object.fromEntries(argsOrder.map(function (argKey, i) {
            return [argKey, argsArr[i]];
          }));
          candidates.push({
            s: _s,
            w: w,
            argsObj: argsObj
          });
        };
        for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
          _loop2();
        }
      } catch (err) {
        _iterator5.e(err);
      } finally {
        _iterator5.f();
      }
    }
  } catch (err) {
    _iterator4.e(err);
  } finally {
    _iterator4.f();
  }
  for (var _i = 0, _candidates = candidates; _i < _candidates.length; _i++) {
    var _candidates$_i = _candidates[_i],
      s = _candidates$_i.s,
      _w = _candidates$_i.w,
      argsObj = _candidates$_i.argsObj;
    var _widgetDef = config.widgets[_w];
    var spelImportValue = _widgetDef.spelImportValue,
      type = _widgetDef.type;
    foundWidget = _w;
    foundSign = s;
    errs = [];
    for (var _k in argsObj) {
      if (!["value"].includes(argsObj[_k].valueSrc)) {
        errs.push("".concat(_k, " has unsupported value src ").concat(argsObj[_k].valueSrc));
      }
    }
    var value = argsObj.v.value;
    if (spelImportValue && !errs.length) {
      var _spelImportValue$call = spelImportValue.call(config.ctx, argsObj.v, _widgetDef, argsObj);
      var _spelImportValue$call2 = (0, _slicedToArray2["default"])(_spelImportValue$call, 2);
      value = _spelImportValue$call2[0];
      errs = _spelImportValue$call2[1];
      if (errs && !Array.isArray(errs)) errs = [errs];
    }
    if (!errs.length) {
      return {
        valueSrc: "value",
        valueType: type,
        value: value
      };
    }
  }
  if (foundWidget && errs.length) {
    meta.errors.push("Signature ".concat(foundSign, " - looks like convertable to ").concat(foundWidget, ", but: ").concat(errs.join("; ")));
  }
  return undefined;
};
var convertFuncToOp = function convertFuncToOp(spel, conv, config, meta, parentSpel, fsigns, convertFuncArg) {
  var candidates = [];
  var _iterator6 = _createForOfIteratorHelper(fsigns),
    _step6;
  try {
    for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
      var _step6$value = _step6.value,
        s = _step6$value.s,
        params = _step6$value.params;
      var found = conv.opFuncs[s] || [];
      var _iterator7 = _createForOfIteratorHelper(found),
        _step7;
      try {
        var _loop4 = function _loop4() {
            var _argsArr$filter;
            var _step7$value = _step7.value,
              op = _step7$value.op,
              argsOrder = _step7$value.argsOrder;
            var argsArr = params.map(convertFuncArg);
            var errs = [];
            if (op === "!compare") {
              if (parentSpel.type.startsWith("op-") && parentSpel.children.length == 2 && parentSpel.children[1].type == "number" && parentSpel.children[1].val === 0) {
                return {
                  v: {
                    type: "!compare",
                    children: argsArr
                  }
                };
              } else {
                errs.push("Result of compareTo() should be compared to 0");
              }
            }
            var opDef = config.operators[op];
            var valueTypes = opDef.valueTypes;
            var argsObj = Object.fromEntries(argsOrder.map(function (argKey, i) {
              return [argKey, argsArr[i]];
            }));
            var field = argsObj["0"];
            var convertedArgs = Object.keys(argsObj).filter(function (k) {
              return parseInt(k) > 0;
            }).map(function (k) {
              return argsObj[k];
            });
            var valueType = (_argsArr$filter = argsArr.filter(function (a) {
              return !!a && a !== field;
            })) === null || _argsArr$filter === void 0 || (_argsArr$filter = _argsArr$filter[0]) === null || _argsArr$filter === void 0 ? void 0 : _argsArr$filter.valueType;
            if (valueTypes && valueType && !valueTypes.includes(valueType)) {
              errs.push("Op supports types ".concat(valueTypes, ", but got ").concat(valueType));
            }
            candidates.push({
              opKey: op,
              foundSign: s,
              field: field,
              convertedArgs: convertedArgs,
              errs: errs
            });
          },
          _ret;
        for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
          _ret = _loop4();
          if (_ret) return _ret.v;
        }
      } catch (err) {
        _iterator7.e(err);
      } finally {
        _iterator7.f();
      }
    }
  } catch (err) {
    _iterator6.e(err);
  } finally {
    _iterator6.f();
  }
  for (var op in config.operators) {
    var opDef = config.operators[op];
    var spelImportFuncs = opDef.spelImportFuncs,
      valueTypes = opDef.valueTypes;
    if (spelImportFuncs) {
      var _loop3 = function _loop3() {
        var fj = spelImportFuncs[i];
        if (isObject(fj)) {
          var argsObj = {};
          if (isJsonCompatible(fj, spel, argsObj)) {
            var _argsObj$;
            var errs = [];
            for (var k in argsObj) {
              argsObj[k] = convertFuncArg(argsObj[k]);
            }
            var field = argsObj["0"];
            var convertedArgs = Object.keys(argsObj).filter(function (k) {
              return parseInt(k) > 0;
            }).map(function (k) {
              return argsObj[k];
            });
            var valueType = (_argsObj$ = argsObj["1"]) === null || _argsObj$ === void 0 ? void 0 : _argsObj$.valueType;
            if (valueTypes && valueType && !valueTypes.includes(valueType)) {
              errs.push("Op supports types ".concat(valueTypes, ", but got ").concat(valueType));
            }
            candidates.push({
              opKey: op,
              foundSign: "spelImportFuncs[".concat(i, "]"),
              field: field,
              convertedArgs: convertedArgs,
              errs: errs
            });
          }
        }
      };
      for (var i = 0; i < spelImportFuncs.length; i++) {
        _loop3();
      }
    }
  }
  var bestCandidate = candidates.find(function (_ref4) {
    var errs = _ref4.errs;
    return !errs.length;
  });
  if (bestCandidate) {
    var opKey = bestCandidate.opKey,
      foundSign = bestCandidate.foundSign,
      field = bestCandidate.field,
      convertedArgs = bestCandidate.convertedArgs,
      errs = bestCandidate.errs;
    return (0, _builder.buildRule)(config, meta, field, opKey, convertedArgs, spel);
  } else if (candidates.length) {
    var allErrs = candidates.map(function (_ref5) {
      var foundSign = _ref5.foundSign,
        opKey = _ref5.opKey,
        errs = _ref5.errs;
      return "Looks like convertable to ".concat(opKey, " with signature ").concat(foundSign, ", but: ").concat(errs.join("; "));
    }).join(".  ");
    meta.errors.push(allErrs);
  }
  return undefined;
};
var compareArgs = function compareArgs(left, right, spel, conv, config, meta) {
  if (left.type == right.type) {
    if (left.type == "!aggr") {
      var _map = [left.source, right.source].map(function (v) {
          return _convertArg(v, conv, config, meta, spel);
        }),
        _map2 = (0, _slicedToArray2["default"])(_map, 2),
        leftSource = _map2[0],
        rightSource = _map2[1];
      //todo: check same filter
      return leftSource.value == rightSource.value;
    } else {
      var _map3 = [left, right].map(function (v) {
          return _convertArg(v, conv, config, meta, spel);
        }),
        _map4 = (0, _slicedToArray2["default"])(_map3, 2),
        leftVal = _map4[0],
        rightVal = _map4[1];
      return leftVal.value == rightVal.value;
    }
  }
  return false;
};
var convertCaseValue = exports.convertCaseValue = function convertCaseValue(val, conv, config, meta) {
  var _config$settings$case2;
  var spel = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null;
  var convVal;
  if ((val === null || val === void 0 ? void 0 : val.type) === "op-plus" && ((_config$settings$case2 = config.settings.caseValueField) === null || _config$settings$case2 === void 0 ? void 0 : _config$settings$case2.type) === "case_value") {
    /**
     * @deprecated
     */
    convVal = convertCaseValueConcat(val, conv, config, meta);
  } else {
    convVal = _convertArg(val, conv, config, meta, spel);
  }
  return convVal;
};

/**
 * @deprecated
 */
var convertCaseValueConcat = exports.convertCaseValueConcat = function convertCaseValueConcat(spel, conv, config, meta) {
  var flat = [];
  function _processConcatChildren(children) {
    children.map(function (child) {
      if (child.type === "op-plus") {
        _processConcatChildren(child.children);
      } else {
        var convertedChild = _convertArg(child, conv, config, meta, spel);
        if (convertedChild) {
          flat.push(convertedChild);
        } else {
          meta.errors.push("Can't convert ".concat(child.type, " in concatenation"));
        }
      }
    });
  }
  _processConcatChildren(spel.children);
  return {
    valueSrc: "value",
    valueType: "case_value",
    value: flat
  };
};