@kavchat/react-native 0.0.0-stage → 0.0.2

package/lib/ui/KavchatProvider.js

@@ -0,0 +1,113 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState, useSyncExternalStore } from 'react';
+import { AppState, Linking } from 'react-native';
+import { KavchatController } from '../controller';
+import { defaultStorage } from '../storage';
+import { deviceLocale } from '../text';
+import { themeFor } from '../theme';
+const KavchatContext = createContext(null);
+export function KavchatProvider(props) {
+    const { publicKey, apiBase, locale, userToken, userName, onScreen, screens, onEvent, storage, theme, fetch, children } = props;
+    const controllerRef = useRef(null);
+    const keyRef = useRef('');
+    const key = `${publicKey}|${apiBase ?? ''}`;
+    if (!controllerRef.current || keyRef.current !== key) {
+        controllerRef.current?.dispose();
+        keyRef.current = key;
+        controllerRef.current = new KavchatController({
+            publicKey,
+            apiBase,
+            locale,
+            userToken: userToken || undefined,
+            userName: userName || undefined,
+            storage: storage ?? defaultStorage(),
+            deviceLocale: deviceLocale(),
+            screens,
+            fetch,
+        });
+    }
+    const controller = controllerRef.current;
+    // callbacks חדשים בכל רינדור לא בונים בקר חדש
+    controller.setCallbacks({
+        onScreen,
+        onEvent,
+        onLink: (url) => {
+            Linking.openURL(url).catch((e) => console.warn('Kavchat: cannot open link', e));
+        },
+    });
+    useEffect(() => {
+        void controller.load();
+        // לא dispose: ב-StrictMode האפקט רץ פעמיים על אותו בקר. רק שולחים את מה שנצבר
+        return () => {
+            void controller.flush();
+        };
+    }, [controller]);
+    useEffect(() => {
+        void controller.setUser({ token: userToken, name: userName });
+    }, [controller, userToken, userName]);
+    // מערך חדש בכל רינדור לא שולח שוב: משווים לפי התוכן
+    const screensKey = JSON.stringify(screens ?? null);
+    const firstScreens = useRef(true);
+    useEffect(() => {
+        // בבנייה הבקר כבר קיבל את המסכים
+        if (firstScreens.current) {
+            firstScreens.current = false;
+            return;
+        }
+        controller.registerScreens(screens);
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [controller, screensKey]);
+    useEffect(() => {
+        controller.setLocale(locale);
+    }, [controller, locale]);
+    // דיווח המסלול כשהאפליקציה עוברת לרקע, כי ייתכן שלא תחזור
+    useEffect(() => {
+        const sub = AppState.addEventListener('change', (s) => {
+            if (s === 'background' || s === 'inactive')
+                void controller.flush();
+        });
+        return () => sub.remove();
+    }, [controller]);
+    const snapshot = useSyncExternalStore(controller.subscribe, controller.getSnapshot, controller.getSnapshot);
+    const [isOpen, setOpen] = useState(false);
+    const open = useCallback(() => {
+        controller.ensureConversation();
+        setOpen(true);
+    }, [controller]);
+    const close = useCallback(() => setOpen(false), []);
+    const toggle = useCallback(() => (isOpen ? close() : open()), [isOpen, open, close]);
+    const primary = snapshot.release?.settings.primaryColor;
+    const themeKey = JSON.stringify(theme ?? null);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    const resolved = useMemo(() => themeFor(primary, theme), [primary, themeKey]);
+    const value = useMemo(() => ({ controller, snapshot, theme: resolved, isOpen: isOpen && snapshot.status === 'ready', open, close, toggle }), [controller, snapshot, resolved, isOpen, open, close, toggle]);
+    return _jsx(KavchatContext.Provider, { value: value, children: children });
+}
+export function useKavchatContext() {
+    const ctx = useContext(KavchatContext);
+    if (!ctx)
+        throw new Error('Kavchat: wrap your app with <KavchatProvider>');
+    return ctx;
+}
+/** ה-hook הציבורי: מצב הפתיחה, זמינות הבוט והחלפת משתמש */
+export function useKavchat() {
+    const { controller, snapshot, isOpen, open, close, toggle } = useKavchatContext();
+    return {
+        status: snapshot.status,
+        /** false כשהבוט כבוי, מוגבל למשתמשי בדיקה או שנגמרה המכסה. אז לא מציגים כניסה לצ'אט */
+        available: snapshot.status === 'ready',
+        offline: snapshot.offline,
+        locale: snapshot.locale,
+        isOpen,
+        open,
+        close,
+        toggle,
+        setUser: (user) => controller.setUser(user),
+        startNewConversation: () => controller.startFresh(),
+        openContactForm: (prefill) => {
+            open();
+            controller.openContactForm(prefill);
+        },
+        controller,
+    };
+}

package/package.json

@@ -1,6 +1,60 @@
 {
   "name": "@kavchat/react-native",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.0.2",
+  "description": "Kavchat for React Native: the scripted support chat as a provider, a chat screen and a floating launcher.",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "react-native": "src/index.ts",
+  "source": "src/index.ts",
+  "files": [
+    "src",
+    "lib",
+    "README.md"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@kavchat/core": "0.0.2"
+  },
+  "peerDependencies": {
+    "@react-native-async-storage/async-storage": ">=1.17.0",
+    "react": ">=18.0.0",
+    "react-native": ">=0.72.0"
+  },
+  "peerDependenciesMeta": {
+    "@react-native-async-storage/async-storage": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/react": "^19.1.1",
+    "react": "^19.3.0",
+    "react-native": "^0.88.0",
+    "typescript": "^5.9.3",
+    "vitest": "^5.0.5"
+  },
+  "keywords": [
+    "chatbot",
+    "customer-support",
+    "expo",
+    "kavchat",
+    "react-native",
+    "rtl",
+    "scripted-bot",
+    "support-chat"
+  ],
+  "homepage": "https://kavchat.com/docs",
+  "bugs": {
+    "email": "support@kavchat.com"
+  },
+  "author": "maxsave <support@kavchat.com>",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  }
+}

