@getlimelight/sdk 0.3.0 → 0.4.0

package/dist/index.js

@@ -258,7 +258,7 @@ var SENSITIVE_HEADERS = [
 var LIMELIGHT_WEB_WSS_URL = "wss://api.getlimelight.io";
 var LIMELIGHT_DESKTOP_WSS_URL = "ws://localhost:8484";
 var WS_PATH = "/limelight";
-var SDK_VERSION = true ? "0.3.0" : "test-version";
+var SDK_VERSION = true ? "0.4.0" : "test-version";
 var RENDER_THRESHOLDS = {
   HOT_VELOCITY: 5,
   HIGH_RENDER_COUNT: 50,
@@ -287,11 +287,11 @@ var redactSensitiveHeaders = (headers) => {
 // src/helpers/safety/safeStringify.ts
 var safeStringify = (value, maxDepth = 10, pretty = false) => {
   const seen = /* @__PURE__ */ new WeakMap();
-  const process2 = (val, currentDepth) => {
+  const process2 = (val, currentDepth, path) => {
     if (val === null) return null;
     if (val === void 0) return "[undefined]";
     if (typeof val === "bigint") return `${val}n`;
-    if (typeof val === "symbol") return val.toString();
+    if (typeof val === "symbol") return `[Symbol: ${val.description || ""}]`;
     if (typeof val === "function") {
       return `[Function: ${val.name || "anonymous"}]`;
     }
@@ -299,52 +299,113 @@ var safeStringify = (value, maxDepth = 10, pretty = false) => {
     if (currentDepth >= maxDepth) {
       return "[Max Depth]";
     }
-    if (seen.has(val)) {
-      return "[Circular]";
+    const seenPath = seen.get(val);
+    if (seenPath !== void 0) {
+      return `[Circular \u2192 ${seenPath}]`;
     }
-    seen.set(val, true);
+    seen.set(val, path || "root");
     if (val instanceof Error) {
       return {
         __type: "Error",
         name: val.name,
         message: val.message,
-        stack: val.stack
+        stack: val.stack,
+        ...Object.fromEntries(
+          Object.entries(val).filter(
+            ([k]) => !["name", "message", "stack"].includes(k)
+          )
+        )
       };
     }
     if (val instanceof Date) {
-      return val.toISOString();
+      return { __type: "Date", value: val.toISOString() };
     }
     if (val instanceof RegExp) {
-      return val.toString();
+      return { __type: "RegExp", value: val.toString() };
     }
     if (val instanceof Map) {
-      const obj = {};
-      val.forEach((v, k) => {
-        const key = typeof k === "string" ? k : String(k);
-        obj[key] = process2(v, currentDepth + 1);
-      });
-      return obj;
+      return {
+        __type: "Map",
+        size: val.size,
+        entries: Array.from(val.entries()).map(([k, v], i) => [
+          process2(k, currentDepth + 1, `${path}.Map[${i}].key`),
+          process2(v, currentDepth + 1, `${path}.Map[${i}].value`)
+        ])
+      };
     }
     if (val instanceof Set) {
-      return Array.from(val).map((v) => process2(v, currentDepth + 1));
+      return {
+        __type: "Set",
+        size: val.size,
+        values: Array.from(val).map(
+          (v, i) => process2(v, currentDepth + 1, `${path}.Set[${i}]`)
+        )
+      };
+    }
+    if (val instanceof WeakMap) {
+      return { __type: "WeakMap", note: "[Contents not enumerable]" };
+    }
+    if (val instanceof WeakSet) {
+      return { __type: "WeakSet", note: "[Contents not enumerable]" };
+    }
+    if (val instanceof Promise) {
+      return { __type: "Promise", note: "[Pending state not accessible]" };
+    }
+    if (val instanceof ArrayBuffer) {
+      return { __type: "ArrayBuffer", byteLength: val.byteLength };
     }
     if (ArrayBuffer.isView(val)) {
-      return `[${val.constructor.name}(${val.length})]`;
+      const typedArray = val;
+      return {
+        __type: val.constructor.name,
+        length: typedArray.length ?? typedArray.byteLength,
+        preview: typedArray.length <= 10 ? Array.from(typedArray.slice?.(0, 10) ?? []) : `[${typedArray.length} items]`
+      };
+    }
+    if (typeof URL !== "undefined" && val instanceof URL) {
+      return { __type: "URL", href: val.href };
+    }
+    if (typeof URLSearchParams !== "undefined" && val instanceof URLSearchParams) {
+      return {
+        __type: "URLSearchParams",
+        entries: Object.fromEntries(val.entries())
+      };
+    }
+    if (val && typeof val.$$typeof === "symbol" && String(val.$$typeof).includes("react.element")) {
+      return {
+        __type: "ReactElement",
+        type: typeof val.type === "function" ? val.type.name || "Component" : val.type || "unknown",
+        key: val.key
+      };
     }
     if (Array.isArray(val)) {
-      return val.map((item) => process2(item, currentDepth + 1));
+      return val.map(
+        (item, i) => process2(item, currentDepth + 1, `${path}[${i}]`)
+      );
     }
     const result = {};
+    const proto = Object.getPrototypeOf(val);
+    if (proto && proto.constructor && proto.constructor.name !== "Object") {
+      result.__type = proto.constructor.name;
+    }
     for (const key in val) {
       if (Object.prototype.hasOwnProperty.call(val, key)) {
-        result[key] = process2(val[key], currentDepth + 1);
+        try {
+          result[key] = process2(
+            val[key],
+            currentDepth + 1,
+            `${path}.${key}`
+          );
+        } catch (e) {
+          result[key] = `[Error accessing property: ${e instanceof Error ? e.message : String(e)}]`;
+        }
       }
     }
     return result;
   };
   try {
-    const processed = process2(value, 0);
-    return JSON.stringify(processed, null, pretty ? 2 : 0);
+    const processed = process2(value, 0, "root");
+    return JSON.stringify(processed, null, pretty ? 2 : void 0);
   } catch (error) {
     return JSON.stringify({
       __error: "Stringification failed",
@@ -507,7 +568,9 @@ var ConsoleInterceptor = class {
    */
   setup(config) {
     if (this.isSetup) {
-      console.warn("[Limelight] Console interceptor already set up");
+      if (this.config?.internalLoggingEnabled) {
+        console.warn("[Limelight] Console interceptor already set up");
+      }
       return;
     }
     this.isSetup = true;
@@ -591,7 +654,9 @@ var ConsoleInterceptor = class {
    */
   cleanup() {
     if (!this.isSetup) {
-      console.warn("[Limelight] Console interceptor not set up");
+      if (this.config?.internalLoggingEnabled) {
+        console.warn("[Limelight] Console interceptor not set up");
+      }
       return;
     }
     this.isSetup = false;
@@ -631,7 +696,9 @@ var NetworkInterceptor = class {
    */
   setup(config) {
     if (this.isSetup) {
-      console.warn("[Limelight] Network interceptor already set up");
+      if (this.config?.internalLoggingEnabled) {
+        console.warn("[Limelight] Network interceptor already set up");
+      }
       return;
     }
     this.isSetup = true;
@@ -667,9 +734,11 @@ var NetworkInterceptor = class {
           }
         } catch {
           requestBodyToSerialize = void 0;
-          console.warn(
-            "[Limelight] Failed to read request body from Request object"
-          );
+          if (self.config?.internalLoggingEnabled) {
+            console.warn(
+              "[Limelight] Failed to read request body from Request object"
+            );
+          }
         }
       }
       const requestBody = serializeBody(
@@ -786,7 +855,9 @@ var NetworkInterceptor = class {
    */
   cleanup() {
     if (!this.isSetup) {
-      console.warn("[Limelight] Network interceptor not set up");
+      if (this.config?.internalLoggingEnabled) {
+        console.warn("[Limelight] Network interceptor not set up");
+      }
       return;
     }
     this.isSetup = false;
@@ -817,7 +888,9 @@ var XHRInterceptor = class {
    */
   setup(config) {
     if (this.isSetup) {
-      console.warn("[Limelight] XHR interceptor already set up");
+      if (this.config?.internalLoggingEnabled) {
+        console.warn("[Limelight] XHR interceptor already set up");
+      }
       return;
     }
     this.isSetup = true;
@@ -1029,7 +1102,9 @@ var XHRInterceptor = class {
    */
   cleanup() {
     if (!this.isSetup) {
-      console.warn("[Limelight] XHR interceptor not set up");
+      if (this.config?.internalLoggingEnabled) {
+        console.warn("[Limelight] XHR interceptor not set up");
+      }
       return;
     }
     this.isSetup = false;
@@ -1061,12 +1136,16 @@ var RenderInterceptor = class {
   }
   setup(config) {
     if (this.isSetup) {
-      console.warn("[Limelight] Render interceptor already set up");
+      if (this.config?.internalLoggingEnabled) {
+        console.warn("[Limelight] Render interceptor already set up");
+      }
       return;
     }
     this.config = config;
     if (!this.installHook()) {
-      console.warn("[Limelight] Failed to install render hook");
+      if (this.config?.internalLoggingEnabled) {
+        console.warn("[Limelight] Failed to install render hook");
+      }
       return;
     }
     this.snapshotTimer = setInterval(() => {
@@ -1074,6 +1153,12 @@ var RenderInterceptor = class {
     }, RENDER_THRESHOLDS.SNAPSHOT_INTERVAL_MS);
     this.isSetup = true;
   }
+  resetProfiles() {
+    this.profiles.clear();
+    this.pendingUnmounts = [];
+    this.currentCommitComponents.clear();
+    this.componentIdCounter = 0;
+  }
   installHook() {
     const globalObj = typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : null;
     if (!globalObj) return false;
@@ -1129,7 +1214,7 @@ var RenderInterceptor = class {
       this.countRenderedComponents(root.current);
       this.walkFiberTree(root.current, null, 0);
     } catch (error) {
-      if (isDevelopment()) {
+      if (this.config?.internalLoggingEnabled) {
         console.warn("[Limelight] Error processing fiber tree:", error);
       }
     }
@@ -1594,6 +1679,259 @@ var RenderInterceptor = class {
   }
 };
 
+// src/limelight/interceptors/StateInterceptor.ts
+var StateInterceptor = class {
+  sendMessage;
+  getSessionId;
+  stores = /* @__PURE__ */ new Map();
+  config = null;
+  constructor(sendMessage, getSessionId) {
+    this.sendMessage = sendMessage;
+    this.getSessionId = getSessionId;
+  }
+  setup(config) {
+    this.config = config;
+    if (!config.stores) return;
+    if (config.enableStateInspector === false) return;
+    for (const [name, store] of Object.entries(config.stores)) {
+      this.registerStore(name, store);
+    }
+  }
+  /**
+   * Register a store for inspection.
+   * Can be called manually via Limelight.addStore() for dynamic registration.
+   */
+  registerStore(name, store) {
+    if (this.stores.has(name)) {
+      console.warn(`[Limelight] Store "${name}" already registered`);
+      return;
+    }
+    const library = this.detectLibrary(store);
+    if (!library) {
+      console.warn(
+        `[Limelight] Could not detect store type for "${name}". Expected Zustand or Redux store.`
+      );
+      return;
+    }
+    const state = this.getState(store, library);
+    const initEvent = {
+      phase: "STATE:INIT" /* INIT */,
+      sessionId: this.getSessionId(),
+      timestamp: Date.now(),
+      data: {
+        storeId: name,
+        library,
+        state
+      }
+    };
+    this.emitEvent(initEvent);
+    const unsubscribe = this.subscribe(store, library, name);
+    this.stores.set(name, { name, library, unsubscribe });
+  }
+  /**
+   * Unregister a store and stop listening to changes.
+   */
+  unregisterStore(name) {
+    const store = this.stores.get(name);
+    if (store) {
+      store.unsubscribe();
+      this.stores.delete(name);
+    }
+  }
+  /**
+   * Emit an event, applying beforeSend hook if configured
+   */
+  emitEvent(event) {
+    if (this.config?.beforeSend) {
+      const modifiedEvent = this.config.beforeSend(event);
+      if (!modifiedEvent) {
+        return;
+      }
+      if (modifiedEvent.phase !== "STATE:INIT" /* INIT */ && modifiedEvent.phase !== "STATE:UPDATE" /* UPDATE */) {
+        console.error("[Limelight] beforeSend must return same event type");
+        return;
+      }
+      this.sendMessage(modifiedEvent);
+    } else {
+      this.sendMessage(event);
+    }
+  }
+  /**
+   * Detect whether a store is Zustand or Redux
+   */
+  detectLibrary(store) {
+    if (!store || typeof store !== "function" && typeof store !== "object") {
+      return null;
+    }
+    if (typeof store === "object" && "dispatch" in store && "getState" in store && "subscribe" in store && typeof store.dispatch === "function") {
+      return "redux" /* REDUX */;
+    }
+    if (typeof store === "function" && "getState" in store && "subscribe" in store && typeof store.getState === "function") {
+      return "zustand" /* ZUSTAND */;
+    }
+    if (typeof store === "object" && "getState" in store && "setState" in store && "subscribe" in store && !("dispatch" in store)) {
+      return "zustand" /* ZUSTAND */;
+    }
+    return null;
+  }
+  /**
+   * Get current state from a store
+   */
+  getState(store, library) {
+    const storeAny = store;
+    return storeAny.getState();
+  }
+  /**
+   * Subscribe to store changes
+   */
+  subscribe(store, library, storeName) {
+    const storeAny = store;
+    if (library === "zustand" /* ZUSTAND */) {
+      return this.subscribeZustand(storeAny, storeName);
+    } else {
+      return this.subscribeRedux(storeAny, storeName);
+    }
+  }
+  /**
+   * Subscribe to Zustand store changes
+   */
+  subscribeZustand(store, storeName) {
+    return store.subscribe((state, prevState) => {
+      const action = this.inferZustandAction(state, prevState);
+      const stackTrace = this.captureStackTrace();
+      const updateEvent = {
+        phase: "STATE:UPDATE" /* UPDATE */,
+        sessionId: this.getSessionId(),
+        timestamp: Date.now(),
+        data: {
+          storeId: storeName,
+          library: "zustand" /* ZUSTAND */,
+          state,
+          action,
+          stackTrace
+        }
+      };
+      this.emitEvent(updateEvent);
+    });
+  }
+  /**
+   * Subscribe to Redux store changes
+   */
+  subscribeRedux(store, storeName) {
+    let lastAction = { type: "@@INIT" };
+    const originalDispatch = store.dispatch;
+    store.dispatch = (action) => {
+      lastAction = {
+        type: action?.type || "unknown",
+        payload: action?.payload
+      };
+      return originalDispatch(action);
+    };
+    const unsubscribe = store.subscribe(() => {
+      const newState = store.getState();
+      const stackTrace = this.captureStackTrace();
+      const updateEvent = {
+        phase: "STATE:UPDATE" /* UPDATE */,
+        sessionId: this.getSessionId(),
+        timestamp: Date.now(),
+        data: {
+          storeId: storeName,
+          library: "redux" /* REDUX */,
+          state: newState,
+          action: lastAction,
+          stackTrace
+        }
+      };
+      this.emitEvent(updateEvent);
+    });
+    return () => {
+      unsubscribe();
+      store.dispatch = originalDispatch;
+    };
+  }
+  /**
+   * Infer action name from stack trace for Zustand
+   */
+  inferZustandAction(state, prevState) {
+    const actionType = this.parseActionFromStack(this.captureStackTrace());
+    const payload = this.computePartialState(state, prevState);
+    return {
+      type: actionType,
+      payload
+    };
+  }
+  /**
+   * Parse function name from stack trace
+   */
+  parseActionFromStack(stack) {
+    if (!stack) return "set";
+    const lines = stack.split("\n");
+    for (const line of lines) {
+      if (line.includes("node_modules/zustand")) continue;
+      if (line.includes("node_modules/immer")) continue;
+      if (line.includes("StateInterceptor")) continue;
+      if (line.includes("limelight")) continue;
+      const v8Match = line.match(/at\s+(?:Object\.)?(\w+)\s+\(/) || line.match(/at\s+(\w+)\s*\[/) || line.match(/at\s+(\w+)/);
+      const hermesMatch = line.match(/^(\w+)@/);
+      const match = v8Match || hermesMatch;
+      if (match && match[1]) {
+        const name = match[1];
+        if (![
+          "anonymous",
+          "Object",
+          "Array",
+          "Function",
+          "eval",
+          "Error"
+        ].includes(name)) {
+          return name;
+        }
+      }
+    }
+    return "set";
+  }
+  /**
+   * Compute what keys changed between states (shallow)
+   */
+  computePartialState(state, prevState) {
+    if (typeof state !== "object" || state === null || typeof prevState !== "object" || prevState === null) {
+      return state;
+    }
+    const partial = {};
+    const stateObj = state;
+    const prevObj = prevState;
+    for (const key of Object.keys(stateObj)) {
+      if (stateObj[key] !== prevObj[key]) {
+        partial[key] = stateObj[key];
+      }
+    }
+    if (Object.keys(partial).length === 0) {
+      return state;
+    }
+    return partial;
+  }
+  /**
+   * Capture current stack trace
+   */
+  captureStackTrace() {
+    try {
+      const err = new Error();
+      return err.stack;
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+   * Cleanup all subscriptions
+   */
+  cleanup() {
+    for (const [, store] of this.stores) {
+      store.unsubscribe();
+    }
+    this.stores.clear();
+  }
+};
+
 // src/limelight/LimelightClient.ts
 var LimelightClient = class {
   ws = null;
@@ -1609,6 +1947,7 @@ var LimelightClient = class {
   xhrInterceptor;
   consoleInterceptor;
   renderInterceptor;
+  stateInterceptor;
   constructor() {
     this.networkInterceptor = new NetworkInterceptor(
       this.sendMessage.bind(this),
@@ -1626,6 +1965,10 @@ var LimelightClient = class {
       this.sendMessage.bind(this),
       () => this.sessionId
     );
+    this.stateInterceptor = new StateInterceptor(
+      this.sendMessage.bind(this),
+      () => this.sessionId
+    );
   }
   /**
    * Configures the Limelight client with the provided settings.
@@ -1646,7 +1989,9 @@ var LimelightClient = class {
       enableNetworkInspector: config?.enableNetworkInspector ?? true,
       enableConsole: config?.enableConsole ?? true,
       enableGraphQL: config?.enableGraphQL ?? true,
-      enableRenderInspector: config?.enableRenderInspector ?? true
+      enableRenderInspector: config?.enableRenderInspector ?? true,
+      enableStateInspector: config?.enableStateInspector ?? true,
+      internalLoggingEnabled: config?.internalLoggingEnabled ?? false
     };
     if (!this.config?.enabled) {
       return;
@@ -1663,8 +2008,13 @@ var LimelightClient = class {
       if (this.config.enableRenderInspector) {
         this.renderInterceptor.setup(this.config);
       }
+      if (this.config.stores && this.config.enableStateInspector) {
+        this.stateInterceptor.setup(this.config);
+      }
     } catch (error) {
-      console.error("[Limelight] Failed to setup interceptors:", error);
+      if (this.config?.internalLoggingEnabled) {
+        console.error("[Limelight] Failed to setup interceptors:", error);
+      }
     }
   }
   /**
@@ -1684,7 +2034,9 @@ var LimelightClient = class {
       return;
     }
     if (this.ws && this.ws.readyState === WebSocket.OPEN) {
-      console.warn("[Limelight] Already connected. Call disconnect() first.");
+      if (this.config?.internalLoggingEnabled) {
+        console.warn("[Limelight] Already connected. Call disconnect() first.");
+      }
       return;
     }
     if (this.ws) {
@@ -1699,7 +2051,9 @@ var LimelightClient = class {
     }
     const { serverUrl, appName, platform } = this.config;
     if (!serverUrl) {
-      console.error("[Limelight] serverUrl missing in configuration.");
+      if (this.config?.internalLoggingEnabled) {
+        console.error("[Limelight] serverUrl missing in configuration.");
+      }
       return;
     }
     try {
@@ -1721,13 +2075,17 @@ var LimelightClient = class {
         this.sendMessage(message);
       };
       this.ws.onerror = (error) => {
-        console.error("[Limelight] WebSocket error:", error);
+        if (this.config?.internalLoggingEnabled) {
+          console.error("[Limelight] WebSocket error:", error);
+        }
       };
       this.ws.onclose = () => {
         this.attemptReconnect();
       };
     } catch (error) {
-      console.error("[Limelight] Failed to connect:", error);
+      if (this.config?.internalLoggingEnabled) {
+        console.error("[Limelight] Failed to connect:", error);
+      }
       this.attemptReconnect();
     }
   }
@@ -1769,7 +2127,9 @@ var LimelightClient = class {
       try {
         this.ws.send(safeStringify(message));
       } catch (error) {
-        console.error("[Limelight] Failed to send queued message:", error);
+        if (this.config?.internalLoggingEnabled) {
+          console.error("[Limelight] Failed to send queued message:", error);
+        }
       }
     }
   }
@@ -1788,7 +2148,9 @@ var LimelightClient = class {
         try {
           this.ws.send(safeStringify(message));
         } catch (error) {
-          console.error("[Limelight] Failed to send message:", error);
+          if (this.config?.internalLoggingEnabled) {
+            console.error("[Limelight] Failed to send message:", error);
+          }
           this.messageQueue.push(message);
         }
       } else {
@@ -1796,7 +2158,11 @@ var LimelightClient = class {
       }
     } else {
       if (this.messageQueue.length >= this.maxQueueSize) {
-        console.warn("[Limelight] Message queue full, dropping oldest message");
+        if (this.config?.internalLoggingEnabled) {
+          console.warn(
+            "[Limelight] Message queue full, dropping oldest message"
+          );
+        }
         this.messageQueue.shift();
       }
       this.messageQueue.push(message);
@@ -1837,6 +2203,7 @@ var LimelightClient = class {
     this.xhrInterceptor.cleanup();
     this.consoleInterceptor.cleanup();
     this.renderInterceptor.cleanup();
+    this.stateInterceptor.cleanup();
     this.reconnectAttempts = 0;
     this.messageQueue = [];
   }