@campxdev/pdfme 1.1.0 → 1.2.0

package/dist/types/_vendors/schemas/dynamicTable/engine/interfaces/rules/rule-engine.interface.d.ts

@@ -0,0 +1,21 @@
+import type { ICell } from '../core';
+import type { EvaluationResult, ResolvedCell } from '../../rules/types/evaluation.types';
+import type { RulePayload } from '../../rules/types/rule.types';
+export interface IRuleEngine {
+    /** Evaluate all matching rules for one cell. Stores result internally. */
+    evaluateCell(cell: ICell): EvaluationResult;
+    /** Evaluate all cells in the table. Stores results internally. */
+    evaluateAll(): void;
+    /** Get the cached evaluation result for a cell. */
+    getResult(cellId: string): EvaluationResult | undefined;
+    /** Get all cached results. */
+    getAllResults(): ReadonlyMap<string, EvaluationResult>;
+    /** Build a ResolvedCell (final renderer snapshot) by merging base style + rule patches. */
+    resolveCell(cell: ICell): ResolvedCell;
+    /** Clear all cached results. */
+    clearResults(): void;
+    /** Export all rules as serializable payloads. */
+    exportRules(): RulePayload[];
+    /** Import rules from serializable payloads, replacing all existing rules. */
+    importRules(payloads: RulePayload[]): void;
+}

package/dist/types/_vendors/schemas/dynamicTable/engine/interfaces/rules/rule-registry.interface.d.ts

@@ -0,0 +1,19 @@
+import type { ICell } from '../core';
+import type { Rule, RuleInput, RulePayload, RuleUpdate } from '../../rules/types/rule.types';
+import type { RuleScope } from '../../types/rule-target.types';
+export type { MatchContext } from '../../rules/rule-matcher';
+export interface IRuleRegistry {
+    addRule(input: RuleInput): string;
+    removeRule(ruleId: string): void;
+    updateRule(ruleId: string, update: RuleUpdate): boolean;
+    getRule(ruleId: string): Rule | undefined;
+    getAll(): Rule[];
+    enableRule(ruleId: string): void;
+    disableRule(ruleId: string): void;
+    getRulesForCell(cell: ICell, ctx: import('../../rules/rule-matcher').MatchContext): Rule[];
+    getRulesByScope(scope: RuleScope): Rule[];
+    searchByLabel(query: string): Rule[];
+    getRulesByValueDep(depKey: string): Rule[];
+    export(): RulePayload[];
+    import(payloads: RulePayload[]): void;
+}

package/dist/types/_vendors/schemas/dynamicTable/engine/interfaces/stores/cell-registry.interface.d.ts

@@ -0,0 +1,12 @@
+import { CellPayload, CellStyle, Region } from "../../types";
+import { ICell } from "../core";
+export interface ICellRegistry {
+    createCell(region: Region, rawValue?: string, style?: Partial<CellStyle>, isDynamic?: boolean): string;
+    createCellWithId(cellId: string, region: Region, rawValue?: string, style?: Partial<CellStyle>, isDynamic?: boolean, computedValue?: string | number): string;
+    getCellById(cellId: string): ICell | undefined;
+    getCellByAddress(address: string): ICell | undefined;
+    updateCell(cellId: string, payload: CellPayload): void;
+    deleteCell(cellId: string): void;
+    setCellAddress(cellId: string, address: string): void;
+    clearCellAddress(cellId: string): void;
+}

package/dist/types/_vendors/schemas/dynamicTable/engine/interfaces/stores/index.d.ts

@@ -0,0 +1,3 @@
+export type { ICellRegistry } from "./cell-registry.interface";
+export type { IMergeRegistry } from "./merge-registry.interface";
+export type { IStructureStore } from "./structure-store.interface";

package/dist/types/_vendors/schemas/dynamicTable/engine/interfaces/stores/merge-registry.interface.d.ts

