@sailfish-ai/recorder 1.0.5 → 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,

package/dist/sailfish-recorder.es.js

@@ -1002,7 +1002,7 @@ var ReconnectingWebSocket = (
     return ReconnectingWebSocket2;
   }()
 );
-const version = "1.0.5";
+const version = "1.0.6";
 let webSocket = null;
 const messageQueue = [];
 function flushMessageQueue() {
@@ -21107,6 +21107,36 @@ function storeCredentialsAndConnection({
   sessionStorage.setItem("sailfishApiKey", apiKey);
   sessionStorage.setItem("sailfishBackendApi", backendApi);
 }
+function matchUrlWithWildcard(url, patterns) {
+  const strippedUrl = url.replace(/^[a-zA-Z]+:\/\//, "");
+  const parsedUrl = new URL("http://" + strippedUrl);
+  const { hostname, pathname } = parsedUrl;
+  const domain = hostname.toLowerCase();
+  return patterns.some((pattern) => {
+    const strippedPattern = pattern.replace(/^[a-zA-Z]+:\/\//, "");
+    let [patternDomain, patternPath] = strippedPattern.split("/", 2);
+    const normalizedPatternDomain = patternDomain.replace(/\./g, "\\.").replace(/\*/g, ".*");
+    const domainRegex = new RegExp(`^${normalizedPatternDomain}$`, "i");
+    const strippedDomain = domain.startsWith("www.") ? domain.slice(4) : domain;
+    if (patternDomain.startsWith("*.") && (domain === patternDomain.slice(2) || strippedDomain === patternDomain.slice(2))) {
+      if (patternPath) {
+        const normalizedPatternPath = patternPath.replace(/\*/g, ".*").replace(/\/$/, "");
+        const pathRegex = new RegExp(`^/${normalizedPatternPath}`, "i");
+        return pathRegex.test(pathname);
+      }
+      return true;
+    }
+    if (!domainRegex.test(strippedDomain) && !domainRegex.test(domain)) {
+      return false;
+    }
+    if (patternPath) {
+      const normalizedPatternPath = patternPath.replace(/\*/g, ".*").replace(/\/$/, "");
+      const pathRegex = new RegExp(`^/${normalizedPatternPath}`, "i");
+      return pathRegex.test(pathname);
+    }
+    return true;
+  });
+}
 function setupXMLHttpRequestInterceptor(domainsToNotPropagateHeaderTo) {
   const originalOpen = XMLHttpRequest.prototype.open;
   const originalSend = XMLHttpRequest.prototype.send;
@@ -21114,14 +21144,15 @@ function setupXMLHttpRequestInterceptor(domainsToNotPropagateHeaderTo) {
   const combinedIgnoreDomains = [
     ...DOMAINS_TO_NOT_PROPAGATE_HEADER_TO_DEFAULT,
     ...domainsToNotPropagateHeaderTo
-  ].map((domain) => domain.startsWith("www.") ? domain.slice(4) : domain);
+  ];
   XMLHttpRequest.prototype.open = function(...args) {
     this._url = args[1];
     originalOpen.apply(this, args);
   };
   XMLHttpRequest.prototype.send = function(...args) {
-    const domain = getEffectiveDomain(this._url);
-    if (sessionId && !combinedIgnoreDomains.includes(domain)) {
+    const url = this._url;
+    const shouldSkipHeader = matchUrlWithWildcard(url, combinedIgnoreDomains);
+    if (sessionId && !shouldSkipHeader) {
       this.setRequestHeader("X-Sf3-Rid", sessionId);
     }
     originalSend.apply(this, args);
@@ -21133,10 +21164,18 @@ function setupFetchInterceptor(domainsToNotPropagateHeaderTo) {
   const combinedIgnoreDomains = [
     ...DOMAINS_TO_NOT_PROPAGATE_HEADER_TO_DEFAULT,
     ...domainsToNotPropagateHeaderTo
-  ].map((domain) => domain.startsWith("www.") ? domain.slice(4) : domain);
+  ];
   window.fetch = async function(input2, init = {}) {
-    const domain = typeof input2 === "string" ? getEffectiveDomain(input2) : "";
-    if (sessionId && !combinedIgnoreDomains.includes(domain)) {
+    let url;
+    if (typeof input2 === "string") {
+      url = input2;
+    } else if (input2 instanceof Request) {
+      url = input2.url;
+    } else {
+      throw new Error("Invalid input type for fetch");
+    }
+    const shouldSkipHeader = matchUrlWithWildcard(url, combinedIgnoreDomains);
+    if (sessionId && !shouldSkipHeader) {
       init.headers = {
         ...init.headers,
         "X-Sf3-Rid": sessionId
@@ -21213,6 +21252,7 @@ export {
   identify,
   initializeRecording,
   initializeWebSocket,
+  matchUrlWithWildcard,
   sendDomainsToNotPropagateHeaderTo,
   sendGraphQLRequest,
   sendMessage,

package/dist/sailfish-recorder.umd.js

@@ -1006,7 +1006,7 @@
       return ReconnectingWebSocket2;
     }()
   );
-  const version = "1.0.5";
+  const version = "1.0.6";
   let webSocket = null;
   const messageQueue = [];
   function flushMessageQueue() {
@@ -21111,6 +21111,36 @@
     sessionStorage.setItem("sailfishApiKey", apiKey);
     sessionStorage.setItem("sailfishBackendApi", backendApi);
   }
+  function matchUrlWithWildcard(url, patterns) {
+    const strippedUrl = url.replace(/^[a-zA-Z]+:\/\//, "");
+    const parsedUrl = new URL("http://" + strippedUrl);
+    const { hostname, pathname } = parsedUrl;
+    const domain = hostname.toLowerCase();
+    return patterns.some((pattern) => {
+      const strippedPattern = pattern.replace(/^[a-zA-Z]+:\/\//, "");
+      let [patternDomain, patternPath] = strippedPattern.split("/", 2);
+      const normalizedPatternDomain = patternDomain.replace(/\./g, "\\.").replace(/\*/g, ".*");
+      const domainRegex = new RegExp(`^${normalizedPatternDomain}$`, "i");
+      const strippedDomain = domain.startsWith("www.") ? domain.slice(4) : domain;
+      if (patternDomain.startsWith("*.") && (domain === patternDomain.slice(2) || strippedDomain === patternDomain.slice(2))) {
+        if (patternPath) {
+          const normalizedPatternPath = patternPath.replace(/\*/g, ".*").replace(/\/$/, "");
+          const pathRegex = new RegExp(`^/${normalizedPatternPath}`, "i");
+          return pathRegex.test(pathname);
+        }
+        return true;
+      }
+      if (!domainRegex.test(strippedDomain) && !domainRegex.test(domain)) {
+        return false;
+      }
+      if (patternPath) {
+        const normalizedPatternPath = patternPath.replace(/\*/g, ".*").replace(/\/$/, "");
+        const pathRegex = new RegExp(`^/${normalizedPatternPath}`, "i");
+        return pathRegex.test(pathname);
+      }
+      return true;
+    });
+  }
   function setupXMLHttpRequestInterceptor(domainsToNotPropagateHeaderTo) {
     const originalOpen = XMLHttpRequest.prototype.open;
     const originalSend = XMLHttpRequest.prototype.send;
@@ -21118,14 +21148,15 @@
     const combinedIgnoreDomains = [
       ...DOMAINS_TO_NOT_PROPAGATE_HEADER_TO_DEFAULT,
       ...domainsToNotPropagateHeaderTo
-    ].map((domain) => domain.startsWith("www.") ? domain.slice(4) : domain);
+    ];
     XMLHttpRequest.prototype.open = function(...args) {
       this._url = args[1];
       originalOpen.apply(this, args);
     };
     XMLHttpRequest.prototype.send = function(...args) {
-      const domain = getEffectiveDomain(this._url);
-      if (sessionId && !combinedIgnoreDomains.includes(domain)) {
+      const url = this._url;
+      const shouldSkipHeader = matchUrlWithWildcard(url, combinedIgnoreDomains);
+      if (sessionId && !shouldSkipHeader) {
         this.setRequestHeader("X-Sf3-Rid", sessionId);
       }
       originalSend.apply(this, args);
@@ -21137,10 +21168,18 @@
     const combinedIgnoreDomains = [
       ...DOMAINS_TO_NOT_PROPAGATE_HEADER_TO_DEFAULT,
       ...domainsToNotPropagateHeaderTo
-    ].map((domain) => domain.startsWith("www.") ? domain.slice(4) : domain);
+    ];
     window.fetch = async function(input2, init = {}) {
-      const domain = typeof input2 === "string" ? getEffectiveDomain(input2) : "";
-      if (sessionId && !combinedIgnoreDomains.includes(domain)) {
+      let url;
+      if (typeof input2 === "string") {
+        url = input2;
+      } else if (input2 instanceof Request) {
+        url = input2.url;
+      } else {
+        throw new Error("Invalid input type for fetch");
+      }
+      const shouldSkipHeader = matchUrlWithWildcard(url, combinedIgnoreDomains);
+      if (sessionId && !shouldSkipHeader) {
         init.headers = {
           ...init.headers,
           "X-Sf3-Rid": sessionId
@@ -21216,6 +21255,7 @@
   exports2.identify = identify;
   exports2.initializeRecording = initializeRecording;
   exports2.initializeWebSocket = initializeWebSocket;
+  exports2.matchUrlWithWildcard = matchUrlWithWildcard;
   exports2.sendDomainsToNotPropagateHeaderTo = sendDomainsToNotPropagateHeaderTo;
   exports2.sendGraphQLRequest = sendGraphQLRequest;
   exports2.sendMessage = sendMessage;

package/dist/types/index.d.ts

@@ -4,6 +4,7 @@ import { CaptureSettings } from "./types";
 export declare const DEFAULT_CAPTURE_SETTINGS: CaptureSettings;
 export declare const DEFAULT_CONSOLE_RECORDING_SETTINGS: LogRecordOptions;
 export declare const DEFAULT_NETWORK_CAPTURE_SETTINGS: NetworkRecordOptions;
+export declare function matchUrlWithWildcard(url: string, patterns: string[]): boolean;
 export declare function startRecording({ apiKey, backendApi, domainsToNotPropagateHeaderTo, }: {
     apiKey: string;
     backendApi: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sailfish-ai/recorder",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "publishPublicly": true,
   "main": "dist/sailfish-recorder.umd.js",
   "types": "dist/types/index.d.ts",
@@ -38,8 +38,10 @@
     "@vitejs/plugin-vue": "^5.1.3",
     "jest": "^29.7.0",
     "jest-transform-stub": "^2.0.0",
+    "jsdom": "^25.0.0",
     "ts-jest": "^29.2.3",
     "typescript": "^5.0.0",
+    "vitest": "^2.1.1",
     "vue": "^3.4.33"
   }
 }