@affino/datagrid-formula-engine 0.1.1

package/dist/evaluators/interpreter.js

@@ -0,0 +1,156 @@
+import { DataGridFormulaEvaluationError } from "../syntax/ast.js";
+import { normalizeFormulaFunctionName } from "../syntax/functions.js";
+import { areFormulaValuesEqual, coerceFormulaValueToNumber, compareFormulaValues, createFormulaRuntimeError, findFormulaErrorValue, formulaNumberIsTruthy, isFormulaErrorValue, isFormulaValuePresent, normalizeFormulaValue, } from "../syntax/values.js";
+import { ZERO_FORMULA_NODE } from "./shared.js";
+function compileFormulaAstEvaluatorForToken(root, functionRegistry, resolveIdentifierToken, getFunctionContext) {
+    var _a, _b, _c;
+    const compileChild = (node) => {
+        return compileFormulaAstEvaluatorForToken(node, functionRegistry, resolveIdentifierToken, getFunctionContext);
+    };
+    if (root.kind === "number")
+        return () => root.value;
+    if (root.kind === "literal")
+        return () => root.value;
+    if (root.kind === "identifier") {
+        const token = resolveIdentifierToken(root.name);
+        if (typeof token === "undefined")
+            return () => 0;
+        return readTokenValue => normalizeFormulaValue(readTokenValue(token));
+    }
+    if (root.kind === "call") {
+        const normalizedFunctionName = normalizeFormulaFunctionName(root.name);
+        const functionDefinition = functionRegistry.get(normalizedFunctionName);
+        if (!functionDefinition) {
+            throw new DataGridFormulaEvaluationError(createFormulaRuntimeError("FUNCTION_UNKNOWN", `Unknown function '${root.name}'.`, { functionName: normalizedFunctionName }));
+        }
+        if (normalizedFunctionName === "IF") {
+            const conditionEvaluator = compileChild((_a = root.args[0]) !== null && _a !== void 0 ? _a : ZERO_FORMULA_NODE);
+            const trueEvaluator = compileChild((_b = root.args[1]) !== null && _b !== void 0 ? _b : ZERO_FORMULA_NODE);
+            const falseEvaluator = compileChild((_c = root.args[2]) !== null && _c !== void 0 ? _c : ZERO_FORMULA_NODE);
+            return (readTokenValue) => {
+                const conditionValue = conditionEvaluator(readTokenValue);
+                if (isFormulaErrorValue(conditionValue))
+                    return conditionValue;
+                return formulaNumberIsTruthy(conditionValue) ? trueEvaluator(readTokenValue) : falseEvaluator(readTokenValue);
+            };
+        }
+        if (normalizedFunctionName === "IFS") {
+            const pairEvaluators = root.args.map(arg => compileChild(arg));
+            return (readTokenValue) => {
+                for (let index = 0; index < pairEvaluators.length; index += 2) {
+                    const conditionEvaluator = pairEvaluators[index];
+                    const valueEvaluator = pairEvaluators[index + 1];
+                    const conditionValue = conditionEvaluator ? conditionEvaluator(readTokenValue) : 0;
+                    if (isFormulaErrorValue(conditionValue))
+                        return conditionValue;
+                    if (!formulaNumberIsTruthy(conditionValue))
+                        continue;
+                    return valueEvaluator ? valueEvaluator(readTokenValue) : 0;
+                }
+                return 0;
+            };
+        }
+        if (normalizedFunctionName === "COALESCE") {
+            const argEvaluators = root.args.map(arg => compileChild(arg));
+            return (readTokenValue) => {
+                for (const evaluator of argEvaluators) {
+                    const value = evaluator(readTokenValue);
+                    if (isFormulaValuePresent(value))
+                        return value;
+                }
+                return 0;
+            };
+        }
+        const argEvaluators = root.args.map(arg => compileChild(arg));
+        return (readTokenValue) => {
+            const args = new Array(argEvaluators.length);
+            for (let index = 0; index < argEvaluators.length; index += 1) {
+                const evaluator = argEvaluators[index];
+                args[index] = evaluator ? evaluator(readTokenValue) : null;
+            }
+            const formulaError = findFormulaErrorValue(args);
+            if (formulaError)
+                return formulaError;
+            try {
+                return normalizeFormulaValue(functionDefinition.compute(args, getFunctionContext === null || getFunctionContext === void 0 ? void 0 : getFunctionContext()));
+            }
+            catch (error) {
+                throw new DataGridFormulaEvaluationError(createFormulaRuntimeError("EVAL_ERROR", error instanceof Error ? error.message : String(error !== null && error !== void 0 ? error : "Function evaluation failed."), { functionName: functionDefinition.name }));
+            }
+        };
+    }
+    if (root.kind === "unary") {
+        const valueEvaluator = compileChild(root.value);
+        return readTokenValue => {
+            const value = valueEvaluator(readTokenValue);
+            if (isFormulaErrorValue(value))
+                return value;
+            if (root.operator === "-")
+                return -coerceFormulaValueToNumber(value);
+            if (root.operator === "+")
+                return coerceFormulaValueToNumber(value);
+            return formulaNumberIsTruthy(value) ? 0 : 1;
+        };
+    }
+    const leftEvaluator = compileChild(root.left);
+    const rightEvaluator = compileChild(root.right);
+    if (root.operator === "AND") {
+        return (readTokenValue) => {
+            const left = leftEvaluator(readTokenValue);
+            if (isFormulaErrorValue(left))
+                return left;
+            if (!formulaNumberIsTruthy(left))
+                return 0;
+            const right = rightEvaluator(readTokenValue);
+            if (isFormulaErrorValue(right))
+                return right;
+            return formulaNumberIsTruthy(right) ? 1 : 0;
+        };
+    }
+    if (root.operator === "OR") {
+        return (readTokenValue) => {
+            const left = leftEvaluator(readTokenValue);
+            if (isFormulaErrorValue(left))
+                return left;
+            if (formulaNumberIsTruthy(left))
+                return 1;
+            const right = rightEvaluator(readTokenValue);
+            if (isFormulaErrorValue(right))
+                return right;
+            return formulaNumberIsTruthy(right) ? 1 : 0;
+        };
+    }
+    if (root.operator === "+")
+        return readTokenValue => coerceFormulaValueToNumber(leftEvaluator(readTokenValue)) + coerceFormulaValueToNumber(rightEvaluator(readTokenValue));
+    if (root.operator === "-")
+        return readTokenValue => coerceFormulaValueToNumber(leftEvaluator(readTokenValue)) - coerceFormulaValueToNumber(rightEvaluator(readTokenValue));
+    if (root.operator === "*")
+        return readTokenValue => coerceFormulaValueToNumber(leftEvaluator(readTokenValue)) * coerceFormulaValueToNumber(rightEvaluator(readTokenValue));
+    if (root.operator === "/") {
+        return (readTokenValue) => {
+            const right = coerceFormulaValueToNumber(rightEvaluator(readTokenValue));
+            if (right === 0) {
+                throw new DataGridFormulaEvaluationError(createFormulaRuntimeError("DIV_ZERO", "Division by zero.", { operator: "/" }));
+            }
+            const left = coerceFormulaValueToNumber(leftEvaluator(readTokenValue));
+            return left / right;
+        };
+    }
+    if (root.operator === ">")
+        return readTokenValue => (compareFormulaValues(leftEvaluator(readTokenValue), rightEvaluator(readTokenValue)) > 0 ? 1 : 0);
+    if (root.operator === "<")
+        return readTokenValue => (compareFormulaValues(leftEvaluator(readTokenValue), rightEvaluator(readTokenValue)) < 0 ? 1 : 0);
+    if (root.operator === ">=")
+        return readTokenValue => (compareFormulaValues(leftEvaluator(readTokenValue), rightEvaluator(readTokenValue)) >= 0 ? 1 : 0);
+    if (root.operator === "<=")
+        return readTokenValue => (compareFormulaValues(leftEvaluator(readTokenValue), rightEvaluator(readTokenValue)) <= 0 ? 1 : 0);
+    if (root.operator === "==")
+        return readTokenValue => (areFormulaValuesEqual(leftEvaluator(readTokenValue), rightEvaluator(readTokenValue)) ? 1 : 0);
+    return readTokenValue => (areFormulaValuesEqual(leftEvaluator(readTokenValue), rightEvaluator(readTokenValue)) ? 0 : 1);
+}
+export function compileFormulaAstEvaluator(root, functionRegistry, resolveIdentifierToken, getFunctionContext) {
+    return compileFormulaAstEvaluatorForToken(root, functionRegistry, resolveIdentifierToken, getFunctionContext);
+}
+export function compileFormulaAstTokenIndexEvaluator(root, functionRegistry, resolveIdentifierTokenIndex) {
+    return compileFormulaAstEvaluatorForToken(root, functionRegistry, resolveIdentifierTokenIndex);
+}

