@tallyui/pos 0.1.0

package/src/currency/currency-provider.tsx

@@ -0,0 +1,32 @@
+import { createContext, useContext, useMemo, useCallback } from 'react';
+import type { ReactNode } from 'react';
+import { formatCurrency } from './format-currency';
+
+interface CurrencyContext {
+  currencyCode: string;
+  locale?: string;
+}
+
+const CurrencyCtx = createContext<CurrencyContext | null>(null);
+
+export interface CurrencyProviderProps {
+  currencyCode: string;
+  locale?: string;
+  children: ReactNode;
+}
+
+export function CurrencyProvider({ currencyCode, locale, children }: CurrencyProviderProps) {
+  const value = useMemo(() => ({ currencyCode, locale }), [currencyCode, locale]);
+  return <CurrencyCtx.Provider value={value}>{children}</CurrencyCtx.Provider>;
+}
+
+export function useCurrencyFormatter(): (amount: number) => string {
+  const ctx = useContext(CurrencyCtx);
+  if (!ctx) {
+    throw new Error('useCurrencyFormatter() must be used within a <CurrencyProvider>');
+  }
+  return useCallback(
+    (amount: number) => formatCurrency(amount, ctx.currencyCode, ctx.locale),
+    [ctx.currencyCode, ctx.locale],
+  );
+}

package/src/currency/format-currency.test.ts

@@ -0,0 +1,36 @@
+import { describe, it, expect } from 'vitest';
+import { formatCurrency } from './format-currency';
+
+describe('formatCurrency', () => {
+  it('formats USD with default locale', () => {
+    const result = formatCurrency(10.5, 'USD', 'en-US');
+    expect(result).toBe('$10.50');
+  });
+
+  it('formats EUR with German locale', () => {
+    const result = formatCurrency(10.5, 'EUR', 'de-DE');
+    expect(result.replace(/\s/g, ' ')).toBe('10,50 €');
+  });
+
+  it('formats JPY (zero decimals)', () => {
+    const result = formatCurrency(1000, 'JPY', 'ja-JP');
+    expect(result).toContain('1,000');
+  });
+
+  it('formats zero', () => {
+    const result = formatCurrency(0, 'USD', 'en-US');
+    expect(result).toBe('$0.00');
+  });
+
+  it('formats negative numbers', () => {
+    const result = formatCurrency(-5.99, 'USD', 'en-US');
+    expect(result).toContain('5.99');
+  });
+
+  it('memoizes formatter for same currency+locale pair', () => {
+    const a = formatCurrency(1, 'USD', 'en-US');
+    const b = formatCurrency(2, 'USD', 'en-US');
+    expect(a).toBe('$1.00');
+    expect(b).toBe('$2.00');
+  });
+});

package/src/currency/format-currency.ts

@@ -0,0 +1,18 @@
+const formatters = new Map<string, Intl.NumberFormat>();
+
+function getFormatter(currencyCode: string, locale?: string): Intl.NumberFormat {
+  const key = `${currencyCode}:${locale ?? 'default'}`;
+  let formatter = formatters.get(key);
+  if (!formatter) {
+    formatter = new Intl.NumberFormat(locale, {
+      style: 'currency',
+      currency: currencyCode,
+    });
+    formatters.set(key, formatter);
+  }
+  return formatter;
+}
+
+export function formatCurrency(amount: number, currencyCode: string, locale?: string): string {
+  return getFormatter(currencyCode, locale).format(amount);
+}

package/src/currency/index.ts

@@ -0,0 +1,3 @@
+export { formatCurrency } from './format-currency';
+export { CurrencyProvider, useCurrencyFormatter } from './currency-provider';
+export type { CurrencyProviderProps } from './currency-provider';

package/src/index.ts