package/src/api.ts

@@ -0,0 +1,167 @@
+import type { ClientRelease, TranscriptEntry } from '@kavchat/core';
+
+/**
+ * קריאות ל-Client API, כמו בווידג'ט לאתר
+ * כלל CORS: בלי כותרות מותאמות (Cache-Control, Pragma וכו'). רק Authorization, Content-Type
+ * ו-If-None-Match, שהשרת מתיר. מניעת מטמון נעשית עם cache: 'no-store'
+ */
+
+export type FetchLike = (url: string, init?: Record<string, unknown>) => Promise<{
+  status: number;
+  ok: boolean;
+  headers: { get(name: string): string | null };
+  json(): Promise<unknown>;
+}>;
+
+export interface ApiConfig {
+  apiBase: string;
+  publicKey: string;
+  getToken: () => string | undefined;
+  /** להחלפה בבדיקות. ברירת מחדל: fetch הגלובלי של React Native */
+  fetch?: FetchLike;
+}
+
+export type DisabledRelease = { enabled: false; reason?: string };
+export type AnyRelease = ClientRelease | DisabledRelease;
+export type EnabledRelease = Extract<ClientRelease, { enabled: true }>;
+
+export type ReleaseResult =
+  | { kind: 'ok'; release: AnyRelease; etag: string }
+  | { kind: 'not-modified' }
+  /** מפתח שגוי או חסום: לא מציגים את הבוט */
+  | { kind: 'denied'; status: number }
+  /** אין רשת או שהשרת נפל: משתמשים בעותק השמור */
+  | { kind: 'offline' };
+
+export interface TicketInput {
+  message: string;
+  name?: string;
+  email?: string;
+  phone?: string;
+  topicId?: string;
+  scriptId?: string;
+  sessionId?: string;
+  transcript?: TranscriptEntry[];
+}
+
+export type TicketResult = { ok: true; id: string; number: number } | { ok: false; code: string; message: string };
+
+const endpoint = (c: ApiConfig, path: string) =>
+  `${c.apiBase.replace(/\/+$/, '')}/v1/client/${encodeURIComponent(c.publicKey)}/${path}`;
+
+function headers(c: ApiConfig, extra: Record<string, string> = {}): Record<string, string> {
+  const token = c.getToken();
+  return token ? { ...extra, Authorization: `Bearer ${token}` } : extra;
+}
+
+const doFetch = (c: ApiConfig): FetchLike => c.fetch ?? (globalThis.fetch as unknown as FetchLike);
+
+export async function fetchRelease(c: ApiConfig, etag?: string): Promise<ReleaseResult> {
+  let res: Awaited<ReturnType<FetchLike>>;
+  try {
+    res = await doFetch(c)(endpoint(c, 'release'), {
+      method: 'GET',
+      cache: 'no-store',
+      credentials: 'omit',
+      headers: headers(c, etag ? { 'If-None-Match': etag } : {}),
+    });
+  } catch {
+    return { kind: 'offline' };
+  }
+  if (res.status === 304) return { kind: 'not-modified' };
+  if (res.status >= 500 || res.status === 429) return { kind: 'offline' };
+  if (!res.ok) return { kind: 'denied', status: res.status };
+  const body = (await res.json().catch(() => null)) as { success?: boolean; data?: { enabled?: unknown } } | null;
+  if (!body || body.success !== true || !body.data || typeof body.data.enabled !== 'boolean') return { kind: 'offline' };
+  return { kind: 'ok', release: body.data as AnyRelease, etag: res.headers.get('ETag') || '' };
+}
+
+function postJson(c: ApiConfig, path: string, body: unknown, signal?: unknown) {
+  return doFetch(c)(endpoint(c, path), {
+    method: 'POST',
+    cache: 'no-store',
+    credentials: 'omit',
+    headers: headers(c, { 'Content-Type': 'application/json' }),
+    body: JSON.stringify(body),
+    ...(signal ? { signal } : {}),
+  });
+}
+
+export interface AiAnswer {
+  answer: string;
+  scriptId: string | null;
+}
+
+export const AI_TIMEOUT_MS = 20000;
+
+/**
+ * תשובת AI לשאלה שאין לה תסריט (פרימיום). כל כישלון, 429, זמן קצוב או answer: null מחזירים null,
+ * והצ'אט מציג את הודעת "לא נמצא" הרגילה
+ */
+export async function postAiAnswer(c: ApiConfig, sessionId: string, question: string, timeoutMs = AI_TIMEOUT_MS): Promise<AiAnswer | null> {
+  const ctrl = typeof AbortController === 'function' ? new AbortController() : null;
+  let timer: ReturnType<typeof setTimeout> | null = null;
+  const timeout = new Promise<null>((resolve) => {
+    timer = setTimeout(() => {
+      ctrl?.abort();
+      resolve(null);
+    }, timeoutMs);
+  });
+  const request = (async (): Promise<AiAnswer | null> => {
+    try {
+      const res = await postJson(c, 'ai/answer', { sessionId, question }, ctrl?.signal);
+      if (!res.ok) return null;
+      const body = (await res.json().catch(() => null)) as { success?: boolean; data?: { answer?: unknown; scriptId?: unknown } } | null;
+      const answer = body && body.success === true && body.data && typeof body.data.answer === 'string' ? body.data.answer.trim() : '';
+      if (!answer) return null;
+      const scriptId = typeof body!.data!.scriptId === 'string' && body!.data!.scriptId ? (body!.data!.scriptId as string) : null;
+      return { answer, scriptId };
+    } catch {
+      return null;
+    }
+  })();
+  try {
+    return await Promise.race([request, timeout]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+
+export async function postEvents(c: ApiConfig, payload: unknown): Promise<boolean> {
+  try {
+    const res = await postJson(c, 'events', payload);
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+
+export async function postTicket(c: ApiConfig, input: TicketInput): Promise<TicketResult> {
+  try {
+    const res = await postJson(c, 'tickets', input);
+    const body = (await res.json().catch(() => null)) as
+      | { success?: boolean; data?: { id?: unknown; number?: unknown }; code?: string; message?: string }
+      | null;
+    if (res.ok && body && body.success && body.data) return { ok: true, id: String(body.data.id), number: Number(body.data.number) };
+    return { ok: false, code: String(body?.code || `http_${res.status}`), message: String(body?.message || '') };
+  } catch {
+    return { ok: false, code: 'network', message: '' };
+  }
+}
+
+export interface ScreensPayload {
+  platform: 'react-native';
+  screens: { id: string; label: string; needsTarget: boolean }[];
+}
+
+/** רישום המסכים. הצלחה רק ב-200 עם success, כדי לא לשמור טביעה על תשובה חלקית */
+export async function postScreens(c: ApiConfig, payload: ScreensPayload): Promise<boolean> {
+  try {
+    const res = await postJson(c, 'screens', payload);
+    if (res.status !== 200) return false;
+    const body = (await res.json().catch(() => null)) as { success?: boolean } | null;
+    return !!body && body.success === true;
+  } catch {
+    return false;
+  }
+}