@@ -0,0 +1,42 @@
+import { Rect } from "../../types/common";
+export interface IMergeRegistry {
+    /**
+     * Create a merge for the given rectangle of cells
+     */
+    createMerge(rect: Rect): void;
+    /**
+     * Validate if a merge rectangle is valid for the current table structure
+     */
+    isValidMerge(rect: Rect): boolean;
+    /**
+     * Get merge by root cell ID
+     * Returns the merge rectangle if it exists
+     */
+    getMergeByRootId(cellId: string): Rect | undefined;
+    /**
+     * Delete a merge by its root cell ID
+     * After deletion, cells are unmerged and layout must be rebuilt
+     */
+    deleteMerge(cellId: string): void;
+    /**
+     * Get all merges organized as top-level rects
+     * Filters nested merges to only return the parent merges
+     */
+    getMergeSet(): Map<string, Rect>;
+    /**
+     * Find a merge that contains a specific cell
+     * Returns the root cell ID and merge rectangle if found
+     */
+    findMergeByContainedCell(cellId: string): {
+        rootCellId: string;
+        merge: Rect;
+    } | undefined;
+    /**
+     * Check if a cell ID is a merge root
+     */
+    isMergeRoot(cellId: string): boolean;
+    /**
+     * Get all cell IDs that are merge roots
+     */
+    getMergeRoots(): string[];
+}

package/dist/types/_vendors/schemas/dynamicTable/engine/interfaces/stores/structure-store.interface.d.ts

@@ -0,0 +1,31 @@
+import { Region } from "../../types";
+export interface IStructureStore {
+    addRootCell(cellId: string, region: Region): void;
+    removeRootCell(cellId: string, region: Region): void;
+    getRoots(region: Region): readonly string[] | undefined;
+    addChildCell(parentId: string, region: Region, childId: string, index?: number): void;
+    removeChildCell(parentId: string, childId: string, region: Region): void;
+    getChildren(parentId: string): readonly string[] | undefined;
+    insertBodyRow(rowIndex: number, cellIds: string[]): void;
+    removeBodyRow(rowIndex: number): string[];
+    insertBodyCol(colIndex: number, cellIds: string[]): void;
+    removeBodyCol(colIndex: number): string[];
+    getBodyCell(rowIndex: number, colIndex: number): string | undefined;
+    getBody(): readonly (readonly string[])[];
+    countTotalRows(): number;
+    countTotalCols(): number;
+    getLeafCells(cellId: string): string[];
+    getHeightOfCell(cellId: string): number;
+    isLeafCell(cellId: string): boolean;
+    getLeafCount(region: Region): number;
+    getBodyIndexForHeaderLeafCell(region: Region, cellId: string): number;
+    reorderHeaderCell(region: Region, fromIndex: number, toIndex: number, withChildren?: boolean): void;
+    /** Check if the body grid needs a new row/col slice to match this region's current leaf count */
+    needsBodySliceForRegion(region: Region): boolean;
+    addFooterCell(rowIndex: number, cellId: string): void;
+    removeFooterCell(rowIndex: number, colIndex: number): string;
+    addFooterRow(cellId: string): void;
+    removeFooterRow(rowIndex: number): string[];
+    getFooter(): readonly (readonly string[])[];
+    getFooterCell(rowIndex: number, colIndex: number): string | undefined;
+}

package/dist/types/_vendors/schemas/dynamicTable/engine/interfaces/table/index.d.ts

@@ -0,0 +1 @@
+export type { ITable } from "./table.inteface";

package/dist/types/_vendors/schemas/dynamicTable/engine/interfaces/table/table.inteface.d.ts