package/dist/evaluators/jit.d.ts

@@ -0,0 +1,7 @@
+import type { DataGridComputedDependencyToken } from "../coreTypes.js";
+import type { DataGridFormulaBatchEvaluator, DataGridFormulaColumnarBatchEvaluator, DataGridFormulaEvaluator, DataGridFormulaFunctionRuntime } from "../runtime/types.js";
+import { type DataGridFormulaAstNode } from "../syntax/ast.js";
+export declare function compileFormulaAstEvaluatorJit(root: DataGridFormulaAstNode, functionRegistry: ReadonlyMap<string, DataGridFormulaFunctionRuntime>, resolveIdentifierTokenIndex: (identifier: string) => number | undefined, dependencyTokens: readonly DataGridComputedDependencyToken[]): DataGridFormulaEvaluator;
+export declare function compileFormulaAstBatchEvaluatorJit(root: DataGridFormulaAstNode, functionRegistry: ReadonlyMap<string, DataGridFormulaFunctionRuntime>, resolveIdentifierTokenIndex: (identifier: string) => number | undefined): DataGridFormulaBatchEvaluator;
+export declare function compileFormulaAstColumnarBatchEvaluatorJit(root: DataGridFormulaAstNode, functionRegistry: ReadonlyMap<string, DataGridFormulaFunctionRuntime>, resolveIdentifierTokenIndex: (identifier: string) => number | undefined): DataGridFormulaColumnarBatchEvaluator;
+//# sourceMappingURL=jit.d.ts.map

