@higher.archi/boe 1.0.0

package/dist/engines/pricing/index.js

@@ -0,0 +1,89 @@
+"use strict";
+/**
+ * Pricing Engine - Tiered/Graduated Pricing & Scenario Comparison
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   PricingEngine,
+ *   compilePricingRuleSet,
+ *   PricingRuleSet
+ * } from '@higher.archi/boe';
+ *
+ * const ruleSet: PricingRuleSet = {
+ *   id: 'cloud-pricing',
+ *   mode: 'pricing',
+ *   scenarios: {
+ *     definitions: {
+ *       light: { name: 'Light Usage' },
+ *       standard: { name: 'Standard Usage', isDefault: true },
+ *       heavy: { name: 'Heavy Usage' }
+ *     }
+ *   },
+ *   rules: [{
+ *     id: 'api-pricing',
+ *     pricing: {
+ *       mode: 'package',
+ *       components: [{
+ *         sku: 'api-requests',
+ *         scenarioValues: {
+ *           light: { requests: 100_000 },
+ *           standard: { requests: 1_000_000 },
+ *           heavy: { requests: 10_000_000 }
+ *         },
+ *         quantity: '$requests',
+ *         pricing: {
+ *           mode: 'graduated',
+ *           tiers: [
+ *             { upTo: 1_000_000, pricePerUnit: 0.0002 },
+ *             { upTo: 5_000_000, pricePerUnit: 0.0001 },
+ *             { upTo: Infinity, pricePerUnit: 0.00005 }
+ *           ]
+ *         }
+ *       }]
+ *     }
+ *   }]
+ * };
+ *
+ * const compiled = compilePricingRuleSet(ruleSet);
+ * const engine = new PricingEngine();
+ *
+ * // Single scenario
+ * const result = engine.calculate(compiled, 'api-pricing', { scenario: 'standard' });
+ * console.log(result.toString());
+ *
+ * // Compare all scenarios
+ * const comparison = engine.calculateScenarios(compiled, 'api-pricing');
+ * console.log(comparison.toString());
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pricingEngine = exports.PricingEngine = exports.pricingStrategy = exports.PricingStrategy = exports.applyMinMax = exports.calculateDiscount = exports.round = exports.formatPercent = exports.formatNumber = exports.formatCurrency = exports.calculateVolume = exports.calculateGraduated = exports.calculateFlat = exports.compilePricingRule = exports.compilePricingRuleSet = exports.getCurrencyInfo = exports.CURRENCIES = void 0;
+// Currency utilities
+var types_1 = require("./types");
+Object.defineProperty(exports, "CURRENCIES", { enumerable: true, get: function () { return types_1.CURRENCIES; } });
+Object.defineProperty(exports, "getCurrencyInfo", { enumerable: true, get: function () { return types_1.getCurrencyInfo; } });
+// Compiler
+var compiler_1 = require("./compiler");
+Object.defineProperty(exports, "compilePricingRuleSet", { enumerable: true, get: function () { return compiler_1.compilePricingRuleSet; } });
+Object.defineProperty(exports, "compilePricingRule", { enumerable: true, get: function () { return compiler_1.compilePricingRule; } });
+// Calculator utilities
+var calculator_1 = require("./calculator");
+Object.defineProperty(exports, "calculateFlat", { enumerable: true, get: function () { return calculator_1.calculateFlat; } });
+Object.defineProperty(exports, "calculateGraduated", { enumerable: true, get: function () { return calculator_1.calculateGraduated; } });
+Object.defineProperty(exports, "calculateVolume", { enumerable: true, get: function () { return calculator_1.calculateVolume; } });
+Object.defineProperty(exports, "formatCurrency", { enumerable: true, get: function () { return calculator_1.formatCurrency; } });
+Object.defineProperty(exports, "formatNumber", { enumerable: true, get: function () { return calculator_1.formatNumber; } });
+Object.defineProperty(exports, "formatPercent", { enumerable: true, get: function () { return calculator_1.formatPercent; } });
+Object.defineProperty(exports, "round", { enumerable: true, get: function () { return calculator_1.round; } });
+Object.defineProperty(exports, "calculateDiscount", { enumerable: true, get: function () { return calculator_1.calculateDiscount; } });
+Object.defineProperty(exports, "applyMinMax", { enumerable: true, get: function () { return calculator_1.applyMinMax; } });
+// Strategy
+var strategy_1 = require("./strategy");
+Object.defineProperty(exports, "PricingStrategy", { enumerable: true, get: function () { return strategy_1.PricingStrategy; } });
+Object.defineProperty(exports, "pricingStrategy", { enumerable: true, get: function () { return strategy_1.pricingStrategy; } });
+// Engine
+var engine_1 = require("./engine");
+Object.defineProperty(exports, "PricingEngine", { enumerable: true, get: function () { return engine_1.PricingEngine; } });
+Object.defineProperty(exports, "pricingEngine", { enumerable: true, get: function () { return engine_1.pricingEngine; } });
+//# sourceMappingURL=index.js.map

package/dist/engines/pricing/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/engines/pricing/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;;;AAyEH,qBAAqB;AACrB,iCAAsD;AAA7C,mGAAA,UAAU,OAAA;AAAE,wGAAA,eAAe,OAAA;AAEpC,WAAW;AACX,uCAAuE;AAA9D,iHAAA,qBAAqB,OAAA;AAAE,8GAAA,kBAAkB,OAAA;AAElD,uBAAuB;AACvB,2CAUsB;AATpB,2GAAA,aAAa,OAAA;AACb,gHAAA,kBAAkB,OAAA;AAClB,6GAAA,eAAe,OAAA;AACf,4GAAA,cAAc,OAAA;AACd,0GAAA,YAAY,OAAA;AACZ,2GAAA,aAAa,OAAA;AACb,mGAAA,KAAK,OAAA;AACL,+GAAA,iBAAiB,OAAA;AACjB,yGAAA,WAAW,OAAA;AAKb,WAAW;AACX,uCAA8D;AAArD,2GAAA,eAAe,OAAA;AAAE,2GAAA,eAAe,OAAA;AAEzC,SAAS;AACT,mCAAwD;AAA/C,uGAAA,aAAa,OAAA;AAAE,uGAAA,aAAa,OAAA"}

package/dist/engines/pricing/strategy.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Pricing Engine Strategy
+ *
+ * Executes pricing calculations:
+ * - Resolves scenario values
+ * - Calculates component prices using appropriate pricing mode
+ * - Applies adjustments (discounts, minimums, maximums)
+ * - Computes metrics for comparison
+ */
+import { CompiledPricingRuleSet, PricingOptions, PricingResult, ScenarioComparisonResult } from './types';
+export declare class PricingStrategy {
+    /**
+     * Calculate pricing for a single scenario.
+     */
+    calculate(ruleSet: CompiledPricingRuleSet, ruleId: string, options?: PricingOptions): PricingResult;
+    /**
+     * Calculate pricing for multiple scenarios for comparison.
+     */
+    calculateScenarios(ruleSet: CompiledPricingRuleSet, ruleId: string, scenarioIds?: string[]): ScenarioComparisonResult;
+}
+export declare const pricingStrategy: PricingStrategy;
+//# sourceMappingURL=strategy.d.ts.map

