react-awesome-query-builder-pd
Version:
User-friendly query builder for React. Demo: https://ukrbublik.github.io/react-awesome-query-builder
790 lines (653 loc) • 25.6 kB
JavaScript
;
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.loadFromJsonLogic = void 0;
var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
var _toArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toArray"));
var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
var _uuid = _interopRequireDefault(require("../utils/uuid"));
var _stuff = require("../utils/stuff");
var _configUtils = require("../utils/configUtils");
var _ruleUtils = require("../utils/ruleUtils");
var _tree = require("./tree");
var _defaultUtils = require("../utils/defaultUtils");
var _moment = _interopRequireDefault(require("moment"));
function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
// http://jsonlogic.com/
// helpers
var arrayUniq = function arrayUniq(arr) {
return Array.from(new Set(arr));
};
var arrayToObject = function arrayToObject(arr) {
return arr.reduce(function (acc, _ref) {
var _ref2 = (0, _slicedToArray2["default"])(_ref, 2),
f = _ref2[0],
fc = _ref2[1];
return _objectSpread(_objectSpread({}, acc), {}, (0, _defineProperty2["default"])({}, f, fc));
}, {});
};
var loadFromJsonLogic = function loadFromJsonLogic(logicTree, config) {
//meta is mutable
var meta = {
errors: []
};
var extendedConfig = (0, _configUtils.extendConfig)(config);
var conv = buildConv(extendedConfig);
var jsTree = logicTree ? convertFromLogic(logicTree, conv, extendedConfig, "rule", meta) : undefined;
if (jsTree && jsTree.type != "group") {
jsTree = wrapInDefaultConj(jsTree, extendedConfig);
}
var immTree = jsTree ? (0, _tree.loadTree)(jsTree) : undefined;
if (meta.errors.length) console.warn("Errors while importing from JsonLogic:", meta.errors);
return immTree;
};
exports.loadFromJsonLogic = loadFromJsonLogic;
var buildConv = function buildConv(config) {
var operators = {};
for (var opKey in config.operators) {
var opConfig = config.operators[opKey];
if (typeof opConfig.jsonLogic == "string") {
// example: "</2", "#in/1"
var opk = (opConfig._jsonLogicIsRevArgs ? "#" : "") + opConfig.jsonLogic + "/" + (0, _stuff.defaultValue)(opConfig.cardinality, 1);
if (!operators[opk]) operators[opk] = [];
operators[opk].push(opKey);
} else if (typeof opConfig.jsonLogic2 == "string") {
// example: all-in/1"
var _opk = opConfig.jsonLogic2 + "/" + (0, _stuff.defaultValue)(opConfig.cardinality, 1);
if (!operators[_opk]) operators[_opk] = [];
operators[_opk].push(opKey);
}
}
var conjunctions = {};
for (var conjKey in config.conjunctions) {
var ck = conjKey.toLowerCase();
conjunctions[ck] = conjKey;
}
var funcs = {};
for (var funcKey in config.funcs) {
var funcConfig = config.funcs[funcKey];
var fk = void 0;
if (funcConfig.jsonLogicIsMethod) {
fk = "#" + funcConfig.jsonLogic;
} else if (typeof funcConfig.jsonLogic == "string") {
fk = funcConfig.jsonLogic;
}
if (fk) {
if (!funcs[fk]) funcs[fk] = [];
funcs[fk].push(funcKey);
}
}
return {
operators: operators,
conjunctions: conjunctions,
funcs: funcs,
varKeys: ["var", config.settings.jsonLogic.groupVarKey, config.settings.jsonLogic.altVarKey]
};
};
var convertFromLogic = function convertFromLogic(logic, conv, config, expectedType, meta) {
var not = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : false;
var fieldConfig = arguments.length > 6 ? arguments[6] : undefined;
var widget = arguments.length > 7 ? arguments[7] : undefined;
var parentField = arguments.length > 8 && arguments[8] !== undefined ? arguments[8] : null;
var op, vals;
if ((0, _stuff.isJsonLogic)(logic)) {
op = Object.keys(logic)[0];
vals = logic[op];
if (!Array.isArray(vals)) vals = [vals];
}
var ret;
var beforeErrorsCnt = meta.errors.length;
var isEmptyOp = op == "!" && vals.length == 1 && vals[0] && (0, _stuff.isJsonLogic)(vals[0]) && conv.varKeys.includes(Object.keys(vals[0])[0]);
var isRev = op == "!" && !isEmptyOp;
if (isRev) {
// reverse with not
ret = convertFromLogic(vals[0], conv, config, expectedType, meta, !not, fieldConfig, widget, parentField);
} else if (expectedType == "val") {
// not is not used here
ret = convertField(op, vals, conv, config, not, meta, parentField) || convertFunc(op, vals, conv, config, not, fieldConfig, meta, parentField) || convertVal(logic, fieldConfig, widget, config, meta);
} else if (expectedType == "rule") {
ret = convertConj(op, vals, conv, config, not, meta, parentField) || convertOp(op, vals, conv, config, not, meta, parentField);
}
var afterErrorsCnt = meta.errors.length;
if (op != "!" && ret === undefined && afterErrorsCnt == beforeErrorsCnt) {
meta.errors.push("Can't parse logic ".concat(JSON.stringify(logic)));
}
return ret;
};
var convertVal = function convertVal(val, fieldConfig, widget, config, meta) {
if (val === undefined) return undefined;
var widgetConfig = config.widgets[widget || fieldConfig.mainWidget];
if (!widgetConfig) {
meta.errors.push("No widget for type ".concat(fieldConfig.type));
return undefined;
}
if ((0, _stuff.isJsonLogic)(val)) {
meta.errors.push("Unexpected logic in value: ".concat(JSON.stringify(val)));
return undefined;
} // number of seconds -> time string
if (fieldConfig && fieldConfig.type == "time" && typeof val == "number") {
var h = Math.floor(val / 60 / 60) % 24,
m = Math.floor(val / 60) % 60,
s = val % 60;
var valueFormat = widgetConfig.valueFormat;
if (valueFormat) {
var dateVal = new Date(val);
dateVal.setMilliseconds(0);
dateVal.setHours(h);
dateVal.setMinutes(m);
dateVal.setSeconds(s);
val = (0, _moment["default"])(dateVal).format(valueFormat);
} else {
val = "".concat(h, ":").concat(m, ":").concat(s);
}
} // "2020-01-08T22:00:00.000Z" -> Date object
if (fieldConfig && ["date", "datetime"].includes(fieldConfig.type) && val && !(val instanceof Date)) {
try {
var _dateVal = new Date(val);
if (_dateVal instanceof Date && _dateVal.toISOString() === val) {
val = _dateVal;
}
} catch (e) {
meta.errors.push("Can't convert value ".concat(val, " as Date"));
val = undefined;
}
} // Date object -> formatted string
if (val instanceof Date && fieldConfig) {
var _valueFormat = widgetConfig.valueFormat;
if (_valueFormat) {
val = (0, _moment["default"])(val).format(_valueFormat);
}
}
var asyncListValues;
if (val && fieldConfig.fieldSettings && fieldConfig.fieldSettings.asyncFetch) {
var vals = Array.isArray(val) ? val : [val];
asyncListValues = vals;
}
return {
valueSrc: "value",
value: val,
valueType: widgetConfig.type,
asyncListValues: asyncListValues
};
};
var convertField = function convertField(op, vals, conv, config, not, meta) {
var parentField = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : null;
var fieldSeparator = config.settings.fieldSeparator;
if (conv.varKeys.includes(op) && typeof vals[0] == "string") {
var field = vals[0];
if (parentField) field = [parentField, field].join(fieldSeparator);
field = (0, _configUtils.normalizeField)(config, field);
var fieldConfig = (0, _configUtils.getFieldConfig)(config, field);
if (!fieldConfig) {
meta.errors.push("No config for field ".concat(field));
return undefined;
}
return {
valueSrc: "field",
value: field,
valueType: fieldConfig.type
};
}
return undefined;
};
var convertFunc = function convertFunc(op, vals, conv, config, not, fieldConfig, meta) {
var parentField = arguments.length > 7 && arguments[7] !== undefined ? arguments[7] : null;
if (!op) return undefined;
var func, argsArr, funcKey;
var jsonLogicIsMethod = op == "method";
if (jsonLogicIsMethod) {
var obj, opts;
var _vals = (0, _toArray2["default"])(vals);
obj = _vals[0];
func = _vals[1];
opts = _vals.slice(2);
argsArr = [obj].concat((0, _toConsumableArray2["default"])(opts));
} else {
func = op;
argsArr = vals;
}
var fk = (jsonLogicIsMethod ? "#" : "") + func;
var funcKeys = (conv.funcs[fk] || []).filter(function (k) {
return fieldConfig ? config.funcs[k].returnType == fieldConfig.type : true;
});
if (funcKeys.length) {
funcKey = funcKeys[0];
} else {
var v = (0, _defineProperty2["default"])({}, op, vals);
for (var _i = 0, _Object$entries = Object.entries(config.funcs || {}); _i < _Object$entries.length; _i++) {
var _Object$entries$_i = (0, _slicedToArray2["default"])(_Object$entries[_i], 2),
f = _Object$entries$_i[0],
fc = _Object$entries$_i[1];
if (fc.jsonLogicImport && fc.returnType == fieldConfig.type) {
var parsed = void 0;
try {
parsed = fc.jsonLogicImport(v);
} catch (_e) {// given expression `v` can't be parsed into function
}
if (parsed) {
funcKey = f;
argsArr = parsed;
}
}
}
}
if (!funcKey) return undefined;
if (funcKey) {
var funcConfig = config.funcs[funcKey];
var argKeys = Object.keys(funcConfig.args || {});
var args = argsArr.reduce(function (acc, val, ind) {
var argKey = argKeys[ind];
var argConfig = funcConfig.args[argKey];
var argVal = convertFromLogic(val, conv, config, "val", meta, false, argConfig, null, parentField);
if (argVal === undefined) {
argVal = argConfig.defaultValue;
if (argVal === undefined) {
meta.errors.push("No value for arg ".concat(argKey, " of func ").concat(funcKey));
return undefined;
}
}
return _objectSpread(_objectSpread({}, acc), {}, (0, _defineProperty2["default"])({}, argKey, argVal));
}, {});
return {
valueSrc: "func",
value: {
func: funcKey,
args: args
},
valueType: funcConfig.returnType
};
}
return undefined;
};
var convertConj = function convertConj(op, vals, conv, config, not, meta) {
var parentField = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : null;
var conjKey = conv.conjunctions[op];
var fieldSeparator = config.settings.fieldSeparator;
if (conjKey) {
var type = "group";
var children = vals.map(function (v) {
return convertFromLogic(v, conv, config, "rule", meta, false, null, null, parentField);
}).filter(function (r) {
return r !== undefined;
}).reduce(function (acc, r) {
return _objectSpread(_objectSpread({}, acc), {}, (0, _defineProperty2["default"])({}, r.id, r));
}, {});
var complexFields = Object.entries(children).filter(function (_ref3) {
var _ref4 = (0, _slicedToArray2["default"])(_ref3, 2),
_k = _ref4[0],
v = _ref4[1];
return v.properties !== undefined && v.properties.field !== undefined && v.properties.field.indexOf(fieldSeparator) != -1;
}).map(function (_ref5) {
var _ref6 = (0, _slicedToArray2["default"])(_ref5, 2),
_k = _ref6[0],
v = _ref6[1];
return v.properties.field.split(fieldSeparator);
});
var complexFieldsParents = complexFields.map(function (parts) {
return parts.slice(0, parts.length - 1).join(fieldSeparator);
});
var complexFieldsConfigs = arrayToObject(arrayUniq(complexFieldsParents).map(function (f) {
return [f, (0, _configUtils.getFieldConfig)(config, f)];
}));
var complexFieldsInRuleGroup = complexFieldsParents.filter(function (f) {
return complexFieldsConfigs[f].type == "!group";
});
var usedRuleGroups = arrayUniq(complexFieldsInRuleGroup);
var usedTopRuleGroups = topLevelFieldsFilter(usedRuleGroups);
var properties = {
conjunction: conjKey,
not: not
};
var id = (0, _uuid["default"])();
var children1 = {}; // TIP: `needSplit` will be true if using mode=struct and there are fields of different groups on one level
// (like "a.b" and "x.z" -> need to split them with hierarchy)
// TIP: Even if fields are of same root parent (like "a.b", "a.c.d"), still we may need to create hierarchy of `rule_group`s
var needSplit = !(usedTopRuleGroups.length == 1 && complexFieldsInRuleGroup.length == Object.keys(children).length);
var groupToId = {};
Object.entries(children).map(function (_ref7) {
var _ref8 = (0, _slicedToArray2["default"])(_ref7, 2),
k = _ref8[0],
v = _ref8[1];
if (v.type == "group" || v.type == "rule_group") {
// put as-is
children1[k] = v;
} else {
var groupFields = usedRuleGroups.filter(function (f) {
return v.properties.field.indexOf(f) == 0;
});
var groupField = groupFields.length > 0 ? groupFields.sort(function (a, b) {
return b.length - a.length;
})[0] : null;
if (!groupField) {
// not in rule_group (can be simple field or in struct) - put as-is
children1[k] = v;
} else {
// wrap field in rule_group (with creating hierarchy if need)
var ch = children1;
groupField.split(fieldSeparator).map(function (f, i, a) {
var p = a.slice(0, i);
var ff = [].concat((0, _toConsumableArray2["default"])(p), [f]).join(fieldSeparator);
ff = (0, _configUtils.normalizeField)(config, ff);
var ffConfig = (0, _configUtils.getFieldConfig)(config, ff) || {};
if (!needSplit && i == 0) {
type = "rule_group";
properties.field = ff;
properties.mode = ffConfig.mode;
groupToId[ff] = id;
} else {
var groupId = groupToId[ff];
if (!groupId) {
groupId = (0, _uuid["default"])();
groupToId[ff] = groupId;
ch[groupId] = {
type: "rule_group",
id: groupId,
children1: {},
properties: {
conjunction: conjKey,
not: false,
field: ff,
mode: ffConfig.mode
}
};
}
ch = ch[groupId].children1;
}
});
ch[k] = v;
}
}
});
return {
type: type,
id: id,
children1: children1,
properties: properties
};
}
return undefined;
};
var topLevelFieldsFilter = function topLevelFieldsFilter(fields) {
var arr = (0, _toConsumableArray2["default"])(fields).sort(function (a, b) {
return a.length - b.length;
});
for (var i = 0; i < arr.length; i++) {
for (var j = i + 1; j < arr.length; j++) {
if (arr[j].indexOf(arr[i]) == 0) {
// arr[j] is inside arr[i] (eg. "a.b" inside "a")
arr.splice(j, 1);
j--;
}
}
}
return arr;
};
var wrapInDefaultConjRuleGroup = function wrapInDefaultConjRuleGroup(rule, parentField, parentFieldConfig, config, conj) {
if (!rule) return undefined;
return {
type: "rule_group",
id: (0, _uuid["default"])(),
children1: (0, _defineProperty2["default"])({}, rule.id, rule),
properties: {
conjunction: conj || (0, _defaultUtils.defaultGroupConjunction)(config, parentFieldConfig),
not: false,
field: parentField
}
};
};
var wrapInDefaultConj = function wrapInDefaultConj(rule, config) {
var not = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
return {
type: "group",
id: (0, _uuid["default"])(),
children1: (0, _defineProperty2["default"])({}, rule.id, rule),
properties: {
conjunction: (0, _defaultUtils.defaultConjunction)(config),
not: not
}
};
};
var parseRule = function parseRule(op, arity, vals, parentField, conv, config, meta) {
var errors = [];
var res = _parseRule(op, arity, vals, parentField, conv, config, errors, false) || _parseRule(op, arity, vals, parentField, conv, config, errors, true);
if (!res) {
meta.errors.push(errors.join("; ") || "Unknown op ".concat(op, "/").concat(arity));
return undefined;
}
return res;
};
var _parseRule = function _parseRule(op, arity, vals, parentField, conv, config, errors, isRevArgs) {
// config.settings.groupOperators are used for group count (cardinality = 0 is exception)
// but don't confuse with "all-in" for multiselect
var isAllInForMultiselect = op == "all" && (0, _stuff.isJsonLogic)(vals[1]) && Object.keys(vals[1])[0] == "in";
var isGroup0 = !isAllInForMultiselect && config.settings.groupOperators.includes(op);
var cardinality = isGroup0 ? 0 : arity - 1;
var opk = op + "/" + cardinality;
var fieldSeparator = config.settings.fieldSeparator;
var opKeys = conv.operators[(isRevArgs ? "#" : "") + opk];
if (opKeys) {
var jlField,
args = [];
var rangeOps = ["<", "<=", ">", ">="];
if (rangeOps.includes(op) && arity == 3) {
jlField = vals[1];
args = [vals[0], vals[2]];
} else if (isRevArgs) {
jlField = vals[1];
args = [vals[0]];
} else {
var _vals2 = (0, _toArray2["default"])(vals);
jlField = _vals2[0];
args = _vals2.slice(1);
}
if (!(0, _stuff.isJsonLogic)(jlField)) {
errors.push("Incorrect operands for ".concat(op, ": ").concat(JSON.stringify(vals)));
return;
}
var k = Object.keys(jlField)[0];
var v = Object.values(jlField)[0];
var field, having, isGroup;
if (conv.varKeys.includes(k) && typeof v == "string") {
field = v;
}
if (isGroup0) {
isGroup = true;
having = args[0];
args = [];
} // reduce/filter for group ext
if (k == "reduce" && Array.isArray(v) && v.length == 3) {
var _v2 = v,
_v3 = (0, _slicedToArray2["default"])(_v2, 3),
filter = _v3[0],
acc = _v3[1],
init = _v3[2];
if ((0, _stuff.isJsonLogic)(filter) && init == 0 && (0, _stuff.isJsonLogic)(acc) && Array.isArray(acc["+"]) && acc["+"][0] == 1 && (0, _stuff.isJsonLogic)(acc["+"][1]) && acc["+"][1]["var"] == "accumulator") {
k = Object.keys(filter)[0];
v = Object.values(filter)[0];
if (k == "filter") {
var _v4 = v,
_v5 = (0, _slicedToArray2["default"])(_v4, 2),
group = _v5[0],
_filter = _v5[1];
if ((0, _stuff.isJsonLogic)(group)) {
k = Object.keys(group)[0];
v = Object.values(group)[0];
if (conv.varKeys.includes(k) && typeof v == "string") {
field = v;
having = _filter;
isGroup = true;
}
}
} else if (conv.varKeys.includes(k) && typeof v == "string") {
field = v;
isGroup = true;
}
}
}
if (!field) {
errors.push("Unknown field ".concat(JSON.stringify(jlField)));
return;
}
if (parentField) field = [parentField, field].join(fieldSeparator);
field = (0, _configUtils.normalizeField)(config, field);
var fieldConfig = (0, _configUtils.getFieldConfig)(config, field);
if (!fieldConfig) {
errors.push("No config for field ".concat(field));
return;
}
var opKey = opKeys[0];
if (opKeys.length > 1 && fieldConfig && fieldConfig.operators) {
// eg. for "equal" and "select_equals"
opKeys = opKeys.filter(function (k) {
return fieldConfig.operators.includes(k);
});
if (opKeys.length == 0) {
errors.push("No corresponding ops for field ".concat(field));
return;
}
opKey = opKeys[0];
}
return {
field: field,
fieldConfig: fieldConfig,
opKey: opKey,
args: args,
having: having
};
}
};
var convertOp = function convertOp(op, vals, conv, config, not, meta) {
var parentField = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : null;
if (!op) return undefined;
var arity = vals.length;
if (op == "all" && (0, _stuff.isJsonLogic)(vals[1])) {
// special case for "all-in"
var op2 = Object.keys(vals[1])[0];
if (op2 == "in") {
vals = [vals[0], vals[1][op2][1]];
op = op + "-" + op2; // "all-in"
}
}
var parseRes = parseRule(op, arity, vals, parentField, conv, config, meta);
if (!parseRes) return undefined;
var field = parseRes.field,
fieldConfig = parseRes.fieldConfig,
opKey = parseRes.opKey,
args = parseRes.args,
having = parseRes.having;
var opConfig = config.operators[opKey]; // Group component in array mode can show NOT checkbox, so do nothing in this case
// Otherwise try to revert
var showNot = fieldConfig.showNot !== undefined ? fieldConfig.showNot : config.settings.showNot;
var canRev = true;
if (fieldConfig.type == "!group" && fieldConfig.mode == "array" && showNot) canRev = false; // Fix "some ! in"
if (fieldConfig.type == "!group" && having && Object.keys(having)[0] == "!") {
not = !not;
having = having["!"];
} // Use reversed op
if (not && canRev && opConfig.reversedOp) {
not = false;
opKey = opConfig.reversedOp;
opConfig = config.operators[opKey];
}
var widget = (0, _ruleUtils.getWidgetForFieldOp)(config, field, opKey);
var convertedArgs = args.map(function (v) {
return convertFromLogic(v, conv, config, "val", meta, false, fieldConfig, widget, parentField);
});
if (convertedArgs.filter(function (v) {
return v === undefined;
}).length) {
//meta.errors.push(`Undefined arg for field ${field} and op ${opKey}`);
return undefined;
}
var res;
if (fieldConfig.type == "!group" && having) {
var conj = Object.keys(having)[0];
var havingVals = having[conj];
var _not = false;
if (conv.conjunctions[conj] !== undefined) {
res = convertConj(conj, havingVals, conv, config, _not, meta, field);
} else {
// need to be wrapped in `rule_group`
var rule = convertOp(conj, havingVals, conv, config, _not, meta, field);
res = wrapInDefaultConjRuleGroup(rule, field, fieldConfig, config, conv.conjunctions["and"]);
}
Object.assign(res.properties, {
mode: fieldConfig.mode,
not: canRev ? false : not,
operator: opKey
});
if (fieldConfig.mode == "array") {
Object.assign(res.properties, {
value: convertedArgs.map(function (v) {
return v.value;
}),
valueSrc: convertedArgs.map(function (v) {
return v.valueSrc;
}),
valueType: convertedArgs.map(function (v) {
return v.valueType;
})
});
}
} else if (fieldConfig.type == "!group" && !having) {
res = {
type: "rule_group",
id: (0, _uuid["default"])(),
children1: {},
properties: {
conjunction: (0, _defaultUtils.defaultGroupConjunction)(config, fieldConfig),
not: canRev ? false : not,
mode: fieldConfig.mode,
field: field,
operator: opKey
}
};
if (fieldConfig.mode == "array") {
Object.assign(res.properties, {
value: convertedArgs.map(function (v) {
return v.value;
}),
valueSrc: convertedArgs.map(function (v) {
return v.valueSrc;
}),
valueType: convertedArgs.map(function (v) {
return v.valueType;
})
});
}
} else {
var asyncListValuesArr = convertedArgs.map(function (v) {
return v.asyncListValues;
}).filter(function (v) {
return v != undefined;
});
var asyncListValues = asyncListValuesArr.length ? asyncListValuesArr[0] : undefined;
res = {
type: "rule",
id: (0, _uuid["default"])(),
properties: {
field: field,
operator: opKey,
value: convertedArgs.map(function (v) {
return v.value;
}),
valueSrc: convertedArgs.map(function (v) {
return v.valueSrc;
}),
valueType: convertedArgs.map(function (v) {
return v.valueType;
}),
asyncListValues: asyncListValues
}
};
}
if (not && canRev) {
//meta.errors.push(`No rev op for ${opKey}`);
res = wrapInDefaultConj(res, config, not);
}
return res;
};