@react-awesome-query-builder/core/cjs/utils/configUtils.js

User-friendly query builder for React. Core

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
  value: true
});
exports._getFromConfigCache = void 0;
exports._getWidgetsAndSrcsForFieldOp = _getWidgetsAndSrcsForFieldOp;
exports.isFieldDescendantOfField = exports.getWidgetsForFieldOp = exports.getWidgetForFieldOp = exports.getValueSourcesForFieldOp = exports.getOperatorsForType = exports.getOperatorsForField = exports.getOperatorConfig = exports.getFuncSignature = exports.getFuncConfig = exports.getFuncArgConfig = exports.getFirstOperator = exports.getFirstField = exports.getFieldWidgetConfig = exports.getFieldSrc = exports.getFieldRawConfig = exports.getFieldPathParts = exports.getFieldPath = exports.getFieldPartsConfigs = exports.getFieldParts = exports.getFieldId = exports.getFieldConfig = exports.filterValueSourcesForField = exports.configKeys = exports._widgetDefKeysToOmit = exports._saveToConfigCache = void 0;
exports.iterateFields = iterateFields;
exports.iterateFuncs = iterateFuncs;
exports.selectTypes = exports.normalizeField = void 0;
var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
var _pick = _interopRequireDefault(require("lodash/pick"));
var _stuff = require("./stuff");
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 _marked = /*#__PURE__*/_regenerator["default"].mark(iterateFuncs),
  _marked2 = /*#__PURE__*/_regenerator["default"].mark(iterateFields);
var _widgetDefKeysToOmit = exports._widgetDefKeysToOmit = _stuff.widgetDefKeysToOmit; // for ui

var configKeys = exports.configKeys = ["conjunctions", "fields", "types", "operators", "widgets", "settings", "funcs", "ctx"];
var selectTypes = exports.selectTypes = ["select", "multiselect", "treeselect", "treemultiselect"];
function iterateFuncs(config) {
  return _regenerator["default"].wrap(function iterateFuncs$(_context) {
    while (1) switch (_context.prev = _context.next) {
      case 0:
        return _context.delegateYield(_iterateFields(config, config.funcs || {}, []), "t0", 1);
      case 1:
      case "end":
        return _context.stop();
    }
  }, _marked);
}
function iterateFields(config) {
  return _regenerator["default"].wrap(function iterateFields$(_context2) {
    while (1) switch (_context2.prev = _context2.next) {
      case 0:
        return _context2.delegateYield(_iterateFields(config, config.fields || {}, []), "t0", 1);
      case 1:
      case "end":
        return _context2.stop();
    }
  }, _marked2);
}
function _iterateFields(config, subfields, path) {
  var subfieldsKey = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : "subfields";
  return /*#__PURE__*/_regenerator["default"].mark(function _callee(_config$settings) {
    var fieldSeparator, fieldKey, fieldConfig;
    return _regenerator["default"].wrap(function _callee$(_context3) {
      while (1) switch (_context3.prev = _context3.next) {
        case 0:
          fieldSeparator = (config === null || config === void 0 || (_config$settings = config.settings) === null || _config$settings === void 0 ? void 0 : _config$settings.fieldSeparator) || ".";
          _context3.t0 = _regenerator["default"].keys(subfields);
        case 2:
          if ((_context3.t1 = _context3.t0()).done) {
            _context3.next = 13;
            break;
          }
          fieldKey = _context3.t1.value;
          fieldConfig = subfields[fieldKey];
          if (!fieldConfig[subfieldsKey]) {
            _context3.next = 9;
            break;
          }
          return _context3.delegateYield(_iterateFields(config, fieldConfig[subfieldsKey], [].concat((0, _toConsumableArray2["default"])(path), [fieldKey]), subfieldsKey), "t2", 7);
        case 7:
          _context3.next = 11;
          break;
        case 9:
          _context3.next = 11;
          return [[].concat((0, _toConsumableArray2["default"])(path), [fieldKey]).join(fieldSeparator), fieldConfig, fieldKey];
        case 11:
          _context3.next = 2;
          break;
        case 13:
        case "end":
          return _context3.stop();
      }
    }, _callee);
  })();
}
var getFieldRawConfig = exports.getFieldRawConfig = function getFieldRawConfig(config, field) {
  var _config$settings3;
  var fieldsKey = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : "fields";
  var subfieldsKey = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : "subfields";
  if (!field) return null;
  if (field === "!case_value") {
    var _config$settings2;
    return config === null || config === void 0 || (_config$settings2 = config.settings) === null || _config$settings2 === void 0 ? void 0 : _config$settings2.caseValueField;
  }
  var fieldSeparator = (config === null || config === void 0 || (_config$settings3 = config.settings) === null || _config$settings3 === void 0 ? void 0 : _config$settings3.fieldSeparator) || ".";
  var parts = getFieldParts(field, config);
  var targetFields = config[fieldsKey];
  if (!targetFields) return null;
  var fields = targetFields;
  var fieldConfig = null;
  var path = [];
  for (var i = 0; i < parts.length; i++) {
    var part = parts[i];
    path.push(part);
    var pathKey = path.join(fieldSeparator);
    fieldConfig = fields[pathKey];
    if (i < parts.length - 1) {
      if (fieldConfig && fieldConfig[subfieldsKey]) {
        fields = fieldConfig[subfieldsKey];
        path = [];
      } else {
        fieldConfig = null;
      }
    }
  }
  return fieldConfig;
};

