@tallyui/pos 0.1.0

package/dist/index.js

@@ -0,0 +1,632 @@
+// src/logging/logger.ts
+function createLogger(scope = "root") {
+  const sinks = /* @__PURE__ */ new Map();
+  function log(level, message, data) {
+    const entry = {
+      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) {
+      return createChildLogger(sinks, name);
+    },
+    addSink(sink) {
+      sinks.set(sink.id, sink);
+    },
+    removeSink(sinkId) {
+      sinks.delete(sinkId);
+    }
+  };
+}
+function logWithSinks(sinks, level, scope, message, data) {
+  const entry = { 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, scope) {
+  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) => createChildLogger(sinks, childName),
+    addSink: (sink) => sinks.set(sink.id, sink),
+    removeSink: (sinkId) => sinks.delete(sinkId)
+  };
+}
+
+// src/logging/sinks.ts
+function consoleSink(options) {
+  return {
+    id: options.id ?? "console",
+    levels: options.levels,
+    scopes: options.scopes,
+    write(entry) {
+      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);
+      }
+    }
+  };
+}
+function callbackSink(options) {
+  return {
+    id: options.id,
+    levels: options.levels,
+    scopes: options.scopes,
+    write: options.callback
+  };
+}
+
+// src/currency/format-currency.ts
+var formatters = /* @__PURE__ */ new Map();
+function getFormatter(currencyCode, locale) {
+  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;
+}
+function formatCurrency(amount, currencyCode, locale) {
+  return getFormatter(currencyCode, locale).format(amount);
+}
+
+// src/currency/currency-provider.tsx
+import { createContext, useContext, useMemo, useCallback } from "react";
+import { jsx } from "react/jsx-runtime";
+var CurrencyCtx = createContext(null);
+function CurrencyProvider({ currencyCode, locale, children }) {
+  const value = useMemo(() => ({ currencyCode, locale }), [currencyCode, locale]);
+  return /* @__PURE__ */ jsx(CurrencyCtx.Provider, { value, children });
+}
+function useCurrencyFormatter() {
+  const ctx = useContext(CurrencyCtx);
+  if (!ctx) {
+    throw new Error("useCurrencyFormatter() must be used within a <CurrencyProvider>");
+  }
+  return useCallback(
+    (amount) => formatCurrency(amount, ctx.currencyCode, ctx.locale),
+    [ctx.currencyCode, ctx.locale]
+  );
+}
+
+// src/tax/calculate.ts
+function round2(n) {
+  return Math.round(n * 100) / 100;
+}
+function addTax(priceExclTax, rate) {
+  return round2(priceExclTax * (1 + rate));
+}
+function extractTax(priceInclTax, rate) {
+  if (rate === 0) return 0;
+  return round2(priceInclTax - priceInclTax / (1 + rate));
+}
+function calculateTax(price, rate, pricesIncludeTax) {
+  if (pricesIncludeTax) {
+    const taxAmount2 = extractTax(price, rate);
+    return {
+      priceInclTax: round2(price),
+      priceExclTax: round2(price - taxAmount2),
+      taxAmount: taxAmount2
+    };
+  }
+  const taxAmount = round2(price * rate);
+  return {
+    priceExclTax: round2(price),
+    priceInclTax: round2(price + taxAmount),
+    taxAmount
+  };
+}
+
+// src/tax/tax-provider.tsx
+import { createContext as createContext2, useContext as useContext2, useMemo as useMemo2 } from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var TaxCtx = createContext2(null);
+function TaxProvider({ rates, pricesIncludeTax, children }) {
+  const value = useMemo2(
+    () => ({
+      getTaxRate(taxClass) {
+        if (taxClass && taxClass in rates) {
+          return rates[taxClass];
+        }
+        return rates.default ?? 0;
+      },
+      pricesIncludeTax
+    }),
+    [rates, pricesIncludeTax]
+  );
+  return /* @__PURE__ */ jsx2(TaxCtx.Provider, { value, children });
+}
+function useTax() {
+  const ctx = useContext2(TaxCtx);
+  if (!ctx) {
+    throw new Error("useTax() must be used within a <TaxProvider>");
+  }
+  return ctx;
+}
+
+// src/repository/create-repository.ts
+import { map } from "rxjs";
+function createRepository(collection) {
+  return {
+    findById$(id) {
+      return collection.findOne(id).$.pipe(
+        map((doc) => doc ? doc.toJSON() : null)
+      );
+    },
+    findAll$(query) {
+      const q = query ? collection.find(query) : collection.find();
+      return q.$.pipe(
+        map((docs) => docs.map((d) => d.toJSON()))
+      );
+    },
+    search$(term, fields) {
+      const escaped = term.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const regex = new RegExp(escaped, "i");
+      return collection.find().$.pipe(
+        map(
+          (docs) => docs.filter((doc) => {
+            const json = doc.toJSON();
+            return fields.some((field) => {
+              const val = json[field];
+              return typeof val === "string" && regex.test(val);
+            });
+          }).map((d) => d.toJSON())
+        )
+      );
+    },
+    count$() {
+      return collection.count().$.pipe(
+        map((count) => count)
+      );
+    },
+    async create(data) {
+      const doc = await collection.insert(data);
+      return doc.toJSON();
+    },
+    async update(id, patch) {
+      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();
+    },
+    async remove(id) {
+      const doc = await collection.findOne(id).exec();
+      if (!doc) throw new Error(`Document ${id} not found`);
+      await doc.remove();
+    },
+    async bulkCreate(items) {
+      const result = await collection.bulkInsert(items);
+      return result.success.map((d) => d.toJSON());
+    },
+    async bulkRemove(ids) {
+      await collection.bulkRemove(ids);
+    }
+  };
+}
+
+// src/order/order-builder.ts
+import { BehaviorSubject } from "rxjs";
+var nextId = 0;
+function uid() {
+  return `${Date.now()}-${++nextId}`;
+}
+function createOrderBuilder(options) {
+  const { currency, taxContext } = options;
+  const orderId = options.id ?? uid();
+  let lineItems = [];
+  let orderDiscounts = [];
+  let payments = [];
+  let customer = null;
+  let note = "";
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const subject = new BehaviorSubject(buildOrder());
+  function recalculateLine(line) {
+    const gross = line.price * line.quantity;
+    const recalcedDiscounts = line.discounts.map((d) => ({
+      ...d,
+      amount: computeDiscountAmount(d, gross)
+    }));
+    const discountAmount = recalcedDiscounts.reduce((sum, d) => sum + d.amount, 0);
+    const afterDiscount = gross - discountAmount;
+    const tax = calculateTax(afterDiscount, line.taxRate, taxContext.pricesIncludeTax);
+    return {
+      ...line,
+      discounts: recalcedDiscounts,
+      discountAmount,
+      taxAmount: tax.taxAmount,
+      lineTotal: taxContext.pricesIncludeTax ? afterDiscount : afterDiscount + tax.taxAmount
+    };
+  }
+  function computeDiscountAmount(discount, base) {
+    if (discount.type === "percentage") {
+      return Math.round(base * discount.value / 100 * 100) / 100;
+    }
+    return Math.min(discount.value, base);
+  }
+  function buildOrder() {
+    const subtotalLines = lineItems.reduce((sum, li) => {
+      const lineGross = li.price * li.quantity - li.discountAmount;
+      if (taxContext.pricesIncludeTax) {
+        const tax = calculateTax(lineGross, li.taxRate, true);
+        return sum + tax.priceExclTax;
+      }
+      return sum + lineGross;
+    }, 0);
+    const subtotal = Math.round(subtotalLines * 100) / 100;
+    const recalcedOrderDiscounts = orderDiscounts.map((d) => ({
+      ...d,
+      amount: computeDiscountAmount(d, subtotal)
+    }));
+    const discountTotal = lineItems.reduce((sum, li) => sum + li.discountAmount, 0) + recalcedOrderDiscounts.reduce((sum, d) => sum + d.amount, 0);
+    const taxTotal = lineItems.reduce((sum, li) => sum + li.taxAmount, 0);
+    const total = lineItems.reduce((sum, li) => sum + li.lineTotal, 0) - recalcedOrderDiscounts.reduce((sum, d) => sum + d.amount, 0);
+    const roundedTotal = Math.round(total * 100) / 100;
+    const paidAmount = payments.reduce((sum, p) => sum + p.amount, 0);
+    const balanceDue = Math.max(0, Math.round((roundedTotal - paidAmount) * 100) / 100);
+    const changeDue = Math.max(0, Math.round((paidAmount - roundedTotal) * 100) / 100);
+    return {
+      id: orderId,
+      status: "draft",
+      lineItems: [...lineItems],
+      discounts: recalcedOrderDiscounts,
+      payments: [...payments],
+      customer,
+      note,
+      subtotal,
+      discountTotal: Math.round(discountTotal * 100) / 100,
+      taxTotal: Math.round(taxTotal * 100) / 100,
+      total: roundedTotal,
+      balanceDue,
+      changeDue,
+      currency,
+      createdAt: now,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  function emit() {
+    subject.next(buildOrder());
+  }
+  return {
+    order$: subject.asObservable(),
+    addProduct(doc, traits, opts) {
+      const productId = traits.getId(doc);
+      const variantId = opts?.variantId;
+      const quantity = opts?.quantity ?? 1;
+      const existing = lineItems.find(
+        (li) => li.productId === productId && li.variantId === variantId
+      );
+      if (existing) {
+        existing.quantity += quantity;
+        lineItems = lineItems.map(
+          (li) => li.id === existing.id ? recalculateLine(existing) : li
+        );
+        emit();
+        return existing.id;
+      }
+      const priceStr = traits.getPrice(doc);
+      const price = priceStr ? parseFloat(priceStr) : 0;
+      const taxRate = taxContext.getTaxRate();
+      const lineId = uid();
+      const line = {
+        id: lineId,
+        productId,
+        variantId,
+        name: traits.getName(doc),
+        sku: traits.getSku(doc) ?? "",
+        imageUrl: traits.getImageUrl(doc),
+        price,
+        quantity,
+        taxRate,
+        taxAmount: 0,
+        discounts: [],
+        discountAmount: 0,
+        lineTotal: 0
+      };
+      lineItems = [...lineItems, recalculateLine(line)];
+      emit();
+      return lineId;
+    },
+    updateQuantity(lineId, quantity) {
+      if (quantity <= 0) {
+        lineItems = lineItems.filter((li) => li.id !== lineId);
+      } else {
+        lineItems = lineItems.map(
+          (li) => li.id === lineId ? recalculateLine({ ...li, quantity }) : li
+        );
+      }
+      emit();
+    },
+    removeItem(lineId) {
+      lineItems = lineItems.filter((li) => li.id !== lineId);
+      emit();
+    },
+    applyLineDiscount(lineId, discount) {
+      lineItems = lineItems.map((li) => {
+        if (li.id !== lineId) return li;
+        const base = li.price * li.quantity;
+        const applied = {
+          ...discount,
+          id: uid(),
+          amount: computeDiscountAmount(discount, base)
+        };
+        return recalculateLine({ ...li, discounts: [...li.discounts, applied] });
+      });
+      emit();
+    },
+    applyOrderDiscount(discount) {
+      const applied = {
+        ...discount,
+        id: uid(),
+        amount: 0
+      };
+      orderDiscounts = [...orderDiscounts, applied];
+      emit();
+    },
+    removeDiscount(discountId) {
+      orderDiscounts = orderDiscounts.filter((d) => d.id !== discountId);
+      lineItems = lineItems.map((li) => {
+        const filtered = li.discounts.filter((d) => d.id !== discountId);
+        if (filtered.length !== li.discounts.length) {
+          return recalculateLine({ ...li, discounts: filtered });
+        }
+        return li;
+      });
+      emit();
+    },
+    addPayment(payment) {
+      const id = uid();
+      payments = [...payments, { ...payment, id }];
+      emit();
+      return id;
+    },
+    removePayment(paymentId) {
+      payments = payments.filter((p) => p.id !== paymentId);
+      emit();
+    },
+    setCustomer(c) {
+      customer = c;
+      emit();
+    },
+    setNote(n) {
+      note = n;
+      emit();
+    },
+    clear() {
+      lineItems = [];
+      orderDiscounts = [];
+      payments = [];
+      customer = null;
+      note = "";
+      emit();
+    },
+    getSnapshot() {
+      return subject.getValue();
+    }
+  };
+}
+
+// src/order/order-manager.ts
+import { BehaviorSubject as BehaviorSubject2, map as map2 } from "rxjs";
+function createOrderManager(options) {
+  const { currency, taxContext, draftsCollection } = options;
+  let activeBuilder = createOrderBuilder({ currency, taxContext });
+  const activeSubject = new BehaviorSubject2(activeBuilder);
+  const parkedOrders$ = draftsCollection.find().$.pipe(
+    map2(
+      (docs) => docs.map((doc) => {
+        const json = doc.toJSON();
+        return {
+          id: json.id,
+          customerName: json.customerName || void 0,
+          itemCount: json.itemCount ?? 0,
+          total: json.total ?? 0,
+          parkedAt: json.parkedAt ?? "",
+          source: "local"
+        };
+      })
+    )
+  );
+  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: (/* @__PURE__ */ 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();
+      const savedOrder = JSON.parse(json.data);
+      const builder = createOrderBuilder({
+        currency,
+        taxContext,
+        id: savedOrder.id
+      });
+      if (savedOrder.customer) {
+        builder.setCustomer(savedOrder.customer);
+      }
+      if (savedOrder.note) {
+        builder.setNote(savedOrder.note);
+      }
+      for (const line of savedOrder.lineItems) {
+        const syntheticTraits = {
+          getId: (d) => d.productId,
+          getName: (d) => d.name,
+          getSku: (d) => d.sku,
+          getPrice: (d) => String(d.price),
+          getRegularPrice: (d) => String(d.price),
+          getSalePrice: () => void 0,
+          isOnSale: () => false,
+          getImageUrl: (d) => d.imageUrl,
+          getImageUrls: (d) => d.imageUrl ? [d.imageUrl] : [],
+          getDescription: () => void 0,
+          getStockStatus: () => "instock",
+          getStockQuantity: () => null,
+          hasVariants: () => false,
+          getType: () => "simple",
+          getBarcode: () => void 0,
+          getCategoryNames: () => []
+        };
+        builder.addProduct(line, syntheticTraits, {
+          variantId: line.variantId,
+          quantity: line.quantity
+        });
+      }
+      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
+            });
+          }
+        }
+      }
+      for (const discount of savedOrder.discounts) {
+        builder.applyOrderDiscount({
+          type: discount.type,
+          value: discount.value,
+          label: discount.label,
+          couponCode: discount.couponCode
+        });
+      }
+      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();
+    }
+  };
+}
+
+// src/receipt/build-receipt-data.ts
+function buildReceiptData(order, config) {
+  const taxByRate = /* @__PURE__ */ new Map();
+  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 || void 0,
+      barcode: order.id
+    },
+    currency: order.currency
+  };
+}
+export {
+  CurrencyProvider,
+  TaxProvider,
+  addTax,
+  buildReceiptData,
+  calculateTax,
+  callbackSink,
+  consoleSink,
+  createLogger,
+  createOrderBuilder,
+  createOrderManager,
+  createRepository,
+  extractTax,
+  formatCurrency,
+  useCurrencyFormatter,
+  useTax
+};

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@tallyui/pos",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Shared POS business logic for Tally UI — tax, orders, payments, discounts, receipts",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "source": "./src/index.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "source": "./src/index.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "license": "MIT",
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  },
+  "peerDependencies": {
+    "@tallyui/core": "workspace:*",
+    "react": ">=18",
+    "rxdb": ">=16",
+    "rxjs": ">=7"
+  },
+  "devDependencies": {
+    "@tallyui/core": "workspace:*",
+    "@types/react": ">=18",
+    "react": "^19.2.4",
+    "rxdb": "16.21.1",
+    "rxjs": "7.8.2"
+  }
+}

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

