@tallyui/pos 0.1.0

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

@@ -0,0 +1,56 @@
+import type { Order } from '../order/types';
+import type { ReceiptConfig, ReceiptData } from './types';
+
+export function buildReceiptData(order: Order, config: ReceiptConfig): ReceiptData {
+  const taxByRate = new Map<number, number>();
+  for (const line of order.lineItems) {
+    const existing = taxByRate.get(line.taxRate) ?? 0;
+    taxByRate.set(line.taxRate, existing + line.taxAmount);
+  }
+
+  const taxLines = Array.from(taxByRate.entries()).map(([rate, amount]) => ({
+    label: config.taxLabels?.[rate] ?? `Tax ${Math.round(rate * 100)}%`,
+    rate,
+    amount: Math.round(amount * 100) / 100,
+  }));
+
+  return {
+    header: {
+      storeName: config.storeName,
+      storeAddress: config.storeAddress,
+      orderNumber: order.id,
+      date: order.createdAt,
+      cashier: config.cashier,
+      register: config.register,
+    },
+    lineItems: order.lineItems.map((li) => ({
+      name: li.name,
+      sku: li.sku,
+      quantity: li.quantity,
+      unitPrice: li.price,
+      lineTotal: li.lineTotal,
+    })),
+    discounts: order.discounts.map((d) => ({
+      label: d.label ?? d.couponCode ?? `${d.type} discount`,
+      amount: d.amount,
+    })),
+    totals: {
+      subtotal: order.subtotal,
+      discountTotal: order.discountTotal,
+      taxLines,
+      taxTotal: order.taxTotal,
+      total: order.total,
+    },
+    payments: order.payments.map((p) => ({
+      method: p.method,
+      amount: p.amount,
+      reference: p.reference,
+    })),
+    changeDue: order.changeDue,
+    footer: {
+      note: order.note || undefined,
+      barcode: order.id,
+    },
+    currency: order.currency,
+  };
+}

package/src/receipt/index.ts

@@ -0,0 +1,2 @@
+export { buildReceiptData } from './build-receipt-data';
+export type { ReceiptData, ReceiptLineItem, ReceiptConfig } from './types';

package/src/receipt/types.ts

@@ -0,0 +1,42 @@
+export interface ReceiptLineItem {
+  name: string;
+  sku: string;
+  quantity: number;
+  unitPrice: number;
+  lineTotal: number;
+}
+
+export interface ReceiptData {
+  header: {
+    storeName: string;
+    storeAddress?: string;
+    orderNumber: string;
+    date: string;
+    cashier?: string;
+    register?: string;
+  };
+  lineItems: ReceiptLineItem[];
+  discounts: { label: string; amount: number }[];
+  totals: {
+    subtotal: number;
+    discountTotal: number;
+    taxLines: { label: string; rate: number; amount: number }[];
+    taxTotal: number;
+    total: number;
+  };
+  payments: { method: string; amount: number; reference?: string }[];
+  changeDue: number;
+  footer: {
+    note?: string;
+    barcode?: string;
+  };
+  currency: string;
+}
+
+export interface ReceiptConfig {
+  storeName: string;
+  storeAddress?: string;
+  cashier?: string;
+  register?: string;
+  taxLabels?: Record<number, string>;
+}

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

@@ -0,0 +1,166 @@
+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/repository/create-repository.ts

