@the-trybe/formula-engine 1.0.0

package/dist/decimal-utils.js

@@ -0,0 +1,355 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Decimal = exports.decimalUtils = exports.DecimalUtils = void 0;
+const decimal_js_1 = __importDefault(require("decimal.js"));
+exports.Decimal = decimal_js_1.default;
+const types_1 = require("./types");
+const errors_1 = require("./errors");
+// Map our rounding modes to decimal.js rounding modes
+const ROUNDING_MODE_MAP = {
+    [types_1.DecimalRoundingMode.CEIL]: decimal_js_1.default.ROUND_CEIL,
+    [types_1.DecimalRoundingMode.FLOOR]: decimal_js_1.default.ROUND_FLOOR,
+    [types_1.DecimalRoundingMode.DOWN]: decimal_js_1.default.ROUND_DOWN,
+    [types_1.DecimalRoundingMode.UP]: decimal_js_1.default.ROUND_UP,
+    [types_1.DecimalRoundingMode.HALF_UP]: decimal_js_1.default.ROUND_HALF_UP,
+    [types_1.DecimalRoundingMode.HALF_DOWN]: decimal_js_1.default.ROUND_HALF_DOWN,
+    [types_1.DecimalRoundingMode.HALF_EVEN]: decimal_js_1.default.ROUND_HALF_EVEN,
+    [types_1.DecimalRoundingMode.HALF_ODD]: decimal_js_1.default.ROUND_HALF_CEIL, // decimal.js doesn't have HALF_ODD, use HALF_CEIL as approximation
+};
+const DEFAULT_CONFIG = {
+    precision: 20,
+    roundingMode: types_1.DecimalRoundingMode.HALF_UP,
+    divisionScale: 10,
+    maxExponent: 1000,
+    minExponent: -1000,
+};
+class DecimalUtils {
+    constructor(config) {
+        this.config = {
+            ...DEFAULT_CONFIG,
+            ...config,
+        };
+        // Configure decimal.js globally
+        decimal_js_1.default.set({
+            precision: this.config.precision,
+            rounding: ROUNDING_MODE_MAP[this.config.roundingMode],
+            toExpNeg: this.config.minExponent,
+            toExpPos: this.config.maxExponent,
+        });
+    }
+    /**
+     * Create a Decimal from various input types
+     */
+    from(value) {
+        if (value instanceof decimal_js_1.default) {
+            return value;
+        }
+        try {
+            if (typeof value === 'bigint') {
+                return new decimal_js_1.default(value.toString());
+            }
+            return new decimal_js_1.default(value);
+        }
+        catch {
+            throw new errors_1.InvalidDecimalError(String(value));
+        }
+    }
+    /**
+     * Check if a value is a Decimal
+     */
+    isDecimal(value) {
+        return value instanceof decimal_js_1.default;
+    }
+    /**
+     * Convert a value to Decimal if it's numeric
+     */
+    toDecimal(value) {
+        if (value instanceof decimal_js_1.default) {
+            return value;
+        }
+        if (typeof value === 'number' && !isNaN(value) && isFinite(value)) {
+            return new decimal_js_1.default(value);
+        }
+        if (typeof value === 'string') {
+            const trimmed = value.trim();
+            if (/^-?\d+\.?\d*$/.test(trimmed) || /^-?\d*\.?\d+$/.test(trimmed)) {
+                try {
+                    return new decimal_js_1.default(trimmed);
+                }
+                catch {
+                    return value;
+                }
+            }
+        }
+        if (typeof value === 'bigint') {
+            return new decimal_js_1.default(value.toString());
+        }
+        return value;
+    }
+    /**
+     * Addition
+     */
+    add(a, b) {
+        return this.from(a).plus(this.from(b));
+    }
+    /**
+     * Subtraction
+     */
+    subtract(a, b) {
+        return this.from(a).minus(this.from(b));
+    }
+    /**
+     * Multiplication
+     */
+    multiply(a, b) {
+        return this.from(a).times(this.from(b));
+    }
+    /**
+     * Division with scale
+     */
+    divide(a, b, scale, roundingMode) {
+        const divisor = this.from(b);
+        if (divisor.isZero()) {
+            throw new errors_1.DecimalDivisionByZeroError();
+        }
+        const result = this.from(a).dividedBy(divisor);
+        if (scale !== undefined) {
+            const rounding = roundingMode
+                ? ROUNDING_MODE_MAP[roundingMode]
+                : ROUNDING_MODE_MAP[this.config.roundingMode];
+            return result.toDecimalPlaces(scale, rounding);
+        }
+        return result.toDecimalPlaces(this.config.divisionScale, ROUNDING_MODE_MAP[this.config.roundingMode]);
+    }
+    /**
+     * Modulo
+     */
+    modulo(a, b) {
+        const divisor = this.from(b);
+        if (divisor.isZero()) {
+            throw new errors_1.DecimalDivisionByZeroError();
+        }
+        return this.from(a).modulo(divisor);
+    }
+    /**
+     * Power
+     */
+    power(base, exponent) {
+        return this.from(base).pow(exponent);
+    }
+    /**
+     * Negation
+     */
+    negate(value) {
+        return this.from(value).negated();
+    }
+    /**
+     * Absolute value
+     */
+    abs(value) {
+        return this.from(value).absoluteValue();
+    }
+    /**
+     * Round to specified decimal places
+     */
+    round(value, scale, roundingMode) {
+        const rounding = roundingMode
+            ? ROUNDING_MODE_MAP[roundingMode]
+            : ROUNDING_MODE_MAP[this.config.roundingMode];
+        return this.from(value).toDecimalPlaces(scale, rounding);
+    }
+    /**
+     * Floor to specified decimal places
+     */
+    floor(value, scale = 0) {
+        return this.from(value).toDecimalPlaces(scale, decimal_js_1.default.ROUND_FLOOR);
+    }
+    /**
+     * Ceiling to specified decimal places
+     */
+    ceil(value, scale = 0) {
+        return this.from(value).toDecimalPlaces(scale, decimal_js_1.default.ROUND_CEIL);
+    }
+    /**
+     * Truncate to specified decimal places
+     */
+    truncate(value, scale = 0) {
+        return this.from(value).toDecimalPlaces(scale, decimal_js_1.default.ROUND_DOWN);
+    }
+    /**
+     * Square root
+     */
+    sqrt(value) {
+        return this.from(value).sqrt();
+    }
+    /**
+     * Natural logarithm
+     */
+    ln(value) {
+        return this.from(value).ln();
+    }
+    /**
+     * Base-10 logarithm
+     */
+    log10(value) {
+        return this.from(value).log(10);
+    }
+    /**
+     * Comparison: returns -1, 0, or 1
+     */
+    compare(a, b) {
+        const result = this.from(a).comparedTo(this.from(b));
+        return result;
+    }
+    /**
+     * Equality check
+     */
+    equals(a, b) {
+        return this.from(a).equals(this.from(b));
+    }
+    /**
+     * Greater than
+     */
+    greaterThan(a, b) {
+        return this.from(a).greaterThan(this.from(b));
+    }
+    /**
+     * Greater than or equal
+     */
+    greaterThanOrEqual(a, b) {
+        return this.from(a).greaterThanOrEqualTo(this.from(b));
+    }
+    /**
+     * Less than
+     */
+    lessThan(a, b) {
+        return this.from(a).lessThan(this.from(b));
+    }
+    /**
+     * Less than or equal
+     */
+    lessThanOrEqual(a, b) {
+        return this.from(a).lessThanOrEqualTo(this.from(b));
+    }
+    /**
+     * Check if zero
+     */
+    isZero(value) {
+        return this.from(value).isZero();
+    }
+    /**
+     * Check if positive
+     */
+    isPositive(value) {
+        return this.from(value).isPositive();
+    }
+    /**
+     * Check if negative
+     */
+    isNegative(value) {
+        return this.from(value).isNegative();
+    }
+    /**
+     * Check if integer
+     */
+    isInteger(value) {
+        return this.from(value).isInteger();
+    }
+    /**
+     * Get sign: -1, 0, or 1
+     */
+    sign(value) {
+        const d = this.from(value);
+        if (d.isZero())
+            return 0;
+        return d.isNegative() ? -1 : 1;
+    }
+    /**
+     * Get precision (total significant digits)
+     */
+    precision(value) {
+        return this.from(value).precision();
+    }
+    /**
+     * Get scale (decimal places)
+     */
+    scale(value) {
+        return this.from(value).decimalPlaces();
+    }
+    /**
+     * Convert to JavaScript number (may lose precision)
+     */
+    toNumber(value) {
+        return this.from(value).toNumber();
+    }
+    /**
+     * Convert to string
+     */
+    toString(value) {
+        return this.from(value).toString();
+    }
+    /**
+     * Convert to fixed decimal places string
+     */
+    toFixed(value, scale) {
+        return this.from(value).toFixed(scale);
+    }
+    /**
+     * Minimum of values
+     */
+    min(...values) {
+        if (values.length === 0) {
+            throw new Error('min requires at least one argument');
+        }
+        return decimal_js_1.default.min(...values.map(v => this.from(v)));
+    }
+    /**
+     * Maximum of values
+     */
+    max(...values) {
+        if (values.length === 0) {
+            throw new Error('max requires at least one argument');
+        }
+        return decimal_js_1.default.max(...values.map(v => this.from(v)));
+    }
+    /**
+     * Sum of values
+     */
+    sum(values) {
+        return values.reduce((acc, v) => acc.plus(this.from(v)), new decimal_js_1.default(0));
+    }
+    /**
+     * Average of values
+     */
+    avg(values) {
+        if (values.length === 0) {
+            throw new Error('avg requires at least one value');
+        }
+        return this.sum(values).dividedBy(values.length);
+    }
+    /**
+     * Product of values
+     */
+    product(values) {
+        return values.reduce((acc, v) => acc.times(this.from(v)), new decimal_js_1.default(1));
+    }
+    /**
+     * Create zero
+     */
+    zero() {
+        return new decimal_js_1.default(0);
+    }
+    /**
+     * Create one
+     */
+    one() {
+        return new decimal_js_1.default(1);
+    }
+}
+exports.DecimalUtils = DecimalUtils;
+// Export a default instance
+exports.decimalUtils = new DecimalUtils();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"decimal-utils.js","sourceRoot":"","sources":["../src/decimal-utils.ts"],"names":[],"mappings":"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","sourcesContent":["import Decimal from 'decimal.js';\nimport { DecimalConfig, DecimalRoundingMode } from './types';\nimport { InvalidDecimalError, DecimalDivisionByZeroError } from './errors';\n\n// Map our rounding modes to decimal.js rounding modes\nconst ROUNDING_MODE_MAP: Record<DecimalRoundingMode, Decimal.Rounding> = {\n  [DecimalRoundingMode.CEIL]: Decimal.ROUND_CEIL,\n  [DecimalRoundingMode.FLOOR]: Decimal.ROUND_FLOOR,\n  [DecimalRoundingMode.DOWN]: Decimal.ROUND_DOWN,\n  [DecimalRoundingMode.UP]: Decimal.ROUND_UP,\n  [DecimalRoundingMode.HALF_UP]: Decimal.ROUND_HALF_UP,\n  [DecimalRoundingMode.HALF_DOWN]: Decimal.ROUND_HALF_DOWN,\n  [DecimalRoundingMode.HALF_EVEN]: Decimal.ROUND_HALF_EVEN,\n  [DecimalRoundingMode.HALF_ODD]: Decimal.ROUND_HALF_CEIL, // decimal.js doesn't have HALF_ODD, use HALF_CEIL as approximation\n};\n\nexport type DecimalLike = Decimal | string | number | bigint;\n\nexport interface DecimalUtilsConfig {\n  precision: number;\n  roundingMode: DecimalRoundingMode;\n  divisionScale: number;\n  maxExponent: number;\n  minExponent: number;\n}\n\nconst DEFAULT_CONFIG: DecimalUtilsConfig = {\n  precision: 20,\n  roundingMode: DecimalRoundingMode.HALF_UP,\n  divisionScale: 10,\n  maxExponent: 1000,\n  minExponent: -1000,\n};\n\nexport class DecimalUtils {\n  private config: DecimalUtilsConfig;\n\n  constructor(config?: Partial<DecimalConfig>) {\n    this.config = {\n      ...DEFAULT_CONFIG,\n      ...config,\n    };\n\n    // Configure decimal.js globally\n    Decimal.set({\n      precision: this.config.precision,\n      rounding: ROUNDING_MODE_MAP[this.config.roundingMode],\n      toExpNeg: this.config.minExponent,\n      toExpPos: this.config.maxExponent,\n    });\n  }\n\n  /**\n   * Create a Decimal from various input types\n   */\n  from(value: DecimalLike): Decimal {\n    if (value instanceof Decimal) {\n      return value;\n    }\n\n    try {\n      if (typeof value === 'bigint') {\n        return new Decimal(value.toString());\n      }\n      return new Decimal(value);\n    } catch {\n      throw new InvalidDecimalError(String(value));\n    }\n  }\n\n  /**\n   * Check if a value is a Decimal\n   */\n  isDecimal(value: unknown): value is Decimal {\n    return value instanceof Decimal;\n  }\n\n  /**\n   * Convert a value to Decimal if it's numeric\n   */\n  toDecimal(value: unknown): Decimal | unknown {\n    if (value instanceof Decimal) {\n      return value;\n    }\n    if (typeof value === 'number' && !isNaN(value) && isFinite(value)) {\n      return new Decimal(value);\n    }\n    if (typeof value === 'string') {\n      const trimmed = value.trim();\n      if (/^-?\\d+\\.?\\d*$/.test(trimmed) || /^-?\\d*\\.?\\d+$/.test(trimmed)) {\n        try {\n          return new Decimal(trimmed);\n        } catch {\n          return value;\n        }\n      }\n    }\n    if (typeof value === 'bigint') {\n      return new Decimal(value.toString());\n    }\n    return value;\n  }\n\n  /**\n   * Addition\n   */\n  add(a: DecimalLike, b: DecimalLike): Decimal {\n    return this.from(a).plus(this.from(b));\n  }\n\n  /**\n   * Subtraction\n   */\n  subtract(a: DecimalLike, b: DecimalLike): Decimal {\n    return this.from(a).minus(this.from(b));\n  }\n\n  /**\n   * Multiplication\n   */\n  multiply(a: DecimalLike, b: DecimalLike): Decimal {\n    return this.from(a).times(this.from(b));\n  }\n\n  /**\n   * Division with scale\n   */\n  divide(a: DecimalLike, b: DecimalLike, scale?: number, roundingMode?: DecimalRoundingMode): Decimal {\n    const divisor = this.from(b);\n    if (divisor.isZero()) {\n      throw new DecimalDivisionByZeroError();\n    }\n\n    const result = this.from(a).dividedBy(divisor);\n\n    if (scale !== undefined) {\n      const rounding = roundingMode\n        ? ROUNDING_MODE_MAP[roundingMode]\n        : ROUNDING_MODE_MAP[this.config.roundingMode];\n      return result.toDecimalPlaces(scale, rounding);\n    }\n\n    return result.toDecimalPlaces(this.config.divisionScale, ROUNDING_MODE_MAP[this.config.roundingMode]);\n  }\n\n  /**\n   * Modulo\n   */\n  modulo(a: DecimalLike, b: DecimalLike): Decimal {\n    const divisor = this.from(b);\n    if (divisor.isZero()) {\n      throw new DecimalDivisionByZeroError();\n    }\n    return this.from(a).modulo(divisor);\n  }\n\n  /**\n   * Power\n   */\n  power(base: DecimalLike, exponent: number): Decimal {\n    return this.from(base).pow(exponent);\n  }\n\n  /**\n   * Negation\n   */\n  negate(value: DecimalLike): Decimal {\n    return this.from(value).negated();\n  }\n\n  /**\n   * Absolute value\n   */\n  abs(value: DecimalLike): Decimal {\n    return this.from(value).absoluteValue();\n  }\n\n  /**\n   * Round to specified decimal places\n   */\n  round(value: DecimalLike, scale: number, roundingMode?: DecimalRoundingMode): Decimal {\n    const rounding = roundingMode\n      ? ROUNDING_MODE_MAP[roundingMode]\n      : ROUNDING_MODE_MAP[this.config.roundingMode];\n    return this.from(value).toDecimalPlaces(scale, rounding);\n  }\n\n  /**\n   * Floor to specified decimal places\n   */\n  floor(value: DecimalLike, scale: number = 0): Decimal {\n    return this.from(value).toDecimalPlaces(scale, Decimal.ROUND_FLOOR);\n  }\n\n  /**\n   * Ceiling to specified decimal places\n   */\n  ceil(value: DecimalLike, scale: number = 0): Decimal {\n    return this.from(value).toDecimalPlaces(scale, Decimal.ROUND_CEIL);\n  }\n\n  /**\n   * Truncate to specified decimal places\n   */\n  truncate(value: DecimalLike, scale: number = 0): Decimal {\n    return this.from(value).toDecimalPlaces(scale, Decimal.ROUND_DOWN);\n  }\n\n  /**\n   * Square root\n   */\n  sqrt(value: DecimalLike): Decimal {\n    return this.from(value).sqrt();\n  }\n\n  /**\n   * Natural logarithm\n   */\n  ln(value: DecimalLike): Decimal {\n    return this.from(value).ln();\n  }\n\n  /**\n   * Base-10 logarithm\n   */\n  log10(value: DecimalLike): Decimal {\n    return this.from(value).log(10);\n  }\n\n  /**\n   * Comparison: returns -1, 0, or 1\n   */\n  compare(a: DecimalLike, b: DecimalLike): -1 | 0 | 1 {\n    const result = this.from(a).comparedTo(this.from(b));\n    return result as -1 | 0 | 1;\n  }\n\n  /**\n   * Equality check\n   */\n  equals(a: DecimalLike, b: DecimalLike): boolean {\n    return this.from(a).equals(this.from(b));\n  }\n\n  /**\n   * Greater than\n   */\n  greaterThan(a: DecimalLike, b: DecimalLike): boolean {\n    return this.from(a).greaterThan(this.from(b));\n  }\n\n  /**\n   * Greater than or equal\n   */\n  greaterThanOrEqual(a: DecimalLike, b: DecimalLike): boolean {\n    return this.from(a).greaterThanOrEqualTo(this.from(b));\n  }\n\n  /**\n   * Less than\n   */\n  lessThan(a: DecimalLike, b: DecimalLike): boolean {\n    return this.from(a).lessThan(this.from(b));\n  }\n\n  /**\n   * Less than or equal\n   */\n  lessThanOrEqual(a: DecimalLike, b: DecimalLike): boolean {\n    return this.from(a).lessThanOrEqualTo(this.from(b));\n  }\n\n  /**\n   * Check if zero\n   */\n  isZero(value: DecimalLike): boolean {\n    return this.from(value).isZero();\n  }\n\n  /**\n   * Check if positive\n   */\n  isPositive(value: DecimalLike): boolean {\n    return this.from(value).isPositive();\n  }\n\n  /**\n   * Check if negative\n   */\n  isNegative(value: DecimalLike): boolean {\n    return this.from(value).isNegative();\n  }\n\n  /**\n   * Check if integer\n   */\n  isInteger(value: DecimalLike): boolean {\n    return this.from(value).isInteger();\n  }\n\n  /**\n   * Get sign: -1, 0, or 1\n   */\n  sign(value: DecimalLike): -1 | 0 | 1 {\n    const d = this.from(value);\n    if (d.isZero()) return 0;\n    return d.isNegative() ? -1 : 1;\n  }\n\n  /**\n   * Get precision (total significant digits)\n   */\n  precision(value: DecimalLike): number {\n    return this.from(value).precision();\n  }\n\n  /**\n   * Get scale (decimal places)\n   */\n  scale(value: DecimalLike): number {\n    return this.from(value).decimalPlaces();\n  }\n\n  /**\n   * Convert to JavaScript number (may lose precision)\n   */\n  toNumber(value: DecimalLike): number {\n    return this.from(value).toNumber();\n  }\n\n  /**\n   * Convert to string\n   */\n  toString(value: DecimalLike): string {\n    return this.from(value).toString();\n  }\n\n  /**\n   * Convert to fixed decimal places string\n   */\n  toFixed(value: DecimalLike, scale: number): string {\n    return this.from(value).toFixed(scale);\n  }\n\n  /**\n   * Minimum of values\n   */\n  min(...values: DecimalLike[]): Decimal {\n    if (values.length === 0) {\n      throw new Error('min requires at least one argument');\n    }\n    return Decimal.min(...values.map(v => this.from(v)));\n  }\n\n  /**\n   * Maximum of values\n   */\n  max(...values: DecimalLike[]): Decimal {\n    if (values.length === 0) {\n      throw new Error('max requires at least one argument');\n    }\n    return Decimal.max(...values.map(v => this.from(v)));\n  }\n\n  /**\n   * Sum of values\n   */\n  sum(values: DecimalLike[]): Decimal {\n    return values.reduce<Decimal>((acc, v) => acc.plus(this.from(v)), new Decimal(0));\n  }\n\n  /**\n   * Average of values\n   */\n  avg(values: DecimalLike[]): Decimal {\n    if (values.length === 0) {\n      throw new Error('avg requires at least one value');\n    }\n    return this.sum(values).dividedBy(values.length);\n  }\n\n  /**\n   * Product of values\n   */\n  product(values: DecimalLike[]): Decimal {\n    return values.reduce<Decimal>((acc, v) => acc.times(this.from(v)), new Decimal(1));\n  }\n\n  /**\n   * Create zero\n   */\n  zero(): Decimal {\n    return new Decimal(0);\n  }\n\n  /**\n   * Create one\n   */\n  one(): Decimal {\n    return new Decimal(1);\n  }\n}\n\n// Export a default instance\nexport const decimalUtils = new DecimalUtils();\n\n// Re-export Decimal type for convenience\nexport { Decimal };\n"]}

