@affino/datagrid-formula-engine 0.1.1

package/dist/graph/executionPlan.js

@@ -0,0 +1,534 @@
+import { parseFormulaReferenceSegments } from "../syntax/tokenizer.js";
+function normalizeName(value, label) {
+    const normalized = value.trim();
+    if (normalized.length === 0) {
+        throw new Error(`[DataGridFormulaExecutionPlan] ${label} must be non-empty.`);
+    }
+    return normalized;
+}
+function normalizeDependency(dependency) {
+    return {
+        domain: dependency.domain,
+        value: normalizeName(dependency.value, "Dependency name"),
+    };
+}
+function splitFieldPathSegments(field) {
+    return parseFormulaReferenceSegments(field)
+        .map(segment => String(segment).trim())
+        .filter(segment => segment.length > 0);
+}
+function collectFieldPathAncestors(field) {
+    const segments = splitFieldPathSegments(field);
+    if (segments.length === 0) {
+        return [];
+    }
+    const ancestors = [];
+    for (let index = 0; index < segments.length; index += 1) {
+        ancestors.push(segments.slice(0, index + 1).join("."));
+    }
+    return ancestors;
+}
+function mergeValueSetIntoMap(target, key, values) {
+    var _a;
+    if (values.size === 0) {
+        return;
+    }
+    const bucket = (_a = target.get(key)) !== null && _a !== void 0 ? _a : new Set();
+    for (const value of values) {
+        bucket.add(value);
+    }
+    target.set(key, bucket);
+}
+function addMapValues(target, source, key) {
+    const values = source.get(key);
+    if (!values || values.size === 0) {
+        return;
+    }
+    for (const value of values) {
+        target.add(value);
+    }
+}
+export function createDataGridFormulaExecutionPlan(input, options = {}) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z;
+    const cyclePolicy = options.cyclePolicy === "iterative"
+        ? "iterative"
+        : "error";
+    const nodeByName = new Map();
+    const nodeIndexByName = new Map();
+    for (const rawNode of input) {
+        const name = normalizeName(rawNode.name, "Node name");
+        const field = normalizeName(rawNode.field, `Field for node '${name}'`);
+        if (nodeByName.has(name)) {
+            throw new Error(`[DataGridFormulaExecutionPlan] Duplicate node '${name}'.`);
+        }
+        const deps = Array.isArray(rawNode.deps)
+            ? rawNode.deps.map(normalizeDependency)
+            : [];
+        nodeByName.set(name, { name, field, deps });
+        nodeIndexByName.set(name, nodeIndexByName.size);
+    }
+    const adjacency = new Map();
+    for (const [name, node] of nodeByName) {
+        const deps = [];
+        for (const dependency of node.deps) {
+            if (dependency.domain !== "computed") {
+                continue;
+            }
+            if (!nodeByName.has(dependency.value)) {
+                throw new Error(`[DataGridFormulaExecutionPlan] Missing computed dependency '${dependency.value}' for '${name}'.`);
+            }
+            deps.push(dependency.value);
+        }
+        adjacency.set(name, deps);
+    }
+    const indexByName = new Map();
+    const lowLinkByName = new Map();
+    const stack = [];
+    const onStack = new Set();
+    const components = [];
+    let indexCounter = 0;
+    const strongConnect = (name) => {
+        var _a, _b, _c, _d, _e, _f, _g;
+        indexByName.set(name, indexCounter);
+        lowLinkByName.set(name, indexCounter);
+        indexCounter += 1;
+        stack.push(name);
+        onStack.add(name);
+        const deps = (_a = adjacency.get(name)) !== null && _a !== void 0 ? _a : [];
+        for (const dependencyName of deps) {
+            if (!indexByName.has(dependencyName)) {
+                strongConnect(dependencyName);
+                lowLinkByName.set(name, Math.min((_b = lowLinkByName.get(name)) !== null && _b !== void 0 ? _b : 0, (_c = lowLinkByName.get(dependencyName)) !== null && _c !== void 0 ? _c : 0));
+                continue;
+            }
+            if (onStack.has(dependencyName)) {
+                lowLinkByName.set(name, Math.min((_d = lowLinkByName.get(name)) !== null && _d !== void 0 ? _d : 0, (_e = indexByName.get(dependencyName)) !== null && _e !== void 0 ? _e : 0));
+            }
+        }
+        if (((_f = lowLinkByName.get(name)) !== null && _f !== void 0 ? _f : -1) !== ((_g = indexByName.get(name)) !== null && _g !== void 0 ? _g : -2)) {
+            return;
+        }
+        const component = [];
+        while (stack.length > 0) {
+            const entry = stack.pop();
+            if (!entry) {
+                break;
+            }
+            onStack.delete(entry);
+            component.push(entry);
+            if (entry === name) {
+                break;
+            }
+        }
+        component.sort((left, right) => { var _a, _b; return ((_a = nodeIndexByName.get(left)) !== null && _a !== void 0 ? _a : 0) - ((_b = nodeIndexByName.get(right)) !== null && _b !== void 0 ? _b : 0); });
+        components.push(component);
+    };
+    for (const name of nodeByName.keys()) {
+        if (!indexByName.has(name)) {
+            strongConnect(name);
+        }
+    }
+    const componentIndexByName = new Map();
+    for (let componentIndex = 0; componentIndex < components.length; componentIndex += 1) {
+        for (const name of (_a = components[componentIndex]) !== null && _a !== void 0 ? _a : []) {
+            componentIndexByName.set(name, componentIndex);
+        }
+    }
+    const isIterativeComponent = (component) => {
+        var _a;
+        if (component.length > 1) {
+            return true;
+        }
+        const name = component[0];
+        if (!name) {
+            return false;
+        }
+        return ((_a = adjacency.get(name)) !== null && _a !== void 0 ? _a : []).includes(name);
+    };
+    const iterativeGroups = components
+        .filter(component => isIterativeComponent(component))
+        .map(component => Object.freeze([...component]));
+    if (cyclePolicy === "error" && iterativeGroups.length > 0) {
+        throw new Error(`[DataGridFormulaExecutionPlan] Cycle detected at '${(_c = (_b = iterativeGroups[0]) === null || _b === void 0 ? void 0 : _b[0]) !== null && _c !== void 0 ? _c : "unknown"}'.`);
+    }
+    const componentDeps = new Map();
+    const componentDependents = new Map();
+    const indegreeByComponent = new Uint32Array(components.length);
+    for (let componentIndex = 0; componentIndex < components.length; componentIndex += 1) {
+        const component = (_d = components[componentIndex]) !== null && _d !== void 0 ? _d : [];
+        const deps = (_e = componentDeps.get(componentIndex)) !== null && _e !== void 0 ? _e : new Set();
+        for (const name of component) {
+            for (const dependencyName of (_f = adjacency.get(name)) !== null && _f !== void 0 ? _f : []) {
+                const dependencyComponentIndex = componentIndexByName.get(dependencyName);
+                if (typeof dependencyComponentIndex !== "number" || dependencyComponentIndex === componentIndex) {
+                    continue;
+                }
+                if (!deps.has(dependencyComponentIndex)) {
+                    deps.add(dependencyComponentIndex);
+                    indegreeByComponent[componentIndex] = ((_g = indegreeByComponent[componentIndex]) !== null && _g !== void 0 ? _g : 0) + 1;
+                }
+                const dependents = (_h = componentDependents.get(dependencyComponentIndex)) !== null && _h !== void 0 ? _h : new Set();
+                dependents.add(componentIndex);
+                componentDependents.set(dependencyComponentIndex, dependents);
+            }
+        }
+        componentDeps.set(componentIndex, deps);
+    }
+    const availableComponents = [];
+    for (let componentIndex = 0; componentIndex < components.length; componentIndex += 1) {
+        if (((_j = indegreeByComponent[componentIndex]) !== null && _j !== void 0 ? _j : 0) === 0) {
+            availableComponents.push(componentIndex);
+        }
+    }
+    availableComponents.sort((left, right) => {
+        var _a, _b;
+        const leftOrder = Math.min(...((_a = components[left]) !== null && _a !== void 0 ? _a : []).map(name => { var _a; return (_a = nodeIndexByName.get(name)) !== null && _a !== void 0 ? _a : Number.MAX_SAFE_INTEGER; }));
+        const rightOrder = Math.min(...((_b = components[right]) !== null && _b !== void 0 ? _b : []).map(name => { var _a; return (_a = nodeIndexByName.get(name)) !== null && _a !== void 0 ? _a : Number.MAX_SAFE_INTEGER; }));
+        return leftOrder - rightOrder;
+    });
+    const componentOrder = [];
+    const componentLevelByIndex = new Map();
+    while (availableComponents.length > 0) {
+        const componentIndex = availableComponents.shift();
+        if (typeof componentIndex !== "number") {
+            continue;
+        }
+        componentOrder.push(componentIndex);
+        const deps = (_k = componentDeps.get(componentIndex)) !== null && _k !== void 0 ? _k : new Set();
+        let level = 0;
+        for (const dependencyComponentIndex of deps) {
+            level = Math.max(level, ((_l = componentLevelByIndex.get(dependencyComponentIndex)) !== null && _l !== void 0 ? _l : 0) + 1);
+        }
+        componentLevelByIndex.set(componentIndex, level);
+        for (const dependentComponentIndex of (_m = componentDependents.get(componentIndex)) !== null && _m !== void 0 ? _m : []) {
+            indegreeByComponent[dependentComponentIndex] = ((_o = indegreeByComponent[dependentComponentIndex]) !== null && _o !== void 0 ? _o : 0) - 1;
+            if (indegreeByComponent[dependentComponentIndex] === 0) {
+                availableComponents.push(dependentComponentIndex);
+                availableComponents.sort((left, right) => {
+                    var _a, _b;
+                    const leftOrder = Math.min(...((_a = components[left]) !== null && _a !== void 0 ? _a : []).map(name => { var _a; return (_a = nodeIndexByName.get(name)) !== null && _a !== void 0 ? _a : Number.MAX_SAFE_INTEGER; }));
+                    const rightOrder = Math.min(...((_b = components[right]) !== null && _b !== void 0 ? _b : []).map(name => { var _a; return (_a = nodeIndexByName.get(name)) !== null && _a !== void 0 ? _a : Number.MAX_SAFE_INTEGER; }));
+                    return leftOrder - rightOrder;
+                });
+            }
+        }
+    }
+    const order = componentOrder.flatMap(componentIndex => { var _a; return (_a = components[componentIndex]) !== null && _a !== void 0 ? _a : []; });
+    const levelByName = new Map();
+    for (const name of order) {
+        const node = nodeByName.get(name);
+        if (!node) {
+            continue;
+        }
+        const componentIndex = componentIndexByName.get(name);
+        let level = typeof componentIndex === "number"
+            ? ((_p = componentLevelByIndex.get(componentIndex)) !== null && _p !== void 0 ? _p : 0)
+            : 0;
+        levelByName.set(name, level);
+    }
+    const levelBuckets = new Map();
+    const orderIndexByName = new Map();
+    for (const name of order) {
+        orderIndexByName.set(name, orderIndexByName.size);
+        const level = (_q = levelByName.get(name)) !== null && _q !== void 0 ? _q : 0;
+        const bucket = (_r = levelBuckets.get(level)) !== null && _r !== void 0 ? _r : [];
+        bucket.push(name);
+        levelBuckets.set(level, bucket);
+    }
+    const levels = Array.from(levelBuckets.entries())
+        .sort((left, right) => left[0] - right[0])
+        .map(([, names]) => Object.freeze([...names]));
+    const edges = Object.freeze(order.flatMap((name) => {
+        const node = nodeByName.get(name);
+        if (!node) {
+            return [];
+        }
+        return node.deps.map((dependency) => Object.freeze({
+            from: dependency.value,
+            to: name,
+            domain: dependency.domain,
+            value: dependency.value,
+        }));
+    }));
+    const nodes = new Map();
+    const dependentsByField = new Map();
+    const dependentsByComputed = new Map();
+    const fieldDepsByName = new Map();
+    const computedDepsByName = new Map();
+    for (const name of order) {
+        const node = nodeByName.get(name);
+        if (!node) {
+            continue;
+        }
+        const fieldDeps = new Set();
+        const computedDeps = new Set();
+        for (const dependency of node.deps) {
+            if (dependency.domain === "meta") {
+                continue;
+            }
+            if (dependency.domain === "field") {
+                fieldDeps.add(dependency.value);
+                continue;
+            }
+            const dependencyNode = nodeByName.get(dependency.value);
+            if (!dependencyNode) {
+                continue;
+            }
+            computedDeps.add(dependency.value);
+            fieldDeps.add(dependencyNode.field);
+            const computedDependents = (_s = dependentsByComputed.get(dependency.value)) !== null && _s !== void 0 ? _s : new Set();
+            computedDependents.add(name);
+            dependentsByComputed.set(dependency.value, computedDependents);
+        }
+        for (const field of fieldDeps) {
+            const fieldDependents = (_t = dependentsByField.get(field)) !== null && _t !== void 0 ? _t : new Set();
+            fieldDependents.add(name);
+            dependentsByField.set(field, fieldDependents);
+        }
+        const orderedFieldDeps = Array.from(fieldDeps);
+        const sortedComputedDeps = Array.from(computedDeps)
+            .sort((left, right) => {
+            var _a, _b;
+            const leftIndex = (_a = orderIndexByName.get(left)) !== null && _a !== void 0 ? _a : Number.MAX_SAFE_INTEGER;
+            const rightIndex = (_b = orderIndexByName.get(right)) !== null && _b !== void 0 ? _b : Number.MAX_SAFE_INTEGER;
+            return leftIndex - rightIndex;
+        });
+        fieldDepsByName.set(name, Object.freeze(orderedFieldDeps));
+        computedDepsByName.set(name, Object.freeze(sortedComputedDeps));
+    }
+    for (const name of order) {
+        const node = nodeByName.get(name);
+        if (!node) {
+            continue;
+        }
+        const componentIndex = componentIndexByName.get(name);
+        const cycleGroup = typeof componentIndex === "number" && isIterativeComponent((_u = components[componentIndex]) !== null && _u !== void 0 ? _u : [])
+            ? Object.freeze([...((_v = components[componentIndex]) !== null && _v !== void 0 ? _v : [])])
+            : null;
+        const sortedDependents = Array.from((_w = dependentsByComputed.get(name)) !== null && _w !== void 0 ? _w : [])
+            .sort((left, right) => {
+            var _a, _b;
+            const leftIndex = (_a = orderIndexByName.get(left)) !== null && _a !== void 0 ? _a : Number.MAX_SAFE_INTEGER;
+            const rightIndex = (_b = orderIndexByName.get(right)) !== null && _b !== void 0 ? _b : Number.MAX_SAFE_INTEGER;
+            return leftIndex - rightIndex;
+        });
+        nodes.set(name, Object.freeze({
+            name,
+            field: node.field,
+            level: (_x = levelByName.get(name)) !== null && _x !== void 0 ? _x : 0,
+            fieldDeps: (_y = fieldDepsByName.get(name)) !== null && _y !== void 0 ? _y : Object.freeze([]),
+            computedDeps: (_z = computedDepsByName.get(name)) !== null && _z !== void 0 ? _z : Object.freeze([]),
+            dependents: Object.freeze(sortedDependents),
+            ...(cycleGroup
+                ? {
+                    iterative: true,
+                    cycleGroup,
+                }
+                : {}),
+        }));
+    }
+    const affectedByComputedClosure = new Map();
+    for (let index = order.length - 1; index >= 0; index -= 1) {
+        const name = order[index];
+        if (!name) {
+            continue;
+        }
+        const closure = new Set([name]);
+        const dependents = dependentsByComputed.get(name);
+        if (dependents && dependents.size > 0) {
+            for (const dependentName of dependents) {
+                const dependentClosure = affectedByComputedClosure.get(dependentName);
+                if (!dependentClosure) {
+                    closure.add(dependentName);
+                    continue;
+                }
+                for (const computedName of dependentClosure) {
+                    closure.add(computedName);
+                }
+            }
+        }
+        affectedByComputedClosure.set(name, closure);
+    }
+    const affectedByFieldClosure = new Map();
+    for (const [field, directDependents] of dependentsByField) {
+        const closure = new Set();
+        for (const dependentName of directDependents) {
+            const dependentClosure = affectedByComputedClosure.get(dependentName);
+            if (!dependentClosure) {
+                closure.add(dependentName);
+                continue;
+            }
+            for (const computedName of dependentClosure) {
+                closure.add(computedName);
+            }
+        }
+        affectedByFieldClosure.set(field, closure);
+    }
+    const directByFieldPrefixClosure = new Map();
+    for (const [field, directDependents] of dependentsByField) {
+        const ancestors = collectFieldPathAncestors(field);
+        if (ancestors.length === 0) {
+            continue;
+        }
+        for (const ancestor of ancestors) {
+            mergeValueSetIntoMap(directByFieldPrefixClosure, ancestor, directDependents);
+        }
+    }
+    const affectedByFieldPrefixClosure = new Map();
+    for (const [field, closure] of affectedByFieldClosure) {
+        const ancestors = collectFieldPathAncestors(field);
+        if (ancestors.length === 0) {
+            continue;
+        }
+        for (const ancestor of ancestors) {
+            mergeValueSetIntoMap(affectedByFieldPrefixClosure, ancestor, closure);
+        }
+    }
+    const directByFields = (changedFields) => {
+        const affectedNames = new Set();
+        for (const rawField of changedFields) {
+            const field = rawField.trim();
+            if (field.length === 0) {
+                continue;
+            }
+            addMapValues(affectedNames, directByFieldPrefixClosure, field);
+            const ancestors = collectFieldPathAncestors(field);
+            for (const ancestor of ancestors) {
+                const directDependents = dependentsByField.get(ancestor);
+                if (!directDependents || directDependents.size === 0) {
+                    continue;
+                }
+                for (const dependentName of directDependents) {
+                    affectedNames.add(dependentName);
+                }
+            }
+        }
+        return affectedNames;
+    };
+    const affectedByFields = (changedFields) => {
+        const affectedNames = new Set();
+        for (const rawField of changedFields) {
+            const field = rawField.trim();
+            if (field.length === 0) {
+                continue;
+            }
+            addMapValues(affectedNames, affectedByFieldPrefixClosure, field);
+            const ancestors = collectFieldPathAncestors(field);
+            for (const ancestor of ancestors) {
+                addMapValues(affectedNames, affectedByFieldClosure, ancestor);
+            }
+        }
+        return affectedNames;
+    };
+    const affectedByComputed = (changedComputed) => {
+        const affectedNames = new Set();
+        for (const rawComputed of changedComputed) {
+            const computed = rawComputed.trim();
+            if (computed.length === 0) {
+                continue;
+            }
+            const affectedByComputedValue = affectedByComputedClosure.get(computed);
+            if (!affectedByComputedValue) {
+                continue;
+            }
+            for (const name of affectedByComputedValue) {
+                affectedNames.add(name);
+            }
+        }
+        return affectedNames;
+    };
+    const iterativeGroupSetByName = new Map();
+    for (const group of iterativeGroups) {
+        for (const name of group) {
+            iterativeGroupSetByName.set(name, group);
+        }
+    }
+    const levelDetails = Object.freeze(levels.map((level, index) => {
+        const cycleGroups = level
+            .map(name => iterativeGroupSetByName.get(name))
+            .filter((group, groupIndex, allGroups) => {
+            if (!group) {
+                return false;
+            }
+            return allGroups.indexOf(group) === groupIndex;
+        });
+        return Object.freeze({
+            index,
+            nodes: Object.freeze([...level]),
+            ...(cycleGroups.length > 0
+                ? {
+                    iterative: true,
+                    cycleGroups: Object.freeze(cycleGroups.map(group => Object.freeze([...group]))),
+                }
+                : {}),
+        });
+    }));
+    return {
+        order: Object.freeze([...order]),
+        levels: Object.freeze([...levels]),
+        levelDetails,
+        nodes,
+        edges,
+        iterativeGroups: Object.freeze(iterativeGroups.map(group => Object.freeze([...group]))),
+        directByFields,
+        affectedByFields,
+        affectedByComputed,
+    };
+}
+export const createDataGridFormulaGraph = createDataGridFormulaExecutionPlan;
+export function snapshotDataGridFormulaExecutionPlan(plan) {
+    const order = Object.freeze([...plan.order]);
+    const levels = Object.freeze(plan.levels.map(level => Object.freeze([...level])));
+    const nodes = Object.freeze(order.reduce((accumulator, name) => {
+        const node = plan.nodes.get(name);
+        if (!node) {
+            return accumulator;
+        }
+        accumulator.push({
+            name: node.name,
+            field: node.field,
+            level: node.level,
+            fieldDeps: Object.freeze([...node.fieldDeps]),
+            computedDeps: Object.freeze([...node.computedDeps]),
+            dependents: Object.freeze([...node.dependents]),
+            ...(node.iterative ? { iterative: true } : {}),
+            ...(node.cycleGroup ? { cycleGroup: Object.freeze([...node.cycleGroup]) } : {}),
+        });
+        return accumulator;
+    }, []));
+    return {
+        order,
+        levels,
+        nodes,
+        ...(plan.iterativeGroups.length > 0
+            ? {
+                iterativeGroups: Object.freeze(plan.iterativeGroups.map(group => Object.freeze([...group]))),
+            }
+            : {}),
+    };
+}
+export function snapshotDataGridFormulaGraph(plan) {
+    const executionPlanSnapshot = snapshotDataGridFormulaExecutionPlan(plan);
+    return {
+        order: executionPlanSnapshot.order,
+        levels: executionPlanSnapshot.levels,
+        levelDetails: plan.levelDetails.map(level => ({
+            index: level.index,
+            nodes: [...level.nodes],
+            ...(level.iterative ? { iterative: true } : {}),
+            ...(level.cycleGroups
+                ? { cycleGroups: level.cycleGroups.map(group => [...group]) }
+                : {}),
+        })),
+        nodes: executionPlanSnapshot.nodes,
+        edges: plan.edges.map(edge => ({
+            from: edge.from,
+            to: edge.to,
+            domain: edge.domain,
+            value: edge.value,
+        })),
+        ...(executionPlanSnapshot.iterativeGroups
+            ? { iterativeGroups: executionPlanSnapshot.iterativeGroups.map(group => [...group]) }
+            : {}),
+    };
+}

