@teincfood/core 0.7.6 → 0.7.8

package/dist/hooks/orders.hooks.js

@@ -272,6 +272,45 @@ export function usePOSOrderPreviewQuery(items, orderType, customerName) {
         staleTime: 30 * 1000,
     });
 }
+// ─── Seller order detail (offline via snapshot fallback) ───────────────────
+export function useSellerOrderQuery(orderId, enabled = true) {
+    const businessId = useBusinessId();
+    const connectivity = useConnectivity();
+    const offline = isOfflineState(connectivity);
+    return useQuery({
+        queryKey: SELLER_KEYS.order(orderId, businessId),
+        queryFn: async () => {
+            if (offline) {
+                const list = businessId ? await orderSnapshotsService.getSellerList(businessId, businessId) : null;
+                const found = list?.find((o) => o.id === orderId || o.order_number === orderId);
+                if (found)
+                    return { data: found };
+            }
+            try {
+                const res = await sellerService.fetchSellerOrder(orderId);
+                return res;
+            }
+            catch (e) {
+                const list = businessId ? await orderSnapshotsService.getSellerList(businessId, businessId) : null;
+                const found = list?.find((o) => o.id === orderId || o.order_number === orderId);
+                if (found)
+                    return { data: found };
+                throw e;
+            }
+        },
+        enabled: enabled && !!orderId && !!businessId,
+        staleTime: 30 * 1000,
+        retry: false,
+        networkMode: "offlineFirst",
+    });
+}
+// ─── Helpers for queued UI ───────────────────────────────────────────────
+export function isQueuedTransition(result) {
+    const r = result;
+    if (!r)
+        return false;
+    return r.status === "pending" && !!r.command_id && !r.id;
+}
 // ─── Order status mutations via SyncEngine (all go through outbox) ────────
 function makeOrderActionMutation(build) {
     return function useOrderActionMutation() {
@@ -298,3 +337,57 @@ export const useStartPreparingOrderMutation = makeOrderActionMutation(({ orderId
 export const useMarkOrderReadyMutation = makeOrderActionMutation(({ orderId, businessId }) => orderRepository.markOrderReady({ orderId, businessId }));
 export const useCompletePickupMutation = makeOrderActionMutation(({ orderId, businessId }) => orderRepository.completePickup({ orderId, businessId }));
 export const useCancelOrderMutation = makeOrderActionMutation(({ orderId, businessId }) => orderRepository.cancelOrder({ orderId, businessId }));
+export function useConfirmHandoverMutation() {
+    const businessId = useBusinessId();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (deliveryId) => {
+            if (!businessId)
+                throw new Error("No active business");
+            return orderRepository.confirmHandover({ deliveryId, businessId });
+        },
+        onSettled: (_d, _e, deliveryId) => {
+            queryClient.invalidateQueries({ queryKey: SELLER_KEYS.all });
+            queryClient.invalidateQueries({ queryKey: POS_KEYS.all });
+            if (deliveryId)
+                queryClient.invalidateQueries({ queryKey: SELLER_KEYS.order(deliveryId) });
+        },
+    });
+}
+export function useAssignRiderMutation() {
+    const businessId = useBusinessId();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: ({ orderId, riderId }) => {
+            if (!businessId)
+                throw new Error("No active business");
+            return orderRepository.assignRider({ orderId, riderId, businessId });
+        },
+        onSettled: () => {
+            queryClient.invalidateQueries({ queryKey: SELLER_KEYS.all });
+            queryClient.invalidateQueries({ queryKey: POS_KEYS.all });
+        },
+    });
+}
+export function useUpdateOrderStatusMutation() {
+    const accept = useAcceptOrderMutation();
+    const reject = useRejectOrderMutation();
+    const preparing = useStartPreparingOrderMutation();
+    const ready = useMarkOrderReadyMutation();
+    const complete = useCompletePickupMutation();
+    const cancel = useCancelOrderMutation();
+    return {
+        mutate: (orderId, status) => {
+            switch (status) {
+                case "accepted": return accept.mutateAsync(orderId);
+                case "preparing": return preparing.mutateAsync(orderId);
+                case "ready": return ready.mutateAsync(orderId);
+                case "delivered": return complete.mutateAsync(orderId);
+                case "cancelled": return cancel.mutateAsync(orderId);
+                case "rejected": return reject.mutateAsync(orderId);
+                default: throw new Error(`Unknown status ${status}`);
+            }
+        },
+        isPending: accept.isPending || reject.isPending || preparing.isPending || ready.isPending || complete.isPending || cancel.isPending,
+    };
+}

package/dist/image-cache/service.d.ts

@@ -0,0 +1,29 @@
+/**
+ * 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.
+ */
+export interface ImageCacheEntry {
+    remoteUrl: string;
+    localUri: string | null;
+    etag: string | null;
+    lastModified: string | null;
+    cachedAt: string | null;
+}
+export declare function stableCacheUrl(url: string): string;
+export declare function getCachedImagePath(url: string): string;
+export declare function ensureImageCacheDir(): Promise<string>;
+export declare function getCachedImageInfo(url: string): Promise<ImageCacheEntry>;
+export declare function cacheRemoteImage(url: string | null | undefined, opts?: {
+    skipIfCached?: boolean;
+    removeOnFailure?: boolean;
+}): Promise<ImageCacheEntry | null>;
+export declare function cacheImageBatch(urls: (string | null | undefined)[], opts?: {
+    skipIfCached?: boolean;
+    removeOnFailure?: boolean;
+}): Promise<ImageCacheEntry[]>;
+export declare function clearImageCache(): Promise<void>;
+export declare function pruneImageCache(knownUrls: Iterable<string | null | undefined>, maxAgeDays?: number): Promise<number>;
+export declare function resolveImageSource(url: string | null | undefined): Promise<{
+    uri: string;
+} | null>;

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;