@cachly-dev/mcp-server 0.10.47 → 0.10.49

package/apps/travel-chaos-organizer/frontend/hooks/useInbox.ts

@@ -0,0 +1,24 @@
+import { useEffect, useState, useCallback } from "react";
+import { inboxApi, InboxItem } from "../lib/api";
+
+export function useInbox(statusFilter = "pending") {
+  const [items, setItems] = useState<InboxItem[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+
+  const refresh = useCallback(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      setItems(await inboxApi.list(statusFilter));
+    } catch (e) {
+      setError(String(e));
+    } finally {
+      setLoading(false);
+    }
+  }, [statusFilter]);
+
+  useEffect(() => { refresh(); }, [refresh]);
+
+  return { items, loading, error, refresh };
+}

package/apps/travel-chaos-organizer/frontend/hooks/useNetworkSync.ts

@@ -0,0 +1,60 @@
+/**
+ * Runs the offline queue drain whenever the app comes to foreground
+ * or network connectivity is restored.
+ *
+ * Import once in the root layout — all other screens benefit automatically.
+ */
+import { useEffect, useRef } from "react";
+import { AppState, AppStateStatus } from "react-native";
+import * as Network from "expo-network";
+import { drainQueue, processQueue, setQueueErrorCallback } from "../lib/offlineQueue";
+import { getAccessToken } from "../lib/auth";
+import { useToast } from "../components/ToastContext";
+
+const BASE_URL = process.env.EXPO_PUBLIC_API_URL!;
+
+async function authHeaders(): Promise<Record<string, string>> {
+  const token = await getAccessToken();
+  if (!token) return {};
+  return { Authorization: `Bearer ${token}` };
+}
+
+export function useNetworkSync(onSynced?: (result: { succeeded: number; failed: number }) => void) {
+  const appState = useRef<AppStateStatus>(AppState.currentState);
+  const wasOffline = useRef(false);
+  const { showToast } = useToast();
+
+  useEffect(() => {
+    setQueueErrorCallback((count) => {
+      showToast(`${count} gespeicherte Änderungen konnten nicht synchronisiert werden`, "error");
+    });
+    // Drain on foreground
+    const appStateSub = AppState.addEventListener("change", async (next) => {
+      if (appState.current.match(/inactive|background/) && next === "active") {
+        const result = await drainQueue(authHeaders, BASE_URL);
+        if (result.succeeded > 0) onSynced?.(result);
+      }
+      appState.current = next;
+    });
+
+    // Drain on network recovery by polling every 5 s (expo-network has no push listener)
+    const interval = setInterval(async () => {
+      if (appState.current !== "active") return;
+      const net = await Network.getNetworkStateAsync();
+      if (!net.isConnected) {
+        wasOffline.current = true;
+        return;
+      }
+      if (wasOffline.current) {
+        wasOffline.current = false;
+        const result = await processQueue(authHeaders, BASE_URL);
+        if (result.succeeded > 0) onSynced?.(result);
+      }
+    }, 5000);
+
+    return () => {
+      appStateSub.remove();
+      clearInterval(interval);
+    };
+  }, []);
+}

package/apps/travel-chaos-organizer/frontend/hooks/useTrips.ts

