@munchi_oy/cart-engine 0.1.0

package/dist/index.cjs

@@ -0,0 +1,889 @@
+"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 __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);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ApplyTo: () => ApplyTo,
+  Cart: () => Cart,
+  VERSION: () => VERSION,
+  allocateProportionalMinorUnits: () => allocateProportionalMinorUnits,
+  calculateCartPriceSnapshot: () => calculateCartPriceSnapshot,
+  calculateDiscountAmount: () => calculateDiscountAmount,
+  calculateItemPrice: () => calculateItemPrice,
+  calculateOrderTaxSummary: () => calculateOrderTaxSummary,
+  calculateSequentialDiscountTotal: () => calculateSequentialDiscountTotal,
+  splitTaxInclusiveAmount: () => splitTaxInclusiveAmount
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/cart/Cart.ts
+var import_core4 = require("@munchi_oy/core");
+var import_cuid2 = require("@paralleldrive/cuid2");
+var import_dayjs = __toESM(require("dayjs"), 1);
+var import_lodash = __toESM(require("lodash"), 1);
+
+// src/pricing/calculator.ts
+var import_core2 = require("@munchi_oy/core");
+
+// src/discount/calculator.ts
+var import_core = require("@munchi_oy/core");
+
+// src/utils/index.ts
+var withSafeIntegers = (fn, ignoreIndexes = []) => {
+  return (...args) => {
+    args.forEach((arg, index) => {
+      if (typeof arg === "number" && !ignoreIndexes.includes(index) && !Number.isInteger(arg)) {
+        throw new Error(
+          `[CartEngine SafeLock] Argument at position ${index} MUST be an integer (minor unit). Received: ${arg}`
+        );
+      }
+    });
+    return fn(...args);
+  };
+};
+function mergeDefinedValue(currentValue, nextValue, hasChanges) {
+  if (nextValue === void 0 || currentValue === nextValue) {
+    return [currentValue, hasChanges];
+  }
+  return [nextValue, true];
+}
+
+// src/discount/calculator.ts
+var discountStrategies = {
+  [import_core.DiscountType.Fixed]: withSafeIntegers(
+    (value, totalAmount) => {
+      return Math.min(value, totalAmount);
+    }
+  ),
+  [import_core.DiscountType.Percentage]: withSafeIntegers(
+    (value, totalAmount) => {
+      return Math.floor(totalAmount * value / 100);
+    },
+    [0]
+  ),
+  default: () => 0
+};
+function calculateDiscountAmount(type, value, totalAmountBeforeDiscounts) {
+  const strategy = discountStrategies[type] ?? discountStrategies.default;
+  return strategy(value, totalAmountBeforeDiscounts);
+}
+function calculateSequentialDiscountTotal(discounts, initialAmount) {
+  let remainingAmount = initialAmount;
+  let totalDiscountAmount = 0;
+  for (const discount of discounts) {
+    const discountAmount = Math.min(
+      calculateDiscountAmount(discount.type, discount.value, remainingAmount),
+      remainingAmount
+    );
+    totalDiscountAmount += discountAmount;
+    remainingAmount -= discountAmount;
+  }
+  return {
+    totalDiscountAmount,
+    remainingAmount
+  };
+}
+
+// src/pricing/calculator.ts
+var assertMinorUnit = (value, fieldName) => {
+  if (!Number.isInteger(value)) {
+    throw new Error(
+      `[CartEngine SafeLock] ${fieldName} MUST be an integer (minor unit). Received: ${value}`
+    );
+  }
+};
+function calculateItemPrice(details) {
+  assertMinorUnit(details.basePriceInMinorUnit, "details.basePriceInMinorUnit");
+  assertMinorUnit(details.quantity, "details.quantity");
+  const totalOptionsPrice = details.options.reduce((sum, opt) => {
+    return sum + opt.suboptions.reduce((subSum, sub) => {
+      assertMinorUnit(sub.price.amount, "option.price.amount");
+      assertMinorUnit(sub.quantity, "option.quantity");
+      return subSum + sub.price.amount * sub.quantity;
+    }, 0);
+  }, 0);
+  const singleUnitPriceAmount = details.basePriceInMinorUnit + totalOptionsPrice;
+  const totalAmountBeforeDiscounts = singleUnitPriceAmount * details.quantity;
+  let discountAmount = 0;
+  if (details.discount) {
+    discountAmount = calculateDiscountAmount(
+      details.discount.type,
+      details.discount.value,
+      totalAmountBeforeDiscounts
+    );
+  }
+  const totalAfterDiscount = totalAmountBeforeDiscounts - discountAmount;
+  return {
+    unitPrice: { amount: singleUnitPriceAmount, currency: details.currency },
+    basePrice: {
+      amount: details.basePriceInMinorUnit,
+      currency: details.currency
+    },
+    vatPercentage: details.taxRate,
+    total: { amount: totalAfterDiscount, currency: details.currency },
+    priceBreakdown: {
+      totalBeforeDiscounts: {
+        amount: totalAmountBeforeDiscounts,
+        currency: details.currency
+      },
+      totalDiscounts: { amount: discountAmount, currency: details.currency },
+      subtotalBasketDiscounts: { amount: 0, currency: details.currency },
+      subtotalItemDiscounts: { amount: 0, currency: details.currency },
+      basePriceBeforeDiscounts: {
+        amount: details.basePriceInMinorUnit * details.quantity,
+        currency: details.currency
+      },
+      unitPriceBeforeDiscounts: {
+        amount: singleUnitPriceAmount,
+        currency: details.currency
+      },
+      subtotalOptionsBasketDiscounts: { amount: 0, currency: details.currency },
+      subtotalOptionsItemDiscounts: { amount: 0, currency: details.currency }
+    }
+  };
+}
+function calculateCartPriceSnapshot(details) {
+  const activeItems = details.items.filter(
+    (item) => item.kitchenStatus !== import_core2.KitchenStatus.Cancelled
+  );
+  const totalBeforeDiscountsAmount = activeItems.reduce(
+    (sum, item) => sum + (item.itemPrice.priceBreakdown.totalBeforeDiscounts.amount ?? 0),
+    0
+  );
+  const subtotalItemDiscountsAmount = activeItems.reduce(
+    (sum, item) => sum + (item.itemPrice.priceBreakdown.totalDiscounts.amount ?? 0),
+    0
+  );
+  const cartDiscounts = details.discounts.filter((discount) => discount.scope === import_core2.DiscountScope.Cart).sort(
+    (left, right) => new Date(left.createdAt).getTime() - new Date(right.createdAt).getTime()
+  );
+  const grossAfterItemDiscounts = Math.max(
+    0,
+    totalBeforeDiscountsAmount - subtotalItemDiscountsAmount
+  );
+  const cartDiscountCalculation = calculateSequentialDiscountTotal(
+    cartDiscounts,
+    grossAfterItemDiscounts
+  );
+  const totalDiscountsAmount = subtotalItemDiscountsAmount + cartDiscountCalculation.totalDiscountAmount;
+  const price = {
+    priceBreakdown: {
+      totalBeforeDiscounts: {
+        amount: totalBeforeDiscountsAmount,
+        currency: details.currency
+      },
+      subtotalItemDiscounts: {
+        amount: subtotalItemDiscountsAmount,
+        currency: details.currency
+      },
+      subtotalBasketDiscounts: {
+        amount: cartDiscountCalculation.totalDiscountAmount,
+        currency: details.currency
+      },
+      totalDiscounts: {
+        amount: totalDiscountsAmount,
+        currency: details.currency
+      }
+    },
+    total: {
+      amount: cartDiscountCalculation.remainingAmount,
+      currency: details.currency
+    }
+  };
+  return {
+    activeItems,
+    totalBeforeDiscountsAmount,
+    subtotalItemDiscountsAmount,
+    subtotalBasketDiscountsAmount: cartDiscountCalculation.totalDiscountAmount,
+    totalDiscountsAmount,
+    totalAmount: cartDiscountCalculation.remainingAmount,
+    price
+  };
+}
+
+// src/tax/index.ts
+var import_core3 = require("@munchi_oy/core");
+
+// src/discount/modulo.ts
+var allocateProportionalMinorUnits = withSafeIntegers(
+  (weights, totalAmount) => {
+    for (let i = 0; i < weights.length; i++) {
+      if (!Number.isInteger(weights[i])) {
+        throw new Error(
+          `[CartEngine SafeLock] Weight at index ${i} MUST be an integer. Received: ${weights[i]}`
+        );
+      }
+    }
+    if (weights.length === 0 || totalAmount <= 0) {
+      return new Array(weights.length).fill(0);
+    }
+    const totalWeight = weights.reduce((sum, weight) => sum + weight, 0);
+    if (totalWeight <= 0) {
+      return new Array(weights.length).fill(0);
+    }
+    const baseAllocations = weights.map(
+      (weight) => Math.floor(weight * totalAmount / totalWeight)
+    );
+    const remainderOrder = weights.map((weight, index) => ({
+      index,
+      remainder: weight * totalAmount % totalWeight
+    })).sort(
+      (left, right) => right.remainder - left.remainder || left.index - right.index
+    );
+    let remainingAmount = totalAmount - baseAllocations.reduce((sum, amount) => sum + amount, 0);
+    for (const { index } of remainderOrder) {
+      if (remainingAmount <= 0) break;
+      baseAllocations[index] = (baseAllocations[index] ?? 0) + 1;
+      remainingAmount -= 1;
+    }
+    return baseAllocations;
+  }
+);
+
+// src/tax/index.ts
+function assertMinorUnit2(value, fieldName) {
+  if (!Number.isInteger(value)) {
+    throw new Error(
+      `[CartEngine SafeLock] ${fieldName} MUST be an integer. Received: ${value}`
+    );
+  }
+}
+function assertValidTaxRate(value, fieldName) {
+  if (!Number.isFinite(value) || value < 0) {
+    throw new Error(
+      `[CartEngine SafeLock] ${fieldName} MUST be a finite non-negative number. Received: ${value}`
+    );
+  }
+}
+function toTaxRateBasisPoints(taxRate) {
+  const normalized = taxRate.toString();
+  if (!/^\d+(\.\d+)?$/.test(normalized)) {
+    throw new Error(
+      `[CartEngine SafeLock] taxRate MUST be a decimal number with dot notation. Received: ${taxRate}`
+    );
+  }
+  const [wholePart, decimalPart = ""] = normalized.split(".");
+  const paddedDecimals = `${decimalPart}00`.slice(0, 2);
+  return Number(wholePart) * 100 + Number(paddedDecimals);
+}
+function splitTaxInclusiveAmount(totalWithTax, taxRate) {
+  assertMinorUnit2(totalWithTax, "totalWithTax");
+  assertValidTaxRate(taxRate, "taxRate");
+  if (taxRate <= 0) {
+    return {
+      taxRate,
+      totalWithTax,
+      totalWithoutTax: totalWithTax,
+      totalTax: 0
+    };
+  }
+  const taxRateBasisPoints = toTaxRateBasisPoints(taxRate);
+  const totalWithoutTax = Math.floor(
+    totalWithTax * 1e4 / (1e4 + taxRateBasisPoints)
+  );
+  return {
+    taxRate,
+    totalWithTax,
+    totalWithoutTax,
+    totalTax: totalWithTax - totalWithoutTax
+  };
+}
+function calculateOrderTaxSummary(details) {
+  const priceSnapshot = calculateCartPriceSnapshot({
+    items: details.items,
+    discounts: details.discounts,
+    currency: details.currency
+  });
+  const activeItems = details.items.filter(
+    (item) => item.kitchenStatus !== import_core3.KitchenStatus.Cancelled
+  );
+  if (activeItems.length === 0 || priceSnapshot.totalAmount <= 0) {
+    return {
+      taxSummaries: [],
+      totalWithoutTax: 0,
+      totalTax: 0,
+      grandTotal: 0
+    };
+  }
+  const basketDiscountAllocations = allocateProportionalMinorUnits(
+    activeItems.map((item) => item.itemPrice.total.amount),
+    priceSnapshot.subtotalBasketDiscountsAmount
+  );
+  const taxRateMap = /* @__PURE__ */ new Map();
+  activeItems.forEach((item, index) => {
+    if (item.taxRate <= 0) {
+      return;
+    }
+    const totalWithTax = Math.max(
+      0,
+      item.itemPrice.total.amount - (basketDiscountAllocations[index] ?? 0)
+    );
+    const taxBreakdown = splitTaxInclusiveAmount(totalWithTax, item.taxRate);
+    const existing = taxRateMap.get(item.taxRate) ?? {
+      totalWithTax: 0,
+      totalTax: 0,
+      totalWithoutTax: 0
+    };
+    existing.totalWithTax += taxBreakdown.totalWithTax;
+    existing.totalTax += taxBreakdown.totalTax;
+    existing.totalWithoutTax += taxBreakdown.totalWithoutTax;
+    taxRateMap.set(item.taxRate, existing);
+  });
+  const taxSummaries = Array.from(taxRateMap.entries()).sort((left, right) => left[0] - right[0]).map(([taxRate, values]) => ({
+    taxRate,
+    totalWithoutTax: values.totalWithoutTax,
+    totalTax: values.totalTax,
+    totalWithTax: values.totalWithTax
+  }));
+  return {
+    taxSummaries,
+    totalWithoutTax: taxSummaries.reduce(
+      (sum, item) => sum + item.totalWithoutTax,
+      0
+    ),
+    totalTax: taxSummaries.reduce((sum, item) => sum + item.totalTax, 0),
+    grandTotal: priceSnapshot.totalAmount
+  };
+}
+
+// src/cart/Cart.ts
+var { isEqual } = import_lodash.default;
+var Cart = class _Cart {
+  id;
+  businessId;
+  currency;
+  createdAt;
+  orderNumber;
+  orderType;
+  orderFormat;
+  spotNumber;
+  comments;
+  orderRefundStatus;
+  updatedAt;
+  status;
+  _loyaltyTransactionIds;
+  _loyaltyProgramId;
+  _items = [];
+  _locatorType;
+  _business;
+  _discounts = [];
+  _customer = null;
+  _refunds = [];
+  _taxSummary;
+  _newlyCancelledItemIds;
+  _invoiceCompany;
+  _staffId;
+  _shiftId;
+  version = "1.0.2";
+  constructor(id, createdAt, options) {
+    this.id = id;
+    this.createdAt = createdAt;
+    this.businessId = options.businessId;
+    this.orderType = options.orderType;
+    this.orderNumber = options.orderNumber;
+    this._business = options.business;
+    this.currency = options.currency;
+    this.updatedAt = createdAt;
+    this.spotNumber = null;
+    this.comments = null;
+    this._loyaltyTransactionIds = [];
+    this._loyaltyProgramId = null;
+    this.orderRefundStatus = import_core4.OrderRefundStatus.None;
+    this.status = import_core4.OrderStatusEnum.Draft;
+    this.orderFormat = import_core4.OrderFormat.Instant;
+    this._locatorType = import_core4.LocatorType.Table;
+    this._newlyCancelledItemIds = /* @__PURE__ */ new Set();
+    this._staffId = options.staffId ?? null;
+    this._shiftId = options.shiftId ?? null;
+    this._invoiceCompany = null;
+  }
+  static create(options) {
+    return new _Cart((0, import_cuid2.createId)(), options.createdAt ?? (0, import_dayjs.default)().toDate(), {
+      businessId: options.businessId,
+      orderType: options.orderType ?? import_core4.OrderTypePOS.DineIn,
+      orderNumber: options.orderNumber,
+      currency: options.currency,
+      business: options.business,
+      staffId: options.staffId,
+      shiftId: options.shiftId
+    });
+  }
+  static fromData(orderDto) {
+    const cart = new _Cart(orderDto.id, (0, import_dayjs.default)(orderDto.createdAt).toDate(), {
+      businessId: orderDto.businessId,
+      orderType: orderDto.orderType,
+      orderNumber: orderDto.orderNumber,
+      currency: orderDto.currency,
+      business: orderDto.business,
+      staffId: orderDto.staffId ?? null,
+      shiftId: orderDto.shiftId ?? null
+    });
+    cart.updatedAt = (0, import_dayjs.default)(orderDto.updatedAt).toDate();
+    cart.spotNumber = orderDto.spotNumber;
+    cart.comments = orderDto.comments;
+    cart.orderRefundStatus = orderDto.orderRefundStatus;
+    cart._locatorType = orderDto.locatorType;
+    cart._items = [...orderDto.items];
+    cart.status = orderDto.status;
+    cart.orderFormat = orderDto.orderFormat ?? import_core4.OrderFormat.Instant;
+    cart._discounts = (orderDto.discounts ?? []).map((discount) => ({
+      ...discount,
+      createdAt: (0, import_dayjs.default)(discount.createdAt).toDate().toISOString()
+    }));
+    cart._customer = orderDto.customer ? { ...orderDto.customer } : null;
+    cart._refunds = orderDto.refunds ? [...orderDto.refunds] : [];
+    cart._loyaltyTransactionIds = [...orderDto.loyaltyTransactionIds];
+    cart._loyaltyProgramId = orderDto.loyaltyProgramId ?? null;
+    cart._newlyCancelledItemIds = /* @__PURE__ */ new Set();
+    cart._taxSummary = orderDto.taxSummary;
+    cart._invoiceCompany = orderDto.invoiceCompany ?? null;
+    return cart;
+  }
+  get items() {
+    return this._items;
+  }
+  get locatorType() {
+    return this._locatorType;
+  }
+  get staffId() {
+    return this._staffId;
+  }
+  get shiftId() {
+    return this._shiftId;
+  }
+  get discounts() {
+    return this._discounts;
+  }
+  get customer() {
+    return this._customer;
+  }
+  get refunds() {
+    return this._refunds;
+  }
+  get loyaltyProgramId() {
+    return this._loyaltyProgramId;
+  }
+  get loyaltyTransactionIds() {
+    return this._loyaltyTransactionIds;
+  }
+  get invoiceCompany() {
+    return this._invoiceCompany;
+  }
+  get price() {
+    return calculateCartPriceSnapshot({
+      items: this._items,
+      discounts: this._discounts,
+      currency: this.currency
+    }).price;
+  }
+  setInvoiceCompany(company) {
+    if (this._invoiceCompany?.id === company?.id) {
+      return;
+    }
+    this._invoiceCompany = company;
+    this.touch();
+  }
+  addItem(itemData, requiresPrep = false) {
+    const lockedStatuses = [
+      import_core4.KitchenStatus.DispatchedToKitchen,
+      import_core4.KitchenStatus.SentToOm,
+      import_core4.KitchenStatus.Completed,
+      import_core4.KitchenStatus.Cancelled
+    ];
+    const existingModifiableItem = this._items.find(
+      (item) => item.posId === itemData.posId && isEqual(item.options, itemData.options) && item.comments === itemData.comments && !lockedStatuses.includes(item.kitchenStatus) && item.discount === null
+    );
+    if (existingModifiableItem) {
+      this._items = this._items.map((item) => {
+        if (item.lineItemId !== existingModifiableItem.lineItemId) {
+          return item;
+        }
+        const quantity = item.quantity + itemData.quantity;
+        const itemPrice = calculateItemPrice({
+          basePriceInMinorUnit: item.basePrice.amount,
+          quantity,
+          taxRate: item.taxRate,
+          options: item.options,
+          currency: this.currency
+        });
+        return {
+          ...item,
+          quantity,
+          itemPrice
+        };
+      });
+      this.touch();
+      return;
+    }
+    this._items.push({
+      ...itemData,
+      lineItemId: (0, import_cuid2.createId)(),
+      kitchenStatus: requiresPrep ? import_core4.KitchenStatus.Pending : import_core4.KitchenStatus.NotApplicable,
+      paymentStatus: import_core4.PosPaymentStatus.Unpaid,
+      discount: null
+    });
+    this.touch();
+  }
+  updateItem(lineItemId, updatedItem) {
+    const itemIndex = this._items.findIndex(
+      (item) => item.lineItemId === lineItemId
+    );
+    if (itemIndex === -1) {
+      return;
+    }
+    this._items[itemIndex] = updatedItem;
+    this.touch();
+  }
+  removeItem(lineItemId) {
+    this._items = this._items.filter((item) => item.lineItemId !== lineItemId);
+    this.touch();
+  }
+  updateItemStatus(lineItemId, newStatus) {
+    const itemIndex = this._items.findIndex(
+      (item2) => item2.lineItemId === lineItemId
+    );
+    if (itemIndex === -1 || !this._items[itemIndex]) {
+      return;
+    }
+    const item = this._items[itemIndex];
+    const isKitchenStatus = Object.values(import_core4.KitchenStatus).includes(
+      newStatus
+    );
+    if (isKitchenStatus && newStatus === import_core4.KitchenStatus.Cancelled && item.kitchenStatus !== import_core4.KitchenStatus.Cancelled) {
+      this._newlyCancelledItemIds.add(lineItemId);
+    }
+    this._items = this._items.map((currentItem) => {
+      if (currentItem.lineItemId !== lineItemId) {
+        return currentItem;
+      }
+      if (isKitchenStatus) {
+        return {
+          ...currentItem,
+          kitchenStatus: newStatus
+        };
+      }
+      return {
+        ...currentItem,
+        paymentStatus: newStatus
+      };
+    });
+    this.touch();
+  }
+  getNewlyCancelledItemIds() {
+    return Array.from(this._newlyCancelledItemIds);
+  }
+  clearCancellationTracking() {
+    this._newlyCancelledItemIds.clear();
+  }
+  applyDiscountToCart(discountData) {
+    this._discounts.push({
+      ...discountData,
+      scope: import_core4.DiscountScope.Cart,
+      lineItemId: null,
+      createdAt: (0, import_dayjs.default)().toDate().toISOString()
+    });
+    this.touch();
+  }
+  applyDiscountToItem(lineItemId, discountData) {
+    const newDiscount = {
+      ...discountData,
+      scope: import_core4.DiscountScope.Item,
+      lineItemId,
+      createdAt: (0, import_dayjs.default)().toDate().toISOString()
+    };
+    const existingDiscountIndex = this._discounts.findIndex(
+      (discount) => discount.lineItemId === lineItemId && discount.scope === import_core4.DiscountScope.Item
+    );
+    if (existingDiscountIndex !== -1) {
+      this._discounts[existingDiscountIndex] = newDiscount;
+    } else {
+      this._discounts.push(newDiscount);
+    }
+    this._items = this._items.map((item) => {
+      if (item.lineItemId !== lineItemId) {
+        return item;
+      }
+      return {
+        ...item,
+        itemPrice: calculateItemPrice({
+          basePriceInMinorUnit: item.basePrice.amount,
+          quantity: item.quantity,
+          taxRate: item.taxRate,
+          options: item.options,
+          currency: this.currency,
+          discount: {
+            type: newDiscount.type,
+            value: newDiscount.value
+          }
+        }),
+        discount: newDiscount
+      };
+    });
+    this.touch();
+  }
+  removeItemDiscount(lineItemId) {
+    this._items = this._items.map((item) => {
+      if (item.lineItemId !== lineItemId) {
+        return item;
+      }
+      return {
+        ...item,
+        itemPrice: calculateItemPrice({
+          basePriceInMinorUnit: item.basePrice.amount,
+          quantity: item.quantity,
+          taxRate: item.taxRate,
+          options: item.options,
+          currency: this.currency
+        }),
+        discount: null
+      };
+    });
+    this._discounts = this._discounts.filter(
+      (discount) => discount.lineItemId !== lineItemId || discount.scope !== import_core4.DiscountScope.Item
+    );
+    this.touch();
+  }
+  removeDiscount(discountId) {
+    this._discounts = this._discounts.filter(
+      (discount) => discount.id !== discountId
+    );
+    this.touch();
+  }
+  setCustomer(customer) {
+    if (this._customer?.id === customer?.id) {
+      return;
+    }
+    this._customer = customer;
+    this.touch();
+  }
+  updateDetails(details) {
+    let hasChanges = false;
+    [this.orderNumber, hasChanges] = mergeDefinedValue(
+      this.orderNumber,
+      details.orderNumber,
+      hasChanges
+    );
+    [this.spotNumber, hasChanges] = mergeDefinedValue(
+      this.spotNumber,
+      details.spotNumber,
+      hasChanges
+    );
+    [this.orderType, hasChanges] = mergeDefinedValue(
+      this.orderType,
+      details.orderType,
+      hasChanges
+    );
+    [this.comments, hasChanges] = mergeDefinedValue(
+      this.comments,
+      details.comments,
+      hasChanges
+    );
+    [this._locatorType, hasChanges] = mergeDefinedValue(
+      this._locatorType,
+      details._locatorType,
+      hasChanges
+    );
+    if (hasChanges) {
+      this.touch();
+    }
+  }
+  setComment(details) {
+    if (details.scope === "order") {
+      if (this.comments === details.comment) {
+        return;
+      }
+      this.comments = details.comment;
+      this.touch();
+      return;
+    }
+    if (!details.lineItemId) {
+      return;
+    }
+    let hasChanges = false;
+    this._items = this._items.map((item) => {
+      if (item.lineItemId !== details.lineItemId || item.comments === details.comment) {
+        return item;
+      }
+      hasChanges = true;
+      return {
+        ...item,
+        comments: details.comment
+      };
+    });
+    if (hasChanges) {
+      this.touch();
+    }
+  }
+  setStaffContext(staffId, shiftId) {
+    if (this._staffId === staffId && this._shiftId === shiftId) {
+      return;
+    }
+    this._staffId = staffId;
+    this._shiftId = shiftId;
+    this.touch();
+  }
+  updateOrderStatus(newStatus) {
+    if (this.status === newStatus) {
+      return;
+    }
+    this.status = newStatus;
+    this.touch();
+  }
+  updateOrderFormat(newFormat) {
+    if (this.orderFormat === newFormat) {
+      return;
+    }
+    this.orderFormat = newFormat;
+    this.touch();
+  }
+  updateLoyaltyProgramId(id) {
+    if (this._loyaltyProgramId === id) {
+      return;
+    }
+    this._loyaltyProgramId = id;
+    this.touch();
+  }
+  updateLoyaltyTransactionId(id) {
+    if (!id || this._loyaltyTransactionIds.includes(id)) {
+      return;
+    }
+    this._loyaltyTransactionIds.push(id);
+    this.touch();
+  }
+  setLoyaltyContext(customer, loyaltyProgramId) {
+    let hasChanges = false;
+    if (this._customer?.id !== customer?.id) {
+      this._customer = customer;
+      hasChanges = true;
+    }
+    if (this._loyaltyProgramId !== loyaltyProgramId) {
+      this._loyaltyProgramId = loyaltyProgramId;
+      hasChanges = true;
+    }
+    if (hasChanges) {
+      this.touch();
+    }
+  }
+  toJSON(paymentEvents = []) {
+    return {
+      id: this.id,
+      businessId: this.businessId,
+      business: this._business,
+      currency: this.currency,
+      createdAt: this.createdAt.toISOString(),
+      updatedAt: this.updatedAt.toISOString(),
+      orderNumber: this.orderNumber,
+      orderFormat: this.orderFormat,
+      orderType: this.orderType,
+      locatorType: this._locatorType,
+      spotNumber: this.spotNumber,
+      comments: this.comments,
+      orderRefundStatus: this.orderRefundStatus,
+      items: this._items,
+      status: this.status,
+      discounts: this._discounts.map((discount) => ({
+        ...discount,
+        createdAt: discount.createdAt
+      })),
+      customer: this._customer,
+      refunds: this._refunds,
+      basketPrice: this.price,
+      paymentEvents,
+      loyaltyTransactionIds: this._loyaltyTransactionIds,
+      loyaltyProgramId: this._loyaltyProgramId,
+      taxSummary: this.calculateOrderTaxSummary(),
+      version: this.version,
+      staffId: this._staffId,
+      shiftId: this._shiftId,
+      invoiceCompany: this._invoiceCompany
+    };
+  }
+  clone() {
+    const newCart = new _Cart(this.id, this.createdAt, {
+      businessId: this.businessId,
+      orderType: this.orderType,
+      orderNumber: this.orderNumber,
+      currency: this.currency,
+      business: this._business,
+      staffId: this._staffId,
+      shiftId: this._shiftId
+    });
+    newCart.updatedAt = this.updatedAt;
+    newCart.spotNumber = this.spotNumber;
+    newCart.comments = this.comments;
+    newCart.orderRefundStatus = this.orderRefundStatus;
+    newCart._locatorType = this._locatorType;
+    newCart._items = [...this._items];
+    newCart.status = this.status;
+    newCart.orderFormat = this.orderFormat;
+    newCart._discounts = [...this._discounts];
+    newCart._customer = this._customer ? { ...this._customer } : null;
+    newCart._refunds = [...this._refunds];
+    newCart._loyaltyProgramId = this._loyaltyProgramId;
+    newCart._loyaltyTransactionIds = [...this._loyaltyTransactionIds];
+    newCart._taxSummary = this._taxSummary;
+    newCart._newlyCancelledItemIds = new Set(this._newlyCancelledItemIds);
+    newCart._invoiceCompany = this._invoiceCompany ? { ...this._invoiceCompany } : null;
+    return newCart;
+  }
+  calculateOrderTaxSummary() {
+    return calculateOrderTaxSummary({
+      items: this._items,
+      discounts: this._discounts,
+      currency: this.currency
+    });
+  }
+  touch() {
+    this.updatedAt = (0, import_dayjs.default)().toDate();
+  }
+};
+
+// src/types/index.ts
+var ApplyTo = /* @__PURE__ */ ((ApplyTo2) => {
+  ApplyTo2["Order"] = "order";
+  ApplyTo2["Item"] = "item";
+  return ApplyTo2;
+})(ApplyTo || {});
+
+// src/version.ts
+var VERSION = "0.1.0";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApplyTo,
+  Cart,
+  VERSION,
+  allocateProportionalMinorUnits,
+  calculateCartPriceSnapshot,
+  calculateDiscountAmount,
+  calculateItemPrice,
+  calculateOrderTaxSummary,
+  calculateSequentialDiscountTotal,
+  splitTaxInclusiveAmount
+});