@sailfish-ai/recorder 1.2.4 → 1.2.6

package/dist/index.js

@@ -158,63 +158,56 @@ export function matchUrlWithWildcard(url, patterns) {
 }
 // Updated XMLHttpRequest interceptor with single check function
 // Updated XMLHttpRequest interceptor to bypass for CORS-sensitive domains
+// Updated XMLHttpRequest interceptor with exclusion handling
 function setupXMLHttpRequestInterceptor(domainsToNotPropagateHeaderTo, domainsToPropagateHeadersTo = []) {
     const originalOpen = XMLHttpRequest.prototype.open;
     const originalSend = XMLHttpRequest.prototype.send;
     const sessionId = getOrSetSessionId();
-    // Combine default and passed ignore domains
+    // Combined ignore and propagate logic
     const combinedIgnoreDomains = [
         ...DOMAINS_TO_NOT_PROPAGATE_HEADER_TO_DEFAULT,
         ...domainsToNotPropagateHeaderTo,
     ];
     // Store URL during open()
     XMLHttpRequest.prototype.open = function (method, url, ...args) {
-        // Ensure the URL is a string, otherwise handle gracefully
-        if (typeof url === "string" && url.length > 0) {
-            this._requestUrl = url; // Capture the valid URL
-        }
-        else {
-            console.warn("Invalid or non-string URL passed to XMLHttpRequest:", url);
-            this._requestUrl = null; // Handle invalid or non-string URL
-        }
+        this._requestUrl = typeof url === "string" && url.length > 0 ? url : null;
         return originalOpen.apply(this, [method, url, ...args]);
     };
     // Intercept send()
     XMLHttpRequest.prototype.send = function (...args) {
         const url = this._requestUrl;
-        // If no valid URL was captured, proceed without modification
-        if (!url) {
+        if (!url)
             return originalSend.apply(this, args);
-        }
-        // Bypass logic for domains listed in the combinedIgnoreDomains
+        // Check if domain should be ignored based on combined ignore list
         if (matchUrlWithWildcard(url, combinedIgnoreDomains)) {
+            console.log([`[XML] [InIgnoreDomains] IGNORE --> ${url}`]);
             return originalSend.apply(this, args);
         }
-        // Check if the domain should propagate headers
+        // Check if domain should propagate headers
         const shouldPropagateHeader = domainsToPropagateHeadersTo.length === 0 ||
             matchUrlWithWildcard(url, domainsToPropagateHeadersTo);
         if (sessionId && shouldPropagateHeader) {
+            console.log([`[XML] [InPropagateDomans] PROPAGATE FOR --> ${url}`]);
             this.setRequestHeader("X-Sf3-Rid", sessionId);
         }
+        console.log([`[XML] [NOT InPropagateDomans] IGNORE --> ${url}`]);
         return originalSend.apply(this, args);
     };
 }
