@react-awesome-query-builder/core
Version:
User-friendly query builder for React. Core
255 lines (252 loc) • 11.8 kB
JavaScript
;
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
var _typeof = require("@babel/runtime/helpers/typeof");
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.wrapInDefaultConj = exports.buildSimpleSwitch = exports.buildRuleGroup = exports.buildRule = exports.buildCaseValProperties = exports.buildCase = void 0;
var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
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 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,
isObject = _Utils$OtherUtils.isObject,
uuid = _Utils$OtherUtils.uuid;
var _Utils$DefaultUtils = Utils.DefaultUtils,
defaultConjunction = _Utils$DefaultUtils.defaultConjunction,
defaultGroupConjunction = _Utils$DefaultUtils.defaultGroupConjunction;
var _Utils$ConfigUtils = Utils.ConfigUtils,
getFieldConfig = _Utils$ConfigUtils.getFieldConfig,
getWidgetForFieldOp = _Utils$ConfigUtils.getWidgetForFieldOp;
// export const wrapInDefaultConjRuleGroup = (rule, parentField, parentFieldConfig, config, conj) => {
// if (!rule) return undefined;
// return {
// type: "rule_group",
// id: uuid(),
// children1: { [rule.id]: rule },
// properties: {
// conjunction: conj || defaultGroupConjunction(config, parentFieldConfig),
// not: false,
// field: parentField,
// }
// };
// };
var wrapInDefaultConj = exports.wrapInDefaultConj = function wrapInDefaultConj(rule, config) {
var not = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
return {
type: "group",
id: uuid(),
children1: (0, _defineProperty2["default"])({}, rule.id, rule),
properties: {
conjunction: defaultConjunction(config),
not: not || false
}
};
};
var buildCase = exports.buildCase = function buildCase(convCond, convVal, conv, config, meta) {
var spel = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : null;
var valProperties = buildCaseValProperties(config, meta, conv, convVal, spel);
var caseI;
if (convCond) {
caseI = convCond;
if (caseI.type) {
if (caseI.type != "group" && caseI.type != "case_group") {
caseI = wrapInDefaultConj(caseI, config);
}
caseI.type = "case_group";
} else {
meta.errors.push("Unexpected case: ".concat(JSON.stringify(caseI)));
caseI = undefined;
}
} else {
caseI = {
id: uuid(),
type: "case_group",
properties: {}
};
}
if (caseI) {
caseI.properties = _objectSpread(_objectSpread({}, caseI.properties), valProperties);
}
return caseI;
};
var buildSimpleSwitch = exports.buildSimpleSwitch = function buildSimpleSwitch(convVal, conv, config, meta) {
var children1 = {};
var caseI = buildCase(null, convVal, conv, config, meta);
if (caseI) {
children1[caseI.id] = caseI;
}
var res = {
type: "switch_group",
id: uuid(),
children1: children1,
properties: {}
};
return res;
};
var buildRuleGroup = exports.buildRuleGroup = function buildRuleGroup(_ref, opKey, convertedArgs, config, meta) {
var groupFilter = _ref.groupFilter,
groupFieldValue = _ref.groupFieldValue;
if (groupFieldValue.valueSrc != "field") throw "Bad groupFieldValue: ".concat(JSON.stringify(groupFieldValue));
var groupField = groupFieldValue.value;
var groupOpRule = buildRule(config, meta, groupField, opKey, convertedArgs);
if (!groupOpRule) return undefined;
var fieldConfig = getFieldConfig(config, groupField);
var mode = fieldConfig === null || fieldConfig === void 0 ? void 0 : fieldConfig.mode;
var res;
if ((groupFilter === null || groupFilter === void 0 ? void 0 : groupFilter.type) === "group") {
res = _objectSpread(_objectSpread({}, groupFilter || {}), {}, {
type: "rule_group",
properties: _objectSpread(_objectSpread(_objectSpread({}, groupOpRule.properties), (groupFilter === null || groupFilter === void 0 ? void 0 : groupFilter.properties) || {}), {}, {
mode: mode
})
});
} else if (groupFilter) {
// rule_group in rule_group
res = _objectSpread(_objectSpread({}, groupOpRule || {}), {}, {
type: "rule_group",
children1: [groupFilter],
properties: _objectSpread(_objectSpread({}, groupOpRule.properties), {}, {
mode: mode
})
});
} else {
res = _objectSpread(_objectSpread({}, groupOpRule || {}), {}, {
type: "rule_group",
properties: _objectSpread(_objectSpread({}, groupOpRule.properties), {}, {
mode: mode
})
});
}
if (!res.id) res.id = uuid();
return res;
};
var buildCaseValProperties = exports.buildCaseValProperties = function buildCaseValProperties(config, meta, conv, convVal) {
var spel = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null;
var valProperties = {};
var widget;
var widgetConfig;
var caseValueFieldConfig = getFieldConfig(config, "!case_value");
if ((convVal === null || convVal === void 0 ? void 0 : convVal.valueType) === "case_value") {
/**
* @deprecated
*/
widget = "case_value";
} else {
widget = caseValueFieldConfig === null || caseValueFieldConfig === void 0 ? void 0 : caseValueFieldConfig.mainWidget;
widgetConfig = config.widgets[widget];
if (convVal && convVal.valueSrc === "value") {
var _widgetConfig;
convVal.valueType = ((_widgetConfig = widgetConfig) === null || _widgetConfig === void 0 ? void 0 : _widgetConfig.type) || (caseValueFieldConfig === null || caseValueFieldConfig === void 0 ? void 0 : caseValueFieldConfig.type) || convVal.valueType;
}
}
var widgetDef = config.widgets[widget];
if (widget === "case_value") {
/**
* @deprecated
*/
var importCaseValue = widgetDef === null || widgetDef === void 0 ? void 0 : widgetDef.spelImportValue;
if (importCaseValue) {
var _importCaseValue$call = importCaseValue.call(config.ctx, convVal),
_importCaseValue$call2 = (0, _slicedToArray2["default"])(_importCaseValue$call, 2),
normVal = _importCaseValue$call2[0],
normErrors = _importCaseValue$call2[1];
normErrors.map(function (e) {
return meta.errors.push(e);
});
if (normVal != undefined) {
var _widgetDef$type;
valProperties = {
value: [normVal],
valueSrc: ["value"],
valueType: [(_widgetDef$type = widgetDef === null || widgetDef === void 0 ? void 0 : widgetDef.type) !== null && _widgetDef$type !== void 0 ? _widgetDef$type : "case_value"],
field: "!case_value"
};
}
}
} else if (convVal != undefined && (convVal === null || convVal === void 0 ? void 0 : convVal.value) != undefined) {
valProperties = {
value: [convVal.value],
valueSrc: [convVal.valueSrc],
valueType: [convVal.valueType],
field: "!case_value"
};
}
return valProperties;
};
var buildRule = exports.buildRule = function buildRule(config, meta, field, opKey, convertedArgs, spel) {
var _field, _opConfig;
if (convertedArgs.filter(function (v) {
return v === undefined;
}).length) {
return undefined;
}
var fieldSrc = (_field = field) !== null && _field !== void 0 && _field.func ? "func" : "field";
if (isObject(field) && field.valueSrc) {
// if comed from convertFuncToOp()
fieldSrc = field.valueSrc;
field = field.value;
}
var fieldConfig = getFieldConfig(config, field);
if (!fieldConfig) {
meta.errors.push("No config for field ".concat(field));
return undefined;
}
var parentFieldConfig = getFieldConfig(config, spel === null || spel === void 0 ? void 0 : spel._groupField);
var isRuleGroup = fieldConfig.type == "!group";
var isGroupArray = isRuleGroup && fieldConfig.mode == "array";
var isInRuleGroup = (parentFieldConfig === null || parentFieldConfig === void 0 ? void 0 : parentFieldConfig.type) == "!group";
var opConfig = config.operators[opKey];
var reversedOpConfig = config.operators[(_opConfig = opConfig) === null || _opConfig === void 0 ? void 0 : _opConfig.reversedOp];
var opNeedsReverse = (spel === null || spel === void 0 ? void 0 : spel.not) && ["between"].includes(opKey);
var opCanReverse = !!reversedOpConfig;
var canRev = opCanReverse && (!!config.settings.reverseOperatorsForNot || opNeedsReverse || !isRuleGroup && isInRuleGroup // 2+ rules in rule-group should be flat. see inits.with_not_and_in_some in test
);
var needRev = (spel === null || spel === void 0 ? void 0 : spel.not) && canRev || opNeedsReverse;
if (needRev) {
// todo: should be already handled at convertOp ? or there are special cases to handle here, like rule-group ?
opKey = opConfig.reversedOp;
opConfig = config.operators[opKey];
spel.not = !spel.not;
}
var needWrapWithNot = !!(spel !== null && spel !== void 0 && spel.not);
var widget = getWidgetForFieldOp(config, field, opKey);
var widgetConfig = config.widgets[widget || fieldConfig.mainWidget];
var asyncListValuesArr = convertedArgs.map(function (v) {
return v.asyncListValues;
}).filter(function (v) {
return v != undefined;
});
var asyncListValues = asyncListValuesArr.length ? asyncListValuesArr[0] : undefined;
var res = {
type: "rule",
id: uuid(),
properties: _objectSpread({
field: field,
fieldSrc: fieldSrc,
operator: opKey,
value: convertedArgs.map(function (v) {
return v.value;
}),
valueSrc: convertedArgs.map(function (v) {
return v.valueSrc;
}),
valueType: convertedArgs.map(function (v) {
if (v.valueSrc == "value") {
return (widgetConfig === null || widgetConfig === void 0 ? void 0 : widgetConfig.type) || (fieldConfig === null || fieldConfig === void 0 ? void 0 : fieldConfig.type) || v.valueType;
}
return v.valueType;
})
}, asyncListValues ? {
asyncListValues: asyncListValues
} : {})
};
if (needWrapWithNot) {
res = wrapInDefaultConj(res, config, spel.not);
// spel.not = !spel.not; // why I added this line?
}
return res;
};