@blinkdotnew/sdk 0.19.1 → 0.19.5

package/dist/index.js

@@ -1020,6 +1020,142 @@ var HttpClient = class {
   }
 };
 
+// src/utils/browser-env.ts
+function hasWindow() {
+  return typeof window !== "undefined";
+}
+function hasWindowLocation() {
+  return typeof window !== "undefined" && typeof window.location !== "undefined";
+}
+function hasDocument() {
+  return typeof document !== "undefined";
+}
+function isReactNative2() {
+  return typeof navigator !== "undefined" && navigator.product === "ReactNative";
+}
+function getWindowLocation() {
+  if (!hasWindow()) return null;
+  try {
+    return window.location;
+  } catch {
+    return null;
+  }
+}
+function getLocationHref() {
+  const loc = getWindowLocation();
+  if (!loc) return null;
+  try {
+    return loc.href;
+  } catch {
+    return null;
+  }
+}
+function getLocationOrigin() {
+  const loc = getWindowLocation();
+  if (!loc) return null;
+  try {
+    return loc.origin;
+  } catch {
+    return null;
+  }
+}
+function getLocationHostname() {
+  const loc = getWindowLocation();
+  if (!loc) return null;
+  try {
+    return loc.hostname;
+  } catch {
+    return null;
+  }
+}
+function getLocationPathname() {
+  const loc = getWindowLocation();
+  if (!loc) return null;
+  try {
+    return loc.pathname;
+  } catch {
+    return null;
+  }
+}
+function getLocationSearch() {
+  const loc = getWindowLocation();
+  if (!loc) return null;
+  try {
+    return loc.search;
+  } catch {
+    return null;
+  }
+}
+function getLocationHash() {
+  const loc = getWindowLocation();
+  if (!loc) return null;
+  try {
+    return loc.hash;
+  } catch {
+    return null;
+  }
+}
+function getLocationProtocol() {
+  const loc = getWindowLocation();
+  if (!loc) return null;
+  try {
+    return loc.protocol;
+  } catch {
+    return null;
+  }
+}
+function getLocationHost() {
+  const loc = getWindowLocation();
+  if (!loc) return null;
+  try {
+    return loc.host;
+  } catch {
+    return null;
+  }
+}
+function constructFullUrl() {
+  if (!hasWindow()) return null;
+  const protocol = getLocationProtocol();
+  const host = getLocationHost();
+  const pathname = getLocationPathname();
+  const search = getLocationSearch();
+  const hash = getLocationHash();
+  if (!protocol || !host) return null;
+  return `${protocol}//${host}${pathname || ""}${search || ""}${hash || ""}`;
+}
+function getDocumentReferrer() {
+  if (!hasDocument()) return null;
+  try {
+    return document.referrer || null;
+  } catch {
+    return null;
+  }
+}
+function getWindowInnerWidth() {
+  if (!hasWindow()) return null;
+  try {
+    return window.innerWidth;
+  } catch {
+    return null;
+  }
+}
+function isIframe() {
+  if (!hasWindow()) return false;
+  try {
+    return window.self !== window.top;
+  } catch {
+    return true;
+  }
+}
+function getSessionStorage() {
+  if (!hasWindow()) return null;
+  try {
+    return window.sessionStorage;
+  } catch {
+    return null;
+  }
+}
+
 // src/auth.ts
 var BlinkAuth = class {
   config;
@@ -1041,13 +1177,16 @@ var BlinkAuth = class {
     this.authConfig = {
       mode: "managed",
       // Default mode
-      authUrl: "https://blink.new",
+      authUrl: "http://localhost:3000",
       coreUrl: "https://core.blink.new",
+      detectSessionInUrl: true,
+      // Default to true for web compatibility
       ...config.auth
     };
     this.authUrl = this.authConfig.authUrl || "https://blink.new";
     this.coreUrl = this.authConfig.coreUrl || "https://core.blink.new";
-    if (typeof window !== "undefined" && this.authUrl === "https://blink.new" && (window.location.hostname === "localhost" || window.location.hostname === "127.0.0.1")) {
+    const hostname = getLocationHostname();
+    if (hostname && this.authUrl === "https://blink.new" && (hostname === "localhost" || hostname === "127.0.0.1")) {
       console.warn("\u26A0\uFE0F Using default authUrl in development. Set auth.authUrl to your app origin for headless auth endpoints to work.");
     }
     if (config.authRequired !== void 0 && !config.auth?.mode) {
@@ -1061,7 +1200,7 @@ var BlinkAuth = class {
     };
     this.storage = config.auth?.storage || config.storage || getDefaultStorageAdapter();
     if (isWeb) {
-      this.isIframe = window.self !== window.top;
+      this.isIframe = isIframe();
       this.setupParentWindowListener();
       this.setupCrossTabSync();
       this.initializationPromise = this.initialize();
@@ -1097,7 +1236,7 @@ var BlinkAuth = class {
    * Setup listener for tokens from parent window
    */
   setupParentWindowListener() {
-    if (!isWeb || !this.isIframe) return;
+    if (!isWeb || !this.isIframe || !hasWindow()) return;
     window.addEventListener("message", (event) => {
       if (event.origin !== "https://blink.new" && event.origin !== "http://localhost:3000" && event.origin !== "http://localhost:3001") {
         return;
@@ -1119,7 +1258,7 @@ var BlinkAuth = class {
         this.clearTokens();
       }
     });
-    if (window.parent !== window) {
+    if (hasWindow() && window.parent !== window) {
       console.log("\u{1F504} Requesting auth tokens from parent window");
       window.parent.postMessage({
         type: "BLINK_REQUEST_AUTH_TOKENS",
@@ -1144,13 +1283,15 @@ var BlinkAuth = class {
           return;
         }
       }
-      const tokensFromUrl = this.extractTokensFromUrl();
-      if (tokensFromUrl) {
-        console.log("\u{1F4E5} Found tokens in URL, setting them...");
-        await this.setTokens(tokensFromUrl, true);
-        this.clearUrlTokens();
-        console.log("\u2705 Auth initialization complete (from URL)");
-        return;
+      if (this.authConfig.detectSessionInUrl !== false) {
+        const tokensFromUrl = this.extractTokensFromUrl();
+        if (tokensFromUrl) {
+          console.log("\u{1F4E5} Found tokens in URL, setting them...");
+          await this.setTokens(tokensFromUrl, true);
+          this.clearUrlTokens();
+          console.log("\u2705 Auth initialization complete (from URL)");
+          return;
+        }
       }
       const storedTokens = await this.getStoredTokens();
       if (storedTokens) {
@@ -1174,11 +1315,11 @@ var BlinkAuth = class {
         }
       }
       console.log("\u274C No tokens found");
-      if (this.config.authRequired) {
+      if (this.config.authRequired && hasWindowLocation()) {
         console.log("\u{1F504} Auth required, redirecting to auth page...");
         this.redirectToAuth();
       } else {
-        console.log("\u26A0\uFE0F Auth not required, continuing without authentication");
+        console.log("\u26A0\uFE0F Auth not required or no window.location, continuing without authentication");
       }
     } finally {
       this.setLoading(false);
@@ -1189,15 +1330,20 @@ var BlinkAuth = class {
    * Redirect to Blink auth page
    */
   login(nextUrl) {
+    if (!hasWindowLocation()) {
+      console.warn("login() called in non-browser environment (no window.location available)");
+      return;
+    }
     let redirectUrl = nextUrl || this.authConfig.redirectUrl;
-    if (!redirectUrl && typeof window !== "undefined") {
-      if (window.location.href.startsWith("http")) {
-        redirectUrl = window.location.href;
+    if (!redirectUrl) {
+      const href = getLocationHref();
+      if (href && href.startsWith("http")) {
+        redirectUrl = href;
       } else {
-        redirectUrl = `${window.location.protocol}//${window.location.host}${window.location.pathname}${window.location.search}${window.location.hash}`;
+        redirectUrl = constructFullUrl() || void 0;
       }
     }
-    if (redirectUrl && typeof window !== "undefined") {
+    if (redirectUrl) {
       try {
         const url = new URL(redirectUrl);
         url.searchParams.delete("redirect_url");
@@ -1212,16 +1358,14 @@ var BlinkAuth = class {
     if (this.config.projectId) {
       authUrl.searchParams.set("project_id", this.config.projectId);
     }
-    if (typeof window !== "undefined") {
-      window.location.href = authUrl.toString();
-    }
+    window.location.href = authUrl.toString();
   }
   /**
    * Logout and clear stored tokens
    */
   logout(redirectUrl) {
     this.clearTokens();
-    if (redirectUrl && typeof window !== "undefined") {
+    if (redirectUrl && hasWindowLocation()) {
       window.location.href = redirectUrl;
     }
   }
@@ -1470,6 +1614,16 @@ var BlinkAuth = class {
   }
   /**
    * Sign in with Google (headless mode)
+   * 
+   * **Universal OAuth** - Works on both Web and React Native!
+   * 
+   * On React Native, requires `webBrowser` to be configured in client:
+   * ```typescript
+   * const blink = createClient({
+   *   auth: { mode: 'headless', webBrowser: WebBrowser }
+   * })
+   * await blink.auth.signInWithGoogle() // Works on both platforms!
+   * ```
    */
   async signInWithGoogle(options) {
     if (this.authConfig.mode !== "headless") {
@@ -1479,6 +1633,9 @@ var BlinkAuth = class {
   }
   /**
    * Sign in with GitHub (headless mode)
+   * 
+   * **Universal OAuth** - Works on both Web and React Native!
+   * See signInWithGoogle() for setup instructions.
    */
   async signInWithGitHub(options) {
     if (this.authConfig.mode !== "headless") {
@@ -1488,6 +1645,9 @@ var BlinkAuth = class {
   }
   /**
    * Sign in with Apple (headless mode)
+   * 
+   * **Universal OAuth** - Works on both Web and React Native!
+   * See signInWithGoogle() for setup instructions.
    */
   async signInWithApple(options) {
     if (this.authConfig.mode !== "headless") {
@@ -1497,6 +1657,9 @@ var BlinkAuth = class {
   }
   /**
    * Sign in with Microsoft (headless mode)
+   * 
+   * **Universal OAuth** - Works on both Web and React Native!
+   * See signInWithGoogle() for setup instructions.
    */
   async signInWithMicrosoft(options) {
     if (this.authConfig.mode !== "headless") {
@@ -1504,22 +1667,250 @@ var BlinkAuth = class {
     }
     return this.signInWithProvider("microsoft", options);
   }
+  /**
+   * Initiate OAuth for mobile without deep linking (expo-web-browser pattern)
+   * 
+   * This method:
+   * 1. Generates a unique session ID
+   * 2. Returns OAuth URL with session parameter
+   * 3. App opens URL in expo-web-browser
+   * 4. App polls checkMobileOAuthSession() until complete
+   * 
+   * @param provider - OAuth provider (google, github, apple, etc.)
+   * @param options - Optional metadata
+   * @returns Session ID and OAuth URL
+   * 
+   * @example
+   * // React Native with expo-web-browser
+   * import * as WebBrowser from 'expo-web-browser';
+   * 
+   * const { sessionId, authUrl } = await blink.auth.initiateMobileOAuth('google');
+   * 
+   * // Open browser
+   * await WebBrowser.openAuthSessionAsync(authUrl);
+   * 
+   * // Poll for completion
+   * const user = await blink.auth.pollMobileOAuthSession(sessionId);
+   * console.log('Authenticated:', user.email);
+   */
+  async initiateMobileOAuth(provider, options) {
+    if (this.authConfig.mode !== "headless") {
+      throw new BlinkAuthError(
+        "INVALID_CREDENTIALS" /* INVALID_CREDENTIALS */,
+        "initiateMobileOAuth is only available in headless mode"
+      );
+    }
+    const sessionId = this.generateSessionId();
+    const authUrl = new URL("/auth", this.authUrl);
+    authUrl.searchParams.set("provider", provider);
+    authUrl.searchParams.set("project_id", this.config.projectId);
+    authUrl.searchParams.set("mode", "mobile-session");
+    authUrl.searchParams.set("session_id", sessionId);
+    if (options?.metadata) {
+      authUrl.searchParams.set("metadata", JSON.stringify(options.metadata));
+    }
+    return {
+      sessionId,
+      authUrl: authUrl.toString()
+    };
+  }
+  /**
+   * Check mobile OAuth session status (single check)
+   * 
+   * @param sessionId - Session ID from initiateMobileOAuth
+   * @returns Tokens if session is complete, null if still pending
+   */
+  async checkMobileOAuthSession(sessionId) {
+    try {
+      const response = await fetch(`${this.authUrl}/api/auth/mobile-session/${sessionId}`, {
+        method: "GET",
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+      if (response.status === 404 || response.status === 202) {
+        return null;
+      }
+      if (!response.ok) {
+        const errorData = await response.json();
+        const errorCode = this.mapErrorCodeFromResponse(errorData.code);
+        throw new BlinkAuthError(
+          errorCode,
+          errorData.error || "Failed to check OAuth session"
+        );
+      }
+      const data = await response.json();
+      return {
+        access_token: data.access_token,
+        refresh_token: data.refresh_token,
+        token_type: data.token_type || "Bearer",
+        expires_in: data.expires_in || 3600,
+        refresh_expires_in: data.refresh_expires_in
+      };
+    } catch (error) {
+      if (error instanceof BlinkAuthError) {
+        throw error;
+      }
+      throw new BlinkAuthError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        `Network error: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Poll mobile OAuth session until complete (convenience method)
+   * 
+   * @param sessionId - Session ID from initiateMobileOAuth
+   * @param options - Polling options
+   * @returns Authenticated user
+   * 
+   * @example
+   * const { sessionId, authUrl } = await blink.auth.initiateMobileOAuth('google');
+   * await WebBrowser.openAuthSessionAsync(authUrl);
+   * const user = await blink.auth.pollMobileOAuthSession(sessionId, {
+   *   maxAttempts: 60,
+   *   intervalMs: 1000
+   * });
+   */
+  async pollMobileOAuthSession(sessionId, options) {
+    const maxAttempts = options?.maxAttempts || 60;
+    const intervalMs = options?.intervalMs || 1e3;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      const tokens = await this.checkMobileOAuthSession(sessionId);
+      if (tokens) {
+        await this.setTokens(tokens, true);
+        return this.authState.user;
+      }
+      await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    }
+    throw new BlinkAuthError(
+      "AUTH_TIMEOUT" /* AUTH_TIMEOUT */,
+      "Mobile OAuth session timed out"
+    );
+  }
+  /**
+   * Sign in with OAuth provider using expo-web-browser (React Native)
+   * 
+   * This is a convenience method that handles the entire flow:
+   * 1. Initiates mobile OAuth session
+   * 2. Returns auth URL to open in WebBrowser
+   * 3. Provides polling function to call after browser opens
+   * 
+   * @param provider - OAuth provider
+   * @returns Object with authUrl and authenticate function
+   * 
+   * @example
+   * import * as WebBrowser from 'expo-web-browser';
+   * 
+   * const { authUrl, authenticate } = await blink.auth.signInWithProviderMobile('google');
+   * 
+   * // Open browser
+   * await WebBrowser.openAuthSessionAsync(authUrl);
+   * 
+   * // Wait for authentication
+   * const user = await authenticate();
+   */
+  async signInWithProviderMobile(provider, options) {
+    const { sessionId, authUrl } = await this.initiateMobileOAuth(provider, options);
+    return {
+      authUrl,
+      authenticate: () => this.pollMobileOAuthSession(sessionId, {
+        maxAttempts: 60,
+        intervalMs: 1e3
+      })
+    };
+  }
+  /**
+   * Universal OAuth flow using session-based authentication (internal)
+   * Works on ALL platforms: Web, iOS, Android
+   * Uses expo-web-browser to open auth URL and polls for completion
+   */
+  async signInWithProviderUniversal(provider, options) {
+    const webBrowser = this.authConfig.webBrowser;
+    if (!webBrowser) {
+      throw new BlinkAuthError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        "webBrowser module is required for universal OAuth flow"
+      );
+    }
+    const { sessionId, authUrl } = await this.initiateMobileOAuth(provider, options);
+    console.log("\u{1F510} Opening OAuth browser for", provider);
+    const result = await webBrowser.openAuthSessionAsync(authUrl);
+    console.log("\u{1F510} Browser closed with result:", result.type);
+    try {
+      const user = await this.pollMobileOAuthSession(sessionId, {
+        maxAttempts: 60,
+        // 30 seconds (500ms intervals)
+        intervalMs: 500
+      });
+      console.log("\u2705 OAuth completed successfully");
+      return user;
+    } catch (pollError) {
+      if (result.type === "cancel" || result.type === "dismiss") {
+        throw new BlinkAuthError(
+          "POPUP_CANCELED" /* POPUP_CANCELED */,
+          "Authentication was canceled"
+        );
+      }
+      throw pollError;
+    }
+  }
   /**
    * Generic provider sign-in method (headless mode)
+   * 
+   * **Universal OAuth** - Works seamlessly on both Web and React Native!
+   * 
+   * When `webBrowser` is configured in the client, this method automatically
+   * uses the session-based OAuth flow that works on ALL platforms.
+   * 
+   * **Universal Setup (configure once, works everywhere):**
+   * ```typescript
+   * import * as WebBrowser from 'expo-web-browser'
+   * import AsyncStorage from '@react-native-async-storage/async-storage'
+   * 
+   * const blink = createClient({
+   *   projectId: 'your-project',
+   *   auth: {
+   *     mode: 'headless',
+   *     webBrowser: WebBrowser  // Pass the module here
+   *   },
+   *   storage: new AsyncStorageAdapter(AsyncStorage)
+   * })
+   * 
+   * // Now this works on ALL platforms - no platform checks needed!
+   * const user = await blink.auth.signInWithGoogle()
+   * ```
+   * 
+   * @param provider - OAuth provider (google, github, apple, etc.)
+   * @param options - Optional redirect URL and metadata
+   * @returns Promise that resolves with authenticated user
    */
   async signInWithProvider(provider, options) {
     if (this.authConfig.mode !== "headless") {
       throw new BlinkAuthError("INVALID_CREDENTIALS" /* INVALID_CREDENTIALS */, "signInWithProvider is only available in headless mode");
     }
+    if (this.authConfig.webBrowser) {
+      return this.signInWithProviderUniversal(provider, options);
+    }
+    if (isReactNative2()) {
+      throw new BlinkAuthError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        'React Native OAuth requires webBrowser in config!\n\nimport * as WebBrowser from "expo-web-browser";\n\nconst blink = createClient({\n  projectId: "your-project",\n  auth: {\n    mode: "headless",\n    webBrowser: WebBrowser\n  }\n})\n\nawait blink.auth.signInWithGoogle() // Works on all platforms!'
+      );
+    }
+    if (!hasWindow()) {
+      throw new BlinkAuthError("NETWORK_ERROR" /* NETWORK_ERROR */, "signInWithProvider requires a browser environment");
+    }
     return new Promise((resolve, reject) => {
       const state = this.generateState();
       try {
-        if (typeof window !== "undefined") {
+        const sessionStorage = getSessionStorage();
+        if (sessionStorage) {
           sessionStorage.setItem("blink_oauth_state", state);
         }
       } catch {
       }
-      const redirectUrl = options?.redirectUrl || window.location.origin;
+      const redirectUrl = options?.redirectUrl || getLocationOrigin() || "";
       const popupUrl = new URL("/auth", this.authUrl);
       popupUrl.searchParams.set("provider", provider);
       popupUrl.searchParams.set("project_id", this.config.projectId);
@@ -1548,7 +1939,8 @@ var BlinkAuth = class {
         if (event.data?.type === "BLINK_AUTH_TOKENS") {
           const { access_token, refresh_token, token_type, expires_in, refresh_expires_in, projectId, state: returnedState } = event.data;
           try {
-            const expected = sessionStorage.getItem("blink_oauth_state");
+            const sessionStorage = getSessionStorage();
+            const expected = sessionStorage?.getItem("blink_oauth_state");
             if (returnedState && expected && returnedState !== expected) {
               reject(new BlinkAuthError("VERIFICATION_FAILED" /* VERIFICATION_FAILED */, "State mismatch"));
               clearTimeout(timeoutId);
@@ -2072,6 +2464,48 @@ var BlinkAuth = class {
     };
     await this.setTokens(tokens, persist);
   }
+  /**
+   * Manually set auth session from tokens (React Native deep link OAuth)
+   * 
+   * Use this method to set the user session after receiving tokens from a deep link callback.
+   * This is the React Native equivalent of automatic URL token detection on web.
+   * 
+   * @param tokens - Auth tokens received from deep link or OAuth callback
+   * @param persist - Whether to persist tokens to storage (default: true)
+   * 
+   * @example
+   * // React Native: Handle deep link OAuth callback
+   * import * as Linking from 'expo-linking'
+   * 
+   * Linking.addEventListener('url', async ({ url }) => {
+   *   const { queryParams } = Linking.parse(url)
+   *   
+   *   if (queryParams.access_token) {
+   *     await blink.auth.setSession({
+   *       access_token: queryParams.access_token,
+   *       refresh_token: queryParams.refresh_token,
+   *       expires_in: parseInt(queryParams.expires_in) || 3600,
+   *       refresh_expires_in: parseInt(queryParams.refresh_expires_in)
+   *     })
+   *     
+   *     console.log('User authenticated:', blink.auth.currentUser())
+   *   }
+   * })
+   */
+  async setSession(tokens, persist = true) {
+    const authTokens = {
+      access_token: tokens.access_token,
+      refresh_token: tokens.refresh_token,
+      token_type: "Bearer",
+      expires_in: tokens.expires_in || 3600,
+      // Default 1 hour
+      refresh_expires_in: tokens.refresh_expires_in,
+      issued_at: Math.floor(Date.now() / 1e3)
+    };
+    await this.setTokens(authTokens, persist);
+    const user = await this.me();
+    return user;
+  }
   /**
    * Refresh access token using refresh token
    */
@@ -2305,12 +2739,13 @@ var BlinkAuth = class {
     }
   }
   extractTokensFromUrl() {
-    if (typeof window === "undefined") return null;
-    const params = new URLSearchParams(window.location.search);
+    const search = getLocationSearch();
+    if (!search) return null;
+    const params = new URLSearchParams(search);
     const accessToken = params.get("access_token");
     const refreshToken = params.get("refresh_token");
     console.log("\u{1F50D} Extracting tokens from URL:", {
-      url: window.location.href,
+      url: getLocationHref(),
       accessToken: accessToken ? `${accessToken.substring(0, 20)}...` : null,
       refreshToken: refreshToken ? `${refreshToken.substring(0, 20)}...` : null,
       allParams: Object.fromEntries(params.entries())
@@ -2337,8 +2772,9 @@ var BlinkAuth = class {
     return null;
   }
   clearUrlTokens() {
-    if (typeof window === "undefined") return;
-    const url = new URL(window.location.href);
+    const href = getLocationHref();
+    if (!href || !hasWindowLocation()) return;
+    const url = new URL(href);
     url.searchParams.delete("access_token");
     url.searchParams.delete("refresh_token");
     url.searchParams.delete("token_type");
@@ -2353,7 +2789,7 @@ var BlinkAuth = class {
     console.log("\u{1F9F9} URL cleaned up, removed auth parameters");
   }
   redirectToAuth() {
-    if (typeof window !== "undefined") {
+    if (hasWindowLocation()) {
       this.login();
     }
   }
@@ -2385,12 +2821,25 @@ var BlinkAuth = class {
       return Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
     }
   }
+  /**
+   * Generate unique session ID for mobile OAuth
+   */
+  generateSessionId() {
+    if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+      const array = new Uint8Array(32);
+      crypto.getRandomValues(array);
+      return Array.from(array, (byte) => byte.toString(16).padStart(2, "0")).join("");
+    } else {
+      return Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
+    }
+  }
   /**
    * Extract magic link token from URL
    */
   extractMagicTokenFromUrl() {
-    if (typeof window === "undefined") return null;
-    const params = new URLSearchParams(window.location.search);
+    const search = getLocationSearch();
+    if (!search) return null;
+    const params = new URLSearchParams(search);
     return params.get("magic_token") || params.get("token");
   }
   /**
@@ -2446,7 +2895,7 @@ var BlinkAuth = class {
    * Setup cross-tab authentication synchronization
    */
   setupCrossTabSync() {
-    if (!isWeb) return;
+    if (!isWeb || !hasWindow()) return;
     window.addEventListener("storage", (e) => {
       if (e.key === this.getStorageKey("tokens")) {
         const newTokens = e.newValue ? JSON.parse(e.newValue) : null;
@@ -4750,9 +5199,9 @@ var BlinkAnalyticsImpl = class {
       user_id: this.userId,
       user_email: this.userEmail,
       session_id: sessionId,
-      pathname: window.location.pathname,
-      referrer: document.referrer || null,
-      screen_width: window.innerWidth,
+      pathname: getLocationPathname(),
+      referrer: getDocumentReferrer(),
+      screen_width: getWindowInnerWidth(),
       channel,
       utm_source: this.utmParams.utm_source || this.persistedAttribution.utm_source || null,
       utm_medium: this.utmParams.utm_medium || this.persistedAttribution.utm_medium || null,
@@ -4905,7 +5354,7 @@ var BlinkAnalyticsImpl = class {
     window.__blinkAnalyticsInstances?.add(this);
   }
   setupUnloadListener() {
-    if (!isWeb) return;
+    if (!isWeb || !hasWindow()) return;
     window.addEventListener("pagehide", () => {
       this.flush();
     });
@@ -4915,7 +5364,12 @@ var BlinkAnalyticsImpl = class {
   }
   captureUTMParams() {
     if (!isWeb) return;
-    const urlParams = new URLSearchParams(window.location.search);
+    const search = getLocationSearch();
+    if (!search) {
+      this.utmParams = {};
+      return;
+    }
+    const urlParams = new URLSearchParams(search);
     this.utmParams = {
       utm_source: urlParams.get("utm_source"),
       utm_medium: urlParams.get("utm_medium"),
@@ -4952,7 +5406,7 @@ var BlinkAnalyticsImpl = class {
     }
   }
   detectChannel() {
-    const referrer = document.referrer;
+    const referrer = getDocumentReferrer();
     const utmMedium = this.utmParams.utm_medium;
     this.utmParams.utm_source;
     if (utmMedium) {