@teincfood/core 0.7.8 → 0.8.0

package/dist/types/api/seller.api.d.ts

@@ -108,6 +108,7 @@ export interface SellerOrder {
     user: OrderUser | null;
     items: OrderItem[];
     inserted_at: string;
+    updated_at?: string;
     rider?: {
         id: string;
         name: string | null;
@@ -170,3 +171,22 @@ export interface BusinessDelivery {
     rider: DeliveryRider | null;
 }
 export type BusinessDeliveriesResponse = PaginatedResponse<BusinessDelivery>;
+export interface SellerDashboardMetrics {
+    today_orders: number;
+    today_revenue_minor: number;
+    pending_orders: number;
+    average_rating: number;
+    active_orders: number;
+}
+export interface SellerDashboardResponse {
+    data: {
+        metrics: SellerDashboardMetrics;
+        recent_orders: Array<{
+            id: string;
+            order_number: string;
+            status: string;
+            total_minor: number;
+            item_count: number;
+        }>;
+    };
+}

package/dist/types/places.d.ts

@@ -0,0 +1,19 @@
+/** Place autocomplete/detail types — backend places payloads. */
+export interface PlaceSuggestion {
+    placeId: string;
+    description: string;
+    mainText: string;
+    secondaryText: string;
+}
+export interface PlaceDetails {
+    placeId: string;
+    formattedAddress: string;
+    street: string;
+    city: string;
+    region: string;
+    postalCode: string;
+    country: string;
+    countryCode?: string;
+    latitude: number;
+    longitude: number;
+}

package/dist/types/places.js

@@ -0,0 +1,2 @@
+/** Place autocomplete/detail types — backend places payloads. */
+export {};

package/dist/types/rider.d.ts

@@ -0,0 +1,67 @@
+export interface RiderMetrics {
+    today_earnings_minor: number;
+    today_deliveries: number;
+    available_deliveries: number;
+    total_deliveries: number;
+    status: string;
+}
+export interface RiderActiveDelivery {
+    id: string;
+    orderId: string;
+    pickup: string;
+    dropoff: string;
+    status: 'assigned' | 'picked_up' | 'delivering' | 'delivered';
+    estimatedTime: string;
+}
+export interface RiderEarnings {
+    today: number;
+    thisWeek: number;
+    thisMonth: number;
+    total: number;
+    pendingPayout: number;
+    currency: string;
+}
+export interface EarningsBreakdown {
+    baseDeliveryFees: number;
+    tipsReceived: number;
+    bonuses: number;
+    totalThisWeek: number;
+    currency: string;
+}
+export interface RiderTransaction {
+    id: string;
+    orderId: string;
+    amount: number;
+    date: string;
+    type: 'delivery' | 'bonus' | 'tip';
+    currency: string;
+}
+export interface RiderStatistics {
+    totalDeliveries: number;
+    acceptanceRate: number;
+    averageRating: number;
+    totalEarnings: number;
+    currency: string;
+}
+export interface DeliveryZone {
+    id: string;
+    name: string;
+    enabled: boolean;
+    radius: string;
+    deliveries: number;
+    latitude: number;
+    longitude: number;
+}
+export interface NavigationSettings {
+    selectedApp: 'google_maps' | 'apple_maps' | 'waze';
+    autoStart: boolean;
+    avoidTolls: boolean;
+    avoidHighways: boolean;
+}
+export interface NavigationApp {
+    id: string;
+    name: string;
+    description: string;
+    icon: string;
+    installed: boolean;
+}

package/dist/types/rider.js

@@ -0,0 +1,2 @@
+// Rider-related models
+export {};

package/dist/utils/attempt-stats.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Attempt counters — monitor-first instrumentation for overload diagnosis.
+ *
+ * Every retry/poll/reconnect path records one counter tick with its caller
+ * tag. Diagnostics screens render per-subsystem totals + per-minute rates so
+ * a hot loop (e.g. discovery sweep, WS reconnect, drain storm) is visible
+ * without guessing. Pure in-memory; no timers, no network, no behavior.
+ */
+export type AttemptSubsystem = "ws_connect" | "ws_reconnect" | "ws_heartbeat" | "lan_discover" | "lan_dial" | "sweep_tick" | "ttl_reap" | "sync_drain" | "rest_attempt" | "probe" | "refetch";
+export interface SubsystemStat {
+    subsystem: AttemptSubsystem;
+    total: number;
+    /** Attempts in the trailing 60s window. */
+    perMin: number;
+    lastAt: string | null;
+    lastDetail: string | null;
+}
+/** Record one attempt. Detail is a short caller/param tag, e.g. "delay=4000" or "GET /orders". */
+export declare function recordAttempt(subsystem: AttemptSubsystem, detail?: string): void;
+/** Snapshot for Diagnostics screens. Never throws. */
+export declare function getAttemptStats(): SubsystemStat[];
+/** Test-only reset. */
+export declare function resetAttemptStats(): void;

package/dist/utils/attempt-stats.js

@@ -0,0 +1,61 @@
+/**
+ * Attempt counters — monitor-first instrumentation for overload diagnosis.
+ *
+ * Every retry/poll/reconnect path records one counter tick with its caller
+ * tag. Diagnostics screens render per-subsystem totals + per-minute rates so
+ * a hot loop (e.g. discovery sweep, WS reconnect, drain storm) is visible
+ * without guessing. Pure in-memory; no timers, no network, no behavior.
+ */
+const WINDOW_MS = 60000;
+const counters = new Map();
+function counterFor(s) {
+    let c = counters.get(s);
+    if (!c) {
+        c = { total: 0, stamps: [], lastAt: null, lastDetail: null };
+        counters.set(s, c);
+    }
+    return c;
+}
+/** Record one attempt. Detail is a short caller/param tag, e.g. "delay=4000" or "GET /orders". */
+export function recordAttempt(subsystem, detail) {
+    try {
+        const c = counterFor(subsystem);
+        const now = Date.now();
+        c.total += 1;
+        c.stamps.push(now);
+        // Prune outside the trailing window (amortized — stamps only grow via ticks).
+        while (c.stamps.length > 0 && now - c.stamps[0] > WINDOW_MS)
+            c.stamps.shift();
+        c.lastAt = new Date(now).toISOString();
+        if (detail !== undefined)
+            c.lastDetail = detail;
+    }
+    catch { }
+}
+/** Snapshot for Diagnostics screens. Never throws. */
+export function getAttemptStats() {
+    try {
+        const now = Date.now();
+        const out = [];
+        counters.forEach((c, subsystem) => {
+            while (c.stamps.length > 0 && now - c.stamps[0] > WINDOW_MS)
+                c.stamps.shift();
+            out.push({
+                subsystem,
+                total: c.total,
+                perMin: c.stamps.length,
+                lastAt: c.lastAt,
+                lastDetail: c.lastDetail,
+            });
+        });
+        out.sort((a, b) => b.perMin - a.perMin || b.total - a.total);
+        return out;
+    }
+    catch {
+        return [];
+    }
+}
+/** Test-only reset. */
+export function resetAttemptStats() {
+    counters.clear();
+}

package/dist/utils/business-hours.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Business open/closed evaluation — single source for the lib.
+ *
+ * Mirrors backend `TeincFoodBackend.Businesses.is_open?/1` exactly:
+ *   - `manually_closed` → closed
+ *   - else UTC clock: day = Elixir `Date.day_of_week - 1` (Monday=0 … Sunday=6),
+ *     a row matches when `day_of_week` equals today, `is_closed` is false and
+ *     `open_time <= now < close_time` (open inclusive, close exclusive).
+ *   - no matching row → closed.
+ *
+ * Reads from SQLite `reference_data` (`operating-hours` + `business:profile`),
+ * so it works fully offline. Known parity limitation (copied from backend, not
+ * fixed here): overnight ranges (close <= open) never match.
+ */
+export type BusinessClosedReason = "manually_closed" | "outside_hours" | "no_hours_configured";
+export interface BusinessOpenState {
+    open: boolean;
+    reason?: BusinessClosedReason;
+    /** 0=Monday … 6=Sunday (backend day_of_week convention) */
+    dayOfWeek: number;
+    /** HH:MM:SS UTC used for the evaluation */
+    timeUtc: string;
+    evaluatedAt: string;
+}
+export declare class BusinessHoursError extends Error {
+    code: "BUSINESS_CLOSED" | "HOURS_NOT_SYNCED";
+    reason?: BusinessClosedReason;
+    constructor(code: "BUSINESS_CLOSED" | "HOURS_NOT_SYNCED", message: string, reason?: BusinessClosedReason);
+}
+export declare function isBusinessOpenNow(businessId: string, now?: Date): Promise<BusinessOpenState>;
+/**
+ * Guard for order creation — fail-closed. Throws `BusinessHoursError` with
+ * code `HOURS_NOT_SYNCED` when no hours are cached (configure in Settings,
+ * works offline) or `BUSINESS_CLOSED` when the business is closed.
+ * Backend remains the final gate for clock-skew edge cases.
+ */
+export declare function assertBusinessOpenForCreate(businessId: string, now?: Date): Promise<BusinessOpenState>;

package/dist/utils/business-hours.js

@@ -0,0 +1,96 @@
+/**
+ * Business open/closed evaluation — single source for the lib.
+ *
+ * Mirrors backend `TeincFoodBackend.Businesses.is_open?/1` exactly:
+ *   - `manually_closed` → closed
+ *   - else UTC clock: day = Elixir `Date.day_of_week - 1` (Monday=0 … Sunday=6),
+ *     a row matches when `day_of_week` equals today, `is_closed` is false and
+ *     `open_time <= now < close_time` (open inclusive, close exclusive).
+ *   - no matching row → closed.
+ *
+ * Reads from SQLite `reference_data` (`operating-hours` + `business:profile`),
+ * so it works fully offline. Known parity limitation (copied from backend, not
+ * fixed here): overnight ranges (close <= open) never match.
+ */
+import { openSyncDatabase } from "../db/connection";
+import { getReferenceData } from "../reference/operations";
+export class BusinessHoursError extends Error {
+    constructor(code, message, reason) {
+        super(message);
+        this.name = "BusinessHoursError";
+        this.code = code;
+        this.reason = reason;
+    }
+}
+function pad2(n) {
+    return n < 10 ? `0${n}` : String(n);
+}
+function toTimeString(v) {
+    if (!v || typeof v !== "string")
+        return null;
+    // Backend Time serializes "HH:MM:SS"; settings screen writes "HH:MM:00".
+    return v.slice(0, 8);
+}
+function normalizeEntries(payload) {
+    if (!payload)
+        return [];
+    if (Array.isArray(payload))
+        return payload;
+    const data = payload.data;
+    if (Array.isArray(data))
+        return data;
+    return [];
+}
+export async function isBusinessOpenNow(businessId, now = new Date()) {
+    const evaluatedAt = new Date().toISOString();
+    // Backend: Date.day_of_week (Mon=1..Sun=7) minus 1 → Mon=0..Sun=6 (UTC).
+    const dayOfWeek = (now.getUTCDay() + 6) % 7;
+    const timeUtc = `${pad2(now.getUTCHours())}:${pad2(now.getUTCMinutes())}:${pad2(now.getUTCSeconds())}`;
+    const db = await openSyncDatabase();
+    const [hoursRec, profileRec] = await Promise.all([
+        getReferenceData(db, businessId, "operating-hours"),
+        getReferenceData(db, businessId, "business:profile"),
+    ]);
+    const profile = (profileRec?.payload ??
+        null);
+    const profileData = profile && typeof profile === "object" && "data" in profile && profile.data !== undefined
+        ? profile.data
+        : (profile ?? {});
+    if (profileData.manually_closed === true) {
+        return { open: false, reason: "manually_closed", dayOfWeek, timeUtc, evaluatedAt };
+    }
+    const entries = normalizeEntries(hoursRec?.payload);
+    if (entries.length === 0) {
+        return { open: false, reason: "no_hours_configured", dayOfWeek, timeUtc, evaluatedAt };
+    }
+    const match = entries.some((e) => {
+        if (e.day_of_week !== dayOfWeek || e.is_closed)
+            return false;
+        const open = toTimeString(e.open_time);
+        const close = toTimeString(e.close_time);
+        if (!open || !close)
+            return false;
+        return open <= timeUtc && timeUtc < close;
+    });
+    return match
+        ? { open: true, dayOfWeek, timeUtc, evaluatedAt }
+        : { open: false, reason: "outside_hours", dayOfWeek, timeUtc, evaluatedAt };
+}
+/**
+ * Guard for order creation — fail-closed. Throws `BusinessHoursError` with
+ * code `HOURS_NOT_SYNCED` when no hours are cached (configure in Settings,
+ * works offline) or `BUSINESS_CLOSED` when the business is closed.
+ * Backend remains the final gate for clock-skew edge cases.
+ */
+export async function assertBusinessOpenForCreate(businessId, now = new Date()) {
+    const state = await isBusinessOpenNow(businessId, now);
+    if (state.reason === "no_hours_configured") {
+        throw new BusinessHoursError("HOURS_NOT_SYNCED", "Operating hours are not available offline — configure them in Settings (works offline) or sync once before taking orders", state.reason);
+    }
+    if (!state.open) {
+        throw new BusinessHoursError("BUSINESS_CLOSED", state.reason === "manually_closed"
+            ? "Business is manually closed — order creation is blocked"
+            : "Business is currently closed — order creation is blocked", state.reason);
+    }
+    return state;
+}

package/dist/utils/debug-log.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Shared debug-log ring buffer — single implementation for Business (Expo)
+ * and Desktop (Tauri), replacing the per-app copies.
+ *
+ * Captures (a) console.* output and (b) core syncLogger output into one
+ * observable store that Diagnostics screens render with level tabs, search,
+ * copy/share and clear. Install once at app bootstrap via
+ * initDebugLogCapture(); safe to call repeatedly.
+ */
+export type LogLevel = "debug" | "info" | "warn" | "error" | "log";
+export interface LogEntry {
+    id: number;
+    ts: string;
+    level: LogLevel;
+    args: unknown[];
+    text: string;
+}
+/** Newest-first snapshot for list rendering. */
+export declare function getDebugLogs(): LogEntry[];
+export declare function clearDebugLogs(): void;
+export declare function subscribeDebugLogs(fn: () => void): () => void;
+export declare function pushDebugLog(level: LogLevel, text: string, data?: unknown): void;
+export declare function initDebugLogCapture(): void;

package/dist/utils/debug-log.js

@@ -0,0 +1,153 @@
+/**
+ * Shared debug-log ring buffer — single implementation for Business (Expo)
+ * and Desktop (Tauri), replacing the per-app copies.
+ *
+ * Captures (a) console.* output and (b) core syncLogger output into one
+ * observable store that Diagnostics screens render with level tabs, search,
+ * copy/share and clear. Install once at app bootstrap via
+ * initDebugLogCapture(); safe to call repeatedly.
+ */
+import { syncLogger } from "./sync-logger";
+const MAX_ENTRIES = 600;
+let entries = [];
+let seq = 0;
+const listeners = new Set();
+let installed = false;
+function fmt(args) {
+    return args
+        .map((a) => {
+        if (typeof a === "string")
+            return a;
+        try {
+            return JSON.stringify(a, null, 2);
+        }
+        catch {
+            return String(a);
+        }
+    })
+        .join(" ");
+}
+let notifyQueued = false;
+function notifyListeners() {
+    // Deferred: console.* fires inside render bodies too (and React forbids
+    // sync setState of another component mid-render). Microtask fan-out keeps
+    // log screens live without ever triggering setState-in-render.
+    if (notifyQueued)
+        return;
+    notifyQueued = true;
+    queueMicrotask(() => {
+        notifyQueued = false;
+        listeners.forEach((fn) => {
+            try {
+                fn();
+            }
+            catch { }
+        });
+    });
+}
+function push(level, args) {
+    const e = { id: ++seq, ts: new Date().toISOString(), level, args, text: fmt(args) };
+    entries.push(e);
+    if (entries.length > MAX_ENTRIES)
+        entries = entries.slice(-MAX_ENTRIES);
+    notifyListeners();
+}
+/** Newest-first snapshot for list rendering. */
+export function getDebugLogs() {
+    return entries.slice().reverse();
+}
+export function clearDebugLogs() {
+    entries = [];
+    notifyListeners();
+}
+export function subscribeDebugLogs(fn) {
+    listeners.add(fn);
+    return () => {
+        listeners.delete(fn);
+    };
+}
+export function pushDebugLog(level, text, data) {
+    push(level, data !== undefined ? [text, data] : [text]);
+}
+const SYNC_WRAPPED = "__teincDebugLogWrapped";
+export function initDebugLogCapture() {
+    if (installed)
+        return;
+    installed = true;
+    // Force core SyncEngine logger on even in production builds — otherwise
+    // strategy/timeout/queue decisions stay silent in the field.
+    try {
+        syncLogger.setEnabled?.(true);
+    }
+    catch { }
+    // Mirror syncLogger output into the buffer (wrap once).
+    try {
+        const rec = syncLogger;
+        if (!rec[SYNC_WRAPPED]) {
+            rec[SYNC_WRAPPED] = true;
+            ["debug", "info", "warn", "error"].forEach((m) => {
+                const orig = rec[m]?.bind(syncLogger);
+                if (!orig)
+                    return;
+                rec[m] = (...a) => {
+                    try {
+                        push(m, a);
+                    }
+                    catch { }
+                    orig(...a);
+                };
+            });
+        }
+    }
+    catch { }
+    // Mirror console.* output (guarded: React Native has no window).
+    try {
+        const c = console;
+        const orig = {
+            debug: console.debug.bind(console),
+            info: console.info.bind(console),
+            warn: console.warn.bind(console),
+            error: console.error.bind(console),
+            log: console.log.bind(console),
+        };
+        console.debug = (...a) => {
+            push("debug", a);
+            orig.debug(...a);
+        };
+        console.info = (...a) => {
+            push("info", a);
+            orig.info(...a);
+        };
+        console.warn = (...a) => {
+            push("warn", a);
+            orig.warn(...a);
+        };
+        console.error = (...a) => {
+            push("error", a);
+            orig.error(...a);
+        };
+        console.log = (...a) => {
+            push("log", a);
+            orig.log(...a);
+        };
+        void c;
+    }
+    catch { }
+    try {
+        const g = globalThis;
+        if (typeof g.addEventListener === "function") {
+            g.addEventListener("error", (e) => {
+                const err = e;
+                push("error", [err?.message, err?.error]);
+            });
+            g.addEventListener("unhandledrejection", (e) => {
+                push("error", ["unhandledrejection", e?.reason]);
+            });
+        }
+    }
+    catch { }
+    try {
+        console.debug("[debug-log] capture installed");
+    }
+    catch { }
+}

package/dist/utils/order-filter.d.ts

@@ -22,6 +22,6 @@ export declare function paginateOffline<T>(orders: T[], page: number, pageSize?:
         page: number;
         page_size: number;
         total_pages: number;
-        total_count: number;
+        total_entries: number;
     };
 };

package/dist/utils/order-filter.js

@@ -45,5 +45,5 @@ export function paginateOffline(orders, page, pageSize = 20) {
     const start = (page - 1) * pageSize;
     const slice = orders.slice(start, start + pageSize);
     const totalPages = Math.max(1, Math.ceil(orders.length / pageSize));
-    return { data: slice, pagination: { page, page_size: pageSize, total_pages: totalPages, total_count: orders.length } };
+    return { data: slice, pagination: { page, page_size: pageSize, total_pages: totalPages, total_entries: orders.length } };
 }

package/dist/utils/order-transitions.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Shared order transition business logic — single source.
+ *
+ * All TeincFood business apps (Business + Desktop) must use this module for
+ * deciding valid transitions, next action, cancellability, payment display and
+ * walk-in vs delivery branching. No per-app fork.
+ *
+ * UI markup stays per-app; this module is pure (no React/Tamagui/sonner).
+ */
+import type { SellerOrder } from "../types/api/seller.api";
+export declare const ORDER_STATUSES: readonly ["pending", "awaiting_payment", "accepted", "preparing", "ready", "waiting_pickup", "on_the_way", "arrived", "delivered", "cancelled"];
+export type OrderStatus = (typeof ORDER_STATUSES)[number];
+export declare const CANCELLABLE_STATUSES: readonly ["pending", "awaiting_payment", "accepted", "preparing", "ready"];
+export declare const PIPELINE: readonly ["pending", "accepted", "preparing", "ready", "delivered"];
+export type OrderAction = "accept" | "reject" | "start_preparing" | "mark_ready" | "complete_pickup" | "cancel" | "assign_rider" | "confirm_handover" | "confirm_cash" | "pay";
+export declare function isUnpaid(order: SellerOrder): boolean;
+export declare function isCancellable(status: string): boolean;
+export declare function cancelLabelFor(status: string): string;
+export declare function getCancelAction(status: string): "reject" | "cancel";
+export declare function isQueuedResult(result: unknown): boolean;
+export declare function isDeliveryOrder(order: Pick<SellerOrder, "order_type" | "delivery_id" | "is_pos">): boolean;
+export declare function isWalkInPickup(order: Pick<SellerOrder, "order_type" | "is_pos">): boolean;
+export declare function nextActionFor(order: SellerOrder): {
+    label: string;
+    key: OrderAction;
+} | null;
+export declare function canTransition(order: SellerOrder, action: OrderAction): boolean;
+export declare function getAllowedActions(order: SellerOrder): OrderAction[];
+export declare const QUEUED_STATUS_BY_COMMAND: Record<string, string>;
+export declare function getQueuedStatus(commandType: string): string | null;