@tallyui/pos 0.1.0

package/src/order/order-manager.test.ts

@@ -0,0 +1,209 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { firstValueFrom } from 'rxjs';
+import { createRxDatabase, addRxPlugin, type RxDatabase } from 'rxdb';
+import { RxDBDevModePlugin } from 'rxdb/plugins/dev-mode';
+import { getRxStorageMemory } from 'rxdb/plugins/storage-memory';
+import { wrappedValidateAjvStorage } from 'rxdb/plugins/validate-ajv';
+import { createOrderManager } from './order-manager';
+import type { ProductTraits } from '@tallyui/core';
+import type { TaxContext } from '../tax/types';
+
+addRxPlugin(RxDBDevModePlugin);
+
+const storage = wrappedValidateAjvStorage({ storage: getRxStorageMemory() });
+
+const traits: ProductTraits = {
+  getId: (doc) => doc.id,
+  getName: (doc) => doc.name,
+  getSku: () => '',
+  getPrice: (doc) => String(doc.price),
+  getRegularPrice: (doc) => String(doc.price),
+  getSalePrice: () => undefined,
+  isOnSale: () => false,
+  getImageUrl: () => undefined,
+  getImageUrls: () => [],
+  getDescription: () => undefined,
+  getStockStatus: () => 'instock',
+  getStockQuantity: () => null,
+  hasVariants: () => false,
+  getType: () => 'simple',
+  getBarcode: () => undefined,
+  getCategoryNames: () => [],
+};
+
+const taxContext: TaxContext = { getTaxRate: () => 0, pricesIncludeTax: false };
+const product = { id: 'p1', name: 'Coffee', price: 5 };
+
+const draftsSchema = {
+  version: 0,
+  primaryKey: 'id',
+  type: 'object' as const,
+  properties: {
+    id: { type: 'string', maxLength: 100 },
+    data: { type: 'string' },
+    customerName: { type: 'string' },
+    itemCount: { type: 'integer', minimum: 0, maximum: 2147483647, multipleOf: 1 },
+    total: { type: 'number' },
+    parkedAt: { type: 'string' },
+  },
+  required: ['id', 'data'] as const,
+};
+
+describe('OrderManager', () => {
+  let db: RxDatabase;
+
+  beforeEach(async () => {
+    db = await createRxDatabase({
+      name: `test_mgr_${Date.now()}`,
+      storage,
+      multiInstance: false,
+      ignoreDuplicate: true,
+    });
+    await db.addCollections({ pos_drafts: { schema: draftsSchema } });
+  });
+
+  afterEach(async () => {
+    await db?.close();
+  });
+
+  it('starts with an active order', async () => {
+    const mgr = createOrderManager({ currency: 'USD', taxContext, draftsCollection: db.pos_drafts });
+    const builder = await firstValueFrom(mgr.activeOrder$);
+    expect(builder).toBeDefined();
+
+    const order = await firstValueFrom(builder.order$);
+    expect(order.status).toBe('draft');
+  });
+
+  it('creates a new order and switches to it', async () => {
+    const mgr = createOrderManager({ currency: 'USD', taxContext, draftsCollection: db.pos_drafts });
+
+    const first = await firstValueFrom(mgr.activeOrder$);
+    const firstOrder = await firstValueFrom(first.order$);
+
+    mgr.newOrder();
+    const second = await firstValueFrom(mgr.activeOrder$);
+    const secondOrder = await firstValueFrom(second.order$);
+
+    expect(firstOrder.id).not.toBe(secondOrder.id);
+  });
+
+  it('parks an order to local storage and lists it', async () => {
+    const mgr = createOrderManager({ currency: 'USD', taxContext, draftsCollection: db.pos_drafts });
+
+    const builder = await firstValueFrom(mgr.activeOrder$);
+    builder.addProduct(product, traits);
+    builder.setCustomer({ id: 'c1', name: 'Alice' });
+
+    await mgr.parkCurrentOrder();
+
+    const parked = await firstValueFrom(mgr.parkedOrders$);
+    expect(parked).toHaveLength(1);
+    expect(parked[0].customerName).toBe('Alice');
+    expect(parked[0].itemCount).toBe(1);
+    expect(parked[0].source).toBe('local');
+  });
+
+  it('resumes a parked order', async () => {
+    const mgr = createOrderManager({ currency: 'USD', taxContext, draftsCollection: db.pos_drafts });
+
+    const builder = await firstValueFrom(mgr.activeOrder$);
+    builder.addProduct(product, traits);
+    const orderId = (await firstValueFrom(builder.order$)).id;
+
+    await mgr.parkCurrentOrder();
+    await mgr.resumeOrder(orderId);
+
+    const resumed = await firstValueFrom(mgr.activeOrder$);
+    const order = await firstValueFrom(resumed.order$);
+    expect(order.id).toBe(orderId);
+    expect(order.lineItems).toHaveLength(1);
+  });
+
+  it('deletes a parked order', async () => {
+    const mgr = createOrderManager({ currency: 'USD', taxContext, draftsCollection: db.pos_drafts });
+
+    const builder = await firstValueFrom(mgr.activeOrder$);
+    builder.addProduct(product, traits);
+    const orderId = (await firstValueFrom(builder.order$)).id;
+
+    await mgr.parkCurrentOrder();
+    await mgr.deleteParkedOrder(orderId);
+
+    const parked = await firstValueFrom(mgr.parkedOrders$);
+    expect(parked).toHaveLength(0);
+  });
+
+  it('preserves line-level discounts through park/resume', async () => {
+    const mgr = createOrderManager({ currency: 'USD', taxContext, draftsCollection: db.pos_drafts });
+
+    const builder = await firstValueFrom(mgr.activeOrder$);
+    const lineId = builder.addProduct(product, traits);
+    builder.applyLineDiscount(lineId, { type: 'percentage', value: 10, label: '10% off' });
+    const orderId = (await firstValueFrom(builder.order$)).id;
+
+    await mgr.parkCurrentOrder();
+    await mgr.resumeOrder(orderId);
+
+    const resumed = await firstValueFrom(mgr.activeOrder$);
+    const order = await firstValueFrom(resumed.order$);
+    expect(order.lineItems[0].discounts).toHaveLength(1);
+    expect(order.lineItems[0].discounts[0].label).toBe('10% off');
+    expect(order.lineItems[0].discountAmount).toBeCloseTo(0.50); // 10% of $5
+  });
+
+  it('preserves order-level discounts through park/resume', async () => {
+    const mgr = createOrderManager({ currency: 'USD', taxContext, draftsCollection: db.pos_drafts });
+
+    const builder = await firstValueFrom(mgr.activeOrder$);
+    builder.addProduct(product, traits);
+    builder.applyOrderDiscount({ type: 'fixed', value: 1, label: 'Loyalty' });
+    const orderId = (await firstValueFrom(builder.order$)).id;
+
+    await mgr.parkCurrentOrder();
+    await mgr.resumeOrder(orderId);
+
+    const resumed = await firstValueFrom(mgr.activeOrder$);
+    const order = await firstValueFrom(resumed.order$);
+    expect(order.discounts).toHaveLength(1);
+    expect(order.discounts[0].label).toBe('Loyalty');
+  });
+
+  it('preserves payments through park/resume', async () => {
+    const mgr = createOrderManager({ currency: 'USD', taxContext, draftsCollection: db.pos_drafts });
+
+    const builder = await firstValueFrom(mgr.activeOrder$);
+    builder.addProduct(product, traits);
+    builder.addPayment({ method: 'cash', amount: 3 });
+    const orderId = (await firstValueFrom(builder.order$)).id;
+
+    await mgr.parkCurrentOrder();
+    await mgr.resumeOrder(orderId);
+
+    const resumed = await firstValueFrom(mgr.activeOrder$);
+    const order = await firstValueFrom(resumed.order$);
+    expect(order.payments).toHaveLength(1);
+    expect(order.payments[0].method).toBe('cash');
+    expect(order.payments[0].amount).toBe(3);
+  });
+
+  it('throws when resuming non-existent order', async () => {
+    const mgr = createOrderManager({ currency: 'USD', taxContext, draftsCollection: db.pos_drafts });
+    await expect(mgr.resumeOrder('nonexistent')).rejects.toThrow('Parked order nonexistent not found');
+  });
+
+  it('parking creates a fresh active order', async () => {
+    const mgr = createOrderManager({ currency: 'USD', taxContext, draftsCollection: db.pos_drafts });
+
+    const builder = await firstValueFrom(mgr.activeOrder$);
+    builder.addProduct(product, traits);
+    const oldId = (await firstValueFrom(builder.order$)).id;
+
+    await mgr.parkCurrentOrder();
+
+    const newBuilder = await firstValueFrom(mgr.activeOrder$);
+    const newOrder = await firstValueFrom(newBuilder.order$);
+    expect(newOrder.id).not.toBe(oldId);
+    expect(newOrder.lineItems).toHaveLength(0);
+  });
+});

