@sailfish-ai/recorder 1.0.4 → 1.0.6

package/dist/index.js

@@ -82,38 +82,103 @@ function storeCredentialsAndConnection({ apiKey, backendApi, }) {
     sessionStorage.setItem("sailfishApiKey", apiKey);
     sessionStorage.setItem("sailfishBackendApi", backendApi);
 }
-// Intercepting XMLHttpRequest
+// Utility function to match domains or paths with wildcard support
+export function matchUrlWithWildcard(url, patterns) {
+    // Strip any protocol (e.g., http, https, ws, wss, ftp, etc.) from the URL
+    const strippedUrl = url.replace(/^[a-zA-Z]+:\/\//, "");
+    const parsedUrl = new URL("http://" + strippedUrl); // Add a dummy protocol for URL parsing
+    const { hostname, pathname } = parsedUrl;
+    const domain = hostname.toLowerCase();
+    return patterns.some((pattern) => {
+        // Strip any protocol from the pattern
+        const strippedPattern = pattern.replace(/^[a-zA-Z]+:\/\//, "");
+        let [patternDomain, patternPath] = strippedPattern.split("/", 2);
+        // Handle domain wildcards
+        const normalizedPatternDomain = patternDomain
+            .replace(/\./g, "\\.") // Escape dots for regex
+            .replace(/\*/g, ".*"); // Replace '*' with regex to match any characters
+        // Create regex for the domain pattern
+        const domainRegex = new RegExp(`^${normalizedPatternDomain}$`, "i");
+        // Strip 'www.' from both the input domain and the pattern domain for comparison
+        const strippedDomain = domain.startsWith("www.") ? domain.slice(4) : domain;
+        // Handle subdomain wildcard (*.) to match both base and subdomains
+        if (patternDomain.startsWith("*.") &&
+            (domain === patternDomain.slice(2) ||
+                strippedDomain === patternDomain.slice(2))) {
+            // Check for path match if the pattern includes a path
+            if (patternPath) {
+                const normalizedPatternPath = patternPath
+                    .replace(/\*/g, ".*") // Replace '*' with regex to match any characters
+                    .replace(/\/$/, ""); // Remove trailing slashes from pattern
+                const pathRegex = new RegExp(`^/${normalizedPatternPath}`, "i");
+                return pathRegex.test(pathname); // Match the path
+            }
+            return true; // Domain matched, no path required
+        }
+        // Check if the domain matches (include check for base domain without www)
+        if (!domainRegex.test(strippedDomain) && !domainRegex.test(domain)) {
+            return false;
+        }
+        // If there's a path in the pattern, match the path
+        if (patternPath) {
+            const normalizedPatternPath = patternPath
+                .replace(/\*/g, ".*") // Replace '*' with regex to match any characters
+                .replace(/\/$/, ""); // Remove trailing slashes from pattern
+            const pathRegex = new RegExp(`^/${normalizedPatternPath}`, "i");
+            return pathRegex.test(pathname); // Match the path
+        }
+        // If no path pattern, only the domain needs to match
+        return true;
+    });
+}
+// Updated XMLHttpRequest interceptor with single check function
 function setupXMLHttpRequestInterceptor(domainsToNotPropagateHeaderTo) {
     const originalOpen = XMLHttpRequest.prototype.open;
     const originalSend = XMLHttpRequest.prototype.send;
     const sessionId = getOrSetSessionId();
+    // Combine default and passed domains
     const combinedIgnoreDomains = [
         ...DOMAINS_TO_NOT_PROPAGATE_HEADER_TO_DEFAULT,
         ...domainsToNotPropagateHeaderTo,
-    ].map((domain) => (domain.startsWith("www.") ? domain.slice(4) : domain)); // Remove 'www.' from ignore domains
+    ];
     XMLHttpRequest.prototype.open = function (...args) {
         this._url = args[1]; // Store the request URL
         originalOpen.apply(this, args);
     };
     XMLHttpRequest.prototype.send = function (...args) {
-        const domain = getEffectiveDomain(this._url); // Use tldts to get the domain
-        if (sessionId && !combinedIgnoreDomains.includes(domain)) {
+        const url = this._url;
+        // Check if URL matches any domain or path pattern
+        const shouldSkipHeader = matchUrlWithWildcard(url, combinedIgnoreDomains);
+        if (sessionId && !shouldSkipHeader) {
             this.setRequestHeader("X-Sf3-Rid", sessionId);
         }
         originalSend.apply(this, args);
     };
 }
-// Intercepting fetch API
+// Updated fetch interceptor with single check function
 function setupFetchInterceptor(domainsToNotPropagateHeaderTo) {
     const originalFetch = window.fetch;
     const sessionId = getOrSetSessionId();
+    // Combine default and passed domains
     const combinedIgnoreDomains = [
         ...DOMAINS_TO_NOT_PROPAGATE_HEADER_TO_DEFAULT,
         ...domainsToNotPropagateHeaderTo,
-    ].map((domain) => (domain.startsWith("www.") ? domain.slice(4) : domain)); // Remove 'www.' from ignore domains
+    ];
     window.fetch = async function (input, init = {}) {
-        const domain = typeof input === "string" ? getEffectiveDomain(input) : "";
-        if (sessionId && !combinedIgnoreDomains.includes(domain)) {
+        let url;
+        // Check if input is a string (URL) or a Request object
+        if (typeof input === "string") {
+            url = input;
+        }
+        else if (input instanceof Request) {
+            url = input.url;
+        }
+        else {
+            throw new Error("Invalid input type for fetch");
+        }
+        // Check if URL matches any domain or path pattern
+        const shouldSkipHeader = matchUrlWithWildcard(url, combinedIgnoreDomains);
+        if (sessionId && !shouldSkipHeader) {
             init.headers = {
                 ...init.headers,
                 "X-Sf3-Rid": sessionId,