// if `field` is alias (fieldName), convert to original full path
var normalizeField = exports.normalizeField = function normalizeField(config, field) {
  var _config$__fieldNames$, _config$__fieldNames$2;
  var parentField = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
  // tip: if parentField is present, field is not full path
  var fieldSeparator = config.settings.fieldSeparator;
  var path = [parentField].concat((0, _toConsumableArray2["default"])(field.split(fieldSeparator))).filter(function (f) {
    return f != null;
  });
  var findStr = field;
  var normalizedPath = (_config$__fieldNames$ = config.__fieldNames[findStr]) === null || _config$__fieldNames$ === void 0 || (_config$__fieldNames$2 = _config$__fieldNames$.find) === null || _config$__fieldNames$2 === void 0 || (_config$__fieldNames$2 = _config$__fieldNames$2.call(_config$__fieldNames$, function (_ref) {
    var inGroup = _ref.inGroup;
    if (inGroup) return parentField === null || parentField === void 0 ? void 0 : parentField.startsWith(inGroup);
    return true;
  })) === null || _config$__fieldNames$2 === void 0 ? void 0 : _config$__fieldNames$2.fullPath;
  return (normalizedPath || path).join(fieldSeparator);
};
var getFuncSignature = exports.getFuncSignature = function getFuncSignature(config, func) {
  if (!func) return null;
  var funcConfig = getFieldRawConfig(config, func, "funcs", "subfields");
  if (!funcConfig) return null;
  var returnType = funcConfig.returnType,
    args = funcConfig.args;
  var argsSignature = Object.fromEntries(Object.entries(args || {}).map(function (_ref2) {
    var _ref3 = (0, _slicedToArray2["default"])(_ref2, 2),
      k = _ref3[0],
      v = _ref3[1];
    var argSignature = (0, _pick["default"])(v, ["type", "valueSources", "defaultValue", "fieldSettings",
    // "asyncListValues", // not supported
    "isOptional",
    // to get proper caching key
    "_funcKey", "_argKey", "_isFuncArg"]);
    return [k, argSignature];
  }));
  var signature = {
    returnType: returnType,
    args: argsSignature
  };
  return signature;
};
var getFuncConfig = exports.getFuncConfig = function getFuncConfig(config, func) {
  if (!func) return null;
  var funcConfig = getFieldRawConfig(config, func, "funcs", "subfields");
  if (!funcConfig) return null; //throw new Error("Can't find func " + func + ", please check your config");
  return funcConfig;
};
var getFuncArgConfig = exports.getFuncArgConfig = function getFuncArgConfig(config, funcKey, argKey) {
  var funcConfig = getFuncConfig(config, funcKey);
  if (!funcConfig) return null; //throw new Error(`Can't find func ${funcKey}, please check your config`);
  var argConfig = funcConfig.args && funcConfig.args[argKey] || null;
  if (!argConfig) return null; //throw new Error(`Can't find arg ${argKey} for func ${funcKey}, please check your config`);
  return argConfig;
};
var isFieldDescendantOfField = exports.isFieldDescendantOfField = function isFieldDescendantOfField(field, parentField) {
  var _config$settings4;
  var config = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
  if (!parentField) return false;
  var fieldSeparator = (config === null || config === void 0 || (_config$settings4 = config.settings) === null || _config$settings4 === void 0 ? void 0 : _config$settings4.fieldSeparator) || ".";
  var path = getFieldPath(field, config);
  var parentPath = getFieldPath(parentField, config);
  return path.startsWith(parentPath + fieldSeparator);
};
var getFieldPath = exports.getFieldPath = function getFieldPath(field) {
  var _config$settings5;
  var config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
  if (typeof field === "string") return field;
  var fieldSeparator = (config === null || config === void 0 || (_config$settings5 = config.settings) === null || _config$settings5 === void 0 ? void 0 : _config$settings5.fieldSeparator) || ".";
  return getFieldParts(field, config).join(fieldSeparator);
};
var getFieldParts = exports.getFieldParts = function getFieldParts(field) {
  var _config$settings6, _field$get, _field$split;
  var config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
  if (!field) return [];
  if (Array.isArray(field)) return field;
  var fieldSeparator = (config === null || config === void 0 || (_config$settings6 = config.settings) === null || _config$settings6 === void 0 ? void 0 : _config$settings6.fieldSeparator) || ".";
  if (field !== null && field !== void 0 && field.func) {
    return Array.isArray(field.func) ? field.func : field.func.split(fieldSeparator);
  }
  if (field !== null && field !== void 0 && (_field$get = field.get) !== null && _field$get !== void 0 && _field$get.call(field, "func")) {
    var _field$get2;
    // immutable
    return field === null || field === void 0 || (_field$get2 = field.get) === null || _field$get2 === void 0 ? void 0 : _field$get2.call(field, "func").split(fieldSeparator);
  }
  return (field === null || field === void 0 || (_field$split = field.split) === null || _field$split === void 0 ? void 0 : _field$split.call(field, fieldSeparator)) || [];
};
var getFieldPathParts = exports.getFieldPathParts = function getFieldPathParts(field, config) {
  var onlyKeys = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
  if (!field) return null;
  var fieldSeparator = config.settings.fieldSeparator;
  var parts = getFieldParts(field, config);
  if (onlyKeys) return parts;else return parts.map(function (_curr, ind, arr) {
    return arr.slice(0, ind + 1);
  }).map(function (parts) {
    return parts.join(fieldSeparator);
  });
};
var getFieldId = exports.getFieldId = function getFieldId(field) {
  var _field$get3;
  if (typeof field === "string" || Array.isArray(field)) {
    return "field:".concat(getFieldPath(field));
  }
  if ((0, _typeof2["default"])(field) === "object" && field) {
    if (field._funcKey && field._argKey) {
      // it's func arg config
      return "arg:".concat(getFieldPath(field._funcKey), "__").concat(field._argKey);
    }
    if (field._funcKey) {
      // it's func config
      return "func:".concat(getFieldPath(field._funcKey));
    }
    if (field.func && field.arg) {
      // it's func arg
      return "arg:".concat(getFieldPath(field.func), "__").concat(field.arg);
    }
    if (field.func) {
      // it's field func
      return "func:".concat(getFieldPath(field.func));
    }
    if (field.type) {
      // it's already a config
      return null;
    }
  }
  if (field !== null && field !== void 0 && (_field$get3 = field.get) !== null && _field$get3 !== void 0 && _field$get3.call(field, "func")) {
    // immutable
    if (field !== null && field !== void 0 && field.get("arg")) {
      // it's func arg
      return "arg:".concat(getFieldPath(field.get("func")), "__").concat(field.get("arg"));
    } else {
      // it's field func
      return "func:".concat(getFieldPath(field.get("func")));
    }
  }
  return null;
};
var _getFromConfigCache = exports._getFromConfigCache = function _getFromConfigCache(config, bucketKey, cacheKey) {
  var _config$__cache;
  return (_config$__cache = config.__cache) === null || _config$__cache === void 0 || (_config$__cache = _config$__cache[bucketKey]) === null || _config$__cache === void 0 ? void 0 : _config$__cache[cacheKey];
};
var _saveToConfigCache = exports._saveToConfigCache = function _saveToConfigCache(config, bucketKey, cacheKey, value) {
  if (!config.__cache || !cacheKey) {
    return;
  }
  if (!config.__cache[bucketKey]) {
    config.__cache[bucketKey] = {};
  }
  config.__cache[bucketKey][cacheKey] = value;
};
var getFieldSrc = exports.getFieldSrc = function getFieldSrc(field) {
  var _field$get4;
  if (!field) return null;
  if ((0, _typeof2["default"])(field) === "object") {
    // should not be possible
    // if (field._isFuncArg) {
    //   // it's func arg
    //   return null;
    // }
    // if (field._isFunc) {
    //   // it's field func
    //   return "func";
    // }
    if (!field.func && field.type) {
      // it's already a config
      return "field";
    }
    if (field.func) {
      if (field.func && field.arg) {
        // it's func arg
        return null;
      } else {
        // it's field func
        return "func";
      }
    }
  }
  if (field !== null && field !== void 0 && (_field$get4 = field.get) !== null && _field$get4 !== void 0 && _field$get4.call(field, "func")) {
    // immutable
    if (field !== null && field !== void 0 && field.get("arg")) {
      // it's func arg
      return null;
    } else {
      // it's field func
      return "func";
    }
  }
  return "field";
};
var getFieldConfig = exports.getFieldConfig = function getFieldConfig(config, field) {
  var _field$get5;
  if (!field) return null;
  if ((0, _typeof2["default"])(field) == "object") {
    if (!field.func && !!field.type && !!field.widgets) {
      // it's already a config
      // but don't mess up with obj from `getFuncSignature`, it has `type` but no `widgets` and other keys !
      return field;
    }
    if (field._isFuncArg) {
      // it's func arg
      return getFuncArgConfig(config, field._funcKey, field._argKey);
    }
    if (field._isFunc) {
      // it's a func
      return getFuncConfig(config, field._funcKey);
    }
    if (field.func) {
      if (field.func && field.arg) {
        // it's func arg
        return getFuncArgConfig(config, field.func, field.arg);
      } else {
        // it's a func
        return getFuncConfig(config, field.func);
      }
    }
  }
  if (field !== null && field !== void 0 && (_field$get5 = field.get) !== null && _field$get5 !== void 0 && _field$get5.call(field, "func")) {
    // immutable
    if (field !== null && field !== void 0 && field.get("arg")) {
      // it's func arg
      return getFuncArgConfig(config, field.get("func"), field.get("arg"));
    } else {
      // it's field func
      return getFuncConfig(config, field.get("func"));
    }
  }
  var fieldConfig = getFieldRawConfig(config, field);
  if (!fieldConfig) return null; //throw new Error("Can't find field " + field + ", please check your config");
  return fieldConfig;
};
var getOperatorConfig = exports.getOperatorConfig = function getOperatorConfig(config, operator) {
  var field = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
  if (!operator) return null;
  var opConfig = config.operators[operator];
  if (field) {
    var _widgetConfig$opProps, _fieldWidgetConfig$op;
    var fieldCacheKey = getFieldId(field);
    var cacheKey = fieldCacheKey ? "".concat(fieldCacheKey, "__").concat(operator) : null;
    var cached = _getFromConfigCache(config, "getOperatorConfig", cacheKey);
    if (cached) return cached;
    var fieldConfig = getFieldConfig(config, field);
    var widget = getWidgetForFieldOp(config, field, operator, null);
    var widgetConfig = config.widgets[widget] || {};
    var fieldWidgetConfig = (fieldConfig && fieldConfig.widgets ? fieldConfig.widgets[widget] : {}) || {};
    var widgetOpProps = ((_widgetConfig$opProps = widgetConfig.opProps) === null || _widgetConfig$opProps === void 0 ? void 0 : _widgetConfig$opProps[operator]) || {};
    var fieldWidgetOpProps = ((_fieldWidgetConfig$op = fieldWidgetConfig.opProps) === null || _fieldWidgetConfig$op === void 0 ? void 0 : _fieldWidgetConfig$op[operator]) || {};
    var mergedConfig = _objectSpread(_objectSpread(_objectSpread({}, opConfig), widgetOpProps), fieldWidgetOpProps);
    _saveToConfigCache(config, "getOperatorConfig", cacheKey, mergedConfig);
    return mergedConfig;
  } else {
    return opConfig;
  }
};
var getFieldWidgetConfig = exports.getFieldWidgetConfig = function getFieldWidgetConfig(config, field) {
  var _fieldConfig$widgets;
  var operator = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
  var widget = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
  var valueSrc = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null;
  var meta = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : {};
  if (!field) return null;
  var fieldConfig = getFieldConfig(config, field);
  var fieldCacheKey = getFieldId(field);
  if (!widget) {
    widget = getWidgetForFieldOp(config, field, operator, valueSrc);
  }
  var cacheKey = fieldCacheKey ? "".concat(fieldCacheKey, "__").concat(operator, "__").concat(widget, "__").concat(valueSrc) : null;
  var cached = _getFromConfigCache(config, "getFieldWidgetConfig", cacheKey);
  if (cached) return cached;
  var widgetConfig = config.widgets[widget] || {};
  var fieldWidgetConfig = (fieldConfig === null || fieldConfig === void 0 || (_fieldConfig$widgets = fieldConfig.widgets) === null || _fieldConfig$widgets === void 0 ? void 0 : _fieldConfig$widgets[widget]) || {};
  var fieldWidgetProps = fieldWidgetConfig.widgetProps || {};
  var valueFieldSettings = valueSrc === "value" || !valueSrc ? fieldConfig === null || fieldConfig === void 0 ? void 0 : fieldConfig.fieldSettings : {}; // useful to take 'validateValue'
  var mergedConfig = _objectSpread(_objectSpread(_objectSpread(_objectSpread({}, widgetConfig), fieldWidgetConfig), fieldWidgetProps), valueFieldSettings);
  _saveToConfigCache(config, "getFieldWidgetConfig", cacheKey, mergedConfig);
  if (meta.forExport) {
    mergedConfig = (0, _stuff.omit)(mergedConfig, "factory");
  }
  return mergedConfig;
};
var getFirstField = exports.getFirstField = function getFirstField(config) {
  var parentRuleGroupField = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
  var fieldSeparator = config.settings.fieldSeparator;
  var parentPathArr = getFieldParts(parentRuleGroupField, config);
  var parentField = parentRuleGroupField ? getFieldRawConfig(config, parentRuleGroupField) : config;
  var firstField = parentField,
    key = null,
    keysPath = [];
  do {
    var _firstField;
    var subfields = firstField === config ? config.fields : (_firstField = firstField) === null || _firstField === void 0 ? void 0 : _firstField.subfields;
    if (!subfields || !Object.keys(subfields).length) {
      firstField = key = null;
      break;
    }
    key = Object.keys(subfields)[0];
    keysPath.push(key);
    firstField = subfields[key];
  } while (firstField.type == "!struct" || firstField.type == "!group");
  return (parentPathArr || []).concat(keysPath).join(fieldSeparator);
};
function _getWidgetsAndSrcsForFieldOp(config, field) {
  var operator = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
  var valueSrc = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
  var widgets = [];
  var valueSrcs = [];
  if (!field) return {
    widgets: widgets,
    valueSrcs: valueSrcs
  };
  var fieldCacheKey = getFieldId(field);
  var cacheKey = fieldCacheKey ? "".concat(fieldCacheKey, "__").concat(operator, "__").concat(valueSrc) : null;
  var cached = _getFromConfigCache(config, "_getWidgetsAndSrcsForFieldOp", cacheKey);
  if (cached) return cached;
  var isFuncArg = (0, _typeof2["default"])(field) === "object" && (!!field.func && !!field.arg || field._isFuncArg);
  var fieldConfig = getFieldConfig(config, field);
  var opConfig = operator ? config.operators[operator] : null;
  if (fieldConfig !== null && fieldConfig !== void 0 && fieldConfig.widgets) {
    var _loop = function _loop() {
      var widgetConfig = fieldConfig.widgets[widget];
      if (!config.widgets[widget]) {
        return 1; // continue
      }
      var widgetValueSrc = config.widgets[widget].valueSrc || "value";
      var canAdd = true;
      if (widget === "field") {
        canAdd = canAdd && filterValueSourcesForField(config, ["field"], fieldConfig, operator).length > 0;
      }
      if (widget === "func") {
        canAdd = canAdd && filterValueSourcesForField(config, ["func"], fieldConfig, operator).length > 0;
      }
      // If can't check operators, don't add
      // Func args don't have operators
      if (valueSrc === "value" && !widgetConfig.operators && !isFuncArg && field !== "!case_value") canAdd = false;
      if (widgetConfig.operators && operator) canAdd = canAdd && widgetConfig.operators.indexOf(operator) != -1;
      if (valueSrc && valueSrc != widgetValueSrc && valueSrc !== "const") canAdd = false;
      if (opConfig && opConfig.cardinality == 0 && widgetValueSrc !== "value") canAdd = false;
      if (canAdd) {
        var _fieldConfig$valueSou, _opConfig$valueSource;
        widgets.push(widget);
        var canAddValueSrc = ((_fieldConfig$valueSou = fieldConfig.valueSources) === null || _fieldConfig$valueSou === void 0 ? void 0 : _fieldConfig$valueSou.indexOf(widgetValueSrc)) != -1;
        if ((opConfig === null || opConfig === void 0 || (_opConfig$valueSource = opConfig.valueSources) === null || _opConfig$valueSource === void 0 ? void 0 : _opConfig$valueSource.indexOf(widgetValueSrc)) == -1) canAddValueSrc = false;
        if (canAddValueSrc && !valueSrcs.find(function (v) {
          return v == widgetValueSrc;
        })) valueSrcs.push(widgetValueSrc);
      }
    };
    for (var widget in fieldConfig.widgets) {
      if (_loop()) continue;
    }
  }
  var widgetWeight = function widgetWeight(w) {
    var wg = 0;
    if (fieldConfig.preferWidgets) {
      if (fieldConfig.preferWidgets.includes(w)) wg += 10 - fieldConfig.preferWidgets.indexOf(w);
    } else if (w == fieldConfig.mainWidget) {
      wg += 100;
    }
    if (w === "field") {
      wg -= 1;
    }
    if (w === "func") {
      wg -= 2;
    }
    return wg;
  };
  widgets.sort(function (w1, w2) {
    return widgetWeight(w2) - widgetWeight(w1);
  });
  var res = {
    widgets: widgets,
    valueSrcs: valueSrcs
  };
  _saveToConfigCache(config, "_getWidgetsAndSrcsForFieldOp", cacheKey, res);
  return res;
}
var filterValueSourcesForField = exports.filterValueSourcesForField = function filterValueSourcesForField(config, valueSrcs, fieldDefinition) {
  var _fieldDefinition$type;
  var operator = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
  if (!fieldDefinition) return valueSrcs;
  var fieldType = (_fieldDefinition$type = fieldDefinition.type) !== null && _fieldDefinition$type !== void 0 ? _fieldDefinition$type : fieldDefinition.returnType;
  if (fieldType === "!group") {
    // todo: aggregation can be not only number?
    fieldType = "number";
  }
  var isOtherType = false;
  if (operator) {
    var opConfig = config.operators[operator];
    if (opConfig !== null && opConfig !== void 0 && opConfig.valueTypes) {
      // Important: for "select" field and "select_any_in" op valueTypes are ["multiselect"]
      fieldType = opConfig.valueTypes[0];
      isOtherType = true;
    }
  }
  // const { _isCaseValue } = fieldDefinition;
  if (!valueSrcs) valueSrcs = Object.keys(config.settings.valueSourcesInfo);
  return valueSrcs.filter(function (vs) {
    var canAdd = true;
    if (vs === "field") {
      if (config.__fieldsCntByType) {
        // tip: LHS field can be used as arg in RHS function
        var minCnt = fieldDefinition._isFuncArg || isOtherType ? 0 : 1;
        canAdd = canAdd && config.__fieldsCntByType[fieldType] > minCnt;
      }
    }
    if (vs === "func") {
      if (fieldDefinition.funcs) {
        canAdd = canAdd && fieldDefinition.funcs.length > 0;
      }
      if (config.__funcsCntByType) {
        canAdd = canAdd && config.__funcsCntByType[fieldType] > 0;
      }
    }
    return canAdd;
  });
};
var getWidgetForFieldOp = exports.getWidgetForFieldOp = function getWidgetForFieldOp(config, field, operator) {
  var valueSrc = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
  var _getWidgetsAndSrcsFor = _getWidgetsAndSrcsForFieldOp(config, field, operator, valueSrc),
    widgets = _getWidgetsAndSrcsFor.widgets;
  var widget = null;
  if (widgets.length) widget = widgets[0];
  return widget;
};
var getValueSourcesForFieldOp = exports.getValueSourcesForFieldOp = function getValueSourcesForFieldOp(config, field, operator) {
  var fieldDefinition = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
  var _getWidgetsAndSrcsFor2 = _getWidgetsAndSrcsForFieldOp(config, field, operator, null),
    valueSrcs = _getWidgetsAndSrcsFor2.valueSrcs;
  var filteredValueSrcs = filterValueSourcesForField(config, valueSrcs, fieldDefinition, operator);
  return filteredValueSrcs;
};
var getWidgetsForFieldOp = exports.getWidgetsForFieldOp = function getWidgetsForFieldOp(config, field, operator) {
  var valueSrc = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
  var _getWidgetsAndSrcsFor3 = _getWidgetsAndSrcsForFieldOp(config, field, operator, valueSrc),
    widgets = _getWidgetsAndSrcsFor3.widgets;
  return widgets;
};
var getOperatorsForType = exports.getOperatorsForType = function getOperatorsForType(config, fieldType) {
  var _config$types$fieldTy;
  return ((_config$types$fieldTy = config.types[fieldType]) === null || _config$types$fieldTy === void 0 ? void 0 : _config$types$fieldTy.operators) || null;
};
var getOperatorsForField = exports.getOperatorsForField = function getOperatorsForField(config, field) {
  var fieldConfig = getFieldConfig(config, field);
  var fieldOps = fieldConfig ? fieldConfig.operators : [];
  return fieldOps;
};
var getFirstOperator = exports.getFirstOperator = function getFirstOperator(config, field) {
  var _fieldOps$;
  var fieldOps = getOperatorsForField(config, field);
  return (_fieldOps$ = fieldOps === null || fieldOps === void 0 ? void 0 : fieldOps[0]) !== null && _fieldOps$ !== void 0 ? _fieldOps$ : null;
};
var getFieldPartsConfigs = exports.getFieldPartsConfigs = function getFieldPartsConfigs(field, config) {
  var parentField = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
  if (!field) return null;
  var parentFieldDef = parentField && getFieldRawConfig(config, parentField) || null;
  var fieldSeparator = config.settings.fieldSeparator;
  var parts = getFieldParts(field, config);
  var isDescendant = isFieldDescendantOfField(field, parentField, config);
  var parentParts = !isDescendant ? [] : getFieldParts(parentField, config);
  return parts.slice(parentParts.length).map(function (_curr, ind, arr) {
    return arr.slice(0, ind + 1);
  }).map(function (parts) {
    return {
      part: [].concat((0, _toConsumableArray2["default"])(parentParts), (0, _toConsumableArray2["default"])(parts)).join(fieldSeparator),
      key: parts[parts.length - 1]
    };
  }).map(function (_ref4) {
    var part = _ref4.part,
      key = _ref4.key;
    var cnf = getFieldRawConfig(config, part);
    return {
      key: key,
      cnf: cnf
    };
  }).map(function (_ref5, ind, arr) {
    var key = _ref5.key,
      cnf = _ref5.cnf;
    var parentCnf = ind > 0 ? arr[ind - 1].cnf : parentFieldDef;
    return [key, cnf, parentCnf];
  });
};