@teincfood/core 0.7.9 → 0.8.0

package/dist/hooks/places.hooks.js

@@ -0,0 +1,112 @@
+/**
+ * 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 { useState, useEffect, useRef, useCallback } from "react";
+import { useSyncExternalStore } from "react";
+import { getConnectivityState, subscribeConnectivity } from "../adapters/connectivity";
+import { placesService } from "../adapters/services";
+export function usePlacesSearch(debounceMs = 300) {
+    const [query, setQuery] = useState("");
+    const [suggestions, setSuggestions] = useState([]);
+    const [isLoading, setIsLoading] = useState(false);
+    const debounceRef = useRef(undefined);
+    // Place search has no offline index — don't fire while unreachable.
+    const connectivity = useSyncExternalStore(subscribeConnectivity, getConnectivityState, getConnectivityState);
+    const online = connectivity.isOnline && connectivity.isCloudReachable !== "unreachable";
+    useEffect(() => {
+        let cancelled = false;
+        if (debounceRef.current) {
+            clearTimeout(debounceRef.current);
+        }
+        if (!query || query.length < 3 || !online) {
+            setSuggestions([]);
+            setIsLoading(false);
+            return;
+        }
+        setIsLoading(true);
+        debounceRef.current = setTimeout(async () => {
+            try {
+                const results = await placesService.searchPlaces(query);
+                if (!cancelled) {
+                    setSuggestions(results);
+                }
+            }
+            catch (error) {
+                try {
+                    console.error("Places search error:", error);
+                }
+                catch { }
+                if (!cancelled) {
+                    setSuggestions([]);
+                }
+            }
+            finally {
+                if (!cancelled) {
+                    setIsLoading(false);
+                }
+            }
+        }, debounceMs);
+        return () => {
+            cancelled = true;
+            if (debounceRef.current) {
+                clearTimeout(debounceRef.current);
+            }
+            setIsLoading(false);
+        };
+    }, [query, debounceMs]);
+    const clearSearch = useCallback(() => {
+        setQuery("");
+        setSuggestions([]);
+    }, []);
+    const clearAll = useCallback(() => {
+        setQuery("");
+        setSuggestions([]);
+        setIsLoading(false);
+    }, []);
+    return {
+        query,
+        setQuery,
+        suggestions,
+        isLoading,
+        clearSearch,
+        clearAll,
+    };
+}
+export function usePlaceDetails(placeId) {
+    const [details, setDetails] = useState(null);
+    const [isLoading, setIsLoading] = useState(false);
+    const connectivity = useSyncExternalStore(subscribeConnectivity, getConnectivityState, getConnectivityState);
+    const online = connectivity.isOnline && connectivity.isCloudReachable !== "unreachable";
+    useEffect(() => {
+        if (!placeId || !online) {
+            setDetails(null);
+            return;
+        }
+        let cancelled = false;
+        setIsLoading(true);
+        placesService.getPlaceDetails(placeId).then((result) => {
+            if (!cancelled && result) {
+                setDetails(result);
+            }
+            setIsLoading(false);
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [placeId]);
+    return { details, isLoading };
+}
+export function clearPlacesCache() {
+    void placesService.clearCache();
+}
+/** Generic debounced-value hook for search/filter inputs. */
+export function useDebouncedValue(value, delayMs = 400) {
+    const [debounced, setDebounced] = useState(value);
+    useEffect(() => {
+        const t = setTimeout(() => setDebounced(value), delayMs);
+        return () => clearTimeout(t);
+    }, [value, delayMs]);
+    return debounced;
+}

package/dist/hooks/realtime-stubs.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Realtime invalidation hooks — bridge Phoenix WebSocket events into the
+ * Sync Engine so useSyncReconciliation fires and React Query caches refresh.
+ *
+ * Both hooks are idempotent-safe and can be called from multiple screens.
+ * Invalidations are debounced: a reconnect/replay burst can deliver dozens
+ * of events at once, and an immediate invalidate-per-event forces repeated
+ * full re-renders of boards/grids — a major CPU spike source on low-power
+ * POS hardware. Coalescing into one invalidation per ~400ms window keeps
+ * the UI fresh without the render storm.
+ */
+/**
+ * Subscribe to real-time order events and invalidate all queries under the
+ * given root key prefix (e.g. ['seller'], ['pos'], ['kiosk']).
+ *
+ * Each event is also persisted to the durable offline read model so order
+ * history and states survive a restart while offline, and published through
+ * the Sync Engine so useSyncReconciliation + LAN relay fire without polling.
+ *
+ * Call once per screen that needs live updates (POS, Orders, Kitchen, etc.).
+ */
+export declare function useOrderRealtimeUpdates(rootKey: readonly string[]): void;
+/**
+ * Global realtime invalidation — currently handled entirely by
+ * useOrderRealtimeUpdates + useSyncReconciliation. Kept as a no-op for
+ * backward compatibility with any lingering call sites.
+ */
+export declare function useRealtimeInvalidation(): void;