package/dist/graph/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./executionPlan.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/graph/index.ts"],"names":[],"mappings":"AAEA,cAAc,oBAAoB,CAAA"}

package/dist/graph/index.js

@@ -0,0 +1,3 @@
+// Dependency/execution-plan ownership. Runtime and host integrations should
+// depend on this surface rather than the internal graph file layout.
+export * from "./executionPlan.js";

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export type { DataGridComputedDependencyToken, DataGridFormulaReferenceDescriptor, DataGridFormulaReferenceDomain, DataGridFormulaReferenceRowDomain, DataGridComputedFieldComputeContext, DataGridComputedFieldDefinition, DataGridComputedFieldSnapshot, DataGridFormulaMetaField, DataGridFormulaContextRecomputeRequest, DataGridFormulaCyclePolicy, DataGridFormulaFieldDefinition, DataGridFormulaFieldSnapshot, DataGridFormulaTableRowsSource, DataGridFormulaTableSource, DataGridFormulaArrayValue, DataGridFormulaErrorValue, DataGridFormulaIterativeCalculationOptions, DataGridFormulaScalarValue, DataGridFormulaValue, DataGridFormulaRuntimeErrorCode, DataGridFormulaRuntimeError, DataGridFormulaDirtyCause, DataGridFormulaDirtyRowCause, DataGridProjectionFormulaDiagnostics, DataGridFormulaComputeStageDiagnostics, DataGridFormulaNodeComputeDiagnostics, DataGridFormulaRowNodeRecomputeDiagnostics, DataGridFormulaRowRecomputeDiagnosticsEntry, DataGridFormulaRowRecomputeDiagnostics, DataGridFormulaRuntimeIntegration, DataGridRowId, } from "./coreTypes.js";
+export type { DataGridCompiledFormulaArtifact, DataGridCompiledFormulaBatchContext, DataGridCompiledFormulaBatchExecutionMode, DataGridCompiledFormulaField, DataGridFormulaAstNode, DataGridFormulaDiagnostic, DataGridFormulaExpressionAnalysis, DataGridFormulaExplainDependency, DataGridFormulaExplainDependencyDomain, DataGridFormulaExplainNode, DataGridFormulaExplainResult, DataGridFormulaFieldExplainResult, DataGridFormulaCompileOptions, DataGridFormulaCompileStrategy, DataGridFormulaFunctionArity, DataGridFormulaFunctionDefinition, DataGridFormulaFunctionRegistry, DataGridFormulaParseResult, DataGridFormulaReferenceParserOptions, DataGridFormulaReferenceSyntax, DataGridFormulaRowSelector, DataGridFormulaRuntimeErrorPolicy, DataGridFormulaDiagnosticsResult, DataGridFormulaSourceSpan, } from "./syntax/index.js";
+export type { DataGridFormulaExecutionDependencyDomain, DataGridFormulaExecutionDependency, DataGridFormulaGraphEdgeSnapshot, DataGridFormulaGraphLevelSnapshot, DataGridFormulaGraphSnapshot, DataGridFormulaExecutionPlanNode, DataGridFormulaExecutionPlanNodeSnapshot, DataGridFormulaExecutionPlan, DataGridFormulaExecutionPlanSnapshot, } from "./graph/index.js";
+export { DATAGRID_FORMULA_META_FIELDS, isDataGridFormulaMetaField, parseDataGridComputedDependencyToken, serializeDataGridComputedDependencyToken, } from "./contracts.js";
+export { DATAGRID_DEFAULT_FORMULA_FUNCTIONS, normalizeFormulaFunctionRegistry, collectFormulaContextKeys, explainDataGridFormulaExpression, explainDataGridFormulaFieldDefinition, createFormulaErrorValue, createFormulaSourceSpan, createFormulaDiagnostic, diagnoseDataGridFormulaExpression, findFormulaErrorValue, getFormulaNodeSpan, isFormulaErrorValue, isFormulaValueBlank, isFormulaValueEmptyText, normalizeFormulaValue, normalizeFormulaDiagnostic, parseDataGridFormulaExpression, parseDataGridFormulaIdentifier, parseFormulaReferenceSegments, normalizeFormulaReference, coerceFormulaValueToNumber, coerceFormulaValueToBoolean, areFormulaValuesEqual, compareFormulaValues, } from "./syntax/index.js";
+export { analyzeDataGridFormulaFieldDefinition, bindCompiledFormulaArtifactToFieldDefinition, compileDataGridFormulaFieldArtifact, compileDataGridFormulaFieldDefinition, } from "./runtime/index.js";
+export { createDataGridFormulaGraph, createDataGridFormulaExecutionPlan, snapshotDataGridFormulaGraph, snapshotDataGridFormulaExecutionPlan, } from "./graph/index.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,YAAY,EACV,+BAA+B,EAC/B,kCAAkC,EAClC,8BAA8B,EAC9B,iCAAiC,EACjC,mCAAmC,EACnC,+BAA+B,EAC/B,6BAA6B,EAC7B,wBAAwB,EACxB,sCAAsC,EACtC,0BAA0B,EAC1B,8BAA8B,EAC9B,4BAA4B,EAC5B,8BAA8B,EAC9B,0BAA0B,EAC1B,yBAAyB,EACzB,yBAAyB,EACzB,0CAA0C,EAC1C,0BAA0B,EAC1B,oBAAoB,EACpB,+BAA+B,EAC/B,2BAA2B,EAC3B,yBAAyB,EACzB,4BAA4B,EAC5B,oCAAoC,EACpC,sCAAsC,EACtC,qCAAqC,EACrC,0CAA0C,EAC1C,2CAA2C,EAC3C,sCAAsC,EACtC,iCAAiC,EACjC,aAAa,GACd,MAAM,gBAAgB,CAAA;AAEvB,YAAY,EACV,+BAA+B,EAC/B,mCAAmC,EACnC,yCAAyC,EACzC,4BAA4B,EAC5B,sBAAsB,EACtB,yBAAyB,EACzB,iCAAiC,EACjC,gCAAgC,EAChC,sCAAsC,EACtC,0BAA0B,EAC1B,4BAA4B,EAC5B,iCAAiC,EACjC,6BAA6B,EAC7B,8BAA8B,EAC9B,4BAA4B,EAC5B,iCAAiC,EACjC,+BAA+B,EAC/B,0BAA0B,EAC1B,qCAAqC,EACrC,8BAA8B,EAC9B,0BAA0B,EAC1B,iCAAiC,EACjC,gCAAgC,EAChC,yBAAyB,GAC1B,MAAM,mBAAmB,CAAA;AAE1B,YAAY,EACV,wCAAwC,EACxC,kCAAkC,EAClC,gCAAgC,EAChC,iCAAiC,EACjC,4BAA4B,EAC5B,gCAAgC,EAChC,wCAAwC,EACxC,4BAA4B,EAC5B,oCAAoC,GACrC,MAAM,kBAAkB,CAAA;AAEzB,OAAO,EACL,4BAA4B,EAC5B,0BAA0B,EAC1B,oCAAoC,EACpC,wCAAwC,GACzC,MAAM,gBAAgB,CAAA;AAEvB,OAAO,EACL,kCAAkC,EAClC,gCAAgC,EAChC,yBAAyB,EACzB,gCAAgC,EAChC,qCAAqC,EACrC,uBAAuB,EACvB,uBAAuB,EACvB,uBAAuB,EACvB,iCAAiC,EACjC,qBAAqB,EACrB,kBAAkB,EAClB,mBAAmB,EACnB,mBAAmB,EACnB,uBAAuB,EACvB,qBAAqB,EACrB,0BAA0B,EAC1B,8BAA8B,EAC9B,8BAA8B,EAC9B,6BAA6B,EAC7B,yBAAyB,EACzB,0BAA0B,EAC1B,2BAA2B,EAC3B,qBAAqB,EACrB,oBAAoB,GACrB,MAAM,mBAAmB,CAAA;AAE1B,OAAO,EACL,qCAAqC,EACrC,4CAA4C,EAC5C,mCAAmC,EACnC,qCAAqC,GACtC,MAAM,oBAAoB,CAAA;AAE3B,OAAO,EACL,0BAA0B,EAC1B,kCAAkC,EAClC,4BAA4B,EAC5B,oCAAoC,GACrC,MAAM,kBAAkB,CAAA"}