package/src/order/order-manager.ts

@@ -0,0 +1,175 @@
+import { BehaviorSubject, map, type Observable } from 'rxjs';
+import type { RxCollection } from 'rxdb';
+import type { TaxContext } from '../tax/types';
+import { createOrderBuilder, type OrderBuilder } from './order-builder';
+import type { Order } from './types';
+
+export interface ParkedOrderSummary {
+  id: string;
+  customerName?: string;
+  itemCount: number;
+  total: number;
+  parkedAt: string;
+  source: 'local' | 'server';
+}
+
+export interface OrderManagerOptions {
+  currency: string;
+  taxContext: TaxContext;
+  draftsCollection: RxCollection;
+}
+
+export interface OrderManager {
+  activeOrder$: Observable<OrderBuilder>;
+  parkedOrders$: Observable<ParkedOrderSummary[]>;
+  newOrder(): OrderBuilder;
+  parkCurrentOrder(): Promise<string>;
+  resumeOrder(orderId: string): Promise<OrderBuilder>;
+  deleteParkedOrder(orderId: string): Promise<void>;
+}
+
+export function createOrderManager(options: OrderManagerOptions): OrderManager {
+  const { currency, taxContext, draftsCollection } = options;
+
+  let activeBuilder = createOrderBuilder({ currency, taxContext });
+  const activeSubject = new BehaviorSubject<OrderBuilder>(activeBuilder);
+
+  const parkedOrders$: Observable<ParkedOrderSummary[]> = draftsCollection.find().$.pipe(
+    map((docs) =>
+      docs.map((doc) => {
+        const json = doc.toJSON() as any;
+        return {
+          id: json.id,
+          customerName: json.customerName || undefined,
+          itemCount: json.itemCount ?? 0,
+          total: json.total ?? 0,
+          parkedAt: json.parkedAt ?? '',
+          source: 'local' as const,
+        };
+      }),
+    ),
+  );
+
+  return {
+    activeOrder$: activeSubject.asObservable(),
+    parkedOrders$,
+
+    newOrder() {
+      activeBuilder = createOrderBuilder({ currency, taxContext });
+      activeSubject.next(activeBuilder);
+      return activeBuilder;
+    },
+
+    async parkCurrentOrder() {
+      const snapshot = activeBuilder.getSnapshot();
+      await draftsCollection.upsert({
+        id: snapshot.id,
+        data: JSON.stringify(snapshot),
+        customerName: snapshot.customer?.name ?? '',
+        itemCount: snapshot.lineItems.length,
+        total: snapshot.total,
+        parkedAt: new Date().toISOString(),
+      });
+
+      activeBuilder = createOrderBuilder({ currency, taxContext });
+      activeSubject.next(activeBuilder);
+      return snapshot.id;
+    },
+
+    async resumeOrder(orderId) {
+      const doc = await draftsCollection.findOne(orderId).exec();
+      if (!doc) throw new Error(`Parked order ${orderId} not found`);
+
+      const json = doc.toJSON() as any;
+      const savedOrder: Order = JSON.parse(json.data);
+
+      const builder = createOrderBuilder({
+        currency,
+        taxContext,
+        id: savedOrder.id,
+      });
+
+      // Restore state from saved order
+      if (savedOrder.customer) {
+        builder.setCustomer(savedOrder.customer);
+      }
+      if (savedOrder.note) {
+        builder.setNote(savedOrder.note);
+      }
+
+      // Restore line items using synthetic traits
+      for (const line of savedOrder.lineItems) {
+        const syntheticTraits = {
+          getId: (d: any) => d.productId,
+          getName: (d: any) => d.name,
+          getSku: (d: any) => d.sku,
+          getPrice: (d: any) => String(d.price),
+          getRegularPrice: (d: any) => String(d.price),
+          getSalePrice: () => undefined,
+          isOnSale: () => false,
+          getImageUrl: (d: any) => d.imageUrl,
+          getImageUrls: (d: any) => (d.imageUrl ? [d.imageUrl] : []),
+          getDescription: () => undefined,
+          getStockStatus: () => 'instock' as const,
+          getStockQuantity: () => null,
+          hasVariants: () => false,
+          getType: () => 'simple',
+          getBarcode: () => undefined,
+          getCategoryNames: () => [],
+        };
+        builder.addProduct(line, syntheticTraits, {
+          variantId: line.variantId,
+          quantity: line.quantity,
+        });
+      }
+
+      // Restore line-level discounts
+      const resumedOrder = builder.getSnapshot();
+      for (const savedLine of savedOrder.lineItems) {
+        const newLine = resumedOrder.lineItems.find(
+          (li) => li.productId === savedLine.productId && li.variantId === savedLine.variantId,
+        );
+        if (newLine) {
+          for (const discount of savedLine.discounts) {
+            builder.applyLineDiscount(newLine.id, {
+              type: discount.type,
+              value: discount.value,
+              label: discount.label,
+              couponCode: discount.couponCode,
+            });
+          }
+        }
+      }
+
+      // Restore order-level discounts
+      for (const discount of savedOrder.discounts) {
+        builder.applyOrderDiscount({
+          type: discount.type,
+          value: discount.value,
+          label: discount.label,
+          couponCode: discount.couponCode,
+        });
+      }
+
+      // Restore payments
+      for (const payment of savedOrder.payments) {
+        builder.addPayment({
+          method: payment.method,
+          amount: payment.amount,
+          reference: payment.reference,
+        });
+      }
+
+      await doc.remove();
+
+      activeBuilder = builder;
+      activeSubject.next(activeBuilder);
+      return builder;
+    },
+
+    async deleteParkedOrder(orderId) {
+      const doc = await draftsCollection.findOne(orderId).exec();
+      if (doc) await doc.remove();
+    },
+  };
+}

