@onabl/js 0.1.0

package/dist/index.js

@@ -0,0 +1,1259 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// ../engine/dist/presentation.js
+var require_presentation = __commonJS({
+  "../engine/dist/presentation.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.shareOfGroup = shareOfGroup;
+    exports2.groupLineItems = groupLineItems2;
+    exports2.presentQuote = presentQuote2;
+    function shareOfGroup(item, tag) {
+      return item.groupAmounts?.[tag] ?? (item.tag === tag ? item.amount : 0);
+    }
+    function labelWithFactor(item) {
+      if (item.factor === void 0 || item.factor === 1)
+        return item.label;
+      const percent = Math.abs(Math.round((item.factor - 1) * 100));
+      return item.factor > 1 ? `${item.label} (+${percent}%)` : `${item.label} (${percent}% off)`;
+    }
+    function groupLineItems2(lineItems, displayGroups) {
+      const visible = lineItems.filter((item) => item.showOnQuote);
+      const groupTotals = {};
+      if (!displayGroups || displayGroups.length === 0) {
+        const main2 = visible.filter((item) => item.amount !== 0).map((item) => ({ key: item.ruleId, label: labelWithFactor(item), amount: item.amount, isGroup: false, sourceItem: item }));
+        return { main: main2, separateSections: [], groupTotals };
+      }
+      const main = [];
+      const separateSections = [];
+      const accounted = /* @__PURE__ */ new Map();
+      const account = (item, amount) => accounted.set(item.ruleId, (accounted.get(item.ruleId) ?? 0) + amount);
+      for (const group of displayGroups) {
+        const matching = visible.filter((item) => item.groupAmounts && group.tag in item.groupAmounts || item.tag === group.tag);
+        const total = matching.reduce((sum, item) => sum + shareOfGroup(item, group.tag), 0);
+        groupTotals[group.tag] = total;
+        if (group.excludeFromTotal)
+          matching.forEach((item) => account(item, shareOfGroup(item, group.tag)));
+        if (!group.showOnQuote || matching.length === 0 || total === 0)
+          continue;
+        if (!group.excludeFromTotal)
+          matching.forEach((item) => account(item, shareOfGroup(item, group.tag)));
+        const active = matching.filter((item) => shareOfGroup(item, group.tag) !== 0);
+        const rowFor = (item) => ({
+          key: `${group.tag}:${item.ruleId}`,
+          label: item.label,
+          amount: shareOfGroup(item, group.tag),
+          isGroup: false,
+          sourceItem: item,
+          groupTag: group.tag
+        });
+        let rows;
+        if (group.displayMode === "individual") {
+          rows = active.map(rowFor);
+        } else if (group.displayMode === "both") {
+          rows = [{ key: group.tag, label: group.label, amount: total, isGroup: true, displayMode: "both", children: active.map(rowFor), groupTag: group.tag }];
+        } else {
+          const label = active.length === 1 ? active[0]?.label ?? group.label : group.label;
+          rows = [{ key: group.tag, label, amount: total, isGroup: true, displayMode: "grouped", groupTag: group.tag }];
+        }
+        if (group.excludeFromTotal)
+          separateSections.push({ group, rows, amount: total });
+        else
+          main.push(...rows);
+      }
+      for (const item of visible) {
+        const remaining = Math.round((item.amount - (accounted.get(item.ruleId) ?? 0)) * 100) / 100;
+        if (remaining === 0)
+          continue;
+        main.push({ key: item.ruleId, label: labelWithFactor(item), amount: remaining, isGroup: false, sourceItem: item });
+      }
+      return { main, separateSections, groupTotals };
+    }
+    function presentQuote2(input) {
+      const { main, separateSections } = groupLineItems2(input.lineItems, input.displayGroups);
+      const subtotal = input.finalTotal;
+      const discountAmount = Math.round((input.finalTotal - input.totalAfterDiscount) * 100) / 100;
+      return {
+        rows: main,
+        separateSections,
+        subtotal,
+        discount: discountAmount > 0 ? { label: input.discountLabel ?? "Discount", amount: discountAmount } : null,
+        total: input.totalAfterDiscount
+      };
+    }
+  }
+});
+
+// ../types/dist/config.js
+var require_config = __commonJS({
+  "../types/dist/config.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.isAndCondition = isAndCondition;
+    function isAndCondition(c) {
+      return c.operator === "and";
+    }
+  }
+});
+
+// ../engine/dist/expression.js
+var require_expression = __commonJS({
+  "../engine/dist/expression.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.parseExpression = parseExpression;
+    exports2.evaluateNode = evaluateNode;
+    exports2.evaluateExpression = evaluateExpression;
+    exports2.printExpression = printExpression;
+    exports2.collectFieldKeys = collectFieldKeys;
+    var IDENT = /[\w]/;
+    function tokenise(source) {
+      const lexemes = [];
+      const src = source.trim();
+      let i = 0;
+      const readIdent = (from) => {
+        let out = "";
+        let j = from;
+        while (j < src.length && IDENT.test(src[j]))
+          out += src[j++];
+        return out;
+      };
+      while (i < src.length) {
+        const ch = src[i];
+        if (ch === " " || ch === "	" || ch === "\n") {
+          i++;
+          continue;
+        }
+        if (ch === "$") {
+          const key = readIdent(i + 1);
+          lexemes.push({ type: "TOKEN", value: key, position: i });
+          i += key.length + 1;
+          continue;
+        }
+        if (src.startsWith("field:", i)) {
+          const key = readIdent(i + 6);
+          lexemes.push({ type: "FIELD", value: key, position: i });
+          i += key.length + 6;
+          continue;
+        }
+        if (src.startsWith("lookup:", i)) {
+          const ref = readIdent(i + 7);
+          lexemes.push({ type: "LOOKUP", value: ref, position: i });
+          i += ref.length + 7;
+          continue;
+        }
+        if (/[0-9]/.test(ch) || ch === "." && /[0-9]/.test(src[i + 1] ?? "")) {
+          let num = "";
+          while (i < src.length && /[0-9.]/.test(src[i]))
+            num += src[i++];
+          lexemes.push({ type: "NUMBER", value: num, position: i - num.length });
+          continue;
+        }
+        if (ch === "+" || ch === "-" || ch === "*" || ch === "/") {
+          lexemes.push({ type: "OP", value: ch, position: i });
+          i++;
+          continue;
+        }
+        if (ch === "(") {
+          lexemes.push({ type: "LPAREN", value: ch, position: i });
+          i++;
+          continue;
+        }
+        if (ch === ")") {
+          lexemes.push({ type: "RPAREN", value: ch, position: i });
+          i++;
+          continue;
+        }
+        lexemes.push({ type: "UNKNOWN", value: ch, position: i });
+        i++;
+      }
+      lexemes.push({ type: "EOF", value: "", position: src.length });
+      return lexemes;
+    }
+    function parseExpression(source) {
+      const errors = [];
+      if (!source || source.trim().length === 0) {
+        return { node: null, errors: [{ ruleId: null, message: "Empty expression" }] };
+      }
+      const lexemes = tokenise(source);
+      let pos = 0;
+      const peek = () => lexemes[pos] ?? { type: "EOF", value: "", position: 0 };
+      const next = () => lexemes[pos++] ?? { type: "EOF", value: "", position: 0 };
+      const fail = (message) => {
+        errors.push({ ruleId: null, message });
+      };
+      function parsePrimary() {
+        const lexeme = next();
+        switch (lexeme.type) {
+          case "NUMBER": {
+            const value = parseFloat(lexeme.value);
+            if (Number.isNaN(value)) {
+              fail(`Invalid number "${lexeme.value}"`);
+              return null;
+            }
+            return { kind: "number", value };
+          }
+          case "TOKEN":
+            if (lexeme.value === "") {
+              fail("Malformed token reference \u2014 nothing after '$'");
+              return null;
+            }
+            return { kind: "token", key: lexeme.value };
+          case "FIELD":
+            if (lexeme.value === "") {
+              fail("Malformed field reference \u2014 nothing after 'field:'");
+              return null;
+            }
+            return { kind: "field", key: lexeme.value };
+          case "LOOKUP":
+            if (lexeme.value === "") {
+              fail("Malformed lookup reference \u2014 nothing after 'lookup:'");
+              return null;
+            }
+            return { kind: "lookup", ref: lexeme.value };
+          case "LPAREN": {
+            const inner = parseExpr();
+            if (peek().type === "RPAREN") {
+              next();
+            } else {
+              fail("Unclosed '(' \u2014 every opening bracket needs a closing one");
+            }
+            return inner;
+          }
+          case "EOF":
+            fail("Expression ended unexpectedly");
+            return null;
+          default:
+            fail(`Unexpected "${lexeme.value}" in expression`);
+            return null;
+        }
+      }
+      function parseFactor() {
+        if (peek().type === "OP" && peek().value === "-") {
+          next();
+          const operand = parseFactor();
+          return operand === null ? null : { kind: "negate", operand };
+        }
+        return parsePrimary();
+      }
+      function parseTerm() {
+        let left = parseFactor();
+        while (peek().type === "OP" && (peek().value === "*" || peek().value === "/")) {
+          const op = next().value;
+          const right = parseFactor();
+          if (left === null || right === null)
+            return null;
+          left = { kind: "binary", op, left, right };
+        }
+        return left;
+      }
+      function parseExpr() {
+        let left = parseTerm();
+        while (peek().type === "OP" && (peek().value === "+" || peek().value === "-")) {
+          const op = next().value;
+          const right = parseTerm();
+          if (left === null || right === null)
+            return null;
+          left = { kind: "binary", op, left, right };
+        }
+        return left;
+      }
+      const node = parseExpr();
+      if (peek().type !== "EOF") {
+        fail(`Unexpected "${peek().value}" after the end of the expression`);
+      }
+      return { node: errors.length > 0 ? null : node, errors };
+    }
+    function evaluateNode(node, scope) {
+      const errors = [];
+      function walk(n) {
+        switch (n.kind) {
+          case "number":
+            return n.value;
+          case "token": {
+            if (!(n.key in scope.tokens)) {
+              errors.push({ ruleId: null, message: `Undefined token: "$${n.key}"` });
+              return 0;
+            }
+            return scope.tokens[n.key];
+          }
+          case "field": {
+            const fields = scope.fields ?? {};
+            if (!(n.key in fields)) {
+              errors.push({ ruleId: null, message: `Unanswered field referenced in a price: "${n.key}"` });
+              return 0;
+            }
+            const value2 = fields[n.key];
+            if (!Number.isFinite(value2)) {
+              errors.push({ ruleId: null, message: `Field "${n.key}" is not a number` });
+              return 0;
+            }
+            return value2;
+          }
+          case "lookup": {
+            const lookups = scope.lookups ?? {};
+            if (!(n.ref in lookups)) {
+              errors.push({ ruleId: null, message: `Unresolved lookup reference: "lookup:${n.ref}"` });
+              return 0;
+            }
+            return lookups[n.ref];
+          }
+          case "negate":
+            return -walk(n.operand);
+          case "binary": {
+            const left = walk(n.left);
+            const right = walk(n.right);
+            switch (n.op) {
+              case "+":
+                return left + right;
+              case "-":
+                return left - right;
+              case "*":
+                return left * right;
+              case "/":
+                if (right === 0) {
+                  errors.push({ ruleId: null, message: "Division by zero in expression" });
+                  return 0;
+                }
+                return left / right;
+            }
+          }
+        }
+      }
+      const value = walk(node);
+      return { value: Number.isFinite(value) ? value : 0, errors };
+    }
+    function evaluateExpression(source, scope) {
+      const { node, errors } = parseExpression(source);
+      if (node === null)
+        return { value: 0, errors };
+      return evaluateNode(node, scope);
+    }
+    var PRECEDENCE = { "+": 1, "-": 1, "*": 2, "/": 2 };
+    function printExpression(node) {
+      const ASSOCIATIVE = { "+": true, "*": true, "-": false, "/": false };
+      function render(n, parentPrecedence = 0, isRightOperand = false, parentOp = null) {
+        switch (n.kind) {
+          case "number":
+            return String(n.value);
+          case "token":
+            return `$${n.key}`;
+          case "field":
+            return `field:${n.key}`;
+          case "lookup":
+            return `lookup:${n.ref}`;
+          case "negate":
+            return `-${render(n.operand, 3)}`;
+          case "binary": {
+            const precedence = PRECEDENCE[n.op];
+            const body = `${render(n.left, precedence, false, n.op)} ${n.op} ${render(n.right, precedence, true, n.op)}`;
+            const parentKeepsOrder = parentOp !== null && !ASSOCIATIVE[parentOp];
+            const needsBrackets = precedence < parentPrecedence || precedence === parentPrecedence && isRightOperand && parentKeepsOrder;
+            return needsBrackets ? `(${body})` : body;
+          }
+        }
+      }
+      return render(node);
+    }
+    function collectFieldKeys(node) {
+      const keys = /* @__PURE__ */ new Set();
+      (function walk(n) {
+        if (n.kind === "field")
+          keys.add(n.key);
+        else if (n.kind === "binary") {
+          walk(n.left);
+          walk(n.right);
+        } else if (n.kind === "negate")
+          walk(n.operand);
+      })(node);
+      return [...keys];
+    }
+  }
+});
+
+// ../engine/dist/resolver.js
+var require_resolver = __commonJS({
+  "../engine/dist/resolver.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.resolveExpression = resolveExpression;
+    exports2.evaluateCondition = evaluateCondition2;
+    var config_1 = require_config();
+    var expression_1 = require_expression();
+    function resolveExpression(expr, variables, lookupValues, fields) {
+      return (0, expression_1.evaluateExpression)(expr, { tokens: variables, lookups: lookupValues, fields });
+    }
+    function evaluateCondition2(condition, answers) {
+      if ((0, config_1.isAndCondition)(condition)) {
+        return condition.clauses.every((c) => evaluateCondition2(c, answers));
+      }
+      const { field, operator, value: condValue } = condition;
+      const answer = answers[field];
+      if (answer === void 0 || answer === null) {
+        return false;
+      }
+      if (operator === "includes") {
+        if (Array.isArray(answer))
+          return answer.includes(String(condValue));
+        return String(answer) === String(condValue);
+      }
+      if (operator === "includes_any") {
+        if (!Array.isArray(answer) || !Array.isArray(condValue)) {
+          return false;
+        }
+        return condValue.some((v) => answer.includes(v));
+      }
+      if (operator === "in") {
+        if (Array.isArray(answer) || !Array.isArray(condValue)) {
+          return false;
+        }
+        return condValue.includes(String(answer));
+      }
+      if (Array.isArray(answer)) {
+        return false;
+      }
+      const op = operator;
+      switch (op) {
+        case "eq":
+          return answer === condValue;
+        case "neq":
+          return answer !== condValue;
+        case "gt":
+        case "gte":
+        case "lt":
+        case "lte": {
+          const numAnswer = Number(answer);
+          const numValue = Number(condValue);
+          if (isNaN(numAnswer) || isNaN(numValue)) {
+            return false;
+          }
+          if (op === "gt")
+            return numAnswer > numValue;
+          if (op === "gte")
+            return numAnswer >= numValue;
+          if (op === "lt")
+            return numAnswer < numValue;
+          if (op === "lte")
+            return numAnswer <= numValue;
+          return false;
+        }
+        default: {
+          const _exhaustive = op;
+          void _exhaustive;
+          return false;
+        }
+      }
+    }
+  }
+});
+
+// ../engine/dist/date-derival.js
+var require_date_derival = __commonJS({
+  "../engine/dist/date-derival.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.injectDateDerivals = injectDateDerivals;
+    function injectDateDerivals(config, raw, now = /* @__PURE__ */ new Date()) {
+      const augmented = { ...raw };
+      for (const field of config.fields) {
+        if (field.type !== "date" || !field.derivedFields)
+          continue;
+        const value = raw[field.key];
+        if (!value || typeof value !== "string")
+          continue;
+        const [year, month, day] = value.split("-").map(Number);
+        if (!year || !month || !day)
+          continue;
+        const date = new Date(year, month - 1, day);
+        const { isWeekend, isPeakSeason, daysUntil } = field.derivedFields;
+        if (isWeekend) {
+          const d = date.getDay();
+          augmented[`__is_weekend__${field.key}`] = d === 0 || d === 6;
+        }
+        if (isPeakSeason?.length) {
+          augmented[`__is_peak_season__${field.key}`] = isPeakSeason.includes(date.getMonth() + 1);
+        }
+        if (daysUntil) {
+          const today = new Date(now);
+          today.setHours(0, 0, 0, 0);
+          const diff = Math.round((date.getTime() - today.getTime()) / 864e5);
+          augmented[`__days_until__${field.key}`] = diff;
+        }
+      }
+      return augmented;
+    }
+  }
+});
+
+// ../engine/dist/variables.js
+var require_variables = __commonJS({
+  "../engine/dist/variables.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.resolveTokens = resolveTokens;
+    var resolver_1 = require_resolver();
+    function extractTokenRefs(expr) {
+      const refs = /* @__PURE__ */ new Set();
+      for (const match of expr.matchAll(/\$(\w+)/g)) {
+        refs.add(match[1]);
+      }
+      return Array.from(refs);
+    }
+    function resolveTokens(rawTokens) {
+      const errors = [];
+      const resolved = {};
+      const resolving = /* @__PURE__ */ new Set();
+      const done = /* @__PURE__ */ new Set();
+      function resolveKey(key) {
+        if (done.has(key))
+          return resolved[key] ?? 0;
+        const raw = rawTokens[key];
+        if (raw === void 0)
+          return 0;
+        if (typeof raw === "number") {
+          resolved[key] = raw;
+          done.add(key);
+          return raw;
+        }
+        if (resolving.has(key)) {
+          errors.push({ ruleId: null, message: `Circular reference detected in token "$${key}"` });
+          resolved[key] = 0;
+          done.add(key);
+          return 0;
+        }
+        resolving.add(key);
+        for (const dep of extractTokenRefs(raw)) {
+          resolveKey(dep);
+        }
+        resolving.delete(key);
+        const { value, errors: exprErrors } = (0, resolver_1.resolveExpression)(raw, resolved, {});
+        errors.push(...exprErrors.map((e) => ({ ...e, message: `Token "$${key}": ${e.message}` })));
+        resolved[key] = value;
+        done.add(key);
+        return value;
+      }
+      for (const key of Object.keys(rawTokens)) {
+        resolveKey(key);
+      }
+      return { variables: resolved, errors };
+    }
+  }
+});
+
+// ../engine/dist/engine.js
+var require_engine = __commonJS({
+  "../engine/dist/engine.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.resolveTokens = exports2.injectDateDerivals = void 0;
+    exports2.applyDefaults = applyDefaults2;
+    exports2.calculate = calculate;
+    var resolver_1 = require_resolver();
+    var date_derival_1 = require_date_derival();
+    Object.defineProperty(exports2, "injectDateDerivals", { enumerable: true, get: function() {
+      return date_derival_1.injectDateDerivals;
+    } });
+    var variables_1 = require_variables();
+    Object.defineProperty(exports2, "resolveTokens", { enumerable: true, get: function() {
+      return variables_1.resolveTokens;
+    } });
+    var presentation_1 = require_presentation();
+    function computeGroupAmounts(groupAssignments, baseAmount, variables, lookupValues, ruleId) {
+      if (!groupAssignments || groupAssignments.length === 0) {
+        return { errors: [] };
+      }
+      const groupAmounts = {};
+      const errors = [];
+      for (const assignment of groupAssignments) {
+        if (assignment.expression) {
+          const { value, errors: exprErrors } = (0, resolver_1.resolveExpression)(assignment.expression, variables, lookupValues);
+          errors.push(...exprErrors.map((e) => ({ ...e, ruleId })));
+          groupAmounts[assignment.tag] = roundCents(value);
+        } else {
+          groupAmounts[assignment.tag] = baseAmount;
+        }
+      }
+      return { groupAmounts: Object.keys(groupAmounts).length > 0 ? groupAmounts : void 0, errors };
+    }
+    function roundCents(n) {
+      return Math.round((n + Number.EPSILON) * 100) / 100;
+    }
+    function applyDefaults2(config, answers) {
+      const result = { ...answers };
+      for (const field of config.fields) {
+        if (result[field.key] === void 0 || result[field.key] === null) {
+          if (field.defaultValue !== null && field.defaultValue !== void 0) {
+            result[field.key] = field.defaultValue;
+          } else {
+            if (field.type === "number")
+              result[field.key] = 0;
+            if (field.type === "toggle")
+              result[field.key] = false;
+          }
+        }
+      }
+      return result;
+    }
+    function processUnitRate(rule, answers, variables, lookupValues, fieldValues, quantityUnit) {
+      const errors = [];
+      const quantityRaw = answers[rule.quantityField];
+      const quantity = Number(quantityRaw);
+      if (quantityRaw === void 0 || quantityRaw === null) {
+        errors.push({
+          ruleId: rule.id,
+          message: `unit_rate rule "${rule.id}": field "${rule.quantityField}" not found in answers`
+        });
+        return { lineItem: null, amount: 0, errors };
+      }
+      if (isNaN(quantity)) {
+        errors.push({
+          ruleId: rule.id,
+          message: `unit_rate rule "${rule.id}": field "${rule.quantityField}" is not a number (got "${quantityRaw}")`
+        });
+        return { lineItem: null, amount: 0, errors };
+      }
+      const { value: rate, errors: rateErrors } = (0, resolver_1.resolveExpression)(rule.rateExpr, variables, lookupValues, fieldValues);
+      const stampedErrors = rateErrors.map((e) => ({ ...e, ruleId: rule.id }));
+      errors.push(...stampedErrors);
+      const amount = roundCents(quantity * rate);
+      const { groupAmounts, errors: groupErrors } = computeGroupAmounts(rule.groupAssignments, amount, variables, lookupValues, rule.id);
+      errors.push(...groupErrors);
+      const lineItem = {
+        ruleId: rule.id,
+        label: rule.label,
+        amount,
+        type: "unit_rate",
+        showOnQuote: rule.showOnQuote,
+        ...rule.tag !== void 0 && { tag: rule.tag },
+        ...groupAmounts !== void 0 && { groupAmounts },
+        quantity,
+        ...quantityUnit !== void 0 && { quantityUnit },
+        ratePerUnit: rate
+      };
+      return { lineItem, amount, errors };
+    }
+    function processConditionalAddon(rule, variables, lookupValues, fieldValues) {
+      const { value: rawAmount, errors: resolveErrors } = (0, resolver_1.resolveExpression)(rule.amountExpr, variables, lookupValues, fieldValues);
+      const amount = roundCents(rawAmount);
+      const errors = resolveErrors.map((e) => ({ ...e, ruleId: rule.id }));
+      const { groupAmounts, errors: groupErrors } = computeGroupAmounts(rule.groupAssignments, amount, variables, lookupValues, rule.id);
+      errors.push(...groupErrors);
+      const lineItem = {
+        ruleId: rule.id,
+        label: rule.label,
+        amount,
+        type: "conditional_addon",
+        showOnQuote: rule.showOnQuote,
+        ...rule.tag !== void 0 && { tag: rule.tag },
+        ...groupAmounts !== void 0 && { groupAmounts }
+      };
+      return { lineItem, amount, errors };
+    }
+    function processLookupTable(rule, answers, variables, lookupValues) {
+      const errors = [];
+      const rowAnswer = String(answers[rule.rowField] ?? "");
+      const colAnswer = String(answers[rule.colField] ?? "");
+      if (answers[rule.rowField] === void 0) {
+        errors.push({
+          ruleId: rule.id,
+          message: `lookup_table rule "${rule.id}": row field "${rule.rowField}" not found in answers`
+        });
+      }
+      if (answers[rule.colField] === void 0) {
+        errors.push({
+          ruleId: rule.id,
+          message: `lookup_table rule "${rule.id}": col field "${rule.colField}" not found in answers`
+        });
+      }
+      if (errors.length > 0) {
+        return { lineItem: null, amount: 0, errors };
+      }
+      const row = rule.table[rowAnswer];
+      if (row === void 0) {
+        errors.push({
+          ruleId: rule.id,
+          message: `lookup_table rule "${rule.id}": no row for value "${rowAnswer}"`
+        });
+        return { lineItem: null, amount: 0, errors };
+      }
+      const rawAmount = row[colAnswer];
+      if (rawAmount === void 0) {
+        errors.push({
+          ruleId: rule.id,
+          message: `lookup_table rule "${rule.id}": no column "${colAnswer}" in row "${rowAnswer}"`
+        });
+        return { lineItem: null, amount: 0, errors };
+      }
+      const amount = roundCents(rawAmount);
+      const { groupAmounts, errors: groupErrors } = computeGroupAmounts(rule.groupAssignments, amount, variables, lookupValues, rule.id);
+      errors.push(...groupErrors);
+      const lineItem = {
+        ruleId: rule.id,
+        label: rule.label,
+        amount,
+        type: "lookup_table",
+        showOnQuote: rule.showOnQuote,
+        ...rule.tag !== void 0 && { tag: rule.tag },
+        ...groupAmounts !== void 0 && { groupAmounts }
+      };
+      return { lineItem, amount, errors };
+    }
+    function processSelectionMultiplier(rule, answers, runningTotal, variables, lookupValues) {
+      const errors = [];
+      const selection = String(answers[rule.field] ?? "");
+      if (answers[rule.field] === void 0) {
+        return { lineItem: null, newTotal: runningTotal, errors };
+      }
+      const factor = rule.multipliers[selection];
+      if (factor === void 0) {
+        return { lineItem: null, newTotal: runningTotal, errors };
+      }
+      const appliedTo = runningTotal;
+      const newTotal = runningTotal * factor;
+      const amount = roundCents(newTotal - appliedTo);
+      const { groupAmounts, errors: groupErrors } = computeGroupAmounts(rule.groupAssignments, amount, variables, lookupValues, rule.id);
+      errors.push(...groupErrors);
+      const lineItem = {
+        ruleId: rule.id,
+        label: rule.label,
+        amount,
+        type: "selection_multiplier",
+        showOnQuote: rule.showOnQuote,
+        ...rule.tag !== void 0 && { tag: rule.tag },
+        ...groupAmounts !== void 0 && { groupAmounts },
+        factor,
+        appliedTo
+      };
+      return { lineItem, newTotal, errors };
+    }
+    function processConditionalMultiplier(rule, variables, lookupValues, fieldValues, runningTotal) {
+      const { value: factor, errors: resolveErrors } = (0, resolver_1.resolveExpression)(rule.factorExpr, variables, lookupValues, fieldValues);
+      const errors = resolveErrors.map((e) => ({ ...e, ruleId: rule.id }));
+      const appliedTo = runningTotal;
+      const newTotal = runningTotal * factor;
+      const amount = roundCents(newTotal - appliedTo);
+      const { groupAmounts, errors: groupErrors } = computeGroupAmounts(rule.groupAssignments, amount, variables, lookupValues, rule.id);
+      errors.push(...groupErrors);
+      const lineItem = {
+        ruleId: rule.id,
+        label: rule.label,
+        amount,
+        type: "conditional_multiplier",
+        showOnQuote: rule.showOnQuote,
+        ...rule.tag !== void 0 && { tag: rule.tag },
+        ...groupAmounts !== void 0 && { groupAmounts },
+        factor,
+        appliedTo
+      };
+      return { lineItem, newTotal, errors };
+    }
+    function processFloorMinimum(rule, variables, lookupValues, fieldValues, currentTotal) {
+      const { value: minimum, errors: resolveErrors } = (0, resolver_1.resolveExpression)(rule.minimumExpr, variables, lookupValues, fieldValues);
+      const errors = resolveErrors.map((e) => ({ ...e, ruleId: rule.id }));
+      if (currentTotal < minimum) {
+        const amount = roundCents(minimum - currentTotal);
+        const { groupAmounts, errors: groupErrors } = computeGroupAmounts(rule.groupAssignments, amount, variables, lookupValues, rule.id);
+        errors.push(...groupErrors);
+        const lineItem = {
+          ruleId: rule.id,
+          label: rule.label,
+          amount,
+          type: "floor_minimum",
+          showOnQuote: rule.showOnQuote,
+          ...rule.tag !== void 0 && { tag: rule.tag },
+          ...groupAmounts !== void 0 && { groupAmounts }
+        };
+        return { lineItem, finalTotal: minimum, minimumApplied: true, minimumAmount: minimum, errors };
+      }
+      return { lineItem: null, finalTotal: currentTotal, minimumApplied: false, minimumAmount: minimum, errors };
+    }
+    function buildTotals(lineItems, finalTotal, displayGroups, minimumApplied) {
+      const errors = [];
+      const cents = (n) => Math.round(n * 100);
+      for (const item of lineItems) {
+        if (!item.groupAmounts)
+          continue;
+        const allocated = Object.values(item.groupAmounts).reduce((a, b) => a + b, 0);
+        if (cents(allocated) !== cents(item.amount)) {
+          errors.push({
+            ruleId: item.ruleId,
+            message: `"${item.label}" is split across groups totalling ${allocated.toFixed(2)}, but the item is ${item.amount.toFixed(2)} \u2014 the split must account for the whole amount`
+          });
+        }
+      }
+      const { groupTotals: rawGroupTotals } = (0, presentation_1.groupLineItems)(lineItems, displayGroups);
+      const groupTotals = {};
+      let separatelyQuoted = 0;
+      for (const group of displayGroups ?? []) {
+        const total = rawGroupTotals[group.tag] ?? 0;
+        groupTotals[group.tag] = roundCents(total);
+        if (group.excludeFromTotal)
+          separatelyQuoted += total;
+      }
+      if (!minimumApplied) {
+        const visible = lineItems.filter((i) => i.showOnQuote).reduce((a, i) => a + i.amount, 0);
+        const hidden = lineItems.filter((i) => !i.showOnQuote).reduce((a, i) => a + i.amount, 0);
+        if (cents(visible + hidden) !== cents(finalTotal)) {
+          errors.push({
+            ruleId: null,
+            message: `Line items sum to ${(visible + hidden).toFixed(2)} but the quote total is ${finalTotal.toFixed(2)} \u2014 the breakdown does not reconcile`
+          });
+        }
+      }
+      return {
+        totals: {
+          gross: roundCents(finalTotal),
+          separatelyQuoted: roundCents(separatelyQuoted),
+          payable: roundCents(finalTotal - separatelyQuoted),
+          groupTotals
+        },
+        errors
+      };
+    }
+    function calculate(config, answers) {
+      const allErrors = [];
+      const lineItems = [];
+      const suppressedRuleIds = [];
+      const lookupValues = {};
+      const { variables, errors: variableErrors } = (0, variables_1.resolveTokens)(config.tokens ?? {});
+      allErrors.push(...variableErrors);
+      const fieldValues = {};
+      for (const [key, answer] of Object.entries(answers)) {
+        const numeric = typeof answer === "boolean" ? answer ? 1 : 0 : Number(answer);
+        if (typeof answer !== "object" && Number.isFinite(numeric))
+          fieldValues[key] = numeric;
+      }
+      let phase1Total = 0;
+      function ruleConditionsMet(rule) {
+        if (rule.condition !== void 0 && !(0, resolver_1.evaluateCondition)(rule.condition, answers))
+          return false;
+        if (rule.scopeCondition !== void 0 && !(0, resolver_1.evaluateCondition)(rule.scopeCondition, answers))
+          return false;
+        return true;
+      }
+      for (const rule of config.rules.phase1) {
+        if (rule.type === "conditional_addon" && rule.feeType === "percent") {
+          continue;
+        }
+        if (!ruleConditionsMet(rule)) {
+          suppressedRuleIds.push(rule.id);
+          continue;
+        }
+        if (rule.type === "unit_rate") {
+          const quantityUnit = config.meta.tokenLabels?.[rule.quantityField]?.unit;
+          const { lineItem, amount, errors } = processUnitRate(rule, answers, variables, lookupValues, fieldValues, quantityUnit);
+          allErrors.push(...errors);
+          if (lineItem !== null) {
+            lineItems.push(lineItem);
+            phase1Total += amount;
+          }
+          continue;
+        }
+        if (rule.type === "conditional_addon") {
+          const { lineItem, amount, errors } = processConditionalAddon(rule, variables, lookupValues, fieldValues);
+          allErrors.push(...errors);
+          if (lineItem !== null) {
+            lineItems.push(lineItem);
+            phase1Total += amount;
+          }
+          continue;
+        }
+        if (rule.type === "lookup_table") {
+          const { lineItem, amount, errors } = processLookupTable(rule, answers, variables, lookupValues);
+          allErrors.push(...errors);
+          if (lineItem !== null) {
+            lookupValues[rule.id] = amount;
+            lineItems.push(lineItem);
+            phase1Total += amount;
+          }
+          continue;
+        }
+      }
+      const phase1SubTotal = phase1Total;
+      for (const rule of config.rules.phase1) {
+        if (!(rule.type === "conditional_addon" && rule.feeType === "percent")) {
+          continue;
+        }
+        if (!ruleConditionsMet(rule)) {
+          suppressedRuleIds.push(rule.id);
+          continue;
+        }
+        const { value: percent, errors: resolveErrors } = (0, resolver_1.resolveExpression)(rule.amountExpr, variables, lookupValues, fieldValues);
+        const errors = resolveErrors.map((e) => ({ ...e, ruleId: rule.id }));
+        allErrors.push(...errors);
+        const amount = roundCents(phase1SubTotal * (percent / 100));
+        const { groupAmounts, errors: groupErrors } = computeGroupAmounts(rule.groupAssignments, amount, variables, lookupValues, rule.id);
+        errors.push(...groupErrors);
+        allErrors.push(...errors);
+        const lineItem = {
+          ruleId: rule.id,
+          label: rule.label,
+          amount,
+          type: "conditional_addon",
+          showOnQuote: rule.showOnQuote,
+          ...rule.tag !== void 0 && { tag: rule.tag },
+          ...groupAmounts !== void 0 && { groupAmounts }
+        };
+        lineItems.push(lineItem);
+        phase1Total += amount;
+      }
+      let runningTotal = phase1Total;
+      for (const rule of config.rules.phase2) {
+        if (!ruleConditionsMet(rule)) {
+          suppressedRuleIds.push(rule.id);
+          continue;
+        }
+        if (rule.type === "selection_multiplier") {
+          const { lineItem, newTotal, errors } = processSelectionMultiplier(rule, answers, runningTotal, variables, lookupValues);
+          allErrors.push(...errors);
+          if (lineItem !== null) {
+            lineItems.push(lineItem);
+          }
+          runningTotal = newTotal;
+          continue;
+        }
+        if (rule.type === "conditional_multiplier") {
+          const { lineItem, newTotal, errors } = processConditionalMultiplier(rule, variables, lookupValues, fieldValues, runningTotal);
+          allErrors.push(...errors);
+          if (lineItem !== null) {
+            lineItems.push(lineItem);
+          }
+          runningTotal = newTotal;
+          continue;
+        }
+      }
+      const phase2Total = runningTotal;
+      let finalTotal = phase2Total;
+      let minimumApplied = false;
+      let minimumAmount = 0;
+      for (const rule of config.rules.phase3) {
+        if (!ruleConditionsMet(rule)) {
+          suppressedRuleIds.push(rule.id);
+          continue;
+        }
+        if (rule.type === "floor_minimum") {
+          const result = processFloorMinimum(rule, variables, lookupValues, fieldValues, finalTotal);
+          allErrors.push(...result.errors);
+          if (result.lineItem !== null) {
+            lineItems.push(result.lineItem);
+          }
+          finalTotal = result.finalTotal;
+          if (result.minimumApplied) {
+            minimumApplied = true;
+            minimumAmount = result.minimumAmount;
+          }
+          continue;
+        }
+      }
+      const { totals, errors: totalsErrors } = buildTotals(lineItems, roundCents(finalTotal), config.meta.displayGroups, minimumApplied);
+      allErrors.push(...totalsErrors);
+      return {
+        phase1Total: roundCents(phase1Total),
+        phase2Total: roundCents(phase2Total),
+        finalTotal: roundCents(finalTotal),
+        minimumApplied,
+        minimumAmount: roundCents(minimumAmount),
+        lineItems,
+        suppressedRuleIds,
+        totals,
+        errors: allErrors
+      };
+    }
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  OnablError: () => OnablError,
+  OnablNetwork: () => OnablNetwork,
+  OnablNotFound: () => OnablNotFound,
+  OnablUnauthorized: () => OnablUnauthorized,
+  OnablValidation: () => OnablValidation,
+  createOnablClient: () => createOnablClient,
+  getAllFields: () => getAllFields,
+  getInitialAnswers: () => getInitialAnswers,
+  getVisibleSteps: () => getVisibleSteps,
+  groupLineItems: () => import_presentation.groupLineItems,
+  presentQuote: () => import_presentation.presentQuote,
+  validateFields: () => validateFields
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/client.ts
+var import_public_api = require("@onabl/contracts/public-api");
+
+// src/errors.ts
+var OnablError = class extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+    this.name = "OnablError";
+  }
+  status;
+};
+var OnablNotFound = class extends OnablError {
+  constructor(message = "Not found") {
+    super(message, 404);
+    this.name = "OnablNotFound";
+  }
+};
+var OnablUnauthorized = class extends OnablError {
+  constructor(message = "Unauthorized") {
+    super(message, 401);
+    this.name = "OnablUnauthorized";
+  }
+};
+var OnablValidation = class extends OnablError {
+  constructor(message, fieldErrors) {
+    super(message, 400);
+    this.fieldErrors = fieldErrors;
+    this.name = "OnablValidation";
+  }
+  fieldErrors;
+};
+var OnablNetwork = class extends OnablError {
+  constructor(message = "Network error", cause) {
+    super(message);
+    this.name = "OnablNetwork";
+    if (cause !== void 0) this.cause = cause;
+  }
+};
+
+// src/client.ts
+var BUILT_AGAINST_API_VERSION = "2026-09-01";
+var DEFAULT_BASE_URL = "https://api.onabl.com";
+var DEFAULT_QUOTE_PATH = "/quote/:uuid";
+function createOnablClient(config) {
+  const baseUrl = config.baseUrl ?? DEFAULT_BASE_URL;
+  const apiVersion = config.apiVersion ?? BUILT_AGAINST_API_VERSION;
+  const quotePath = config.quotePath ?? DEFAULT_QUOTE_PATH;
+  async function request(path, init) {
+    const headers = new Headers(init.headers);
+    headers.set("Onabl-Version", apiVersion);
+    if (init.auth === "secret") {
+      headers.set("x-api-key", config.secretKey);
+    } else {
+      headers.set("Authorization", `Bearer ${init.auth.token}`);
+    }
+    if (init.body) headers.set("Content-Type", "application/json");
+    let response;
+    try {
+      response = await fetch(`${baseUrl}${path}`, { ...init, headers });
+    } catch (cause) {
+      throw new OnablNetwork("Request to onabl failed", cause);
+    }
+    if (response.ok) {
+      if (response.status === 204) return void 0;
+      try {
+        return await response.json();
+      } catch (cause) {
+        throw new OnablNetwork("Received an unparseable response from onabl", cause);
+      }
+    }
+    const body = await response.json().catch(() => void 0);
+    if (response.status === 404) throw new OnablNotFound(body?.message ?? "Not found");
+    if (response.status === 401) throw new OnablUnauthorized(body?.message ?? "Unauthorized");
+    if (response.status === 400) throw new OnablValidation(body?.message ?? "Validation failed", body?.fieldErrors);
+    throw new OnablError(body?.message ?? `Request failed with status ${response.status}`, response.status);
+  }
+  function formPath(opts) {
+    return opts?.slug ? `/forms/q/${config.handle}/${opts.slug}` : `/forms/q/${config.handle}`;
+  }
+  function submissionPath(opts) {
+    return opts?.slug ? `/submissions/q/${config.handle}/${opts.slug}` : `/submissions/q/${config.handle}`;
+  }
+  return {
+    forms: {
+      async get(opts) {
+        const raw = await request(formPath(opts), { method: "GET", auth: "secret" });
+        return import_public_api.PublicFormSchema.parse(raw);
+      },
+      async validateDiscountCode(code, opts) {
+        const raw = await request(`${formPath(opts)}/validate-code?code=${encodeURIComponent(code)}`, { method: "GET", auth: "secret" });
+        return import_public_api.ValidateCodeResponseSchema.parse(raw);
+      }
+    },
+    quotes: {
+      async get(uuid, opts) {
+        const raw = await request(`/quotes/${uuid}`, { method: "GET", auth: opts });
+        return import_public_api.QuoteSchema.parse(raw);
+      },
+      async accept(uuid, opts) {
+        const raw = await request(`/quotes/${uuid}/accept`, { method: "POST", auth: opts });
+        import_public_api.QuoteAcceptResponseSchema.parse(raw);
+      },
+      async decline(uuid, reason, note, opts) {
+        const raw = await request(`/quotes/${uuid}/decline`, { method: "POST", auth: opts, body: JSON.stringify({ declineReason: reason, declineNote: note }) });
+        import_public_api.QuoteDeclineResponseSchema.parse(raw);
+      }
+    },
+    invoices: {
+      async get(uuid, opts) {
+        const raw = await request(`/invoices/${uuid}`, { method: "GET", auth: opts });
+        return import_public_api.InvoiceSchema.parse(raw);
+      },
+      async savePopUrl(uuid, key, milestone, opts) {
+        const path = milestone === "deposit" ? `/invoices/${uuid}/deposit-pop-url` : `/invoices/${uuid}/pop-url`;
+        const raw = await request(path, { method: "PATCH", auth: opts, body: JSON.stringify({ key }) });
+        import_public_api.PopUrlUpdateResponseSchema.parse(raw);
+      }
+    },
+    storage: {
+      async presignPop(resourceId, filename, contentType, fileSize, opts) {
+        const raw = await request("/storage/presign/public", {
+          method: "POST",
+          auth: opts,
+          body: JSON.stringify({ resourceId, filename, contentType, fileSize, pathPrefix: "pop" })
+        });
+        return import_public_api.PresignResponseSchema.parse(raw);
+      }
+    },
+    submissions: {
+      async create(answers, opts) {
+        const path = opts?.isTenantSource ? `${submissionPath(opts)}?source=tenant` : submissionPath(opts);
+        const raw = await request(path, {
+          method: "POST",
+          auth: "secret",
+          body: JSON.stringify({ answers, consentGiven: opts?.consentGiven, discountCode: opts?.discountCode })
+        });
+        const parsed = import_public_api.SubmissionCreateResponseSchema.parse(raw);
+        return { quoteId: parsed.uuid, quoteUrl: quotePath.replace(":uuid", parsed.uuid), token: parsed.token };
+      }
+    }
+  };
+}
+
+// src/presentation.ts
+var import_presentation = __toESM(require_presentation());
+
+// src/form-state.ts
+var import_engine = __toESM(require_engine());
+var import_resolver = __toESM(require_resolver());
+var UNGROUPED_STEP_ID = "__ungrouped";
+function getVisibleSteps(form, answers) {
+  const config = form.config;
+  const steps = [];
+  for (const step of config.steps) {
+    const fields = fieldsForStep(config.fields, step.id, answers);
+    if (fields.length > 0) steps.push({ ...step, fields });
+  }
+  const ungroupedFields = fieldsForStep(config.fields, null, answers);
+  if (ungroupedFields.length > 0) {
+    steps.push({ id: UNGROUPED_STEP_ID, label: "Details", fields: ungroupedFields });
+  }
+  return steps;
+}
+function fieldsForStep(fields, stepId, answers) {
+  return fields.filter((f) => f.stepId === stepId && f.type !== "hidden" && conditionMet(f.condition, answers) && conditionMet(f.scopeCondition, answers));
+}
+function conditionMet(condition, answers) {
+  if (!condition) return true;
+  return (0, import_resolver.evaluateCondition)(condition, answers);
+}
+function getAllFields(form) {
+  return form.config.fields;
+}
+function getInitialAnswers(form) {
+  return (0, import_engine.applyDefaults)(form.config, {});
+}
+function validateFields(fields, answers) {
+  const errors = {};
+  for (const field of fields) {
+    if (!field.required) continue;
+    const value = answers[field.key];
+    if (field.type === "multicheck") {
+      if (!Array.isArray(value) || value.length === 0) {
+        errors[field.key] = "Please select at least one option.";
+      }
+      continue;
+    }
+    if (field.type === "toggle") {
+      if (value === void 0 || value === null || value === "") {
+        errors[field.key] = "Please make a selection.";
+      }
+      continue;
+    }
+    if (field.type === "number") {
+      if (value === void 0 || value === null || value === "") {
+        errors[field.key] = "Please enter a value.";
+        continue;
+      }
+      const num = Number(value);
+      if (isNaN(num)) {
+        errors[field.key] = "Please enter a valid number.";
+        continue;
+      }
+      if (field.min !== void 0 && num < field.min) {
+        errors[field.key] = `Minimum value is ${field.min}.`;
+        continue;
+      }
+      if (field.max !== void 0 && num > field.max) {
+        errors[field.key] = `Maximum value is ${field.max}.`;
+        continue;
+      }
+      continue;
+    }
+    if (field.type === "date") {
+      if (!value || value === "") {
+        errors[field.key] = "Please enter a date.";
+        continue;
+      }
+      if (isNaN(new Date(value).getTime())) {
+        errors[field.key] = "Please enter a valid date.";
+      }
+      continue;
+    }
+    if (!value || value === "") {
+      const isChoice = field.type === "radio" || field.type === "select";
+      errors[field.key] = isChoice ? "Please make a selection." : "This field is required.";
+    }
+  }
+  return errors;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  OnablError,
+  OnablNetwork,
+  OnablNotFound,
+  OnablUnauthorized,
+  OnablValidation,
+  createOnablClient,
+  getAllFields,
+  getInitialAnswers,
+  getVisibleSteps,
+  groupLineItems,
+  presentQuote,
+  validateFields
+});
+//# sourceMappingURL=index.js.map