@@ -0,0 +1,63 @@
+import { ICell } from "../core";
+import { CellPayload, CellStyle, Region, TableSettings, TablePosition, TableStyle, RegionStyle, BodyRegionStyle, RegionStyleMap, UIState } from "../../types";
+import { Rect } from "../../types/common";
+import type { EvaluationResult } from "../../rules/types/evaluation.types";
+import type { TableExportData } from "../../renderers/types/serialization.types";
+import type { RenderableTableInstance } from "../../renderers/types/renderable-types";
+export interface ITable {
+    addHeaderCell(region: Region, parentId?: string, index?: number): string | 'exceeds-bounds';
+    removeHeaderCell(cellId: string, region: Region, isRoot: boolean, parentId?: string): void;
+    buildBody(data: (string | number)[][]): void;
+    insertBodyRow(rowIndex: number, data?: (string | number)[]): 'added' | 'max-reached' | 'exceeds-bounds';
+    removeBodyRow(rowIndex: number): 'removed' | 'cleared';
+    insertBodyCol(colIndex: number, data?: (string | number)[]): 'added' | 'max-reached' | 'exceeds-bounds';
+    removeBodyCol(colIndex: number): 'removed' | 'cleared';
+    getCellById(cellId: string): ICell | undefined;
+    getCellByAddress(row: number, col: number): ICell | undefined;
+    updateCell(cellId: string, payload: CellPayload): void;
+    mergeCells(rect: Rect): void;
+    unmergeCells(cellId: string): void;
+    getMerges(): Map<string, Rect>;
+    getSettings(): TableSettings;
+    updateSettings(settings: Partial<TableSettings>): string | null;
+    getTableStyle(): TableStyle;
+    setTableStyle(style: Partial<TableStyle>): void;
+    getRegionStyles(): RegionStyleMap;
+    getRegionStyle(region: Region): RegionStyle | BodyRegionStyle | undefined;
+    setRegionStyle(region: Region, style: RegionStyle | BodyRegionStyle): void;
+    setColumnWidth(colIndex: number, width: number): void;
+    setRowHeight(rowIndex: number, height: number): void;
+    setDefaultCellWidth(width: number): void;
+    setDefaultCellHeight(height: number): void;
+    getColumnWidths(): number[];
+    getRowHeights(): number[];
+    setTablePosition(position: TablePosition): void;
+    getTablePosition(): TablePosition;
+    setFooterRowHeight(rowIndex: number, height: number): void;
+    getFooterRowHeights(): number[];
+    getFooterCellWidths(): number[][];
+    setFooterCellWidth(rowIndex: number, colIndex: number, width: number): void;
+    getFooter(): readonly (readonly string[])[];
+    addFooterRow(): void;
+    addFooterCell(rowIndex: number): void;
+    removeFooterCell(rowIndex: number, colIndex: number): void;
+    removeFooterRow(rowIndex: number): void;
+    getCompleteGrid(): string[][];
+    getEvaluationResult(cellId: string): EvaluationResult | undefined;
+    getOverflowStylePatch(cellId: string): Partial<CellStyle> | undefined;
+    exportState(): TableExportData;
+    getUIState(): UIState;
+    startEditing(cellId: string): void;
+    stopEditing(): void;
+    selectCell(cellId: string): void;
+    selectCells(cellIds: string[]): void;
+    setSelectionAnchor(anchor: {
+        row: number;
+        col: number;
+        region: string;
+    } | null): void;
+    clearSelection(): void;
+    resetUIState(): void;
+    getRenderSnapshot(): RenderableTableInstance;
+    toJSON(): string;
+}

package/dist/types/_vendors/schemas/dynamicTable/engine/renderers/types/renderable-types.d.ts

