@affino/datagrid-formula-engine 0.1.1

package/dist/syntax/analysis.js

@@ -0,0 +1,159 @@
+import { collectFormulaContextKeys, normalizeFormulaFieldName, normalizeFormulaFunctionRegistry, normalizeFormulaText, } from "./functions.js";
+import { normalizeFormulaDiagnostic, } from "./ast.js";
+import { parseFormula } from "./parser.js";
+import { tokenizeFormula } from "./tokenizer.js";
+import { collectFormulaIdentifiers, validateFormulaFunctions, foldFormulaConstants, } from "./optimizer.js";
+import { parseDataGridComputedDependencyToken as parseDependencyToken } from "../contracts.js";
+function dedupeFormulaIdentifiers(root) {
+    const references = [];
+    collectFormulaIdentifiers(root, references);
+    const identifiers = [];
+    const seenIdentifiers = new Set();
+    for (const reference of references) {
+        const normalized = reference.trim();
+        if (normalized.length === 0 || seenIdentifiers.has(normalized)) {
+            continue;
+        }
+        seenIdentifiers.add(normalized);
+        identifiers.push(normalized);
+    }
+    return Object.freeze(identifiers);
+}
+function normalizeFormulaExplainDependency(identifier, token) {
+    const parsedToken = parseDependencyToken(token);
+    if (parsedToken) {
+        return {
+            identifier,
+            token,
+            domain: parsedToken.domain,
+            value: parsedToken.name,
+            ...(parsedToken.rowDomain.kind === "current"
+                ? null
+                : { rowSelector: parsedToken.rowDomain }),
+        };
+    }
+    const normalizedToken = typeof token === "string" ? token.trim() : "";
+    if (normalizedToken.startsWith("field:")) {
+        return { identifier, token, domain: "field", value: normalizedToken.slice("field:".length) };
+    }
+    if (normalizedToken.startsWith("computed:")) {
+        return { identifier, token, domain: "computed", value: normalizedToken.slice("computed:".length) };
+    }
+    if (normalizedToken.startsWith("meta:")) {
+        return { identifier, token, domain: "meta", value: normalizedToken.slice("meta:".length) };
+    }
+    return {
+        identifier,
+        token,
+        domain: "unknown",
+        value: normalizedToken.length > 0 ? normalizedToken : String(token),
+    };
+}
+function createFormulaExplainNode(root) {
+    var _a;
+    if (root.kind === "number") {
+        return { kind: root.kind, label: String(root.value), span: root.span, children: [], value: root.value };
+    }
+    if (root.kind === "literal") {
+        return { kind: root.kind, label: "literal", span: root.span, children: [], value: root.value };
+    }
+    if (root.kind === "identifier") {
+        return {
+            kind: root.kind,
+            label: root.name,
+            span: root.span,
+            children: [],
+            name: root.name,
+            sheetReference: root.sheetReference,
+            referenceName: root.referenceName,
+            rangeReferenceName: (_a = root.rangeReferenceName) !== null && _a !== void 0 ? _a : null,
+            rowSelector: root.rowSelector,
+        };
+    }
+    if (root.kind === "call") {
+        return {
+            kind: root.kind,
+            label: `${root.name}()`,
+            span: root.span,
+            children: root.args.map(createFormulaExplainNode),
+            name: root.name,
+            operator: "CALL",
+        };
+    }
+    if (root.kind === "unary") {
+        return {
+            kind: root.kind,
+            label: root.operator,
+            span: root.span,
+            children: [createFormulaExplainNode(root.value)],
+            operator: root.operator,
+        };
+    }
+    return {
+        kind: root.kind,
+        label: root.operator,
+        span: root.span,
+        children: [createFormulaExplainNode(root.left), createFormulaExplainNode(root.right)],
+        operator: root.operator,
+    };
+}
+function dedupeFormulaContextKeys(root, functionRegistry) {
+    const contextKeys = [];
+    collectFormulaContextKeys(root, functionRegistry, contextKeys);
+    return Object.freeze(Array.from(new Set(contextKeys.map(key => key.trim()).filter(key => key.length > 0))));
+}
+export function parseDataGridFormulaExpression(formula, options = {}) {
+    const normalizedFormula = normalizeFormulaText(formula);
+    const tokens = tokenizeFormula(normalizedFormula, options.referenceParserOptions);
+    const ast = parseFormula(tokens, options.referenceParserOptions);
+    return { formula: normalizedFormula, tokens, ast };
+}
+export function diagnoseDataGridFormulaExpression(formula, options = {}) {
+    const normalizedFormula = normalizeFormulaText(formula);
+    try {
+        const tokens = tokenizeFormula(normalizedFormula, options.referenceParserOptions);
+        const ast = parseFormula(tokens, options.referenceParserOptions);
+        const functionRegistry = normalizeFormulaFunctionRegistry(options.functionRegistry, {
+            onFunctionOverride: options.onFunctionOverride,
+        });
+        validateFormulaFunctions(ast, functionRegistry);
+        return { ok: true, formula: normalizedFormula, diagnostics: [], tokens, ast };
+    }
+    catch (error) {
+        return { ok: false, formula: normalizedFormula, diagnostics: [normalizeFormulaDiagnostic(error)] };
+    }
+}
+export function explainDataGridFormulaExpression(formula, options = {}) {
+    var _a;
+    const normalizedFormula = normalizeFormulaText(formula);
+    const tokens = tokenizeFormula(normalizedFormula, options.referenceParserOptions);
+    const ast = parseFormula(tokens, options.referenceParserOptions);
+    const optimizedAst = foldFormulaConstants(ast);
+    const identifiers = dedupeFormulaIdentifiers(optimizedAst);
+    const functionRegistry = normalizeFormulaFunctionRegistry(options.functionRegistry, {
+        onFunctionOverride: options.onFunctionOverride,
+    });
+    validateFormulaFunctions(optimizedAst, functionRegistry);
+    const resolveDependencyToken = (_a = options.resolveDependencyToken) !== null && _a !== void 0 ? _a : ((identifier) => `field:${identifier}`);
+    const dependencies = identifiers.map(identifier => normalizeFormulaExplainDependency(identifier, resolveDependencyToken(identifier)));
+    return {
+        formula: normalizedFormula,
+        tokens,
+        ast: optimizedAst,
+        identifiers,
+        dependencies,
+        contextKeys: dedupeFormulaContextKeys(optimizedAst, functionRegistry),
+        tree: createFormulaExplainNode(optimizedAst),
+    };
+}
+export function explainDataGridFormulaFieldDefinition(definition, options = {}) {
+    var _a;
+    const name = normalizeFormulaFieldName(definition.name, "Formula name");
+    const field = normalizeFormulaFieldName((_a = definition.field) !== null && _a !== void 0 ? _a : name, "Formula target field");
+    const explained = explainDataGridFormulaExpression(definition.formula, options);
+    return {
+        name,
+        field,
+        ...explained,
+    };
+}