@@ -0,0 +1,34 @@
+// Logging
+export { createLogger, consoleSink, callbackSink } from './logging';
+export type { Logger, LogSink, LogEntry, LogLevel } from './logging';
+
+// Currency
+export { formatCurrency, CurrencyProvider, useCurrencyFormatter } from './currency';
+export type { CurrencyProviderProps } from './currency';
+
+// Tax
+export { calculateTax, extractTax, addTax, TaxProvider, useTax } from './tax';
+export type { TaxProviderProps } from './tax';
+export type { TaxResult, TaxRateMap, TaxContext } from './tax';
+
+// Repository
+export { createRepository } from './repository';
+export type { Repository } from './repository';
+
+// Order
+export { createOrderBuilder, createOrderManager } from './order';
+export type { OrderBuilder, OrderBuilderOptions } from './order';
+export type { OrderManager, OrderManagerOptions, ParkedOrderSummary } from './order';
+export type {
+  Order,
+  LineItem,
+  Discount,
+  AppliedDiscount,
+  Payment,
+  CustomerSummary,
+  PaymentMethod,
+} from './order';
+
+// Receipt
+export { buildReceiptData } from './receipt';
+export type { ReceiptData, ReceiptLineItem, ReceiptConfig } from './receipt';

package/src/logging/index.ts

@@ -0,0 +1,3 @@
+export { createLogger } from './logger';
+export { consoleSink, callbackSink } from './sinks';
+export type { Logger, LogSink, LogEntry, LogLevel } from './types';

package/src/logging/logger.test.ts

@@ -0,0 +1,154 @@
+import { describe, it, expect, vi } from 'vitest';
+import { createLogger } from './logger';
+import type { LogSink, LogEntry } from './types';
+
+function createTestSink(overrides?: Partial<LogSink>): LogSink & { entries: LogEntry[] } {
+  const entries: LogEntry[] = [];
+  return {
+    id: 'test',
+    levels: ['debug', 'info', 'warn', 'error'],
+    write: (entry) => entries.push(entry),
+    entries,
+    ...overrides,
+  };
+}
+
+describe('createLogger', () => {
+  it('creates a logger with default root scope', () => {
+    const logger = createLogger();
+    expect(logger).toBeDefined();
+    expect(typeof logger.debug).toBe('function');
+    expect(typeof logger.info).toBe('function');
+    expect(typeof logger.warn).toBe('function');
+    expect(typeof logger.error).toBe('function');
+  });
+
+  it('writes log entries to registered sinks', () => {
+    const logger = createLogger();
+    const sink = createTestSink();
+    logger.addSink(sink);
+
+    logger.info('hello world');
+
+    expect(sink.entries).toHaveLength(1);
+    expect(sink.entries[0].level).toBe('info');
+    expect(sink.entries[0].message).toBe('hello world');
+    expect(sink.entries[0].scope).toBe('root');
+    expect(sink.entries[0].timestamp).toBeGreaterThan(0);
+  });
+
+  it('includes data in log entries', () => {
+    const logger = createLogger();
+    const sink = createTestSink();
+    logger.addSink(sink);
+
+    logger.error('failed', { code: 500 });
+
+    expect(sink.entries[0].data).toEqual({ code: 500 });
+  });
+
+  it('only writes to sinks that match the log level', () => {
+    const logger = createLogger();
+    const errorOnly = createTestSink({ id: 'errors', levels: ['error'] });
+    logger.addSink(errorOnly);
+
+    logger.debug('debug msg');
+    logger.info('info msg');
+    logger.warn('warn msg');
+    logger.error('error msg');
+
+    expect(errorOnly.entries).toHaveLength(1);
+    expect(errorOnly.entries[0].level).toBe('error');
+  });
+
+  it('removes sinks by id', () => {
+    const logger = createLogger();
+    const sink = createTestSink();
+    logger.addSink(sink);
+    logger.info('before');
+    logger.removeSink('test');
+    logger.info('after');
+
+    expect(sink.entries).toHaveLength(1);
+    expect(sink.entries[0].message).toBe('before');
+  });
+});
+
+describe('scoped loggers', () => {
+  it('creates a child logger with a scoped name', () => {
+    const logger = createLogger();
+    const sink = createTestSink();
+    logger.addSink(sink);
+
+    const child = logger.createScope('order-builder');
+    child.info('order created');
+
+    expect(sink.entries[0].scope).toBe('order-builder');
+  });
+
+  it('child loggers share sinks with parent', () => {
+    const logger = createLogger();
+    const sink = createTestSink();
+    logger.addSink(sink);
+
+    const child = logger.createScope('tax');
+    child.warn('rate missing');
+    logger.info('root message');
+
+    expect(sink.entries).toHaveLength(2);
+    expect(sink.entries[0].scope).toBe('tax');
+    expect(sink.entries[1].scope).toBe('root');
+  });
+
+  it('sinks can filter by scope', () => {
+    const logger = createLogger();
+    const taxOnly = createTestSink({ id: 'tax-sink', scopes: ['tax'] });
+    logger.addSink(taxOnly);
+
+    const taxLog = logger.createScope('tax');
+    const orderLog = logger.createScope('order');
+
+    taxLog.info('tax message');
+    orderLog.info('order message');
+
+    expect(taxOnly.entries).toHaveLength(1);
+    expect(taxOnly.entries[0].scope).toBe('tax');
+  });
+
+  it('sinks added to parent are visible to existing children', () => {
+    const logger = createLogger();
+    const child = logger.createScope('child');
+
+    const sink = createTestSink();
+    logger.addSink(sink);
+
+    child.info('after add');
+    expect(sink.entries).toHaveLength(1);
+  });
+
+  it('sinks removed from parent are removed from children', () => {
+    const logger = createLogger();
+    const sink = createTestSink();
+    logger.addSink(sink);
+
+    const child = logger.createScope('child');
+    child.info('before');
+    logger.removeSink('test');
+    child.info('after');
+
+    expect(sink.entries).toHaveLength(1);
+  });
+
+  it('nested scopes (grandchild) share sinks with root', () => {
+    const logger = createLogger();
+    const sink = createTestSink();
+    logger.addSink(sink);
+
+    const child = logger.createScope('parent');
+    const grandchild = child.createScope('grandchild');
+
+    grandchild.info('deep message');
+    expect(sink.entries).toHaveLength(1);
+    expect(sink.entries[0].scope).toBe('grandchild');
+  });
+});

