@react-awesome-query-builder/core/esm/utils/funcUtils.js

User-friendly query builder for React. Core

import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
import { getFieldConfig, getFuncConfig, getFuncSignature, selectTypes } from "../utils/configUtils";
import { getDefaultArgValue, setArgValue, setFuncDefaultArgs, setFuncDefaultArg } from "../utils/ruleUtils";
import { validateValue } from "../utils/validation";
import Immutable from "immutable";
export { setArgValue, setFuncDefaultArgs, setFuncDefaultArg, getDefaultArgValue };

/**
 * @param {Immutable.Map} value 
 * @return {array} - [usedFields, badFields]
 */
// const getUsedFieldsInFuncValue = (value, config) => {
//   let usedFields = [];
//   let badFields = [];

//   const _traverse = (value) => {
//     const args = value && value.get("args");
//     if (!args) return;
//     for (const arg of args.values()) {
//       if (arg.get("valueSrc") == "field") {
//         const rightField = arg.get("value");
//         if (rightField) {
//           const rightFieldDefinition = config ? getFieldConfig(config, rightField) : undefined;
//           if (config && !rightFieldDefinition)
//             badFields.push(rightField);
//           else
//             usedFields.push(rightField);
//         }
//       } else if (arg.get("valueSrc") == "func") {
//         _traverse(arg.get("value"));
//       }
//     }
//   };

//   _traverse(value);

//   return [usedFields, badFields];
// };

/**
 * Used @ FuncWidget
 * @param {Immutable.Map} value 
 * @param {string} funcKey 
 * @param {object} config 
 * @param {boolean} canFixArgs
 */
export var setFunc = function setFunc(value, funcKey, config, canFixArgs) {
  var fieldSeparator = config.settings.fieldSeparator;
  value = value || new Immutable.Map();
  if (Array.isArray(funcKey)) {
    // fix for cascader
    funcKey = funcKey.join(fieldSeparator);
  }
  var oldFuncKey = value.get("func");
  var oldArgs = value.get("args");
  value = value.set("func", funcKey);
  var funcConfig = funcKey && getFuncConfig(config, funcKey);
  var newFuncSignature = funcKey && getFuncSignature(config, funcKey);
  var oldFuncSignature = oldFuncKey && getFuncSignature(config, oldFuncKey);
  var keepArgsKeys = getCompatibleArgsOnFuncChange(oldFuncSignature, newFuncSignature, oldArgs, config, canFixArgs);
  if (keepArgsKeys.length) {
    var argsKeys = Object.keys(newFuncSignature.args);
    var deleteArgsKeys = argsKeys.filter(function (k) {
      return !keepArgsKeys.includes(k);
    });
    value = deleteArgsKeys.reduce(function (value, k) {
      return value.deleteIn(["args", k]);
    }, value);
  } else {
    value = value.set("args", new Immutable.Map());
  }

  // defaults
  value = setFuncDefaultArgs(config, value, funcConfig);
  return value;
};

/**
* Used @ FuncWidget
* @param {Immutable.Map} value 
* @param {string} argKey 
* @param {string} argValSrc 
* @param {object} argConfig 
*/
export var setArgValueSrc = function setArgValueSrc(value, argKey, argValSrc, _argConfig, _config) {
  if (value && value.get("func")) {
    value = value.setIn(["args", argKey], new Immutable.Map({
      valueSrc: argValSrc
    }));
  }
  return value;
};
export var setArgValueAsyncListValues = function setArgValueAsyncListValues(value, argKey, asyncListValues, _argConfig, _config) {
  if (value && value.get("func")) {
    value = value.setIn(["args", argKey, "asyncListValues"], asyncListValues);
  }
  return value;
};

// see getFuncSignature in configUtils
export var getCompatibleArgsOnFuncChange = function getCompatibleArgsOnFuncChange(s1, s2, argVals, config) {
  var canFixArgs = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
  if ((s1 === null || s1 === void 0 ? void 0 : s1.returnType) != (s2 === null || s2 === void 0 ? void 0 : s2.returnType)) return [];
  var checkIndexes = false;
  var keys = Object.keys(s2.args);
  var compatibleKeys = keys.filter(function (k, i) {
    var arg2 = s2.args[k];
    var arg1 = s1.args[k];
    var oldInd = Object.keys(s1.args).indexOf(k);
    if (!arg1 && (arg2.defaultValue !== undefined || arg2.isOptional)) {
      return true;
    }
    if (checkIndexes && i !== oldInd) {
      return false;
    }
    if ((arg1 === null || arg1 === void 0 ? void 0 : arg1.type) != arg2.type) return false;
    if (selectTypes.includes(arg2.type)) {
      if (!arg1.listValuesType || arg1.listValuesType !== arg2.listValuesType) return false;
    }
    if (argVals) {
      var _argValidErrors$filte;
      var argVal = argVals.get(k);
      var argValue = argVal === null || argVal === void 0 ? void 0 : argVal.get("value");
      var argValueSrc = argVal === null || argVal === void 0 ? void 0 : argVal.get("valueSrc");
      if (argValueSrc && arg2.valueSources && !arg2.valueSources.includes(argValueSrc)) return false;
      var leftField = null,
        operator = null,
        argDef = arg2,
        asyncListValues = null,
        isEndValue = true;
      var _validateValue = validateValue(config, leftField, argDef, operator, argValue, argDef.type, argValueSrc, asyncListValues, canFixArgs, isEndValue),
        _validateValue2 = _slicedToArray(_validateValue, 2),
        _fixedArgVal = _validateValue2[0],
        argValidErrors = _validateValue2[1];
      if (argValidErrors !== null && argValidErrors !== void 0 && (_argValidErrors$filte = argValidErrors.filter(function (e) {
        return !e.fixed;
      })) !== null && _argValidErrors$filte !== void 0 && _argValidErrors$filte.length) return false;
    }
    return true;
  });
  return compatibleKeys;
};