package/dist/index.js

@@ -0,0 +1,4 @@
+export { DATAGRID_FORMULA_META_FIELDS, isDataGridFormulaMetaField, parseDataGridComputedDependencyToken, serializeDataGridComputedDependencyToken, } from "./contracts.js";
+export { DATAGRID_DEFAULT_FORMULA_FUNCTIONS, normalizeFormulaFunctionRegistry, collectFormulaContextKeys, explainDataGridFormulaExpression, explainDataGridFormulaFieldDefinition, createFormulaErrorValue, createFormulaSourceSpan, createFormulaDiagnostic, diagnoseDataGridFormulaExpression, findFormulaErrorValue, getFormulaNodeSpan, isFormulaErrorValue, isFormulaValueBlank, isFormulaValueEmptyText, normalizeFormulaValue, normalizeFormulaDiagnostic, parseDataGridFormulaExpression, parseDataGridFormulaIdentifier, parseFormulaReferenceSegments, normalizeFormulaReference, coerceFormulaValueToNumber, coerceFormulaValueToBoolean, areFormulaValuesEqual, compareFormulaValues, } from "./syntax/index.js";
+export { analyzeDataGridFormulaFieldDefinition, bindCompiledFormulaArtifactToFieldDefinition, compileDataGridFormulaFieldArtifact, compileDataGridFormulaFieldDefinition, } from "./runtime/index.js";
+export { createDataGridFormulaGraph, createDataGridFormulaExecutionPlan, snapshotDataGridFormulaGraph, snapshotDataGridFormulaExecutionPlan, } from "./graph/index.js";

