@teincfood/core 0.7.8 → 0.8.0

package/dist/local-node/store.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Local Node store — platform-agnostic, core-owned.
+ * Mesh mode: no elected node, every isLocalNodeEnabled device is both publisher and scanner.
+ */
+export interface DiscoveredNode {
+    deviceId: string;
+    name: string;
+    host: string;
+    port: number;
+    deviceName?: string;
+    lastSeenAt: string;
+}
+export interface ConnectedClient {
+    deviceId: string;
+    deviceName?: string;
+    host?: string;
+    connectedAt: string;
+}
+interface LocalNodeState {
+    isLocalNodeEnabled: boolean;
+    localNodePort: number;
+    discoveredNodes: DiscoveredNode[];
+    connectedClients: ConnectedClient[];
+}
+type Listener = (state: LocalNodeState, prev: LocalNodeState) => void;
+declare class LocalNodeStore {
+    private state;
+    private listeners;
+    constructor();
+    private hydrate;
+    rehydrate(): Promise<void>;
+    private persist;
+    private set;
+    getState(): LocalNodeState & {
+        setIsLocalNodeEnabled: (v: boolean) => void;
+        setLocalNodePort: (p: number) => void;
+        addDiscoveredNode: (n: DiscoveredNode) => void;
+        removeDiscoveredNode: (id: string) => void;
+        clearDiscoveredNodes: () => void;
+        addConnectedClient: (c: ConnectedClient) => void;
+        removeConnectedClient: (id: string) => void;
+        clearConnectedClients: () => void;
+    };
+    subscribe(listener: Listener): () => void;
+    _reset(): void;
+}
+export declare const localNodeStore: LocalNodeStore;
+export declare function useLocalNodeStore(): ReturnType<LocalNodeStore["getState"]>;
+export declare function useLocalNodeStore<T>(selector: (s: ReturnType<LocalNodeStore["getState"]>) => T): T;
+export {};

package/dist/local-node/store.js