@@ -0,0 +1,79 @@
+import { CellLayout, CellStyle, TableSettings, TableStyle, RegionStyleMap, Region, Rect } from "../../types";
+import { EvaluationResult } from "../../rules/types/evaluation.types";
+/**
+ * Renderable version of a cell - optimized for rendering
+ * Contains all calculated and style information needed by renderers.
+ * style is the fully resolved CellStyle (after cascade).
+ */
+export interface RenderableCell {
+    cellID: string;
+    rawValue: string | number;
+    computedValue?: string | number;
+    layout: CellLayout;
+    style: CellStyle;
+    inRegion: Region;
+    evaluationResult?: EvaluationResult;
+    isDynamic: boolean;
+    mergeRect?: Rect;
+}
+/**
+ * Renderable row - groups cells that belong to same row
+ */
+export interface RenderableRow {
+    rowIndex: number;
+    globalRowIndex: number;
+    region: Region;
+    height: number;
+    cells: Map<number, RenderableCell>;
+    rawValues: (string | number)[];
+}
+/**
+ * Column information with calculated width
+ */
+export interface RenderableColumn {
+    colIndex: number;
+    width: number;
+}
+/**
+ * Renderable merge - tracks merged cell regions
+ */
+export interface RenderableMerge {
+    cellID: string;
+    startRow: number;
+    startCol: number;
+    endRow: number;
+    endCol: number;
+    primaryRegion: Region;
+}
+/**
+ * Complete renderable table instance
+ * Everything needed to render without touching the Table facade
+ */
+export interface RenderableTableInstance {
+    settings: TableSettings;
+    tableStyle: TableStyle;
+    regionStyles: RegionStyleMap;
+    columns: RenderableColumn[];
+    footerColumns: RenderableColumn[];
+    regions: {
+        theader: RenderableRow[];
+        lheader: RenderableRow[];
+        rheader: RenderableRow[];
+        footer: RenderableRow[];
+        body: RenderableRow[];
+    };
+    cellsById: Map<string, RenderableCell>;
+    merges: RenderableMerge[];
+    evaluationResults: Map<string, EvaluationResult>;
+    editingCellId: string | null;
+    selectedCellIds: ReadonlySet<string>;
+    mergeMode: 'none' | 'selecting' | 'unmerging' | 'styling';
+    getCellAt(row: number, col: number, region: Region): RenderableCell | undefined;
+    getCellByID(cellID: string): RenderableCell | undefined;
+    getRowsInRegion(region: Region): RenderableRow[];
+    getWidth(): number;
+    getHeight(): number;
+    getHeadHeight(): number;
+    getBodyHeight(): number;
+    getFooterHeight(): number;
+}

package/dist/types/_vendors/schemas/dynamicTable/engine/renderers/types/serialization.types.d.ts

@@ -0,0 +1,46 @@
+import type { CellStyle, OverflowMode, Rect, TableSettings, TableStyle, RegionStyleMap } from '../../types';
+import type { RulePayload } from '../../rules/types/rule.types';
+/**
+ * JSON-serializable representation of a header tree node.
+ * Used only for transport/storage — at runtime, StructureStore is the source of truth.
+ */
+export interface SerializedHeaderNode {
+    cellId: string;
+    rawValue: string | number;
+    style: Partial<CellStyle>;
+    overflow?: OverflowMode;
+    isDynamic: boolean;
+    computedValue?: string | number;
+    children: SerializedHeaderNode[];
+}
+/**
+ * Serialized body cell data (one entry per body grid position).
+ */
+export interface SerializedBodyCell {
+    cellId: string;
+    rawValue: string | number;
+    style: Partial<CellStyle>;
+    overflow?: OverflowMode;
+    isDynamic: boolean;
+    computedValue?: string | number;
+}
+/**
+ * Complete export of a Table's state — everything needed to reconstruct
+ * the Table instance from scratch.
+ *
+ * CellLayout is NOT included because it is always recomputed by LayoutEngine.rebuild().
+ */
+export interface TableExportData {
+    headerTrees: Record<'theader' | 'lheader' | 'rheader', SerializedHeaderNode[]>;
+    footer: SerializedBodyCell[][];
+    body: SerializedBodyCell[][];
+    merges: Rect[];
+    settings: TableSettings;
+    tableStyle: TableStyle;
+    regionStyles: RegionStyleMap;
+    columnWidths: number[];
+    rowHeights: number[];
+    footerCellWidths: number[][];
+    footerRowHeights: number[];
+    rules: RulePayload[];
+}

package/dist/types/_vendors/schemas/dynamicTable/engine/rules/expression/ast.types.d.ts