package/src/order/payment.test.ts

@@ -0,0 +1,91 @@
+import { describe, it, expect } from 'vitest';
+import { firstValueFrom } from 'rxjs';
+import { createOrderBuilder } from './order-builder';
+import type { ProductTraits } from '@tallyui/core';
+import type { TaxContext } from '../tax/types';
+
+const traits: ProductTraits = {
+  getId: (doc) => doc.id,
+  getName: (doc) => doc.name,
+  getSku: () => '',
+  getPrice: (doc) => String(doc.price),
+  getRegularPrice: (doc) => String(doc.price),
+  getSalePrice: () => undefined,
+  isOnSale: () => false,
+  getImageUrl: () => undefined,
+  getImageUrls: () => [],
+  getDescription: () => undefined,
+  getStockStatus: () => 'instock',
+  getStockQuantity: () => null,
+  hasVariants: () => false,
+  getType: () => 'simple',
+  getBarcode: () => undefined,
+  getCategoryNames: () => [],
+};
+
+const taxContext: TaxContext = { getTaxRate: () => 0, pricesIncludeTax: false };
+
+describe('payment splitting', () => {
+  it('tracks a single payment', async () => {
+    const builder = createOrderBuilder({ currency: 'USD', taxContext });
+    builder.addProduct({ id: 'p1', name: 'Item', price: 20 }, traits);
+    builder.addPayment({ method: 'cash', amount: 20 });
+
+    const order = await firstValueFrom(builder.order$);
+    expect(order.payments).toHaveLength(1);
+    expect(order.balanceDue).toBe(0);
+    expect(order.changeDue).toBe(0);
+  });
+
+  it('splits payment across two methods', async () => {
+    const builder = createOrderBuilder({ currency: 'USD', taxContext });
+    builder.addProduct({ id: 'p1', name: 'Item', price: 35.50 }, traits);
+    builder.addPayment({ method: 'cash', amount: 20 });
+    builder.addPayment({ method: 'card', amount: 15.50 });
+
+    const order = await firstValueFrom(builder.order$);
+    expect(order.payments).toHaveLength(2);
+    expect(order.balanceDue).toBe(0);
+    expect(order.changeDue).toBe(0);
+  });
+
+  it('calculates balance due when partially paid', async () => {
+    const builder = createOrderBuilder({ currency: 'USD', taxContext });
+    builder.addProduct({ id: 'p1', name: 'Item', price: 30 }, traits);
+    builder.addPayment({ method: 'card', amount: 10 });
+
+    const order = await firstValueFrom(builder.order$);
+    expect(order.balanceDue).toBeCloseTo(20);
+    expect(order.changeDue).toBe(0);
+  });
+
+  it('calculates change due when overpaid with cash', async () => {
+    const builder = createOrderBuilder({ currency: 'USD', taxContext });
+    builder.addProduct({ id: 'p1', name: 'Item', price: 17 }, traits);
+    builder.addPayment({ method: 'cash', amount: 20 });
+
+    const order = await firstValueFrom(builder.order$);
+    expect(order.balanceDue).toBe(0);
+    expect(order.changeDue).toBeCloseTo(3);
+  });
+
+  it('removes a payment', async () => {
+    const builder = createOrderBuilder({ currency: 'USD', taxContext });
+    builder.addProduct({ id: 'p1', name: 'Item', price: 20 }, traits);
+    const paymentId = builder.addPayment({ method: 'cash', amount: 20 });
+
+    builder.removePayment(paymentId);
+    const order = await firstValueFrom(builder.order$);
+    expect(order.payments).toHaveLength(0);
+    expect(order.balanceDue).toBe(20);
+  });
+
+  it('includes payment reference', async () => {
+    const builder = createOrderBuilder({ currency: 'USD', taxContext });
+    builder.addProduct({ id: 'p1', name: 'Item', price: 10 }, traits);
+    builder.addPayment({ method: 'card', amount: 10, reference: 'TXN-4567' });
+
+    const order = await firstValueFrom(builder.order$);
+    expect(order.payments[0].reference).toBe('TXN-4567');
+  });
+});