package/dist/syntax/ast.d.ts

@@ -0,0 +1,18 @@
+import type { DataGridFormulaRuntimeError } from "../coreTypes.js";
+import type { DataGridFormulaAstNode, DataGridFormulaDiagnostic, DataGridFormulaSourceSpan } from "./types.js";
+export type { DataGridFormulaSourceSpan, DataGridFormulaOperator, DataGridFormulaToken, DataGridFormulaAstNode, DataGridFormulaDiagnostic, } from "./types.js";
+export type { DataGridFormulaExplainNode } from "../analysis/types.js";
+export declare class DataGridFormulaEvaluationError extends Error {
+    readonly runtimeError: DataGridFormulaRuntimeError;
+    constructor(runtimeError: DataGridFormulaRuntimeError);
+}
+export declare class DataGridFormulaSyntaxError extends Error {
+    readonly span: DataGridFormulaSourceSpan;
+    constructor(message: string, span: DataGridFormulaSourceSpan);
+}
+export declare function createFormulaSourceSpan(start: number, end: number): DataGridFormulaSourceSpan;
+export declare function getFormulaNodeSpan(node: DataGridFormulaAstNode): DataGridFormulaSourceSpan;
+export declare function throwFormulaError(message: string, span?: DataGridFormulaSourceSpan): never;
+export declare function createFormulaDiagnostic(message: string, span: DataGridFormulaSourceSpan): DataGridFormulaDiagnostic;
+export declare function normalizeFormulaDiagnostic(error: unknown): DataGridFormulaDiagnostic;
+//# sourceMappingURL=ast.d.ts.map