package/dist/evaluators/jit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jit.d.ts","sourceRoot":"","sources":["../../src/evaluators/jit.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,iBAAiB,CAAA;AACtE,OAAO,KAAK,EACV,6BAA6B,EAC7B,qCAAqC,EACrC,wBAAwB,EACxB,8BAA8B,EAC/B,MAAM,qBAAqB,CAAA;AAC5B,OAAO,EAAE,KAAK,sBAAsB,EAAE,MAAM,kBAAkB,CAAA;AAwG9D,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,sBAAsB,EAC5B,gBAAgB,EAAE,WAAW,CAAC,MAAM,EAAE,8BAA8B,CAAC,EACrE,2BAA2B,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,EACvE,gBAAgB,EAAE,SAAS,+BAA+B,EAAE,GAC3D,wBAAwB,CAwB1B;AAED,wBAAgB,kCAAkC,CAChD,IAAI,EAAE,sBAAsB,EAC5B,gBAAgB,EAAE,WAAW,CAAC,MAAM,EAAE,8BAA8B,CAAC,EACrE,2BAA2B,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,GACtE,6BAA6B,CA2B/B;AAED,wBAAgB,0CAA0C,CACxD,IAAI,EAAE,sBAAsB,EAC5B,gBAAgB,EAAE,WAAW,CAAC,MAAM,EAAE,8BAA8B,CAAC,EACrE,2BAA2B,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,GACtE,qCAAqC,CA2BvC"}

package/dist/evaluators/jit.js