package/src/order/types.ts

@@ -0,0 +1,66 @@
+export interface Order {
+  id: string;
+  status: 'draft' | 'parked' | 'saved' | 'completed';
+  lineItems: LineItem[];
+  discounts: AppliedDiscount[];
+  payments: Payment[];
+  customer: CustomerSummary | null;
+  note: string;
+  subtotal: number;
+  discountTotal: number;
+  taxTotal: number;
+  total: number;
+  balanceDue: number;
+  changeDue: number;
+  currency: string;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface LineItem {
+  id: string;
+  productId: string;
+  variantId?: string;
+  name: string;
+  sku: string;
+  imageUrl?: string;
+  price: number;
+  quantity: number;
+  taxRate: number;
+  taxAmount: number;
+  discounts: AppliedDiscount[];
+  discountAmount: number;
+  lineTotal: number;
+}
+
+export interface Discount {
+  type: 'percentage' | 'fixed';
+  value: number;
+  label?: string;
+  couponCode?: string;
+}
+
+export interface AppliedDiscount extends Discount {
+  id: string;
+  amount: number;
+}
+
+export interface Payment {
+  id: string;
+  method: string;
+  amount: number;
+  reference?: string;
+}
+
+export interface CustomerSummary {
+  id: string;
+  name: string;
+  email?: string;
+}
+
+export interface PaymentMethod {
+  id: string;
+  label: string;
+  icon?: string;
+  requiresReference?: boolean;
+}

package/src/receipt/build-receipt-data.test.ts

@@ -0,0 +1,166 @@
+import { describe, it, expect } from 'vitest';
+import { buildReceiptData } from './build-receipt-data';
+import type { Order } from '../order/types';
+import type { ReceiptConfig } from './types';
+
+const baseOrder: Order = {
+  id: 'order-001',
+  status: 'completed',
+  lineItems: [
+    {
+      id: 'li1',
+      productId: 'p1',
+      name: 'Espresso',
+      sku: 'ESP-001',
+      price: 4.5,
+      quantity: 2,
+      taxRate: 0.1,
+      taxAmount: 0.9,
+      discounts: [],
+      discountAmount: 0,
+      lineTotal: 9.9,
+    },
+    {
+      id: 'li2',
+      productId: 'p2',
+      name: 'Muffin',
+      sku: 'MUF-001',
+      price: 3.0,
+      quantity: 1,
+      taxRate: 0.05,
+      taxAmount: 0.15,
+      discounts: [],
+      discountAmount: 0,
+      lineTotal: 3.15,
+    },
+  ],
+  discounts: [{ id: 'd1', type: 'fixed', value: 1, amount: 1, label: 'Loyalty' }],
+  payments: [{ id: 'pay1', method: 'cash', amount: 15.0 }],
+  customer: { id: 'c1', name: 'Alice' },
+  note: 'Extra hot',
+  subtotal: 12.0,
+  discountTotal: 1.0,
+  taxTotal: 1.05,
+  total: 12.05,
+  balanceDue: 0,
+  changeDue: 2.95,
+  currency: 'USD',
+  createdAt: '2026-02-26T10:00:00Z',
+  updatedAt: '2026-02-26T10:05:00Z',
+};
+
+const config: ReceiptConfig = {
+  storeName: 'Test Coffee Shop',
+  storeAddress: '123 Main St',
+  cashier: 'Bob',
+  register: 'POS-1',
+  taxLabels: { 0.1: 'VAT 10%', 0.05: 'Reduced VAT 5%' },
+};
+
+describe('buildReceiptData', () => {
+  it('builds receipt header from config and order', () => {
+    const receipt = buildReceiptData(baseOrder, config);
+    expect(receipt.header.storeName).toBe('Test Coffee Shop');
+    expect(receipt.header.storeAddress).toBe('123 Main St');
+    expect(receipt.header.orderNumber).toBe('order-001');
+    expect(receipt.header.cashier).toBe('Bob');
+    expect(receipt.header.register).toBe('POS-1');
+    expect(receipt.header.date).toBe('2026-02-26T10:00:00Z');
+  });
+
+  it('maps line items', () => {
+    const receipt = buildReceiptData(baseOrder, config);
+    expect(receipt.lineItems).toHaveLength(2);
+    expect(receipt.lineItems[0]).toEqual({
+      name: 'Espresso',
+      sku: 'ESP-001',
+      quantity: 2,
+      unitPrice: 4.5,
+      lineTotal: 9.9,
+    });
+  });
+
+  it('maps discounts', () => {
+    const receipt = buildReceiptData(baseOrder, config);
+    expect(receipt.discounts).toHaveLength(1);
+    expect(receipt.discounts[0]).toEqual({ label: 'Loyalty', amount: 1 });
+  });
+
+  it('groups tax lines by rate with labels', () => {
+    const receipt = buildReceiptData(baseOrder, config);
+    expect(receipt.totals.taxLines).toHaveLength(2);
+    expect(receipt.totals.taxLines).toContainEqual({
+      label: 'VAT 10%',
+      rate: 0.1,
+      amount: 0.9,
+    });
+    expect(receipt.totals.taxLines).toContainEqual({
+      label: 'Reduced VAT 5%',
+      rate: 0.05,
+      amount: 0.15,
+    });
+  });
+
+  it('uses default tax label when not configured', () => {
+    const receipt = buildReceiptData(baseOrder, { storeName: 'Shop' });
+    const labels = receipt.totals.taxLines.map((t) => t.label);
+    expect(labels).toContain('Tax 10%');
+    expect(labels).toContain('Tax 5%');
+  });
+
+  it('calculates totals', () => {
+    const receipt = buildReceiptData(baseOrder, config);
+    expect(receipt.totals.subtotal).toBe(12.0);
+    expect(receipt.totals.discountTotal).toBe(1.0);
+    expect(receipt.totals.taxTotal).toBe(1.05);
+    expect(receipt.totals.total).toBe(12.05);
+  });
+
+  it('maps payments', () => {
+    const receipt = buildReceiptData(baseOrder, config);
+    expect(receipt.payments).toHaveLength(1);
+    expect(receipt.payments[0]).toEqual({ method: 'cash', amount: 15.0 });
+  });
+
+  it('includes change due and footer', () => {
+    const receipt = buildReceiptData(baseOrder, config);
+    expect(receipt.changeDue).toBe(2.95);
+    expect(receipt.footer.note).toBe('Extra hot');
+    expect(receipt.footer.barcode).toBe('order-001');
+  });
+
+  it('includes currency', () => {
+    const receipt = buildReceiptData(baseOrder, config);
+    expect(receipt.currency).toBe('USD');
+  });
+
+  it('handles empty order with no line items', () => {
+    const emptyOrder: Order = {
+      ...baseOrder,
+      lineItems: [],
+      discounts: [],
+      payments: [],
+      subtotal: 0,
+      discountTotal: 0,
+      taxTotal: 0,
+      total: 0,
+      balanceDue: 0,
+      changeDue: 0,
+    };
+    const receipt = buildReceiptData(emptyOrder, config);
+    expect(receipt.lineItems).toHaveLength(0);
+    expect(receipt.totals.taxLines).toHaveLength(0);
+    expect(receipt.totals.total).toBe(0);
+  });
+
+  it('uses fallback label for discount without label or couponCode', () => {
+    const orderWithUnlabeledDiscount: Order = {
+      ...baseOrder,
+      discounts: [
+        { id: 'd1', type: 'percentage', value: 10, amount: 1.20 },
+      ],
+    };
+    const receipt = buildReceiptData(orderWithUnlabeledDiscount, config);
+    expect(receipt.discounts[0].label).toBe('percentage discount');
+  });
+});