package/dist/runtime/compile.d.ts

@@ -0,0 +1,7 @@
+import type { DataGridFormulaFieldDefinition } from "../coreTypes.js";
+import { type DataGridCompiledFormulaArtifact, type DataGridCompiledFormulaField, type DataGridFormulaExpressionAnalysis, type DataGridFormulaCompileOptions } from "../syntax/core.js";
+export declare function analyzeDataGridFormulaFieldDefinition(definition: DataGridFormulaFieldDefinition, options?: DataGridFormulaCompileOptions): DataGridFormulaExpressionAnalysis;
+export declare function bindCompiledFormulaArtifactToFieldDefinition<TRow = unknown>(artifact: DataGridCompiledFormulaArtifact<TRow>, definition: DataGridFormulaFieldDefinition, options?: Pick<DataGridFormulaCompileOptions, "runtimeErrorPolicy" | "onRuntimeError">): DataGridCompiledFormulaField<TRow>;
+export declare function compileDataGridFormulaFieldArtifact<TRow = unknown>(definition: DataGridFormulaFieldDefinition, options?: DataGridFormulaCompileOptions): DataGridCompiledFormulaArtifact<TRow>;
+export declare function compileDataGridFormulaFieldDefinition<TRow = unknown>(definition: DataGridFormulaFieldDefinition, options?: DataGridFormulaCompileOptions): DataGridCompiledFormulaField<TRow>;
+//# sourceMappingURL=compile.d.ts.map