@@ -0,0 +1,158 @@
+import {} from "../syntax/ast.js";
+import { normalizeFormulaFunctionName } from "../syntax/functions.js";
+import { buildJitReadValueBody, canInlineBuiltinFunction, createFormulaJitRuntimeHelpers, ZERO_FORMULA_NODE, } from "./shared.js";
+function compileFormulaAstToJitExpression(root, options) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    if (root.kind === "number")
+        return Number.isFinite(root.value) ? String(root.value) : "0";
+    if (root.kind === "literal") {
+        if (root.value === null)
+            return "null";
+        if (root.value instanceof Date)
+            return `new Date(${root.value.getTime()})`;
+        if (typeof root.value === "string")
+            return JSON.stringify(root.value);
+        if (typeof root.value === "boolean")
+            return root.value ? "true" : "false";
+        return Number.isFinite(root.value) ? String(root.value) : "0";
+    }
+    if (root.kind === "identifier") {
+        const tokenIndex = options.resolveIdentifierTokenIndex(root.name);
+        if (typeof tokenIndex !== "number")
+            return "null";
+        return `readValue(${tokenIndex})`;
+    }
+    if (root.kind === "call") {
+        const normalizedFunctionName = normalizeFormulaFunctionName(root.name);
+        if (normalizedFunctionName === "IF") {
+            const condition = compileFormulaAstToJitExpression((_a = root.args[0]) !== null && _a !== void 0 ? _a : ZERO_FORMULA_NODE, options);
+            const whenTrue = compileFormulaAstToJitExpression((_b = root.args[1]) !== null && _b !== void 0 ? _b : ZERO_FORMULA_NODE, options);
+            const whenFalse = compileFormulaAstToJitExpression((_c = root.args[2]) !== null && _c !== void 0 ? _c : ZERO_FORMULA_NODE, options);
+            return `(toBoolean(${condition}) ? (${whenTrue}) : (${whenFalse}))`;
+        }
+        if (normalizedFunctionName === "IFS") {
+            const conditions = [];
+            for (let index = 0; index < root.args.length; index += 2) {
+                const conditionExpression = compileFormulaAstToJitExpression((_d = root.args[index]) !== null && _d !== void 0 ? _d : ZERO_FORMULA_NODE, options);
+                const valueExpression = compileFormulaAstToJitExpression((_e = root.args[index + 1]) !== null && _e !== void 0 ? _e : ZERO_FORMULA_NODE, options);
+                conditions.push(`if (toBoolean(${conditionExpression})) { return (${valueExpression}) }`);
+            }
+            return `(() => { ${conditions.join("; ")}; return 0 })()`;
+        }
+        if (normalizedFunctionName === "COALESCE") {
+            const checks = root.args.map((arg, index) => {
+                const expression = compileFormulaAstToJitExpression(arg, options);
+                const variableName = `coalesceValue${index}`;
+                return `const ${variableName} = (${expression}); if (isPresent(${variableName})) { return ${variableName} }`;
+            });
+            return `(() => { ${checks.join("; ")}; return 0 })()`;
+        }
+        if (options.canInlineBuiltin(normalizedFunctionName)) {
+            if (normalizedFunctionName === "ABS") {
+                const valueExpression = compileFormulaAstToJitExpression((_f = root.args[0]) !== null && _f !== void 0 ? _f : ZERO_FORMULA_NODE, options);
+                return `Math.abs(toNumber(${valueExpression}))`;
+            }
+            if (normalizedFunctionName === "ROUND") {
+                const valueExpression = compileFormulaAstToJitExpression((_g = root.args[0]) !== null && _g !== void 0 ? _g : ZERO_FORMULA_NODE, options);
+                const digitsExpression = compileFormulaAstToJitExpression((_h = root.args[1]) !== null && _h !== void 0 ? _h : ZERO_FORMULA_NODE, options);
+                return `round(toNumber(${valueExpression}), toNumber(${digitsExpression}))`;
+            }
+            if (normalizedFunctionName === "MIN") {
+                if (root.args.length === 0)
+                    return "0";
+                const minArgs = root.args.map(arg => `toNumber(${compileFormulaAstToJitExpression(arg, options)})`).join(", ");
+                return `Math.min(${minArgs})`;
+            }
+            if (normalizedFunctionName === "MAX") {
+                if (root.args.length === 0)
+                    return "0";
+                const maxArgs = root.args.map(arg => `toNumber(${compileFormulaAstToJitExpression(arg, options)})`).join(", ");
+                return `Math.max(${maxArgs})`;
+            }
+            if (normalizedFunctionName === "SUM") {
+                if (root.args.length === 0)
+                    return "0";
+                return `(${root.args.map(arg => `toNumber(${compileFormulaAstToJitExpression(arg, options)})`).join(" + ")})`;
+            }
+        }
+        const args = root.args.map(arg => compileFormulaAstToJitExpression(arg, options)).join(", ");
+        return `callFunction(${JSON.stringify(normalizedFunctionName)}, [${args}])`;
+    }
+    if (root.kind === "unary") {
+        const valueExpression = compileFormulaAstToJitExpression(root.value, options);
+        if (root.operator === "-")
+            return `(-toNumber(${valueExpression}))`;
+        if (root.operator === "+")
+            return `(+toNumber(${valueExpression}))`;
+        return `(toBoolean(${valueExpression}) ? 0 : 1)`;
+    }
+    const leftExpression = compileFormulaAstToJitExpression(root.left, options);
+    const rightExpression = compileFormulaAstToJitExpression(root.right, options);
+    if (root.operator === "AND")
+        return `((toBoolean(${leftExpression}) && toBoolean(${rightExpression})) ? 1 : 0)`;
+    if (root.operator === "OR")
+        return `((toBoolean(${leftExpression}) || toBoolean(${rightExpression})) ? 1 : 0)`;
+    if (root.operator === "+")
+        return `(toNumber(${leftExpression}) + toNumber(${rightExpression}))`;
+    if (root.operator === "-")
+        return `(toNumber(${leftExpression}) - toNumber(${rightExpression}))`;
+    if (root.operator === "*")
+        return `(toNumber(${leftExpression}) * toNumber(${rightExpression}))`;
+    if (root.operator === "/")
+        return `divide(toNumber(${leftExpression}), toNumber(${rightExpression}))`;
+    if (root.operator === ">")
+        return `(compare(${leftExpression}, ${rightExpression}) > 0 ? 1 : 0)`;
+    if (root.operator === "<")
+        return `(compare(${leftExpression}, ${rightExpression}) < 0 ? 1 : 0)`;
+    if (root.operator === ">=")
+        return `(compare(${leftExpression}, ${rightExpression}) >= 0 ? 1 : 0)`;
+    if (root.operator === "<=")
+        return `(compare(${leftExpression}, ${rightExpression}) <= 0 ? 1 : 0)`;
+    if (root.operator === "==")
+        return `(equals(${leftExpression}, ${rightExpression}) ? 1 : 0)`;
+    return `(equals(${leftExpression}, ${rightExpression}) ? 0 : 1)`;
+}
+export function compileFormulaAstEvaluatorJit(root, functionRegistry, resolveIdentifierTokenIndex, dependencyTokens) {
+    const expression = compileFormulaAstToJitExpression(root, {
+        resolveIdentifierTokenIndex,
+        canInlineBuiltin: functionName => canInlineBuiltinFunction(functionName, functionRegistry),
+    });
+    const { toNumber, toBoolean, isPresent, compare, equals, callFunction, divide, round } = createFormulaJitRuntimeHelpers(functionRegistry);
+    const createEvaluator = new Function("toNumber", "toBoolean", "isPresent", "compare", "equals", "callFunction", "divide", "round", "dependencyTokens", `return function evaluate(readTokenValue) {
+      ${buildJitReadValueBody("single")}
+      return (${expression})
+    }`);
+    return createEvaluator(toNumber, toBoolean, isPresent, compare, equals, callFunction, divide, round, dependencyTokens);
+}
+export function compileFormulaAstBatchEvaluatorJit(root, functionRegistry, resolveIdentifierTokenIndex) {
+    const expression = compileFormulaAstToJitExpression(root, {
+        resolveIdentifierTokenIndex,
+        canInlineBuiltin: functionName => canInlineBuiltinFunction(functionName, functionRegistry),
+    });
+    const { toNumber, toBoolean, isPresent, compare, equals, callFunction, divide, round } = createFormulaJitRuntimeHelpers(functionRegistry);
+    const createEvaluator = new Function("toNumber", "toBoolean", "isPresent", "compare", "equals", "callFunction", "divide", "round", `return function evaluateBatch(contextsCount, readTokenByIndex) {
+      const output = new Array(contextsCount)
+      for (let contextIndex = 0; contextIndex < contextsCount; contextIndex += 1) {
+        ${buildJitReadValueBody("batch")}
+        output[contextIndex] = (${expression})
+      }
+      return output
+    }`);
+    return createEvaluator(toNumber, toBoolean, isPresent, compare, equals, callFunction, divide, round);
+}
+export function compileFormulaAstColumnarBatchEvaluatorJit(root, functionRegistry, resolveIdentifierTokenIndex) {
+    const expression = compileFormulaAstToJitExpression(root, {
+        resolveIdentifierTokenIndex,
+        canInlineBuiltin: functionName => canInlineBuiltinFunction(functionName, functionRegistry),
+    });
+    const { toNumber, toBoolean, isPresent, compare, equals, callFunction, divide, round } = createFormulaJitRuntimeHelpers(functionRegistry);
+    const createEvaluator = new Function("toNumber", "toBoolean", "isPresent", "compare", "equals", "callFunction", "divide", "round", `return function evaluateColumnarBatch(contextsCount, tokenColumns) {
+      const output = new Array(contextsCount)
+      for (let contextIndex = 0; contextIndex < contextsCount; contextIndex += 1) {
+        ${buildJitReadValueBody("columnar")}
+        output[contextIndex] = (${expression})
+      }
+      return output
+    }`);
+    return createEvaluator(toNumber, toBoolean, isPresent, compare, equals, callFunction, divide, round);
+}

