@teincfood/core 0.7.7 → 0.7.8

package/dist/image-cache/service.js

@@ -0,0 +1,125 @@
+/**
+ * Image cache for offline reference — port of Business src/reference/image-cache.ts
+ * Durable documentDirectory cache (not cacheDirectory) with stable presigned URL keying.
+ * Host injects FileSystemAdapter; falls back to no-op on web.
+ */
+import { getFileSystemAdapter } from "../adapters/filesystem";
+import { syncLogger } from "../utils/sync-logger";
+export function stableCacheUrl(url) {
+    try {
+        const p = new URL(url);
+        return `${p.origin}${p.pathname}`;
+    }
+    catch {
+        return url;
+    }
+}
+function cacheKeyFromUrl(url) {
+    let hash = 0;
+    const stable = stableCacheUrl(url);
+    for (let i = 0; i < stable.length; i++) {
+        hash = (hash << 5) - hash + stable.charCodeAt(i);
+        hash |= 0;
+    }
+    return `${Math.abs(hash).toString(16)}.img`;
+}
+function getImageCacheDir(fs) {
+    const base = fs?.getDocumentDirectory() ?? "";
+    return `${base}teincfood_images/`;
+}
+export function getCachedImagePath(url) {
+    const fs = getFileSystemAdapter();
+    return `${getImageCacheDir(fs)}${cacheKeyFromUrl(url)}`;
+}
+export async function ensureImageCacheDir() {
+    const fs = getFileSystemAdapter();
+    if (!fs)
+        return "";
+    const dir = getImageCacheDir(fs);
+    const info = await fs.getInfoAsync(dir);
+    if (!info.exists)
+        await fs.makeDirectoryAsync(dir, { intermediates: true });
+    return dir;
+}
+export async function getCachedImageInfo(url) {
+    const fs = getFileSystemAdapter();
+    if (!fs)
+        return { remoteUrl: url, localUri: url, etag: null, lastModified: null, cachedAt: new Date().toISOString() };
+    const localPath = getCachedImagePath(url);
+    const info = await fs.getInfoAsync(localPath);
+    return { remoteUrl: url, localUri: info.exists && !info.isDirectory ? localPath : null, etag: null, lastModified: null, cachedAt: info.exists ? new Date().toISOString() : null };
+}
+export async function cacheRemoteImage(url, opts = {}) {
+    if (!url)
+        return null;
+    const fs = getFileSystemAdapter();
+    if (!fs)
+        return { remoteUrl: url, localUri: url, etag: null, lastModified: null, cachedAt: new Date().toISOString() };
+    await ensureImageCacheDir();
+    const localPath = getCachedImagePath(url);
+    const existing = await fs.getInfoAsync(localPath);
+    if (opts.skipIfCached && existing.exists && !existing.isDirectory) {
+        return { remoteUrl: url, localUri: localPath, etag: null, lastModified: null, cachedAt: new Date().toISOString() };
+    }
+    try {
+        const res = await fs.downloadAsync(url, localPath);
+        if (res.uri)
+            return { remoteUrl: url, localUri: localPath, etag: null, lastModified: null, cachedAt: new Date().toISOString() };
+    }
+    catch (e) {
+        syncLogger.warn("ImageCache", "Failed to download", { url, error: String(e) });
+    }
+    if (opts.removeOnFailure)
+        await fs.deleteAsync(localPath, { idempotent: true }).catch(() => { });
+    if (existing.exists && !existing.isDirectory)
+        return { remoteUrl: url, localUri: localPath, etag: null, lastModified: null, cachedAt: new Date().toISOString() };
+    return { remoteUrl: url, localUri: null, etag: null, lastModified: null, cachedAt: null };
+}
+export async function cacheImageBatch(urls, opts = {}) {
+    const results = await Promise.all(urls.map((u) => cacheRemoteImage(u, opts)));
+    return results.filter((r) => r !== null);
+}
+export async function clearImageCache() {
+    const fs = getFileSystemAdapter();
+    if (!fs)
+        return;
+    await fs.deleteAsync(getImageCacheDir(fs), { idempotent: true });
+}
+export async function pruneImageCache(knownUrls, maxAgeDays = 30) {
+    try {
+        const fs = getFileSystemAdapter();
+        if (!fs)
+            return 0;
+        const known = new Set();
+        for (const u of knownUrls)
+            if (u)
+                known.add(u);
+        const dir = getImageCacheDir(fs);
+        const info = await fs.getInfoAsync(dir);
+        if (!info.exists || info.isDirectory !== true)
+            return 0;
+        // cutoff check skipped without modificationTime — just orphan check
+        const entries = await fs.readDirectoryAsync(dir);
+        let pruned = 0;
+        for (const f of entries) {
+            if (!f.endsWith(".img"))
+                continue;
+            if ([...known].some((url) => getCachedImagePath(url) === `${dir}${f}`))
+                continue;
+            await fs.deleteAsync(`${dir}${f}`, { idempotent: true });
+            pruned += 1;
+        }
+        if (pruned > 0)
+            syncLogger.info("ImageCache", "Pruned orphan images", { pruned });
+        return pruned;
+    }
+    catch {
+        return 0;
+    }
+}
+export async function resolveImageSource(url) {
+    if (!url)
+        return null;
+    const cached = await getCachedImageInfo(url);
+    return cached.localUri ? { uri: cached.localUri } : { uri: url };
+}

