turbodesk-livechat-react-native 0.1.0-alpha.0

package/src/axios/axios.ts

@@ -0,0 +1,159 @@
+let _apiBaseUrl = "";
+let _getToken: (() => string | null | undefined) | null = null;
+
+export function setApiBaseUrl(url: string) {
+  _apiBaseUrl = url.replace(/\/+$/, "");
+}
+
+export function getApiBaseUrl(): string {
+  return _apiBaseUrl;
+}
+
+export function setTokenGetter(fn: () => string | null | undefined) {
+  _getToken = fn;
+}
+
+const joinUrl = (baseURL: string, path: string) => {
+  const base = baseURL.replace(/\/+$/, "");
+  const p = path.replace(/^\/+/, "");
+  return `${base}/${p}`;
+};
+
+export type RequestOptions = {
+  headers?: Record<string, string>;
+  params?: Record<string, string | number | boolean | undefined | null>;
+  signal?: AbortSignal;
+};
+
+const appendSearchParams = (
+  absoluteUrl: string,
+  params?: RequestOptions["params"]
+) => {
+  if (!params) return absoluteUrl;
+  const entries = Object.entries(params).filter(
+    ([, v]) => v !== undefined && v !== null
+  );
+  if (entries.length === 0) return absoluteUrl;
+  const sep = absoluteUrl.includes("?") ? "&" : "?";
+  const qs = entries
+    .map(([k, v]) => encodeURIComponent(k) + "=" + encodeURIComponent(String(v)))
+    .join("&");
+  return absoluteUrl + sep + qs;
+};
+
+const parseBody = async (res: Response): Promise<unknown> => {
+  const ct = res.headers.get("content-type") ?? "";
+  if (ct.includes("application/json")) {
+    const text = await res.text();
+    if (!text) return null;
+    try {
+      return JSON.parse(text) as unknown;
+    } catch {
+      return text;
+    }
+  }
+  return res.text();
+};
+
+type AuthRefreshFn = () => Promise<string | null | undefined>;
+type OnTokenRefreshedFn = (token: string | null | undefined) => void;
+
+let _authRefreshCallback: AuthRefreshFn | null = null;
+let _onTokenRefreshed: OnTokenRefreshedFn | null = null;
+
+export function registerAuthRefresh(
+  callback: AuthRefreshFn,
+  onTokenRefreshed: OnTokenRefreshedFn
+) {
+  _authRefreshCallback = callback;
+  _onTokenRefreshed = onTokenRefreshed;
+}
+
+export function unregisterAuthRefresh() {
+  _authRefreshCallback = null;
+  _onTokenRefreshed = null;
+}
+
+type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+
+async function request<T>(
+  method: HttpMethod,
+  path: string,
+  body?: unknown,
+  options?: RequestOptions,
+  isRetry = false
+): Promise<{ data: T }> {
+  const baseURL = getApiBaseUrl();
+  const url = appendSearchParams(joinUrl(baseURL, path), options?.params);
+  const token = _getToken?.() ?? null;
+
+  const headers: Record<string, string> = {
+    Accept: "application/json",
+    ...options?.headers,
+  };
+  if (token !== null) {
+    headers.Authorization = `Bearer ${token}`;
+  }
+  if (body !== undefined && method !== "GET" && method !== "DELETE") {
+    headers["Content-Type"] = "application/json";
+  }
+
+  let res: Response;
+  try {
+    res = await fetch(url, {
+      method,
+      headers,
+      signal: options?.signal,
+      body:
+        body !== undefined && method !== "GET" && method !== "DELETE"
+          ? JSON.stringify(body)
+          : undefined,
+    });
+  } catch {
+    throw Object.assign(new Error("Network error"), {
+      response: { status: 0, data: null },
+    });
+  }
+
+  if (res.status === 401 && !isRetry && _authRefreshCallback) {
+    const newToken = await _authRefreshCallback();
+    _onTokenRefreshed?.(newToken ?? null);
+    return request<T>(method, path, body, options, true);
+  }
+
+  if (res.status === 401 || res.status === 403) {
+    throw Object.assign(new Error(res.status === 401 ? "Unauthorized" : "Forbidden"), {
+      response: { status: res.status, data: null },
+    });
+  }
+
+  const data = (await parseBody(res)) as T;
+
+  if (!res.ok) {
+    throw Object.assign(new Error(`HTTP ${res.status}`), {
+      response: { status: res.status, data },
+    });
+  }
+
+  return { data };
+}
+
+export type ApiClient = {
+  get: <T>(path: string, options?: RequestOptions) => Promise<{ data: T }>;
+  post: <T>(path: string, body?: unknown, options?: RequestOptions) => Promise<{ data: T }>;
+  put: <T>(path: string, body?: unknown, options?: RequestOptions) => Promise<{ data: T }>;
+  patch: <T>(path: string, body?: unknown, options?: RequestOptions) => Promise<{ data: T }>;
+  delete: <T>(path: string, options?: RequestOptions) => Promise<{ data: T }>;
+};
+
+const client: ApiClient = {
+  get: (path, options) => request("GET", path, undefined, options),
+  post: (path, body, options) => request("POST", path, body, options),
+  put: (path, body, options) => request("PUT", path, body, options),
+  patch: (path, body, options) => request("PATCH", path, body, options),
+  delete: (path, options) => request("DELETE", path, undefined, options),
+};
+
+const getApiClient = (): ApiClient => client;
+
+export default getApiClient;

