@tallyui/pos 0.1.0 → 2.0.0

package/src/order/payment.test.ts

@@ -1,91 +0,0 @@
-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/receipt/build-receipt-data.test.ts

@@ -1,166 +0,0 @@
-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');
-  });
-});

package/src/repository/create-repository.test.ts

@@ -1,166 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-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 { firstValueFrom } from 'rxjs';
-import { createRepository } from './create-repository';
-
-addRxPlugin(RxDBDevModePlugin);
-
-const storage = wrappedValidateAjvStorage({ storage: getRxStorageMemory() });
-
-const testSchema = {
-  version: 0,
-  primaryKey: 'id',
-  type: 'object' as const,
-  properties: {
-    id: { type: 'string', maxLength: 100 },
-    name: { type: 'string' },
-    category: { type: 'string' },
-  },
-  required: ['id', 'name'] as const,
-};
-
-type TestDoc = { id: string; name: string; category?: string };
-
-describe('createRepository', () => {
-  let db: RxDatabase;
-
-  beforeEach(async () => {
-    db = await createRxDatabase({
-      name: `test_repo_${Date.now()}`,
-      storage,
-      multiInstance: false,
-      ignoreDuplicate: true,
-    });
-    await db.addCollections({ items: { schema: testSchema } });
-  });
-
-  afterEach(async () => {
-    await db?.close();
-  });
-
-  it('creates a document and retrieves it by id', async () => {
-    const repo = createRepository<TestDoc>(db.items);
-    const doc = await repo.create({ id: '1', name: 'Widget' });
-    expect(doc.name).toBe('Widget');
-
-    const found = await firstValueFrom(repo.findById$('1'));
-    expect(found).not.toBeNull();
-    expect(found!.name).toBe('Widget');
-  });
-
-  it('returns null for non-existent id', async () => {
-    const repo = createRepository<TestDoc>(db.items);
-    const found = await firstValueFrom(repo.findById$('nonexistent'));
-    expect(found).toBeNull();
-  });
-
-  it('finds all documents', async () => {
-    const repo = createRepository<TestDoc>(db.items);
-    await repo.create({ id: '1', name: 'A' });
-    await repo.create({ id: '2', name: 'B' });
-
-    const all = await firstValueFrom(repo.findAll$());
-    expect(all).toHaveLength(2);
-  });
-
-  it('finds documents with a mango query', async () => {
-    const repo = createRepository<TestDoc>(db.items);
-    await repo.create({ id: '1', name: 'A', category: 'x' });
-    await repo.create({ id: '2', name: 'B', category: 'y' });
-
-    const filtered = await firstValueFrom(
-      repo.findAll$({ selector: { category: 'x' } }),
-    );
-    expect(filtered).toHaveLength(1);
-    expect(filtered[0].name).toBe('A');
-  });
-
-  it('updates a document', async () => {
-    const repo = createRepository<TestDoc>(db.items);
-    await repo.create({ id: '1', name: 'Old' });
-    const updated = await repo.update('1', { name: 'New' });
-    expect(updated.name).toBe('New');
-  });
-
-  it('removes a document', async () => {
-    const repo = createRepository<TestDoc>(db.items);
-    await repo.create({ id: '1', name: 'A' });
-    await repo.remove('1');
-
-    const all = await firstValueFrom(repo.findAll$());
-    expect(all).toHaveLength(0);
-  });
-
-  it('bulk creates documents', async () => {
-    const repo = createRepository<TestDoc>(db.items);
-    const docs = await repo.bulkCreate([
-      { id: '1', name: 'A' },
-      { id: '2', name: 'B' },
-      { id: '3', name: 'C' },
-    ]);
-    expect(docs).toHaveLength(3);
-
-    const all = await firstValueFrom(repo.findAll$());
-    expect(all).toHaveLength(3);
-  });
-
-  it('bulk removes documents', async () => {
-    const repo = createRepository<TestDoc>(db.items);
-    await repo.bulkCreate([
-      { id: '1', name: 'A' },
-      { id: '2', name: 'B' },
-      { id: '3', name: 'C' },
-    ]);
-    await repo.bulkRemove(['1', '3']);
-
-    const all = await firstValueFrom(repo.findAll$());
-    expect(all).toHaveLength(1);
-    expect(all[0].id).toBe('2');
-  });
-
-  it('count$ returns document count', async () => {
-    const repo = createRepository<TestDoc>(db.items);
-    const count0 = await firstValueFrom(repo.count$());
-    expect(count0).toBe(0);
-
-    await repo.create({ id: '1', name: 'A' });
-    await repo.create({ id: '2', name: 'B' });
-
-    const count2 = await firstValueFrom(repo.count$());
-    expect(count2).toBe(2);
-  });
-
-  it('search$ filters by text across specified fields', async () => {
-    const repo = createRepository<TestDoc>(db.items);
-    await repo.create({ id: '1', name: 'Coffee Beans' });
-    await repo.create({ id: '2', name: 'Tea Leaves' });
-    await repo.create({ id: '3', name: 'Coffee Grinder' });
-
-    const results = await firstValueFrom(repo.search$('coffee', ['name']));
-    expect(results).toHaveLength(2);
-  });
-
-  it('search$ handles regex special characters in search term', async () => {
-    const repo = createRepository<TestDoc>(db.items);
-    await repo.create({ id: '1', name: 'Coffee (Organic)' });
-    await repo.create({ id: '2', name: 'Tea' });
-
-    // This should not throw — the parentheses are escaped
-    const results = await firstValueFrom(repo.search$('(Organic)', ['name']));
-    expect(results).toHaveLength(1);
-    expect(results[0].name).toBe('Coffee (Organic)');
-  });
-
-  it('throws when updating a non-existent document', async () => {
-    const repo = createRepository<TestDoc>(db.items);
-    await expect(repo.update('nonexistent', { name: 'New' })).rejects.toThrow('Document nonexistent not found');
-  });
-
-  it('throws when removing a non-existent document', async () => {
-    const repo = createRepository<TestDoc>(db.items);
-    await expect(repo.remove('nonexistent')).rejects.toThrow('Document nonexistent not found');
-  });
-});