package/src/logging/logger.ts

@@ -0,0 +1,67 @@
+import type { Logger, LogEntry, LogLevel, LogSink } from './types';
+
+export function createLogger(scope = 'root'): Logger {
+  const sinks: Map<string, LogSink> = new Map();
+
+  function log(level: LogLevel, message: string, data?: Record<string, unknown>) {
+    const entry: LogEntry = {
+      level,
+      scope,
+      message,
+      data,
+      timestamp: Date.now(),
+    };
+
+    for (const sink of sinks.values()) {
+      if (!sink.levels.includes(level)) continue;
+      if (sink.scopes && !sink.scopes.includes(scope)) continue;
+      sink.write(entry);
+    }
+  }
+
+  return {
+    debug: (message, data) => log('debug', message, data),
+    info: (message, data) => log('info', message, data),
+    warn: (message, data) => log('warn', message, data),
+    error: (message, data) => log('error', message, data),
+
+    createScope(name: string): Logger {
+      return createChildLogger(sinks, name);
+    },
+
+    addSink(sink: LogSink) {
+      sinks.set(sink.id, sink);
+    },
+
+    removeSink(sinkId: string) {
+      sinks.delete(sinkId);
+    },
+  };
+}
+
+function logWithSinks(
+  sinks: Map<string, LogSink>,
+  level: LogLevel,
+  scope: string,
+  message: string,
+  data?: Record<string, unknown>,
+) {
+  const entry: LogEntry = { level, scope, message, data, timestamp: Date.now() };
+  for (const sink of sinks.values()) {
+    if (!sink.levels.includes(level)) continue;
+    if (sink.scopes && !sink.scopes.includes(scope)) continue;
+    sink.write(entry);
+  }
+}
+
+function createChildLogger(sinks: Map<string, LogSink>, scope: string): Logger {
+  return {
+    debug: (message, data) => logWithSinks(sinks, 'debug', scope, message, data),
+    info: (message, data) => logWithSinks(sinks, 'info', scope, message, data),
+    warn: (message, data) => logWithSinks(sinks, 'warn', scope, message, data),
+    error: (message, data) => logWithSinks(sinks, 'error', scope, message, data),
+    createScope: (childName: string) => createChildLogger(sinks, childName),
+    addSink: (sink: LogSink) => sinks.set(sink.id, sink),
+    removeSink: (sinkId: string) => sinks.delete(sinkId),
+  };
+}