package/dist/engines/pricing/strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strategy.d.ts","sourceRoot":"","sources":["../../../src/engines/pricing/strategy.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,OAAO,EACL,sBAAsB,EAMtB,cAAc,EACd,aAAa,EACb,wBAAwB,EAMzB,MAAM,SAAS,CAAC;AA6gBjB,qBAAa,eAAe;IAC1B;;OAEG;IACH,SAAS,CACP,OAAO,EAAE,sBAAsB,EAC/B,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,cAAmB,GAC3B,aAAa;IAyGhB;;OAEG;IACH,kBAAkB,CAChB,OAAO,EAAE,sBAAsB,EAC/B,MAAM,EAAE,MAAM,EACd,WAAW,CAAC,EAAE,MAAM,EAAE,GACrB,wBAAwB;CA4D5B;AAGD,eAAO,MAAM,eAAe,iBAAwB,CAAC"}

package/dist/engines/pricing/strategy.js

@@ -0,0 +1,517 @@
+"use strict";
+/**
+ * Pricing Engine Strategy
+ *
+ * Executes pricing calculations:
+ * - Resolves scenario values
+ * - Calculates component prices using appropriate pricing mode
+ * - Applies adjustments (discounts, minimums, maximums)
+ * - Computes metrics for comparison
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pricingStrategy = exports.PricingStrategy = void 0;
+const calculator_1 = require("./calculator");
+/**
+ * Resolve a compiled operand to its value using simple context.
+ */
+function resolveOperandValue(operand, context) {
+    if (operand.type === 'constant') {
+        return operand.value;
+    }
+    if (operand.type === 'property') {
+        const { param, path } = operand.ref;
+        // First check if the param directly exists in context
+        let value = context[param];
+        // If path has elements, traverse them
+        if (path.length > 0 && value !== undefined && value !== null) {
+            for (const key of path) {
+                if (value === null || value === undefined)
+                    return undefined;
+                value = value[key];
+            }
+        }
+        return value;
+    }
+    if (operand.type === 'expression') {
+        return evaluateSimpleExpression(operand.compiled, context);
+    }
+    return undefined;
+}
+/**
+ * Evaluate a simple expression (arithmetic operations).
+ */
+function evaluateSimpleExpression(expr, context) {
+    const { op, operands } = expr;
+    if (!operands || operands.length === 0) {
+        return undefined;
+    }
+    // Get operand values
+    const values = operands.map(o => resolveOperandValue(o, context));
+    // Arithmetic operations
+    switch (op) {
+        case 'add':
+            return values[0] + values[1];
+        case 'subtract':
+            return values[0] - values[1];
+        case 'multiply':
+            return values[0] * values[1];
+        case 'divide':
+            return values[1] !== 0 ? values[0] / values[1] : 0;
+        case 'modulo':
+            return values[0] % values[1];
+        case 'power':
+            return Math.pow(values[0], values[1]);
+        case 'min':
+            return Math.min(values[0], values[1]);
+        case 'max':
+            return Math.max(values[0], values[1]);
+        case 'abs':
+            return Math.abs(values[0]);
+        case 'ceil':
+            return Math.ceil(values[0]);
+        case 'floor':
+            return Math.floor(values[0]);
+        case 'round':
+            return Math.round(values[0]);
+        case 'sqrt':
+            return Math.sqrt(values[0]);
+        default:
+            return values[0];
+    }
+}
+/**
+ * Evaluate a condition for discounts.
+ */
+function evaluateCondition(condition, context) {
+    const { op, operands, children } = condition;
+    // Logical operators
+    if (op === 'and' && children) {
+        return children.every(child => evaluateCondition(child, context));
+    }
+    if (op === 'or' && children) {
+        return children.some(child => evaluateCondition(child, context));
+    }
+    if (op === 'not' && children) {
+        return !evaluateCondition(children[0], context);
+    }
+    if (!operands || operands.length < 2) {
+        return false;
+    }
+    const left = resolveOperandValue(operands[0], context);
+    const right = resolveOperandValue(operands[1], context);
+    // Comparison operators
+    switch (op) {
+        case 'equals':
+            return left === right;
+        case 'notEquals':
+            return left !== right;
+        case 'greaterThan':
+            return left > right;
+        case 'greaterThanOrEquals':
+            return left >= right;
+        case 'lessThan':
+            return left < right;
+        case 'lessThanOrEquals':
+            return left <= right;
+        default:
+            return false;
+    }
+}
+/**
+ * Create a calculator context from value context.
+ */
+function createCalculatorContext(valueContext) {
+    return {
+        resolve: (operand) => {
+            const value = resolveOperandValue(operand, valueContext);
+            return typeof value === 'number' ? value : 0;
+        }
+    };
+}
+// ========================================
+// Pricing Mode Execution
+// ========================================
+/**
+ * Execute a pricing mode and return the result.
+ */
+function executePricingMode(pricing, quantity, calcContext) {
+    switch (pricing.mode) {
+        case 'flat':
+            return (0, calculator_1.calculateFlat)(quantity, pricing.pricePerUnit, calcContext);
+        case 'graduated':
+            return (0, calculator_1.calculateGraduated)(quantity, pricing.tiers, calcContext);
+        case 'volume':
+            return (0, calculator_1.calculateVolume)(quantity, pricing.brackets, calcContext);
+        case 'formula': {
+            const total = calcContext.resolve(pricing.calculate);
+            return {
+                total,
+                breakdown: [{
+                        tier: 'Formula',
+                        range: 'Calculated',
+                        units: quantity,
+                        rate: quantity > 0 ? total / quantity : 0,
+                        subtotal: total
+                    }]
+            };
+        }
+        case 'multi-meter':
+            throw new Error('Multi-meter should be handled by executeMeter');
+    }
+}
+/**
+ * Execute a meter calculation.
+ */
+function executeMeter(meter, valueContext, calcContext) {
+    const quantity = resolveOperandValue(meter.quantity, valueContext) || 0;
+    const result = executePricingMode(meter.pricing, quantity, calcContext);
+    return {
+        id: meter.id,
+        name: meter.name,
+        quantity,
+        unit: meter.unit,
+        tierBreakdown: result.breakdown,
+        subtotal: result.total
+    };
+}
+// ========================================
+// Component Execution
+// ========================================
+/**
+ * Execute pricing for a single component.
+ */
+function executeComponent(component, scenarioId, precision) {
+    // Get scenario values for this component
+    const scenarioValues = component.scenarioValues[scenarioId] || {};
+    // Build value context from scenario values
+    const valueContext = { ...scenarioValues };
+    const calcContext = createCalculatorContext(valueContext);
+    // Resolve quantity
+    const quantity = resolveOperandValue(component.quantity, valueContext) || 0;
+    // Resolve attributes
+    const attributes = {};
+    for (const [key, operand] of Object.entries(component.attributes)) {
+        attributes[key] = resolveOperandValue(operand, valueContext);
+    }
+    // Handle multi-meter pricing separately
+    if (component.pricing.mode === 'multi-meter') {
+        const meters = component.pricing.meters.map(m => executeMeter(m, valueContext, calcContext));
+        const subtotal = (0, calculator_1.round)(meters.reduce((sum, m) => sum + m.subtotal, 0), precision);
+        return {
+            sku: component.sku,
+            name: component.name,
+            attributes,
+            quantity,
+            unit: component.unit,
+            meters,
+            subtotal
+        };
+    }
+    // Execute standard pricing mode
+    const result = executePricingMode(component.pricing, quantity, calcContext);
+    return {
+        sku: component.sku,
+        name: component.name,
+        attributes,
+        quantity,
+        unit: component.unit,
+        tierBreakdown: result.breakdown,
+        subtotal: (0, calculator_1.round)(result.total, precision)
+    };
+}
+// ========================================
+// Adjustment Execution
+// ========================================
+/**
+ * Execute adjustments and return results.
+ */
+function executeAdjustments(adjustments, componentsTotal, valueContext, precision) {
+    const results = [];
+    let currentTotal = componentsTotal;
+    for (const adjustment of adjustments) {
+        switch (adjustment.type) {
+            case 'discount': {
+                // Check condition if present
+                if (adjustment.condition) {
+                    const conditionMet = evaluateCondition(adjustment.condition, valueContext);
+                    if (!conditionMet)
+                        continue;
+                }
+                const discountAmount = (0, calculator_1.calculateDiscount)(currentTotal, adjustment.percent, adjustment.amount);
+                if (discountAmount > 0) {
+                    results.push({
+                        type: 'discount',
+                        name: adjustment.name,
+                        percent: adjustment.percent,
+                        amount: (0, calculator_1.round)(-discountAmount, precision)
+                    });
+                    currentTotal -= discountAmount;
+                }
+                break;
+            }
+            case 'minimum': {
+                if (currentTotal < adjustment.amount) {
+                    const increase = adjustment.amount - currentTotal;
+                    results.push({
+                        type: 'minimum',
+                        name: adjustment.name,
+                        amount: (0, calculator_1.round)(increase, precision)
+                    });
+                    currentTotal = adjustment.amount;
+                }
+                break;
+            }
+            case 'maximum': {
+                if (currentTotal > adjustment.amount) {
+                    const decrease = currentTotal - adjustment.amount;
+                    results.push({
+                        type: 'maximum',
+                        name: adjustment.name,
+                        amount: (0, calculator_1.round)(-decrease, precision)
+                    });
+                    currentTotal = adjustment.amount;
+                }
+                break;
+            }
+        }
+    }
+    return {
+        results,
+        adjustedTotal: (0, calculator_1.round)(currentTotal, precision)
+    };
+}
+// ========================================
+// Metric Computation
+// ========================================
+/**
+ * Compute metrics for a pricing result.
+ */
+function computeMetrics(metrics, components, summary, scenarioValues, precision) {
+    const result = {};
+    // Build context with all values available for metric calculations
+    const context = {
+        ...scenarioValues,
+        summary,
+        componentsTotal: summary.componentsTotal,
+        adjustmentsTotal: summary.adjustmentsTotal,
+        total: summary.total,
+        componentCount: components.length
+    };
+    // Add component values by SKU
+    for (const comp of components) {
+        context[comp.sku] = {
+            subtotal: comp.subtotal,
+            quantity: comp.quantity
+        };
+    }
+    for (const metric of metrics) {
+        const value = resolveOperandValue(metric.calculate, context);
+        result[metric.id] = (0, calculator_1.round)(typeof value === 'number' ? value : 0, precision);
+    }
+    return result;
+}
+// ========================================
+// Result Formatting
+// ========================================
+/**
+ * Format a pricing result as a string.
+ */
+function formatPricingResult(ruleId, ruleName, scenario, components, adjustments, summary, metrics, executionTimeMs, currency, precision) {
+    const lines = [];
+    lines.push('╔════════════════════════════════════════════════════════════════╗');
+    lines.push(`║  PRICING RESULT: ${ruleName || ruleId}`.padEnd(66) + '║');
+    if (scenario) {
+        lines.push(`║  Scenario: ${scenario}`.padEnd(66) + '║');
+    }
+    lines.push('╠════════════════════════════════════════════════════════════════╣');
+    // Components
+    lines.push('║  COMPONENTS'.padEnd(66) + '║');
+    lines.push('╟────────────────────────────────────────────────────────────────╢');
+    for (const comp of components) {
+        const subtotal = (0, calculator_1.formatCurrency)(comp.subtotal, currency, precision);
+        lines.push(`║  ${comp.name}`.padEnd(50) + subtotal.padStart(15) + ' ║');
+        if (comp.meters) {
+            for (const meter of comp.meters) {
+                const meterTotal = (0, calculator_1.formatCurrency)(meter.subtotal, currency, precision);
+                lines.push(`║    └─ ${meter.name}: ${(0, calculator_1.formatNumber)(meter.quantity)} ${meter.unit}`.padEnd(50) + meterTotal.padStart(15) + ' ║');
+            }
+        }
+        else if (comp.tierBreakdown && comp.tierBreakdown.length > 1) {
+            for (const tier of comp.tierBreakdown) {
+                const tierTotal = (0, calculator_1.formatCurrency)(tier.subtotal, currency, precision);
+                lines.push(`║    └─ ${tier.range}: ${(0, calculator_1.formatNumber)(tier.units)} @ ${(0, calculator_1.formatCurrency)(tier.rate, currency, 4)}`.padEnd(50) + tierTotal.padStart(15) + ' ║');
+            }
+        }
+    }
+    // Adjustments
+    if (adjustments.length > 0) {
+        lines.push('╟────────────────────────────────────────────────────────────────╢');
+        lines.push('║  ADJUSTMENTS'.padEnd(66) + '║');
+        for (const adj of adjustments) {
+            const amount = (0, calculator_1.formatCurrency)(adj.amount, currency, precision);
+            const label = adj.percent ? `${adj.name} (${adj.percent}%)` : adj.name;
+            lines.push(`║  ${label}`.padEnd(50) + amount.padStart(15) + ' ║');
+        }
+    }
+    // Summary
+    lines.push('╠════════════════════════════════════════════════════════════════╣');
+    const total = (0, calculator_1.formatCurrency)(summary.total, currency, precision);
+    lines.push(`║  TOTAL`.padEnd(50) + total.padStart(15) + ' ║');
+    // Metrics
+    if (Object.keys(metrics).length > 0) {
+        lines.push('╟────────────────────────────────────────────────────────────────╢');
+        lines.push('║  METRICS'.padEnd(66) + '║');
+        for (const [key, value] of Object.entries(metrics)) {
+            const formatted = (0, calculator_1.formatCurrency)(value, currency, precision);
+            lines.push(`║  ${key}`.padEnd(50) + formatted.padStart(15) + ' ║');
+        }
+    }
+    lines.push('╠════════════════════════════════════════════════════════════════╣');
+    lines.push(`║  Processing time: ${executionTimeMs.toFixed(2)}ms`.padEnd(66) + '║');
+    lines.push('╚════════════════════════════════════════════════════════════════╝');
+    return lines.join('\n');
+}
+/**
+ * Format scenario comparison result as a string.
+ */
+function formatComparisonResult(ruleId, scenarios, executionTimeMs, currency, precision) {
+    const lines = [];
+    const scenarioEntries = Object.entries(scenarios);
+    lines.push('╔════════════════════════════════════════════════════════════════╗');
+    lines.push(`║  SCENARIO COMPARISON: ${ruleId}`.padEnd(66) + '║');
+    lines.push('╠════════════════════════════════════════════════════════════════╣');
+    // Summary table
+    const headers = ['Scenario', 'Components', 'Adjustments', 'Total'];
+    lines.push(`║  ${headers[0].padEnd(20)} ${headers[1].padEnd(12)} ${headers[2].padEnd(12)} ${headers[3].padEnd(12)}`.padEnd(65) + '║');
+    lines.push('╟────────────────────────────────────────────────────────────────╢');
+    for (const [, scenario] of scenarioEntries) {
+        const comp = (0, calculator_1.formatCurrency)(scenario.summary.componentsTotal, currency, precision);
+        const adj = (0, calculator_1.formatCurrency)(scenario.summary.adjustmentsTotal, currency, precision);
+        const total = (0, calculator_1.formatCurrency)(scenario.summary.total, currency, precision);
+        lines.push(`║  ${scenario.name.padEnd(20)} ${comp.padEnd(12)} ${adj.padEnd(12)} ${total.padEnd(12)}`.padEnd(65) + '║');
+    }
+    lines.push('╠════════════════════════════════════════════════════════════════╣');
+    lines.push(`║  Processing time: ${executionTimeMs.toFixed(2)}ms`.padEnd(66) + '║');
+    lines.push('╚════════════════════════════════════════════════════════════════╝');
+    return lines.join('\n');
+}
+// ========================================
+// Main Strategy Class
+// ========================================
+class PricingStrategy {
+    /**
+     * Calculate pricing for a single scenario.
+     */
+    calculate(ruleSet, ruleId, options = {}) {
+        const startTime = performance.now();
+        // Find the rule
+        const rule = ruleSet.rules.find(r => r.id === ruleId);
+        if (!rule) {
+            throw new Error(`Rule not found: ${ruleId}`);
+        }
+        // Determine scenario
+        const scenarioId = options.scenario
+            || ruleSet.scenarios.defaultScenario
+            || Object.keys(ruleSet.scenarios.definitions)[0];
+        if (!scenarioId) {
+            throw new Error('No scenario specified and no default scenario defined');
+        }
+        const scenarioDefinition = ruleSet.scenarios.definitions[scenarioId];
+        if (!scenarioDefinition && Object.keys(ruleSet.scenarios.definitions).length > 0) {
+            throw new Error(`Unknown scenario: ${scenarioId}`);
+        }
+        // Execute components
+        const components = [];
+        for (const component of rule.components) {
+            const result = executeComponent(component, scenarioId, ruleSet.config.precision);
+            components.push(result);
+            options.onComponent?.(component.sku, result);
+        }
+        // Calculate components total
+        const componentsTotal = (0, calculator_1.round)(components.reduce((sum, c) => sum + c.subtotal, 0), ruleSet.config.precision);
+        // Gather all scenario values for adjustments
+        const allScenarioValues = {};
+        for (const comp of rule.components) {
+            Object.assign(allScenarioValues, comp.scenarioValues[scenarioId] || {});
+        }
+        // Execute adjustments
+        const { results: adjustments, adjustedTotal } = executeAdjustments(rule.adjustments, componentsTotal, allScenarioValues, ruleSet.config.precision);
+        for (const adj of adjustments) {
+            options.onAdjustment?.(adj);
+        }
+        // Build summary
+        const summary = {
+            componentsTotal,
+            adjustmentsTotal: (0, calculator_1.round)(adjustedTotal - componentsTotal, ruleSet.config.precision),
+            total: adjustedTotal
+        };
+        // Compute metrics
+        const metrics = computeMetrics(rule.metrics, components, summary, allScenarioValues, ruleSet.config.precision);
+        const executionTimeMs = Math.round((performance.now() - startTime) * 100) / 100;
+        const result = {
+            ruleId: rule.id,
+            ruleName: rule.name,
+            scenario: scenarioId,
+            components,
+            adjustments,
+            summary,
+            metrics,
+            executionTimeMs,
+            toString: function () {
+                return formatPricingResult(this.ruleId, this.ruleName, this.scenario, this.components, this.adjustments, this.summary, this.metrics, this.executionTimeMs, ruleSet.config.currency, ruleSet.config.precision);
+            }
+        };
+        return result;
+    }
+    /**
+     * Calculate pricing for multiple scenarios for comparison.
+     */
+    calculateScenarios(ruleSet, ruleId, scenarioIds) {
+        const startTime = performance.now();
+        // Determine which scenarios to calculate
+        const scenarios = scenarioIds
+            || Object.keys(ruleSet.scenarios.definitions);
+        if (scenarios.length === 0) {
+            throw new Error('No scenarios to calculate');
+        }
+        // Calculate each scenario
+        const results = {};
+        for (const scenarioId of scenarios) {
+            const scenarioDefinition = ruleSet.scenarios.definitions[scenarioId];
+            if (!scenarioDefinition) {
+                throw new Error(`Unknown scenario: ${scenarioId}`);
+            }
+            const pricingResult = this.calculate(ruleSet, ruleId, { scenario: scenarioId });
+            // Get scenario values for inputs
+            const rule = ruleSet.rules.find(r => r.id === ruleId);
+            const inputs = {};
+            for (const comp of rule.components) {
+                Object.assign(inputs, comp.scenarioValues[scenarioId] || {});
+            }
+            results[scenarioId] = {
+                name: scenarioDefinition.name,
+                description: scenarioDefinition.description,
+                inputs,
+                components: pricingResult.components,
+                adjustments: pricingResult.adjustments,
+                summary: pricingResult.summary,
+                metrics: pricingResult.metrics
+            };
+        }
+        const executionTimeMs = Math.round((performance.now() - startTime) * 100) / 100;
+        const comparisonResult = {
+            rulesetId: ruleSet.id,
+            ruleId,
+            scenarios: results,
+            executionTimeMs,
+            toString: function () {
+                return formatComparisonResult(this.ruleId, this.scenarios, this.executionTimeMs, ruleSet.config.currency, ruleSet.config.precision);
+            }
+        };
+        return comparisonResult;
+    }
+}
+exports.PricingStrategy = PricingStrategy;
+// Export singleton instance
+exports.pricingStrategy = new PricingStrategy();
+//# sourceMappingURL=strategy.js.map