@robylon/react-native-sdk 2.2.1 → 2.2.3-staging.0

package/src/utils/errorHandler.ts

@@ -0,0 +1,58 @@
+import { logger } from "./logger";
+import { ErrorTypes } from "../constants/errorConstants";
+import { Platform } from "react-native";
+import { errorTracker } from "../services/ErrorTrackingService";
+
+// Global error handler for uncaught errors and promise rejections
+export const setupGlobalErrorHandlers = () => {
+  if (__DEV__) {
+    // Handle synchronous errors
+    const errorHandler = (error: Error, isFatal?: boolean) => {
+      errorTracker.trackError(error, "GlobalErrorHandler", {
+        isFatal,
+        type: ErrorTypes.RUNTIME_ERROR,
+        platform: Platform.OS,
+      });
+    };
+
+    // Handle promise rejections
+    const rejectionHandler = (event: any) => {
+      errorTracker.trackError(
+        event?.reason || new Error("Unknown Promise Error"),
+        "UnhandledPromiseRejection",
+        {
+          type: ErrorTypes.RUNTIME_ERROR,
+          platform: Platform.OS,
+        }
+      );
+    };
+
+    // Set up handlers
+    if ((global as any).ErrorUtils) {
+      const prevHandler = (global as any).ErrorUtils.getGlobalHandler();
+      (global as any).ErrorUtils.setGlobalHandler(
+        (error: Error, isFatal?: boolean) => {
+          errorHandler(error, isFatal);
+          prevHandler(error, isFatal);
+        }
+      );
+    }
+
+    // Handle promise rejections
+    const setupPromiseRejectionTracking = () => {
+      const tracking = require("promise/setimmediate/rejection-tracking");
+      tracking.enable({
+        allRejections: true,
+        onUnhandled: (id: number, error: Error) => {
+          rejectionHandler({ reason: error });
+        },
+      });
+    };
+
+    try {
+      setupPromiseRejectionTracking();
+    } catch (error) {
+      logger.warn("Promise rejection tracking setup failed:", error);
+    }
+  }
+};

package/src/utils/fileDownload.ts

