@the-trybe/formula-engine 1.0.0

package/dist/types.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenType = exports.DecimalRoundingMode = void 0;
+// ============================================================================
+// Decimal Configuration
+// ============================================================================
+var DecimalRoundingMode;
+(function (DecimalRoundingMode) {
+    DecimalRoundingMode["CEIL"] = "CEIL";
+    DecimalRoundingMode["FLOOR"] = "FLOOR";
+    DecimalRoundingMode["DOWN"] = "DOWN";
+    DecimalRoundingMode["UP"] = "UP";
+    DecimalRoundingMode["HALF_UP"] = "HALF_UP";
+    DecimalRoundingMode["HALF_DOWN"] = "HALF_DOWN";
+    DecimalRoundingMode["HALF_EVEN"] = "HALF_EVEN";
+    DecimalRoundingMode["HALF_ODD"] = "HALF_ODD";
+})(DecimalRoundingMode || (exports.DecimalRoundingMode = DecimalRoundingMode = {}));
+// ============================================================================
+// Token Types
+// ============================================================================
+var TokenType;
+(function (TokenType) {
+    // Literals
+    TokenType["NUMBER"] = "NUMBER";
+    TokenType["STRING"] = "STRING";
+    TokenType["BOOLEAN"] = "BOOLEAN";
+    TokenType["NULL"] = "NULL";
+    // Identifiers and Variables
+    TokenType["IDENTIFIER"] = "IDENTIFIER";
+    TokenType["VARIABLE"] = "VARIABLE";
+    TokenType["CONTEXT_VAR"] = "CONTEXT_VAR";
+    // Operators
+    TokenType["PLUS"] = "PLUS";
+    TokenType["MINUS"] = "MINUS";
+    TokenType["MULTIPLY"] = "MULTIPLY";
+    TokenType["DIVIDE"] = "DIVIDE";
+    TokenType["MODULO"] = "MODULO";
+    TokenType["POWER"] = "POWER";
+    // Comparison
+    TokenType["EQ"] = "EQ";
+    TokenType["NEQ"] = "NEQ";
+    TokenType["LT"] = "LT";
+    TokenType["GT"] = "GT";
+    TokenType["LTE"] = "LTE";
+    TokenType["GTE"] = "GTE";
+    // Logical
+    TokenType["AND"] = "AND";
+    TokenType["OR"] = "OR";
+    TokenType["NOT"] = "NOT";
+    // Punctuation
+    TokenType["LPAREN"] = "LPAREN";
+    TokenType["RPAREN"] = "RPAREN";
+    TokenType["LBRACKET"] = "LBRACKET";
+    TokenType["RBRACKET"] = "RBRACKET";
+    TokenType["COMMA"] = "COMMA";
+    TokenType["DOT"] = "DOT";
+    TokenType["QUESTION"] = "QUESTION";
+    TokenType["COLON"] = "COLON";
+    // Special
+    TokenType["EOF"] = "EOF";
+})(TokenType || (exports.TokenType = TokenType = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":";;;AAUA,+EAA+E;AAC/E,wBAAwB;AACxB,+EAA+E;AAE/E,IAAY,mBASX;AATD,WAAY,mBAAmB;IAC7B,oCAAa,CAAA;IACb,sCAAe,CAAA;IACf,oCAAa,CAAA;IACb,gCAAS,CAAA;IACT,0CAAmB,CAAA;IACnB,8CAAuB,CAAA;IACvB,8CAAuB,CAAA;IACvB,4CAAqB,CAAA;AACvB,CAAC,EATW,mBAAmB,mCAAnB,mBAAmB,QAS9B;AA0QD,+EAA+E;AAC/E,cAAc;AACd,+EAA+E;AAE/E,IAAY,SA6CX;AA7CD,WAAY,SAAS;IACnB,WAAW;IACX,8BAAiB,CAAA;IACjB,8BAAiB,CAAA;IACjB,gCAAmB,CAAA;IACnB,0BAAa,CAAA;IAEb,4BAA4B;IAC5B,sCAAyB,CAAA;IACzB,kCAAqB,CAAA;IACrB,wCAA2B,CAAA;IAE3B,YAAY;IACZ,0BAAa,CAAA;IACb,4BAAe,CAAA;IACf,kCAAqB,CAAA;IACrB,8BAAiB,CAAA;IACjB,8BAAiB,CAAA;IACjB,4BAAe,CAAA;IAEf,aAAa;IACb,sBAAS,CAAA;IACT,wBAAW,CAAA;IACX,sBAAS,CAAA;IACT,sBAAS,CAAA;IACT,wBAAW,CAAA;IACX,wBAAW,CAAA;IAEX,UAAU;IACV,wBAAW,CAAA;IACX,sBAAS,CAAA;IACT,wBAAW,CAAA;IAEX,cAAc;IACd,8BAAiB,CAAA;IACjB,8BAAiB,CAAA;IACjB,kCAAqB,CAAA;IACrB,kCAAqB,CAAA;IACrB,4BAAe,CAAA;IACf,wBAAW,CAAA;IACX,kCAAqB,CAAA;IACrB,4BAAe,CAAA;IAEf,UAAU;IACV,wBAAW,CAAA;AACb,CAAC,EA7CW,SAAS,yBAAT,SAAS,QA6CpB","sourcesContent":["import { Decimal } from 'decimal.js';\n\n// ============================================================================\n// Value Types\n// ============================================================================\n\nexport type ValueType = 'number' | 'decimal' | 'string' | 'boolean' | 'array' | 'object' | 'null' | 'any';\n\nexport type FormulaValue = Decimal | number | string | boolean | null | FormulaValue[] | { [key: string]: FormulaValue };\n\n// ============================================================================\n// Decimal Configuration\n// ============================================================================\n\nexport enum DecimalRoundingMode {\n  CEIL = 'CEIL',\n  FLOOR = 'FLOOR',\n  DOWN = 'DOWN',\n  UP = 'UP',\n  HALF_UP = 'HALF_UP',\n  HALF_DOWN = 'HALF_DOWN',\n  HALF_EVEN = 'HALF_EVEN',\n  HALF_ODD = 'HALF_ODD',\n}\n\nexport interface DecimalConfig {\n  precision?: number;\n  roundingMode?: DecimalRoundingMode;\n  divisionScale?: number;\n  preserveTrailingZeros?: boolean;\n  autoConvertFloats?: boolean;\n  maxExponent?: number;\n  minExponent?: number;\n}\n\n// ============================================================================\n// Rounding Configuration\n// ============================================================================\n\nexport interface RoundingConfig {\n  mode: 'HALF_UP' | 'HALF_DOWN' | 'FLOOR' | 'CEIL' | 'NONE';\n  precision: number;\n}\n\n// ============================================================================\n// Error Behavior\n// ============================================================================\n\nexport interface ErrorBehavior {\n  type: 'THROW' | 'NULL' | 'ZERO' | 'DEFAULT' | 'SKIP';\n  defaultValue?: unknown;\n}\n\n// ============================================================================\n// Formula Definition\n// ============================================================================\n\nexport interface FormulaDefinition {\n  id: string;\n  expression: string;\n  dependencies?: string[];\n  onError?: ErrorBehavior;\n  defaultValue?: unknown;\n  rounding?: RoundingConfig;\n  metadata?: Record<string, unknown>;\n}\n\n// ============================================================================\n// Evaluation Context\n// ============================================================================\n\nexport interface EvaluationContext {\n  variables: Record<string, unknown>;\n  collections?: Record<string, unknown[]>;\n  extra?: Record<string, unknown>;\n}\n\n// ============================================================================\n// Engine Configuration\n// ============================================================================\n\nexport interface OperatorDefinition {\n  symbol: string;\n  precedence: number;\n  associativity: 'left' | 'right';\n  handler: (left: unknown, right: unknown) => unknown;\n}\n\nexport interface SecurityConfig {\n  maxExpressionLength?: number;\n  maxRecursionDepth?: number;\n  maxIterations?: number;\n  maxExecutionTime?: number;\n  allowedFunctions?: string[];\n  blockedFunctions?: string[];\n}\n\nexport interface FormulaEngineConfig {\n  enableCache?: boolean;\n  maxCacheSize?: number;\n  defaultErrorBehavior?: ErrorBehavior;\n  defaultRounding?: RoundingConfig;\n  variablePrefix?: string;\n  contextPrefix?: string;\n  strictMode?: boolean;\n  operators?: OperatorDefinition[];\n  functions?: FunctionDefinition[];\n  decimal?: DecimalConfig;\n  security?: SecurityConfig;\n}\n\n// ============================================================================\n// AST Node Types\n// ============================================================================\n\nexport interface DecimalLiteral {\n  type: 'DecimalLiteral';\n  value: string;\n  raw: string;\n}\n\nexport interface NumberLiteral {\n  type: 'NumberLiteral';\n  value: number;\n}\n\nexport interface StringLiteral {\n  type: 'StringLiteral';\n  value: string;\n}\n\nexport interface BooleanLiteral {\n  type: 'BooleanLiteral';\n  value: boolean;\n}\n\nexport interface NullLiteral {\n  type: 'NullLiteral';\n}\n\nexport interface ArrayLiteral {\n  type: 'ArrayLiteral';\n  elements: ASTNode[];\n}\n\nexport interface VariableReference {\n  type: 'VariableReference';\n  prefix: '$' | '@';\n  name: string;\n}\n\nexport interface BinaryOperation {\n  type: 'BinaryOperation';\n  operator: string;\n  left: ASTNode;\n  right: ASTNode;\n}\n\nexport interface UnaryOperation {\n  type: 'UnaryOperation';\n  operator: string;\n  operand: ASTNode;\n}\n\nexport interface ConditionalExpression {\n  type: 'ConditionalExpression';\n  condition: ASTNode;\n  consequent: ASTNode;\n  alternate: ASTNode;\n}\n\nexport interface FunctionCall {\n  type: 'FunctionCall';\n  name: string;\n  arguments: ASTNode[];\n}\n\nexport interface MemberAccess {\n  type: 'MemberAccess';\n  object: ASTNode;\n  property: string;\n}\n\nexport interface IndexAccess {\n  type: 'IndexAccess';\n  object: ASTNode;\n  index: ASTNode;\n}\n\nexport type ASTNode =\n  | DecimalLiteral\n  | NumberLiteral\n  | StringLiteral\n  | BooleanLiteral\n  | NullLiteral\n  | ArrayLiteral\n  | VariableReference\n  | BinaryOperation\n  | UnaryOperation\n  | ConditionalExpression\n  | FunctionCall\n  | MemberAccess\n  | IndexAccess;\n\n// ============================================================================\n// Function Definition\n// ============================================================================\n\nexport interface ArgumentType {\n  name: string;\n  type: ValueType;\n  required: boolean;\n  default?: unknown;\n}\n\nexport type FunctionImplementation = (\n  args: unknown[],\n  context: EvaluationContext,\n  engine: unknown\n) => unknown;\n\nexport interface FunctionDefinition {\n  name: string;\n  minArgs: number;\n  maxArgs: number;\n  argTypes?: ArgumentType[];\n  returnType: ValueType;\n  implementation: FunctionImplementation;\n  description?: string;\n}\n\n// ============================================================================\n// Dependency Graph\n// ============================================================================\n\nexport interface DependencyGraph {\n  nodes: Set<string>;\n  edges: Map<string, Set<string>>;\n  hasCycles(): boolean;\n  getRoots(): Set<string>;\n  getDependents(nodeId: string): Set<string>;\n  getDependencies(nodeId: string): Set<string>;\n  getTransitiveDependencies(nodeId: string): Set<string>;\n  topologicalSort(): string[];\n}\n\n// ============================================================================\n// Evaluation Results\n// ============================================================================\n\nexport interface EvaluationResult {\n  value: unknown;\n  success: boolean;\n  error?: Error;\n  executionTimeMs: number;\n  accessedVariables: Set<string>;\n}\n\nexport interface EvaluationResultSet {\n  results: Map<string, EvaluationResult>;\n  success: boolean;\n  errors: Error[];\n  totalExecutionTimeMs: number;\n  evaluationOrder: string[];\n}\n\n// ============================================================================\n// Validation Result\n// ============================================================================\n\nexport interface ValidationResult {\n  valid: boolean;\n  errors: Error[];\n  warnings: string[];\n  dependencyGraph: DependencyGraph;\n  evaluationOrder: string[];\n}\n\n// ============================================================================\n// Cache Statistics\n// ============================================================================\n\nexport interface CacheStats {\n  size: number;\n  hits: number;\n  misses: number;\n  hitRate: number;\n}\n\n// ============================================================================\n// Token Types\n// ============================================================================\n\nexport enum TokenType {\n  // Literals\n  NUMBER = 'NUMBER',\n  STRING = 'STRING',\n  BOOLEAN = 'BOOLEAN',\n  NULL = 'NULL',\n\n  // Identifiers and Variables\n  IDENTIFIER = 'IDENTIFIER',\n  VARIABLE = 'VARIABLE',\n  CONTEXT_VAR = 'CONTEXT_VAR',\n\n  // Operators\n  PLUS = 'PLUS',\n  MINUS = 'MINUS',\n  MULTIPLY = 'MULTIPLY',\n  DIVIDE = 'DIVIDE',\n  MODULO = 'MODULO',\n  POWER = 'POWER',\n\n  // Comparison\n  EQ = 'EQ',\n  NEQ = 'NEQ',\n  LT = 'LT',\n  GT = 'GT',\n  LTE = 'LTE',\n  GTE = 'GTE',\n\n  // Logical\n  AND = 'AND',\n  OR = 'OR',\n  NOT = 'NOT',\n\n  // Punctuation\n  LPAREN = 'LPAREN',\n  RPAREN = 'RPAREN',\n  LBRACKET = 'LBRACKET',\n  RBRACKET = 'RBRACKET',\n  COMMA = 'COMMA',\n  DOT = 'DOT',\n  QUESTION = 'QUESTION',\n  COLON = 'COLON',\n\n  // Special\n  EOF = 'EOF',\n}\n\nexport interface Token {\n  type: TokenType;\n  value: string | number | boolean | null;\n  position: number;\n  line: number;\n  column: number;\n}\n"]}

package/jest.config.js

@@ -0,0 +1,23 @@
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  roots: ['<rootDir>/src'],
+  testMatch: ['**/*.test.ts'],
+  collectCoverageFrom: [
+    'src/**/*.ts',
+    '!src/**/*.test.ts',
+    '!src/index.ts'
+  ],
+  coverageThreshold: {
+    global: {
+      branches: 80,
+      functions: 80,
+      lines: 80,
+      statements: 80
+    }
+  },
+  moduleFileExtensions: ['ts', 'js', 'json'],
+  transform: {
+    '^.+\\.ts$': 'ts-jest'
+  }
+};

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@the-trybe/formula-engine",
+  "version": "1.0.0",
+  "description": "Configuration-driven expression evaluation system with dependency resolution and decimal precision",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "lint": "eslint src --ext .ts",
+    "clean": "rm -rf dist"
+  },
+  "keywords": [
+    "formula",
+    "expression",
+    "parser",
+    "evaluator",
+    "dependency-graph",
+    "decimal"
+  ],
+  "author": "",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/jest": "^29.5.11",
+    "@types/node": "^20.10.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.1",
+    "typescript": "^5.3.0"
+  },
+  "dependencies": {
+    "decimal.js": "^10.4.3"
+  }
+}

package/src/decimal-utils.ts

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

package/src/dependency-extractor.ts

@@ -0,0 +1,117 @@
+import { ASTNode } from './types';
+import { Parser } from './parser';
+
+export class DependencyExtractor {
+  private parser: Parser;
+
+  constructor() {
+    this.parser = new Parser();
+  }
+
+  /**
+   * Extract all variable dependencies from an expression string
+   * Returns a set of variable names (without the $ or @ prefix)
+   */
+  extract(expression: string): Set<string> {
+    const ast = this.parser.parse(expression);
+    return this.extractFromNode(ast);
+  }
+
+  /**
+   * Extract dependencies from an AST node
+   */
+  extractFromNode(node: ASTNode): Set<string> {
+    const dependencies = new Set<string>();
+    this.visit(node, dependencies);
+    return dependencies;
+  }
+
+  private visit(node: ASTNode, dependencies: Set<string>): void {
+    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'
+   */
+  private visitMemberRoot(node: ASTNode, dependencies: Set<string>): void {
+    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;
+    }
+  }
+}