@@ -0,0 +1,112 @@
+import { useEffect, useState, useCallback } from "react";
+import * as Network from "expo-network";
+import { tripsApi, itemsApi, Trip, TripItem } from "../lib/api";
+import { upsertTrips, upsertItems, getLocalTrips, getLocalItems, deleteLocalItem } from "../lib/db";
+import { enqueue } from "../lib/offlineQueue";
+import { cancelItemReminders } from "../lib/notifications";
+
+export function useTrips() {
+  const [trips, setTrips] = useState<Trip[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+
+  const sync = useCallback(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const net = await Network.getNetworkStateAsync();
+      if (net.isConnected) {
+        const remote = await tripsApi.list();
+        upsertTrips(remote);
+        setTrips(remote);
+      } else {
+        setTrips(getLocalTrips());
+      }
+    } catch (e) {
+      setError(String(e));
+      setTrips(getLocalTrips());
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+
+  useEffect(() => { sync(); }, [sync]);
+
+  async function createOffline(data: Pick<Trip, "name" | "description" | "start_date" | "end_date">) {
+    const net = await Network.getNetworkStateAsync();
+    if (net.isConnected) {
+      const trip = await tripsApi.create(data);
+      upsertTrips([trip]);
+      setTrips((prev) => [...prev, trip]);
+      return trip;
+    }
+    enqueue("POST", "/api/v1/trips", data);
+    const temp: Trip = { id: `temp-${Date.now()}`, user_id: "local", created_at: new Date().toISOString(), updated_at: new Date().toISOString(), ...data };
+    upsertTrips([temp]);
+    setTrips((prev) => [...prev, temp]);
+    return temp;
+  }
+
+  async function updateOffline(id: string, data: Partial<Pick<Trip, "name" | "description" | "start_date" | "end_date">>) {
+    const net = await Network.getNetworkStateAsync();
+    if (net.isConnected) {
+      const updated = await tripsApi.update(id, data);
+      upsertTrips([updated]);
+      setTrips((prev) => prev.map((t) => (t.id === id ? updated : t)));
+      return updated;
+    }
+    enqueue("PATCH", `/api/v1/trips/${id}`, data);
+    setTrips((prev) => prev.map((t) => (t.id === id ? { ...t, ...data } : t)));
+  }
+
+  async function deleteTrip(id: string) {
+    const net = await Network.getNetworkStateAsync();
+    if (net.isConnected) {
+      await tripsApi.delete(id);
+    } else {
+      enqueue("DELETE", `/api/v1/trips/${id}`, {});
+    }
+    setTrips((prev) => prev.filter((t) => t.id !== id));
+  }
+
+  return { trips, loading, error, refresh: sync, createOffline, updateOffline, deleteTrip };
+}
+
+export function useTripItems(tripId: string) {
+  const [items, setItems] = useState<TripItem[]>([]);
+  const [loading, setLoading] = useState(true);
+
+  const sync = useCallback(async () => {
+    setLoading(true);
+    try {
+      const net = await Network.getNetworkStateAsync();
+      if (net.isConnected) {
+        const remote = await itemsApi.list(tripId);
+        upsertItems(remote);
+        setItems(remote);
+      } else {
+        setItems(getLocalItems(tripId));
+      }
+    } catch {
+      setItems(getLocalItems(tripId));
+    } finally {
+      setLoading(false);
+    }
+  }, [tripId]);
+
+  useEffect(() => { sync(); }, [sync]);
+
+  async function deleteItem(itemId: string) {
+    const net = await Network.getNetworkStateAsync();
+    if (net.isConnected) {
+      await itemsApi.delete(tripId, itemId);
+    } else {
+      enqueue("DELETE", `/api/v1/trips/${tripId}/items/${itemId}`, {});
+    }
+    deleteLocalItem(itemId);
+    await cancelItemReminders(itemId);
+    setItems((prev) => prev.filter((i) => i.id !== itemId));
+  }
+
+  return { items, loading, refresh: sync, deleteItem };
+}

package/apps/travel-chaos-organizer/frontend/lib/api.ts

@@ -0,0 +1,223 @@
+import { getAccessToken } from "./auth";
+import { enqueueRequest } from "./offlineQueue";
+
+const BASE_URL = process.env.EXPO_PUBLIC_API_URL!;
+
+/** Default timeout for regular API calls (trips, items, users, etc.) */
+const DEFAULT_TIMEOUT_MS = 30_000;
+/** Extended timeout for AI parse calls (Ollama can be slow on first run) */
+const PARSE_TIMEOUT_MS = 120_000;
+
+export class ApiError extends Error {
+  constructor(
+    message: string,
+    public readonly status: number,
+    public readonly body: string,
+  ) {
+    super(message);
+    this.name = "ApiError";
+  }
+}
+
+async function authHeaders(): Promise<Record<string, string>> {
+  const token = await getAccessToken();
+  if (!token) throw new Error("Not authenticated");
+  return { Authorization: `Bearer ${token}`, "Content-Type": "application/json" };
+}
+
+async function request<T>(path: string, init: RequestInit = {}): Promise<T> {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), DEFAULT_TIMEOUT_MS);
+  try {
+    const headers = await authHeaders();
+    const res = await fetch(`${BASE_URL}${path}`, {
+      ...init,
+      headers: { ...headers, ...init.headers },
+      signal: controller.signal,
+    });
+    if (!res.ok) {
+      const body = await res.text();
+      throw new ApiError(`API ${res.status}: ${body}`, res.status, body);
+    }
+    return res.json() as Promise<T>;
+  } catch (err) {
+    if (err instanceof Error && err.name === "AbortError") {
+      throw new ApiError("Timeout: Server antwortet nicht", 408, "timeout");
+    }
+    // Network error (no status) — queue for offline retry
+    if (!(err instanceof ApiError) && init.method && ["POST","PATCH","DELETE"].includes(init.method)) {
+      const bodyObj = init.body ? (() => { try { return JSON.parse(init.body as string) as object; } catch { return undefined; } })() : undefined;
+      enqueueRequest(init.method as "POST" | "PATCH" | "DELETE", path, bodyObj);
+    }
+    throw err;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// ── Trips ──────────────────────────────────────────────────────────────────
+
+export type Trip = {
+  id: string;
+  user_id: string;
+  name: string;
+  description: string | null;
+  start_date: string | null;
+  end_date: string | null;
+  created_at: string;
+  updated_at: string;
+};
+
+export const tripsApi = {
+  list: () => request<Trip[]>("/api/v1/trips"),
+  get: (id: string) => request<Trip>(`/api/v1/trips/${id}`),
+  create: (data: Pick<Trip, "name" | "description" | "start_date" | "end_date">) =>
+    request<Trip>("/api/v1/trips", { method: "POST", body: JSON.stringify(data) }),
+  update: (id: string, data: Partial<Trip>) =>
+    request<Trip>(`/api/v1/trips/${id}`, { method: "PATCH", body: JSON.stringify(data) }),
+  delete: (id: string) => request<void>(`/api/v1/trips/${id}`, { method: "DELETE" }),
+  search: (q: string) => request<Trip[]>(`/api/v1/trips/search?q=${encodeURIComponent(q)}`),
+};
+
+// ── Trip Items ─────────────────────────────────────────────────────────────
+
+export type TripItem = {
+  id: string;
+  trip_id: string;
+  type: string;
+  title: string;
+  raw_text: string | null;
+  parsed_data: Record<string, unknown> | null;
+  event_at: string | null;
+  event_end_at: string | null;
+  booking_ref: string | null;
+  provider: string | null;
+  created_at: string;
+};
+
+export const itemsApi = {
+  list: (tripId: string) => request<TripItem[]>(`/api/v1/trips/${tripId}/items`),
+  delete: (tripId: string, itemId: string) =>
+    request<void>(`/api/v1/trips/${tripId}/items/${itemId}`, { method: "DELETE" }),
+};
+
+// ── Chaos Inbox ────────────────────────────────────────────────────────────
+
+export type InboxItem = {
+  id: string;
+  raw_content: string | null;
+  source: string | null;
+  status: string;
+  parsed_data: Record<string, unknown> | null;
+  created_at: string;
+};
+
+export const inboxApi = {
+  list: (status = "pending") => request<InboxItem[]>(`/api/v1/inbox?status_filter=${status}`),
+  assign: (inboxId: string, tripId: string, type = "other") =>
+    request<{ trip_item_id: string; title: string; event_at: string | null }>(`/api/v1/inbox/${inboxId}/assign`, {
+      method: "POST",
+      body: JSON.stringify({ trip_id: tripId, type }),
+    }),
+  reject: (inboxId: string) => request<void>(`/api/v1/inbox/${inboxId}`, { method: "DELETE" }),
+};
+
+// ── User / Plan ────────────────────────────────────────────────────────────
+
+export type UserPlan = {
+  id: string;
+  plan: "free" | "pro";
+  plan_expires_at: string | null;
+  free_daily_parses: number;
+  free_max_trips: number;
+  is_pro: boolean;
+  telegram_linked: boolean;
+};
+
+export const usersApi = {
+  me: () => request<UserPlan>("/api/v1/users/me"),
+  telegramPin: () => request<{ pin: string; expires_in_seconds: number }>("/api/v1/users/telegram-pin", { method: "POST" }),
+  telegramUnlink: () => request<{ ok: boolean }>("/api/v1/users/telegram-unlink", { method: "DELETE" }),
+};
+
+export type CacheStats = {
+  configured: boolean;
+  hits: number;
+  misses: number;
+  key_count: number;
+  hit_rate: number;
+  ttl_days: number;
+};
+
+export const cacheApi = {
+  stats: () => request<CacheStats>("/api/v1/cache/stats"),
+};
+
+// ── Parse ──────────────────────────────────────────────────────────────────
+
+export const mailApi = {
+  import: async (rawEmail: string, tripId?: string): Promise<unknown> => {
+    const token = await getAccessToken();
+    if (!token) throw new Error("Not authenticated");
+    const qs = tripId ? `?trip_id=${encodeURIComponent(tripId)}` : "";
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), PARSE_TIMEOUT_MS);
+    try {
+      const res = await fetch(`${BASE_URL}/api/v1/mail/import${qs}`, {
+        method: "POST",
+        headers: { Authorization: `Bearer ${token}`, "Content-Type": "text/plain" },
+        body: rawEmail,
+        signal: controller.signal,
+      });
+      if (!res.ok) {
+        const body = await res.text();
+        throw new ApiError(`Mail import failed: ${res.status}`, res.status, body);
+      }
+      return res.json();
+    } catch (err) {
+      if (err instanceof Error && err.name === "AbortError") {
+        throw new ApiError("Timeout: KI antwortet nicht", 408, "timeout");
+      }
+      throw err;
+    } finally {
+      clearTimeout(timer);
+    }
+  },
+};
+
+export async function parseFile(
+  fileUri: string,
+  mimeType: string,
+  fileName: string,
+  tripId?: string
+): Promise<unknown> {
+  const token = await getAccessToken();
+  if (!token) throw new Error("Not authenticated");
+
+  const form = new FormData();
+  form.append("file", { uri: fileUri, type: mimeType, name: fileName } as unknown as Blob);
+  if (tripId) form.append("trip_id", tripId);
+
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), PARSE_TIMEOUT_MS);
+  try {
+    const res = await fetch(`${BASE_URL}/api/v1/parse/file`, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${token}` },
+      body: form,
+      signal: controller.signal,
+    });
+    if (!res.ok) {
+      const body = await res.text();
+      throw new ApiError(`Parse failed: ${res.status}`, res.status, body);
+    }
+    return res.json();
+  } catch (err) {
+    if (err instanceof Error && err.name === "AbortError") {
+      throw new ApiError("Timeout: KI antwortet nicht", 408, "timeout");
+    }
+    throw err;
+  } finally {
+    clearTimeout(timer);
+  }
+}

package/apps/travel-chaos-organizer/frontend/lib/auth.ts

@@ -0,0 +1,93 @@
+import * as AuthSession from "expo-auth-session";
+import * as WebBrowser from "expo-web-browser";
+import AsyncStorage from "@react-native-async-storage/async-storage";
+
+// NOTE: maybeCompleteAuthSession() must also be called in app/auth.tsx
+// (the callback route). The call here is a belt-and-suspenders fallback.
+WebBrowser.maybeCompleteAuthSession();
+
+const KEYCLOAK_URL = process.env.EXPO_PUBLIC_KEYCLOAK_URL!;
+const REALM = process.env.EXPO_PUBLIC_KEYCLOAK_REALM!;
+const CLIENT_ID = process.env.EXPO_PUBLIC_KEYCLOAK_CLIENT_ID!;
+
+const discovery = {
+  authorizationEndpoint: `${KEYCLOAK_URL}/realms/${REALM}/protocol/openid-connect/auth`,
+  tokenEndpoint: `${KEYCLOAK_URL}/realms/${REALM}/protocol/openid-connect/token`,
+  revocationEndpoint: `${KEYCLOAK_URL}/realms/${REALM}/protocol/openid-connect/logout`,
+};
+
+const TOKEN_KEY = "tco_tokens";
+
+export let onAuthFailure: (() => void) | null = null;
+export function setAuthFailureCallback(cb: () => void) { onAuthFailure = cb; }
+
+export type Tokens = {
+  accessToken: string;
+  refreshToken: string;
+  expiresAt: number;
+};
+
+export async function login(): Promise<Tokens | null> {
+  const redirectUri = AuthSession.makeRedirectUri({ scheme: "tco", path: "auth" });
+  // Let expo-auth-session generate a cryptographically secure code verifier.
+  // Manual generation with Math.random() + BASE64 produces non-URL-safe chars
+  // (+, /, =) that are invalid in PKCE and cause Keycloak to reject the exchange.
+  const request = new AuthSession.AuthRequest({
+    clientId: CLIENT_ID,
+    redirectUri,
+    scopes: ["openid", "profile", "email", "offline_access"],
+    usePKCE: true,
+  });
+
+  const result = await request.promptAsync(discovery);
+  if (result.type !== "success") return null;
+
+  const tokenResult = await AuthSession.exchangeCodeAsync(
+    {
+      clientId: CLIENT_ID,
+      code: result.params.code,
+      redirectUri,
+      extraParams: { code_verifier: request.codeVerifier! },
+    },
+    discovery
+  );
+
+  const tokens: Tokens = {
+    accessToken: tokenResult.accessToken,
+    refreshToken: tokenResult.refreshToken!,
+    expiresAt: Date.now() + (tokenResult.expiresIn ?? 300) * 1000,
+  };
+  await AsyncStorage.setItem(TOKEN_KEY, JSON.stringify(tokens));
+  return tokens;
+}
+
+export async function getAccessToken(): Promise<string | null> {
+  const raw = await AsyncStorage.getItem(TOKEN_KEY);
+  if (!raw) return null;
+  const tokens: Tokens = JSON.parse(raw);
+
+  if (Date.now() < tokens.expiresAt - 30_000) return tokens.accessToken;
+
+  // refresh
+  try {
+    const refreshed = await AuthSession.refreshAsync(
+      { clientId: CLIENT_ID, refreshToken: tokens.refreshToken },
+      discovery
+    );
+    const updated: Tokens = {
+      accessToken: refreshed.accessToken,
+      refreshToken: refreshed.refreshToken ?? tokens.refreshToken,
+      expiresAt: Date.now() + (refreshed.expiresIn ?? 300) * 1000,
+    };
+    await AsyncStorage.setItem(TOKEN_KEY, JSON.stringify(updated));
+    return updated.accessToken;
+  } catch {
+    await AsyncStorage.removeItem(TOKEN_KEY);
+    onAuthFailure?.();
+    return null;
+  }
+}
+
+export async function logout(): Promise<void> {
+  await AsyncStorage.removeItem(TOKEN_KEY);
+}

package/apps/travel-chaos-organizer/frontend/lib/db.ts

@@ -0,0 +1,86 @@
+/**
+ * Local SQLite — offline mirror of trips and trip_items.
+ * Syncs from API when online, reads locally when offline.
+ */
+import * as SQLite from "expo-sqlite";
+import { Trip, TripItem } from "./api";
+
+const db = SQLite.openDatabaseSync("tco.db");
+
+export function initDb(): void {
+  db.execSync(`
+    CREATE TABLE IF NOT EXISTS trips (
+      id TEXT PRIMARY KEY,
+      user_id TEXT,
+      name TEXT NOT NULL,
+      description TEXT,
+      start_date TEXT,
+      end_date TEXT,
+      created_at TEXT,
+      updated_at TEXT,
+      synced_at INTEGER
+    );
+
+    CREATE TABLE IF NOT EXISTS trip_items (
+      id TEXT PRIMARY KEY,
+      trip_id TEXT NOT NULL,
+      type TEXT,
+      title TEXT,
+      raw_text TEXT,
+      parsed_data TEXT,
+      event_at TEXT,
+      event_end_at TEXT,
+      booking_ref TEXT,
+      provider TEXT,
+      created_at TEXT,
+      synced_at INTEGER
+    );
+  `);
+}
+
+export function upsertTrips(trips: Trip[]): void {
+  const now = Date.now();
+  for (const t of trips) {
+    db.runSync(
+      `INSERT OR REPLACE INTO trips
+        (id, user_id, name, description, start_date, end_date, created_at, updated_at, synced_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      [t.id, t.user_id, t.name, t.description ?? null, t.start_date ?? null,
+       t.end_date ?? null, t.created_at, t.updated_at, now]
+    );
+  }
+}
+
+export function upsertItems(items: TripItem[]): void {
+  const now = Date.now();
+  for (const i of items) {
+    db.runSync(
+      `INSERT OR REPLACE INTO trip_items
+        (id, trip_id, type, title, raw_text, parsed_data, event_at, event_end_at, booking_ref, provider, created_at, synced_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      [i.id, i.trip_id, i.type, i.title, i.raw_text ?? null,
+       i.parsed_data ? JSON.stringify(i.parsed_data) : null,
+       i.event_at ?? null, i.event_end_at ?? null, i.booking_ref ?? null,
+       i.provider ?? null, i.created_at, now]
+    );
+  }
+}
+
+export function getLocalTrips(): Trip[] {
+  return db.getAllSync<Trip>("SELECT * FROM trips ORDER BY start_date ASC");
+}
+
+export function deleteLocalItem(itemId: string): void {
+  db.runSync("DELETE FROM trip_items WHERE id = ?", [itemId]);
+}
+
+export function getLocalItems(tripId: string): TripItem[] {
+  const rows = db.getAllSync<Record<string, unknown>>(
+    "SELECT * FROM trip_items WHERE trip_id = ? ORDER BY event_at ASC",
+    [tripId]
+  );
+  return rows.map((r) => ({
+    ...r,
+    parsed_data: r.parsed_data ? JSON.parse(r.parsed_data as string) : null,
+  })) as TripItem[];
+}

package/apps/travel-chaos-organizer/frontend/lib/fileCache.ts

@@ -0,0 +1,54 @@
+/**
+ * Local file cache — downloads attachments and stores them in expo-file-system.
+ * Tickets, PDFs and QR-source files are available offline after first fetch.
+ */
+import * as FileSystem from "expo-file-system";
+
+const CACHE_DIR = `${FileSystem.documentDirectory}tco-cache/`;
+
+export async function ensureCacheDir(): Promise<void> {
+  const info = await FileSystem.getInfoAsync(CACHE_DIR);
+  if (!info.exists) await FileSystem.makeDirectoryAsync(CACHE_DIR, { intermediates: true });
+}
+
+function cacheKey(url: string): string {
+  // stable filename from URL — replace slashes/colons so it's a valid filename
+  return url.replace(/[^a-zA-Z0-9._-]/g, "_");
+}
+
+export async function getCachedPath(url: string): Promise<string | null> {
+  const path = CACHE_DIR + cacheKey(url);
+  const info = await FileSystem.getInfoAsync(path);
+  return info.exists ? path : null;
+}
+
+export async function downloadAndCache(
+  url: string,
+  authToken: string
+): Promise<string> {
+  await ensureCacheDir();
+  const path = CACHE_DIR + cacheKey(url);
+
+  const info = await FileSystem.getInfoAsync(path);
+  if (info.exists) return path;
+
+  const result = await FileSystem.downloadAsync(url, path, {
+    headers: { Authorization: `Bearer ${authToken}` },
+  });
+
+  if (result.status !== 200) {
+    await FileSystem.deleteAsync(path, { idempotent: true });
+    throw new Error(`Download failed: ${result.status}`);
+  }
+
+  return path;
+}
+
+export async function clearCache(): Promise<void> {
+  await FileSystem.deleteAsync(CACHE_DIR, { idempotent: true });
+}
+
+export async function cacheSizeBytes(): Promise<number> {
+  const info = await FileSystem.getInfoAsync(CACHE_DIR, { size: true });
+  return (info.exists && "size" in info) ? (info.size ?? 0) : 0;
+}

package/apps/travel-chaos-organizer/frontend/lib/haptics.ts

@@ -0,0 +1,13 @@
+/**
+ * Centralised haptic helpers — one import, consistent feel across the app.
+ * expo-haptics is a soft dependency; if unavailable (web/simulator) we no-op.
+ */
+import * as Haptics from "expo-haptics";
+
+export const haptics = {
+  tap: () => Haptics.impactAsync(Haptics.ImpactFeedbackStyle.Light),
+  confirm: () => Haptics.impactAsync(Haptics.ImpactFeedbackStyle.Medium),
+  success: () => Haptics.notificationAsync(Haptics.NotificationFeedbackType.Success),
+  error: () => Haptics.notificationAsync(Haptics.NotificationFeedbackType.Error),
+  warning: () => Haptics.notificationAsync(Haptics.NotificationFeedbackType.Warning),
+};