@clianta/sdk 1.6.5 → 1.6.7

package/dist/vue.esm.js

@@ -1,5 +1,5 @@
 /*!
- * Clianta SDK v1.6.5
+ * Clianta SDK v1.6.7
  * (c) 2026 Clianta
  * Released under the MIT License.
  */
@@ -10,7 +10,7 @@ import { ref, inject } from 'vue';
  * @see SDK_VERSION in core/config.ts
  */
 /** SDK Version */
-const SDK_VERSION = '1.6.5';
+const SDK_VERSION = '1.6.7';
 /** Default API endpoint — reads from env or falls back to localhost */
 const getDefaultApiEndpoint = () => {
     // Next.js (process.env)
@@ -2314,19 +2314,26 @@ class AutoIdentifyPlugin extends BasePlugin {
         if (typeof window === 'undefined')
             return;
         // First check after 2 seconds (give auth providers time to init)
-        setTimeout(() => this.checkForAuthUser(), 2000);
+        setTimeout(() => {
+            try {
+                this.checkForAuthUser();
+            }
+            catch { /* silently fail */ }
+        }, 2000);
         // Then check periodically
         this.checkInterval = setInterval(() => {
             this.checkCount++;
             if (this.checkCount >= this.MAX_CHECKS) {
-                // Stop checking after MAX_CHECKS — user probably isn't logged in
                 if (this.checkInterval) {
                     clearInterval(this.checkInterval);
                     this.checkInterval = null;
                 }
                 return;
             }
-            this.checkForAuthUser();
+            try {
+                this.checkForAuthUser();
+            }
+            catch { /* silently fail */ }
         }, this.CHECK_INTERVAL_MS);
     }
     destroy() {
@@ -2342,24 +2349,131 @@ class AutoIdentifyPlugin extends BasePlugin {
     checkForAuthUser() {
         if (!this.tracker || this.identifiedEmail)
             return;
-        // 1. Check cookies for JWTs
-        const cookieUser = this.checkCookies();
-        if (cookieUser) {
-            this.identifyUser(cookieUser);
-            return;
+        // 0. Check well-known auth provider globals (most reliable)
+        try {
+            const providerUser = this.checkAuthProviders();
+            if (providerUser) {
+                this.identifyUser(providerUser);
+                return;
+            }
         }
-        // 2. Check localStorage
-        const localUser = this.checkStorage(localStorage);
-        if (localUser) {
-            this.identifyUser(localUser);
-            return;
+        catch { /* provider check failed */ }
+        try {
+            // 1. Check cookies for JWTs
+            const cookieUser = this.checkCookies();
+            if (cookieUser) {
+                this.identifyUser(cookieUser);
+                return;
+            }
         }
-        // 3. Check sessionStorage
-        const sessionUser = this.checkStorage(sessionStorage);
-        if (sessionUser) {
-            this.identifyUser(sessionUser);
-            return;
+        catch { /* cookie access blocked */ }
+        try {
+            // 2. Check localStorage
+            if (typeof localStorage !== 'undefined') {
+                const localUser = this.checkStorage(localStorage);
+                if (localUser) {
+                    this.identifyUser(localUser);
+                    return;
+                }
+            }
+        }
+        catch { /* localStorage access blocked */ }
+        try {
+            // 3. Check sessionStorage
+            if (typeof sessionStorage !== 'undefined') {
+                const sessionUser = this.checkStorage(sessionStorage);
+                if (sessionUser) {
+                    this.identifyUser(sessionUser);
+                    return;
+                }
+            }
+        }
+        catch { /* sessionStorage access blocked */ }
+    }
+    /**
+     * Check well-known auth provider globals on window
+     * These are the most reliable — they expose user data directly
+     */
+    checkAuthProviders() {
+        const win = window;
+        // ─── Clerk ───
+        // Clerk exposes window.Clerk after initialization
+        try {
+            const clerkUser = win.Clerk?.user;
+            if (clerkUser) {
+                const email = clerkUser.primaryEmailAddress?.emailAddress
+                    || clerkUser.emailAddresses?.[0]?.emailAddress;
+                if (email) {
+                    return {
+                        email,
+                        firstName: clerkUser.firstName || undefined,
+                        lastName: clerkUser.lastName || undefined,
+                    };
+                }
+            }
+        }
+        catch { /* Clerk not available */ }
+        // ─── Firebase Auth ───
+        try {
+            const fbAuth = win.firebase?.auth?.();
+            const fbUser = fbAuth?.currentUser;
+            if (fbUser?.email) {
+                const parts = (fbUser.displayName || '').split(' ');
+                return {
+                    email: fbUser.email,
+                    firstName: parts[0] || undefined,
+                    lastName: parts.slice(1).join(' ') || undefined,
+                };
+            }
+        }
+        catch { /* Firebase not available */ }
+        // ─── Supabase ───
+        try {
+            const sbClient = win.__SUPABASE_CLIENT__ || win.supabase;
+            if (sbClient?.auth) {
+                // Supabase v2 stores session
+                const session = sbClient.auth.session?.() || sbClient.auth.getSession?.();
+                const user = session?.data?.session?.user || session?.user;
+                if (user?.email) {
+                    const meta = user.user_metadata || {};
+                    return {
+                        email: user.email,
+                        firstName: meta.first_name || meta.full_name?.split(' ')[0] || undefined,
+                        lastName: meta.last_name || meta.full_name?.split(' ').slice(1).join(' ') || undefined,
+                    };
+                }
+            }
+        }
+        catch { /* Supabase not available */ }
+        // ─── Auth0 SPA ───
+        try {
+            const auth0 = win.__auth0Client || win.auth0Client;
+            if (auth0?.isAuthenticated?.()) {
+                const user = auth0.getUser?.();
+                if (user?.email) {
+                    return {
+                        email: user.email,
+                        firstName: user.given_name || user.name?.split(' ')[0] || undefined,
+                        lastName: user.family_name || user.name?.split(' ').slice(1).join(' ') || undefined,
+                    };
+                }
+            }
         }
+        catch { /* Auth0 not available */ }
+        // ─── Global clianta identify hook ───
+        // Any auth system can set: window.__clianta_user = { email, firstName, lastName }
+        try {
+            const manualUser = win.__clianta_user;
+            if (manualUser?.email && typeof manualUser.email === 'string' && manualUser.email.includes('@')) {
+                return {
+                    email: manualUser.email,
+                    firstName: manualUser.firstName || undefined,
+                    lastName: manualUser.lastName || undefined,
+                };
+            }
+        }
+        catch { /* manual user not set */ }
+        return null;
     }
     /**
      * Identify the user and stop checking