package/src/tax/calculate.test.ts

@@ -1,59 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { calculateTax, extractTax, addTax } from './calculate';
-
-describe('addTax', () => {
-  it('adds 10% tax to $10.00', () => {
-    expect(addTax(10, 0.1)).toBeCloseTo(11);
-  });
-
-  it('adds 0% tax', () => {
-    expect(addTax(10, 0)).toBe(10);
-  });
-
-  it('adds 20% tax to $25.00', () => {
-    expect(addTax(25, 0.2)).toBeCloseTo(30);
-  });
-});
-
-describe('extractTax', () => {
-  it('extracts 10% tax from $11.00 inclusive', () => {
-    expect(extractTax(11, 0.1)).toBeCloseTo(1);
-  });
-
-  it('extracts 0% tax', () => {
-    expect(extractTax(10, 0)).toBe(0);
-  });
-
-  it('extracts 20% tax from $30.00 inclusive', () => {
-    expect(extractTax(30, 0.2)).toBeCloseTo(5);
-  });
-});
-
-describe('calculateTax', () => {
-  it('calculates from tax-exclusive price', () => {
-    const result = calculateTax(10, 0.1, false);
-    expect(result.priceExclTax).toBeCloseTo(10);
-    expect(result.taxAmount).toBeCloseTo(1);
-    expect(result.priceInclTax).toBeCloseTo(11);
-  });
-
-  it('calculates from tax-inclusive price', () => {
-    const result = calculateTax(11, 0.1, true);
-    expect(result.priceInclTax).toBeCloseTo(11);
-    expect(result.taxAmount).toBeCloseTo(1);
-    expect(result.priceExclTax).toBeCloseTo(10);
-  });
-
-  it('handles zero rate', () => {
-    const result = calculateTax(10, 0, false);
-    expect(result.priceExclTax).toBe(10);
-    expect(result.taxAmount).toBe(0);
-    expect(result.priceInclTax).toBe(10);
-  });
-
-  it('rounds to 2 decimal places', () => {
-    const result = calculateTax(10.33, 0.075, false);
-    expect(result.taxAmount).toBeCloseTo(0.77, 2);
-    expect(result.priceInclTax).toBeCloseTo(11.10, 2);
-  });
-});

package/src/tax/calculate.ts

@@ -1,32 +0,0 @@
-import type { TaxResult } from './types';
-
-function round2(n: number): number {
-  return Math.round(n * 100) / 100;
-}
-
-export function addTax(priceExclTax: number, rate: number): number {
-  return round2(priceExclTax * (1 + rate));
-}
-
-export function extractTax(priceInclTax: number, rate: number): number {
-  if (rate === 0) return 0;
-  return round2(priceInclTax - priceInclTax / (1 + rate));
-}
-
-export function calculateTax(price: number, rate: number, pricesIncludeTax: boolean): TaxResult {
-  if (pricesIncludeTax) {
-    const taxAmount = extractTax(price, rate);
-    return {
-      priceInclTax: round2(price),
-      priceExclTax: round2(price - taxAmount),
-      taxAmount,
-    };
-  }
-
-  const taxAmount = round2(price * rate);
-  return {
-    priceExclTax: round2(price),
-    priceInclTax: round2(price + taxAmount),
-    taxAmount,
-  };
-}

package/src/tax/tax-provider.test.tsx

@@ -1,51 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { renderHook } from '@testing-library/react';
-import type { ReactNode } from 'react';
-import { TaxProvider, useTax } from './tax-provider';
-
-function wrapper(rates: Record<string, number>, pricesIncludeTax = false) {
-  return function Wrapper({ children }: { children: ReactNode }) {
-    return (
-      <TaxProvider rates={rates} pricesIncludeTax={pricesIncludeTax}>
-        {children}
-      </TaxProvider>
-    );
-  };
-}
-
-describe('TaxProvider + useTax', () => {
-  it('provides default tax rate', () => {
-    const { result } = renderHook(() => useTax(), {
-      wrapper: wrapper({ default: 0.1 }),
-    });
-    expect(result.current.getTaxRate()).toBe(0.1);
-  });
-
-  it('provides tax rate by class', () => {
-    const { result } = renderHook(() => useTax(), {
-      wrapper: wrapper({ default: 0.2, reduced: 0.05, zero: 0 }),
-    });
-    expect(result.current.getTaxRate('reduced')).toBe(0.05);
-    expect(result.current.getTaxRate('zero')).toBe(0);
-  });
-
-  it('falls back to default for unknown tax class', () => {
-    const { result } = renderHook(() => useTax(), {
-      wrapper: wrapper({ default: 0.1 }),
-    });
-    expect(result.current.getTaxRate('nonexistent')).toBe(0.1);
-  });
-
-  it('provides pricesIncludeTax flag', () => {
-    const { result } = renderHook(() => useTax(), {
-      wrapper: wrapper({ default: 0.1 }, true),
-    });
-    expect(result.current.pricesIncludeTax).toBe(true);
-  });
-
-  it('throws when used outside provider', () => {
-    expect(() => {
-      renderHook(() => useTax());
-    }).toThrow('useTax() must be used within a <TaxProvider>');
-  });
-});