@@ -0,0 +1,284 @@
+/**
+ * Local Node store — platform-agnostic, core-owned.
+ * Mesh mode: no elected node, every isLocalNodeEnabled device is both publisher and scanner.
+ */
+import { getKVDriver } from "../adapters/kv";
+const DEFAULT_PORT = 44621;
+const KV_KEY = "teinc_local_node";
+class LocalNodeStore {
+    constructor() {
+        this.state = {
+            isLocalNodeEnabled: false,
+            localNodePort: DEFAULT_PORT,
+            discoveredNodes: [],
+            connectedClients: [],
+        };
+        this.listeners = new Set();
+        this.hydrate();
+    }
+    hydrate() {
+        try {
+            const ls = typeof localStorage !== "undefined" ? localStorage.getItem(KV_KEY) : null;
+            if (ls) {
+                const parsed = JSON.parse(ls);
+                this.state = { ...this.state, ...parsed, discoveredNodes: [], connectedClients: [] };
+                return;
+            }
+            const old = typeof localStorage !== "undefined" ? localStorage.getItem("local_node_data") : null;
+            if (old) {
+                try {
+                    const parsedOld = JSON.parse(old);
+                    const p = parsedOld.state ?? parsedOld;
+                    if (p && typeof p.isLocalNodeEnabled === "boolean") {
+                        this.state = { ...this.state, ...p, discoveredNodes: [], connectedClients: [] };
+                        return;
+                    }
+                }
+                catch { }
+            }
+        }
+        catch { }
+        try {
+            const kv = getKVDriver();
+            const raw = kv?.getItem(KV_KEY);
+            if (raw instanceof Promise) {
+                raw.then((v) => {
+                    if (!v) {
+                        const kv2 = getKVDriver();
+                        const rawOld = kv2?.getItem("local_node_data");
+                        if (rawOld instanceof Promise)
+                            rawOld.then((o) => { if (!o)
+                                return; try {
+                                const po = JSON.parse(o);
+                                const p = po.state ?? po;
+                                this.state = { ...this.state, ...p, discoveredNodes: [], connectedClients: [] };
+                                const prev = { ...this.state };
+                                for (const l of this.listeners)
+                                    try {
+                                        l(this.getState(), prev);
+                                    }
+                                    catch { }
+                            }
+                            catch { } }).catch(() => { });
+                        else if (rawOld)
+                            try {
+                                const po = JSON.parse(rawOld);
+                                const p = po.state ?? po;
+                                this.state = { ...this.state, ...p, discoveredNodes: [], connectedClients: [] };
+                                const prev2 = { ...this.state };
+                                for (const l of this.listeners)
+                                    try {
+                                        l(this.getState(), prev2);
+                                    }
+                                    catch { }
+                            }
+                            catch { }
+                        return;
+                    }
+                    try {
+                        const parsed = JSON.parse(v);
+                        const prev = { ...this.state, discoveredNodes: [...this.state.discoveredNodes], connectedClients: [...this.state.connectedClients] };
+                        this.state = { ...this.state, ...parsed, discoveredNodes: [], connectedClients: [] };
+                        for (const l of this.listeners)
+                            try {
+                                l(this.getState(), prev);
+                            }
+                            catch { }
+                    }
+                    catch { }
+                }).catch(() => { });
+            }
+            else if (raw) {
+                const parsed = JSON.parse(raw);
+                this.state = { ...this.state, ...parsed, discoveredNodes: [], connectedClients: [] };
+            }
+        }
+        catch { }
+    }
+    async rehydrate() {
+        try {
+            const kv = getKVDriver();
+            const raw = await kv.getItem(KV_KEY);
+            let parsed = null;
+            if (raw) {
+                try {
+                    parsed = JSON.parse(raw);
+                }
+                catch { }
+            }
+            else {
+                try {
+                    const ls = typeof localStorage !== "undefined" ? localStorage.getItem(KV_KEY) : null;
+                    if (ls)
+                        parsed = JSON.parse(ls);
+                }
+                catch { }
+            }
+            if (!parsed) {
+                try {
+                    const oldRaw = await kv.getItem("local_node_data");
+                    if (oldRaw) {
+                        const po = JSON.parse(oldRaw);
+                        parsed = po.state ?? po;
+                    }
+                }
+                catch { }
+            }
+            if (!parsed)
+                return;
+            const prev = { ...this.state, discoveredNodes: [...this.state.discoveredNodes], connectedClients: [...this.state.connectedClients] };
+            const next = {};
+            if (typeof parsed.isLocalNodeEnabled === "boolean")
+                next.isLocalNodeEnabled = parsed.isLocalNodeEnabled;
+            if (typeof parsed.localNodePort === "number")
+                next.localNodePort = parsed.localNodePort;
+            const changed = next.isLocalNodeEnabled !== undefined && next.isLocalNodeEnabled !== this.state.isLocalNodeEnabled;
+            this.state = { ...this.state, ...next, discoveredNodes: [], connectedClients: [] };
+            if (changed) {
+                for (const l of this.listeners)
+                    try {
+                        l(this.getState(), prev);
+                    }
+                    catch { }
+            }
+        }
+        catch { }
+    }
+    persist() {
+        try {
+            const kv = getKVDriver();
+            if (!kv)
+                return;
+            const toSave = {
+                isLocalNodeEnabled: this.state.isLocalNodeEnabled,
+                localNodePort: this.state.localNodePort,
+            };
+            const raw = JSON.stringify(toSave);
+            kv.setItem(KV_KEY, raw);
+            try {
+                if (typeof localStorage !== "undefined")
+                    localStorage.setItem(KV_KEY, raw);
+            }
+            catch { }
+        }
+        catch { }
+    }
+    set(partial) {
+        const prev = { ...this.state, discoveredNodes: [...this.state.discoveredNodes], connectedClients: [...this.state.connectedClients] };
+        this.state = { ...this.state, ...partial };
+        this.persist();
+        for (const l of this.listeners) {
+            try {
+                l(this.getState(), prev);
+            }
+            catch { }
+        }
+    }
+    getState() {
+        const self = this;
+        return {
+            ...this.state,
+            setIsLocalNodeEnabled: (enabled) => self.set({ isLocalNodeEnabled: enabled }),
+            setLocalNodePort: (port) => self.set({ localNodePort: port }),
+            addDiscoveredNode: (node) => {
+                const prev = { ...self.state, discoveredNodes: [...self.state.discoveredNodes] };
+                // Dedup by deviceId (same peer re-announced) OR by host:port
+                // (TCP sweep's synthetic "lan-X.X.X.X" vs mDNS real UUID for same device).
+                const existingById = self.state.discoveredNodes.find((n) => n.deviceId === node.deviceId);
+                const existingByAddr = !existingById && node.host && node.port
+                    ? self.state.discoveredNodes.find((n) => n.host === node.host && n.port === node.port)
+                    : undefined;
+                const existing = existingById ?? existingByAddr;
+                if (existing) {
+                    // Prefer the real UUID entry over synthetic "lan-" prefix entries
+                    const keep = (existing.deviceId.startsWith("lan-") && !node.deviceId.startsWith("lan-"))
+                        ? node : existing;
+                    self.state = {
+                        ...self.state,
+                        discoveredNodes: self.state.discoveredNodes.map((n) => (n.deviceId === keep.deviceId || n.host === keep.host && n.port === keep.port)
+                            ? { ...n, ...keep, lastSeenAt: new Date().toISOString() }
+                            : n),
+                    };
+                }
+                else {
+                    self.state = { ...self.state, discoveredNodes: [...self.state.discoveredNodes, { ...node, lastSeenAt: new Date().toISOString() }] };
+                }
+                for (const l of self.listeners) {
+                    try {
+                        l(self.getState(), prev);
+                    }
+                    catch { }
+                }
+            },
+            removeDiscoveredNode: (deviceId) => {
+                const prev = { ...self.state, discoveredNodes: [...self.state.discoveredNodes] };
+                self.state = { ...self.state, discoveredNodes: self.state.discoveredNodes.filter((n) => n.deviceId !== deviceId) };
+                for (const l of self.listeners) {
+                    try {
+                        l(self.getState(), prev);
+                    }
+                    catch { }
+                }
+            },
+            clearDiscoveredNodes: () => self.set({ discoveredNodes: [] }),
+            addConnectedClient: (client) => {
+                const prev = { ...self.state, connectedClients: [...self.state.connectedClients] };
+                const existing = self.state.connectedClients.find((c) => c.deviceId === client.deviceId);
+                if (existing) {
+                    self.state = {
+                        ...self.state,
+                        connectedClients: self.state.connectedClients.map((c) => (c.deviceId === client.deviceId ? { ...c, ...client } : c)),
+                    };
+                }
+                else {
+                    self.state = { ...self.state, connectedClients: [...self.state.connectedClients, client] };
+                }
+                for (const l of self.listeners) {
+                    try {
+                        l(self.getState(), prev);
+                    }
+                    catch { }
+                }
+            },
+            removeConnectedClient: (deviceId) => {
+                const prev = { ...self.state, connectedClients: [...self.state.connectedClients] };
+                self.state = { ...self.state, connectedClients: self.state.connectedClients.filter((c) => c.deviceId !== deviceId) };
+                for (const l of self.listeners) {
+                    try {
+                        l(self.getState(), prev);
+                    }
+                    catch { }
+                }
+            },
+            clearConnectedClients: () => self.set({ connectedClients: [] }),
+        };
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    _reset() {
+        this.state = {
+            isLocalNodeEnabled: false,
+            localNodePort: DEFAULT_PORT,
+            discoveredNodes: [],
+            connectedClients: [],
+        };
+        this.listeners.clear();
+    }
+}
+export const localNodeStore = new LocalNodeStore();
+import * as React from "react";
+export function useLocalNodeStore(selector) {
+    const [state, setState] = React.useState(() => localNodeStore.getState());
+    React.useEffect(() => {
+        const unsub = localNodeStore.subscribe((next) => setState(next));
+        setState(localNodeStore.getState());
+        return unsub;
+    }, []);
+    if (selector)
+        return selector(state);
+    return state;
+}
+useLocalNodeStore.getState = () => localNodeStore.getState();
+useLocalNodeStore.subscribe = (fn) => localNodeStore.subscribe(fn);

package/dist/local-node/types.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Types for the Local Node / multi-terminal LAN layer.
+ */
+import type { Command, DomainEvent } from "../sync/types";
+import type { ReferenceDataKey, ReferenceDataRecord } from "../reference/types";
+export type LocalNodeMessageType = "command" | "command_response" | "event" | "relay_event" | "ping" | "pong" | "hello" | "challenge" | "auth" | "auth_ok" | "auth_fail" | "register" | "register_ack" | "reference_fetch" | "reference_response";
+export interface LocalNodeMessage {
+    type: LocalNodeMessageType;
+    id: string;
+    payload: unknown;
+}
+export interface LocalNodeCommandMessage extends LocalNodeMessage {
+    type: "command";
+    payload: Command;
+}
+export interface LocalNodeCommandResponseMessage extends LocalNodeMessage {
+    type: "command_response";
+    payload: DomainEvent[];
+}
+export interface LocalNodeEventMessage extends LocalNodeMessage {
+    type: "event";
+    payload: DomainEvent;
+}
+export interface LocalNodeRelayEventMessage extends LocalNodeMessage {
+    type: "relay_event";
+    payload: DomainEvent;
+}
+export interface LocalNodeHelloMessage extends LocalNodeMessage {
+    type: "hello";
+    payload: {
+        deviceId: string;
+        deviceName?: string;
+        businessId?: string;
+    };
+}
+export interface LocalNodeChallengeMessage extends LocalNodeMessage {
+    type: "challenge";
+    payload: {
+        nonce: string;
+    };
+}
+export interface LocalNodeAuthMessage extends LocalNodeMessage {
+    type: "auth";
+    payload: {
+        nonce: string;
+        proof: string;
+    };
+}
+export interface LocalNodeAuthOkMessage extends LocalNodeMessage {
+    type: "auth_ok";
+    payload: Record<string, never>;
+}
+export interface LocalNodeAuthFailMessage extends LocalNodeMessage {
+    type: "auth_fail";
+    payload: {
+        reason?: string;
+    };
+}
+export interface LocalNodeRegisterMessage extends LocalNodeMessage {
+    type: "register";
+    payload: {
+        deviceId: string;
+        deviceName?: string;
+        businessId?: string;
+        connectedAt: string;
+    };
+}
+export interface LocalNodeRegisterAckMessage extends LocalNodeMessage {
+    type: "register_ack";
+    payload: Record<string, never>;
+}
+export interface LocalNodeReferenceFetchMessage extends LocalNodeMessage {
+    type: "reference_fetch";
+    payload: {
+        businessId: string;
+        keys: ReferenceDataKey[];
+    };
+}
+export interface LocalNodeReferenceResponseMessage extends LocalNodeMessage {
+    type: "reference_response";
+    payload: {
+        data: Partial<Record<ReferenceDataKey, ReferenceDataRecord | null>>;
+    };
+}
+export type LocalNodeConnectionState = "disconnected" | "connecting" | "connected";
+export interface LocalNodeInfo {
+    deviceId: string;
+    host: string;
+    port: number;
+    businessId?: string;
+    deviceName?: string;
+}

package/dist/local-node/types.js

@@ -0,0 +1,4 @@
+/**
+ * Types for the Local Node / multi-terminal LAN layer.
+ */
+export {};

package/dist/printer/receipt.d.ts

@@ -9,4 +9,8 @@
 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 generateHtmlAsync(order: SellerOrder, opts?: {
+    logoDataUri?: string | null;
+    useCache?: boolean;
+}): Promise<string>;
 export declare function generateHtml(order: SellerOrder, logoDataUri?: string | null): string;

package/dist/printer/receipt.js

@@ -6,6 +6,9 @@
  * Backend source: lib/teinc_food_backend/orders/receipt.ex
  * Keep this file in sync with backend when template changes.
  */
+import { openSyncDatabase } from "../db/connection";
+import { getReferenceData } from "../reference/operations";
+import { cacheRemoteImage, resolveImageSource } from "../image-cache/service";
 const LINE_WIDTH = 32;
 const ESC_INIT = "\x1B\x40";
 const ESC_ALIGN_LEFT = "\x1B\x61\x00";
@@ -116,6 +119,31 @@ function businessAddress(business) {
         return b.address;
     return null;
 }
+function businessLogoUrl(order) {
+    const b = order.business;
+    if (!b)
+        return null;
+    return (b.logo_url ?? b.logoUrl ?? null);
+}
+/** Fetch remote URL (or tfimg://) and return data URI, or null on failure. Uses Web fetch; works for http(s) and for cached tfimg via Rust protocol. */
+async function fetchAsDataUri(url) {
+    try {
+        const res = await fetch(url);
+        if (!res.ok)
+            return null;
+        const blob = await res.blob();
+        const reader = await new Promise((resolve, reject) => {
+            const fr = new FileReader();
+            fr.onload = () => resolve(fr.result);
+            fr.onerror = () => reject(new Error("FileReader failed"));
+            fr.readAsDataURL(blob);
+        });
+        return reader;
+    }
+    catch {
+        return null;
+    }
+}
 // ── ESC/POS ────────────────────────────────────────────────────────────
 function doubleLineEscpos() { return "═".repeat(LINE_WIDTH) + LF; }
 function singleLineEscpos() { return "─".repeat(LINE_WIDTH); }
@@ -222,6 +250,53 @@ export function generateEscpos(order) {
     return parts.filter((p) => p != null).join("");
 }
 // ── HTML ───────────────────────────────────────────────────────────────
+export async function generateHtmlAsync(order, opts) {
+    const explicit = opts?.logoDataUri;
+    if (explicit)
+        return generateHtml(order, explicit);
+    const logoUrl = businessLogoUrl(order);
+    if (!logoUrl) {
+        try {
+            const bId = order.business_id;
+            if (bId) {
+                const db = await openSyncDatabase();
+                const ref = await getReferenceData(db, bId, "business:profile");
+                const refLogo = ref?.payload?.data?.logo_url;
+                if (refLogo) {
+                    const dataUri = await fetchAsDataUri(refLogo);
+                    if (dataUri)
+                        return generateHtml(order, dataUri);
+                    try {
+                        await cacheRemoteImage(refLogo, { skipIfCached: true });
+                        const resolved = await resolveImageSource(refLogo);
+                        const src = resolved?.uri ?? refLogo;
+                        const dataUri2 = await fetchAsDataUri(src);
+                        if (dataUri2)
+                            return generateHtml(order, dataUri2);
+                        if (src !== refLogo)
+                            return generateHtml(order, src);
+                    }
+                    catch { }
+                    return generateHtml(order, refLogo);
+                }
+            }
+        }
+        catch { }
+        return generateHtml(order, null);
+    }
+    try {
+        await cacheRemoteImage(logoUrl, { skipIfCached: true });
+        const resolved = await resolveImageSource(logoUrl);
+        const src = resolved?.uri ?? logoUrl;
+        const dataUri = await fetchAsDataUri(src);
+        if (dataUri)
+            return generateHtml(order, dataUri);
+        if (src !== logoUrl)
+            return generateHtml(order, src);
+    }
+    catch { }
+    return generateHtml(order, logoUrl);
+}
 export function generateHtml(order, logoDataUri) {
     const business = order.business;
     const items = order.items || [];

package/dist/printer/service.js

@@ -7,6 +7,7 @@ import { getHttpClient } from "../adapters/http";
 import { getTcpAdapter, getPrintFileAdapter } from "../adapters/print";
 import { getPrinterState } from "./store";
 import { generateEscpos, generateHtml } from "./receipt";
+import { API_BASE_URL } from "../utils/constants";
 async function fetchReceipt(orderId, format = "html") {
     const http = getHttpClient();
     // http adapter wraps axios; fallback to fetch if not set
@@ -21,7 +22,6 @@ async function fetchReceipt(orderId, format = "html") {
         return String(data);
     }
     // Fallback fetch using API_BASE_URL already injected
-    const { API_BASE_URL } = await import("../utils/constants");
     const url = `${API_BASE_URL}/orders/${orderId}/receipt?format=${format}`;
     const resp = await fetch(url, { headers: { Accept: format === "html" ? "text/html" : "text/plain" } });
     if (!resp.ok) {

package/dist/providers/query-client.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Shared QueryClient factory — single source for query defaults + cache
+ * persistence. Apps inject only platform specifics: the error toast and the
+ * storage backend (MMKV on mobile, Tauri store on desktop).
+ */
+import { QueryClient } from "@tanstack/react-query";
+export interface QueryPersistStorage {
+    getItem: (key: string) => string | null | undefined | Promise<string | null | undefined>;
+    setItem: (key: string, value: string) => void | Promise<void>;
+    removeItem: (key: string) => void | Promise<void>;
+}
+export declare function createAppQueryClient(onMutationError: (message: string) => void): QueryClient;
+export declare function createQueryPersister(storage: QueryPersistStorage, key?: string, throttleTime?: number): import("@tanstack/query-persist-client-core").Persister;

package/dist/providers/query-client.js

@@ -0,0 +1,58 @@
+/**
+ * Shared QueryClient factory — single source for query defaults + cache
+ * persistence. Apps inject only platform specifics: the error toast and the
+ * storage backend (MMKV on mobile, Tauri store on desktop).
+ */
+import { MutationCache, QueryClient } from "@tanstack/react-query";
+import { createAsyncStoragePersister } from "@tanstack/query-async-storage-persister";
+import { getConnectivityState } from "../adapters/connectivity";
+export function createAppQueryClient(onMutationError) {
+    return new QueryClient({
+        mutationCache: new MutationCache({
+            onError: (error) => {
+                try {
+                    onMutationError(error instanceof Error ? error.message : "Something went wrong");
+                }
+                catch { }
+            },
+        }),
+        defaultOptions: {
+            queries: {
+                // Offline-first: when the cloud is known unreachable (health probe
+                // failed / backend down), fail fast with zero retries — retrying a
+                // dead backend only multiplies error spam. Transient failures while
+                // reachable keep the standard 2 retries.
+                retry: (failureCount, error) => {
+                    try {
+                        if (getConnectivityState().isCloudReachable === "unreachable")
+                            return false;
+                    }
+                    catch { }
+                    // Never retry explicit offline short-circuits (axios guard / adapters).
+                    const msg = error instanceof Error ? error.message : String(error ?? "");
+                    if (msg.startsWith("Offline") || error?.code === "OFFLINE")
+                        return false;
+                    return failureCount < 2;
+                },
+                refetchOnWindowFocus: true,
+                refetchOnReconnect: true,
+                staleTime: 30 * 1000,
+                gcTime: 5 * 60 * 1000,
+            },
+            mutations: {
+                retry: 1,
+            },
+        },
+    });
+}
+export function createQueryPersister(storage, key = "teincfood-query-cache", throttleTime = 1000) {
+    return createAsyncStoragePersister({
+        storage: {
+            getItem: (k) => storage.getItem(k),
+            setItem: (k, v) => storage.setItem(k, v),
+            removeItem: (k) => storage.removeItem(k),
+        },
+        key,
+        throttleTime,
+    });
+}

package/dist/realtime/events.service.d.ts

@@ -0,0 +1,18 @@
+type EventCallback = (event: Record<string, unknown>) => void;
+declare class EventsService {
+    private refCount;
+    private topic;
+    private joined;
+    private lastSequence;
+    private activeBusinessId;
+    private listeners;
+    private wildcardListeners;
+    private frameHandlerUnsub;
+    connect(userId: string, businessId?: string | null): () => void;
+    on(eventType: string, callback: EventCallback): () => void;
+    onAny(callback: EventCallback): () => void;
+    isConnected(): boolean;
+    resetSequence(): void;
+}
+export declare const eventsService: EventsService;
+export {};