@digifi/jexl-functions
Version:
Package with available JEXL functions
302 lines (301 loc) • 11.5 kB
JavaScript
;
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const bignumber_js_1 = __importDefault(require("bignumber.js"));
const errors_1 = require("../errors");
const module_1 = require("../utils/module");
exports.default = (0, module_1.createModule)(({ safeFlatten, coerceToNumber, validateArrayLikeValueMaxSize, evalCriteriaParseResult, parseCriteriaExpression, validateCriteria, }, { defaultMaxArraySize }) => {
const QUOTIENT = (numerator, denominator) => {
return Math.floor(coerceToNumber(numerator) / coerceToNumber(denominator));
};
const RADIANS = (value) => {
return (coerceToNumber(value) * Math.PI) / 180;
};
const UNFLATTENPRODUCT = (...args) => {
validateArrayLikeValueMaxSize(args);
return args.reduce((product, arg) => product * coerceToNumber(arg), 1);
};
const PRODUCT = (...args) => {
return UNFLATTENPRODUCT(...safeFlatten(args));
};
const ROUNDDOWN = (value, digits) => {
const coercedValue = coerceToNumber(value);
const coercedDigits = coerceToNumber(digits);
const sign = coercedValue > 0 ? 1 : -1;
return (sign * Math.floor(Math.abs(coercedValue) * Math.pow(10, coercedDigits))) / Math.pow(10, coercedDigits);
};
const ROUNDUP = (value, digits) => {
const coercedValue = coerceToNumber(value);
const coercedDigits = coerceToNumber(digits);
const sign = coercedValue > 0 ? 1 : -1;
return (sign * Math.ceil(Math.abs(coercedValue) * Math.pow(10, coercedDigits))) / Math.pow(10, coercedDigits);
};
const SEC = (value) => {
return 1 / Math.cos(coerceToNumber(value));
};
const SECH = (value) => {
const coercedValue = coerceToNumber(value);
return 2 / (Math.exp(coercedValue) + Math.exp(-coercedValue));
};
const SIN = (value) => {
return Math.sin(coerceToNumber(value));
};
const SINH = (value) => {
const coercedValue = coerceToNumber(value);
return (Math.exp(coercedValue) - Math.exp(-coercedValue)) / 2;
};
const SQRT = (value) => {
return Math.sqrt(coerceToNumber(value));
};
const SQRTPI = (value) => {
return Math.sqrt(coerceToNumber(value) * Math.PI);
};
const TAN = (value) => {
return Math.tan(coerceToNumber(value));
};
const TANH = (value) => {
const exp = Math.exp(2 * coerceToNumber(value));
return (exp - 1) / (exp + 1);
};
const TRUNC = (value, digits) => {
const coercedValue = coerceToNumber(value);
const coercedDigits = coerceToNumber(digits);
const factor = new bignumber_js_1.default(10).pow(coercedDigits);
/**
* [TODO] Rewrite to toLocaleString('en-US', {
* minimumFractionDigits: 2,
* maximumFractionDigits: 2,
* useGrouping: false,
* roundingMode: "trunc"
* }); after we will migrate to node.js 20
*/
return (0, bignumber_js_1.default)(coercedValue)
.multipliedBy(factor)
.integerValue(bignumber_js_1.default.ROUND_DOWN)
.dividedBy(factor)
.toNumber();
};
const SUM = (...args) => {
return safeFlatten(args).reduce((previousValue, arg) => {
return previousValue + coerceToNumber(arg);
}, 0);
};
const SUMSQ = (...args) => {
return safeFlatten(args).reduce((previousValue, arg) => {
const coercedArg = coerceToNumber(arg);
return previousValue + (coercedArg * coercedArg);
}, 0);
};
const SUMX2MY2 = (firstArray, secondArray) => {
const transformedFirstArray = Array.isArray(firstArray) ? firstArray : [firstArray];
const transformedSecondArray = Array.isArray(secondArray) ? secondArray : [secondArray];
validateArrayLikeValueMaxSize(transformedFirstArray);
validateArrayLikeValueMaxSize(transformedSecondArray);
return transformedFirstArray.reduce((previousValue, arg, index) => {
const coercedArg = coerceToNumber(arg);
const coercedSecondArg = coerceToNumber(transformedSecondArray[index]);
return previousValue + (coercedArg * coercedArg - coercedSecondArg * coercedSecondArg);
}, 0);
};
const SUMX2PY2 = (firstArray, secondArray) => {
const transformedFirstArray = Array.isArray(firstArray) ? firstArray : [firstArray];
const transformedSecondArray = Array.isArray(secondArray) ? secondArray : [secondArray];
validateArrayLikeValueMaxSize(transformedFirstArray);
validateArrayLikeValueMaxSize(transformedSecondArray);
return transformedFirstArray.reduce((previousValue, arg, index) => {
const coercedArg = coerceToNumber(arg);
const coercedSecondArg = coerceToNumber(transformedSecondArray[index]);
return previousValue + (coercedArg * coercedArg + coercedSecondArg * coercedSecondArg);
}, 0);
};
const SUMXMY2 = (firstArray, secondArray) => {
const transformedFirstArray = Array.isArray(firstArray) ? firstArray : [firstArray];
const transformedSecondArray = Array.isArray(secondArray) ? secondArray : [secondArray];
validateArrayLikeValueMaxSize(transformedFirstArray);
validateArrayLikeValueMaxSize(transformedSecondArray);
return transformedFirstArray.reduce((previousValue, arg, index) => {
const coercedArg = coerceToNumber(arg);
const coercedSecondArg = coerceToNumber(transformedSecondArray[index]);
return previousValue + Math.pow(coercedArg - coercedSecondArg, 2);
}, 0);
};
const SUMIF = (range, criteria, sumRange) => {
const flattenRange = safeFlatten(range);
const flattenSumRange = sumRange ? safeFlatten(sumRange) : flattenRange;
validateCriteria(criteria);
const parseResult = parseCriteriaExpression(criteria);
return flattenRange.reduce((result, valueInRange, index) => {
const evaluationResult = evalCriteriaParseResult(parseResult, valueInRange);
return evaluationResult
? result + coerceToNumber(flattenSumRange[index])
: result;
}, 0);
};
const ABS = (value) => {
return Math.abs(coerceToNumber(value));
};
const ACOS = (value) => {
return Math.acos(coerceToNumber(value));
};
const ACOSH = (value) => {
return Math.acosh(coerceToNumber(value));
};
const ACOT = (value) => {
return Math.atan(1 / coerceToNumber(value));
};
const ACOTH = (value) => {
const coercedValue = coerceToNumber(value);
return 0.5 * Math.log((coercedValue + 1) / (coercedValue - 1));
};
const ASIN = (value) => {
return Math.asin(coerceToNumber(value));
};
const ASINH = (value) => {
return Math.asinh(coerceToNumber(value));
};
const ATAN = (value) => {
return Math.atan(coerceToNumber(value));
};
const ATAN2 = (firstValue, secondValue) => {
return Math.atan2(coerceToNumber(firstValue), coerceToNumber(secondValue));
};
const ATANH = (value) => {
return Math.atanh(coerceToNumber(value));
};
const COS = (value) => {
return Math.cos(coerceToNumber(value));
};
const COSH = (value) => {
return Math.cosh(coerceToNumber(value));
};
const COT = (value) => {
return 1 / Math.tan(coerceToNumber(value));
};
const COTH = (value) => {
const coercedValue = coerceToNumber(value);
return (Math.exp(2 * coercedValue) + 1) / (Math.exp(2 * coercedValue) - 1);
};
const CSC = (value) => {
return 1 / Math.sin(coerceToNumber(value));
};
const CSCH = (value) => {
const coercedValue = coerceToNumber(value);
return 2 / (Math.exp(coercedValue) - Math.exp(-coercedValue));
};
const E = () => {
return Math.E;
};
const EVEN = (value) => {
const flooredValue = Math.floor(coerceToNumber(value));
const isEvenFlooredValue = flooredValue % 2 === 0;
if (value === flooredValue && isEvenFlooredValue) {
return value;
}
return isEvenFlooredValue ? flooredValue + 2 : flooredValue + 1;
};
const EXP = (value) => {
return Math.exp(coerceToNumber(value));
};
const LN = (value) => {
return Math.log(coerceToNumber(value));
};
const LOG = (value, base) => {
return Math.log(coerceToNumber(value)) / Math.log(coerceToNumber(base));
};
const MOD = (value, divisor) => {
const coercedValue = coerceToNumber(value);
const coercedDivisor = coerceToNumber(divisor);
const modulus = Math.abs(coercedValue % coercedDivisor);
const result = coercedValue < 0 ? coercedDivisor - modulus : modulus;
return coercedDivisor > 0 ? result : -result;
};
const ODD = (value) => {
const coercedValue = coerceToNumber(value);
const ceilledValue = Math.ceil(Math.abs(coercedValue));
const result = ceilledValue & 1 ? ceilledValue : ceilledValue + 1;
return coercedValue >= 0 ? result : -result;
};
const PI = () => {
return Math.PI;
};
const POWER = (value, power) => {
return Math.pow(coerceToNumber(value), coerceToNumber(power));
};
const RAND = () => {
return Math.random();
};
const RANDBETWEEN = (bottom, top) => {
const coercedBottom = coerceToNumber(bottom);
const coercedTop = coerceToNumber(top);
return coercedBottom + Math.ceil((coercedTop - coercedBottom + 1) * Math.random()) - 1;
};
const ROUND = (value, digits) => {
const coercedValue = coerceToNumber(value);
const coercedDigits = coerceToNumber(digits);
return Math.round(coercedValue * Math.pow(10, coercedDigits)) / Math.pow(10, coercedDigits);
};
const BASE = (value, radix, minLength) => {
const coercedValue = coerceToNumber(value);
const coercedRadix = coerceToNumber(radix);
const coercedMinLength = coerceToNumber(minLength);
const valueInString = coercedValue.toString(coercedRadix);
const digitsToAdd = coercedMinLength + 1 - valueInString.length;
if (digitsToAdd > defaultMaxArraySize) {
throw new errors_1.JexlFunctionExecutionError(`Min length should be less or equal than: ${coercedMinLength - 1 + valueInString.length}`);
}
return new Array(Math.max(coercedMinLength + 1 - valueInString.length, 0)).join('0') + valueInString;
};
return {
QUOTIENT,
RADIANS,
PRODUCT,
ROUNDDOWN,
ROUNDUP,
SEC,
SECH,
SIN,
SINH,
SQRT,
SQRTPI,
TAN,
TANH,
TRUNC,
SUM,
SUMSQ,
SUMX2MY2,
SUMX2PY2,
SUMXMY2,
SUMIF,
ABS,
ROUND,
RANDBETWEEN,
RAND,
PI,
POWER,
ODD,
LOG,
MOD,
EVEN,
EXP,
LN,
CSC,
CSCH,
COT,
COTH,
E,
ASIN,
ATAN,
COS,
COSH,
ATAN2,
ATANH,
ACOS,
ACOSH,
ACOT,
ACOTH,
ASINH,
BASE,
};
});