-// Updated fetch interceptor to bypass for CORS-sensitive domains
-function setupFetchInterceptor(domainsToNotPropagateHeaderTo, domainsToPropagateHeadersTo = []) {
+// Updated fetch interceptor with exclusion handling
+function setupFetchInterceptor(domainsToNotPropagateHeadersTo, domainsToPropagateHeadersTo = []) {
     const originalFetch = window.fetch;
     const sessionId = getOrSetSessionId();
-    // Combine default and passed ignore domains
     const combinedIgnoreDomains = [
         ...DOMAINS_TO_NOT_PROPAGATE_HEADER_TO_DEFAULT,
-        ...domainsToNotPropagateHeaderTo,
+        ...domainsToNotPropagateHeadersTo,
     ];
-    // Proxy to conditionally intercept fetch based on domains
+    const cache = new Map();
     window.fetch = new Proxy(originalFetch, {
         apply: (target, thisArg, args) => {
             let input = args[0];
             let init = args[1] || {};
             let url;
-            // Handle different types of `input` for fetch
             if (typeof input === "string") {
                 url = input;
             }
@@ -225,45 +218,65 @@ function setupFetchInterceptor(domainsToNotPropagateHeaderTo, domainsToPropagate
                 url = input.href;
             }
             else {
-                // Unsupported type, skip interception
-                console.warn("Unsupported input type for fetch:", input);
-                return target.apply(thisArg, args);
+                return target.apply(thisArg, args); // Skip unsupported inputs
             }
-            // ** Check if we should skip patching fetch entirely for this domain **
+            // Cache check
+            if (cache.has(url)) {
+                const cachedResult = cache.get(url);
+                if (cachedResult === "ignore") {
+                    console.log(`[CACHE] IGNORE --> ${url}`);
+                    return target.apply(thisArg, args);
+                }
+                if (cachedResult === "propagate") {
+                    console.log(`[CACHE] PROPAGATE FOR --> ${url}`);
+                    return injectHeader(target, thisArg, args, input, init, sessionId);
+                }
+            }
+            // Check domain exclusion
             if (matchUrlWithWildcard(url, combinedIgnoreDomains)) {
+                cache.set(url, "ignore");
+                console.log(`[InIgnoreDomains] IGNORE --> ${url}`);
                 return target.apply(thisArg, args);
             }
-            // Check if the domain should propagate the header
+            // Check domain propagation
             const shouldPropagateHeader = domainsToPropagateHeadersTo.length === 0 ||
                 matchUrlWithWildcard(url, domainsToPropagateHeadersTo);
-            // ** Skip CORS-sensitive requests **
-            // Ensure we don't modify headers for cross-origin requests to non-whitelisted domains
             if (!shouldPropagateHeader) {
+                cache.set(url, "ignore");
+                console.log(`[NOT InPropagateDomans] IGNORE --> ${url}`);
                 return target.apply(thisArg, args);
             }
-            // ** Add X-Sf3-Rid header if needed **
-            if (sessionId && shouldPropagateHeader) {
-                if (input instanceof Request) {
-                    const clonedRequest = input.clone();
-                    const newHeaders = new Headers(clonedRequest.headers);
-                    newHeaders.set("X-Sf3-Rid", sessionId);
-                    const modifiedRequest = new Request(clonedRequest, {
-                        headers: newHeaders,
-                    });
-                    return target.call(thisArg, modifiedRequest, init);
-                }
-                else {
-                    const modifiedInit = { ...init };
-                    const newHeaders = new Headers(init.headers || {});
-                    newHeaders.set("X-Sf3-Rid", sessionId);
-                    modifiedInit.headers = newHeaders;
-                    return target.call(thisArg, input, modifiedInit);
-                }
-            }
-            // If no header propagation, return the original fetch call
-            return target.apply(thisArg, args);
+            cache.set(url, "propagate");
+            console.log(`[InPropagateDomans] PROPAGATE FOR --> ${url}`);
+            return injectHeader(target, thisArg, args, input, init, sessionId);
         },
     });
+    // Helper function to inject the X-Sf3-Rid header
+    function injectHeader(target, thisArg, args, input, init, sessionId) {
+        if (sessionId) {
+            if (input instanceof Request) {
+                // Clone the Request and modify headers
+                const clonedRequest = input.clone();
+                const newHeaders = new Headers(clonedRequest.headers);
+                newHeaders.set("X-Sf3-Rid", sessionId);
+                const modifiedRequest = new Request(clonedRequest, {
+                    headers: newHeaders,
+                });
+                return target.call(thisArg, modifiedRequest, init);
+            }
+            else {
+                // For string or URL input, modify init to add headers
+                const modifiedInit = { ...init };
+                const newHeaders = new Headers(init.headers || {});
+                newHeaders.set("X-Sf3-Rid", sessionId);
+                modifiedInit.headers = newHeaders;
+                return target.call(thisArg, input, modifiedInit);
+            }
+        }
+        else {
+            return target.apply(thisArg, args);
+        }
+    }
 }
 // Main Recording Function
 export async function startRecording({ apiKey, backendApi, domainsToPropagateHeaderTo = [], domainsToNotPropagateHeaderTo = [], }) {