package/dist/evaluators/shared.d.ts

@@ -0,0 +1,36 @@
+import type { DataGridFormulaValue } from "../coreTypes.js";
+import { type DataGridFormulaFunctionRuntime } from "../runtime/types.js";
+import { type DataGridFormulaAstNode, type DataGridFormulaOperator } from "../syntax/ast.js";
+export declare const ZERO_FORMULA_NODE: DataGridFormulaAstNode;
+export declare const NON_INLINEABLE_BUILTIN_FUNCTIONS: Set<string>;
+export type DataGridFormulaFusedColumnKernel = (contextsCount: number, tokenColumns: readonly (readonly unknown[])[]) => DataGridFormulaValue[];
+export type DataGridFormulaVectorColumnKernel = (contextsCount: number, tokenColumns: readonly (readonly unknown[])[]) => DataGridFormulaValue[];
+export declare function createFormulaConstantColumnKernel(value: DataGridFormulaValue): DataGridFormulaVectorColumnKernel;
+export declare function createFormulaIdentifierColumnKernel(tokenIndex: number | undefined): DataGridFormulaVectorColumnKernel;
+export interface DataGridFormulaRowIndexSelection {
+    indexes: readonly number[];
+    count: number;
+}
+export declare function createFormulaArrayFilled(contextsCount: number, value: DataGridFormulaValue): DataGridFormulaValue[];
+export declare function sliceTokenColumnsByIndexes(tokenColumns: readonly (readonly unknown[])[], rowIndexes: readonly number[] | DataGridFormulaRowIndexSelection): unknown[][];
+export declare function evaluateVectorKernelForIndexes(kernel: DataGridFormulaVectorColumnKernel, tokenColumns: readonly (readonly unknown[])[], rowIndexes: readonly number[] | DataGridFormulaRowIndexSelection): DataGridFormulaValue[];
+export declare function createSequentialRowIndexes(contextsCount: number): number[];
+export declare function evaluateFormulaUnaryOperator(operator: "-" | "+" | "NOT", value: DataGridFormulaValue): DataGridFormulaValue;
+export declare function evaluateFormulaBinaryOperator(operator: DataGridFormulaOperator, left: DataGridFormulaValue, right: DataGridFormulaValue): DataGridFormulaValue;
+export declare function createFormulaUnaryColumnKernel(valueKernel: DataGridFormulaVectorColumnKernel, operator: "-" | "+" | "NOT"): DataGridFormulaVectorColumnKernel;
+export declare function createFormulaBinaryColumnKernel(leftKernel: DataGridFormulaVectorColumnKernel, rightKernel: DataGridFormulaVectorColumnKernel, operator: DataGridFormulaOperator): DataGridFormulaVectorColumnKernel;
+export interface DataGridFormulaJitRuntimeHelpers {
+    toNumber: (value: DataGridFormulaValue) => number;
+    toBoolean: (value: DataGridFormulaValue) => boolean;
+    isPresent: (value: DataGridFormulaValue) => boolean;
+    compare: (left: DataGridFormulaValue, right: DataGridFormulaValue) => number;
+    equals: (left: DataGridFormulaValue, right: DataGridFormulaValue) => boolean;
+    callFunction: (functionName: string, args: readonly DataGridFormulaValue[]) => DataGridFormulaValue;
+    divide: (left: number, right: number) => number;
+    round: (value: number, digits: number) => number;
+}
+export type DataGridFormulaJitReadValueMode = "single" | "batch" | "columnar";
+export declare function buildJitReadValueBody(mode: DataGridFormulaJitReadValueMode): string;
+export declare function createFormulaJitRuntimeHelpers(functionRegistry: ReadonlyMap<string, DataGridFormulaFunctionRuntime>): DataGridFormulaJitRuntimeHelpers;
+export declare function canInlineBuiltinFunction(functionName: string, functionRegistry: ReadonlyMap<string, DataGridFormulaFunctionRuntime>): boolean;
+//# sourceMappingURL=shared.d.ts.map

