@teincfood/core 0.7.9 → 0.8.0

package/dist/hooks/orders.hooks.js

@@ -1,340 +1,149 @@
 /**
- * Order lifecycle hooks — offline-first, device-owned outbox.
- *
- * Device owns its partition: when offline it serves the durable
- * entity_snapshots + pending overlay immediately; the SyncEngine replays
- * queued commands when back online. No hook ever blocks on a cloud timeout
- * when offline.
- *
- * Host apps just re-export from "@teincfood/core" — no app-local duplication.
+ * Order hooks — SQLite is real DB (no pending overlay, no fetchAll).
+ * Apps just import from "@teincfood/core".
  */
-import { useEffect, useMemo, useSyncExternalStore } from "react";
+import { useEffect } from "react";
 import { useInfiniteQuery, useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { getActiveBusiness, subscribeBusiness } from "../adapters/business";
+import { useSyncExternalStore } from "react";
+import { listLocalOrders, getLocalOrder } from "../domain/orders/service";
+import { getDeviceNumber, ensureLease } from "../sync/device-lease.service";
+import { assertOnlineFor } from "../sync/online-gates";
+import { SELLER_DASHBOARD_KEYS } from "../adapters/query-keys";
+import { openSyncDatabase } from "../db/connection";
+import { getReferenceData } from "../reference/operations";
+import { calculatePricing } from "../pricing/engine";
+import { generateUUID } from "../utils/uuid";
+import { subscribePendingOrders, getPendingOrdersSnapshot } from "../adapters/pending-orders";
+import { hydratePendingOrders, mergePendingIntoList } from "../sync/pending-orders.service";
 import { posRepository } from "../repositories/pos.repository";
 import { orderRepository } from "../repositories/order.repository";
-import { sellerService } from "../adapters/services";
-import { getActiveBusiness, subscribeBusiness } from "../adapters/business";
-import { getConnectivityState, subscribeConnectivity } from "../adapters/connectivity";
-import { getPendingOrdersSnapshot, subscribePendingOrders, } from "../adapters/pending-orders";
-import { orderSnapshotsService } from "../sync/order-snapshots.service";
-import { hydratePendingOrders } from "../sync/pending-orders.service";
-import { isLocalOrderNumber } from "../sync/order-number";
-import { filterOrdersOffline, paginateOffline } from "../utils/order-filter";
-// ─── Keys (host apps should import from core, not define their own) ─────
-export const POS_KEYS = {
-    all: ["pos"],
-    orders: (businessId) => ["pos", "orders", businessId],
-    preview: (businessId) => ["pos", "preview", businessId],
-};
-export const SELLER_KEYS = {
-    all: ["seller"],
-    orders: (businessId, filters) => [...SELLER_KEYS.all, "orders", businessId, filters].filter((x) => x !== undefined),
-    deliveries: (businessId, filters) => [...SELLER_KEYS.all, "deliveries", businessId, filters].filter((x) => x !== undefined),
-    order: (id, businessId) => [...SELLER_KEYS.all, "order", id, businessId],
-};
-// ─── Helpers ───────────────────────────────────────────────────────────────
+export const POS_KEYS = { all: ["pos"], orders: (bid) => ["pos", "orders", bid], preview: (bid) => ["pos", "preview", bid] };
+export const SELLER_KEYS = { all: ["seller"], orders: (bid, f) => [...SELLER_KEYS.all, "orders", bid, f].filter((x) => x !== undefined), deliveries: (bid, f) => [...SELLER_KEYS.all, "deliveries", bid, f].filter((x) => x !== undefined), order: (id, bid) => [...SELLER_KEYS.all, "order", id, bid] };
 function useBusinessId() {
     const id = useSyncExternalStore(subscribeBusiness, () => getActiveBusiness()?.id ?? null, () => null);
     return id ?? undefined;
 }
-function useConnectivity() {
-    const state = useSyncExternalStore(subscribeConnectivity, getConnectivityState, getConnectivityState);
-    return state;
-}
-function useCorePendingOrders(businessId) {
-    const snap = useSyncExternalStore(subscribePendingOrders, getPendingOrdersSnapshot, getPendingOrdersSnapshot);
-    useEffect(() => {
-        if (snap.hydrated)
-            return;
-        hydratePendingOrders().catch(() => { });
-    }, [snap.hydrated]);
-    return useMemo(() => (businessId ? snap.orders.filter((o) => o.business_id === businessId) : snap.orders), [snap.orders, businessId]);
-}
-function mergePendingOrders(pending, serverOrders) {
-    if (pending.length === 0)
-        return serverOrders ?? [];
-    const seen = new Set();
-    const merged = [];
-    for (const order of pending) {
-        seen.add(order.order_number);
-        merged.push(order);
-    }
-    for (const order of serverOrders ?? []) {
-        if (!seen.has(order.order_number))
-            merged.push(order);
-    }
-    return merged.sort((a, b) => (b.inserted_at ?? "").localeCompare(a.inserted_at ?? ""));
-}
-function isOfflineState(s) {
-    return !s.isOnline || s.isCloudReachable === "unreachable";
-}
-// ─── POS Orders Query (offline-first) ─────────────────────────────────────
 export function usePOSOrdersQuery(filters, enabled = true) {
-    const businessId = useBusinessId();
-    const pendingOrders = useCorePendingOrders(businessId);
-    const connectivity = useConnectivity();
-    const offline = isOfflineState(connectivity);
-    const query = useInfiniteQuery({
-        queryKey: [...POS_KEYS.orders(businessId), filters],
+    const bid = useBusinessId();
+    return useInfiniteQuery({
+        queryKey: [...POS_KEYS.orders(bid), filters],
         queryFn: async ({ pageParam = 1 }) => {
-            const params = { page: String(pageParam) };
-            if (filters?.status)
-                params.status = filters.status;
-            if (filters?.order_type)
-                params.order_type = filters.order_type;
-            if (filters?.is_pos)
-                params.is_pos = filters.is_pos;
-            if (filters?.date_from)
-                params.date_from = filters.date_from;
-            if (filters?.date_to)
-                params.date_to = filters.date_to;
-            if (filters?.q)
-                params.q = filters.q;
-            if (filters?.search)
-                params.search = filters.search;
-            if (offline) {
-                const offlineList = businessId ? await orderSnapshotsService.getSellerList(businessId, businessId) : null;
-                const base = offlineList ?? [];
-                const filtered = filterOrdersOffline(base, filters);
-                // date_from/to are handled inside filterSellerOrders via inserted_at; apply if present
-                const paged = paginateOffline(filtered, pageParam, 20);
-                return paged;
-            }
-            try {
-                const result = (await posRepository.fetchOrders(businessId, params));
-                if (pageParam === 1 && businessId && Array.isArray(result.data)) {
-                    orderSnapshotsService.persistSellerOrders(businessId, businessId, result.data).catch(() => { });
-                }
-                return result;
-            }
-            catch (e) {
-                const offlineList = businessId ? await orderSnapshotsService.getSellerList(businessId, businessId) : null;
-                if (offlineList) {
-                    const filtered = filterOrdersOffline(offlineList, filters);
-                    const paged = paginateOffline(filtered, pageParam, 20);
-                    return paged;
-                }
-                throw e;
-            }
+            if (!bid)
+                return { data: [], pagination: { page: 1, page_size: 20, total_pages: 1, total_entries: 0 } };
+            const { data, total } = await listLocalOrders(bid, filters, pageParam, 20);
+            // Offline overlay: pending creations + queued statuses (page 1). Refetch
+            // is driven by the pending-orders invalidator on every apply path.
+            const merged = await mergePendingIntoList(data, bid, pageParam);
+            const totalPages = Math.max(1, Math.ceil(total / 20));
+            return { data: merged, pagination: { page: pageParam, page_size: 20, total_pages: totalPages, total_entries: total + (merged.length - data.length) } };
         },
         initialPageParam: 1,
         getNextPageParam: (lastPage) => {
             const p = lastPage.pagination;
-            return p && p.page < p.total_pages ? p.page + 1 : undefined;
+            return p.page < p.total_pages ? p.page + 1 : undefined;
         },
-        enabled: enabled && !!businessId,
-        staleTime: 30 * 1000,
-        retry: false,
+        enabled: enabled && !!bid,
+        staleTime: 5 * 1000,
         networkMode: "offlineFirst",
         select: (data) => data.pages.flatMap((p) => p.data),
     });
-    const data = useMemo(() => mergePendingOrders(pendingOrders, query.data), [pendingOrders, query.data]);
-    return { ...query, data };
 }
-// ─── Seller Orders Query (offline-first, shares same snapshot) ────────────
 export function useSellerOrdersQuery(enabled = true, filters) {
-    const businessId = useBusinessId();
-    const pendingOrders = useCorePendingOrders(businessId);
-    const connectivity = useConnectivity();
-    const offline = isOfflineState(connectivity);
-    const query = useInfiniteQuery({
-        queryKey: SELLER_KEYS.orders(businessId, filters),
+    const bid = useBusinessId();
+    return useInfiniteQuery({
+        queryKey: SELLER_KEYS.orders(bid, filters),
         queryFn: async ({ pageParam = 1 }) => {
-            const params = { page: pageParam, page_size: 20 };
-            if (filters?.status)
-                params.status = filters.status;
-            if (filters?.q)
-                params.q = filters.q;
-            if (filters?.search)
-                params.search = filters.search;
-            if (filters?.date_from)
-                params.date_from = filters.date_from;
-            if (filters?.date_to)
-                params.date_to = filters.date_to;
-            if (offline) {
-                const offlineList = businessId ? await orderSnapshotsService.getSellerList(businessId, businessId) : null;
-                const base = offlineList ?? [];
-                const filtered = filterOrdersOffline(base, filters);
-                const paged = paginateOffline(filtered, pageParam, 20);
-                return paged;
-            }
-            try {
-                const result = (await sellerService.fetchBusinessOrders(businessId, params));
-                if (pageParam === 1 && businessId && Array.isArray(result.data)) {
-                    orderSnapshotsService.persistSellerOrders(businessId, businessId, result.data).catch(() => { });
-                }
-                return result;
-            }
-            catch (e) {
-                const offlineList = businessId ? await orderSnapshotsService.getSellerList(businessId, businessId) : null;
-                if (offlineList) {
-                    const filtered = filterOrdersOffline(offlineList, filters);
-                    const paged = paginateOffline(filtered, pageParam, 20);
-                    return paged;
-                }
-                throw e;
-            }
+            if (!bid)
+                return { data: [], pagination: { page: 1, page_size: 20, total_pages: 1, total_entries: 0 } };
+            const q = filters?.q ?? filters?.search;
+            const { data, total } = await listLocalOrders(bid, { status: filters?.status, q }, pageParam, 20);
+            const merged = await mergePendingIntoList(data, bid, pageParam);
+            const totalPages = Math.max(1, Math.ceil(total / 20));
+            return { data: merged, pagination: { page: pageParam, page_size: 20, total_pages: totalPages, total_entries: total + (merged.length - data.length) } };
         },
         initialPageParam: 1,
         getNextPageParam: (lastPage) => {
             const p = lastPage.pagination;
-            return p && p.page < p.total_pages ? p.page + 1 : undefined;
+            return p.page < p.total_pages ? p.page + 1 : undefined;
         },
-        enabled: enabled && !!businessId,
-        staleTime: 30 * 1000,
-        retry: false,
+        enabled: enabled && !!bid,
+        staleTime: 5 * 1000,
         networkMode: "offlineFirst",
         select: (data) => data.pages.flatMap((p) => p.data),
     });
-    const data = useMemo(() => mergePendingOrders(pendingOrders, query.data), [pendingOrders, query.data]);
-    return { ...query, data };
 }
-// ─── Pending orders hook (for screens that just need the overlay) ─────────
-export function usePendingOrders(businessId) {
-    return useCorePendingOrders(businessId);
+export function useSellerOrderQuery(orderId, enabled = true) {
+    const bid = useBusinessId();
+    return useQuery({
+        queryKey: SELLER_KEYS.order(orderId, bid),
+        queryFn: async () => {
+            if (!bid)
+                throw new Error("No business");
+            const order = await getLocalOrder(bid, orderId);
+            if (!order)
+                throw new Error("Order not found");
+            return { data: order };
+        },
+        enabled: enabled && !!orderId && !!bid,
+        staleTime: 5 * 1000,
+    });
 }
-// ─── Create POS Order (device-lease aware, via SyncEngine) ────────────────
 export function useCreatePOSOrderMutation() {
-    const businessId = useBusinessId();
-    const queryClient = useQueryClient();
+    const bid = useBusinessId();
+    const qc = useQueryClient();
     return useMutation({
         mutationFn: async (data) => {
-            const { isOnline, isCloudReachable } = getConnectivityState();
-            if (!businessId)
-                throw new Error("Missing business — select a business before creating orders");
-            try {
-                const m = await import("../sync/device-lease.service");
-                const dn = m.getDeviceNumber?.(businessId) ?? null;
-                if (!dn) {
-                    const leased = await m.ensureDeviceLease?.(businessId);
-                    if (!leased && (!isOnline || isCloudReachable === "unreachable")) {
-                        throw new Error("No device number leased (99 devices max) — cannot create offline orders");
-                    }
-                }
+            if (!bid)
+                throw new Error("No business");
+            const dn = getDeviceNumber(bid);
+            if (!dn) {
+                const leased = await ensureLease(bid);
+                if (!leased)
+                    throw new Error("No device number leased — connect online once");
             }
-            catch (e) {
-                if (e?.message?.includes("device number") || e?.message?.includes("No device lease"))
-                    throw e;
-            }
-            return posRepository.createOrder(businessId, data);
-        },
-        onSuccess: (result) => {
-            const r = result;
-            const orderNumber = r?.order_number ?? "";
-            const queued = orderNumber ? isLocalOrderNumber(orderNumber) && r?.status === "pending" : false;
-            queryClient.invalidateQueries({ queryKey: POS_KEYS.orders(businessId) });
-            queryClient.invalidateQueries({ queryKey: SELLER_KEYS.orders(businessId) });
-            queryClient.invalidateQueries({ queryKey: SELLER_KEYS.all });
-            // Toast is host concern — core just invalidates; host can show queued vs created.
-            void queued;
+            // Engine route: cloud → LAN node → queue. Never createLocalOrder
+            // directly — it bypasses sync and peers never see the order.
+            return orderRepository.createOrder({ businessId: bid, data, entityId: generateUUID() });
         },
+        onSuccess: () => { qc.invalidateQueries({ queryKey: POS_KEYS.orders(bid) }); qc.invalidateQueries({ queryKey: SELLER_KEYS.all }); qc.invalidateQueries({ queryKey: SELLER_DASHBOARD_KEYS.all }); },
     });
 }
-// ─── Preview (offline via tax-rules reference) ────────────────────────────
-function cartHash(items) {
-    if (items.length === 0)
-        return "";
-    return items
-        .map((i) => `${i.menu_item.id}:${i.quantity}:${i.selected_variant?.id || ""}:${(i.selected_addons || []).map((a) => a.addon_id).sort().join(",")}`)
-        .join("|");
-}
+function cartHash(items) { return items.map((i) => `${i.menu_item.id}:${i.quantity}:${i.selected_variant?.id || ""}:${(i.selected_addons || []).map((a) => a.addon_id).sort().join(",")}`).join("|"); }
 export function usePOSOrderPreviewQuery(items, orderType, customerName) {
-    const businessId = useBusinessId();
-    const hash = useMemo(() => cartHash(items), [items]);
+    const bid = useBusinessId();
+    const hash = cartHash(items);
     return useQuery({
-        queryKey: [...POS_KEYS.preview(businessId), hash, orderType, customerName],
+        queryKey: [...POS_KEYS.preview(bid), hash, orderType, customerName],
         queryFn: async () => {
-            const orderItems = items.map((i) => ({
-                menu_item_id: i.menu_item.id,
-                quantity: i.quantity,
-                variant_id: i.selected_variant?.id,
-                addon_ids: i.selected_addons.length > 0 ? i.selected_addons.map((a) => a.addon_id) : undefined,
-            }));
+            const orderItems = items.map((i) => ({ menu_item_id: i.menu_item.id, quantity: i.quantity, variant_id: i.selected_variant?.id, addon_ids: i.selected_addons.length > 0 ? i.selected_addons.map((a) => a.addon_id) : undefined }));
             try {
-                return await posRepository.fetchPreview({ businessId: businessId, items: orderItems, orderType, customerName: customerName || undefined });
+                return await posRepository.fetchPreview({ businessId: bid, items: orderItems, orderType, customerName: customerName || undefined });
             }
-            catch (e) {
-                const s = getConnectivityState();
-                const isOffline = !s.isOnline || s.isCloudReachable === "unreachable";
-                if (!isOffline)
-                    throw e;
-                const { openSyncDatabase } = await import("../db/connection");
-                const { getReferenceData } = await import("../reference/operations");
-                const { calculatePricing } = await import("../pricing/engine");
+            catch {
                 const db = await openSyncDatabase();
-                const taxRec = await getReferenceData(db, businessId, "tax-rules");
+                const taxRec = await getReferenceData(db, bid, "tax-rules");
                 const taxRules = taxRec?.payload?.data ?? [];
                 const pricing = calculatePricing({ items: items, taxRules: taxRules });
                 return { data: { subtotal_minor: pricing.subtotal_minor, discount_minor: pricing.discount_minor, delivery_fee_minor: pricing.delivery_fee_minor, tax_minor: pricing.tax_minor, tip_minor: pricing.tip_minor, total_minor: pricing.total_minor, tax_lines: pricing.tax_lines, currency: pricing.currency_code } };
             }
         },
-        enabled: !!businessId && items.length > 0,
+        enabled: !!bid && items.length > 0,
         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);
-    const pendingOrders = useCorePendingOrders(businessId);
-    return useQuery({
-        queryKey: SELLER_KEYS.order(orderId, businessId),
-        queryFn: async () => {
-            const pendingHit = pendingOrders.find((o) => o.id === orderId || o.order_number === orderId);
-            if (pendingHit)
-                return { data: pendingHit };
-            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 };
-                const pendingAgain = getPendingOrdersSnapshot().orders.find((o) => o.id === orderId || o.order_number === orderId);
-                if (pendingAgain)
-                    return { data: pendingAgain };
-                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() {
-        const businessId = useBusinessId();
-        const queryClient = useQueryClient();
+        const bid = useBusinessId();
+        const qc = useQueryClient();
         return useMutation({
             mutationFn: (orderId) => {
-                if (!businessId)
+                if (!bid)
                     throw new Error("No active business");
-                return build({ orderId, businessId });
-            },
-            onSettled: (_d, _e, orderId) => {
-                queryClient.invalidateQueries({ queryKey: SELLER_KEYS.orders() });
-                queryClient.invalidateQueries({ queryKey: POS_KEYS.orders(businessId) });
-                if (orderId)
-                    queryClient.invalidateQueries({ queryKey: SELLER_KEYS.order(orderId) });
+                return build({ orderId, businessId: bid });
             },
+            onSuccess: (_d, _e, orderId) => { qc.invalidateQueries({ queryKey: SELLER_KEYS.all }); qc.invalidateQueries({ queryKey: POS_KEYS.all }); qc.invalidateQueries({ queryKey: SELLER_DASHBOARD_KEYS.all }); if (orderId)
+                qc.invalidateQueries({ queryKey: SELLER_KEYS.order(orderId) }); },
         });
     };
 }
@@ -345,73 +154,45 @@ export const useMarkOrderReadyMutation = makeOrderActionMutation(({ orderId, bus
 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) });
-        },
-    });
+    const bid = useBusinessId();
+    const qc = useQueryClient();
+    return useMutation({ mutationFn: (deliveryId) => { if (!bid)
+            throw new Error("No business"); assertOnlineFor("order:confirm_handover"); return orderRepository.confirmHandover({ deliveryId, businessId: bid }); }, onSuccess: () => { qc.invalidateQueries({ queryKey: SELLER_KEYS.all }); qc.invalidateQueries({ queryKey: POS_KEYS.all }); qc.invalidateQueries({ queryKey: SELLER_DASHBOARD_KEYS.all }); } });
 }
 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 });
-        },
-    });
+    const bid = useBusinessId();
+    const qc = useQueryClient();
+    return useMutation({ mutationFn: ({ orderId, riderId }) => { if (!bid)
+            throw new Error("No business"); assertOnlineFor("order:assign_rider"); return orderRepository.assignRider({ orderId, riderId, businessId: bid }); }, onSuccess: () => { qc.invalidateQueries({ queryKey: SELLER_KEYS.all }); qc.invalidateQueries({ queryKey: SELLER_DASHBOARD_KEYS.all }); } });
 }
 export function useConfirmCashPaymentMutation() {
-    const businessId = useBusinessId();
-    const queryClient = useQueryClient();
-    return useMutation({
-        mutationFn: (orderId) => {
-            if (!businessId)
-                throw new Error("No active business");
-            return orderRepository.confirmCashPayment({ orderId, businessId });
-        },
-        onSettled: (_d, _e, orderId) => {
-            queryClient.invalidateQueries({ queryKey: SELLER_KEYS.all });
-            queryClient.invalidateQueries({ queryKey: POS_KEYS.all });
-            if (orderId)
-                queryClient.invalidateQueries({ queryKey: SELLER_KEYS.order(orderId) });
-        },
-    });
-}
-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,
-    };
+    const bid = useBusinessId();
+    const qc = useQueryClient();
+    return useMutation({ mutationFn: (orderId) => { if (!bid)
+            throw new Error("No business"); return orderRepository.confirmCashPayment({ orderId, businessId: bid }); }, onSuccess: (_d, _e, orderId) => { qc.invalidateQueries({ queryKey: SELLER_KEYS.all }); qc.invalidateQueries({ queryKey: POS_KEYS.all }); qc.invalidateQueries({ queryKey: SELLER_DASHBOARD_KEYS.all }); if (orderId)
+            qc.invalidateQueries({ queryKey: SELLER_KEYS.order(orderId) }); } });
+}
+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) => { const s = String(status); if (!["accepted", "preparing", "ready", "delivered", "cancelled", "rejected"].includes(s))
+        throw new Error(`Unknown status ${s}`); switch (s) {
+        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 ${s}`);
+    } }, isPending: accept.isPending || reject.isPending || preparing.isPending || ready.isPending || complete.isPending || cancel.isPending, }; }
+export function isQueuedTransition(result) { const r = result; return !!r && r.status === "pending" && !!r.command_id && !r.id; }
+/**
+ * Reactive view of locally queued (unconfirmed) order creations.
+ * Hydrates persisted optimistic events once (survives restart offline).
+ */
+export function usePendingOrders() {
+    const snap = useSyncExternalStore(subscribePendingOrders, () => getPendingOrdersSnapshot().orders, () => []);
+    useEffect(() => {
+        if (!getPendingOrdersSnapshot().hydrated) {
+            hydratePendingOrders().catch(() => undefined);
+        }
+    }, []);
+    return snap;
 }

package/dist/hooks/places.hooks.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Places search hooks — single source for both apps (previously verbatim
+ * copies). Pure React + injected placesService; storage-backed caching lives
+ * in the host service implementations.
+ */
+import type { PlaceSuggestion, PlaceDetails } from "../types/places";
+export declare function usePlacesSearch(debounceMs?: number): {
+    query: string;
+    setQuery: import("react").Dispatch<import("react").SetStateAction<string>>;
+    suggestions: PlaceSuggestion[];
+    isLoading: boolean;
+    clearSearch: () => void;
+    clearAll: () => void;
+};
+export declare function usePlaceDetails(placeId: string | null): {
+    details: PlaceDetails | null;
+    isLoading: boolean;
+};
+export declare function clearPlacesCache(): void;
+/** Generic debounced-value hook for search/filter inputs. */
+export declare function useDebouncedValue<T>(value: T, delayMs?: number): T;