@affino/datagrid-formula-engine 0.1.1

package/dist/syntax/functions.js

@@ -0,0 +1,139 @@
+import {} from "./values.js";
+import { throwFormulaError } from "./ast.js";
+import { DATAGRID_ADVANCED_FORMULA_FUNCTIONS } from "./functionGroups/advancedFunctions.js";
+import { DATAGRID_DATE_FORMULA_FUNCTIONS } from "./functionGroups/dateFunctions.js";
+import { DATAGRID_LOGIC_FORMULA_FUNCTIONS } from "./functionGroups/logicFunctions.js";
+import { DATAGRID_NUMERIC_FORMULA_FUNCTIONS } from "./functionGroups/numericFunctions.js";
+import { DATAGRID_TEXT_FORMULA_FUNCTIONS } from "./functionGroups/textFunctions.js";
+export function normalizeFormulaText(value) {
+    if (typeof value !== "string") {
+        throwFormulaError("Formula must be a string.");
+    }
+    const normalized = value.trim();
+    if (normalized.length === 0) {
+        throwFormulaError("Formula must be non-empty.");
+    }
+    return normalized.startsWith("=") ? normalized.slice(1).trim() : normalized;
+}
+export function normalizeFormulaFieldName(value, label) {
+    if (typeof value !== "string") {
+        throwFormulaError(`${label} must be a string.`);
+    }
+    const normalized = value.trim();
+    if (normalized.length === 0) {
+        throwFormulaError(`${label} must be non-empty.`);
+    }
+    return normalized;
+}
+export function normalizeFormulaFunctionName(value) {
+    return value.trim().toUpperCase();
+}
+function normalizeFormulaFunctionArity(arity, functionName) {
+    if (typeof arity === "undefined") {
+        return undefined;
+    }
+    if (typeof arity === "number") {
+        if (!Number.isInteger(arity) || arity < 0) {
+            throwFormulaError(`Function '${functionName}' has invalid arity definition.`);
+        }
+        return arity;
+    }
+    const min = Math.trunc(arity.min);
+    const max = typeof arity.max === "number" ? Math.trunc(arity.max) : undefined;
+    if (!Number.isFinite(min) || min < 0) {
+        throwFormulaError(`Function '${functionName}' has invalid minimum arity.`);
+    }
+    if (typeof max === "number") {
+        if (!Number.isFinite(max) || max < min) {
+            throwFormulaError(`Function '${functionName}' has invalid maximum arity.`);
+        }
+        return { min, max };
+    }
+    return { min };
+}
+function normalizeFormulaContextKeys(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    const normalized = [];
+    const seen = new Set();
+    for (const entry of value) {
+        if (typeof entry !== "string") {
+            continue;
+        }
+        const nextValue = entry.trim();
+        if (nextValue.length === 0 || seen.has(nextValue)) {
+            continue;
+        }
+        seen.add(nextValue);
+        normalized.push(nextValue);
+    }
+    return normalized;
+}
+export function normalizeFormulaFunctionRegistry(input, options = {}) {
+    const normalized = new Map();
+    const registerEntry = (key, definition, source) => {
+        var _a;
+        const normalizedName = normalizeFormulaFunctionName(key);
+        if (normalizedName.length === 0) {
+            throwFormulaError("Function name must be non-empty.");
+        }
+        const runtimeDefinition = typeof definition === "function"
+            ? { compute: definition }
+            : definition;
+        if (typeof runtimeDefinition.compute !== "function") {
+            throwFormulaError(`Function '${normalizedName}' must provide a compute implementation.`);
+        }
+        if (source === "user" && normalized.has(normalizedName)) {
+            (_a = options.onFunctionOverride) === null || _a === void 0 ? void 0 : _a.call(options, normalizedName);
+        }
+        normalized.set(normalizedName, {
+            name: normalizedName,
+            arity: normalizeFormulaFunctionArity(runtimeDefinition.arity, normalizedName),
+            contextKeys: normalizeFormulaContextKeys(runtimeDefinition.contextKeys),
+            resolveContextKeys: typeof runtimeDefinition.resolveContextKeys === "function"
+                ? runtimeDefinition.resolveContextKeys
+                : undefined,
+            requiresRuntimeContext: runtimeDefinition.requiresRuntimeContext === true,
+            compute: runtimeDefinition.compute,
+        });
+    };
+    for (const [key, definition] of Object.entries(DATAGRID_DEFAULT_FORMULA_FUNCTIONS)) {
+        registerEntry(key, definition, "default");
+    }
+    for (const [key, definition] of Object.entries(input !== null && input !== void 0 ? input : {})) {
+        registerEntry(key, definition, "user");
+    }
+    return normalized;
+}
+export function collectFormulaContextKeys(root, functionRegistry, output) {
+    if (root.kind === "call") {
+        const functionName = normalizeFormulaFunctionName(root.name);
+        const functionDefinition = functionRegistry.get(functionName);
+        if (functionDefinition) {
+            output.push(...functionDefinition.contextKeys);
+            if (typeof functionDefinition.resolveContextKeys === "function") {
+                output.push(...functionDefinition.resolveContextKeys(root.args));
+            }
+        }
+        for (const arg of root.args) {
+            collectFormulaContextKeys(arg, functionRegistry, output);
+        }
+        return;
+    }
+    if (root.kind === "unary") {
+        collectFormulaContextKeys(root.value, functionRegistry, output);
+        return;
+    }
+    if (root.kind === "binary") {
+        collectFormulaContextKeys(root.left, functionRegistry, output);
+        collectFormulaContextKeys(root.right, functionRegistry, output);
+    }
+}
+export const DATAGRID_DEFAULT_FORMULA_FUNCTIONS = {
+    ...DATAGRID_NUMERIC_FORMULA_FUNCTIONS,
+    ...DATAGRID_LOGIC_FORMULA_FUNCTIONS,
+    ...DATAGRID_TEXT_FORMULA_FUNCTIONS,
+    ...DATAGRID_DATE_FORMULA_FUNCTIONS,
+    ...DATAGRID_ADVANCED_FORMULA_FUNCTIONS,
+};