package/dist/hooks/realtime-stubs.js

@@ -0,0 +1,85 @@
+/**
+ * Realtime invalidation hooks — bridge Phoenix WebSocket events into the
+ * Sync Engine so useSyncReconciliation fires and React Query caches refresh.
+ *
+ * Both hooks are idempotent-safe and can be called from multiple screens.
+ * Invalidations are debounced: a reconnect/replay burst can deliver dozens
+ * of events at once, and an immediate invalidate-per-event forces repeated
+ * full re-renders of boards/grids — a major CPU spike source on low-power
+ * POS hardware. Coalescing into one invalidation per ~400ms window keeps
+ * the UI fresh without the render storm.
+ */
+import { useEffect } from "react";
+import { useQueryClient } from "@tanstack/react-query";
+import { orderEventsService } from "../realtime/order-events.service";
+import { orderSnapshotsService } from "../sync/order-snapshots.service";
+import { syncEngine } from "../sync/engine";
+import { generateEventId } from "../utils/uuid";
+import { getAppInstanceId } from "../adapters/devices";
+const INVALIDATE_DEBOUNCE_MS = 400;
+/**
+ * Subscribe to real-time order events and invalidate all queries under the
+ * given root key prefix (e.g. ['seller'], ['pos'], ['kiosk']).
+ *
+ * Each event is also persisted to the durable offline read model so order
+ * history and states survive a restart while offline, and published through
+ * the Sync Engine so useSyncReconciliation + LAN relay fire without polling.
+ *
+ * Call once per screen that needs live updates (POS, Orders, Kitchen, etc.).
+ */
+export function useOrderRealtimeUpdates(rootKey) {
+    const queryClient = useQueryClient();
+    useEffect(() => {
+        let timer;
+        const pendingOrderIds = new Set();
+        const pending = { rootKey: false };
+        const ownDeviceId = getAppInstanceId();
+        const flush = () => {
+            timer = undefined;
+            if (pending.rootKey)
+                queryClient.invalidateQueries({ queryKey: rootKey });
+            for (const oid of pendingOrderIds) {
+                queryClient.invalidateQueries({ queryKey: [...rootKey, "order", oid] });
+            }
+            pendingOrderIds.clear();
+            pending.rootKey = false;
+        };
+        const unsub = orderEventsService.onOrderUpdates((event) => {
+            pending.rootKey = true;
+            if (event.order_id)
+                pendingOrderIds.add(event.order_id);
+            const payload = { ...event };
+            const domainEvent = {
+                event_id: payload.event_id ?? generateEventId(),
+                event_type: event.type,
+                event_version: payload.event_version ?? "1.0",
+                timestamp: payload.timestamp ?? new Date().toISOString(),
+                device_id: payload.device_id ?? ownDeviceId,
+                user_id: payload.user_id ?? "system",
+                entity_id: event.order_id ?? "",
+                payload,
+            };
+            // Persist to durable offline read model (entity_snapshots table).
+            orderSnapshotsService.persistOrderEvent(domainEvent, "cloud").catch(() => { });
+            // Publish through the Sync Engine so useSyncReconciliation + LAN relay
+            // fire without waiting for the next poll.
+            try {
+                syncEngine.publish(domainEvent);
+            }
+            catch { }
+            if (!timer)
+                timer = setTimeout(flush, INVALIDATE_DEBOUNCE_MS);
+        });
+        return () => {
+            if (timer)
+                clearTimeout(timer);
+            unsub();
+        };
+    }, [queryClient, rootKey]);
+}
+/**
+ * Global realtime invalidation — currently handled entirely by
+ * useOrderRealtimeUpdates + useSyncReconciliation. Kept as a no-op for
+ * backward compatibility with any lingering call sites.
+ */
+export function useRealtimeInvalidation() { }