package/dist/runtime/compile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../../src/runtime/compile.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAGV,8BAA8B,EAG/B,MAAM,iBAAiB,CAAA;AACxB,OAAO,EAEL,KAAK,+BAA+B,EACpC,KAAK,4BAA4B,EAGjC,KAAK,iCAAiC,EACtC,KAAK,6BAA6B,EAInC,MAAM,mBAAmB,CAAA;AAwN1B,wBAAgB,qCAAqC,CACnD,UAAU,EAAE,8BAA8B,EAC1C,OAAO,GAAE,6BAAkC,GAC1C,iCAAiC,CASnC;AAED,wBAAgB,4CAA4C,CAAC,IAAI,GAAG,OAAO,EACzE,QAAQ,EAAE,+BAA+B,CAAC,IAAI,CAAC,EAC/C,UAAU,EAAE,8BAA8B,EAC1C,OAAO,GAAE,IAAI,CAAC,6BAA6B,EAAE,oBAAoB,GAAG,gBAAgB,CAAM,GACzF,4BAA4B,CAAC,IAAI,CAAC,CAEpC;AAED,wBAAgB,mCAAmC,CAAC,IAAI,GAAG,OAAO,EAChE,UAAU,EAAE,8BAA8B,EAC1C,OAAO,GAAE,6BAAkC,GAC1C,+BAA+B,CAAC,IAAI,CAAC,CA8WvC;AAED,wBAAgB,qCAAqC,CAAC,IAAI,GAAG,OAAO,EAClE,UAAU,EAAE,8BAA8B,EAC1C,OAAO,GAAE,6BAAkC,GAC1C,4BAA4B,CAAC,IAAI,CAAC,CAGpC"}