@@ -0,0 +1,117 @@
+/**
+ * AST (Abstract Syntax Tree) node types for rule expressions.
+ * Discriminated union of all expression node types.
+ */
+/**
+ * Literal value — number, string, or boolean.
+ * Evaluates to its value directly.
+ */
+export interface LiteralNode {
+    type: 'Literal';
+    value: string | number | boolean | null;
+}
+/**
+ * Variable reference — dot-path like "cell.value", "table.rowCount".
+ * Engine resolves path against EvalContext at evaluation time.
+ *
+ * Examples:
+ *   - "cell.value"       → string display value
+ *   - "cell.numericValue"→ numeric value
+ *   - "cell.rowIndex"    → row index
+ *   - "cell.overflows"   → boolean
+ *   - "table.rowCount"   → total rows
+ */
+export interface VarNode {
+    type: 'Var';
+    path: string;
+}
+/**
+ * Binary operation — left operator right.
+ * Examples: >100, cell.value == "red", SUM(col:0) > AVG(col:1)
+ *
+ * Operators:
+ *   - Comparison: >, <, >=, <=, ==, !=
+ *   - Arithmetic: +, -, *, /, %
+ *   - Logical: AND, OR
+ */
+export interface BinaryOpNode {
+    type: 'BinaryOp';
+    op: '>' | '<' | '>=' | '<=' | '==' | '!=' | '+' | '-' | '*' | '/' | '%' | 'AND' | 'OR';
+    left: ExprNode;
+    right: ExprNode;
+}
+/**
+ * Unary operation — operator operand.
+ * Examples: NOT true, -5
+ *
+ * Operators: NOT (logical negation), - (numeric negation)
+ */
+export interface UnaryOpNode {
+    type: 'UnaryOp';
+    op: 'NOT' | '-';
+    operand: ExprNode;
+}
+/**
+ * Function call — name with arguments.
+ * Examples: SUM(col:0), TEXT_HEIGHT(cell.value, 12), CELL(0, 1)
+ *
+ * Arguments are evaluated recursively; functions receive resolved values.
+ */
+export interface FnCallNode {
+    type: 'FnCall';
+    name: string;
+    args: ExprNode[];
+}
+/**
+ * Range reference — notation like "col:0", "row:3", "col:self", "body", "self", etc.
+ * Evaluates to ICell[] (array of cells matching the range).
+ *
+ * Notation examples:
+ *   - "col:0"  → all cells in column 0
+ *   - "col:self" → all cells in the rule's target column (resolved at eval time)
+ *   - "row:3"  → all cells in row 3
+ *   - "row:self" → all cells in the rule's target row (resolved at eval time)
+ *   - "r0c0:r2c3" → rectangular selection (rows 0-2, cols 0-3)
+ *   - "body"   → all body cells
+ *   - "self"   → for selection-scoped rules, the selection rect
+ */
+export interface RangeRefNode {
+    type: 'RangeRef';
+    notation: string;
+}
+/**
+ * Object literal — key-value pairs.
+ * Used in result expressions to build structured outputs.
+ *
+ * Examples:
+ *   - { style: { backgroundColor: 'red' } }
+ *   - { rowHeightMin: 50, colWidthMin: 100 }
+ */
+export interface ObjectLiteralNode {
+    type: 'ObjectLiteral';
+    properties: Map<string, ExprNode>;
+}
+/**
+ * Array literal — list of values.
+ * Used in complex expressions (though less common in rule conditions).
+ */
+export interface ArrayLiteralNode {
+    type: 'ArrayLiteral';
+    elements: ExprNode[];
+}
+/**
+ * ExprNode — discriminated union of all expression node types.
+ * Represents the complete syntax tree of a rule expression.
+ */
+export type ExprNode = LiteralNode | VarNode | BinaryOpNode | UnaryOpNode | FnCallNode | RangeRefNode | ObjectLiteralNode | ArrayLiteralNode;
+/**
+ * Helper type guard functions (optional, for convenience).
+ */
+export declare const isLiteral: (node: ExprNode) => node is LiteralNode;
+export declare const isVar: (node: ExprNode) => node is VarNode;
+export declare const isBinaryOp: (node: ExprNode) => node is BinaryOpNode;
+export declare const isUnaryOp: (node: ExprNode) => node is UnaryOpNode;
+export declare const isFnCall: (node: ExprNode) => node is FnCallNode;
+export declare const isRangeRef: (node: ExprNode) => node is RangeRefNode;
+export declare const isObjectLiteral: (node: ExprNode) => node is ObjectLiteralNode;
+export declare const isArrayLiteral: (node: ExprNode) => node is ArrayLiteralNode;

