@digifi/jexl-functions
Version:
Package with available JEXL functions
156 lines (155 loc) • 6.39 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
const module_1 = require("../utils/module");
exports.default = (0, module_1.createModule)(({ evalCriteriaParseResult, parseCriteriaExpression, validateCriteria, safeFlatten, coerceToNumber, }) => {
const AVERAGE = (...args) => {
const flattenArgs = safeFlatten(args);
const sum = flattenArgs.reduce((previousSum, arg) => {
return typeof arg === 'number' ? previousSum + coerceToNumber(arg) : previousSum;
}, 0);
return sum / flattenArgs.length;
};
const AVERAGEA = (...args) => {
const flattenArgs = safeFlatten(args);
const { sum, items } = flattenArgs.reduce((previousResult, arg) => {
if (typeof arg === 'number' || arg === true) {
return {
sum: previousResult.sum + Number(arg),
items: previousResult.items + 1,
};
}
if (arg !== null) {
return Object.assign(Object.assign({}, previousResult), { items: previousResult.items + 1 });
}
return previousResult;
}, { items: 0, sum: 0 });
return sum / items;
};
const AVERAGEIF = (range, criteria, averageRange) => {
const flattenRange = safeFlatten(range);
const flattenAverageRange = averageRange ? safeFlatten(averageRange) : flattenRange;
validateCriteria(criteria);
const parseResult = parseCriteriaExpression(criteria);
const { count, result } = flattenRange.reduce((data, valueInRange, index) => {
const evaluationResult = evalCriteriaParseResult(parseResult, valueInRange);
return evaluationResult
? { result: data.result + coerceToNumber(flattenAverageRange[index]), count: data.count + 1 }
: data;
}, { count: 0, result: 0 });
return result / count;
};
const COUNTIF = (range, criteria) => {
const flattenRange = safeFlatten(range);
validateCriteria(criteria);
const parseResult = parseCriteriaExpression(criteria);
return flattenRange.reduce((previousCount, valueInRange) => {
const evaluationResult = evalCriteriaParseResult(parseResult, valueInRange);
return evaluationResult
? previousCount + 1
: previousCount;
}, 0);
};
const MAX = (...args) => {
const flattenArg = safeFlatten(args);
const filteredArgs = flattenArg.filter((arg) => typeof arg === 'number');
return Math.max(...filteredArgs);
};
const MAXA = (...args) => {
const result = safeFlatten(args).reduce((maxValue, arg) => {
const coercedValue = coerceToNumber(arg);
const valueForCompare = Number.isNaN(coercedValue) ? 0 : coercedValue;
return valueForCompare > maxValue ? valueForCompare : maxValue;
}, -Infinity);
return result === -Infinity ? 0 : result;
};
const MIN = (...args) => {
const flattenArg = safeFlatten(args);
const filteredArgs = flattenArg.filter((arg) => typeof arg === 'number');
return Math.min(...filteredArgs);
};
const MINA = (...args) => {
const result = safeFlatten(args).reduce((minValue, arg) => {
const coercedValue = coerceToNumber(arg);
const valueForCompare = Number.isNaN(coercedValue) ? 0 : coercedValue;
return minValue > valueForCompare ? valueForCompare : minValue;
}, Infinity);
return result === Infinity ? 0 : result;
};
const MODE = (...args) => {
const countsByValues = {};
let currentMostCommonValue;
for (const arg of safeFlatten(args)) {
const coercedArg = coerceToNumber(arg);
const newCount = countsByValues[coercedArg] + 1;
countsByValues[coercedArg] = newCount;
if (currentMostCommonValue === undefined || countsByValues[currentMostCommonValue] < newCount) {
currentMostCommonValue = coercedArg;
}
}
return currentMostCommonValue;
};
const STANDARDIZE = (value, mean, sd) => {
return (coerceToNumber(value) - coerceToNumber(mean)) / coerceToNumber(sd);
};
const SMALL = (array, k) => {
const numberArray = safeFlatten(array).map((item) => coerceToNumber(item));
return numberArray.sort((firstItem, secondItem) => firstItem - secondItem)[coerceToNumber(k) - 1];
};
const LARGE = (array, k) => {
const numberArray = safeFlatten(array).map((item) => coerceToNumber(item));
return numberArray.sort((firstItem, secondItem) => secondItem - firstItem)[coerceToNumber(k) - 1];
};
const COUNT = (...args) => {
return safeFlatten(args).filter((arg) => typeof arg === 'number').length;
};
const COUNTA = (...args) => {
return args.length;
};
const COUNTBLANK = (...args) => {
return safeFlatten(args).filter((arg) => arg === null || arg === undefined || arg === '').length;
};
const COUNTUNIQUE = (...args) => {
const visitedElements = {};
let count = 0;
for (const arg of safeFlatten(args)) {
if ((typeof arg === 'object' && arg !== null) || typeof arg === 'function') {
continue;
}
const identifier = `${typeof arg}-${arg}`;
const wasVisited = visitedElements[identifier];
if (!wasVisited) {
count++;
visitedElements[identifier] = true;
}
}
return count;
};
const MEDIAN = (...args) => {
const numberArray = safeFlatten(args).map((item) => coerceToNumber(item));
const half = Math.floor(numberArray.length / 2);
const sortedArray = numberArray.sort((firstArg, secondArg) => firstArg - secondArg);
if (sortedArray.length % 2) {
return sortedArray[half];
}
return (sortedArray[half - 1] + sortedArray[half]) / 2.0;
};
return {
AVERAGE,
AVERAGEA,
MAX,
MAXA,
MIN,
MINA,
MODE,
STANDARDIZE,
SMALL,
LARGE,
COUNT,
COUNTA,
COUNTBLANK,
MEDIAN,
AVERAGEIF,
COUNTIF,
COUNTUNIQUE,
};
});