package/dist/index.d.ts

@@ -63,16 +63,27 @@ export * from "./reference/service";
 export { referenceSyncService } from "./reference/service";
 export * from "./reference/capabilities";
 export * from "./adapters/sqlite";
-export * from "./adapters/kv";
+export { KVDriver, setKVDriver, getKVDriver, kvGetItem, kvSetItem, kvRemoveItem, getItem, setItem, removeItem, getItemSync, setItemSync } from "./adapters/kv";
 export * from "./adapters/connectivity";
 export * from "./adapters/http";
 export * from "./adapters/local-node";
 export * from "./adapters/services";
 export * from "./adapters/devices";
-export * from "./adapters/image-cache";
+export { imageCacheService } from "./adapters/image-cache";
 export * from "./adapters/business";
 export * from "./adapters/pending-orders";
+export * from "./adapters/print";
+export * from "./adapters/filesystem";
 export { KIOSK_KEYS, SELLER_ORDERS_KEYS, BUSINESS_DELIVERIES_KEYS, MENU_KEYS, REFERENCE_KEYS } from "./adapters/query-keys";
+export * from "./printer/types";
+export * from "./printer/store";
+export * from "./printer/receipt";
+export * from "./printer/service";
+export * from "./printer/hooks";
+export * from "./cart/store";
+export * from "./cart/hooks";
+export * from "./catalog/hooks";
+export { getCachedImagePath, ensureImageCacheDir, getCachedImageInfo, cacheRemoteImage, cacheImageBatch, clearImageCache, pruneImageCache, resolveImageSource, stableCacheUrl } from "./image-cache/service";
 import { type SqliteDriver } from "./adapters/sqlite";
 import { type KVDriver } from "./adapters/kv";
 import { type HttpClient } from "./adapters/http";
@@ -88,6 +99,12 @@ export interface CoreConfig {
         isOnline?: boolean;
         isCloudReachable?: "reachable" | "unreachable" | "unknown";
     };