package/dist/dependency-extractor.d.ts

@@ -0,0 +1,20 @@
+import { ASTNode } from './types';
+export declare class DependencyExtractor {
+    private parser;
+    constructor();
+    /**
+     * Extract all variable dependencies from an expression string
+     * Returns a set of variable names (without the $ or @ prefix)
+     */
+    extract(expression: string): Set<string>;
+    /**
+     * Extract dependencies from an AST node
+     */
+    extractFromNode(node: ASTNode): Set<string>;
+    private visit;
+    /**
+     * Visit the root of a member/index access chain
+     * For $product.price.value, we want to extract 'product'
+     */
+    private visitMemberRoot;
+}

package/dist/dependency-extractor.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DependencyExtractor = void 0;
+const parser_1 = require("./parser");
+class DependencyExtractor {
+    constructor() {
+        this.parser = new parser_1.Parser();
+    }
+    /**
+     * Extract all variable dependencies from an expression string
+     * Returns a set of variable names (without the $ or @ prefix)
+     */
+    extract(expression) {
+        const ast = this.parser.parse(expression);
+        return this.extractFromNode(ast);
+    }
+    /**
+     * Extract dependencies from an AST node
+     */
+    extractFromNode(node) {
+        const dependencies = new Set();
+        this.visit(node, dependencies);
+        return dependencies;
+    }
+    visit(node, dependencies) {
+        switch (node.type) {
+            case 'VariableReference':
+                // Only extract $ prefixed variables (not @ context variables)
+                // Context variables are considered external and don't form part of the dependency graph
+                if (node.prefix === '$') {
+                    dependencies.add(node.name);
+                }
+                break;
+            case 'BinaryOperation':
+                this.visit(node.left, dependencies);
+                this.visit(node.right, dependencies);
+                break;
+            case 'UnaryOperation':
+                this.visit(node.operand, dependencies);
+                break;
+            case 'ConditionalExpression':
+                this.visit(node.condition, dependencies);
+                this.visit(node.consequent, dependencies);
+                this.visit(node.alternate, dependencies);
+                break;
+            case 'FunctionCall':
+                // Visit all function arguments
+                for (const arg of node.arguments) {
+                    this.visit(arg, dependencies);
+                }
+                break;
+            case 'MemberAccess':
+                // For member access like $product.price, we want to extract 'product'
+                // The root variable is what matters for dependency tracking
+                this.visitMemberRoot(node.object, dependencies);
+                break;
+            case 'IndexAccess':
+                // Similar to MemberAccess - extract the root variable
+                this.visitMemberRoot(node.object, dependencies);
+                // Also visit the index expression as it might contain variables
+                this.visit(node.index, dependencies);
+                break;
+            case 'ArrayLiteral':
+                for (const element of node.elements) {
+                    this.visit(element, dependencies);
+                }
+                break;
+            // Literals don't have dependencies
+            case 'DecimalLiteral':
+            case 'NumberLiteral':
+            case 'StringLiteral':
+            case 'BooleanLiteral':
+            case 'NullLiteral':
+                break;
+        }
+    }
+    /**
+     * Visit the root of a member/index access chain
+     * For $product.price.value, we want to extract 'product'
+     */
+    visitMemberRoot(node, dependencies) {
+        switch (node.type) {
+            case 'VariableReference':
+                if (node.prefix === '$') {
+                    dependencies.add(node.name);
+                }
+                break;
+            case 'MemberAccess':
+                this.visitMemberRoot(node.object, dependencies);
+                break;
+            case 'IndexAccess':
+                this.visitMemberRoot(node.object, dependencies);
+                this.visit(node.index, dependencies);
+                break;
+            default:
+                // For other node types (like function calls), visit normally
+                this.visit(node, dependencies);
+                break;
+        }
+    }
+}
+exports.DependencyExtractor = DependencyExtractor;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dependency-extractor.js","sourceRoot":"","sources":["../src/dependency-extractor.ts"],"names":[],"mappings":"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","sourcesContent":["import { ASTNode } from './types';\nimport { Parser } from './parser';\n\nexport class DependencyExtractor {\n  private parser: Parser;\n\n  constructor() {\n    this.parser = new Parser();\n  }\n\n  /**\n   * Extract all variable dependencies from an expression string\n   * Returns a set of variable names (without the $ or @ prefix)\n   */\n  extract(expression: string): Set<string> {\n    const ast = this.parser.parse(expression);\n    return this.extractFromNode(ast);\n  }\n\n  /**\n   * Extract dependencies from an AST node\n   */\n  extractFromNode(node: ASTNode): Set<string> {\n    const dependencies = new Set<string>();\n    this.visit(node, dependencies);\n    return dependencies;\n  }\n\n  private visit(node: ASTNode, dependencies: Set<string>): void {\n    switch (node.type) {\n      case 'VariableReference':\n        // Only extract $ prefixed variables (not @ context variables)\n        // Context variables are considered external and don't form part of the dependency graph\n        if (node.prefix === '$') {\n          dependencies.add(node.name);\n        }\n        break;\n\n      case 'BinaryOperation':\n        this.visit(node.left, dependencies);\n        this.visit(node.right, dependencies);\n        break;\n\n      case 'UnaryOperation':\n        this.visit(node.operand, dependencies);\n        break;\n\n      case 'ConditionalExpression':\n        this.visit(node.condition, dependencies);\n        this.visit(node.consequent, dependencies);\n        this.visit(node.alternate, dependencies);\n        break;\n\n      case 'FunctionCall':\n        // Visit all function arguments\n        for (const arg of node.arguments) {\n          this.visit(arg, dependencies);\n        }\n        break;\n\n      case 'MemberAccess':\n        // For member access like $product.price, we want to extract 'product'\n        // The root variable is what matters for dependency tracking\n        this.visitMemberRoot(node.object, dependencies);\n        break;\n\n      case 'IndexAccess':\n        // Similar to MemberAccess - extract the root variable\n        this.visitMemberRoot(node.object, dependencies);\n        // Also visit the index expression as it might contain variables\n        this.visit(node.index, dependencies);\n        break;\n\n      case 'ArrayLiteral':\n        for (const element of node.elements) {\n          this.visit(element, dependencies);\n        }\n        break;\n\n      // Literals don't have dependencies\n      case 'DecimalLiteral':\n      case 'NumberLiteral':\n      case 'StringLiteral':\n      case 'BooleanLiteral':\n      case 'NullLiteral':\n        break;\n    }\n  }\n\n  /**\n   * Visit the root of a member/index access chain\n   * For $product.price.value, we want to extract 'product'\n   */\n  private visitMemberRoot(node: ASTNode, dependencies: Set<string>): void {\n    switch (node.type) {\n      case 'VariableReference':\n        if (node.prefix === '$') {\n          dependencies.add(node.name);\n        }\n        break;\n\n      case 'MemberAccess':\n        this.visitMemberRoot(node.object, dependencies);\n        break;\n\n      case 'IndexAccess':\n        this.visitMemberRoot(node.object, dependencies);\n        this.visit(node.index, dependencies);\n        break;\n\n      default:\n        // For other node types (like function calls), visit normally\n        this.visit(node, dependencies);\n        break;\n    }\n  }\n}\n"]}

package/dist/dependency-graph.d.ts

@@ -0,0 +1,60 @@
+import { DependencyGraph as IDependencyGraph, FormulaDefinition } from './types';
+export declare class DependencyGraph implements IDependencyGraph {
+    nodes: Set<string>;
+    edges: Map<string, Set<string>>;
+    constructor();
+    /**
+     * Add a node to the graph
+     */
+    addNode(id: string): void;
+    /**
+     * Add an edge from source to target (source depends on target)
+     */
+    addEdge(source: string, target: string): void;
+    /**
+     * Check if the graph has any cycles
+     */
+    hasCycles(): boolean;
+    /**
+     * Get all root nodes (nodes with no dependencies)
+     */
+    getRoots(): Set<string>;
+    /**
+     * Get all nodes that depend on the given node
+     */
+    getDependents(nodeId: string): Set<string>;
+    /**
+     * Get direct dependencies of a node
+     */
+    getDependencies(nodeId: string): Set<string>;
+    /**
+     * Get all transitive dependencies of a node
+     */
+    getTransitiveDependencies(nodeId: string): Set<string>;
+    private collectTransitiveDependencies;
+    /**
+     * Perform topological sort using Kahn's algorithm
+     * Returns nodes in evaluation order (dependencies first)
+     * Throws CircularDependencyError if a cycle is detected
+     */
+    topologicalSort(): string[];
+    /**
+     * Find a cycle in the graph using DFS
+     */
+    private findCycle;
+}
+/**
+ * Build a dependency graph from formula definitions
+ */
+export declare class DependencyGraphBuilder {
+    private extractor;
+    constructor();
+    /**
+     * Build a dependency graph from formula definitions
+     */
+    build(formulas: FormulaDefinition[]): DependencyGraph;
+    /**
+     * Get the evaluation order for a set of formulas
+     */
+    getEvaluationOrder(formulas: FormulaDefinition[]): string[];
+}