@sailfish-ai/recorder 1.2.4 → 1.2.5

package/dist/index.js

@@ -200,14 +200,30 @@ function setupXMLHttpRequestInterceptor(domainsToNotPropagateHeaderTo, domainsTo
     };
 }
 // Updated fetch interceptor to bypass for CORS-sensitive domains
-function setupFetchInterceptor(domainsToNotPropagateHeaderTo, domainsToPropagateHeadersTo = []) {
+function setupFetchInterceptor(domainsToNotPatchFetchFor, domainsToPropagateHeadersTo = []) {
     const originalFetch = window.fetch;
     const sessionId = getOrSetSessionId();
     // Combine default and passed ignore domains
     const combinedIgnoreDomains = [
         ...DOMAINS_TO_NOT_PROPAGATE_HEADER_TO_DEFAULT,
-        ...domainsToNotPropagateHeaderTo,
+        ...domainsToNotPatchFetchFor,
     ];
+    // Cache results of domain checks to reduce performance overhead
+    const cache = new Map();
+    // Function to check if the input is a non-standard fetch input (Blob, FormData, etc.)
+    function isNonStandardRequestInfo(input) {
+        return (input instanceof Blob ||
+            input instanceof FormData ||
+            input instanceof ArrayBuffer);
+    }
+    // Function to check if fetch is polyfilled (e.g., in older browsers or Node.js)
+    function isPolyfilledFetch() {
+        return !window.fetch.toString().includes("[native code]");
+    }
+    // Log a warning if fetch is polyfilled
+    if (isPolyfilledFetch()) {
+        console.log("Fetch is polyfilled, behavior may differ from native fetch.");
+    }
     // Proxy to conditionally intercept fetch based on domains
     window.fetch = new Proxy(originalFetch, {
         apply: (target, thisArg, args) => {
@@ -224,46 +240,80 @@ function setupFetchInterceptor(domainsToNotPropagateHeaderTo, domainsToPropagate
             else if (input instanceof URL) {
                 url = input.href;
             }
-            else {
-                // Unsupported type, skip interception
-                console.warn("Unsupported input type for fetch:", input);
+            else if (isNonStandardRequestInfo(input)) {
+                // Pass through non-standard inputs like Blob, FormData, etc.
                 return target.apply(thisArg, args);
             }
-            // ** Check if we should skip patching fetch entirely for this domain **
-            if (matchUrlWithWildcard(url, combinedIgnoreDomains)) {
+            else {
+                // Unsupported input type, skip interception
+                console.warn("Unsupported input type for fetch:", input);
                 return target.apply(thisArg, args);
             }
-            // Check if the domain should propagate the header
-            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) {
-                return target.apply(thisArg, args);
+            // Check the cache for domain results to avoid redundant checks
+            if (cache.has(url)) {
+                const cachedResult = cache.get(url);
+                if (cachedResult === "ignore") {
+                    return target.apply(thisArg, args);
+                }
+                if (cachedResult === "propagate") {
+                    return injectHeader(target, thisArg, args, input, init, sessionId);
+                }
             }
-            // ** 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);
+            // ** Security Restriction Handling **
+            try {
+                // ** Check if we should skip patching fetch entirely for this domain **
+                if (matchUrlWithWildcard(url, combinedIgnoreDomains)) {
+                    // Cache the result for this domain to avoid future checks
+                    cache.set(url, "ignore");
+                    return target.apply(thisArg, args);
                 }
-                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);
+                // Check if the domain should propagate the header
+                const shouldPropagateHeader = domainsToPropagateHeadersTo.length === 0 ||
+                    matchUrlWithWildcard(url, domainsToPropagateHeadersTo);
+                // ** Skip CORS-sensitive requests **
+                if (!shouldPropagateHeader) {
+                    // Cache the result for this domain to avoid future checks
+                    cache.set(url, "ignore");
+                    return target.apply(thisArg, args);
                 }
+                // Cache the result for this domain
+                cache.set(url, "propagate");
+                // ** Proceed to inject X-Sf3-Rid header **
+                return injectHeader(target, thisArg, args, input, init, sessionId);
+            }
+            catch (error) {
+                // ** Handle security restrictions and fallback to the original fetch **
+                console.error("Failed to intercept fetch due to security restrictions:", error);
+                return target.apply(thisArg, args);
             }
-            // If no header propagation, return the original fetch call
-            return target.apply(thisArg, args);
         },
     });
+    // 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 = [], }) {