+    printAdapters?: {
+        tcp?: import("./adapters/print").TcpSocketAdapter;
+        printFile?: import("./adapters/print").PrintFileAdapter;
+        mdns?: import("./adapters/print").MdnsAdapter;
+    };
+    fileSystemAdapter?: import("./adapters/filesystem").FileSystemAdapter;
 }
 export declare function createTeincCore(config?: CoreConfig): {
     engine: SyncEngine;

package/dist/index.js

@@ -66,22 +66,39 @@ export { referenceSyncService } from "./reference/service";
 export * from "./reference/capabilities";
 // ── Adapters (for host apps to supply) ──
 export * from "./adapters/sqlite";
-export * from "./adapters/kv";
+export { setKVDriver, getKVDriver, kvGetItem, kvSetItem, kvRemoveItem, getItem, setItem, removeItem, getItemSync, setItemSync } from "./adapters/kv";
 export * from "./adapters/connectivity";
 export * from "./adapters/http";
 export * from "./adapters/local-node";
 export * from "./adapters/services";
 export * from "./adapters/devices";
-export * from "./adapters/image-cache";
+export { imageCacheService } from "./adapters/image-cache";
 export * from "./adapters/business";
 export * from "./adapters/pending-orders";
+export * from "./adapters/print";
+export * from "./adapters/filesystem";
 export { KIOSK_KEYS, SELLER_ORDERS_KEYS, BUSINESS_DELIVERIES_KEYS, MENU_KEYS, REFERENCE_KEYS } from "./adapters/query-keys";
 // POS_KEYS / SELLER_KEYS are exported from hooks/orders.hooks (offline-first source of truth)
+// ── Printer (backend-identical template) ──
+export * from "./printer/types";
+export * from "./printer/store";
+export * from "./printer/receipt";
+export * from "./printer/service";
+export * from "./printer/hooks";
+// ── Cart (device-local) ──
+export * from "./cart/store";
+export * from "./cart/hooks";
+// ── Catalog ──
+export * from "./catalog/hooks";
+// ── Image cache (durable) ──
+export { getCachedImagePath, ensureImageCacheDir, getCachedImageInfo, cacheRemoteImage, cacheImageBatch, clearImageCache, pruneImageCache, resolveImageSource, stableCacheUrl } from "./image-cache/service";
 // ── Init helper ──
 import { setSqliteDriver } from "./adapters/sqlite";
 import { setKVDriver } from "./adapters/kv";
 import { setConnectivityState } from "./adapters/connectivity";
 import { setHttpClient } from "./adapters/http";
+import { setTcpAdapter, setPrintFileAdapter, setMdnsAdapter } from "./adapters/print";
+import { setFileSystemAdapter } from "./adapters/filesystem";
 import { API_BASE_URL, WS_BASE_URL, setApiBaseUrl, setWsBaseUrl } from "./utils/constants";
 import { SyncEngine } from "./sync/engine";
 import { restTransport } from "./sync/transport-rest";
@@ -105,6 +122,14 @@ export function createTeincCore(config = {}) {
         setKVDriver(config.kvDriver);
     if (config.httpClient)
         setHttpClient(config.httpClient);
+    if (config.printAdapters?.tcp)
+        setTcpAdapter(config.printAdapters.tcp);
+    if (config.printAdapters?.printFile)
+        setPrintFileAdapter(config.printAdapters.printFile);
+    if (config.printAdapters?.mdns)
+        setMdnsAdapter(config.printAdapters.mdns);
+    if (config.fileSystemAdapter)
+        setFileSystemAdapter(config.fileSystemAdapter);
     if (config.apiBaseUrl)
         setApiBaseUrl(config.apiBaseUrl);
     else {

package/dist/printer/hooks.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Printer hooks for UI.
+ */
+import { setDefaultPrinter, setAutoPrint, addPrinter, updatePrinter, removePrinter } from "./store";
+import type { SellerOrder } from "../types/api/seller.api";
+export declare function usePrinter(): {
+    defaultPrinterId: string | null;
+    printers: import("./types").PrinterConfig[];
+    autoPrint: boolean;
+    setDefaultPrinter: typeof setDefaultPrinter;
+    setAutoPrint: typeof setAutoPrint;
+    addPrinter: typeof addPrinter;
+    updatePrinter: typeof updatePrinter;
+    removePrinter: typeof removePrinter;
+};
+export declare function usePrintOrder(): {
+    print: (order: SellerOrder) => Promise<void>;
+    printing: boolean;
+};
+export declare function useDiscoverPrinters(): {
+    printers: {
+        name: string;
+        ip: string;
+        port: number;
+    }[];
+    discovering: boolean;
+    discover: (timeoutMs?: number) => Promise<{
+        name: string;
+        ip: string;
+        port: number;
+    }[]>;
+};

package/dist/printer/hooks.js

@@ -0,0 +1,53 @@
+/**
+ * Printer hooks for UI.
+ */
+import { useSyncExternalStore, useCallback } from "react";
+import { subscribePrinter, getPrinterSnapshot, setDefaultPrinter, setAutoPrint, addPrinter, updatePrinter, removePrinter, hydratePrinterStore } from "./store";
+import { getMdnsAdapter } from "../adapters/print";
+import { printerService } from "./service";
+import { useEffect, useState } from "react";
+export function usePrinter() {
+    const state = useSyncExternalStore(subscribePrinter, getPrinterSnapshot, getPrinterSnapshot);
+    useEffect(() => { void hydratePrinterStore(); }, []);
+    return {
+        ...state,
+        setDefaultPrinter,
+        setAutoPrint,
+        addPrinter,
+        updatePrinter,
+        removePrinter,
+    };
+}
+export function usePrintOrder() {
+    const [printing, setPrinting] = useState(false);
+    const print = useCallback(async (order) => {
+        setPrinting(true);
+        try {
+            await printerService.printOrderReceipt(order);
+        }
+        finally {
+            setPrinting(false);
+        }
+    }, []);
+    return { print, printing };
+}
+export function useDiscoverPrinters() {
+    const [discovering, setDiscovering] = useState(false);
+    const [printers, setPrinters] = useState([]);
+    const discover = useCallback(async (timeoutMs = 8000) => {
+        setDiscovering(true);
+        try {
+            const mdns = getMdnsAdapter();
+            if (mdns?.discoverPrinters) {
+                const found = await mdns.discoverPrinters(timeoutMs);
+                setPrinters(found);
+                return found;
+            }
+            return [];
+        }
+        finally {
+            setDiscovering(false);
+        }
+    }, []);
+    return { printers, discovering, discover };
+}

package/dist/printer/receipt.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Local receipt generation — 1:1 port of TeincFoodBackend.Orders.Receipt
+ * Generates ESC/POS (80mm, 32 chars) and HTML from a SellerOrder snapshot.
+ * Works fully offline for queued DD-RRR-CCC orders without backend fetch.
+ *
+ * Backend source: lib/teinc_food_backend/orders/receipt.ex
+ * Keep this file in sync with backend when template changes.
+ */
+import type { SellerOrder } from "../types/api/seller.api";
+export declare function calloutNumber(order: SellerOrder): string;
+export declare function generateEscpos(order: SellerOrder): string;
+export declare function generateHtml(order: SellerOrder, logoDataUri?: string | null): string;

package/dist/printer/receipt.js

@@ -0,0 +1,315 @@
+/**
+ * Local receipt generation — 1:1 port of TeincFoodBackend.Orders.Receipt
+ * Generates ESC/POS (80mm, 32 chars) and HTML from a SellerOrder snapshot.
+ * Works fully offline for queued DD-RRR-CCC orders without backend fetch.
+ *
+ * Backend source: lib/teinc_food_backend/orders/receipt.ex
+ * Keep this file in sync with backend when template changes.
+ */
+const LINE_WIDTH = 32;
+const ESC_INIT = "\x1B\x40";
+const ESC_ALIGN_LEFT = "\x1B\x61\x00";
+const ESC_ALIGN_CENTER = "\x1B\x61\x01";
+const ESC_BOLD_ON = "\x1B\x45\x01";
+const ESC_BOLD_OFF = "\x1B\x45\x00";
+const GS_SIZE_NORMAL = "\x1D\x21\x00";
+const GS_SIZE_DOUBLE_W = "\x1D\x21\x11";
+const GS_SIZE_DOUBLE_WH = "\x1D\x21\x33";
+const LF = "\x0A";
+const ESC_FEED_3 = "\x1B\x64\x03";
+const GS_CUT_FULL = "\x1D\x56\x00";
+function padR(text, width) {
+    if (text.length >= width)
+        return text.slice(0, width);
+    return text.padEnd(width, " ");
+}
+function currencySymbol(currency) {
+    switch (currency) {
+        case "GHS": return "₵";
+        case "USD": return "$";
+        case "EUR": return "€";
+        case "GBP": return "£";
+        default: return currency ? currency + " " : "";
+    }
+}
+function formatMoney(amountMinor, order) {
+    if (amountMinor == null)
+        return "---";
+    const sym = currencySymbol(order.currency_code || order.currency);
+    return `${sym}${(amountMinor / 100).toFixed(2)}`;
+}
+function formatDatetime(iso) {
+    if (!iso)
+        return "---";
+    try {
+        const d = new Date(iso);
+        // Backend: Calendar.strftime(dt, "%d %b %Y %H:%M") e.g. "03 Sep 2026 14:05"
+        const day = String(d.getDate()).padStart(2, "0");
+        const months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+        const mon = months[d.getMonth()];
+        const year = d.getFullYear();
+        const hh = String(d.getHours()).padStart(2, "0");
+        const mm = String(d.getMinutes()).padStart(2, "0");
+        return `${day} ${mon} ${year} ${hh}:${mm}`;
+    }
+    catch {
+        return iso;
+    }
+}
+export function calloutNumber(order) {
+    const num = order.order_number || "";
+    if (!num)
+        return "----";
+    const last4 = num.slice(-4);
+    const n = parseInt(last4, 10);
+    if (Number.isNaN(n))
+        return last4;
+    return String(n);
+}
+function itemName(item) {
+    return item.menu_item?.name || "(deleted item)";
+}
+function addonName(addon) {
+    const a = addon;
+    if (a.addon?.name)
+        return a.addon.name;
+    if (a.name)
+        return a.name;
+    return "Add-on";
+}
+function orderTypeText(order) {
+    const t = order.order_type;
+    if (t === "takeout")
+        return "Takeout";
+    if (t === "dine_in")
+        return "Dine-in";
+    if (t === "delivery")
+        return "Delivery";
+    if (order.payment_mode === "pay_on_delivery")
+        return "Pay on Delivery";
+    if (order.payment_mode === "prepaid")
+        return "Prepaid";
+    return "Walk-in";
+}
+function paymentLineText(order) {
+    const m = order.pos_payment_method;
+    if (m)
+        return `Payment: ${m.charAt(0).toUpperCase() + m.slice(1)}`;
+    if (order.payment_mode === "pay_on_delivery")
+        return "Payment: Cash / Pay on Delivery";
+    if (order.payment_mode === "prepaid")
+        return "Payment: Prepaid (Online)";
+    return "Payment: Walk-in";
+}
+function escHtml(s) {
+    if (!s)
+        return "";
+    return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function businessAddress(business) {
+    const b = business;
+    if (!b)
+        return null;
+    if (b.location?.address)
+        return b.location.address;
+    if (b.address)
+        return b.address;
+    return null;
+}
+// ── ESC/POS ────────────────────────────────────────────────────────────
+function doubleLineEscpos() { return "═".repeat(LINE_WIDTH) + LF; }
+function singleLineEscpos() { return "─".repeat(LINE_WIDTH); }
+function customerLineEscpos(order) {
+    if (order.customer_name)
+        return `Customer: ${order.customer_name}${LF}`;
+    if (order.customer_phone)
+        return `Phone: ${order.customer_phone}${LF}`;
+    if (order.user?.full_name)
+        return `Customer: ${order.user.full_name}${LF}`;
+    return null;
+}
+function orderTypeEscpos(order) { return orderTypeText(order); }
+function paymentLineEscpos(order) { return paymentLineText(order); }
+export function generateEscpos(order) {
+    const business = order.business;
+    const items = order.items || [];
+    const taxLines = (order.order_tax_lines ?? order.tax_lines ?? []);
+    const parts = [];
+    const push = (s) => { if (s != null)
+        parts.push(s); };
+    // Header — matches receipt.ex to_escpos/1
+    push(ESC_INIT);
+    push(ESC_ALIGN_CENTER);
+    push(GS_SIZE_DOUBLE_WH);
+    push(business?.name || "Teinc Food");
+    push(LF);
+    push(GS_SIZE_NORMAL);
+    const addr = businessAddress(business);
+    if (addr)
+        push(addr + LF);
+    const bPhone = business?.phone;
+    if (bPhone)
+        push(`Tel: ${bPhone}${LF}`);
+    push(GS_SIZE_NORMAL);
+    push(doubleLineEscpos());
+    // Order info
+    push(ESC_ALIGN_LEFT);
+    push(`Order: ${order.order_number}${LF}`);
+    // callout_box_escpos
+    push(ESC_ALIGN_CENTER);
+    push(GS_SIZE_DOUBLE_W);
+    push(`Callout: ${calloutNumber(order)}${LF}`);
+    push(GS_SIZE_NORMAL);
+    push(LF);
+    push(ESC_ALIGN_LEFT);
+    push(`Date: ${formatDatetime(order.inserted_at)}${LF}`);
+    push(`Type: ${orderTypeEscpos(order)}${LF}`);
+    const custLine = customerLineEscpos(order);
+    if (custLine)
+        push(custLine);
+    push(LF);
+    // Barcode — CODE128 GS k 73
+    push(ESC_ALIGN_CENTER);
+    const data = order.order_number || "";
+    push(String.fromCharCode(0x1d, 0x6b, 0x49, data.length) + data);
+    push(LF);
+    // Items
+    push(ESC_ALIGN_LEFT);
+    push(`${padR("Item", 16)} Qty   Price`);
+    push(LF);
+    push(singleLineEscpos());
+    push(LF);
+    for (const item of items) {
+        const qty = item.quantity || 1;
+        const price = formatMoney((item.unit_price ?? 0) * qty, order);
+        push(`  ${padR(itemName(item), 16)} ${padR(String(qty), 4)} ${padR(price, 9)}${LF}`);
+        const addons = item.order_item_addons ?? item.addons ?? [];
+        for (const addon of addons) {
+            const aName = addonName(addon);
+            const aPriceMinor = addon.price_minor ?? addon.price ?? 0;
+            const addonPrice = formatMoney(aPriceMinor, order);
+            push(`    + ${padR(aName, 12)}      ${padR(addonPrice, 9)}${LF}`);
+        }
+    }
+    push(singleLineEscpos());
+    push(LF);
+    // Subtotal section — mirrors subtotal_section_escpos/2
+    push(`${padR("Subtotal:", 20)} ${formatMoney(order.subtotal_minor, order)}${LF}`);
+    if (order.delivery_fee_minor && order.delivery_fee_minor > 0) {
+        push(`${padR("Delivery Fee:", 20)} ${formatMoney(order.delivery_fee_minor, order)}${LF}`);
+    }
+    for (const tax of taxLines) {
+        const rateStr = tax.rate_basis_points ? `(${Math.floor(tax.rate_basis_points / 100)}%)` : "";
+        const label = `${tax.name || ""} ${rateStr}`.trim().slice(0, 19);
+        push(`${padR(label, 20)} ${formatMoney(tax.tax_amount_minor, order)}${LF}`);
+    }
+    if (order.discount_minor && order.discount_minor > 0) {
+        push(`${padR("Discount:", 20)} -${formatMoney(order.discount_minor, order)}${LF}`);
+    }
+    push(ESC_BOLD_ON);
+    push(`${padR("TOTAL:", 20)} ${formatMoney(order.total_minor, order)}${LF}`);
+    push(ESC_BOLD_OFF);
+    push(LF);
+    push(ESC_ALIGN_CENTER);
+    push(paymentLineEscpos(order));
+    push(LF);
+    // Footer
+    push(doubleLineEscpos());
+    push("Thank you for your order!" + LF);
+    push("Come back soon!" + LF);
+    push(ESC_FEED_3);
+    push(GS_CUT_FULL);
+    return parts.filter((p) => p != null).join("");
+}
+// ── HTML ───────────────────────────────────────────────────────────────
+export function generateHtml(order, logoDataUri) {
+    const business = order.business;
+    const items = order.items || [];
+    const taxLines = ((order.order_tax_lines) ?? order.tax_lines ?? []);
+    const callout = calloutNumber(order);
+    const logoSrc = logoDataUri || business?.logo_url || "";
+    const hasLogo = !!logoSrc;
+    const businessName = escHtml(business?.name || "Teinc Food");
+    const addr = businessAddress(business);
+    const bPhone = business?.phone;
+    const itemRows = items.map((item) => {
+        const qty = item.quantity || 1;
+        // unit_price is already minor? backend format_money expects minor
+        const price = formatMoney((item.unit_price ?? 0) * qty, order);
+        const main = `<tr><td class="item-name">${escHtml(itemName(item))}</td><td class="item-qty">${qty}</td><td class="item-price">${price}</td></tr>`;
+        const addons = (item.order_item_addons ?? item.addons ?? []);
+        const addonRows = addons.map((addon) => {
+            const aName = escHtml(addonName(addon));
+            const aPriceMinor = addon.price_minor ?? addon.price ?? 0;
+            return `<tr class="addon-row"><td class="item-name">+ ${aName}</td><td class="item-qty"></td><td class="addon-price">${formatMoney(aPriceMinor, order)}</td></tr>`;
+        }).join("\n");
+        return [main, addonRows].filter(Boolean).join("\n");
+    }).join("\n");
+    const taxRowsHtml = taxLines.map((tax) => {
+        const rateStr = tax.rate_basis_points ? `(${Math.floor(tax.rate_basis_points / 100)}%)` : "";
+        return `<tr><td class="label">${escHtml(tax.name || "")} ${escHtml(rateStr)}</td><td class="amount">${formatMoney(tax.tax_amount_minor, order)}</td></tr>`;
+    }).join("\n");
+    // Exact style from receipt.ex to_html/2
+    return `<!DOCTYPE html>
+<html>
+<head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
+<style>
+  body{font-family:monospace;max-width:320px;margin:0 auto;padding:16px;background:#fff;color:#111;}
+  .header{text-align:center;border-top:2px solid #333;border-bottom:2px solid #333;padding:8px 0;margin-bottom:12px;}
+  .header .logo{max-width:180px;max-height:60px;margin:4px auto;display:block;object-fit:contain;}
+  .header h2{margin:4px 0 0;font-size:14px;}
+  .header .address{font-size:11px;color:#555;margin:2px 0;}
+  .callout{border:3px double #333;text-align:center;padding:10px;margin:10px 0;}
+  .callout .number{font-size:36px;font-weight:bold;letter-spacing:4px;margin:0;}
+  .callout .label{font-size:10px;color:#555;margin:0;}
+  .order-info{font-size:12px;margin:8px 0;}
+  table{width:100%;font-size:12px;border-collapse:collapse;}
+  td{padding:2px 0;vertical-align:top;}
+  .item-name{width:50%;}
+  .item-qty{width:15%;text-align:center;}
+  .item-price{width:35%;text-align:right;}
+  .addon-row td{font-size:11px;color:#666;padding-left:12px;}
+  .addon-row td.addon-price{text-align:right;}
+  .totals{margin-top:8px;}
+  .totals td.label{text-align:left;width:70%;}
+  .totals td.amount{text-align:right;width:30%;}
+  .total-row{font-weight:bold;font-size:15px;border-top:2px solid #333;border-bottom:2px solid #333;padding:4px 0;}
+  .footer{text-align:center;margin-top:16px;padding-top:8px;font-size:12px;color:#555;}
+  @media print{body{max-width:80mm;padding:0;}}
+</style></head>
+<body>
+<div class="header">
+  ${hasLogo ? `<img class="logo" src="${escHtml(logoSrc)}" alt="${businessName}" />` : ""}
+  <h2>${businessName}</h2>
+  <div class="address">${escHtml(addr || "")}</div>
+  ${bPhone ? `<div class="address">Tel: ${escHtml(bPhone)}</div>` : ""}
+</div>
+<div class="order-info">
+  <strong>Order:</strong> ${escHtml(order.order_number)}<br>
+  <strong>Date:</strong> ${escHtml(formatDatetime(order.inserted_at))}<br>
+  <strong>Type:</strong> ${escHtml(orderTypeText(order))}<br>
+  ${order.customer_name ? `<strong>Customer:</strong> ${escHtml(order.customer_name)}<br>` : order.user?.full_name ? `<strong>Customer:</strong> ${escHtml(order.user.full_name)}<br>` : ""}
+</div>
+<div class="callout">
+  <div class="number">${escHtml(callout)}</div>
+  <div class="label">CALL OUT NUMBER</div>
+</div>
+<table>
+  <tr style="border-bottom:1px solid #ccc;"><td class="item-name"><strong>Item</strong></td><td class="item-qty"><strong>Qty</strong></td><td class="item-price"><strong>Price</strong></td></tr>
+  ${itemRows}
+</table>
+<div class="totals">
+  <table>
+    <tr><td class="label">Subtotal</td><td class="amount">${formatMoney(order.subtotal_minor, order)}</td></tr>
+    ${order.delivery_fee_minor ? `<tr><td class="label">Delivery Fee</td><td class="amount">${formatMoney(order.delivery_fee_minor, order)}</td></tr>` : ""}
+    ${taxRowsHtml}
+    ${order.discount_minor ? `<tr><td class="label">Discount</td><td class="amount">-${formatMoney(order.discount_minor, order)}</td></tr>` : ""}
+    <tr class="total-row"><td class="label">TOTAL</td><td class="amount">${formatMoney(order.total_minor, order)}</td></tr>
+    <tr><td colspan="2" style="text-align:center;padding-top:8px;">${escHtml(paymentLineText(order))}</td></tr>
+  </table>
+</div>
+<div class="footer">
+  Thank you for your order!<br>Come back soon!
+</div>
+</body></html>`;
+}

package/dist/printer/service.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Printer service — fetch receipt from backend when online,
+ * otherwise generate locally from SellerOrder snapshot (backend-identical template).
+ * Sends ESC/POS via TcpSocketAdapter, falls back to PrintFileAdapter.
+ */
+import { generateEscpos, generateHtml } from "./receipt";
+import type { SellerOrder } from "../types/api/seller.api";
+declare function fetchReceipt(orderId: string, format?: "html" | "escpos"): Promise<string>;
+/**
+ * Generate receipt locally without network — used for offline queued DD-RRR-CCC orders.
+ */
+export declare function generateLocalReceipt(order: SellerOrder, format?: "html" | "escpos", logoDataUri?: string | null): string;
+/**
+ * Print an order — tries TCP ESC/POS if a default printer is configured, otherwise
+ * generates HTML and uses the PrintFileAdapter (expo-print / Tauri print).
+ * `order` must be a full SellerOrder snapshot; for online orders we attempt to
+ * fetch the authoritative receipt first so the business logo/address are server-rendered.
+ */
+export declare function printOrderReceipt(order: SellerOrder, opts?: {
+    logoDataUri?: string | null;
+}): Promise<void>;
+export declare function sendToTcpPrinter(ip: string, port: number, text: string): Promise<void>;
+export declare const printerService: {
+    fetchReceipt: typeof fetchReceipt;
+    generateLocalReceipt: typeof generateLocalReceipt;
+    printOrderReceipt: typeof printOrderReceipt;
+    sendToTcpPrinter: typeof sendToTcpPrinter;
+    generateEscpos: typeof generateEscpos;
+    generateHtml: typeof generateHtml;
+};
+export {};