@getlimelight/sdk 0.1.1

package/dist/index.d.ts

@@ -0,0 +1,399 @@
+declare enum NetworkType {
+    FETCH = "fetch",
+    XHR = "xhr",
+    GRAPHQL = "graphql"
+}
+declare enum NetworkPhase {
+    CONNECT = "CONNECT",
+    REQUEST = "REQUEST",
+    RESPONSE = "RESPONSE",
+    ERROR = "ERROR"
+}
+declare enum BodyFormat {
+    TEXT = "TEXT",
+    JSON = "JSON",
+    FORM_DATA = "FORM_DATA",
+    BLOB = "BLOB",
+    ARRAY_BUFFER = "ARRAY_BUFFER",
+    NONE = "NONE",
+    UNSERIALIZABLE = "UNSERIALIZABLE"
+}
+declare enum HttpMethod {
+    GET = "GET",
+    POST = "POST",
+    PUT = "PUT",
+    PATCH = "PATCH",
+    DELETE = "DELETE",
+    HEAD = "HEAD",
+    OPTIONS = "OPTIONS",
+    TRACE = "TRACE",
+    CONNECT = "CONNECT"
+}
+declare enum HttpStatusClass {
+    INFORMATIONAL = 100,
+    SUCCESS = 200,
+    REDIRECTION = 300,
+    CLIENT_ERROR = 400,
+    SERVER_ERROR = 500
+}
+/**
+ * Normalized serialized body format
+ */
+interface SerializedBody {
+    format: BodyFormat;
+    size: number;
+    preview: string;
+    raw?: string;
+}
+/**
+ * Base shape all network events share
+ */
+interface BaseNetworkEvent {
+    id: string;
+    sessionId: string;
+    timestamp: number;
+    phase: NetworkPhase;
+    networkType: NetworkType;
+    graphql?: {
+        operationName?: string;
+        operationType?: GraphqlOprtation | null;
+        variables?: any;
+        query?: string;
+    };
+}
+/**
+ * The REQUEST event your RN client sends first
+ */
+interface NetworkRequest extends BaseNetworkEvent {
+    phase: NetworkPhase.REQUEST;
+    url: string;
+    method: HttpMethod;
+    headers: Record<string, string>;
+    body?: SerializedBody;
+    name: string;
+    initiator: string;
+    requestSize: number;
+}
+/**
+ * The RESPONSE event (2nd step)
+ */
+interface NetworkResponse extends BaseNetworkEvent {
+    phase: NetworkPhase.RESPONSE;
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    body?: SerializedBody;
+    duration: number;
+    responseSize: number;
+    redirected: boolean;
+    ok: boolean;
+}
+/**
+ * NETWORK ERROR (3rd possible outcome)
+ */
+interface NetworkErrorEvent extends BaseNetworkEvent {
+    phase: NetworkPhase.ERROR;
+    errorMessage: string;
+    stack?: string;
+}
+/**
+ * CONNECT event (session start)
+ */
+interface ConnectEvent {
+    phase: NetworkPhase.CONNECT;
+    sessionId: string;
+    timestamp: number;
+    data: {
+        appName: string;
+        platform: "ios" | "android";
+    };
+}
+declare enum EventType {
+    NETWORK = "NETWORK",
+    CONSOLE = "CONSOLE"
+}
+/**
+ * All possible events that can be sent over WebSocket
+ */
+type NetworkEvent = ConnectEvent | NetworkRequest | NetworkResponse | NetworkErrorEvent | GraphQLRequest | GraphQLResponse;
+type LimelightEvent = NetworkEvent | ConsoleEvent;
+interface Session {
+    id: string;
+    appName: string;
+    platform: "ios" | "android";
+    connectedAt: number;
+}
+/**
+ * Request with its corresponding response (for UI display)
+ */
+interface NetworkRequestWithResponse extends NetworkRequest {
+    response?: NetworkResponse;
+    status?: number;
+    duration?: number;
+    error?: NetworkErrorEvent;
+}
+/**
+ * Request with its corresponding response (for UI display)
+ */
+interface NetworkRequestWithResponse extends NetworkRequest {
+    response?: NetworkResponse;
+    status?: number;
+    duration?: number;
+}
+
+/**
+ * Console log levels
+ */
+declare enum ConsoleLevel {
+    LOG = "log",
+    WARN = "warn",
+    ERROR = "error",
+    INFO = "info",
+    DEBUG = "debug",
+    TRACE = "trace"
+}
+/**
+ * Where logs originate from
+ */
+declare enum ConsoleSource {
+    APP = "app",
+    LIBRARY = "library",
+    REACT_NATIVE = "react-native",
+    NATIVE = "native"
+}
+/**
+ * Type of console log
+ */
+declare enum ConsoleType {
+    EXCEPTION = "exception",
+    WARNING = "warning",
+    NETWORK = "network",
+    PERFORMANCE = "performance",
+    GENERAL = "general"
+}
+/**
+ * Console log event from the app
+ */
+interface ConsoleEvent {
+    id: string;
+    phase: "CONSOLE";
+    type: EventType.CONSOLE;
+    level: ConsoleLevel;
+    timestamp: number;
+    sessionId: string;
+    source: ConsoleSource;
+    consoleType: ConsoleType;
+    args: string[];
+    stackTrace?: string;
+}
+
+/**
+ * GRAPHQL EXTENSIONS
+ */
+interface GraphQLRequest extends NetworkRequest {
+    networkType: NetworkType.GRAPHQL;
+    query: string;
+    variables?: Record<string, any>;
+    operationName?: string;
+}
+/**
+ * GRAPHQL Response
+ */
+interface GraphQLResponse extends NetworkResponse {
+    networkType: NetworkType.GRAPHQL;
+    data?: any;
+    errors?: any[];
+}
+declare enum GraphqlOprtation {
+    QUERY = "QUERY",
+    MUTATION = "MUTATION",
+    SUB = "SUBSCRIPTION"
+}
+
+/**
+ * Configuration options for Limelight SDK.
+ *
+ * @example
+ * ```ts
+ * import { LimelightConfig } from "@limelight-sdk/sdk";
+ *
+ * const config: LimelightConfig = {
+ * appName: "MyReactNativeApp",
+ * enabled: true,
+ * enableNetworkInspector: true,
+ * enableConsole: true,
+ * enableGraphQL: false,
+ * disableBodyCapture: false,
+ * beforeSend: (event) => {
+ *  // Modify event or return null to drop the event
+ *  return event;
+ * },
+ * serverUrl: "ws://localhost:8080/limelight",
+ * };
+ * ```
+ */
+interface LimelightConfig {
+    /**
+     * The platform of the application (e.g., "ios", "android").
+     */
+    platform?: string;
+    /**
+     * The URL of the Limelight server to connect to.
+     */
+    serverUrl?: string;
+    /**
+     * The name of the application being monitored.
+     */
+    appName?: string;
+    /**
+     * Flag to enable or disable the Limelight SDK.
+     */
+    enabled?: boolean;
+    /**
+     * Flag to enable or disable network request inspection.
+     */
+    enableNetworkInspector?: boolean;
+    /**
+     * Flag to enable or disable console event capturing.
+     */
+    enableConsole?: boolean;
+    /**
+     * Flag to enable or disable GraphQL request capturing.
+     */
+    enableGraphQL?: boolean;
+    /**
+     * Flag to disable capturing of request and response bodies.
+     */
+    disableBodyCapture?: boolean;
+    /**
+     * A callback function to modify or filter events before they are sent to the server.
+     */
+    beforeSend?: (event: LimelightMessage) => LimelightMessage | null;
+}
+/**
+ * Represents a connection or disconnection event in the Limelight SDK.
+ */
+interface ConnectionEvent {
+    phase: "CONNECT" | "DISCONNECT";
+    sessionId: string;
+    timestamp: number;
+    data?: {
+        appName?: string;
+        platform?: string;
+        reason?: string;
+    };
+}
+/**
+ * Union type representing all possible Limelight messages.
+ */
+type LimelightMessage = NetworkRequest | NetworkResponse | NetworkErrorEvent | ConsoleEvent | ConnectionEvent;
+
+/**
+ * Represents a single frame in a stack trace.
+ */
+interface StackFrame {
+    fileName: string;
+    lineNumber?: number;
+    columnNumber?: number;
+    functionName?: string;
+    source: string;
+}
+/**
+ * Represents a parsed stack trace with its frames and raw string.
+ */
+interface ParsedStackTrace {
+    frames: StackFrame[];
+    raw: string;
+}
+
+declare class LimelightClient {
+    private ws;
+    private config;
+    private sessionId;
+    private reconnectAttempts;
+    private maxReconnectAttempts;
+    private reconnectDelay;
+    private reconnectTimer;
+    private messageQueue;
+    private maxQueueSize;
+    private networkInterceptor;
+    private xhrInterceptor;
+    private consoleInterceptor;
+    constructor();
+    /**
+     * Configures the Limelight client with the provided settings.
+     * Sets up network, XHR, and console interceptors based on the configuration.
+     * @internal
+     * @private
+     * @param {LimelightConfig} config - Configuration object for Limelight
+     * @returns {void}
+     */
+    private configure;
+    /**
+     * Establishes a WebSocket connection to the Limelight server.
+     * If a config object is provided, it will configure the client before connecting.
+     *
+     * If no config is provided and the client hasn't been configured, it will use default settings.
+     *
+     * Prevents multiple simultaneous connections and handles reconnection logic.
+     *
+     * @param {LimelightConfig} [config] - Optional configuration object.
+     * @returns {void}
+     */
+    connect(config?: LimelightConfig): void;
+    /**
+     * Attempts to reconnect to the Limelight server using exponential backoff.
+     * Will retry up to maxReconnectAttempts times with increasing delays.
+     * Maximum delay is capped at 30 seconds.
+     * @private
+     * @returns {void}
+     */
+    private attemptReconnect;
+    /**
+     * Sends all queued messages to the server.
+     * Only executes if the WebSocket connection is open.
+     * @private
+     * @returns {void}
+     */
+    private flushMessageQueue;
+    /**
+     * Sends a message to the Limelight server or queues it if not connected.
+     * Messages are automatically queued when the connection is not open.
+     * If the queue is full, the oldest message will be dropped.
+     * @private
+     * @param {LimelightMessage} message - The message to send
+     * @returns {void}
+     */
+    private sendMessage;
+    /**
+     * Disconnects from the Limelight server and cleans up resources.
+     * Closes the WebSocket connection, removes all interceptors, and resets connection state.
+     * Preserves configuration and session ID for potential reconnection.
+     * @returns {void}
+     */
+    disconnect(): void;
+    /**
+     * Performs a complete reset of the Limelight client.
+     * Disconnects from the server and clears all configuration and session data.
+     * After calling reset(), connect() must be called again.
+     * @returns {void}
+     */
+    reset(): void;
+}
+declare const Limelight: LimelightClient;
+
+declare global {
+    interface XMLHttpRequest {
+        _limelightData?: {
+            id: string;
+            method: string;
+            url: string;
+            headers: Record<string, string>;
+            startTime: number;
+            skipIntercept?: boolean;
+            listeners?: Map<string, EventListener>;
+        };
+    }
+}
+
+export { type BaseNetworkEvent, BodyFormat, type ConnectEvent, type ConnectionEvent, type ConsoleEvent, ConsoleLevel, ConsoleSource, ConsoleType, EventType, type GraphQLRequest, type GraphQLResponse, GraphqlOprtation, HttpMethod, HttpStatusClass, Limelight, type LimelightConfig, type LimelightEvent, type LimelightMessage, type NetworkErrorEvent, type NetworkEvent, NetworkPhase, type NetworkRequest, type NetworkRequestWithResponse, type NetworkResponse, NetworkType, type ParsedStackTrace, type SerializedBody, type Session, type StackFrame };