package/dist/syntax/index.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/syntax/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA;AAC1B,cAAc,UAAU,CAAA;AACxB,cAAc,aAAa,CAAA;AAC3B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,aAAa,CAAA;AAC3B,cAAc,gBAAgB,CAAA;AAE9B,YAAY,EACV,6BAA6B,EAC7B,8BAA8B,EAC9B,4BAA4B,EAC5B,iCAAiC,EACjC,+BAA+B,EAC/B,mCAAmC,EACnC,yCAAyC,EACzC,8BAA8B,EAC9B,+BAA+B,EAC/B,gCAAgC,EAChC,wBAAwB,EACxB,kCAAkC,EAClC,6BAA6B,EAC7B,qCAAqC,EACrC,0BAA0B,GAC3B,MAAM,qBAAqB,CAAA;AAC5B,YAAY,EACV,gCAAgC,EAChC,sCAAsC,EACtC,gCAAgC,EAChC,0BAA0B,EAC1B,4BAA4B,EAC5B,iCAAiC,GAClC,MAAM,sBAAsB,CAAA"}

package/dist/syntax/index.js

@@ -0,0 +1,7 @@
+export * from "./types.js";
+export * from "./ast.js";
+export * from "./values.js";
+export * from "./functions.js";
+export * from "./tokenizer.js";
+export * from "./parser.js";
+export * from "./optimizer.js";

package/dist/syntax/legacy.d.ts

@@ -0,0 +1,29 @@
+import type { DataGridFormulaRuntimeError } from "../coreTypes.js";
+import type { DataGridFormulaDiagnosticsResult, DataGridFormulaExplainResult, DataGridFormulaFieldExplainResult } from "../analysis/types.js";
+export type { DataGridFormulaDiagnosticsResult, DataGridFormulaExplainDependency, DataGridFormulaExplainDependencyDomain, DataGridFormulaExplainNode, DataGridFormulaExplainResult, DataGridFormulaFieldExplainResult, } from "../analysis/types.js";
+import type { DataGridFormulaCompileOptions, DataGridFormulaParseResult } from "../runtime/types.js";
+export type { DataGridCompiledFormulaArtifact, DataGridCompiledFormulaBatchContext, DataGridCompiledFormulaBatchExecutionMode, DataGridCompiledFormulaField, DataGridFormulaBatchEvaluator, DataGridFormulaColumnarBatchEvaluator, DataGridFormulaCompileOptions, DataGridFormulaCompileStrategy, DataGridFormulaEvaluator, DataGridFormulaEvaluatorForToken, DataGridFormulaExpressionAnalysis, DataGridFormulaFunctionRuntime, DataGridFormulaParseResult, DataGridFormulaRuntimeErrorPolicy, DataGridFormulaTokenIndexEvaluator, DataGridFormulaTokenValueReader, } from "../runtime/types.js";
+import type { DataGridFormulaAstNode, DataGridFormulaDiagnostic, DataGridFormulaSourceSpan } from "./types.js";
+export type { DataGridFormulaAstNode, DataGridFormulaDiagnostic, DataGridFormulaFunctionArity, DataGridFormulaFunctionDefinition, DataGridFormulaFunctionRegistry, DataGridFormulaOperator, DataGridFormulaReferenceSegment, DataGridFormulaSourceSpan, DataGridFormulaToken, } from "./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;
+export declare function parseDataGridFormulaExpression(formula: string): DataGridFormulaParseResult;
+export declare function diagnoseDataGridFormulaExpression(formula: string, options?: Pick<DataGridFormulaCompileOptions, "functionRegistry" | "onFunctionOverride">): DataGridFormulaDiagnosticsResult;
+export declare function explainDataGridFormulaExpression(formula: string, options?: Pick<DataGridFormulaCompileOptions, "resolveDependencyToken" | "functionRegistry" | "onFunctionOverride">): DataGridFormulaExplainResult;
+export declare function explainDataGridFormulaFieldDefinition(definition: {
+    name: string;
+    field?: string;
+    formula: string;
+}, options?: Pick<DataGridFormulaCompileOptions, "resolveDependencyToken" | "functionRegistry" | "onFunctionOverride">): DataGridFormulaFieldExplainResult;
+//# sourceMappingURL=legacy.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"legacy.d.ts","sourceRoot":"","sources":["../../src/syntax/legacy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAIV,2BAA2B,EAE5B,MAAM,iBAAiB,CAAA;AACxB,OAAO,KAAK,EACV,gCAAgC,EAIhC,4BAA4B,EAC5B,iCAAiC,EAClC,MAAM,sBAAsB,CAAA;AAC7B,YAAY,EACV,gCAAgC,EAChC,gCAAgC,EAChC,sCAAsC,EACtC,0BAA0B,EAC1B,4BAA4B,EAC5B,iCAAiC,GAClC,MAAM,sBAAsB,CAAA;AAC7B,OAAO,KAAK,EAOV,6BAA6B,EAM7B,0BAA0B,EAI3B,MAAM,qBAAqB,CAAA;AAC5B,YAAY,EACV,+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,GAChC,MAAM,qBAAqB,CAAA;AAO5B,OAAO,KAAK,EACV,sBAAsB,EACtB,yBAAyB,EAMzB,yBAAyB,EAE1B,MAAM,YAAY,CAAA;AACnB,YAAY,EACV,sBAAsB,EACtB,yBAAyB,EACzB,4BAA4B,EAC5B,iCAAiC,EACjC,+BAA+B,EAC/B,uBAAuB,EACvB,+BAA+B,EAC/B,yBAAyB,EACzB,oBAAoB,GACrB,MAAM,YAAY,CAAA;AASnB,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;AAuFD,wBAAgB,8BAA8B,CAAC,OAAO,EAAE,MAAM,GAAG,0BAA0B,CAK1F;AAED,wBAAgB,iCAAiC,CAC/C,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,IAAI,CAAC,6BAA6B,EAAE,kBAAkB,GAAG,oBAAoB,CAAM,GAC3F,gCAAgC,CAalC;AAED,wBAAgB,gCAAgC,CAC9C,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,IAAI,CAAC,6BAA6B,EAAE,wBAAwB,GAAG,kBAAkB,GAAG,oBAAoB,CAAM,GACtH,4BAA4B,CAyB9B;AAED,wBAAgB,qCAAqC,CACnD,UAAU,EAAE;IACV,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,MAAM,CAAA;CAChB,EACD,OAAO,GAAE,IAAI,CAAC,6BAA6B,EAAE,wBAAwB,GAAG,kBAAkB,GAAG,oBAAoB,CAAM,GACtH,iCAAiC,CASnC"}