package/src/logging/sinks.test.ts

@@ -0,0 +1,60 @@
+import { describe, it, expect, vi } from 'vitest';
+import { consoleSink, callbackSink } from './sinks';
+import type { LogEntry } from './types';
+
+const entry: LogEntry = {
+  level: 'info',
+  scope: 'test',
+  message: 'hello',
+  data: { key: 'value' },
+  timestamp: 1000,
+};
+
+describe('consoleSink', () => {
+  it('writes info/debug to console.log', () => {
+    const spy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const sink = consoleSink({ levels: ['info'] });
+    sink.write(entry);
+    expect(spy).toHaveBeenCalledOnce();
+    spy.mockRestore();
+  });
+
+  it('writes warn to console.warn', () => {
+    const spy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    const sink = consoleSink({ levels: ['warn'] });
+    sink.write({ ...entry, level: 'warn' });
+    expect(spy).toHaveBeenCalledOnce();
+    spy.mockRestore();
+  });
+
+  it('writes error to console.error', () => {
+    const spy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    const sink = consoleSink({ levels: ['error'] });
+    sink.write({ ...entry, level: 'error' });
+    expect(spy).toHaveBeenCalledOnce();
+    spy.mockRestore();
+  });
+
+  it('uses provided id or defaults to console', () => {
+    const s1 = consoleSink({ levels: ['info'] });
+    expect(s1.id).toBe('console');
+
+    const s2 = consoleSink({ id: 'debug-console', levels: ['debug'] });
+    expect(s2.id).toBe('debug-console');
+  });
+});
+
+describe('callbackSink', () => {
+  it('calls the callback for matching entries', () => {
+    const cb = vi.fn();
+    const sink = callbackSink({ id: 'toast', levels: ['error'], callback: cb });
+    sink.write({ ...entry, level: 'error' });
+    expect(cb).toHaveBeenCalledWith(expect.objectContaining({ level: 'error', message: 'hello' }));
+  });
+
+  it('has correct id and levels', () => {
+    const sink = callbackSink({ id: 'my-sink', levels: ['warn', 'error'], callback: vi.fn() });
+    expect(sink.id).toBe('my-sink');
+    expect(sink.levels).toEqual(['warn', 'error']);
+  });
+});

package/src/logging/sinks.ts

@@ -0,0 +1,46 @@
+import type { LogEntry, LogLevel, LogSink } from './types';
+
+export interface ConsoleSinkOptions {
+  id?: string;
+  levels: LogLevel[];
+  scopes?: string[];
+}
+
+export function consoleSink(options: ConsoleSinkOptions): LogSink {
+  return {
+    id: options.id ?? 'console',
+    levels: options.levels,
+    scopes: options.scopes,
+    write(entry: LogEntry) {
+      const prefix = `[${entry.scope}]`;
+      const args = entry.data ? [prefix, entry.message, entry.data] : [prefix, entry.message];
+
+      switch (entry.level) {
+        case 'error':
+          console.error(...args);
+          break;
+        case 'warn':
+          console.warn(...args);
+          break;
+        default:
+          console.log(...args);
+      }
+    },
+  };
+}
+
+export interface CallbackSinkOptions {
+  id: string;
+  levels: LogLevel[];
+  scopes?: string[];
+  callback: (entry: LogEntry) => void;
+}
+
+export function callbackSink(options: CallbackSinkOptions): LogSink {
+  return {
+    id: options.id,
+    levels: options.levels,
+    scopes: options.scopes,
+    write: options.callback,
+  };
+}