package/dist/syntax/ast.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast.d.ts","sourceRoot":"","sources":["../../src/syntax/ast.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,iBAAiB,CAAA;AAClE,OAAO,KAAK,EACV,sBAAsB,EACtB,yBAAyB,EACzB,yBAAyB,EAC1B,MAAM,YAAY,CAAA;AACnB,YAAY,EACV,yBAAyB,EACzB,uBAAuB,EACvB,oBAAoB,EACpB,sBAAsB,EACtB,yBAAyB,GAC1B,MAAM,YAAY,CAAA;AACnB,YAAY,EAAE,0BAA0B,EAAE,MAAM,sBAAsB,CAAA;AAEtE,qBAAa,8BAA+B,SAAQ,KAAK;IACvD,QAAQ,CAAC,YAAY,EAAE,2BAA2B,CAAA;gBAEtC,YAAY,EAAE,2BAA2B;CAKtD;AAED,qBAAa,0BAA2B,SAAQ,KAAK;IACnD,QAAQ,CAAC,IAAI,EAAE,yBAAyB,CAAA;gBAE5B,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,yBAAyB;CAK7D;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,yBAAyB,CAI7F;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,sBAAsB,GAAG,yBAAyB,CAE1F;AAED,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,MAAM,EACf,IAAI,GAAE,yBAAyD,GAC9D,KAAK,CAEP;AAED,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,yBAAyB,GAC9B,yBAAyB,CAM3B;AAED,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,OAAO,GAAG,yBAAyB,CASpF"}

package/dist/syntax/ast.js