@@ -0,0 +1,198 @@
+/**
+ * File: src/utils/fileDownload.ts
+ * Utility functions for handling file downloads
+ */
+
+import { Linking, NativeModules, Platform } from "react-native";
+import { logger } from "./logger";
+
+export interface DownloadRequest {
+  url: string;
+  filename?: string;
+  inPlace?: boolean;
+}
+
+const normalizeUrl = (url: string): string => {
+  return url?.trim();
+};
+
+const getUrlPathTail = (url?: string): string => {
+  const cleanedUrl = url?.split("?")?.[0] || "";
+  return cleanedUrl?.split("/")?.pop()?.trim() || "";
+};
+
+const getExtensionFromName = (name?: string): string => {
+  if (!name?.includes(".")) return "";
+  return name.substring(name.lastIndexOf("."));
+};
+
+const resolveDownloadFileName = (filename?: string, url?: string): string => {
+  const trimmedName = filename?.trim();
+  if (trimmedName) {
+    const sanitizedName = trimmedName.replace(/[<>:"/\\|?*\x00-\x1F]/g, "_");
+    const urlExtension = getExtensionFromName(getUrlPathTail(url));
+    if (getExtensionFromName(sanitizedName) || !urlExtension)
+      return sanitizedName;
+    return `${sanitizedName}${urlExtension}`;
+  }
+  const tailName = getUrlPathTail(url);
+  if (tailName) return tailName.replace(/[<>:"/\\|?*\x00-\x1F]/g, "_");
+  return `download-robylon-${Date.now()}`;
+};
+
+type RobylonDownloadNativeModule = {
+  downloadFile: (url: string, filename: string) => Promise<string>;
+};
+
+const isValidHttpUrl = (url: string): boolean => {
+  return /^https?:\/\//i.test(url);
+};
+
+const getNativeDownloadModule = (): RobylonDownloadNativeModule | null => {
+  return (
+    (NativeModules?.RobylonDownloadModule as RobylonDownloadNativeModule) ||
+    null
+  );
+};
+
+const openUrlWithFallback = async (url: string): Promise<void> => {
+  try {
+    await Linking.openURL(url);
+    return;
+  } catch (primaryError) {
+    logger.warn("Primary URL open failed, trying browser fallback", {
+      url,
+      primaryError:
+        primaryError instanceof Error
+          ? primaryError?.message
+          : String(primaryError),
+    });
+  }
+
+  await Linking.openURL(
+    `https://docs.google.com/viewer?url=${encodeURIComponent(url)}`,
+  );
+};
+
+const downloadOnAndroid = async (
+  url: string,
+  filename: string,
+): Promise<void> => {
+  const module = getNativeDownloadModule();
+  if (!module?.downloadFile) {
+    throw new Error("Robylon native download module is not linked on Android");
+  }
+  await module.downloadFile(url, filename);
+};
+
+const downloadOniOS = async (url: string, filename: string): Promise<void> => {
+  const module = getNativeDownloadModule();
+  if (!module?.downloadFile) {
+    throw new Error("Robylon native download module is not linked on iOS");
+  }
+  await module.downloadFile(url, filename);
+};
+
+const downloadWithNativeStorage = async (
+  url: string,
+  filename?: string,
+): Promise<void> => {
+  const safeName = resolveDownloadFileName(filename, url);
+  if (Platform.OS === "android") {
+    await downloadOnAndroid(url, safeName);
+    return;
+  }
+  if (Platform.OS === "ios") {
+    await downloadOniOS(url, safeName);
+    return;
+  }
+  await openUrlWithFallback(url);
+};
+
+const shouldUseInPlaceDownload = (
+  downloadRequest?: DownloadRequest,
+): boolean => {
+  return downloadRequest?.inPlace === true;
+};
+
+/**
+ * Downloads a file using native storage when possible
+ * @param url - The URL of the file to download
+ * @param filename - Optional filename for the download
+ */
+export const downloadFile = async (
+  url: string,
+  filename?: string,
+  inPlace?: boolean,
+): Promise<void> => {
+  try {
+    const normalizedUrl = normalizeUrl(url);
+    logger.debug("Initiating file download", { url: normalizedUrl, filename });
+
+    // Validate URL
+    if (!normalizedUrl || typeof normalizedUrl !== "string") {
+      throw new Error("Invalid URL provided for download");
+    }
+
+    if (!isValidHttpUrl(normalizedUrl)) {
+      throw new Error("Download URL must be an http/https URL");
+    }
+
+    if (inPlace) {
+      try {
+        await downloadWithNativeStorage(normalizedUrl, filename);
+        logger.debug("File downloaded with native storage flow");
+      } catch (nativeDownloadError) {
+        logger.warn("Native download failed, falling back to URL open", {
+          url: normalizedUrl,
+          nativeDownloadError:
+            nativeDownloadError instanceof Error
+              ? nativeDownloadError?.message
+              : String(nativeDownloadError),
+        });
+        await openUrlWithFallback(normalizedUrl);
+        logger.debug("File download opened with fallback browser flow");
+      }
+      return;
+    }
+
+    await openUrlWithFallback(normalizedUrl);
+    logger.debug("File download opened with legacy URL flow");
+  } catch (error) {
+    logger.error("File download failed", {
+      url,
+      filename,
+      error: error instanceof Error ? error?.message : String(error),
+    });
+    throw error;
+  }
+};
+
+/**
+ * Handles download request from WebView post message
+ * @param downloadRequest - The download request object
+ */
+export const handleDownloadRequest = async (
+  downloadRequest: DownloadRequest,
+): Promise<void> => {
+  const { url, filename } = downloadRequest;
+
+  if (!url) {
+    logger.error("Download request missing URL");
+    return;
+  }
+
+  try {
+    await downloadFile(
+      url,
+      filename,
+      shouldUseInPlaceDownload(downloadRequest),
+    );
+  } catch (error) {
+    logger.error("Failed to handle download request", {
+      downloadRequest,
+      error,
+    });
+    // Don't re-throw to avoid breaking the WebView message handling
+  }
+};

package/src/utils/logger.ts

@@ -0,0 +1,14 @@
+export const logger = {
+  error: (message: string, error?: any) => {
+    console.error(message, error);
+  },
+  info: (message: string, data?: any) => {
+    console.info(message, data);
+  },
+  warn: (message: string, data?: any) => {
+    console.warn(message, data);
+  },
+  debug: (message: string, data?: any) => {
+    console.log(message, data);
+  },
+};

package/src/utils/session.ts

@@ -0,0 +1,38 @@
+/**
+ * Session id pass-through between the chatbot web app and the SDK client.
+ *
+ * The session id travels on its own message type so that it never reaches
+ * `onEvent`, `onMessage` or the internal `/users/sdk/record-logs/` endpoint.
+ * Its only exits from the SDK are the `onSession` prop and `getSessionId()`
+ * on the ref, both of which the client has to opt into explicitly.
+ */
+
+/** Message the web app posts whenever the active session id changes. */
+export const SESSION_UPDATED_MESSAGE_TYPE = "SESSION_UPDATED";
+
+/** Key carrying the resume target inside the `registerUserId` payload. */
+export const RESUME_SESSION_KEY = "sessionId";
+
+/**
+ * Action the web app treats as an authoritative switch to another conversation.
+ *
+ * The resume target on `registerUserId` is only consulted while a session is
+ * being created, so re-sending it to a chat surface that has already booted
+ * arms a value nothing goes on to consume. A notification tap is exactly that
+ * case — the WebView is warm and usually showing a different conversation — so
+ * the switch travels as its own intent, which the web app answers by tearing
+ * down the conversation on screen and re-initializing on the target.
+ */
+export const SWITCH_SESSION_ACTION = "switch_session";
+
+/**
+ * Pulls the session id out of a `SESSION_UPDATED` payload.
+ *
+ * Accepts the snake_case, camelCase and nested spellings so a naming slip on
+ * the web side degrades to a no-op rather than a broken build. Anything that
+ * is not a non-empty string is dropped.
+ */
+export const extractSessionId = (data: any): string | undefined => {
+  const raw = data?.session_id ?? data?.sessionId ?? data?.session?.id;
+  return typeof raw === "string" && raw.length > 0 ? raw : undefined;
+};

package/src/utils/systemInfo.ts

@@ -0,0 +1,110 @@
+import { Platform, Dimensions, PixelRatio } from "react-native";
+import { SDK_VERSION } from "../version";
+
+interface ScreenSize {
+  width: number;
+  height: number;
+}
+
+interface SystemInfo {
+  platform: string;
+  os: string;
+  browser: string;
+  browser_version: string | null;
+  browser_language: string | null;
+  sdk_version: string;
+  device: string;
+  screen_size: ScreenSize;
+}
+
+// Get device type based on platform and screen dimensions
+const getDeviceType = (): string => {
+  const { width, height } = Dimensions.get("window");
+  const aspectRatio = height / width;
+
+  if (Platform.OS === "ios") {
+    return Platform.isPad ? "iPad" : "iPhone";
+  } else if (Platform.OS === "android") {
+    return aspectRatio < 1.6 ? "Android Tablet" : "Android Phone";
+  }
+  return "Desktop";
+};
+
+// Get screen dimensions with pixel ratio
+const getScreenSize = (): ScreenSize => {
+  return {
+    width: Math.round(Dimensions.get("window").width * PixelRatio.get()),
+    height: Math.round(Dimensions.get("window").height * PixelRatio.get()),
+  };
+};
+
+// Get browser detection script
+export const getBrowserAndOSInfoScript = (): string => {
+  return `
+    function getOSAndBrowser() {
+      const userAgent = navigator.userAgent;
+      
+      // OS Detection
+      let os = "unknown";
+      if (userAgent.indexOf("Win") !== -1) os = "Windows";
+      else if (userAgent.indexOf("Mac") !== -1) os = "MacOS";
+      else if (userAgent.indexOf("Linux") !== -1) os = "Linux";
+      else if (userAgent.indexOf("Android") !== -1) os = "Android";
+      else if (userAgent.indexOf("like Mac") !== -1) os = "iOS";
+
+      // Browser Detection
+      let browser = "unknown";
+      let browserVersion = null;
+      if (userAgent.indexOf("Chrome") !== -1) {
+        browser = "Chrome";
+        const chromeMatch = userAgent.match(/Chrome\\/([0-9.]+)/);
+        browserVersion = chromeMatch ? chromeMatch[1] : null;
+      } else if (userAgent.indexOf("Safari") !== -1) {
+        browser = "Safari";
+        const safariMatch = userAgent.match(/Version\\/([0-9.]+)/);
+        browserVersion = safariMatch ? safariMatch[1] : null;
+      } else if (userAgent.indexOf("Firefox") !== -1) {
+        browser = "Firefox";
+        const firefoxMatch = userAgent.match(/Firefox\\/([0-9.]+)/);
+        browserVersion = firefoxMatch ? firefoxMatch[1] : null;
+      } else if (userAgent.indexOf("Edge") !== -1) {
+        browser = "Edge";
+        const edgeMatch = userAgent.match(/Edge\\/([0-9.]+)/);
+        browserVersion = edgeMatch ? edgeMatch[1] : null;
+      } else if (userAgent.indexOf("MSIE") !== -1 || userAgent.indexOf("Trident/") !== -1) {
+        browser = "IE";
+        const ieMatch = userAgent.match(/(?:MSIE |rv:)([0-9.]+)/);
+        browserVersion = ieMatch ? ieMatch[1] : null;
+      }
+
+      // Browser Language
+      const browserLanguage = navigator.language || navigator.languages?.[0] || null;
+
+      window.ReactNativeWebView.postMessage(JSON.stringify({
+        type: 'SYSTEM_INFO',
+        data: { os, browser, browser_version: browserVersion, browser_language: browserLanguage }
+      }));
+    }
+    getOSAndBrowser();
+    true;
+  `;
+};
+
+// Get complete system information
+export const getSystemInfo = (webViewSystemInfo: {
+  os: string;
+  browser: string;
+  browser_version?: string | null;
+  browser_language?: string | null;
+}): SystemInfo => {
+  return {
+    platform: Platform.OS,
+    os: webViewSystemInfo.os || Platform.OS,
+    browser: webViewSystemInfo.browser || "WebView",
+    browser_version: webViewSystemInfo.browser_version || null,
+    browser_language: webViewSystemInfo.browser_language || null,
+    sdk_version: SDK_VERSION,
+    device: getDeviceType(),
+    screen_size: getScreenSize(),
+  };
+};

package/src/utils/webViewNavigation.ts

@@ -0,0 +1,132 @@
+/**
+ * File: src/utils/webViewNavigation.ts
+ * Decides which navigations stay inside the chatbot WebView and hands the rest
+ * to the OS.
+ *
+ * Returning `false` from `onShouldStartLoadWithRequest` only cancels the
+ * navigation: neither platform then falls back to the OS, so without this an
+ * external link (`https://…`) or an app handoff (`tel:`, `mailto:`) silently
+ * does nothing.
+ */
+
+import { Linking } from "react-native";
+import { logger } from "./logger";
+
+/**
+ * Schemes the WebView resolves against its own document. Handing these to
+ * `Linking` would only produce an "unsupported URL" error.
+ */
+const INTERNAL_SCHEMES = ["about:", "javascript:", "data:", "blob:"];
+
+/**
+ * Schemes that hand the URL to another app rather than rendering a document.
+ *
+ * The chat surface requests these from a detached iframe on purpose: the
+ * WebView cannot render them, so navigating the page itself would leave the
+ * user looking at an ERR_UNKNOWN_URL_SCHEME error instead of the conversation.
+ * That makes them the one kind of sub-frame navigation worth acting on.
+ */
+const APP_HANDOFF_SCHEMES = [
+  "tel:",
+  "sms:",
+  "mailto:",
+  "facetime:",
+  "whatsapp:",
+  "geo:",
+  "maps:",
+  "intent:",
+];
+
+/**
+ * What to pass as the WebView's `originWhitelist`.
+ *
+ * The library's default is http/https only, and it answers anything outside
+ * that itself — with a `canOpenURL` check that Android 11 makes fail for an
+ * installed dialer. So the handoff schemes are added to the default rather
+ * than the default being replaced: every other scheme keeps the library's
+ * handling, and this list cannot drift from the one above.
+ */
+export const CHATBOT_ORIGIN_WHITELIST: string[] = [
+  "http://*",
+  "https://*",
+  ...APP_HANDOFF_SCHEMES.map((scheme) => `${scheme}*`),
+];
+
+const isAppHandoffScheme = (url?: string): boolean => {
+  const lowerUrl = trimUrl(url)?.toLowerCase();
+  return !!APP_HANDOFF_SCHEMES?.some((scheme) => lowerUrl?.startsWith(scheme));
+};
+
+/** `hasTargetFrame` is sent by iOS but missing from the library's TS types. */
+export interface WebViewNavigationRequestLike {
+  url?: string;
+  isTopFrame?: boolean;
+  hasTargetFrame?: boolean;
+}
+
+const trimUrl = (url?: string): string => url?.trim() || "";
+
+const isInternalScheme = (url?: string): boolean => {
+  const lowerUrl = trimUrl(url)?.toLowerCase();
+  return !!INTERNAL_SCHEMES?.some((scheme) => lowerUrl?.startsWith(scheme));
+};
+
+const matchesAnyPrefix = (
+  url: string,
+  prefixes?: (string | undefined)[],
+): boolean =>
+  !!prefixes?.some((prefix) => !!prefix?.trim() && url?.startsWith(prefix));
+
+export const shouldLoadInChatbotWebView = (
+  request?: WebViewNavigationRequestLike,
+  chatbotUrlPrefixes?: (string | undefined)[],
+): boolean => matchesAnyPrefix(trimUrl(request?.url), chatbotUrlPrefixes);
+
+/**
+ * A sub-frame load is a resource the page pulled in — an embedded player, a
+ * tracking pixel — not a destination the user asked for, so it must not launch
+ * an app. A popup (`window.open`, `target="_blank"`) reports no target frame
+ * and is a real destination.
+ *
+ * Both flags are iOS-only; Android only reports frame-level navigations here.
+ */
+const isUserDestination = (request?: WebViewNavigationRequestLike): boolean =>
+  request?.isTopFrame !== false ||
+  request?.hasTargetFrame === false ||
+  // The chat surface asks for these from a hidden frame deliberately, so the
+  // sub-frame rule above would reject exactly the case it was written for. A
+  // pixel or embedded player is http(s) and is still rejected.
+  isAppHandoffScheme(request?.url);
+
+const canLeaveWebView = (request?: WebViewNavigationRequestLike): boolean =>
+  !!trimUrl(request?.url) &&
+  !isInternalScheme(request?.url) &&
+  isUserDestination(request);
+
+export const openUrlOutsideWebView = async (url?: string): Promise<boolean> => {
+  try {
+    await Linking.openURL(trimUrl(url));
+    return true;
+  } catch (error) {
+    logger.warn("Failed to open URL outside the WebView", {
+      url,
+      error: error instanceof Error ? error?.message : String(error),
+    });
+    return false;
+  }
+};
+
+/**
+ * Synchronous by contract: `onShouldStartLoadWithRequest` needs its answer
+ * immediately, so the external launch is fired off without being awaited.
+ */
+export const handleWebViewNavigationRequest = (
+  request?: WebViewNavigationRequestLike,
+  chatbotUrlPrefixes?: (string | undefined)[],
+): boolean => {
+  if (shouldLoadInChatbotWebView(request, chatbotUrlPrefixes)) return true;
+  if (!canLeaveWebView(request)) return false;
+  logger.debug("Opening navigation outside the WebView", { url: request?.url });
+  void openUrlOutsideWebView(request?.url);
+  return false;
+};

package/src/utils/webViewStorage.ts

@@ -0,0 +1,62 @@
+import { logger } from "./logger";
+
+export enum StorageMessageType {
+  GET_STORAGE = "GET_STORAGE",
+  SET_STORAGE = "SET_STORAGE",
+  STORAGE_READY = "STORAGE_READY",
+  STORAGE_ERROR = "STORAGE_ERROR",
+  STORAGE_RESPONSE = "STORAGE_RESPONSE",
+}
+
+export interface StorageMessage {
+  type: StorageMessageType;
+  key?: string;
+  value?: string;
+  error?: string;
+}
+
+export const getStorageScript = () => `
+  window.handleStorageOperation = function(message) {
+    try {
+      switch(message.type) {
+        case '${StorageMessageType.GET_STORAGE}':
+          const value = localStorage.getItem(message.key);
+          window.ReactNativeWebView.postMessage(JSON.stringify({
+            type: '${StorageMessageType.STORAGE_RESPONSE}',
+            key: message.key,
+            value: value
+          }));
+          break;
+        case '${StorageMessageType.SET_STORAGE}':
+          localStorage.setItem(message.key, message.value);
+          window.ReactNativeWebView.postMessage(JSON.stringify({
+            type: '${StorageMessageType.STORAGE_RESPONSE}',
+            key: message.key,
+            value: message.value
+          }));
+          break;
+      }
+    } catch (error) {
+      window.ReactNativeWebView.postMessage(JSON.stringify({
+        type: '${StorageMessageType.STORAGE_ERROR}',
+        error: error.message
+      }));
+    }
+  };
+
+  window.ReactNativeWebView.postMessage(JSON.stringify({
+    type: '${StorageMessageType.STORAGE_READY}'
+  }));
+`;
+
+export const createStorageMessage = (
+  type: StorageMessageType,
+  key?: string,
+  value?: string
+): string => {
+  return `window.handleStorageOperation(${JSON.stringify({
+    type,
+    key,
+    value,
+  })});`;
+};

package/src/version.ts

@@ -0,0 +1,2 @@
+// This file is auto-generated. Do not modify it manually.
+export { SDK_VERSION } from './versions/version.staging';

package/src/versions/version.dev.ts

@@ -0,0 +1,2 @@
+// This file is auto-generated. Do not modify it manually.
+export const SDK_VERSION = '2.0.22-dev.0';

package/src/versions/version.production.ts

@@ -0,0 +1,2 @@
+// This file is auto-generated. Do not modify it manually.
+export const SDK_VERSION = "0.0.0";

package/src/versions/version.staging.ts

@@ -0,0 +1,2 @@
+// This file is auto-generated. Do not modify it manually.
+export const SDK_VERSION = '2.2.3-staging.0';