blixify-ui-web 1.2.181 → 1.2.183

package/lib/components/data/formula/functions.js

@@ -0,0 +1,773 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleToFormulaDate = exports.handleFormatFormulaDate = exports.FORMULA_FUNCTION_CATEGORIES = exports.FORMULA_CONSTANTS = exports.FORMULA_FUNCTIONS = exports.handleToFormulaText = exports.handleToFormulaNumber = exports.FORMULA_MAX_TEXT = void 0;
+var dayjs_1 = __importDefault(require("../../dayjs"));
+var advancedFormat_1 = __importDefault(require("dayjs/plugin/advancedFormat"));
+var weekOfYear_1 = __importDefault(require("dayjs/plugin/weekOfYear"));
+dayjs_1.default.extend(advancedFormat_1.default);
+dayjs_1.default.extend(weekOfYear_1.default);
+var dayjs = dayjs_1.default;
+exports.FORMULA_MAX_TEXT = 10000;
+//=====================================================================================
+//SECTION: Value coercion — Monday semantics: an empty cell is "" everywhere,
+// which reads as 0 in arithmetic and as blank text in text functions
+//=====================================================================================
+var handleToFormulaNumber = function (value) {
+    if (value === "" || value === null || value === undefined)
+        return 0;
+    if (typeof value === "boolean")
+        return value ? 1 : 0;
+    return Number(value);
+};
+exports.handleToFormulaNumber = handleToFormulaNumber;
+var handleToFormulaText = function (value) {
+    if (value === null || value === undefined)
+        return "";
+    if (typeof value === "number")
+        return Number.isFinite(value) ? String(handleRoundTo(value, 10)) : "NaN";
+    return String(value);
+};
+exports.handleToFormulaText = handleToFormulaText;
+var handleRoundTo = function (value, digits) {
+    var factor = Math.pow(10, digits);
+    return Math.round(value * factor) / factor;
+};
+var handleToFormulaDate = function (value) {
+    if (value === "" || value === null || value === undefined)
+        return null;
+    var parsed = dayjs(value instanceof Date ? value : String(value));
+    return parsed.isValid() ? parsed : null;
+};
+exports.handleToFormulaDate = handleToFormulaDate;
+// INFO: a date that carries no time of day is written without one, so a date
+// column and TODAY() compare as equal text and display the way they were typed
+var handleFormatFormulaDate = function (date) {
+    if (!date)
+        return "";
+    var hasTime = date.hour() !== 0 || date.minute() !== 0 || date.second() !== 0;
+    return date.format(hasTime ? "YYYY-MM-DD HH:mm" : "YYYY-MM-DD");
+};
+exports.handleFormatFormulaDate = handleFormatFormulaDate;
+// INFO: joins text up to the formula text cap and stops there, rather than
+// building the whole string and cutting it afterwards
+var handleJoinCapped = function (parts) {
+    var output = "";
+    for (var _i = 0, parts_1 = parts; _i < parts_1.length; _i++) {
+        var each = parts_1[_i];
+        var room = exports.FORMULA_MAX_TEXT - output.length;
+        if (room <= 0)
+            break;
+        output += each.length > room ? each.slice(0, room) : each;
+    }
+    return output;
+};
+var handleFlattenArgs = function (args) {
+    return args.reduce(function (acc, each) { return acc.concat(Array.isArray(each) ? each : [each]); }, []);
+};
+// INFO: TEXT(8500.6, "$#,##0.00") — the subset of spreadsheet number formats
+// Monday documents: literal prefix/suffix, thousands separator, fixed decimals
+// and a trailing percent
+var handleFormatNumberPattern = function (value, pattern) {
+    var numberValue = (0, exports.handleToFormulaNumber)(value);
+    if (!Number.isFinite(numberValue))
+        return "NaN";
+    var match = /[#0][#0,]*(\.[#0]+)?%?/.exec(pattern !== null && pattern !== void 0 ? pattern : "");
+    if (!match)
+        return (0, exports.handleToFormulaText)(value);
+    var token = match[0];
+    var isPercent = token.endsWith("%");
+    var decimals = match[1] ? match[1].length - 1 : 0;
+    var scaled = isPercent ? numberValue * 100 : numberValue;
+    var formatted = scaled.toLocaleString("en-US", {
+        minimumFractionDigits: decimals,
+        maximumFractionDigits: decimals,
+        useGrouping: token.includes(","),
+    });
+    return (pattern.slice(0, match.index) +
+        formatted +
+        (isPercent ? "%" : "") +
+        pattern.slice(match.index + token.length));
+};
+var handleCountWorkdays = function (to, from) {
+    var _a;
+    var start = handleToFormulaDate(from);
+    var end = handleToFormulaDate(to);
+    if (!start || !end)
+        return NaN;
+    start = start.startOf("day");
+    end = end.startOf("day");
+    var sign = end.isBefore(start) ? -1 : 1;
+    if (sign < 0)
+        _a = [end, start], start = _a[0], end = _a[1];
+    // INFO: whole weeks are counted at once and only the remainder (under 7
+    // days) is walked — a span of centuries is as quick as a span of days, so a
+    // mistyped year cannot freeze the table
+    var totalDays = end.diff(start, "day") + 1;
+    var fullWeeks = Math.floor(totalDays / 7);
+    var count = fullWeeks * 5;
+    var cursor = start.add(fullWeeks * 7, "day");
+    while (!cursor.isAfter(end)) {
+        var weekday = cursor.day();
+        if (weekday !== 0 && weekday !== 6)
+            count += 1;
+        cursor = cursor.add(1, "day");
+    }
+    return count * sign;
+};
+var handleAddWorkdays = function (date, days) {
+    var cursor = handleToFormulaDate(date);
+    if (!cursor)
+        return "";
+    var total = Math.trunc((0, exports.handleToFormulaNumber)(days));
+    if (!Number.isFinite(total))
+        return "";
+    var step = total < 0 ? -1 : 1;
+    // INFO: every 5 working days is exactly one calendar week, so whole weeks
+    // jump at once and only the last few days are walked
+    var fullWeeks = Math.floor(Math.abs(total) / 5);
+    cursor = cursor.add(step * fullWeeks * 7, "day");
+    var remaining = Math.abs(total) - fullWeeks * 5;
+    // INFO: a start on a weekend lands on the weekend after the jump; with
+    // nothing left to add the result moves to the next working day in the
+    // direction of travel, as a day-by-day walk would have
+    if (remaining === 0 && fullWeeks > 0)
+        while (cursor.day() === 0 || cursor.day() === 6)
+            cursor = cursor.add(-step, "day");
+    while (remaining > 0) {
+        cursor = cursor.add(step, "day");
+        if (cursor.day() !== 0 && cursor.day() !== 6)
+            remaining -= 1;
+    }
+    return handleFormatFormulaDate(cursor);
+};
+var handleParseHours = function (value) {
+    var _a = (0, exports.handleToFormulaText)(value).split(":").map(Number), hours = _a[0], minutes = _a[1];
+    if (isNaN(hours))
+        return NaN;
+    return hours * 60 + (isNaN(minutes) ? 0 : minutes);
+};
+//=====================================================================================
+//SECTION: Function library — names, descriptions and examples follow
+// monday.com's "Available functions in the Formula Column"
+//=====================================================================================
+exports.FORMULA_FUNCTIONS = [
+    // INFO: Text
+    {
+        name: "CONCATENATE",
+        category: "Text",
+        description: "Joins text values into a single text value.",
+        example: 'CONCATENATE("I", "love", "monday") => Ilovemonday',
+        fn: function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            return handleJoinCapped(handleFlattenArgs(args).map(exports.handleToFormulaText));
+        },
+    },
+    {
+        name: "LEFT",
+        category: "Text",
+        description: "Extracts a given number of characters from the left side.",
+        example: 'LEFT("monday.com", 3) => mon',
+        fn: function (text, count) {
+            if (count === void 0) { count = 1; }
+            return (0, exports.handleToFormulaText)(text).slice(0, (0, exports.handleToFormulaNumber)(count));
+        },
+    },
+    {
+        name: "LEN",
+        category: "Text",
+        description: "Returns the number of characters in a text value.",
+        example: 'LEN("hello") => 5',
+        fn: function (text) { return (0, exports.handleToFormulaText)(text).length; },
+    },
+    {
+        name: "LOWER",
+        category: "Text",
+        description: "Converts text to lowercase.",
+        example: 'LOWER("Some STRING") => some string',
+        fn: function (text) { return (0, exports.handleToFormulaText)(text).toLowerCase(); },
+    },
+    {
+        name: "REPLACE",
+        category: "Text",
+        description: "Replaces part of a text value, from a start position (1-based) for a number of characters.",
+        example: 'REPLACE("Goat", 1, 2, "Fl") => Flat',
+        fn: function (text, start, count, replacement) {
+            var source = (0, exports.handleToFormulaText)(text);
+            var from = Math.max(0, (0, exports.handleToFormulaNumber)(start) - 1);
+            return handleJoinCapped([
+                source.slice(0, from),
+                (0, exports.handleToFormulaText)(replacement),
+                source.slice(from + (0, exports.handleToFormulaNumber)(count)),
+            ]);
+        },
+    },
+    {
+        name: "REPT",
+        category: "Text",
+        description: "Repeats text a given number of times.",
+        example: 'REPT("monday", 3) => mondaymondaymonday',
+        fn: function (text, count) {
+            var source = (0, exports.handleToFormulaText)(text);
+            var times = Math.max(0, Math.trunc((0, exports.handleToFormulaNumber)(count)));
+            // INFO: capped at monday's 10K-character formula limit — one cell is
+            // drawn in every row, so an unbounded repeat would freeze the board
+            if (!source || !Number.isFinite(times))
+                return "";
+            return source
+                .repeat(Math.min(times, Math.ceil(exports.FORMULA_MAX_TEXT / source.length)))
+                .slice(0, exports.FORMULA_MAX_TEXT);
+        },
+    },
+    {
+        name: "RIGHT",
+        category: "Text",
+        description: "Extracts a given number of characters from the right side.",
+        example: 'RIGHT("monday", 3) => day',
+        fn: function (text, count) {
+            if (count === void 0) { count = 1; }
+            var source = (0, exports.handleToFormulaText)(text);
+            var size = (0, exports.handleToFormulaNumber)(count);
+            return size <= 0 ? "" : source.slice(-size);
+        },
+    },
+    {
+        name: "SEARCH",
+        category: "Text",
+        description: "Finds text within other text and returns its position (1-based), or 0 when not found.",
+        example: 'IF(SEARCH("love", "I love monday") > 0, "Exist", "Not") => Exist',
+        fn: function (find, within, start) {
+            if (start === void 0) { start = 1; }
+            return (0, exports.handleToFormulaText)(within)
+                .toLowerCase()
+                .indexOf((0, exports.handleToFormulaText)(find).toLowerCase(), Math.max(0, (0, exports.handleToFormulaNumber)(start) - 1)) + 1;
+        },
+    },
+    {
+        name: "SUBSTITUTE",
+        category: "Text",
+        description: "Replaces every match of a text with new text.",
+        example: 'SUBSTITUTE("goodmorning", "morning", "night") => goodnight',
+        fn: function (text, search, replacement) {
+            var needle = (0, exports.handleToFormulaText)(search);
+            if (!needle)
+                return (0, exports.handleToFormulaText)(text);
+            var pieces = (0, exports.handleToFormulaText)(text).split(needle);
+            var glue = (0, exports.handleToFormulaText)(replacement);
+            // INFO: interleaved and joined with the cap, so 10K matches of a 10K
+            // replacement never build the 100M-character string first
+            var parts = [];
+            pieces.forEach(function (each, index) {
+                if (index > 0)
+                    parts.push(glue);
+                parts.push(each);
+            });
+            return handleJoinCapped(parts);
+        },
+    },
+    {
+        name: "TEXT",
+        category: "Text",
+        description: "Formats a number using a text format.",
+        example: 'TEXT(8500.6, "$#,##0.00") => $8,500.60',
+        fn: function (value, pattern) {
+            return handleFormatNumberPattern(value, (0, exports.handleToFormulaText)(pattern));
+        },
+    },
+    {
+        name: "TRIM",
+        category: "Text",
+        description: "Removes extra spaces, keeping single spaces between words.",
+        example: 'TRIM(" I love  MDY ") => I love MDY',
+        fn: function (text) { return (0, exports.handleToFormulaText)(text).trim().replace(/\s+/g, " "); },
+    },
+    {
+        name: "UPPER",
+        category: "Text",
+        description: "Converts text to uppercase.",
+        example: 'UPPER("monday.com") => MONDAY.COM',
+        fn: function (text) { return (0, exports.handleToFormulaText)(text).toUpperCase(); },
+    },
+    // INFO: Logical
+    {
+        name: "AND",
+        category: "Logical",
+        description: "Returns true when every condition is true.",
+        example: "AND(3 > 1, 4 > 2) => true",
+        fn: function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            return args.length > 0 && args.every(Boolean);
+        },
+    },
+    {
+        name: "EXACT",
+        category: "Logical",
+        description: "Returns true when two values are exactly the same.",
+        example: "EXACT({Status}, {Status}) => true",
+        fn: function (a, b) { return (0, exports.handleToFormulaText)(a) === (0, exports.handleToFormulaText)(b); },
+    },
+    {
+        name: "IF",
+        category: "Logical",
+        description: "Checks a condition. Returns the first value when it is met, otherwise the second.",
+        example: 'IF({Budget} > 100, "Big Deal", "Small Deal")',
+        fn: function (condition, yes, no) {
+            if (no === void 0) { no = ""; }
+            return (condition ? yes : no);
+        },
+    },
+    {
+        name: "OR",
+        category: "Logical",
+        description: "Returns true when any condition is true.",
+        example: "OR(3 > 10, 4 > 2) => true",
+        fn: function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            return args.some(Boolean);
+        },
+    },
+    {
+        name: "XOR",
+        category: "Logical",
+        description: "Returns true when an odd number of conditions are true.",
+        example: "XOR(3 > 0, 2 > 9) => true",
+        fn: function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            return args.filter(Boolean).length % 2 === 1;
+        },
+    },
+    {
+        name: "NOT",
+        category: "Logical",
+        description: "Reverses a condition.",
+        example: "NOT(3 > 5) => true",
+        fn: function (value) { return !value; },
+    },
+    {
+        name: "SWITCH",
+        category: "Logical",
+        description: "Compares a value against pairs of value and result, returning the matching result or the default.",
+        example: 'SWITCH({Priority}, "High", 3, "Medium", 2, "Low", 1, 0) => 2',
+        fn: function (value) {
+            var cases = [];
+            for (var _i = 1; _i < arguments.length; _i++) {
+                cases[_i - 1] = arguments[_i];
+            }
+            for (var i = 0; i + 1 < cases.length; i += 2) {
+                if ((0, exports.handleToFormulaText)(value) === (0, exports.handleToFormulaText)(cases[i]))
+                    return cases[i + 1];
+            }
+            return cases.length % 2 === 1 ? cases[cases.length - 1] : "";
+        },
+    },
+    // INFO: Numeric
+    {
+        name: "ABS",
+        category: "Numeric",
+        description: "Returns the absolute value of a number.",
+        example: "ABS(-1) => 1",
+        fn: function (value) { return Math.abs((0, exports.handleToFormulaNumber)(value)); },
+    },
+    {
+        name: "AVERAGE",
+        category: "Numeric",
+        description: "Returns the average of the given numbers.",
+        example: "AVERAGE(1, 2, 3) => 2",
+        fn: function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            var values = handleFlattenArgs(args).map(exports.handleToFormulaNumber);
+            return values.length
+                ? values.reduce(function (a, b) { return a + b; }, 0) / values.length
+                : 0;
+        },
+    },
+    {
+        name: "COUNT",
+        category: "Numeric",
+        description: "Counts how many of the given values are numbers.",
+        example: 'COUNT(1, 2, "a") => 2',
+        fn: function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            return handleFlattenArgs(args).filter(function (each) {
+                return each !== "" &&
+                    typeof each !== "boolean" &&
+                    Number.isFinite(Number(each));
+            }).length;
+        },
+    },
+    {
+        name: "DIVIDE",
+        category: "Numeric",
+        description: "Divides one number by another.",
+        example: "DIVIDE(10, 5) => 2",
+        fn: function (a, b) { return (0, exports.handleToFormulaNumber)(a) / (0, exports.handleToFormulaNumber)(b); },
+    },
+    {
+        name: "LOG",
+        category: "Numeric",
+        description: "Returns the logarithm of a number in a base (default 10).",
+        example: "LOG(16, 2) => 4",
+        fn: function (value, base) {
+            if (base === void 0) { base = 10; }
+            return Math.log((0, exports.handleToFormulaNumber)(value)) /
+                Math.log((0, exports.handleToFormulaNumber)(base));
+        },
+    },
+    {
+        name: "MAX",
+        category: "Numeric",
+        description: "Returns the largest of the given numbers.",
+        example: "MAX(1, 3, 5, 9) => 9",
+        fn: function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            return Math.max.apply(Math, handleFlattenArgs(args).map(exports.handleToFormulaNumber));
+        },
+    },
+    {
+        name: "MIN",
+        category: "Numeric",
+        description: "Returns the smallest of the given numbers.",
+        example: "MIN(1, 3, 5, 9) => 1",
+        fn: function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            return Math.min.apply(Math, handleFlattenArgs(args).map(exports.handleToFormulaNumber));
+        },
+    },
+    {
+        name: "MINUS",
+        category: "Numeric",
+        description: "Subtracts the second number from the first.",
+        example: "MINUS(5, 3) => 2",
+        fn: function (a, b) { return (0, exports.handleToFormulaNumber)(a) - (0, exports.handleToFormulaNumber)(b); },
+    },
+    {
+        name: "MOD",
+        category: "Numeric",
+        description: "Returns the remainder of a division.",
+        example: "MOD(10, 3) => 1",
+        fn: function (a, b) { return (0, exports.handleToFormulaNumber)(a) % (0, exports.handleToFormulaNumber)(b); },
+    },
+    {
+        name: "MULTIPLY",
+        category: "Numeric",
+        description: "Multiplies the given numbers.",
+        example: "MULTIPLY(5, 2) => 10",
+        fn: function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            return handleFlattenArgs(args)
+                .map(exports.handleToFormulaNumber)
+                .reduce(function (a, b) { return a * b; }, 1);
+        },
+    },
+    {
+        name: "POWER",
+        category: "Numeric",
+        description: "Raises a number to a power.",
+        example: "POWER(2, 3) => 8",
+        fn: function (a, b) { return Math.pow((0, exports.handleToFormulaNumber)(a), (0, exports.handleToFormulaNumber)(b)); },
+    },
+    {
+        name: "ROUND",
+        category: "Numeric",
+        description: "Rounds a number to a number of digits.",
+        example: "ROUND(1.123456, 2) => 1.12",
+        fn: function (value, digits) {
+            if (digits === void 0) { digits = 0; }
+            return handleRoundTo((0, exports.handleToFormulaNumber)(value), (0, exports.handleToFormulaNumber)(digits));
+        },
+    },
+    {
+        name: "ROUNDUP",
+        category: "Numeric",
+        description: "Always rounds a number up, away from zero.",
+        example: "ROUNDUP(1.1, 0) => 2",
+        fn: function (value, digits) {
+            if (digits === void 0) { digits = 0; }
+            var factor = Math.pow(10, (0, exports.handleToFormulaNumber)(digits));
+            var numberValue = (0, exports.handleToFormulaNumber)(value);
+            return ((Math.sign(numberValue) * Math.ceil(Math.abs(numberValue) * factor)) /
+                factor);
+        },
+    },
+    {
+        name: "ROUNDDOWN",
+        category: "Numeric",
+        description: "Always rounds a number down, towards zero.",
+        example: "ROUNDDOWN(1.9, 0) => 1",
+        fn: function (value, digits) {
+            if (digits === void 0) { digits = 0; }
+            var factor = Math.pow(10, (0, exports.handleToFormulaNumber)(digits));
+            var numberValue = (0, exports.handleToFormulaNumber)(value);
+            return ((Math.sign(numberValue) * Math.floor(Math.abs(numberValue) * factor)) /
+                factor);
+        },
+    },
+    {
+        name: "SQRT",
+        category: "Numeric",
+        description: "Returns the square root of a positive number.",
+        example: "SQRT(9) => 3",
+        fn: function (value) { return Math.sqrt((0, exports.handleToFormulaNumber)(value)); },
+    },
+    {
+        name: "SUM",
+        category: "Numeric",
+        description: "Adds up the given numbers.",
+        example: "SUM(2, 3, 8) => 13",
+        fn: function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            return handleFlattenArgs(args)
+                .map(exports.handleToFormulaNumber)
+                .reduce(function (a, b) { return a + b; }, 0);
+        },
+    },
+    // INFO: Date
+    {
+        name: "ADD_DAYS",
+        category: "Date",
+        description: "Adds days to a date and returns the new date.",
+        example: 'ADD_DAYS("2019-01-20", 5) => 2019-01-25',
+        fn: function (date, days) {
+            var parsed = handleToFormulaDate(date);
+            return parsed
+                ? handleFormatFormulaDate(parsed.add((0, exports.handleToFormulaNumber)(days), "day"))
+                : "";
+        },
+    },
+    {
+        name: "DATE",
+        category: "Date",
+        description: "Builds a date from a year, month and day.",
+        example: "DATE(2018, 5, 30) => 2018-05-30",
+        fn: function (year, month, day) {
+            return handleFormatFormulaDate(dayjs(new Date((0, exports.handleToFormulaNumber)(year), (0, exports.handleToFormulaNumber)(month) - 1, (0, exports.handleToFormulaNumber)(day))));
+        },
+    },
+    {
+        name: "DATEVALUE",
+        category: "Date",
+        description: "Converts text that represents a date into a date.",
+        example: 'DATEVALUE("2025-11-12") => 2025-11-12',
+        fn: function (text) { return handleFormatFormulaDate(handleToFormulaDate(text)); },
+    },
+    {
+        name: "DAY",
+        category: "Date",
+        description: "Returns the day of the month of a date.",
+        example: "DAY({Created At}) => 31",
+        fn: function (date) { var _a, _b; return (_b = (_a = handleToFormulaDate(date)) === null || _a === void 0 ? void 0 : _a.date()) !== null && _b !== void 0 ? _b : ""; },
+    },
+    {
+        name: "DAYS",
+        category: "Date",
+        description: "Returns the number of days between two dates.",
+        example: "DAYS({End Date}, {Start Date}) => 14",
+        fn: function (to, from) {
+            var end = handleToFormulaDate(to);
+            var start = handleToFormulaDate(from);
+            if (!end || !start)
+                return "";
+            return end.startOf("day").diff(start.startOf("day"), "day");
+        },
+    },
+    {
+        name: "FORMAT_DATE",
+        category: "Date",
+        description: 'Formats a date. The default format is "MMM D, YYYY".',
+        example: 'FORMAT_DATE(TODAY(), "YYYY-MM-DD") => 2020-02-16',
+        fn: function (date, pattern) {
+            var _a, _b;
+            if (pattern === void 0) { pattern = "MMM D, YYYY"; }
+            return (_b = (_a = handleToFormulaDate(date)) === null || _a === void 0 ? void 0 : _a.format((0, exports.handleToFormulaText)(pattern))) !== null && _b !== void 0 ? _b : "";
+        },
+    },
+    {
+        name: "HOUR",
+        category: "Date",
+        description: "Returns the hour of a date, from 0 to 23.",
+        example: "HOUR(NOW()) => 23",
+        fn: function (date) { var _a, _b; return (_b = (_a = handleToFormulaDate(date)) === null || _a === void 0 ? void 0 : _a.hour()) !== null && _b !== void 0 ? _b : ""; },
+    },
+    {
+        name: "HOURS_DIFF",
+        category: "Date",
+        description: "Returns the difference between two times as HH:mm.",
+        example: 'HOURS_DIFF("23:00", "20:00") => 03:00',
+        fn: function (to, from) {
+            var diff = handleParseHours(to) - handleParseHours(from);
+            if (isNaN(diff))
+                return "";
+            var sign = diff < 0 ? "-" : "";
+            var absolute = Math.abs(diff);
+            var hours = String(Math.floor(absolute / 60)).padStart(2, "0");
+            var minutes = String(absolute % 60).padStart(2, "0");
+            return "".concat(sign).concat(hours, ":").concat(minutes);
+        },
+    },
+    {
+        name: "ISOWEEKNUM",
+        category: "Date",
+        description: "Returns the ISO week number of a date.",
+        example: "ISOWEEKNUM({Created At}) => 42",
+        fn: function (date) { var _a, _b; return (_b = (_a = handleToFormulaDate(date)) === null || _a === void 0 ? void 0 : _a.isoWeek()) !== null && _b !== void 0 ? _b : ""; },
+    },
+    {
+        name: "MINUTE",
+        category: "Date",
+        description: "Returns the minute of a date, from 0 to 59.",
+        example: "MINUTE(NOW()) => 10",
+        fn: function (date) { var _a, _b; return (_b = (_a = handleToFormulaDate(date)) === null || _a === void 0 ? void 0 : _a.minute()) !== null && _b !== void 0 ? _b : ""; },
+    },
+    {
+        name: "MONTH",
+        category: "Date",
+        description: "Returns the month of a date, from 1 to 12.",
+        example: "MONTH({Created At}) => 7",
+        fn: function (date) {
+            var parsed = handleToFormulaDate(date);
+            return parsed ? parsed.month() + 1 : "";
+        },
+    },
+    {
+        name: "NOW",
+        category: "Date",
+        description: "Returns the current date and time.",
+        example: "NOW() => 2020-02-16 23:10",
+        fn: function () { return dayjs().format("YYYY-MM-DD HH:mm"); },
+    },
+    {
+        name: "SECOND",
+        category: "Date",
+        description: "Returns the second of a date, from 0 to 59.",
+        example: "SECOND(NOW()) => 1",
+        fn: function (date) { var _a, _b; return (_b = (_a = handleToFormulaDate(date)) === null || _a === void 0 ? void 0 : _a.second()) !== null && _b !== void 0 ? _b : ""; },
+    },
+    {
+        name: "SUBTRACT_DAYS",
+        category: "Date",
+        description: "Subtracts days from a date and returns the new date.",
+        example: 'SUBTRACT_DAYS("2019-01-20", 5) => 2019-01-15',
+        fn: function (date, days) {
+            var parsed = handleToFormulaDate(date);
+            return parsed
+                ? handleFormatFormulaDate(parsed.subtract((0, exports.handleToFormulaNumber)(days), "day"))
+                : "";
+        },
+    },
+    {
+        name: "SUBTRACT_MINUTES",
+        category: "Date",
+        description: "Subtracts minutes from a date and returns the new date.",
+        example: "SUBTRACT_MINUTES({Date}, 30)",
+        fn: function (date, minutes) {
+            var parsed = handleToFormulaDate(date);
+            return parsed
+                ? parsed
+                    .subtract((0, exports.handleToFormulaNumber)(minutes), "minute")
+                    .format("YYYY-MM-DD HH:mm")
+                : "";
+        },
+    },
+    {
+        name: "TODAY",
+        category: "Date",
+        description: "Returns the current date.",
+        example: "TODAY() => 2018-07-05",
+        fn: function () { return dayjs().format("YYYY-MM-DD"); },
+    },
+    {
+        name: "WEEKNUM",
+        category: "Date",
+        description: "Returns the week number of a date within its year.",
+        example: "WEEKNUM({Created At}) => 42",
+        fn: function (date) { var _a, _b; return (_b = (_a = handleToFormulaDate(date)) === null || _a === void 0 ? void 0 : _a.week()) !== null && _b !== void 0 ? _b : ""; },
+    },
+    {
+        name: "WORKDAY",
+        category: "Date",
+        description: "Adds working days (Monday to Friday) to a date.",
+        example: "WORKDAY({Date}, 20)",
+        fn: handleAddWorkdays,
+    },
+    {
+        name: "WORKDAYS",
+        category: "Date",
+        description: "Returns the number of working days between two dates.",
+        example: "WORKDAYS({To Date}, {From Date}) => 10",
+        fn: handleCountWorkdays,
+    },
+    {
+        name: "YEAR",
+        category: "Date",
+        description: "Returns the year of a date.",
+        example: "YEAR({Created At}) => 2018",
+        fn: function (date) { var _a, _b; return (_b = (_a = handleToFormulaDate(date)) === null || _a === void 0 ? void 0 : _a.year()) !== null && _b !== void 0 ? _b : ""; },
+    },
+    // INFO: Constants
+    {
+        name: "PI",
+        category: "Constants",
+        description: "The value of PI (3.14159).",
+        example: "PI() => 3.14159",
+        constant: true,
+    },
+    {
+        name: "TRUE",
+        category: "Constants",
+        description: "The logical true value.",
+        example: 'IF(3 > 5 = TRUE, "a", "b") => b',
+        constant: true,
+    },
+    {
+        name: "FALSE",
+        category: "Constants",
+        description: "The logical false value.",
+        example: 'IF(3 > 5 = FALSE, "a", "b") => a',
+        constant: true,
+    },
+];
+exports.FORMULA_CONSTANTS = {
+    PI: Math.PI,
+    TRUE: true,
+    FALSE: false,
+};
+exports.FORMULA_FUNCTION_CATEGORIES = [
+    "Text",
+    "Logical",
+    "Numeric",
+    "Date",
+    "Constants",
+];
+//# sourceMappingURL=functions.js.map