blixify-ui-web 1.2.181 → 1.2.183

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

@@ -0,0 +1,801 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleMatchFormulaQuery = exports.handleCompareFormulaResults = exports.handleIsFormulaEmpty = exports.handleFormatFormulaValue = exports.handleEvaluateFormulaRow = exports.handleEvaluateFormula = exports.handleValidateFormula = exports.handleCompileFormula = exports.handleFormulaToStorage = exports.handleGetFormulaDisplay = exports.handleFormulaToDisplay = exports.handleGetFormulaColumns = exports.handleFindFormulaColumn = exports.handleFormulaEquals = exports.FORMULA_MAX_LENGTH = exports.FORMULA_INCOMPATIBLE_TYPES = void 0;
+var expr_eval_1 = require("expr-eval");
+var functions_1 = require("./functions");
+__exportStar(require("./functions"), exports);
+// INFO: column types a formula can read — monday leaves files, links and
+// locations out of formulas, and so do we
+exports.FORMULA_INCOMPATIBLE_TYPES = [
+    "password",
+    "image",
+    "file",
+    "multipleImage",
+    "multipleFile",
+    "signature",
+    "canvas",
+    "object",
+    "listObject",
+    "address",
+    "listAddress",
+    "ganttchart",
+];
+var LABEL_TYPES = [
+    "reference",
+    "listReference",
+    "referenceSelection",
+    "person",
+    "listPerson",
+    "roles",
+];
+var FUNCTION_NAMES = new Set(functions_1.FORMULA_FUNCTIONS.filter(function (each) { return !each.constant; }).map(function (each) { return each.name; }));
+var CONSTANT_NAMES = new Set(Object.keys(functions_1.FORMULA_CONSTANTS));
+// INFO: null-prototype tables throughout — expr-eval resolves names with
+// `in`, so a plain object would answer for constructor, toString and the rest
+// of Object.prototype
+var handleOwnOnly = function (source, keys) {
+    var table = Object.create(null);
+    (keys !== null && keys !== void 0 ? keys : Object.keys(source)).forEach(function (each) {
+        if (Object.prototype.hasOwnProperty.call(source, each))
+            table[each] = source[each];
+    });
+    return table;
+};
+var HARDENED_OPTIONS = {
+    allowMemberAccess: false,
+    operators: handleOwnOnly({
+        assignment: false,
+        fndef: false,
+        array: false,
+        in: false,
+    }),
+};
+// INFO: the operators a translated formula can contain — everything else the
+// stock parser knows (sqrt, not, length, in, =, [ …) is not there to reach
+var FORMULA_UNARY_OPS = ["-", "+"];
+var FORMULA_BINARY_OPS = [
+    "+",
+    "-",
+    "*",
+    "/",
+    "%",
+    "^",
+    "||",
+    "==",
+    "!=",
+    ">",
+    "<",
+    ">=",
+    "<=",
+];
+// INFO: the longest formula a column can hold — monday's own formula limit
+exports.FORMULA_MAX_LENGTH = 10000;
+// INFO: text a formula can build stops at FORMULA_MAX_TEXT. Every text function
+// stops at it and so does every result, so no formula (or chain of formula
+// columns) can hand every row an unbounded string.
+var handleClampText = function (value) {
+    return typeof value === "string" && value.length > functions_1.FORMULA_MAX_TEXT
+        ? value.slice(0, functions_1.FORMULA_MAX_TEXT)
+        : value;
+};
+var handleCreateParser = function () {
+    var _a;
+    var parser = new expr_eval_1.Parser(HARDENED_OPTIONS);
+    var functions = Object.create(null);
+    functions_1.FORMULA_FUNCTIONS.forEach(function (each) {
+        var fn = each.fn;
+        if (fn)
+            functions[each.name] = function () {
+                var args = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    args[_i] = arguments[_i];
+                }
+                return handleClampText(fn.apply(void 0, args));
+            };
+    });
+    parser.functions = functions;
+    parser.unaryOps = handleOwnOnly(parser.unaryOps, FORMULA_UNARY_OPS);
+    parser.binaryOps = handleOwnOnly(parser.binaryOps, FORMULA_BINARY_OPS);
+    parser.ternaryOps = handleOwnOnly((_a = parser.ternaryOps) !== null && _a !== void 0 ? _a : {}, ["?"]);
+    parser.consts = Object.assign(Object.create(null), functions_1.FORMULA_CONSTANTS, {
+        true: true,
+        false: false,
+    });
+    return parser;
+};
+var formulaParser = handleCreateParser();
+// INFO: a math column a formula reads is worked out exactly as the math column
+// itself is in the table (listModule): the stock parser over the raw fields,
+// 0 for an absent one. Same parser, same values — nothing new is exposed.
+var mathParser = new expr_eval_1.Parser();
+// INFO: monday's = compares a number column with "5" or an empty cell with 0
+// as equal values, where expr-eval's == is ===. Numbers compare as numbers,
+// anything else as text (case-sensitive, as monday documents).
+var handleIsNumberLike = function (value) {
+    return typeof value === "number" ||
+        typeof value === "boolean" ||
+        (typeof value === "string" &&
+            value.trim() !== "" &&
+            Number.isFinite(Number(value)));
+};
+var handleIsEmptyValue = function (value) {
+    return value === "" || value === null || value === undefined;
+};
+var handleFormulaEquals = function (a, b) {
+    if (a === b)
+        return true;
+    if (handleIsEmptyValue(a) && handleIsEmptyValue(b))
+        return true;
+    var aNumeric = typeof a === "number" || typeof a === "boolean";
+    var bNumeric = typeof b === "number" || typeof b === "boolean";
+    // INFO: against a number, an empty cell is 0 and a numeric text is its number
+    if ((aNumeric && (handleIsNumberLike(b) || handleIsEmptyValue(b))) ||
+        (bNumeric && (handleIsNumberLike(a) || handleIsEmptyValue(a))) ||
+        (handleIsNumberLike(a) && handleIsNumberLike(b)))
+        return (Number(handleIsEmptyValue(a) ? 0 : a) ===
+            Number(handleIsEmptyValue(b) ? 0 : b));
+    return (0, functions_1.handleToFormulaText)(a) === (0, functions_1.handleToFormulaText)(b);
+};
+exports.handleFormulaEquals = handleFormulaEquals;
+formulaParser.binaryOps["=="] = exports.handleFormulaEquals;
+formulaParser.binaryOps["!="] = function (a, b) {
+    return !(0, exports.handleFormulaEquals)(a, b);
+};
+//=====================================================================================
+//SECTION: Column references
+//=====================================================================================
+var handleFindFormulaColumn = function (reference, schema) {
+    var _a, _b, _c;
+    var target = reference.trim();
+    var lowered = target.toLowerCase();
+    return ((_c = (_b = (_a = schema.find(function (each) { return each.id === target; })) !== null && _a !== void 0 ? _a : schema.find(function (each) { return each.name === target; })) !== null && _b !== void 0 ? _b : schema.find(function (each) { var _a; return ((_a = each.name) !== null && _a !== void 0 ? _a : "").toLowerCase() === lowered; })) !== null && _c !== void 0 ? _c : schema.find(function (each) { return each.id.toLowerCase() === lowered; }));
+};
+exports.handleFindFormulaColumn = handleFindFormulaColumn;
+// INFO: columns the builder offers — everything a formula can read except the
+// column being edited, which would only ever reference itself
+var handleGetFormulaColumns = function (schema, excludeId) {
+    return schema.filter(function (each) {
+        return each.id !== excludeId &&
+            each.id !== "_id" &&
+            !exports.FORMULA_INCOMPATIBLE_TYPES.includes(each.type);
+    });
+};
+exports.handleGetFormulaColumns = handleGetFormulaColumns;
+var QUOTES = {
+    '"': '"',
+    "'": "'",
+    "\u201C": "\u201D",
+    "\u2018": "\u2019",
+};
+// INFO: walks a formula once, handing string literals and {references} to
+// callbacks and copying everything else — every rewrite below shares it, so
+// none of them can touch the inside of a string by accident
+var handleWalkFormula = function (source, handlers) {
+    var output = "";
+    var text = "";
+    var index = 0;
+    var handleFlushText = function () {
+        if (text)
+            output += handlers.onText(text, index - text.length);
+        text = "";
+    };
+    while (index < source.length) {
+        var char = source[index];
+        if (QUOTES[char]) {
+            handleFlushText();
+            var closers = [QUOTES[char], char === "\u201C" ? '"' : char];
+            var end = index + 1;
+            while (end < source.length && !closers.includes(source[end]))
+                end += 1;
+            if (end >= source.length)
+                throw new Error("Missing a closing quote");
+            output += handlers.onString(source.slice(index + 1, end), char);
+            index = end + 1;
+            continue;
+        }
+        if (char === "{") {
+            handleFlushText();
+            var end = source.indexOf("}", index);
+            if (end < 0)
+                throw new Error("Missing a closing }");
+            output += handlers.onReference(source.slice(index + 1, end));
+            index = end + 1;
+            continue;
+        }
+        text += char;
+        index += 1;
+    }
+    handleFlushText();
+    return output;
+};
+var handleRewriteBraces = function (expression, handleMap) {
+    try {
+        return handleWalkFormula(expression, {
+            onString: function (content, quote) { var _a; return quote + content + ((_a = QUOTES[quote]) !== null && _a !== void 0 ? _a : quote); },
+            onReference: function (reference) { return "{".concat(handleMap(reference), "}"); },
+            onText: function (text) { return text; },
+        });
+    }
+    catch (err) {
+        return expression;
+    }
+};
+/**
+ * Stored → shown: `{budgetAmount}` becomes `{Budget}`.
+ */
+var handleFormulaToDisplay = function (expression, schema) {
+    if (!expression)
+        return "";
+    return handleRewriteBraces(expression, function (reference) {
+        var _a;
+        var column = schema.find(function (each) { return each.id === reference.trim(); });
+        if (!column)
+            return reference;
+        // INFO: a name is shown only when saving it finds this same column again.
+        // A name shared with another column, or equal to another column's id,
+        // would be saved as that other column — it is shown by id instead.
+        var name = (_a = column.name) === null || _a === void 0 ? void 0 : _a.trim();
+        if (name && (0, exports.handleFindFormulaColumn)(name, schema) === column)
+            return name;
+        return column.id;
+    });
+};
+exports.handleFormulaToDisplay = handleFormulaToDisplay;
+// INFO: what the builder opens with for an existing formula column
+var handleGetFormulaDisplay = function (column, schema) { return (0, exports.handleFormulaToDisplay)(column === null || column === void 0 ? void 0 : column.formulaExpression, schema); };
+exports.handleGetFormulaDisplay = handleGetFormulaDisplay;
+/**
+ * Shown → stored: `{Budget}` becomes `{budgetAmount}`, so renaming a column
+ * never breaks the formulas that read it. Unknown names are kept for the
+ * validator to report.
+ */
+var handleFormulaToStorage = function (expression, schema) {
+    return handleRewriteBraces(expression, function (reference) {
+        var column = (0, exports.handleFindFormulaColumn)(reference, schema);
+        return column ? column.id : reference;
+    });
+};
+exports.handleFormulaToStorage = handleFormulaToStorage;
+//=====================================================================================
+//SECTION: Compile
+//=====================================================================================
+var handleTranslateFormula = function (expression, schema) {
+    var variables = Object.create(null);
+    var literals = Object.create(null);
+    var columnVariables = Object.create(null);
+    var source = handleWalkFormula(expression, {
+        // INFO: text is handed to the parser as a variable, never as a quoted
+        // literal — expr-eval's own string rules (backslash escapes) can then
+        // never disagree with the scanner about where a string ends, so no part of
+        // a string can be read as code
+        onString: function (content) {
+            var variable = "__s".concat(Object.keys(literals).length);
+            literals[variable] = content;
+            return " ".concat(variable, " ");
+        },
+        onReference: function (reference) {
+            var column = (0, exports.handleFindFormulaColumn)(reference, schema);
+            if (!column)
+                throw new Error("Unknown column {".concat(reference.trim(), "}"));
+            if (exports.FORMULA_INCOMPATIBLE_TYPES.includes(column.type))
+                throw new Error("{".concat(column.name, "} cannot be used in a formula"));
+            var variable = columnVariables[column.id];
+            if (!variable) {
+                variable = "__c".concat(Object.keys(variables).length);
+                columnVariables[column.id] = variable;
+                variables[variable] = column.id;
+            }
+            return " ".concat(variable, " ");
+        },
+        onText: function (text) {
+            var _a;
+            var output = "";
+            var index = 0;
+            while (index < text.length) {
+                var char = text[index];
+                var next = text[index + 1];
+                if (char === "}")
+                    throw new Error("Unexpected }");
+                if (char === "[" || char === "]" || char === ";")
+                    throw new Error("\"".concat(char, "\" is not supported in a formula"));
+                if (char === "<" && next === ">") {
+                    output += "!=";
+                    index += 2;
+                    continue;
+                }
+                if (char === "=") {
+                    if (next === "=") {
+                        output += "==";
+                        index += 2;
+                        continue;
+                    }
+                    // INFO: monday's = compares; <=, >= and != keep their own =
+                    var previous = text[index - 1];
+                    output +=
+                        previous === "<" || previous === ">" || previous === "!"
+                            ? "="
+                            : "==";
+                    index += 1;
+                    continue;
+                }
+                if (char === "&") {
+                    output += " || ";
+                    index += 1;
+                    continue;
+                }
+                var numberMatch = /^(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?/.exec(text.slice(index));
+                if (numberMatch && !/[A-Za-z0-9_]/.test((_a = text[index - 1]) !== null && _a !== void 0 ? _a : "")) {
+                    output += numberMatch[0];
+                    index += numberMatch[0].length;
+                    continue;
+                }
+                var wordMatch = /^[A-Za-z_][A-Za-z0-9_]*/.exec(text.slice(index));
+                if (wordMatch) {
+                    var word = wordMatch[0];
+                    var upper = word.toUpperCase();
+                    index += word.length;
+                    if (CONSTANT_NAMES.has(upper)) {
+                        output += upper;
+                        // INFO: monday writes PI() and TRUE alike — a constant called
+                        // with no arguments is the constant
+                        var call = /^\s*\(\s*\)/.exec(text.slice(index));
+                        if (call)
+                            index += call[0].length;
+                    }
+                    else if (FUNCTION_NAMES.has(upper)) {
+                        output += upper;
+                    }
+                    else {
+                        throw new Error("Unknown name \"".concat(word, "\" \u2014 wrap column names in { }"));
+                    }
+                    continue;
+                }
+                output += char;
+                index += 1;
+            }
+            return output;
+        },
+    });
+    return { source: source, variables: variables, literals: literals };
+};
+// INFO: operators that bind looser than & in monday/Excel — comparisons and
+// the ternary. & itself sits just above them, below + and -.
+var LOOSER_THAN_CONCAT = ["==", "!=", "<=", ">=", "<", ">", "?", ":"];
+var handleTokenizeTranslated = function (source) {
+    var tokens = [];
+    var index = 0;
+    var text = "";
+    var handleFlush = function () {
+        if (text)
+            tokens.push({ kind: "text", value: text });
+        text = "";
+    };
+    while (index < source.length) {
+        var char = source[index];
+        var pair = source.slice(index, index + 2);
+        if (["||", "==", "!=", "<=", ">="].includes(pair)) {
+            handleFlush();
+            tokens.push({ kind: "op", value: pair });
+            index += 2;
+            continue;
+        }
+        if (["<", ">", "?", ":"].includes(char)) {
+            handleFlush();
+            tokens.push({ kind: "op", value: char });
+            index += 1;
+            continue;
+        }
+        if (char === "(" || char === ")" || char === ",") {
+            handleFlush();
+            tokens.push({
+                kind: char === "(" ? "open" : char === ")" ? "close" : "comma",
+                value: char,
+            });
+            index += 1;
+            continue;
+        }
+        text += char;
+        index += 1;
+    }
+    handleFlush();
+    return tokens;
+};
+var handleNestTokens = function (tokens) {
+    var root = [];
+    var stack = [root];
+    tokens.forEach(function (each) {
+        var current = stack[stack.length - 1];
+        if (each.kind === "open") {
+            var group = { kind: "group", items: [] };
+            current.push(group);
+            stack.push(group.items);
+        }
+        else if (each.kind === "close") {
+            // INFO: an unmatched ) is left for the parser to report
+            if (stack.length > 1)
+                stack.pop();
+            else
+                current.push(each);
+        }
+        else
+            current.push(each);
+    });
+    return root;
+};
+var handleRenderConcatNodes = function (nodes) {
+    var handleRenderNode = function (node) {
+        return node.kind === "group"
+            ? "(".concat(handleRenderConcatNodes(node.items), ")")
+            : node.value;
+    };
+    var handleRenderOperand = function (operand) {
+        var parts = [[]];
+        operand.forEach(function (each) {
+            if (each.kind === "op" && each.value === "||")
+                parts.push([]);
+            else
+                parts[parts.length - 1].push(each);
+        });
+        var rendered = parts.map(function (each) { return each.map(handleRenderNode).join(""); });
+        return parts.length > 1
+            ? " CONCATENATE(".concat(rendered.map(function (each) { return "(".concat(each, ")"); }).join(", "), ") ")
+            : rendered[0];
+    };
+    // INFO: split on commas, then on operators looser than &, so each & chain
+    // is gathered whole and nothing that binds tighter is left outside it
+    var segments = [[]];
+    var separators = [];
+    nodes.forEach(function (each) {
+        if (each.kind === "comma" ||
+            (each.kind === "op" && LOOSER_THAN_CONCAT.includes(each.value))) {
+            separators.push(each.value);
+            segments.push([]);
+        }
+        else
+            segments[segments.length - 1].push(each);
+    });
+    return segments
+        .map(function (each, index) {
+        return handleRenderOperand(each) +
+            (index < separators.length ? " ".concat(separators[index], " ") : "");
+    })
+        .join("");
+};
+/**
+ * INFO: `&` binds looser than + and - in monday, but expr-eval reads its
+ * stand-in `||` at the level of + and -, so `"Total: " & {a} + 1` would
+ * become NaN. Each & chain is rewritten into one CONCATENATE call, which gives
+ * it monday's precedence: below arithmetic, above comparisons.
+ */
+var handleLowerConcatenation = function (source) {
+    if (!handleTokenizeTranslated(source).some(function (each) { return each.value === "||"; }))
+        return source;
+    return handleRenderConcatNodes(handleNestTokens(handleTokenizeTranslated(source)));
+};
+var handleCheckSymbols = function (expression, allowed) {
+    var blocked = expression
+        .symbols()
+        .find(function (eachSymbol) { return !allowed(eachSymbol); });
+    if (blocked)
+        throw new Error("\"".concat(blocked, "\" is not allowed in a formula"));
+};
+var compileCache = new Map();
+var handleCompileFormula = function (expression, schema) {
+    if (!expression || !expression.trim())
+        return { variables: {}, error: "The formula is empty" };
+    if (expression.length > exports.FORMULA_MAX_LENGTH)
+        return {
+            variables: {},
+            error: "A formula can be up to ".concat(exports.FORMULA_MAX_LENGTH, " characters"),
+        };
+    var cacheKey = "".concat(expression, "\0").concat(schema
+        .map(function (each) { return "".concat(each.id, "\u0001").concat(each.name, "\u0001").concat(each.type); })
+        .join("\u0002"));
+    var cached = compileCache.get(cacheKey);
+    if (cached)
+        return cached;
+    var compiled;
+    try {
+        var _a = handleTranslateFormula(expression, schema), source = _a.source, variables_1 = _a.variables, literals_1 = _a.literals;
+        var parsed = formulaParser.parse(handleLowerConcatenation(source));
+        var handleIsOwn_1 = function (table, key) {
+            return Object.prototype.hasOwnProperty.call(table, key);
+        };
+        handleCheckSymbols(parsed, function (symbol) {
+            return FUNCTION_NAMES.has(symbol) ||
+                handleIsOwn_1(variables_1, symbol) ||
+                handleIsOwn_1(literals_1, symbol);
+        });
+        compiled = { expression: parsed, variables: variables_1, literals: literals_1 };
+    }
+    catch (err) {
+        compiled = { variables: {}, error: handleCleanParseError(err === null || err === void 0 ? void 0 : err.message) };
+    }
+    if (compileCache.size > 500)
+        compileCache.clear();
+    compileCache.set(cacheKey, compiled);
+    return compiled;
+};
+exports.handleCompileFormula = handleCompileFormula;
+// INFO: expr-eval reports positions in the translated source, which the user
+// never sees — keep the reason, drop the position
+var handleCleanParseError = function (message) {
+    if (!message)
+        return "Illegal formula";
+    return message.replace(/\s*\[?\s*at position \d+\s*\]?/gi, "").trim();
+};
+var handleValidateFormula = function (expression, schema) { var _a; return (_a = (0, exports.handleCompileFormula)(expression, schema).error) !== null && _a !== void 0 ? _a : ""; };
+exports.handleValidateFormula = handleValidateFormula;
+//=====================================================================================
+//SECTION: Evaluate
+//=====================================================================================
+var handleIsPrimitive = function (value) {
+    return typeof value === "string" ||
+        typeof value === "number" ||
+        typeof value === "boolean";
+};
+var handleResolveDate = function (value, column) {
+    if (value === "" || value === null || value === undefined)
+        return "";
+    var source = typeof value === "object" && !(value instanceof Date) && (value === null || value === void 0 ? void 0 : value._seconds)
+        ? new Date(value._seconds * 1000)
+        : value;
+    var parsed = (0, functions_1.handleToFormulaDate)(source);
+    if (!parsed)
+        return "";
+    if (column.hideShowDate)
+        return parsed.format("HH:mm");
+    if (column.hideShowTime)
+        return parsed.format("YYYY-MM-DD");
+    return (0, functions_1.handleFormatFormulaDate)(parsed);
+};
+var handleResolveListValue = function (value) {
+    if (Array.isArray(value))
+        return value
+            .map(function (each) {
+            var _a, _b;
+            return handleIsPrimitive(each)
+                ? String(each)
+                : ((_b = (_a = each === null || each === void 0 ? void 0 : each.label) !== null && _a !== void 0 ? _a : each === null || each === void 0 ? void 0 : each.name) !== null && _b !== void 0 ? _b : "");
+        })
+            .filter(Boolean)
+            .join(", ");
+    return handleIsPrimitive(value) ? value : "";
+};
+// INFO: the math column's own evaluation, as listModule runs it, returned as
+// a number for the formula reading it
+var handleEvaluateMathColumn = function (column, rawRow) {
+    var _a;
+    try {
+        var expr = mathParser.parse((_a = column.mathExpression) !== null && _a !== void 0 ? _a : "");
+        var variableKeys_1 = {};
+        expr.variables().forEach(function (eachVariable) {
+            var _a;
+            variableKeys_1[eachVariable] = (_a = rawRow === null || rawRow === void 0 ? void 0 : rawRow[eachVariable]) !== null && _a !== void 0 ? _a : 0;
+        });
+        return Number(expr.evaluate(variableKeys_1));
+    }
+    catch (err) {
+        throw new Error("{".concat(column.name || column.id, "} has an error"));
+    }
+};
+var handleResolveColumnValue = function (column, rawRow, displayRow, schema, memo, visiting) {
+    if (column.type === "math")
+        return handleEvaluateMathColumn(column, rawRow);
+    if (column.type === "formula") {
+        var nested = handleEvaluateColumn(column, rawRow, displayRow, schema, memo, visiting);
+        if (nested.error)
+            throw new Error(nested.error);
+        return nested.value;
+    }
+    var raw = rawRow === null || rawRow === void 0 ? void 0 : rawRow[column.id];
+    switch (column.type) {
+        case "number": {
+            if (raw === "" || raw === null || raw === undefined)
+                return "";
+            var numberValue = Number(raw);
+            return Number.isFinite(numberValue) ? numberValue : "";
+        }
+        case "boolean":
+            return raw === true || raw === "true";
+        case "date":
+            return handleResolveDate(raw, column);
+        case "multipleList":
+            return handleResolveListValue(raw);
+        default:
+            break;
+    }
+    // INFO: a reference or person stores an id; the label the table already
+    // resolved is what a formula should compare against, as monday reads labels
+    if (LABEL_TYPES.includes(column.type)) {
+        var shown = displayRow === null || displayRow === void 0 ? void 0 : displayRow[column.id];
+        if (handleIsPrimitive(shown))
+            return shown === " - " ? "" : shown;
+        // INFO: a reference list is shown as an array of labels, " - " standing
+        // in for none — the labels are joined, never the stored ids
+        if (Array.isArray(shown))
+            return handleResolveListValue(shown.filter(function (each) { return each !== " - " && handleIsPrimitive(each); }));
+        return handleResolveListValue(raw);
+    }
+    if (raw === null || raw === undefined)
+        return "";
+    return handleIsPrimitive(raw) ? raw : "";
+};
+var handleEvaluateColumn = function (column, rawRow, displayRow, schema, memo, visiting) {
+    var _a;
+    var memoised = memo.get(column.id);
+    if (memoised)
+        return memoised;
+    if (visiting.has(column.id))
+        return { value: "", error: "Circular reference" };
+    var compiled = (0, exports.handleCompileFormula)(column.formulaExpression, schema);
+    if (compiled.error || !compiled.expression) {
+        var result_1 = { value: "", error: compiled.error };
+        memo.set(column.id, result_1);
+        return result_1;
+    }
+    visiting.add(column.id);
+    var result;
+    try {
+        var values_1 = Object.create(null);
+        Object.entries((_a = compiled.literals) !== null && _a !== void 0 ? _a : {}).forEach(function (_a) {
+            var variable = _a[0], text = _a[1];
+            values_1[variable] = text;
+        });
+        Object.entries(compiled.variables).forEach(function (_a) {
+            var variable = _a[0], columnId = _a[1];
+            var referenced = schema.find(function (each) { return each.id === columnId; });
+            values_1[variable] = referenced
+                ? handleResolveColumnValue(referenced, rawRow, displayRow, schema, memo, visiting)
+                : "";
+        });
+        result = { value: handleClampText(compiled.expression.evaluate(values_1)) };
+        if (typeof result.value === "function" || typeof result.value === "object")
+            result = { value: "", error: "Illegal formula" };
+    }
+    catch (err) {
+        result = { value: "", error: handleCleanParseError(err === null || err === void 0 ? void 0 : err.message) };
+    }
+    visiting.delete(column.id);
+    memo.set(column.id, result);
+    return result;
+};
+/**
+ * Evaluates one formula column for a row. `rawRow` is the stored document;
+ * `displayRow` is the same row as the table shows it, where reference and
+ * person labels are already resolved.
+ */
+var handleEvaluateFormula = function (column, rawRow, displayRow, schema) {
+    return handleEvaluateColumn(column, rawRow, displayRow, schema, new Map(), new Set());
+};
+exports.handleEvaluateFormula = handleEvaluateFormula;
+// INFO: every formula column of a row, sharing one memo so a formula read by
+// several others is worked out once
+var handleEvaluateFormulaRow = function (rawRow, displayRow, schema) {
+    var memo = new Map();
+    var results = {};
+    schema.forEach(function (each) {
+        if (each.type !== "formula")
+            return;
+        results[each.id] = handleEvaluateColumn(each, rawRow, displayRow, schema, memo, new Set());
+    });
+    return results;
+};
+exports.handleEvaluateFormulaRow = handleEvaluateFormulaRow;
+var handleFormatFormulaValue = function (result) {
+    if (result.error)
+        return "Error";
+    var value = result.value;
+    if (value === null || value === undefined)
+        return "";
+    if (typeof value === "number") {
+        if (Number.isNaN(value))
+            return "NaN";
+        if (!Number.isFinite(value))
+            return value > 0 ? "∞" : "-∞";
+        // INFO: shown as computed, to ten places — ROUND and TEXT are how a
+        // formula asks for fewer, and a fixed two would undo ROUND({a}, 4)
+        return value.toLocaleString("en-US", {
+            maximumFractionDigits: 10,
+            useGrouping: false,
+        });
+    }
+    if (typeof value === "boolean")
+        return value ? "true" : "false";
+    return (0, functions_1.handleToFormulaText)(value);
+};
+exports.handleFormatFormulaValue = handleFormatFormulaValue;
+//=====================================================================================
+//SECTION: Sort & filter — monday sorts and filters a formula column on its
+// computed value, so these run on the evaluated rows
+//=====================================================================================
+var handleIsFormulaEmpty = function (result) {
+    return !result ||
+        !!result.error ||
+        result.value === "" ||
+        result.value === null ||
+        result.value === undefined ||
+        (typeof result.value === "number" && Number.isNaN(result.value));
+};
+exports.handleIsFormulaEmpty = handleIsFormulaEmpty;
+var handleAsNumber = function (value) {
+    if (typeof value === "number")
+        return value;
+    if (typeof value === "boolean")
+        return value ? 1 : 0;
+    if (typeof value === "string" && value.trim() !== "") {
+        var numberValue = Number(value);
+        if (Number.isFinite(numberValue))
+            return numberValue;
+    }
+    return undefined;
+};
+var handleSortValue = function (result) { return result.value; };
+// INFO: empty and errored cells are kept for the caller to place last
+var handleCompareFormulaResults = function (a, b) {
+    var aValue = handleSortValue(a);
+    var bValue = handleSortValue(b);
+    var aNumber = handleAsNumber(aValue);
+    var bNumber = handleAsNumber(bValue);
+    if (aNumber !== undefined && bNumber !== undefined)
+        return aNumber - bNumber;
+    return (0, functions_1.handleToFormulaText)(aValue).localeCompare((0, functions_1.handleToFormulaText)(bValue), undefined, { numeric: true, sensitivity: "base" });
+};
+exports.handleCompareFormulaResults = handleCompareFormulaResults;
+var handleCompareToFilter = function (result, filterValue) {
+    var value = handleSortValue(result);
+    var valueNumber = handleAsNumber(value);
+    var filterNumber = handleAsNumber(filterValue);
+    if (valueNumber !== undefined && filterNumber !== undefined)
+        return valueNumber - filterNumber;
+    return (0, functions_1.handleToFormulaText)(value).localeCompare((0, functions_1.handleToFormulaText)(filterValue), undefined, { numeric: true, sensitivity: "base" });
+};
+var handleEqualsFilter = function (result, filterValue) {
+    return handleCompareToFilter(result, filterValue) === 0 ||
+        (0, exports.handleFormatFormulaValue)(result).toLowerCase() ===
+            (0, functions_1.handleToFormulaText)(filterValue).trim().toLowerCase();
+};
+/**
+ * Applies one flex-filter condition (as produced by renderFlexFilterConditions)
+ * to a formula cell.
+ */
+var handleMatchFormulaQuery = function (result, query) {
+    var empty = (0, exports.handleIsFormulaEmpty)(result);
+    switch (query.type) {
+        case "exists":
+            return query.value === false ? empty : !empty;
+        case "=":
+            return !empty && handleEqualsFilter(result, query.value);
+        case "!=":
+            return empty || !handleEqualsFilter(result, query.value);
+        case ">":
+            return !empty && handleCompareToFilter(result, query.value) > 0;
+        case "<":
+            return !empty && handleCompareToFilter(result, query.value) < 0;
+        case "><": {
+            if (empty || !Array.isArray(query.value))
+                return false;
+            var _a = query.value, start = _a[0], end = _a[1];
+            return (handleCompareToFilter(result, start) >= 0 &&
+                handleCompareToFilter(result, end) <= 0);
+        }
+        default:
+            return true;
+    }
+};
+exports.handleMatchFormulaQuery = handleMatchFormulaQuery;
+//# sourceMappingURL=index.js.map