package/src/core/config.ts

@@ -0,0 +1,54 @@
+import type { LiveChatProviderProps } from "../provider/types";
+import { getOrCreateDeviceUserId } from "./identity";
+
+export type RuntimeConfig = {
+  widgetId: string;
+  apiBaseUrl: string;
+  userId?: string;
+  userToken?: string;
+  authCallback?: () => Promise<string | null | undefined>;
+  visitorProfile?: { name?: string; email?: string; phone?: string };
+};
+
+export function normalizeBaseUrl(url: string): string {
+  return url.replace(/\/+$/, "");
+}
+
+export function buildWsBaseUrl(apiBaseUrl: string): string {
+  return normalizeBaseUrl(apiBaseUrl)
+    .replace(/^https:\/\//i, "wss://")
+    .replace(/^http:\/\//i, "ws://");
+}
+
+export async function resolveConfig(
+  props: LiveChatProviderProps
+): Promise<RuntimeConfig> {
+  const widgetId = props.widgetId?.trim();
+  if (!widgetId) throw new Error("[LiveChat] widgetId is required");
+
+  const base = normalizeBaseUrl(props.apiBaseUrl);
+  const token = props.userToken?.trim();
+
+  if (token) {
+    return {
+      widgetId,
+      apiBaseUrl: base,
+      userId: props.userId?.trim() ?? "",
+      userToken: token,
+      authCallback: props.authCallback,
+      visitorProfile: props.visitorProfile,
+    };
+  }
+
+  const userId =
+    props.userId?.trim() || (await getOrCreateDeviceUserId(widgetId));
+
+  return {
+    widgetId,
+    apiBaseUrl: base,
+    userId,
+    userToken: undefined,
+    authCallback: props.authCallback,
+    visitorProfile: props.visitorProfile,
+  };
+}

package/src/core/http-client.ts

@@ -0,0 +1,136 @@
+export type RequestOptions = {
+  headers?: Record<string, string>;
+  params?: Record<string, string | number | boolean | undefined | null>;
+  signal?: AbortSignal;
+};
+
+type AuthRefreshFn = () => Promise<string | null | undefined>;
+type OnTokenRefreshedFn = (token: string | null | undefined) => void;
+
+let _apiBaseUrl = "";
+let _getToken: (() => string | null | undefined) | null = null;
+let _authRefreshCallback: AuthRefreshFn | null = null;
+let _onTokenRefreshed: OnTokenRefreshedFn | null = null;
+
+export function configureHttpClient(opts: {
+  apiBaseUrl: string;
+  getToken: () => string | null | undefined;
+}): void {
+  _apiBaseUrl = opts.apiBaseUrl.replace(/\/+$/, "");
+  _getToken = opts.getToken;
+}
+
+export function registerAuthRefresh(
+  callback: AuthRefreshFn,
+  onTokenRefreshed: OnTokenRefreshedFn
+): void {
+  _authRefreshCallback = callback;
+  _onTokenRefreshed = onTokenRefreshed;
+}
+
+export function unregisterAuthRefresh(): void {
+  _authRefreshCallback = null;
+  _onTokenRefreshed = null;
+}
+
+function joinUrl(base: string, p: string): string {
+  return base.replace(/\/+$/, "") + "/" + p.replace(/^\/+/, "");
+}
+
+function appendSearchParams(
+  absoluteUrl: string,
+  params?: RequestOptions["params"]
+): string {
+  if (!params) return absoluteUrl;
+  const entries = Object.entries(params).filter(
+    ([, v]) => v !== undefined && v !== null
+  );
+  if (entries.length === 0) return absoluteUrl;
+  const sep = absoluteUrl.includes("?") ? "&" : "?";
+  const qs = entries
+    .map(([k, v]) => encodeURIComponent(k) + "=" + encodeURIComponent(String(v)))
+    .join("&");
+  return absoluteUrl + sep + qs;
+}
+
+async function parseBody(res: Response): Promise<unknown> {
+  const ct = res.headers.get("content-type") ?? "";
+  if (ct.includes("application/json")) {
+    const text = await res.text();
+    if (!text) return null;
+    try { return JSON.parse(text) as unknown; } catch { return text; }
+  }
+  return res.text();
+}
+
+type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+
+async function doRequest<T>(
+  method: HttpMethod,
+  path: string,
+  body: unknown,
+  options: RequestOptions | undefined,
+  isRetry: boolean
+): Promise<{ data: T }> {
+  const baseURL = _apiBaseUrl;
+  const url = appendSearchParams(joinUrl(baseURL, path), options?.params);
+  const token = _getToken?.() ?? null;
+
+  const headers: Record<string, string> = {
+    Accept: "application/json",
+    ...options?.headers,
+  };
+  if (token) headers.Authorization = "Bearer " + token;
+  if (body !== undefined && method !== "GET" && method !== "DELETE") {
+    headers["Content-Type"] = "application/json";
+  }
+
+  let res: Response;
+  try {
+    res = await fetch(url, {
+      method,
+      headers,
+      signal: options?.signal,
+      body: body !== undefined && method !== "GET" && method !== "DELETE"
+        ? JSON.stringify(body) : undefined,
+    });
+  } catch {
+    const err = Object.assign(new Error("Network error"), { response: { status: 0, data: null } });
+    throw err;
+  }
+
+  if (res.status === 401 && !isRetry && _authRefreshCallback) {
+    const newToken = await _authRefreshCallback();
+    _onTokenRefreshed?.(newToken ?? null);
+    return doRequest<T>(method, path, body, options, true);
+  }
+
+  if (res.status === 401 || res.status === 403) {
+    const msg = res.status === 401 ? "Unauthorized" : "Forbidden";
+    throw Object.assign(new Error(msg), { response: { status: res.status, data: null } });
+  }
+
+  const data = (await parseBody(res)) as T;
+
+  if (!res.ok) {
+    throw Object.assign(new Error("HTTP " + res.status), { response: { status: res.status, data } });
+  }
+
+  return { data };
+}
+
+export type ApiClient = {
+  get: <T>(path: string, options?: RequestOptions) => Promise<{ data: T }>;
+  post: <T>(path: string, body?: unknown, options?: RequestOptions) => Promise<{ data: T }>;
+  put: <T>(path: string, body?: unknown, options?: RequestOptions) => Promise<{ data: T }>;
+  patch: <T>(path: string, body?: unknown, options?: RequestOptions) => Promise<{ data: T }>;
+  delete: <T>(path: string, options?: RequestOptions) => Promise<{ data: T }>;
+};
+
+export const apiClient: ApiClient = {
+  get: (path, options) => doRequest("GET", path, undefined, options, false),
+  post: (path, body, options) => doRequest("POST", path, body, options, false),
+  put: (path, body, options) => doRequest("PUT", path, body, options, false),
+  patch: (path, body, options) => doRequest("PATCH", path, body, options, false),
+  delete: (path, options) => doRequest("DELETE", path, undefined, options, false),
+};

package/src/core/identity.ts

@@ -0,0 +1,68 @@
+let AsyncStorage: {
+  getItem(k: string): Promise<string | null>;
+  setItem(k: string, v: string): Promise<void>;
+  removeItem(k: string): Promise<void>;
+} | null = null;
+
+try {
+  // Optional peer dep — import lazily so the package builds without it installed
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  AsyncStorage = require("@react-native-async-storage/async-storage").default;
+} catch {
+  AsyncStorage = null;
+}
+
+const storageKey = (widgetId: string) => `lcw_uid_${widgetId}`;
+
+function randomUserId(): string {
+  if (
+    typeof crypto !== "undefined" &&
+    typeof crypto.getRandomValues === "function"
+  ) {
+    const bytes = new Uint8Array(16);
+    crypto.getRandomValues(bytes);
+    return `fp_${Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join(
+      ""
+    )}`;
+  }
+  // Fallback for environments without crypto
+  return `fp_${Date.now().toString(16)}${Math.random().toString(16).slice(2)}`;
+}
+
+/**
+ * Returns the stored anonymous visitor id for this widgetId, creating one if absent.
+ * Async because AsyncStorage is async on React Native.
+ */
+export async function getOrCreateDeviceUserId(
+  widgetId: string
+): Promise<string> {
+  const key = storageKey(widgetId);
+
+  if (AsyncStorage) {
+    try {
+      const existing = await AsyncStorage.getItem(key);
+      if (existing) return existing;
+    } catch {
+      /* ignore storage errors */
+    }
+    const fresh = randomUserId();
+    try {
+      await AsyncStorage.setItem(key, fresh);
+    } catch {
+      /* ignore */
+    }
+    return fresh;
+  }
+
+  // No AsyncStorage — generate a non-persistent id (stays stable per process)
+  return randomUserId();
+}
+
+export async function clearStoredDeviceUserId(widgetId: string): Promise<void> {
+  if (!AsyncStorage) return;
+  try {
+    await AsyncStorage.removeItem(storageKey(widgetId));
+  } catch {
+    /* ignore */
+  }
+}

package/src/core/visitor-params.ts

@@ -0,0 +1,48 @@
+export type VisitorProfile = {
+  name?: string;
+  email?: string;
+  phone?: string;
+};
+
+export type VisitorQueryParams = Record<string, string>;
+
+export function buildVisitorQueryParams(opts: {
+  widgetId: string;
+  userId?: string;
+  userToken?: string;
+  visitorProfile?: VisitorProfile;
+}): VisitorQueryParams | null {
+  const { widgetId, userId, userToken, visitorProfile } = opts;
+  if (!widgetId?.trim()) return null;
+
+  const params: VisitorQueryParams = { widgetId: widgetId.trim() };
+  const token = userToken?.trim();
+
+  if (token) {
+    params.userToken = token;
+    const uid = userId?.trim();
+    if (uid) params.userId = uid;
+  } else {
+    const uid = userId?.trim();
+    if (!uid) return null;
+    params.userId = uid;
+  }
+
+  if (visitorProfile) {
+    const name = visitorProfile.name?.trim();
+    if (name) params.name = name.slice(0, 200);
+    const email = visitorProfile.email?.trim();
+    if (email) params.email = email;
+    const phone = visitorProfile.phone?.trim();
+    if (phone) params.phone = phone;
+  }
+
+  return params;
+}
+
+/** user-presence helper — mirrors web's user-presence.ts */
+export function getUserPresenceStatus(user: any): "active" | "away" | null {
+  const raw = user?.presence?.status;
+  if (raw === "active" || raw === "away") return raw;
+  return null;
+}

package/src/hooks/use-conversations.ts

@@ -0,0 +1,181 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { conversationApi } from "../api/conversation-api";
+import { useLiveChatContext } from "../provider/LiveChatContext";
+
+const PAGE_SIZE = 20;
+
+function pickConversations(raw: any): any[] {
+  if (!raw) return [];
+  const body = raw?.data !== undefined ? raw.data : raw;
+  const inner = body?.data !== undefined ? body.data : body;
+  if (Array.isArray(inner)) return inner;
+  if (Array.isArray(inner?.conversations)) return inner.conversations;
+  if (Array.isArray(body?.conversations)) return body.conversations;
+  return [];
+}
+
+function pickPagination(raw: any): { hasNextPage?: boolean; nextPage?: number } {
+  const body = raw?.data !== undefined ? raw.data : raw;
+  const inner = body?.data !== undefined ? body.data : body;
+  return inner?.pagination ?? body?.pagination ?? {};
+}
+
+function patchConversation(prev: any[], incoming: any): any[] {
+  if (!incoming?._id) return prev;
+  const idx = prev.findIndex((c) => c?._id === incoming._id);
+  if (idx > -1) {
+    const next = [...prev];
+    next[idx] = { ...next[idx], ...incoming };
+    return next;
+  }
+  return [incoming, ...prev];
+}
+
+export type UseConversationsResult = {
+  list: any[] | null;
+  loading: boolean;
+  loadingMore: boolean;
+  error: string | null;
+  hasNextPage: boolean;
+  conversationCount: number;
+  refresh: () => void;
+  loadMore: () => void;
+};
+
+function pickCount(raw: any): number {
+  const body = raw?.data ?? raw;
+  const inner = body?.data ?? body;
+  const v = inner?.count ?? inner?.total ?? 0;
+  return typeof v === "number" ? v : parseInt(v, 10) || 0;
+}
+
+export function useConversations(): UseConversationsResult {
+  const { wsClient, visitorQueryParams, setTotalUnread } = useLiveChatContext();
+
+  const [list, setList] = useState<any[] | null>(null);
+  const [loading, setLoading] = useState(true);
+  const [loadingMore, setLoadingMore] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const [hasNextPage, setHasNextPage] = useState(false);
+  const [conversationCount, setConversationCount] = useState(0);
+  const [refreshKey, setRefreshKey] = useState(0);
+
+  const currentPageRef = useRef(0);
+  const inFlightRef = useRef(false);
+
+  useEffect(() => {
+    if (!visitorQueryParams) {
+      setList(null);
+      setLoading(false);
+      setError(null);
+      setHasNextPage(false);
+      return;
+    }
+    const ac = new AbortController();
+    setList(null);
+    setLoading(true);
+    setError(null);
+    setHasNextPage(false);
+    currentPageRef.current = 0;
+
+    (async () => {
+      try {
+        const [raw, countRaw] = await Promise.all([
+          conversationApi.getConversations({
+            params: { ...visitorQueryParams, page: 1, limit: PAGE_SIZE },
+            signal: ac.signal,
+          }),
+          conversationApi.getConversationCount(visitorQueryParams),
+        ]);
+        if (ac.signal.aborted) return;
+        setList(pickConversations(raw));
+        const p = pickPagination(raw);
+        setHasNextPage(!!p.hasNextPage);
+        currentPageRef.current = 1;
+        setConversationCount(pickCount(countRaw));
+      } catch (e: any) {
+        if (ac.signal.aborted || e?.name === "AbortError") return;
+        setError("Could not load conversations. Pull to refresh.");
+        setList(null);
+      } finally {
+        if (!ac.signal.aborted) setLoading(false);
+      }
+    })();
+
+    return () => ac.abort();
+  }, [visitorQueryParams, refreshKey]);
+
+  const loadMore = useCallback(async () => {
+    if (inFlightRef.current || !hasNextPage || !visitorQueryParams) return;
+    inFlightRef.current = true;
+    setLoadingMore(true);
+    const nextPage = currentPageRef.current + 1;
+    try {
+      const raw = await conversationApi.getConversations({
+        params: { ...visitorQueryParams, page: nextPage, limit: PAGE_SIZE },
+      });
+      const rows = pickConversations(raw);
+      const p = pickPagination(raw);
+      setList((prev) => (prev ? [...prev, ...rows] : rows));
+      setHasNextPage(!!p.hasNextPage);
+      currentPageRef.current = nextPage;
+    } catch {
+      /* ignore load-more errors */
+    } finally {
+      inFlightRef.current = false;
+      setLoadingMore(false);
+    }
+  }, [hasNextPage, visitorQueryParams]);
+
+  const refresh = useCallback(() => setRefreshKey((k) => k + 1), []);
+
+  // ── WS event handlers ──────────────────────────────────────────────────────
+  useEffect(() => {
+    if (!wsClient) return;
+
+    const handleNewMessage = (payload: any) => {
+      const data = payload?.data ?? payload;
+      const conv = data?.conversation;
+      const msg = data?.message;
+      if (!conv?._id) return;
+      setList((prev) => {
+        if (!prev) return prev;
+        const idx = prev.findIndex((c) => c?._id === conv._id);
+        const updated = {
+          ...(idx > -1 ? prev[idx] : conv),
+          latestMessageId: msg,
+          latestMessageAt: conv?.latestMessageAt,
+          livechat: {
+            visitorUnreadCount: conv?.livechat?.visitorUnreadCount,
+            ...conv?.livechat,
+          },
+          hasUnreadMessages: (conv?.livechat?.visitorUnreadCount ?? 0) > 0,
+          userUnreadCount: conv?.userUnreadCount,
+        };
+        if (idx > -1) {
+          const next = [...prev];
+          next[idx] = updated;
+          return next;
+        }
+        return [updated, ...prev];
+      });
+    };
+
+    const patchHandler = (payload: any) => {
+      const data = payload?.data ?? payload;
+      const incoming = data?.conversation;
+      if (!incoming?._id) return;
+      setList((prev) => (prev ? patchConversation(prev, incoming) : prev));
+    };
+
+    const u1 = wsClient.subscribe("new_livechat_message", handleNewMessage);
+    const u2 = wsClient.subscribe("conversation_intervened", patchHandler);
+    const u3 = wsClient.subscribe("conversation_unassigned", patchHandler);
+    const u4 = wsClient.subscribe("conversation_transferred", patchHandler);
+    const u5 = wsClient.subscribe("conversation_resolved", patchHandler);
+
+    return () => { u1(); u2(); u3(); u4(); u5(); };
+  }, [wsClient]);
+
+  return { list, loading, loadingMore, error, hasNextPage, conversationCount, refresh, loadMore };
+}