@@ -0,0 +1,36 @@
+import { describe, it, expect } from 'vitest';
+import { renderHook } from '@testing-library/react';
+import type { ReactNode } from 'react';
+import { CurrencyProvider, useCurrencyFormatter } from './currency-provider';
+
+function wrapper(currency: string, locale?: string) {
+  return function Wrapper({ children }: { children: ReactNode }) {
+    return (
+      <CurrencyProvider currencyCode={currency} locale={locale}>
+        {children}
+      </CurrencyProvider>
+    );
+  };
+}
+
+describe('CurrencyProvider + useCurrencyFormatter', () => {
+  it('formats using provided currency and locale', () => {
+    const { result } = renderHook(() => useCurrencyFormatter(), {
+      wrapper: wrapper('USD', 'en-US'),
+    });
+    expect(result.current(10.5)).toBe('$10.50');
+  });
+
+  it('formats EUR with German locale', () => {
+    const { result } = renderHook(() => useCurrencyFormatter(), {
+      wrapper: wrapper('EUR', 'de-DE'),
+    });
+    expect(result.current(10.5).replace(/\s/g, ' ')).toBe('10,50 €');
+  });
+
+  it('throws when used outside provider', () => {
+    expect(() => {
+      renderHook(() => useCurrencyFormatter());
+    }).toThrow('useCurrencyFormatter() must be used within a <CurrencyProvider>');
+  });
+});