@@ -0,0 +1,54 @@
+export class DataGridFormulaEvaluationError extends Error {
+    constructor(runtimeError) {
+        super(runtimeError.message);
+        Object.defineProperty(this, "runtimeError", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = "DataGridFormulaEvaluationError";
+        this.runtimeError = runtimeError;
+    }
+}
+export class DataGridFormulaSyntaxError extends Error {
+    constructor(message, span) {
+        super(message);
+        Object.defineProperty(this, "span", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = "DataGridFormulaSyntaxError";
+        this.span = span;
+    }
+}
+export function createFormulaSourceSpan(start, end) {
+    const normalizedStart = Math.max(0, Math.trunc(start));
+    const normalizedEnd = Math.max(normalizedStart, Math.trunc(end));
+    return { start: normalizedStart, end: normalizedEnd };
+}
+export function getFormulaNodeSpan(node) {
+    return node.span;
+}
+export function throwFormulaError(message, span = createFormulaSourceSpan(0, 0)) {
+    throw new DataGridFormulaSyntaxError(`[DataGridFormula] ${message}`, span);
+}
+export function createFormulaDiagnostic(message, span) {
+    return {
+        severity: "error",
+        message,
+        span,
+    };
+}
+export function normalizeFormulaDiagnostic(error) {
+    if (error instanceof DataGridFormulaSyntaxError) {
+        return createFormulaDiagnostic(error.message, error.span);
+    }
+    if (error instanceof DataGridFormulaEvaluationError) {
+        return createFormulaDiagnostic(error.runtimeError.message, createFormulaSourceSpan(0, 0));
+    }
+    const message = error instanceof Error ? error.message : String(error !== null && error !== void 0 ? error : "Formula diagnostics failed.");
+    return createFormulaDiagnostic(message, createFormulaSourceSpan(0, 0));
+}

package/dist/syntax/core.d.ts

@@ -0,0 +1,4 @@
+export * from "./analysis.js";
+export type { DataGridCompiledFormulaArtifact, DataGridCompiledFormulaBatchContext, DataGridCompiledFormulaBatchExecutionMode, DataGridCompiledFormulaField, DataGridFormulaBatchEvaluator, DataGridFormulaColumnarBatchEvaluator, DataGridFormulaCompileOptions, DataGridFormulaCompileStrategy, DataGridFormulaEvaluator, DataGridFormulaEvaluatorForToken, DataGridFormulaExpressionAnalysis, DataGridFormulaFunctionRuntime, DataGridFormulaParseResult, DataGridFormulaRuntimeErrorPolicy, DataGridFormulaTokenIndexEvaluator, DataGridFormulaTokenValueReader, } from "../runtime/types.js";
+export type { DataGridFormulaDiagnosticsResult, DataGridFormulaExplainDependency, DataGridFormulaExplainDependencyDomain, DataGridFormulaExplainNode, DataGridFormulaExplainResult, DataGridFormulaFieldExplainResult, } from "../analysis/types.js";
+//# sourceMappingURL=core.d.ts.map

package/dist/syntax/core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../../src/syntax/core.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAA;AAE7B,YAAY,EACX,+BAA+B,EAC/B,mCAAmC,EACnC,yCAAyC,EACzC,4BAA4B,EAC5B,6BAA6B,EAC7B,qCAAqC,EACrC,6BAA6B,EAC7B,8BAA8B,EAC9B,wBAAwB,EACxB,gCAAgC,EAChC,iCAAiC,EACjC,8BAA8B,EAC9B,0BAA0B,EAC1B,iCAAiC,EACjC,kCAAkC,EAClC,+BAA+B,GAC/B,MAAM,qBAAqB,CAAA;AAE5B,YAAY,EACX,gCAAgC,EAChC,gCAAgC,EAChC,sCAAsC,EACtC,0BAA0B,EAC1B,4BAA4B,EAC5B,iCAAiC,GACjC,MAAM,sBAAsB,CAAA"}

package/dist/syntax/core.js

@@ -0,0 +1 @@
+export * from "./analysis.js";

package/dist/syntax/functionGroups/advancedFunctions.d.ts

@@ -0,0 +1,2 @@
+export declare const DATAGRID_ADVANCED_FORMULA_FUNCTIONS: Readonly<Record<string, import("../types.js").DataGridFormulaFunctionDefinition>>;
+//# sourceMappingURL=advancedFunctions.d.ts.map

package/dist/syntax/functionGroups/advancedFunctions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"advancedFunctions.d.ts","sourceRoot":"","sources":["../../../src/syntax/functionGroups/advancedFunctions.ts"],"names":[],"mappings":"AAkEA,eAAO,MAAM,mCAAmC,mFAgN9C,CAAA"}

package/dist/syntax/functionGroups/advancedFunctions.js

@@ -0,0 +1,252 @@
+import { areFormulaValuesEqual, coerceFormulaValueToNumber, compareFormulaValues, } from "../values.js";
+import { collectFilteredValues, collectFormulaTableRelatedValues, collectFormulaTableValues, collectValuesFromArgs, computeAverage, createFormulaTableContextKey, defineFormulaFunctions, expandFormulaValue, formulaValueMatchesCriterion, normalizeFormulaTableName, resolveFormulaLiteralText, stringifyFormulaScalarValue, toDistinctFormulaValues, toNumericFormulaValues, } from "../functionHelpers.js";
+function resolveFormulaRelationAggregateMethod(value) {
+    var _a;
+    if (Array.isArray(value)) {
+        return resolveFormulaRelationAggregateMethod((_a = value[0]) !== null && _a !== void 0 ? _a : "");
+    }
+    return String(value !== null && value !== void 0 ? value : "").trim().toLowerCase();
+}
+function computeFormulaRelationRollupValue(values, methodValue, emptyValue) {
+    var _a, _b, _c;
+    const method = resolveFormulaRelationAggregateMethod(methodValue);
+    switch (method) {
+        case "count":
+            return values.length;
+        case "sum":
+            return toNumericFormulaValues(values).reduce((sum, value) => sum + value, 0);
+        case "avg":
+        case "average":
+            return computeAverage(values);
+        case "min":
+            if (values.length === 0) {
+                return emptyValue !== null && emptyValue !== void 0 ? emptyValue : 0;
+            }
+            return (_a = [...values].sort((left, right) => compareFormulaValues(left, right))[0]) !== null && _a !== void 0 ? _a : (emptyValue !== null && emptyValue !== void 0 ? emptyValue : 0);
+        case "max":
+            if (values.length === 0) {
+                return emptyValue !== null && emptyValue !== void 0 ? emptyValue : 0;
+            }
+            return (_b = [...values].sort((left, right) => compareFormulaValues(right, left))[0]) !== null && _b !== void 0 ? _b : (emptyValue !== null && emptyValue !== void 0 ? emptyValue : 0);
+        case "join":
+            return values
+                .map(value => stringifyFormulaScalarValue(value))
+                .filter(value => value.length > 0)
+                .join(", ");
+        case "first":
+        default:
+            return (_c = values[0]) !== null && _c !== void 0 ? _c : (emptyValue !== null && emptyValue !== void 0 ? emptyValue : null);
+    }
+}
+export const DATAGRID_ADVANCED_FORMULA_FUNCTIONS = defineFormulaFunctions({
+    ARRAY: {
+        compute: args => Object.freeze([...collectValuesFromArgs(args)]),
+    },
+    AVERAGEIF: {
+        arity: { min: 2, max: 3 },
+        compute: args => {
+            var _a, _b, _c, _d;
+            const criteriaRange = expandFormulaValue((_a = args[0]) !== null && _a !== void 0 ? _a : null);
+            const criterion = (_b = args[1]) !== null && _b !== void 0 ? _b : null;
+            const averageRange = expandFormulaValue((_d = (_c = args[2]) !== null && _c !== void 0 ? _c : args[0]) !== null && _d !== void 0 ? _d : null);
+            return computeAverage(collectFilteredValues(averageRange, [{ range: criteriaRange, criterion }]));
+        },
+    },
+    CHOOSE: {
+        arity: { min: 2 },
+        compute: args => {
+            var _a, _b;
+            const index = Math.trunc(coerceFormulaValueToNumber((_a = args[0]) !== null && _a !== void 0 ? _a : null));
+            if (index < 1 || index >= args.length) {
+                return 0;
+            }
+            return (_b = args[index]) !== null && _b !== void 0 ? _b : 0;
+        },
+    },
+    COLLECT: {
+        arity: { min: 3 },
+        compute: args => {
+            var _a, _b, _c;
+            const values = expandFormulaValue((_a = args[0]) !== null && _a !== void 0 ? _a : null);
+            const criteria = [];
+            for (let index = 1; index < args.length; index += 2) {
+                criteria.push({
+                    range: expandFormulaValue((_b = args[index]) !== null && _b !== void 0 ? _b : null),
+                    criterion: ((_c = args[index + 1]) !== null && _c !== void 0 ? _c : null),
+                });
+            }
+            return Object.freeze([...collectFilteredValues(values, criteria)]);
+        },
+    },
+    COUNTIFS: {
+        arity: { min: 2 },
+        compute: args => {
+            var _a, _b, _c;
+            const firstRange = expandFormulaValue((_a = args[0]) !== null && _a !== void 0 ? _a : null);
+            const criteria = [];
+            for (let index = 0; index < args.length; index += 2) {
+                criteria.push({
+                    range: expandFormulaValue((_b = args[index]) !== null && _b !== void 0 ? _b : null),
+                    criterion: ((_c = args[index + 1]) !== null && _c !== void 0 ? _c : null),
+                });
+            }
+            return collectFilteredValues(firstRange, criteria).length;
+        },
+    },
+    DISTINCT: {
+        arity: 1,
+        compute: args => { var _a; return toDistinctFormulaValues(expandFormulaValue((_a = args[0]) !== null && _a !== void 0 ? _a : null)); },
+    },
+    INDEX: {
+        arity: { min: 2, max: 3 },
+        compute: args => {
+            var _a, _b, _c, _d, _e;
+            const source = expandFormulaValue((_a = args[0]) !== null && _a !== void 0 ? _a : null);
+            const index = Math.trunc(coerceFormulaValueToNumber((_b = args[1]) !== null && _b !== void 0 ? _b : null));
+            if (index < 1 || index > source.length) {
+                return (_c = args[2]) !== null && _c !== void 0 ? _c : 0;
+            }
+            return (_d = source[index - 1]) !== null && _d !== void 0 ? _d : ((_e = args[2]) !== null && _e !== void 0 ? _e : 0);
+        },
+    },
+    MATCH: {
+        arity: { min: 2, max: 3 },
+        compute: args => {
+            var _a, _b, _c, _d;
+            const needle = (_a = args[0]) !== null && _a !== void 0 ? _a : null;
+            const haystack = expandFormulaValue((_b = args[1]) !== null && _b !== void 0 ? _b : null);
+            const matchMode = Math.trunc(coerceFormulaValueToNumber((_c = args[2]) !== null && _c !== void 0 ? _c : 0));
+            if (matchMode !== 0) {
+                return 0;
+            }
+            for (let index = 0; index < haystack.length; index += 1) {
+                if (areFormulaValuesEqual(needle, (_d = haystack[index]) !== null && _d !== void 0 ? _d : null)) {
+                    return index + 1;
+                }
+            }
+            return 0;
+        },
+    },
+    RANGE: {
+        compute: args => Object.freeze([...collectValuesFromArgs(args)]),
+    },
+    SUMIF: {
+        arity: { min: 2, max: 3 },
+        compute: args => {
+            var _a, _b, _c, _d;
+            const criteriaRange = expandFormulaValue((_a = args[0]) !== null && _a !== void 0 ? _a : null);
+            const criterion = (_b = args[1]) !== null && _b !== void 0 ? _b : null;
+            const sumRange = expandFormulaValue((_d = (_c = args[2]) !== null && _c !== void 0 ? _c : args[0]) !== null && _d !== void 0 ? _d : null);
+            return toNumericFormulaValues(collectFilteredValues(sumRange, [{ range: criteriaRange, criterion }]))
+                .reduce((sum, value) => sum + value, 0);
+        },
+    },
+    SUMIFS: {
+        arity: { min: 3 },
+        compute: args => {
+            var _a, _b, _c;
+            const sumRange = expandFormulaValue((_a = args[0]) !== null && _a !== void 0 ? _a : null);
+            const criteria = [];
+            for (let index = 1; index < args.length; index += 2) {
+                criteria.push({
+                    range: expandFormulaValue((_b = args[index]) !== null && _b !== void 0 ? _b : null),
+                    criterion: ((_c = args[index + 1]) !== null && _c !== void 0 ? _c : null),
+                });
+            }
+            return toNumericFormulaValues(collectFilteredValues(sumRange, criteria))
+                .reduce((sum, value) => sum + value, 0);
+        },
+    },
+    TABLE: {
+        arity: { min: 1, max: 2 },
+        requiresRuntimeContext: true,
+        resolveContextKeys: (args) => {
+            const literalTableName = resolveFormulaLiteralText(args[0]);
+            return [literalTableName ? createFormulaTableContextKey(literalTableName) : "tables"];
+        },
+        compute: (args, context) => {
+            var _a, _b;
+            const tableName = normalizeFormulaTableName((_a = args[0]) !== null && _a !== void 0 ? _a : null);
+            if (tableName.length === 0) {
+                return Object.freeze([]);
+            }
+            return collectFormulaTableValues((_b = context === null || context === void 0 ? void 0 : context.getContextValue) === null || _b === void 0 ? void 0 : _b.call(context, createFormulaTableContextKey(tableName)), args[1]);
+        },
+    },
+    RELATED: {
+        arity: { min: 4, max: 5 },
+        requiresRuntimeContext: true,
+        resolveContextKeys: (args) => {
+            const literalTableName = resolveFormulaLiteralText(args[0]);
+            return [literalTableName ? createFormulaTableContextKey(literalTableName) : "tables"];
+        },
+        compute: (args, context) => {
+            var _a, _b, _c, _d, _e, _f;
+            const tableName = normalizeFormulaTableName((_a = args[0]) !== null && _a !== void 0 ? _a : null);
+            if (tableName.length === 0) {
+                return (_b = args[4]) !== null && _b !== void 0 ? _b : null;
+            }
+            const values = collectFormulaTableRelatedValues((_c = context === null || context === void 0 ? void 0 : context.getContextValue) === null || _c === void 0 ? void 0 : _c.call(context, createFormulaTableContextKey(tableName)), args[2], (_d = args[1]) !== null && _d !== void 0 ? _d : null, args[3]);
+            return (_e = values[0]) !== null && _e !== void 0 ? _e : ((_f = args[4]) !== null && _f !== void 0 ? _f : null);
+        },
+    },
+    ROLLUP: {
+        arity: { min: 5, max: 6 },
+        requiresRuntimeContext: true,
+        resolveContextKeys: (args) => {
+            const literalTableName = resolveFormulaLiteralText(args[0]);
+            return [literalTableName ? createFormulaTableContextKey(literalTableName) : "tables"];
+        },
+        compute: (args, context) => {
+            var _a, _b, _c, _d, _e;
+            const tableName = normalizeFormulaTableName((_a = args[0]) !== null && _a !== void 0 ? _a : null);
+            if (tableName.length === 0) {
+                return (_b = args[5]) !== null && _b !== void 0 ? _b : 0;
+            }
+            const values = collectFormulaTableRelatedValues((_c = context === null || context === void 0 ? void 0 : context.getContextValue) === null || _c === void 0 ? void 0 : _c.call(context, createFormulaTableContextKey(tableName)), args[1], (_d = args[2]) !== null && _d !== void 0 ? _d : null, args[3]);
+            return computeFormulaRelationRollupValue(values, (_e = args[4]) !== null && _e !== void 0 ? _e : "first", args[5]);
+        },
+    },
+    XLOOKUP: {
+        arity: { min: 3, max: 5 },
+        compute: args => {
+            var _a, _b, _c, _d, _e, _f, _g;
+            const needle = (_a = args[0]) !== null && _a !== void 0 ? _a : null;
+            const lookupValues = expandFormulaValue((_b = args[1]) !== null && _b !== void 0 ? _b : null);
+            const returnValues = expandFormulaValue((_c = args[2]) !== null && _c !== void 0 ? _c : null);
+            const notFound = (_d = args[3]) !== null && _d !== void 0 ? _d : 0;
+            const matchMode = Math.trunc(coerceFormulaValueToNumber((_e = args[4]) !== null && _e !== void 0 ? _e : 0));
+            if (matchMode !== 0) {
+                return notFound;
+            }
+            for (let index = 0; index < lookupValues.length; index += 1) {
+                if (areFormulaValuesEqual(needle, (_f = lookupValues[index]) !== null && _f !== void 0 ? _f : null)) {
+                    return (_g = returnValues[index]) !== null && _g !== void 0 ? _g : notFound;
+                }
+            }
+            return notFound;
+        },
+    },
+    COUNTIF: {
+        arity: 2,
+        compute: args => {
+            var _a;
+            return expandFormulaValue((_a = args[0]) !== null && _a !== void 0 ? _a : null)
+                .filter(value => { var _a; return formulaValueMatchesCriterion(value, (_a = args[1]) !== null && _a !== void 0 ? _a : null); }).length;
+        },
+    },
+    VLOOKUP: {
+        arity: { min: 3, max: 4 },
+        compute: args => {
+            var _a, _b, _c, _d, _e;
+            const needle = (_a = args[0]) !== null && _a !== void 0 ? _a : null;
+            const lookupValues = expandFormulaValue((_b = args[1]) !== null && _b !== void 0 ? _b : null);
+            const columnNumber = Math.trunc(coerceFormulaValueToNumber((_c = args[2]) !== null && _c !== void 0 ? _c : null));
+            const exact = Math.trunc(coerceFormulaValueToNumber((_d = args[3]) !== null && _d !== void 0 ? _d : 0)) === 0;
+            if (!exact || columnNumber !== 1) {
+                return 0;
+            }
+            return (_e = lookupValues.find(value => areFormulaValuesEqual(value, needle))) !== null && _e !== void 0 ? _e : 0;
+        },
+    },
+});

package/dist/syntax/functionGroups/dateFunctions.d.ts

@@ -0,0 +1,2 @@
+export declare const DATAGRID_DATE_FORMULA_FUNCTIONS: Readonly<Record<string, import("../types.js").DataGridFormulaFunctionDefinition>>;
+//# sourceMappingURL=dateFunctions.d.ts.map

package/dist/syntax/functionGroups/dateFunctions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dateFunctions.d.ts","sourceRoot":"","sources":["../../../src/syntax/functionGroups/dateFunctions.ts"],"names":[],"mappings":"AAwBA,eAAO,MAAM,+BAA+B,mFAwH1C,CAAA"}

package/dist/syntax/functionGroups/dateFunctions.js

@@ -0,0 +1,144 @@
+import { coerceFormulaValueToNumber, } from "../values.js";
+import { addCalendarDays, addWorkingDays, coerceFormulaValueToDate, countDaysBetween, countWorkingDays, defineFormulaFunctions, normalizeHolidayTimes, parseTimeLikeValue, } from "../functionHelpers.js";
+function stripTime(date) {
+    return new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()));
+}
+function resolveWeekNumber(date) {
+    const startOfYear = Date.UTC(date.getUTCFullYear(), 0, 1);
+    const current = Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate());
+    return Math.floor((current - startOfYear) / 86400000 / 7) + 1;
+}
+export const DATAGRID_DATE_FORMULA_FUNCTIONS = defineFormulaFunctions({
+    DATE: {
+        arity: 3,
+        compute: args => {
+            var _a, _b, _c;
+            const year = Math.trunc(coerceFormulaValueToNumber((_a = args[0]) !== null && _a !== void 0 ? _a : null));
+            const month = Math.trunc(coerceFormulaValueToNumber((_b = args[1]) !== null && _b !== void 0 ? _b : null));
+            const day = Math.trunc(coerceFormulaValueToNumber((_c = args[2]) !== null && _c !== void 0 ? _c : null));
+            return new Date(Date.UTC(year, month - 1, day));
+        },
+    },
+    DATEONLY: {
+        arity: 1,
+        compute: args => {
+            var _a;
+            const date = coerceFormulaValueToDate((_a = args[0]) !== null && _a !== void 0 ? _a : null);
+            return date ? stripTime(date) : null;
+        },
+    },
+    DAY: {
+        arity: 1,
+        compute: args => {
+            var _a;
+            const date = coerceFormulaValueToDate((_a = args[0]) !== null && _a !== void 0 ? _a : null);
+            return date ? date.getUTCDate() : 0;
+        },
+    },
+    MONTH: {
+        arity: 1,
+        compute: args => {
+            var _a;
+            const date = coerceFormulaValueToDate((_a = args[0]) !== null && _a !== void 0 ? _a : null);
+            return date ? date.getUTCMonth() + 1 : 0;
+        },
+    },
+    NETDAYS: {
+        arity: 2,
+        compute: args => {
+            var _a, _b;
+            const start = coerceFormulaValueToDate((_a = args[0]) !== null && _a !== void 0 ? _a : null);
+            const end = coerceFormulaValueToDate((_b = args[1]) !== null && _b !== void 0 ? _b : null);
+            if (!start || !end) {
+                return 0;
+            }
+            return countDaysBetween(start, end, false);
+        },
+    },
+    NETWORKDAY: {
+        arity: { min: 2 },
+        compute: args => {
+            var _a, _b;
+            const start = coerceFormulaValueToDate((_a = args[0]) !== null && _a !== void 0 ? _a : null);
+            const end = coerceFormulaValueToDate((_b = args[1]) !== null && _b !== void 0 ? _b : null);
+            if (!start || !end) {
+                return 0;
+            }
+            return countWorkingDays(start, end, normalizeHolidayTimes(args.slice(2)));
+        },
+    },
+    NETWORKDAYS: {
+        arity: { min: 2 },
+        compute: args => {
+            var _a, _b;
+            const start = coerceFormulaValueToDate((_a = args[0]) !== null && _a !== void 0 ? _a : null);
+            const end = coerceFormulaValueToDate((_b = args[1]) !== null && _b !== void 0 ? _b : null);
+            if (!start || !end) {
+                return 0;
+            }
+            return countWorkingDays(start, end, normalizeHolidayTimes(args.slice(2)));
+        },
+    },
+    TIME: {
+        arity: { min: 1, max: 3 },
+        compute: args => { var _a; return parseTimeLikeValue((_a = args[0]) !== null && _a !== void 0 ? _a : null); },
+    },
+    TODAY: {
+        arity: { min: 0, max: 1 },
+        compute: args => {
+            var _a;
+            const now = new Date();
+            const base = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate()));
+            const offset = Math.trunc(coerceFormulaValueToNumber((_a = args[0]) !== null && _a !== void 0 ? _a : 0));
+            return addCalendarDays(base, offset);
+        },
+    },
+    WEEKDAY: {
+        arity: 1,
+        compute: args => {
+            var _a;
+            const date = coerceFormulaValueToDate((_a = args[0]) !== null && _a !== void 0 ? _a : null);
+            return date ? date.getUTCDay() + 1 : 0;
+        },
+    },
+    WEEKNUMBER: {
+        arity: 1,
+        compute: args => {
+            var _a;
+            const date = coerceFormulaValueToDate((_a = args[0]) !== null && _a !== void 0 ? _a : null);
+            return date ? resolveWeekNumber(date) : 0;
+        },
+    },
+    WORKDAY: {
+        arity: { min: 2 },
+        compute: args => {
+            var _a, _b;
+            const date = coerceFormulaValueToDate((_a = args[0]) !== null && _a !== void 0 ? _a : null);
+            if (!date) {
+                return null;
+            }
+            return addWorkingDays(date, coerceFormulaValueToNumber((_b = args[1]) !== null && _b !== void 0 ? _b : 0), normalizeHolidayTimes(args.slice(2)));
+        },
+    },
+    YEAR: {
+        arity: 1,
+        compute: args => {
+            var _a;
+            const date = coerceFormulaValueToDate((_a = args[0]) !== null && _a !== void 0 ? _a : null);
+            return date ? date.getUTCFullYear() : 0;
+        },
+    },
+    YEARDAY: {
+        arity: 1,
+        compute: args => {
+            var _a;
+            const date = coerceFormulaValueToDate((_a = args[0]) !== null && _a !== void 0 ? _a : null);
+            if (!date) {
+                return 0;
+            }
+            const start = Date.UTC(date.getUTCFullYear(), 0, 1);
+            const current = Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate());
+            return Math.floor((current - start) / 86400000) + 1;
+        },
+    },
+});

package/dist/syntax/functionGroups/logicFunctions.d.ts

@@ -0,0 +1,2 @@
+export declare const DATAGRID_LOGIC_FORMULA_FUNCTIONS: Readonly<Record<string, import("../types.js").DataGridFormulaFunctionDefinition>>;
+//# sourceMappingURL=logicFunctions.d.ts.map

package/dist/syntax/functionGroups/logicFunctions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logicFunctions.d.ts","sourceRoot":"","sources":["../../../src/syntax/functionGroups/logicFunctions.ts"],"names":[],"mappings":"AAgBA,eAAO,MAAM,gCAAgC,mFA4H3C,CAAA"}