package/dist/types/_vendors/schemas/dynamicTable/engine/rules/expression/compiler.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Compiler — converts expression strings to AST and validates them.
+ * Wraps lexer, parser, and validation logic.
+ *
+ * Pipeline: string → Lexer → tokens → Parser → AST → validator → (AST or error)
+ */
+import type { ExprNode } from './ast.types';
+export interface CompileError {
+    message: string;
+    position?: number;
+}
+export interface ValidationResult {
+    valid: boolean;
+    errors: CompileError[];
+}
+/**
+ * Compiler — translates expression strings to AST.
+ */
+export declare class Compiler {
+    /**
+     * Compile an expression string to AST.
+     * @param expr - expression string (e.g., "cell.value > 100")
+     * @returns AST node
+     * @throws CompileError if syntax is invalid
+     */
+    static compile(expr: string): ExprNode;
+    /**
+     * Validate an expression string without evaluating it.
+     * Checks syntax only; does not verify Var/FnCall names exist.
+     *
+     * @param expr - expression string
+     * @returns validation result
+     */
+    static validate(expr: string): ValidationResult;
+    /**
+     * Quick syntax check without throwing.
+     * @param expr - expression string
+     * @returns true if syntax is valid
+     */
+    static isSyntaxValid(expr: string): boolean;
+    /**
+     * Parse multiple expressions at once (batch validation).
+     * Useful for validating a whole rule set.
+     */
+    static compileMultiple(expressions: string[]): {
+        asts: ExprNode[];
+        errors: Record<number, CompileError[]>;
+    };
+}
+/**
+ * Convenience function — compile and return AST, or null on error.
+ * Useful for lenient parsing.
+ */
+export declare function tryCompile(expr: string): ExprNode | null;

package/dist/types/_vendors/schemas/dynamicTable/engine/rules/expression/evaluator.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Evaluator — walks an AST and evaluates it to a typed value.
+ * Handles the engine-specific parts:
+ *   - Var resolution (cell.value, table.rowCount)
+ *   - FnCall dispatch (SUM, AVG, TEXT_HEIGHT, etc.)
+ *   - RangeRef resolution (col:0, row:self, body, etc.)
+ *
+ * Everything else (literals, operators, object literals) is standard expression evaluation.
+ */
+import type { ExprNode } from './ast.types';
+import type { EvalContext } from '../types/evaluation.types';
+export declare class EvaluationError extends Error {
+    message: string;
+    constructor(message: string);
+}
+/**
+ * Evaluator — evaluates an ExprNode AST.
+ */
+export declare class Evaluator {
+    /**
+     * Evaluate an AST node against the given context.
+     * @param node - AST node to evaluate
+     * @param ctx - evaluation context (cell, table, stores, etc.)
+     * @returns the evaluated result
+     */
+    static evaluate(node: ExprNode, ctx: EvalContext): any;
+    private static evaluateVar;
+    private static evaluateBinaryOp;
+    private static evaluateUnaryOp;
+    private static evaluateFnCall;
+    private static evaluateRangeRef;
+    private static evaluateObjectLiteral;
+    private static evaluateArrayLiteral;
+    /** Convert value to boolean (for AND, OR, NOT) */
+    private static toBoolean;
+}

package/dist/types/_vendors/schemas/dynamicTable/engine/rules/expression/extract-deps.d.ts

@@ -0,0 +1,8 @@
+/**
+ * extractVarPaths — walks an AST and collects all variable dependency keys.
+ *
+ * Used by RuleRegistry to auto-populate Rule.valueDeps on addRule/updateRule.
+ * Collects Var node paths (e.g. "cell.value") and RangeRef notations (e.g. "col:0").
+ */
+import type { ExprNode } from './ast.types';
+export declare function extractVarPaths(ast: ExprNode): string[];