@@ -0,0 +1,74 @@
+import { map } from 'rxjs';
+import type { Observable } from 'rxjs';
+import type { RxCollection, MangoQuery } from 'rxdb';
+import type { Repository } from './types';
+
+export function createRepository<T extends { id: string }>(
+  collection: RxCollection<T>,
+): Repository<T> {
+  return {
+    findById$(id: string): Observable<T | null> {
+      return collection.findOne(id).$.pipe(
+        map((doc) => (doc ? (doc.toJSON() as T) : null)),
+      );
+    },
+
+    findAll$(query?: MangoQuery<T>): Observable<T[]> {
+      const q = query ? collection.find(query) : collection.find();
+      return q.$.pipe(
+        map((docs) => docs.map((d) => d.toJSON() as T)),
+      );
+    },
+
+    search$(term: string, fields: (keyof T)[]): Observable<T[]> {
+      const escaped = term.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+      const regex = new RegExp(escaped, 'i');
+      return collection.find().$.pipe(
+        map((docs) =>
+          docs
+            .filter((doc) => {
+              const json = doc.toJSON() as Record<string, unknown>;
+              return fields.some((field) => {
+                const val = json[field as string];
+                return typeof val === 'string' && regex.test(val);
+              });
+            })
+            .map((d) => d.toJSON() as T),
+        ),
+      );
+    },
+
+    count$(): Observable<number> {
+      return collection.count().$.pipe(
+        map((count) => count),
+      );
+    },
+
+    async create(data: Partial<T>): Promise<T> {
+      const doc = await collection.insert(data as T);
+      return doc.toJSON() as T;
+    },
+
+    async update(id: string, patch: Partial<T>): Promise<T> {
+      const doc = await collection.findOne(id).exec();
+      if (!doc) throw new Error(`Document ${id} not found`);
+      const updated = await doc.incrementalPatch(patch);
+      return updated.toJSON() as T;
+    },
+
+    async remove(id: string): Promise<void> {
+      const doc = await collection.findOne(id).exec();
+      if (!doc) throw new Error(`Document ${id} not found`);
+      await doc.remove();
+    },
+
+    async bulkCreate(items: Partial<T>[]): Promise<T[]> {
+      const result = await collection.bulkInsert(items as T[]);
+      return result.success.map((d) => d.toJSON() as T);
+    },
+
+    async bulkRemove(ids: string[]): Promise<void> {
+      await collection.bulkRemove(ids);
+    },
+  };
+}

package/src/repository/index.ts

@@ -0,0 +1,2 @@
+export { createRepository } from './create-repository';
+export type { Repository } from './types';

package/src/repository/types.ts

@@ -0,0 +1,15 @@
+import type { Observable } from 'rxjs';
+import type { MangoQuery } from 'rxdb';
+
+export interface Repository<T> {
+  findById$(id: string): Observable<T | null>;
+  findAll$(query?: MangoQuery<T>): Observable<T[]>;
+  search$(term: string, fields: (keyof T)[]): Observable<T[]>;
+  count$(): Observable<number>;
+
+  create(data: Partial<T>): Promise<T>;
+  update(id: string, patch: Partial<T>): Promise<T>;
+  remove(id: string): Promise<void>;
+  bulkCreate(items: Partial<T>[]): Promise<T[]>;
+  bulkRemove(ids: string[]): Promise<void>;
+}

package/src/tax/calculate.test.ts

@@ -0,0 +1,59 @@
+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

@@ -0,0 +1,32 @@
+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/index.ts

@@ -0,0 +1,4 @@
+export { calculateTax, extractTax, addTax } from './calculate';
+export { TaxProvider, useTax } from './tax-provider';
+export type { TaxProviderProps } from './tax-provider';
+export type { TaxResult, TaxRateMap, TaxContext } from './types';

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

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

package/src/tax/tax-provider.tsx

@@ -0,0 +1,36 @@
+import { createContext, useContext, useMemo } from 'react';
+import type { ReactNode } from 'react';
+import type { TaxContext } from './types';
+
+const TaxCtx = createContext<TaxContext | null>(null);
+
+export interface TaxProviderProps {
+  rates: Record<string, number>;
+  pricesIncludeTax: boolean;
+  children: ReactNode;
+}
+
+export function TaxProvider({ rates, pricesIncludeTax, children }: TaxProviderProps) {
+  const value = useMemo<TaxContext>(
+    () => ({
+      getTaxRate(taxClass?: string) {
+        if (taxClass && taxClass in rates) {
+          return rates[taxClass];
+        }
+        return rates.default ?? 0;
+      },
+      pricesIncludeTax,
+    }),
+    [rates, pricesIncludeTax],
+  );
+
+  return <TaxCtx.Provider value={value}>{children}</TaxCtx.Provider>;
+}
+
+export function useTax(): TaxContext {
+  const ctx = useContext(TaxCtx);
+  if (!ctx) {
+    throw new Error('useTax() must be used within a <TaxProvider>');
+  }
+  return ctx;
+}

package/src/tax/types.ts

@@ -0,0 +1,15 @@
+export interface TaxResult {
+  priceExclTax: number;
+  priceInclTax: number;
+  taxAmount: number;
+}
+
+export type TaxRateMap = {
+  default: number;
+  [taxClass: string]: number;
+};
+
+export interface TaxContext {
+  getTaxRate(taxClass?: string): number;
+  pricesIncludeTax: boolean;
+}