package/dist/evaluators/shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../src/evaluators/shared.ts"],"names":[],"mappings":"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"}

package/dist/evaluators/shared.js

@@ -0,0 +1,242 @@
+import {} from "../runtime/types.js";
+import { DATAGRID_DEFAULT_FORMULA_FUNCTIONS } from "../syntax/functions.js";
+import { DataGridFormulaEvaluationError, createFormulaSourceSpan, } from "../syntax/ast.js";
+import { areFormulaValuesEqual, coerceFormulaValueToBoolean, coerceFormulaValueToNumber, compareFormulaValues, createFormulaRuntimeError, findFormulaErrorValue, formulaNumberIsTruthy, isFormulaErrorValue, isFormulaValuePresent, normalizeFormulaValue, } from "../syntax/values.js";
+export const ZERO_FORMULA_NODE = {
+    kind: "number",
+    value: 0,
+    span: createFormulaSourceSpan(0, 0),
+};
+export const NON_INLINEABLE_BUILTIN_FUNCTIONS = new Set([
+    "ARRAY",
+    "AVG",
+    "CONCAT",
+    "COUNT",
+    "INDEX",
+    "IN",
+    "LEN",
+    "MATCH",
+    "MAX",
+    "MIN",
+    "RANGE",
+    "SUM",
+    "TABLE",
+    "XLOOKUP",
+]);
+export function createFormulaConstantColumnKernel(value) {
+    return (contextsCount) => createFormulaArrayFilled(contextsCount, value);
+}
+export function createFormulaIdentifierColumnKernel(tokenIndex) {
+    if (typeof tokenIndex !== "number") {
+        return (contextsCount) => createFormulaArrayFilled(contextsCount, null);
+    }
+    return (contextsCount, tokenColumns) => {
+        const output = new Array(contextsCount);
+        const column = tokenColumns[tokenIndex];
+        for (let contextIndex = 0; contextIndex < contextsCount; contextIndex += 1) {
+            output[contextIndex] = normalizeFormulaValue(column ? column[contextIndex] : undefined);
+        }
+        return output;
+    };
+}
+function isFormulaRowIndexSelection(rowIndexes) {
+    return !Array.isArray(rowIndexes);
+}
+export function createFormulaArrayFilled(contextsCount, value) {
+    const output = new Array(contextsCount);
+    for (let contextIndex = 0; contextIndex < contextsCount; contextIndex += 1) {
+        output[contextIndex] = value;
+    }
+    return output;
+}
+export function sliceTokenColumnsByIndexes(tokenColumns, rowIndexes) {
+    const indexes = isFormulaRowIndexSelection(rowIndexes) ? rowIndexes.indexes : rowIndexes;
+    const count = isFormulaRowIndexSelection(rowIndexes) ? rowIndexes.count : rowIndexes.length;
+    return tokenColumns.map((column) => {
+        const subset = new Array(count);
+        for (let index = 0; index < count; index += 1) {
+            const rowIndex = indexes[index];
+            subset[index] = typeof rowIndex === "number" ? column === null || column === void 0 ? void 0 : column[rowIndex] : undefined;
+        }
+        return subset;
+    });
+}
+export function evaluateVectorKernelForIndexes(kernel, tokenColumns, rowIndexes) {
+    const count = isFormulaRowIndexSelection(rowIndexes) ? rowIndexes.count : rowIndexes.length;
+    if (count === 0) {
+        return [];
+    }
+    return kernel(count, sliceTokenColumnsByIndexes(tokenColumns, rowIndexes));
+}
+export function createSequentialRowIndexes(contextsCount) {
+    const rowIndexes = new Array(contextsCount);
+    for (let index = 0; index < contextsCount; index += 1) {
+        rowIndexes[index] = index;
+    }
+    return rowIndexes;
+}
+export function evaluateFormulaUnaryOperator(operator, value) {
+    if (isFormulaErrorValue(value)) {
+        return value;
+    }
+    if (operator === "-") {
+        return -coerceFormulaValueToNumber(value);
+    }
+    if (operator === "+") {
+        return coerceFormulaValueToNumber(value);
+    }
+    return formulaNumberIsTruthy(value) ? 0 : 1;
+}
+export function evaluateFormulaBinaryOperator(operator, left, right) {
+    const formulaError = findFormulaErrorValue([left, right]);
+    if (formulaError) {
+        return formulaError;
+    }
+    if (operator === "+") {
+        return coerceFormulaValueToNumber(left) + coerceFormulaValueToNumber(right);
+    }
+    if (operator === "-") {
+        return coerceFormulaValueToNumber(left) - coerceFormulaValueToNumber(right);
+    }
+    if (operator === "*") {
+        return coerceFormulaValueToNumber(left) * coerceFormulaValueToNumber(right);
+    }
+    if (operator === "/") {
+        const divisor = coerceFormulaValueToNumber(right);
+        if (divisor === 0) {
+            throw new DataGridFormulaEvaluationError(createFormulaRuntimeError("DIV_ZERO", "Division by zero.", { operator: "/" }));
+        }
+        return coerceFormulaValueToNumber(left) / divisor;
+    }
+    if (operator === ">") {
+        return compareFormulaValues(left, right) > 0 ? 1 : 0;
+    }
+    if (operator === "<") {
+        return compareFormulaValues(left, right) < 0 ? 1 : 0;
+    }
+    if (operator === ">=") {
+        return compareFormulaValues(left, right) >= 0 ? 1 : 0;
+    }
+    if (operator === "<=") {
+        return compareFormulaValues(left, right) <= 0 ? 1 : 0;
+    }
+    if (operator === "==") {
+        return areFormulaValuesEqual(left, right) ? 1 : 0;
+    }
+    if (operator === "!=") {
+        return areFormulaValuesEqual(left, right) ? 0 : 1;
+    }
+    throw new Error(`Unsupported non-scalar binary operator '${operator}'.`);
+}
+export function createFormulaUnaryColumnKernel(valueKernel, operator) {
+    return (contextsCount, tokenColumns) => {
+        var _a;
+        const values = valueKernel(contextsCount, tokenColumns);
+        const output = new Array(contextsCount);
+        for (let contextIndex = 0; contextIndex < contextsCount; contextIndex += 1) {
+            const value = (_a = values[contextIndex]) !== null && _a !== void 0 ? _a : null;
+            output[contextIndex] = evaluateFormulaUnaryOperator(operator, value);
+        }
+        return output;
+    };
+}
+export function createFormulaBinaryColumnKernel(leftKernel, rightKernel, operator) {
+    return (contextsCount, tokenColumns) => {
+        var _a, _b;
+        const leftValues = leftKernel(contextsCount, tokenColumns);
+        const rightValues = rightKernel(contextsCount, tokenColumns);
+        const output = new Array(contextsCount);
+        for (let contextIndex = 0; contextIndex < contextsCount; contextIndex += 1) {
+            const left = (_a = leftValues[contextIndex]) !== null && _a !== void 0 ? _a : null;
+            const right = (_b = rightValues[contextIndex]) !== null && _b !== void 0 ? _b : null;
+            output[contextIndex] = evaluateFormulaBinaryOperator(operator, left, right);
+        }
+        return output;
+    };
+}
+export function buildJitReadValueBody(mode) {
+    const readRawExpression = mode === "single"
+        ? `const token = dependencyTokens[tokenIndex]\n          const raw = readTokenValue(token)`
+        : mode === "batch"
+            ? `const raw = readTokenByIndex(contextIndex, tokenIndex)`
+            : `const column = tokenColumns[tokenIndex]\n          const raw = column ? column[contextIndex] : undefined`;
+    return `const readValue = (tokenIndex) => {
+          ${readRawExpression}
+          if (raw === null || typeof raw === "undefined") {
+            return null
+          }
+          if (raw instanceof Date) {
+            const rawTime = raw.getTime()
+            return Number.isNaN(rawTime) ? null : raw
+          }
+          const rawType = typeof raw
+          if (rawType === "number") {
+            return Number.isFinite(raw) ? raw : 0
+          }
+          if (rawType === "string" || rawType === "boolean") {
+            return raw
+          }
+          if (rawType === "object" && raw && raw.kind === "error" && typeof raw.code === "string" && typeof raw.message === "string") {
+            return raw
+          }
+          if (rawType === "bigint") {
+            return Number(raw)
+          }
+          return null
+        }`;
+}
+export function createFormulaJitRuntimeHelpers(functionRegistry) {
+    const divide = (left, right) => {
+        if (right === 0) {
+            throw new DataGridFormulaEvaluationError(createFormulaRuntimeError("DIV_ZERO", "Division by zero.", { operator: "/" }));
+        }
+        return left / right;
+    };
+    const callFunction = (functionName, args) => {
+        const functionDefinition = functionRegistry.get(functionName);
+        if (!functionDefinition) {
+            throw new DataGridFormulaEvaluationError(createFormulaRuntimeError("FUNCTION_UNKNOWN", `Unknown function '${functionName}'.`, { functionName }));
+        }
+        try {
+            const formulaError = findFormulaErrorValue(args);
+            if (formulaError) {
+                return formulaError;
+            }
+            return normalizeFormulaValue(functionDefinition.compute(args));
+        }
+        catch (error) {
+            throw new DataGridFormulaEvaluationError(createFormulaRuntimeError("EVAL_ERROR", error instanceof Error ? error.message : String(error !== null && error !== void 0 ? error : "Function evaluation failed."), { functionName: functionDefinition.name }));
+        }
+    };
+    const toNumber = (value) => coerceFormulaValueToNumber(value);
+    const toBoolean = (value) => coerceFormulaValueToBoolean(value);
+    const isPresent = (value) => isFormulaValuePresent(value);
+    const compare = (left, right) => compareFormulaValues(left, right);
+    const equals = (left, right) => areFormulaValuesEqual(left, right);
+    const round = (value, digits) => {
+        const safeDigits = Math.max(0, Math.trunc(digits));
+        const factor = 10 ** safeDigits;
+        return Math.round(value * factor) / factor;
+    };
+    return {
+        toNumber,
+        toBoolean,
+        isPresent,
+        compare,
+        equals,
+        callFunction,
+        divide,
+        round,
+    };
+}
+export function canInlineBuiltinFunction(functionName, functionRegistry) {
+    if (NON_INLINEABLE_BUILTIN_FUNCTIONS.has(functionName)) {
+        return false;
+    }
+    const defaultDefinition = DATAGRID_DEFAULT_FORMULA_FUNCTIONS[functionName];
+    const runtimeDefinition = functionRegistry.get(functionName);
+    if (!defaultDefinition || !runtimeDefinition) {
+        return false;
+    }
+    return runtimeDefinition.compute === defaultDefinition.compute;
+}