package/dist/types/_vendors/schemas/dynamicTable/engine/rules/expression/functions/registry.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Function Registry — hardcoded FnCall definitions that the engine understands.
+ * Maps function names to implementations.
+ *
+ * Canvas uses the catalog to show autocomplete / pick-list.
+ * Engine uses implementations to evaluate FnCall nodes at runtime.
+ */
+import type { EvalContext } from '../../types/evaluation.types';
+export interface FnDef {
+    /** Function name */
+    name: string;
+    /** Human-readable signature (e.g., "SUM(range)") */
+    signature: string;
+    /** Description */
+    description: string;
+    /** Return type */
+    returnType: 'string' | 'number' | 'boolean';
+    /** Implementation: (resolvedArgs, context) => result */
+    fn: (args: any[], ctx: EvalContext) => string | number | boolean | null | undefined;
+}
+/**
+ * FunctionRegistry — manages custom function registration.
+ */
+export declare class FunctionRegistry {
+    private customFunctions;
+    constructor();
+    /**
+     * Register a custom function.
+     */
+    register(def: FnDef): void;
+    /**
+     * Get a function by name.
+     */
+    getFunction(name: string): FnDef | undefined;
+    /**
+     * Call a function with resolved arguments.
+     */
+    call(name: string, args: any[], ctx: EvalContext): any;
+    /**
+     * Get list of all available functions (for canvas UI).
+     */
+    getAvailableFunctions(): FnDef[];
+}
+/**
+ * Global singleton function registry.
+ */
+export declare const functionRegistry: FunctionRegistry;

package/dist/types/_vendors/schemas/dynamicTable/engine/rules/expression/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Barrel export for the expression evaluator module.
+ */
+export type { ExprNode, LiteralNode, VarNode, BinaryOpNode, UnaryOpNode, FnCallNode, RangeRefNode, ObjectLiteralNode, ArrayLiteralNode, } from './ast.types';
+export { isLiteral, isVar, isBinaryOp, isUnaryOp, isFnCall, isRangeRef, isObjectLiteral, isArrayLiteral, } from './ast.types';
+export type { Token, TokenType } from './lexer';
+export { Lexer } from './lexer';
+export { Parser, ParseError } from './parser';
+export { Evaluator, EvaluationError } from './evaluator';
+export { Compiler, tryCompile } from './compiler';
+export type { CompileError, ValidationResult } from './compiler';
+export { VAR_CATALOG, resolveVar, getAvailableVars } from './var-catalog';
+export type { VarDef } from './var-catalog';
+export { functionRegistry, FunctionRegistry } from './functions/registry';
+export type { FnDef } from './functions/registry';
+export { TextMeasurer } from './text-measurer';
+export { resolveRangeRef } from './range-resolver';
+export { extractVarPaths } from './extract-deps';
+export { SCOPE_VOCABULARY } from './scope-vocabulary';
+export type { PaletteItem, RuleScope } from './scope-vocabulary';

package/dist/types/_vendors/schemas/dynamicTable/engine/rules/expression/lexer.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Lexer — tokenizes expression strings into a token stream.
+ * Input: "cell.value > 100 AND SUM(col:0) == 0"
+ * Output: Token[] with type, value, and position info
+ */
+export type TokenType = 'Number' | 'String' | 'Identifier' | 'Keyword' | 'Dot' | 'LParen' | 'RParen' | 'LBrace' | 'RBrace' | 'LBracket' | 'RBracket' | 'Colon' | 'Comma' | 'Operator' | 'EOF';
+export interface Token {
+    type: TokenType;
+    value: string | number | boolean;
+    position: number;
+}
+/**
+ * Lexer class — tokenizes expression strings.
+ */
+export declare class Lexer {
+    private input;
+    private pos;
+    constructor(input: string);
+    /**
+     * Tokenize the input string into a Token array.
+     * Throws ParseError if invalid token encountered.
+     */
+    tokenize(): Token[];
+    /** Try to scan a multi-character operator */
+    private tryOperator;
+    private scanNumber;
+    private scanString;
+    private scanIdentifier;
+    private isKeyword;
+    private isWhitespace;
+    private isDigit;
+    private isIdentifierStart;
+    private isIdentifierPart;
+    private current;
+    private advance;
+}