package/src/logging/types.ts

@@ -0,0 +1,26 @@
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+
+export interface LogEntry {
+  level: LogLevel;
+  scope: string;
+  message: string;
+  data?: Record<string, unknown>;
+  timestamp: number;
+}
+
+export interface LogSink {
+  id: string;
+  levels: LogLevel[];
+  scopes?: string[];
+  write(entry: LogEntry): void;
+}
+
+export interface Logger {
+  debug(message: string, data?: Record<string, unknown>): void;
+  info(message: string, data?: Record<string, unknown>): void;
+  warn(message: string, data?: Record<string, unknown>): void;
+  error(message: string, data?: Record<string, unknown>): void;
+  createScope(name: string): Logger;
+  addSink(sink: LogSink): void;
+  removeSink(sinkId: string): void;
+}

package/src/order/discount-engine.test.ts

@@ -0,0 +1,152 @@
+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: (doc) => doc.sku ?? '',
+  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.1, pricesIncludeTax: false };
+const product = { id: 'p1', name: 'Coffee', price: 10 };
+
+describe('discount engine', () => {
+  describe('line-level discounts', () => {
+    it('applies a percentage discount to a line item', async () => {
+      const builder = createOrderBuilder({ currency: 'USD', taxContext });
+      const lineId = builder.addProduct(product, traits);
+      builder.applyLineDiscount(lineId, { type: 'percentage', value: 10, label: '10% off' });
+
+      const order = await firstValueFrom(builder.order$);
+      const line = order.lineItems[0];
+      expect(line.discountAmount).toBeCloseTo(1.00);
+      expect(line.lineTotal).toBeCloseTo(9.90); // (10 - 1) + 0.90 tax
+    });
+
+    it('applies a fixed discount to a line item', async () => {
+      const builder = createOrderBuilder({ currency: 'USD', taxContext });
+      const lineId = builder.addProduct(product, traits);
+      builder.applyLineDiscount(lineId, { type: 'fixed', value: 3 });
+
+      const order = await firstValueFrom(builder.order$);
+      const line = order.lineItems[0];
+      expect(line.discountAmount).toBe(3);
+      expect(line.lineTotal).toBeCloseTo(7.70); // (10 - 3) + 0.70 tax
+    });
+
+    it('caps fixed discount at line gross', async () => {
+      const builder = createOrderBuilder({ currency: 'USD', taxContext });
+      const lineId = builder.addProduct(product, traits);
+      builder.applyLineDiscount(lineId, { type: 'fixed', value: 50 });
+
+      const order = await firstValueFrom(builder.order$);
+      expect(order.lineItems[0].discountAmount).toBe(10);
+    });
+  });
+
+  describe('order-level discounts', () => {
+    it('applies a percentage discount to the order', async () => {
+      const builder = createOrderBuilder({ currency: 'USD', taxContext });
+      builder.addProduct(product, traits);
+      builder.applyOrderDiscount({ type: 'percentage', value: 20 });
+
+      const order = await firstValueFrom(builder.order$);
+      expect(order.discountTotal).toBeCloseTo(2.00);
+      expect(order.total).toBeCloseTo(9.00); // 11 - 2
+    });
+
+    it('applies a fixed discount to the order', async () => {
+      const builder = createOrderBuilder({ currency: 'USD', taxContext });
+      builder.addProduct(product, traits);
+      builder.applyOrderDiscount({ type: 'fixed', value: 5 });
+
+      const order = await firstValueFrom(builder.order$);
+      expect(order.discountTotal).toBeCloseTo(5.00);
+    });
+  });
+
+  describe('discount recalculation on quantity change', () => {
+    it('percentage discount recalculates when quantity changes', async () => {
+      const builder = createOrderBuilder({ currency: 'USD', taxContext });
+      const lineId = builder.addProduct(product, traits); // $10
+      builder.applyLineDiscount(lineId, { type: 'percentage', value: 10 }); // 10% = $1
+
+      // Change quantity to 3 — discount should now be $3 (10% of $30)
+      builder.updateQuantity(lineId, 3);
+
+      const order = await firstValueFrom(builder.order$);
+      const line = order.lineItems[0];
+      expect(line.discountAmount).toBeCloseTo(3.00); // 10% of $30
+      expect(line.lineTotal).toBeCloseTo(29.70); // ($30 - $3) + $2.70 tax
+    });
+
+    it('fixed discount recalculates (caps) when quantity changes', async () => {
+      const builder = createOrderBuilder({ currency: 'USD', taxContext });
+      const lineId = builder.addProduct({ id: 'p1', name: 'Cheap', price: 2 }, traits);
+      builder.applyLineDiscount(lineId, { type: 'fixed', value: 5 }); // capped at $2
+
+      // Change quantity to 3 — gross now $6, fixed $5 is no longer capped
+      builder.updateQuantity(lineId, 3);
+
+      const order = await firstValueFrom(builder.order$);
+      expect(order.lineItems[0].discountAmount).toBe(5);
+    });
+
+    it('stacks multiple discounts on the same line', async () => {
+      const builder = createOrderBuilder({ currency: 'USD', taxContext });
+      const lineId = builder.addProduct(product, traits); // $10
+      builder.applyLineDiscount(lineId, { type: 'percentage', value: 10, label: '10% off' });
+      builder.applyLineDiscount(lineId, { type: 'fixed', value: 2, label: '$2 off' });
+
+      const order = await firstValueFrom(builder.order$);
+      const line = order.lineItems[0];
+      expect(line.discounts).toHaveLength(2);
+      expect(line.discountAmount).toBeCloseTo(3.00); // $1 + $2
+    });
+  });
+
+  describe('removing discounts', () => {
+    it('removes a line discount by id', async () => {
+      const builder = createOrderBuilder({ currency: 'USD', taxContext });
+      const lineId = builder.addProduct(product, traits);
+      builder.applyLineDiscount(lineId, { type: 'fixed', value: 2 });
+
+      let order = await firstValueFrom(builder.order$);
+      const discountId = order.lineItems[0].discounts[0].id;
+      builder.removeDiscount(discountId);
+
+      order = await firstValueFrom(builder.order$);
+      expect(order.lineItems[0].discountAmount).toBe(0);
+    });
+
+    it('removes an order discount by id', async () => {
+      const builder = createOrderBuilder({ currency: 'USD', taxContext });
+      builder.addProduct(product, traits);
+      builder.applyOrderDiscount({ type: 'fixed', value: 5 });
+
+      let order = await firstValueFrom(builder.order$);
+      const discountId = order.discounts[0].id;
+      builder.removeDiscount(discountId);
+
+      order = await firstValueFrom(builder.order$);
+      expect(order.discounts).toHaveLength(0);
+      expect(order.discountTotal).toBe(0);
+    });
+  });
+});

package/src/order/index.ts

@@ -0,0 +1,13 @@
+export { createOrderBuilder } from './order-builder';
+export type { OrderBuilder, OrderBuilderOptions } from './order-builder';
+export { createOrderManager } from './order-manager';
+export type { OrderManager, OrderManagerOptions, ParkedOrderSummary } from './order-manager';
+export type {
+  Order,
+  LineItem,
+  Discount,
+  AppliedDiscount,
+  Payment,
+  CustomerSummary,
+  PaymentMethod,
+} from './types';