@yantrix/functions
Version:
Typescript built-ins for Yantrix framework
573 lines (563 loc) • 18.5 kB
JavaScript
import * as _ from 'lodash-es';
import { isEqual, isNull, every, some, isNil, isNumber, isArray, isObject } from 'lodash-es';
import { isPositiveInteger, isPositiveNumber } from '@yantrix/utils';
var __defProp = Object.defineProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
var __export = (target, all2) => {
for (var name in all2)
__defProp(target, name, { get: all2[name], enumerable: true });
};
function currentStateId(automataClass) {
return (automata) => automata instanceof automataClass ? automata.state : null;
}
__name(currentStateId, "currentStateId");
function currentStateName(automataClass, statesDictionary) {
return (automata) => automata instanceof automataClass ? Object.entries(statesDictionary).find(([_3, id]) => id === automata.state)?.[0] ?? null : null;
}
__name(currentStateName, "currentStateName");
function currentActionId(automataClass) {
return (automata) => automata instanceof automataClass ? automata.lastAction : null;
}
__name(currentActionId, "currentActionId");
function currentActionName(automataClass, actionsDictionary) {
return (automata) => automata instanceof automataClass ? Object.entries(actionsDictionary).find(([_3, id]) => id === automata.lastAction)?.[0] ?? null : null;
}
__name(currentActionName, "currentActionName");
function currentCycle(automataClass) {
return (automata) => automata instanceof automataClass ? automata.currentCycle : null;
}
__name(currentCycle, "currentCycle");
function currentEpoch(epochRef) {
return () => epochRef;
}
__name(currentEpoch, "currentEpoch");
function currentTimestamp() {
if (typeof process !== "undefined" && process.hrtime?.bigint !== void 0) {
return Number(process.hrtime.bigint() / BigInt(1e3));
} else if (typeof performance !== "undefined" && performance.now !== void 0) {
return Math.floor(performance.now() * 1e3);
} else {
return Date.now() * 1e3;
}
}
__name(currentTimestamp, "currentTimestamp");
function currentTime() {
return (/* @__PURE__ */ new Date()).toISOString();
}
__name(currentTime, "currentTime");
function random(min2, max2) {
if (isNumber(min2) && isNumber(max2)) return Math.floor(Math.random() * (max2 - min2) + min2);
else return Math.round(Math.random());
}
__name(random, "random");
function weightedRandom(object) {
const objectKeys = Object.keys(object);
const objectWeights = Object.values(object);
if (objectKeys.length === 0) throw new Error("Weighted random object is empty");
for (const value of objectWeights) {
if (!Number.isInteger(value)) throw new Error("Weighted random object contains non-integer values");
else if (value <= 0) throw new Error("Weighted random object contains values of 0 or less");
}
const weightsSum = objectWeights.reduce((acc, weight) => acc + weight, 0);
const cumulativeWeights = [];
let cumulativeWeight = 0;
for (let index = 0; index < objectWeights.length; index++) {
cumulativeWeight += objectWeights[index] / weightsSum;
cumulativeWeights.push(cumulativeWeight);
}
const randomNumber = Math.random();
for (let i = 0; i < cumulativeWeights.length; i++) {
if (cumulativeWeights[i] >= randomNumber) return objectKeys[i];
}
throw new Error("Unexpected error, could not get weighted random value");
}
__name(weightedRandom, "weightedRandom");
var automataInternals = {
currentStateId,
currentStateName,
currentActionId,
currentActionName,
currentCycle,
currentEpoch
};
var pureInternals = {
currentTimestamp,
currentTime,
random,
weightedRandom
};
// src/typescript/conditionals.ts
var conditionals_exports = {};
__export(conditionals_exports, {
case: () => _case,
choose: () => choose,
coalesce: () => coalesce,
if: () => _if
});
// src/typescript/utils/errors.ts
var ERRORS = {
DIVISION_BY_ZERO: "Division by 0",
INVALID_NUMBER_OF_ARGUMENTS: "Invalid number of arguments",
INVALID_NUMERIC_ARGUMENT: "Argument must be provided and be a valid number.",
INVALID_BINARY_ARGUMENT: "Argument must be provided and be a valid binary",
INVALID_ARGUMENTS: "Invalid arguments",
INDEX_OUT_OF_RANGE: "Index out of range",
INVALID_PRECISION_ARGUMENT: "Precision must be a valid number.",
AT_LEAST_ONE_NUMBER_REQUIRED: "At least 1 parameter must be provided and be a number.",
ALL_ARGUMENTS_MUST_BE_NUMBERS: "All arguments must be numbers.",
LISTS_MUST_BE_ARRAYS: "All arguments provided must be lists",
MIN_TWO_LISTS_REQUIRED: "At least 2 lists of the same length must be provided.",
NON_EMPTY_LISTS_REQUIRED: "All lists must have at least 1 number.",
LISTS_MUST_BE_SAME_LENGTH: "All lists provided must be the same length.",
ALL_LIST_ITEMS_MUST_BE_NUMERIC: "All items in the provided lists must be numbers.",
UNEXPECTED_ERROR: "An unexpected error has occurred.",
ALL_ARGUMENTS_MUST_BE_STRINGS: "All arguments must be strings.",
ALL_ARGUMENTS_MUST_BE_LISTS: "All arguments must be lists.",
INVALID_LIST_ARGUMENT: "Invalid List argument",
LIST_LENGTH_MISMATCH: "All List arguments must be of the same length"
};
var errorTypes = {
DIVISION_BY_ZERO: EvalError,
INDEX_OUT_OF_RANGE: RangeError,
UNEXPECTED_ERROR: Error
};
function invalid(errorKey, extra) {
throw new (errorTypes[errorKey] ?? TypeError)(ERRORS[errorKey] + (extra ? `: ${extra}` : ""));
}
__name(invalid, "invalid");
// src/typescript/conditionals.ts
function _if(condition, trueValue, falseValue) {
return condition ? trueValue ?? condition : falseValue ?? null;
}
__name(_if, "_if");
var _case = /* @__PURE__ */ __name((...args) => {
if (!args?.length || args.length % 2 === 0)
return invalid("INVALID_ARGUMENTS");
const defaultValue = args[args.length - 1] ?? null;
for (let i = 0; i < args.length - 1; i++) {
if (i % 2 === 0 && typeof args[i] !== "boolean") {
return invalid("INVALID_BINARY_ARGUMENT");
}
if (args[i] === true) {
if (typeof args[i + 1] === "undefined")
return invalid("INDEX_OUT_OF_RANGE");
return args[i + 1];
}
}
return defaultValue;
}, "_case");
var coalesce = /* @__PURE__ */ __name((...values3) => {
if (!values3?.length) return invalid("INVALID_ARGUMENTS");
for (const value of values3) {
if (value !== null && value !== void 0) {
return value;
}
}
return null;
}, "coalesce");
function choose(index, ...options) {
if (options.length === 0) return invalid("INVALID_NUMBER_OF_ARGUMENTS");
const flattenedOptions = [...options || []];
if (index < 0 || index >= flattenedOptions.length) return invalid("INDEX_OUT_OF_RANGE");
return flattenedOptions[index];
}
__name(choose, "choose");
// src/typescript/predicates.ts
var predicates_exports = {};
__export(predicates_exports, {
all: () => all,
and: () => and,
any: () => any,
contains: () => contains,
has: () => has,
isEqual: () => isEqual,
isEven: () => isEven,
isGreater: () => isGreater,
isGreaterOrEqual: () => isGreaterOrEqual,
isInteger: () => isInteger,
isLess: () => isLess,
isLessOrEqual: () => isLessOrEqual,
isNegative: () => isNegative,
isNull: () => isNull,
isOdd: () => isOdd,
isPositive: () => isPositive,
none: () => none,
not: () => not,
or: () => or
});
var and = /* @__PURE__ */ __name((...conditions) => every(conditions || [], Boolean) ?? false, "and");
var all = and;
var or = /* @__PURE__ */ __name((...conditions) => some(conditions || [], Boolean) ?? false, "or");
var any = or;
var not = /* @__PURE__ */ __name((condition) => isNil(condition) ? invalid("INVALID_BINARY_ARGUMENT") : !condition, "not");
var none = /* @__PURE__ */ __name((...conditions) => every(conditions || [], (t) => !t) ?? false, "none");
function isEven(n) {
if (!Number.isFinite(n)) return invalid("INVALID_NUMERIC_ARGUMENT");
return n % 2 === 0;
}
__name(isEven, "isEven");
function isOdd(n) {
return !isEven(n);
}
__name(isOdd, "isOdd");
function isInteger(value) {
if (!Number.isFinite(value))
return invalid("INVALID_NUMERIC_ARGUMENT");
return Number.isInteger(value);
}
__name(isInteger, "isInteger");
function isGreater(a, b) {
return Number.isFinite(a) && Number.isFinite(b) ? a > b : invalid("ALL_ARGUMENTS_MUST_BE_NUMBERS");
}
__name(isGreater, "isGreater");
function isGreaterOrEqual(a, b) {
return Number.isFinite(a) && Number.isFinite(b) ? a >= b : invalid("ALL_ARGUMENTS_MUST_BE_NUMBERS");
}
__name(isGreaterOrEqual, "isGreaterOrEqual");
function isLess(a, b) {
return Number.isFinite(a) && Number.isFinite(b) ? a < b : invalid("ALL_ARGUMENTS_MUST_BE_NUMBERS");
}
__name(isLess, "isLess");
function isLessOrEqual(a, b) {
return Number.isFinite(a) && Number.isFinite(b) ? a <= b : invalid("ALL_ARGUMENTS_MUST_BE_NUMBERS");
}
__name(isLessOrEqual, "isLessOrEqual");
function isNegative(value) {
if (!Number.isFinite(value)) return invalid("INVALID_NUMERIC_ARGUMENT");
return value < 0;
}
__name(isNegative, "isNegative");
function isPositive(value) {
if (!Number.isFinite(value)) return invalid("INVALID_NUMERIC_ARGUMENT");
return value > 0;
}
__name(isPositive, "isPositive");
function contains(container, value) {
switch (true) {
case typeof container === "string":
if (typeof value === "string") return container.includes(value);
return invalid("INVALID_ARGUMENTS");
case Array.isArray(container):
return container.includes(value);
case !container:
return false;
case typeof container !== "object":
return invalid("INVALID_ARGUMENTS");
default:
return Object.values(container).includes(value);
}
}
__name(contains, "contains");
function has(container, key) {
if (!container) return false;
if (isNil(key))
return invalid("INVALID_ARGUMENTS");
try {
return Object.keys(container).includes(String(key));
} catch (error) {
return invalid("INVALID_ARGUMENTS", error.message);
}
}
__name(has, "has");
// src/typescript/transformers.ts
var transformers_exports = {};
__export(transformers_exports, {
add: () => add,
avg: () => avg,
ceil: () => ceil,
concat: () => concat2,
cos: () => cos,
dec: () => dec,
deg: () => deg,
diff: () => diff,
div: () => div,
every: () => every4,
filterBy: () => filterBy,
find: () => find2,
inc: () => inc,
indexOf: () => indexOf2,
intersect: () => intersect,
inv: () => inv,
keys: () => keys2,
left: () => left,
len: () => len,
lg: () => lg,
ln: () => ln,
log: () => log,
lookup: () => lookup,
max: () => max,
med: () => med,
merge: () => merge2,
min: () => min,
mod: () => mod,
mult: () => mult,
neg: () => neg,
omit: () => omit2,
padLeft: () => padLeft,
padRight: () => padRight,
pick: () => pick2,
pluck: () => pluck,
pow: () => pow,
rad: () => rad,
repeat: () => repeat2,
reverse: () => reverse2,
right: () => right,
round: () => round,
sample: () => sample2,
setAttr: () => setAttr,
shuffle: () => shuffle2,
sin: () => sin,
sort: () => sort,
sqrt: () => sqrt,
substr: () => substr,
sum: () => sum,
sumProduct: () => sumProduct,
sumsq: () => sumsq,
trunc: () => trunc,
unsetAttr: () => unsetAttr,
values: () => values2,
zip: () => zip2
});
function isCollection(value) {
return isArray(value) && every(value, (it) => isObject(it) && !isNull(it));
}
__name(isCollection, "isCollection");
function isIterable(obj) {
return !isNil(obj) && typeof obj[Symbol.iterator] === "function";
}
__name(isIterable, "isIterable");
// src/typescript/collections.ts
function len(iterable) {
return isIterable(iterable) ? iterable.length : 0;
}
__name(len, "len");
function lookup(list, value) {
if (!_.isArray(list)) return null;
for (const item of list) {
if (_.isEqual(item, value)) return item;
}
return null;
}
__name(lookup, "lookup");
function substr(str, start, end) {
if (!_.isString(str) || !Number.isFinite(start) || !_.isNil(end) && !Number.isFinite(end)) return "";
return str.substring(start, end);
}
__name(substr, "substr");
function pluck(collection, prop) {
return isCollection(collection) ? _.map(collection, (item) => item[prop]) : [];
}
__name(pluck, "pluck");
var left = _.take;
var right = _.takeRight;
var reverse2 = _.reverse;
var indexOf2 = _.indexOf;
var repeat2 = _.repeat;
var filterBy = _.filter;
var sort = _.sortBy;
var shuffle2 = _.shuffle;
var concat2 = _.concat;
var find2 = _.find;
var every4 = _.every;
var intersect = _.intersection;
var keys2 = _.keys;
var merge2 = _.merge;
var omit2 = _.omit;
var padRight = _.padEnd;
var padLeft = _.padStart;
var pick2 = _.pick;
var sample2 = _.sample;
var setAttr = _.set;
var unsetAttr = _.unset;
var values2 = _.values;
var zip2 = _.zip;
function add(...nums) {
if (!nums?.length) return null;
const flatNums = nums.flat();
let sum2 = 0;
for (let i = 0; i < flatNums.length; i++) {
if (!Number.isFinite(flatNums[i])) return invalid("ALL_ARGUMENTS_MUST_BE_NUMBERS");
sum2 += flatNums[i];
}
return sum2;
}
__name(add, "add");
function diff(a, b) {
return Number.isFinite(a) && Number.isFinite(b) ? b - a : invalid("ALL_ARGUMENTS_MUST_BE_NUMBERS");
}
__name(diff, "diff");
function mult(...nums) {
if (!nums?.length) return null;
const flatNums = nums.flat();
let product = 1;
for (let i = 0; i < flatNums.length; i++) {
if (!Number.isFinite(flatNums[i])) return invalid("ALL_ARGUMENTS_MUST_BE_NUMBERS");
product *= flatNums[i];
}
return product;
}
__name(mult, "mult");
function div(a, b) {
return Number.isFinite(a) && Number.isFinite(b) ? b === 0 ? invalid("DIVISION_BY_ZERO") : a / b : invalid("INVALID_ARGUMENTS");
}
__name(div, "div");
function pow(n, exp) {
return Number.isFinite(n) && Number.isFinite(exp) ? n ** exp : invalid("INVALID_ARGUMENTS");
}
__name(pow, "pow");
function inc(n) {
return add(n, 1);
}
__name(inc, "inc");
function dec(n) {
return add(n, -1);
}
__name(dec, "dec");
function neg(n) {
return mult(n, -1);
}
__name(neg, "neg");
function inv(n) {
return div(1, n);
}
__name(inv, "inv");
function mod(a, b) {
return Number.isFinite(a) && Number.isFinite(b) ? a % b : invalid("INVALID_ARGUMENTS");
}
__name(mod, "mod");
function trunc(n) {
return Number.isFinite(n) ? Math.trunc(n) : invalid("INVALID_NUMERIC_ARGUMENT");
}
__name(trunc, "trunc");
function ceil(n) {
return Number.isFinite(n) ? Math.ceil(n) : invalid("INVALID_NUMERIC_ARGUMENT");
}
__name(ceil, "ceil");
function round(n, precision = 0) {
if (_.isNil(n)) return null;
if (!Number.isFinite(n)) return invalid("INVALID_NUMERIC_ARGUMENT");
if (!isPositiveInteger(precision) && precision !== 0)
return invalid("INVALID_PRECISION_ARGUMENT");
const factor = 10 ** precision;
return Math.round(n * factor) / factor;
}
__name(round, "round");
function sin(n) {
return Number.isFinite(n) ? Math.sin(n) : invalid("INVALID_NUMERIC_ARGUMENT");
}
__name(sin, "sin");
function cos(n) {
return Number.isFinite(n) ? Math.cos(n) : invalid("INVALID_NUMERIC_ARGUMENT");
}
__name(cos, "cos");
function sqrt(n) {
return Number.isFinite(n) ? Math.sqrt(n) : invalid("INVALID_NUMERIC_ARGUMENT");
}
__name(sqrt, "sqrt");
function ln(n) {
return Math.log(n);
}
__name(ln, "ln");
function log(num, base) {
return Number.isFinite(num) && isPositiveNumber(base) ? ln(num) / ln(base) : invalid("INVALID_ARGUMENTS");
}
__name(log, "log");
function lg(n) {
return log(n, 10);
}
__name(lg, "lg");
function deg(rads) {
return Number.isFinite(rads) ? rads * (180 / Math.PI) : invalid("INVALID_NUMERIC_ARGUMENT");
}
__name(deg, "deg");
function rad(degs) {
return Number.isFinite(degs) ? degs * (Math.PI / 180) : invalid("INVALID_NUMERIC_ARGUMENT");
}
__name(rad, "rad");
// src/typescript/stats.ts
function max(...nums) {
const flatNums = nums.flat();
if (!flatNums.length) return null;
let mx = -Infinity;
for (let i = 0; i < flatNums.length; i++) {
if (!Number.isFinite(flatNums[i])) return invalid("ALL_ARGUMENTS_MUST_BE_NUMBERS");
if (flatNums[i] > mx) mx = flatNums[i];
}
return mx;
}
__name(max, "max");
function min(...nums) {
const flatNums = nums.flat();
if (!flatNums?.length) return null;
let mn = Infinity;
for (let i = 0; i < flatNums.length; i++) {
if (!Number.isFinite(flatNums[i])) return invalid("ALL_ARGUMENTS_MUST_BE_NUMBERS");
if (flatNums[i] < mn) mn = flatNums[i];
}
return mn;
}
__name(min, "min");
function sum(...nums) {
const flatNums = nums.flat();
if (!flatNums?.length) return null;
return flatNums.reduce((sum2, num) => !Number.isFinite(num) ? invalid("ALL_ARGUMENTS_MUST_BE_NUMBERS") : sum2 + num, 0);
}
__name(sum, "sum");
function avg(...nums) {
const flatNums = nums.flat();
if (!flatNums?.length) return null;
return (sum(...flatNums) ?? invalid("INVALID_NUMERIC_ARGUMENT")) / flatNums.length;
}
__name(avg, "avg");
function med(...nums) {
const flatNums = nums.flat();
if (!flatNums.length) return null;
if (!flatNums.every((t) => Number.isFinite(t))) return invalid("INVALID_NUMERIC_ARGUMENT");
const sorted = flatNums.sort();
const middle = Math.floor(sorted.length / 2);
return sorted.length % 2 ? sorted[middle] : (sorted[middle - 1] + sorted[middle]) / 2;
}
__name(med, "med");
function sumsq(...nums) {
const flatNums = nums.flat();
if (!flatNums.length) return null;
return flatNums.reduce((acc, num) => acc + num * num, 0);
}
__name(sumsq, "sumsq");
var sumProduct = /* @__PURE__ */ __name((...lists) => {
const tuples = Array.from({ length: Math.max(...lists.map((t) => t.length)) });
if (!lists.length) return null;
for (const list of lists) {
if (!Array.isArray(list)) return invalid("ALL_ARGUMENTS_MUST_BE_LISTS");
if (list.length < tuples.length) return invalid("LIST_LENGTH_MISMATCH");
for (let i = 0; i < list.length; i++) {
if (!Number.isFinite(list[i])) return invalid("ALL_LIST_ITEMS_MUST_BE_NUMERIC");
if (!tuples[i]) tuples[i] = [];
tuples[i] = (tuples[i] || []).concat(list[i]);
}
}
return sum(tuples.map((t) => mult(...t)));
}, "sumProduct");
// src/index.ts
var Conditionals = {
...conditionals_exports
};
var Predicates = {
...predicates_exports
};
var Transformers = {
...transformers_exports
};
var builtInFunctions = {
...conditionals_exports,
...predicates_exports,
...transformers_exports
};
var internalFunctions = {
...automataInternals,
...pureInternals
};
var ReservedInternalFunctionNames = Object.keys(automataInternals);
export { Conditionals, Predicates, ReservedInternalFunctionNames, Transformers, builtInFunctions, internalFunctions };
//# sourceMappingURL=index.js.map
//# sourceMappingURL=index.js.map