@vertesia/ui 1.2.0 → 1.4.0-dev.20260615.042549Z

package/src/session/auth/composable.ts

@@ -1,9 +1,9 @@
 /**
  * Handle client caching and refresh of auth token
  */
-import { AuthTokenPayload } from "@vertesia/common";
-import { jwtDecode } from "jwt-decode";
+import type { AuthTokenPayload } from '@vertesia/common';
 import { Env } from '@vertesia/ui/env';
+import { jwtDecode } from 'jwt-decode';
 import { LastSelectedAccountId_KEY, LastSelectedProjectId_KEY } from '../constants';
 import { getFirebaseAuth, getFirebaseAuthToken } from './firebase';
 
@@ -17,7 +17,31 @@ interface ComposableTokenResponse {
     message?: string;
 }
 
-export async function fetchComposableToken(getIdToken: () => Promise<string | null | undefined>, accountId?: string, projectId?: string, ttl?: number, retryCount = 0): Promise<string> {
+function normalizeIssuer(value: string | undefined): string | undefined {
+    return value?.replace(/\/+$/, '');
+}
+
+function decodeToken(token: string): AuthTokenPayload {
+    return jwtDecode(token) as AuthTokenPayload;
+}
+
+function isVertesiaIssuedToken(token: string | undefined): token is string {
+    if (!token) return false;
+    try {
+        const decoded = decodeToken(token) as AuthTokenPayload & { iss?: string };
+        return normalizeIssuer(decoded.iss) === normalizeIssuer(Env.endpoints.sts);
+    } catch {
+        return false;
+    }
+}
+
+export async function fetchComposableToken(
+    getIdToken: () => Promise<string | null | undefined>,
+    accountId?: string,
+    projectId?: string,
+    ttl?: number,
+    retryCount = 0,
+): Promise<string> {
     console.log(`Getting/refreshing composable token for account ${accountId} and project ${projectId} `);
     Env.logger.info('Getting/refreshing composable token', {
         vertesia: {
@@ -46,7 +70,7 @@ export async function fetchComposableToken(getIdToken: () => Promise<string | nu
 
     try {
         // Call STS to generate a user token
-        const stsUrl = new URL(stsEndpoint + '/token/issue');
+        const stsUrl = new URL(`${stsEndpoint}/token/issue`);
         const requestBody = {
             type: 'user',
             account_id: accountId,
@@ -58,9 +82,9 @@ export async function fetchComposableToken(getIdToken: () => Promise<string | nu
             method: 'POST',
             headers: {
                 'Content-Type': 'application/json',
-                'Authorization': `Bearer ${idToken}` // Firebase token for authentication
+                Authorization: `Bearer ${idToken}`, // Firebase token for authentication
             },
-            body: JSON.stringify(requestBody)
+            body: JSON.stringify(requestBody),
         }).catch((error) => {
             console.error('Failed to call STS endpoint', error);
             Env.logger.error('Failed to call STS endpoint', {
@@ -80,16 +104,16 @@ export async function fetchComposableToken(getIdToken: () => Promise<string | nu
                 vertesia: {
                     account_id: accountId,
                     project_id: projectId,
-                    status: stsRes?.status
+                    status: stsRes?.status,
                 },
             });
 
-            const ensureResponse = await fetch(Env.endpoints.studio + '/auth/ensure-user', {
+            const ensureResponse = await fetch(`${Env.endpoints.studio}/auth/ensure-user`, {
                 method: 'POST',
                 headers: {
-                    'Authorization': `Bearer ${idToken}`,
-                    'Content-Type': 'application/json'
-                }
+                    Authorization: `Bearer ${idToken}`,
+                    'Content-Type': 'application/json',
+                },
             });
 
             if (ensureResponse.status === 412) {
@@ -99,9 +123,9 @@ export async function fetchComposableToken(getIdToken: () => Promise<string | nu
                     vertesia: {
                         account_id: accountId,
                         project_id: projectId,
-                    }
+                    },
                 });
-                const idTokenDecoded = jwtDecode(idToken) as any;
+                const idTokenDecoded = jwtDecode<{ email?: string }>(idToken);
                 if (!idTokenDecoded?.email) {
                     Env.logger.error('No email found in id token');
                     throw new Error('No email found in id token');
@@ -109,6 +133,17 @@ export async function fetchComposableToken(getIdToken: () => Promise<string | nu
                 throw new UserNotFoundError('User not found - signup required', idTokenDecoded.email);
             }
 
+            if (ensureResponse.status === 403) {
+                // SigninScreen keys the invite-required view off this message.
+                Env.logger.warn('403: Customer-domain user requires an invite to join', {
+                    vertesia: {
+                        account_id: accountId,
+                        project_id: projectId,
+                    },
+                });
+                throw new Error('Customer-domain user requires an invite to join');
+            }
+
             if (!ensureResponse.ok) {
                 console.error('Failed to ensure user exists', ensureResponse.status);
                 Env.logger.error('Failed to ensure user exists', {
@@ -127,7 +162,7 @@ export async function fetchComposableToken(getIdToken: () => Promise<string | nu
                 vertesia: {
                     account_id: accountId,
                     project_id: projectId,
-                }
+                },
             });
             return fetchComposableToken(getIdToken, accountId, projectId, ttl, retryCount);
         }
@@ -138,10 +173,10 @@ export async function fetchComposableToken(getIdToken: () => Promise<string | nu
                 vertesia: {
                     account_id: accountId,
                     project_id: projectId,
-                    status: stsRes?.status
+                    status: stsRes?.status,
                 },
             });
-            const idTokenDecoded = jwtDecode(idToken) as any;
+            const idTokenDecoded = jwtDecode<{ email?: string }>(idToken);
             if (!idTokenDecoded?.email) {
                 Env.logger.error('No email found in id token');
                 throw new Error('No email found in id token');
@@ -150,8 +185,8 @@ export async function fetchComposableToken(getIdToken: () => Promise<string | nu
                 vertesia: {
                     account_id: accountId,
                     project_id: projectId,
-                    email: idTokenDecoded.email
-                }
+                    email: idTokenDecoded.email,
+                },
             });
             throw new UserNotFoundError('User not found', idTokenDecoded.email);
         }
@@ -171,7 +206,7 @@ export async function fetchComposableToken(getIdToken: () => Promise<string | nu
                         account_id: accountId,
                         project_id: projectId,
                         status: stsRes.status,
-                        retry_count: retryCount
+                        retry_count: retryCount,
                     },
                 });
                 throw new Error('Access denied - user may not have access to any accounts');
@@ -183,14 +218,14 @@ export async function fetchComposableToken(getIdToken: () => Promise<string | nu
                     account_id: accountId,
                     project_id: projectId,
                     status: stsRes.status,
-                    retry_count: retryCount
+                    retry_count: retryCount,
                 },
             });
 
             // Clear any stale account/project from localStorage
             localStorage.removeItem(LastSelectedAccountId_KEY);
             if (accountId) {
-                localStorage.removeItem(LastSelectedProjectId_KEY + '-' + accountId);
+                localStorage.removeItem(`${LastSelectedProjectId_KEY}-${accountId}`);
             }
 
             // Retry without account/project scope - let user log in to their default account
@@ -215,7 +250,6 @@ export async function fetchComposableToken(getIdToken: () => Promise<string | nu
         console.log('Successfully got token from STS');
         Env.logger.info('Successfully got token from STS');
         return token;
-
     } catch (error) {
         if (error instanceof UserNotFoundError || error instanceof STSError) {
             throw error; // Re-throw UserNotFoundError and STSError to be handled separately in the caller
@@ -224,7 +258,7 @@ export async function fetchComposableToken(getIdToken: () => Promise<string | nu
         // Clear any stale account/project from localStorage on error
         localStorage.removeItem(LastSelectedAccountId_KEY);
         if (accountId) {
-            localStorage.removeItem(LastSelectedProjectId_KEY + '-' + accountId);
+            localStorage.removeItem(`${LastSelectedProjectId_KEY}-${accountId}`);
         }
         console.error('Failed to get composable token from STS', error);
         Env.logger.error('Failed to get composable token from STS', {
@@ -249,23 +283,65 @@ export async function fetchComposableTokenFromFirebaseToken(accountId?: string,
     return fetchComposableToken(getFirebaseAuthToken, accountId, projectId, ttl);
 }
 
-export async function getComposableToken(accountId?: string, projectId?: string, initToken?: string, forceRefresh = false, useInternalAuth = false): Promise<ComposableTokenResponse> {
+/**
+ * Mint a scoped Vertesia token from an existing Vertesia JWT. STS accepts STS-issued
+ * tokens on /token/issue, so this works for sessions established via Central Auth where
+ * the browser has no Firebase user.
+ */
+export async function fetchComposableTokenFromVertesiaToken(
+    vertesiaToken: string,
+    accountId?: string,
+    projectId?: string,
+    ttl?: number,
+) {
+    return fetchComposableToken(() => Promise.resolve(vertesiaToken), accountId, projectId, ttl);
+}
+
+/** Returns the cached Vertesia raw JWT, if any. Does not refresh. */
+export function getCurrentVertesiaToken(): string | undefined {
+    return AUTH_TOKEN_RAW;
+}
 
-    const selectedAccount = accountId ?? localStorage.getItem(LastSelectedAccountId_KEY) ?? undefined
-    const selectedProject = projectId ?? localStorage.getItem(LastSelectedProjectId_KEY + '-' + selectedAccount) ?? undefined
+export async function getComposableToken(
+    accountId?: string,
+    projectId?: string,
+    initToken?: string,
+    forceRefresh = false,
+    useInternalAuth = false,
+): Promise<ComposableTokenResponse> {
+    const selectedAccount = accountId ?? localStorage.getItem(LastSelectedAccountId_KEY) ?? undefined;
+    const selectedProject =
+        projectId ?? localStorage.getItem(`${LastSelectedProjectId_KEY}-${selectedAccount}`) ?? undefined;
+    const devAuthToken = Env.isLocalDev ? Env.devAuthToken : undefined;
+    const suppliedToken = devAuthToken ?? initToken ?? AUTH_TOKEN_RAW;
 
     //token is still valid for more than 5 minutes
-    if (!forceRefresh && AUTH_TOKEN_RAW && AUTH_TOKEN && AUTH_TOKEN.exp > (Date.now() / 1000 + 300)) {
+    if (!forceRefresh && AUTH_TOKEN_RAW && AUTH_TOKEN && AUTH_TOKEN.exp > Date.now() / 1000 + 300) {
+        return { rawToken: AUTH_TOKEN_RAW, token: AUTH_TOKEN, error: false };
+    }
+
+    if (!forceRefresh && isVertesiaIssuedToken(suppliedToken)) {
+        AUTH_TOKEN_RAW = suppliedToken;
+        AUTH_TOKEN = decodeToken(AUTH_TOKEN_RAW);
+        if (!AUTH_TOKEN.exp) {
+            throw new Error('Invalid composable token');
+        }
         return { rawToken: AUTH_TOKEN_RAW, token: AUTH_TOKEN, error: false };
     }
 
     //token is close to expire, refresh it
-    if (!useInternalAuth && getFirebaseAuth().currentUser) {
+    if (!devAuthToken && !useInternalAuth && getFirebaseAuth().currentUser) {
         //we have a firebase user, get the token from there
         AUTH_TOKEN_RAW = await fetchComposableTokenFromFirebaseToken(selectedAccount, selectedProject);
-    } else if (initToken || AUTH_TOKEN_RAW) {
+    } else if (!devAuthToken && (initToken || AUTH_TOKEN_RAW)) {
         // we have a token already and no firebase user, refresh it
-        AUTH_TOKEN_RAW = await fetchComposableToken(() => Promise.resolve(initToken ?? AUTH_TOKEN_RAW), selectedAccount, selectedProject);
+        AUTH_TOKEN_RAW = await fetchComposableToken(
+            () => Promise.resolve(initToken ?? AUTH_TOKEN_RAW),
+            selectedAccount,
+            selectedProject,
+        );
+    } else if (devAuthToken) {
+        AUTH_TOKEN_RAW = devAuthToken;
     }
 
     if (!AUTH_TOKEN_RAW) {
@@ -278,9 +354,9 @@ export async function getComposableToken(accountId?: string, projectId?: string,
         throw new Error('Cannot acquire a composable token');
     }
 
-    AUTH_TOKEN = jwtDecode(AUTH_TOKEN_RAW) as AuthTokenPayload;
+    AUTH_TOKEN = decodeToken(AUTH_TOKEN_RAW);
 
-    if (!AUTH_TOKEN || !AUTH_TOKEN.exp || !AUTH_TOKEN_RAW) {
+    if (!AUTH_TOKEN?.exp || !AUTH_TOKEN_RAW) {
         console.error('Invalid composable token', AUTH_TOKEN);
         Env.logger.error('Invalid composable token', {
             vertesia: {
@@ -292,7 +368,6 @@ export async function getComposableToken(accountId?: string, projectId?: string,
     }
 
     return { rawToken: AUTH_TOKEN_RAW, token: AUTH_TOKEN, error: false };
-
 }
 
 export class UserNotFoundError extends Error {

package/src/session/auth/domainRouting.test.ts

@@ -1,25 +1,25 @@
-import { afterEach, describe, expect, it } from "vitest";
-import { shouldRedirectToCentralAuth, shouldUseFirebaseAuth } from "./domainRouting";
+import { afterEach, describe, expect, it } from 'vitest';
+import { shouldRedirectToCentralAuth, shouldUseFirebaseAuth } from './domainRouting';
 
-describe("domainRouting", () => {
+describe('domainRouting', () => {
     afterEach(() => {
-        delete (globalThis as any).window;
+        delete (globalThis as { window?: unknown }).window;
     });
 
     it("uses Firebase auth when AUTH_MODE is 'firebase'", () => {
-        (globalThis as any).window = { AUTH_MODE: "firebase" };
+        (globalThis as { window?: unknown }).window = { AUTH_MODE: 'firebase' };
         expect(shouldUseFirebaseAuth()).toBe(true);
         expect(shouldRedirectToCentralAuth()).toBe(false);
     });
 
     it("uses central auth when AUTH_MODE is 'central'", () => {
-        (globalThis as any).window = { AUTH_MODE: "central" };
+        (globalThis as { window?: unknown }).window = { AUTH_MODE: 'central' };
         expect(shouldUseFirebaseAuth()).toBe(false);
         expect(shouldRedirectToCentralAuth()).toBe(true);
     });
 
-    it("defaults to central auth when AUTH_MODE is not set", () => {
-        (globalThis as any).window = {};
+    it('defaults to central auth when AUTH_MODE is not set', () => {
+        (globalThis as { window?: unknown }).window = {};
         expect(shouldUseFirebaseAuth()).toBe(false);
         expect(shouldRedirectToCentralAuth()).toBe(true);
     });

package/src/session/auth/firebase.ts

@@ -1,8 +1,8 @@
-import { UIResolvedTenant } from "@vertesia/common";
-import { Env } from "@vertesia/ui/env";
-import { Analytics, getAnalytics } from "firebase/analytics";
-import { FirebaseApp, initializeApp } from "firebase/app";
-import { Auth, getAuth } from "firebase/auth";
+import type { UIResolvedTenant } from '@vertesia/common';
+import { Env } from '@vertesia/ui/env';
+import { type Analytics, getAnalytics } from 'firebase/analytics';
+import { type FirebaseApp, initializeApp } from 'firebase/app';
+import { type Auth, getAuth } from 'firebase/auth';
 
 // Use lazy initialization to avoid accessing Env before it's initialized
 let _firebaseApp: FirebaseApp | null = null;
@@ -14,12 +14,14 @@ export function getFirebaseApp(): FirebaseApp {
     if (!_firebaseApp) {
         try {
             if (!Env.firebase) {
-                throw new Error("Firebase configuration is not available in the environment");
+                throw new Error('Firebase configuration is not available in the environment');
             }
             _firebaseApp = initializeApp(Env.firebase);
         } catch (error) {
-            console.error("Failed to initialize Firebase app:", error);
-            throw new Error("Firebase initialization failed - environment may not be properly initialized", { cause: error });
+            console.error('Failed to initialize Firebase app:', error);
+            throw new Error('Firebase initialization failed - environment may not be properly initialized', {
+                cause: error,
+            });
         }
     }
     return _firebaseApp;
@@ -39,15 +41,14 @@ export function getFirebaseAuth(): Auth {
     return _firebaseAuth;
 }
 
-
 export async function setFirebaseTenant(tenantEmail?: string) {
     if (!tenantEmail) {
-        console.log("No tenant name or email specified, skipping tenant setup");
+        console.log('No tenant name or email specified, skipping tenant setup');
         return;
     }
 
     if (!Env.firebase) {
-        console.log("Firebase configuration is not available in the environment");
+        console.log('Firebase configuration is not available in the environment');
         return;
     }
 
@@ -61,10 +62,10 @@ export async function setFirebaseTenant(tenantEmail?: string) {
         while (retries > 0) {
             try {
                 // Call the API endpoint to resolve the tenant ID
-                const response = await fetch("/api/resolve-tenant", {
-                    method: "POST",
+                const response = await fetch('/api/resolve-tenant', {
+                    method: 'POST',
                     headers: {
-                        "Content-Type": "application/json",
+                        'Content-Type': 'application/json',
                     },
                     body: JSON.stringify({
                         tenantEmail: tenantEmail,
@@ -75,7 +76,7 @@ export async function setFirebaseTenant(tenantEmail?: string) {
 
                 // Check for network errors
                 if (!response) {
-                    throw new Error("No response received from tenant API");
+                    throw new Error('No response received from tenant API');
                 }
 
                 // Handle HTTP error responses
@@ -83,8 +84,8 @@ export async function setFirebaseTenant(tenantEmail?: string) {
                     // Try to parse the error response
                     try {
                         const errorData = await response.json();
-                        console.error("Failed to resolve tenant ID:", errorData.error);
-                    } catch (parseError) {
+                        console.error('Failed to resolve tenant ID:', errorData.error);
+                    } catch {
                         console.error(`Failed to resolve tenant ID: HTTP ${response.status}`);
                     }
 
@@ -100,10 +101,10 @@ export async function setFirebaseTenant(tenantEmail?: string) {
                 // Successfully got a response, parse it
                 const data = (await response.json()) as UIResolvedTenant;
 
-                if (data && data.firebaseTenantId) {
+                if (data?.firebaseTenantId) {
                     const auth = getFirebaseAuth();
                     auth.tenantId = data.firebaseTenantId;
-                    Env.firebase.providerType = data.provider ?? "oidc";
+                    Env.firebase.providerType = data.provider ?? 'oidc';
                     console.log(`Tenant ID set to ${auth.tenantId}`);
                     return data;
                 } else {
@@ -124,7 +125,7 @@ export async function setFirebaseTenant(tenantEmail?: string) {
         }
     } catch (error) {
         // Final error handler
-        console.error("Error setting Firebase tenant:", error instanceof Error ? error.message : "Unknown error");
+        console.error('Error setting Firebase tenant:', error instanceof Error ? error.message : 'Unknown error');
 
         // Continue without tenant ID - authentication will work without multi-tenancy
         // but the user will access the default tenant
@@ -138,7 +139,7 @@ export async function getFirebaseAuthToken(refresh?: boolean) {
         return user
             .getIdToken(refresh)
             .then((token) => {
-                Env.logger.info("Got Firebase token", {
+                Env.logger.info('Got Firebase token', {
                     vertesia: {
                         user_email: user.email,
                         user_name: user.displayName,
@@ -149,7 +150,7 @@ export async function getFirebaseAuthToken(refresh?: boolean) {
                 return token;
             })
             .catch((err) => {
-                Env.logger.error("Failed to get Firebase token", {
+                Env.logger.error('Failed to get Firebase token', {
                     vertesia: {
                         user_email: user.email,
                         user_name: user.displayName,
@@ -158,11 +159,11 @@ export async function getFirebaseAuthToken(refresh?: boolean) {
                         error: err,
                     },
                 });
-                console.error("Failed to get access token", err);
+                console.error('Failed to get access token', err);
                 return null;
             });
     } else {
-        Env.logger.warn("No user found");
+        Env.logger.warn('No user found');
         return Promise.resolve(null);
     }
 }

package/src/session/auth/useAuthState.ts

@@ -1,27 +1,24 @@
-
 /**
  * This hook is used to generate and verify state for OAuth2 authorization requests.
- * @returns 
+ * @returns
  */
 
-import { useCallback } from "react";
-
+import { useCallback } from 'react';
 
 const AUTH_STATE_KEY = 'auth_state';
 const STATE_EXPIRY_KEY = 'auth_state_expiry';
 const STATE_TTL = 5 * 60 * 1000; // 5 min
 
-
 export function useAuthState() {
     // Generate new state
     const generateState = useCallback(() => {
         const state = crypto.randomUUID();
         const expiryTime = Date.now() + STATE_TTL;
-        
+
         // Store state and expiry
         sessionStorage.setItem(AUTH_STATE_KEY, state);
         sessionStorage.setItem(STATE_EXPIRY_KEY, expiryTime.toString());
-        
+
         return state;
     }, []);
 
@@ -32,7 +29,7 @@ export function useAuthState() {
         }
 
         const savedState = sessionStorage.getItem(AUTH_STATE_KEY);
-        const expiryTime = parseInt(sessionStorage.getItem(STATE_EXPIRY_KEY) || '0');
+        const expiryTime = parseInt(sessionStorage.getItem(STATE_EXPIRY_KEY) || '0', 10);
         let reason: string | undefined;
 
         // Verify state matches and hasn't expired

package/src/session/auth/useCurrentTenant.ts

@@ -1,6 +1,6 @@
-import { useState, useEffect } from 'react';
-import { useUserSession } from "@vertesia/ui/session";
-import { i18nInstance, NAMESPACE } from '../../i18n/instance.js';
+import { i18nInstance, NAMESPACE } from '@vertesia/ui/i18n';
+import { useEffect, useState } from 'react';
+import { useUserSession } from '../UserSession';
 
 interface TenantConfig {
     tenantKey: string;
@@ -12,7 +12,6 @@ interface TenantConfig {
 }
 
 export function useCurrentTenant() {
-    const t = i18nInstance.getFixedT(null, NAMESPACE);
     const { user } = useUserSession();
     const [currentTenant, setCurrentTenant] = useState<TenantConfig | null>(null);
     const [isLoading, setIsLoading] = useState(true);
@@ -33,8 +32,8 @@ export function useCurrentTenant() {
                         'Content-Type': 'application/json',
                     },
                     body: JSON.stringify({
-                        tenantEmail: user.email
-                    })
+                        tenantEmail: user.email,
+                    }),
                 });
 
                 if (response.ok) {
@@ -47,7 +46,7 @@ export function useCurrentTenant() {
                             domain: tenantData.domain || [],
                             firebaseTenantId: tenantData.firebaseTenantId,
                             provider: tenantData.provider,
-                            logo: tenantData.logo
+                            logo: tenantData.logo,
                         });
                     } else {
                         setCurrentTenant(null);
@@ -57,19 +56,19 @@ export function useCurrentTenant() {
                 }
             } catch (error) {
                 console.error('Error loading current tenant:', error);
-                setError(t('errors.failedToLoadTenantConfig'));
+                setError(i18nInstance.getFixedT(null, NAMESPACE)('errors.failedToLoadTenantConfig'));
                 setCurrentTenant(null);
             } finally {
                 setIsLoading(false);
             }
         };
 
-        loadCurrentTenant();
+        void loadCurrentTenant();
     }, [user?.email]);
 
     return {
         currentTenant,
         isLoading,
-        error
+        error,
     };
-}
+}

package/src/session/constants.ts

@@ -1,2 +1,2 @@
 export const LastSelectedAccountId_KEY = 'composableai.lastSelectedAccountId';
-export const LastSelectedProjectId_KEY = 'composableai.lastSelectedProjectId';
+export const LastSelectedProjectId_KEY = 'composableai.lastSelectedProjectId';

package/src/session/index.ts

@@ -1,7 +1,7 @@
-export * from "./auth/composable";
-export * from "./auth/useCurrentTenant";
-export * from "./auth/useAuthState";
-export * from "./auth/firebase";
-export * from "./UserSession";
-export * from "./UserSessionProvider";
-export * from "./useUXTracking";
+export * from './auth/composable';
+export * from './auth/firebase';
+export * from './auth/useAuthState';
+export * from './auth/useCurrentTenant';
+export * from './UserSession';
+export * from './UserSessionProvider';
+export * from './useUXTracking';

package/src/session/useUXTracking.tsx

@@ -1,38 +1,34 @@
+import type { AuthTokenPayload } from '@vertesia/common';
 import { Env } from '@vertesia/ui/env';
-import { AuthTokenPayload } from '@vertesia/common';
-import { logEvent } from "firebase/analytics";
-import { getFirebaseAnalytics } from "./auth/firebase";
+import { logEvent } from 'firebase/analytics';
+import { getFirebaseAnalytics } from './auth/firebase';
 
 export function useUXTracking() {
-
     //identify user in monitoring and UX systems
     const tagUserSession = async (user?: AuthTokenPayload) => {
-        const signupData = window.localStorage.getItem("composableSignupData");
+        const signupData = window.localStorage.getItem('composableSignupData');
         if (!user) {
             console.error('No user found -- skipping tagging');
             return;
         }
 
         if (signupData) {
-            window.localStorage.removeItem("composableSignupData");
+            window.localStorage.removeItem('composableSignupData');
         }
-    }
+    };
 
     //send event to analytics and UX systems
-    const trackEvent = (eventName: string, eventProperties?: any) => {
-
+    const trackEvent = (eventName: string, eventProperties?: Record<string, unknown>) => {
         if (!Env.isProd) {
             console.debug('track event', eventName, eventProperties);
         }
 
         //GA via firebase
         logEvent(getFirebaseAnalytics(), eventName, { ...eventProperties, debug_mode: !Env.isProd });
-
-    }
+    };
 
     return {
         tagUserSession,
-        trackEvent
-    }
-
-}
+        trackEvent,
+    };
+}