package/dist/syntax/legacy.js

@@ -0,0 +1,188 @@
+import { collectFormulaContextKeys, normalizeFormulaFieldName, normalizeFormulaFunctionRegistry, normalizeFormulaText, } from "./functions.js";
+import { parseFormula } from "./parser.js";
+import { tokenizeFormula } from "./tokenizer.js";
+import { collectFormulaIdentifiers, validateFormulaFunctions, foldFormulaConstants, } from "./optimizer.js";
+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));
+}
+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 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) {
+    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 };
+    }
+    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) {
+    const normalizedFormula = normalizeFormulaText(formula);
+    const tokens = tokenizeFormula(normalizedFormula);
+    const ast = parseFormula(tokens);
+    return { formula: normalizedFormula, tokens, ast };
+}
+export function diagnoseDataGridFormulaExpression(formula, options = {}) {
+    const normalizedFormula = normalizeFormulaText(formula);
+    try {
+        const tokens = tokenizeFormula(normalizedFormula);
+        const ast = parseFormula(tokens);
+        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);
+    const ast = parseFormula(tokens);
+    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/optimizer.d.ts

@@ -0,0 +1,6 @@
+import type { DataGridFormulaAstNode } from "./ast.js";
+import type { DataGridFormulaFunctionRuntime } from "./functions.js";
+export declare function collectFormulaIdentifiers(root: DataGridFormulaAstNode, output: string[]): void;
+export declare function validateFormulaFunctions(root: DataGridFormulaAstNode, functionRegistry: ReadonlyMap<string, DataGridFormulaFunctionRuntime>): void;
+export declare function foldFormulaConstants(root: DataGridFormulaAstNode): DataGridFormulaAstNode;
+//# sourceMappingURL=optimizer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"optimizer.d.ts","sourceRoot":"","sources":["../../src/syntax/optimizer.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,sBAAsB,EAEvB,MAAM,UAAU,CAAA;AACjB,OAAO,KAAK,EACV,8BAA8B,EAC/B,MAAM,gBAAgB,CAAA;AA+CvB,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,sBAAsB,EAC5B,MAAM,EAAE,MAAM,EAAE,GACf,IAAI,CAmBN;AAED,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,sBAAsB,EAC5B,gBAAgB,EAAE,WAAW,CAAC,MAAM,EAAE,8BAA8B,CAAC,GACpE,IAAI,CA2BN;AA0ED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,sBAAsB,GAAG,sBAAsB,CAwRzF"}