package/dist/evaluators/vector.d.ts

@@ -0,0 +1,6 @@
+import type { DataGridFormulaColumnarBatchEvaluator } from "../runtime/types.js";
+import { type DataGridFormulaAstNode } from "../syntax/ast.js";
+import { type DataGridFormulaVectorColumnKernel } from "./shared.js";
+export declare function compileFormulaAstVectorColumnKernel(root: DataGridFormulaAstNode, resolveIdentifierTokenIndex: (identifier: string) => number | undefined): DataGridFormulaVectorColumnKernel | null;
+export declare function compileFormulaAstColumnarBatchEvaluatorVector(root: DataGridFormulaAstNode, resolveIdentifierTokenIndex: (identifier: string) => number | undefined): DataGridFormulaColumnarBatchEvaluator | null;
+//# sourceMappingURL=vector.d.ts.map

package/dist/evaluators/vector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vector.d.ts","sourceRoot":"","sources":["../../src/evaluators/vector.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,qCAAqC,EAAE,MAAM,qBAAqB,CAAA;AAChF,OAAO,EAAE,KAAK,sBAAsB,EAAE,MAAM,kBAAkB,CAAA;AAO9D,OAAO,EAQL,KAAK,iCAAiC,EAEvC,MAAM,aAAa,CAAA;AAapB,wBAAgB,mCAAmC,CACjD,IAAI,EAAE,sBAAsB,EAC5B,2BAA2B,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,GACtE,iCAAiC,GAAG,IAAI,CAsO1C;AAED,wBAAgB,6CAA6C,CAC3D,IAAI,EAAE,sBAAsB,EAC5B,2BAA2B,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,GACtE,qCAAqC,GAAG,IAAI,CAI9C"}