@iblai/web-utils 1.11.7 → 1.11.9

package/dist/auth/web-utils/src/providers/auth-provider.d.ts

@@ -0,0 +1,129 @@
+/**
+ * AuthProvider Component
+ *
+ * Provider that handles authentication state and route protection.
+ * It manages authentication checks, public route access, and redirects to auth SPA when needed.
+ *
+ * Platform Support:
+ * - Web (Next.js): Uses cookies for cross-SPA synchronization
+ * - React Native (Expo): Uses AsyncStorage only (no cookies)
+ *
+ * IMPORTANT: Cross-SPA Synchronization (Web Only)
+ * ================================================
+ * On web platforms, this component uses cookies to keep authentication state synchronized
+ * across multiple SPAs (e.g., skills and mentor) that share the same domain.
+ *
+ * To ensure proper synchronization on web, you MUST call the following functions:
+ *
+ * 1. On Login:
+ *    ```typescript
+ *    await storageService.setItem(LOCAL_STORAGE_KEYS.USER_DATA, userData);
+ *    await storageService.setItem(LOCAL_STORAGE_KEYS.CURRENT_TENANT, tenantKey);
+ *    await storageService.setItem(LOCAL_STORAGE_KEYS.TENANTS, tenants);
+ *    await syncAuthToCookies(storageService);
+ *    ```
+ *
+ * 2. On Logout:
+ *    ```typescript
+ *    await storageService.clear();
+ *    clearAuthCookies();
+ *    ```
+ *
+ * 3. On Tenant Switch:
+ *    ```typescript
+ *    await storageService.setItem(LOCAL_STORAGE_KEYS.CURRENT_TENANT, newTenantKey);
+ *    await syncAuthToCookies(storageService);
+ *    ```
+ *
+ * The AuthProvider automatically (web only):
+ * - Syncs cookies to localStorage on mount
+ * - Polls for cookie changes every 2 seconds
+ * - Refreshes the page when cross-SPA changes are detected
+ * - Listens for storage events to update cookies when localStorage changes
+ * - Monitors logout timestamp cookie to trigger cross-SPA logout
+ * - Automatically logs out when another SPA initiates logout
+ *
+ * For React Native:
+ * - Relies on AsyncStorage only (handled by StorageService)
+ * - No cookie synchronization
+ * - No cross-app automatic sync
+ */
+import React from "react";
+import { StorageService } from "@iblai/data-layer";
+/**
+ * Sync authentication state to cookies (web only)
+ * Should be called on login, logout, and tenant switch
+ * On React Native, this is a no-op
+ */
+export declare function syncAuthToCookies(storageService: StorageService): Promise<void>;
+export declare function hasNonExpiredAuthToken(): boolean;
+/**
+ * Clear current tenant cookie only (web only)
+ * Should be called before tenant switching
+ * On React Native, this is a no-op
+ */
+export declare function clearCurrentTenantCookie(): void;
+/**
+ * Clear all authentication cookies (web only)
+ * Should be called on logout
+ * On React Native, this is a no-op
+ */
+export declare function clearAuthCookies(): void;
+export declare function getStoredUserName(storageService: StorageService): Promise<any>;
+export declare function useAuthProvider({ middleware, onAuthSuccess, onAuthFailure, redirectToAuthSpa, username, pathname, storageService, skipAuthCheck, token, enableStorageSync, }: Props): {
+    isAuthenticating: boolean;
+    userIsAccessingPublicRoute: boolean;
+    setUserIsAccessingPublicRoute: React.Dispatch<React.SetStateAction<boolean>>;
+};
+/**
+ * Type definition for the authentication context
+ * Tracks whether the user is accessing a public route and provides a setter
+ */
+export type AuthContextType = {
+    userIsAccessingPublicRoute: boolean;
+    isLoggedIn: boolean;
+    setUserIsAccessingPublicRoute: (iuserIsAccessingPublicRoute: boolean) => void;
+};
+export declare const AuthContext: React.Context<AuthContextType | undefined>;
+/**
+ * Hook to access the auth context
+ * @throws Error if used outside of AuthContextProvider
+ */
+export declare const useAuthContext: () => AuthContextType;
+/**
+ * Context Provider component that wraps children with auth context
+ */
+export declare const AuthContextProvider: ({ value, children, }: {
+    value: AuthContextType;
+    children: React.ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+/**
+ * Props for the AuthProvider component
+ */
+type Props = {
+    children?: React.ReactNode;
+    fallback?: React.ReactNode;
+    middleware?: Map<string | RegExp, () => Promise<boolean>>;
+    onAuthSuccess?: () => void;
+    onAuthFailure?: (reason: string) => void;
+    redirectToAuthSpa: (redirectTo?: string, platformKey?: string, logout?: boolean, saveRedirect?: boolean) => void;
+    username: string;
+    pathname: string;
+    skipAuthCheck?: boolean;
+    storageService?: StorageService;
+    token?: string;
+    enableStorageSync?: boolean;
+    skip?: boolean;
+};
+/**
+ * AuthProvider Component
+ *
+ * Main authentication provider that:
+ * 1. Checks if the current route requires authentication
+ * 2. Validates the auth token
+ * 3. Fetches user metadata to verify authentication
+ * 4. Handles redirects to auth SPA when needed
+ * 5. Manages public route access state
+ */
+export declare function AuthProvider({ children, fallback, middleware, onAuthSuccess, onAuthFailure, redirectToAuthSpa, username, pathname, storageService, token, enableStorageSync, skip, }: Props): string | number | bigint | boolean | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | import("react/jsx-runtime").JSX.Element | null | undefined;
+export {};

package/dist/auth/web-utils/src/providers/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./auth-provider";
+export * from "./mentor-provider";
+export * from "./tenant-provider";
+export * from "./service-worker-provider";

package/dist/auth/web-utils/src/providers/mentor-provider.d.ts

@@ -0,0 +1,44 @@
+/**
+ * MentorProvider Component
+ *
+ * Provider that manages AI mentor selection and redirection logic.
+ * It handles:
+ * - Mentor selection based on user preferences and history
+ * - Mentor seeding for new tenants
+ * - Redirection to appropriate mentor or creation flow
+ * - Integration with tenant context for access control
+ */
+import React from "react";
+/**
+ * Props for the MentorProvider component
+ */
+type Props = {
+    children?: React.ReactNode;
+    fallback?: React.ReactNode;
+    onAuthSuccess?: () => void;
+    onAuthFailure?: (reason: string) => void;
+    redirectToAuthSpa: () => void;
+    redirectToMentor: (tenantKey: string, mentorId: string) => void;
+    onLoadMentorsPermissions?: (rbacPermissions: Record<string, unknown> | undefined) => void;
+    redirectToNoMentorsPage: () => void;
+    redirectToCreateMentor: () => void;
+    username: string;
+    isAdmin: boolean;
+    mainTenantKey: string;
+    requestedMentorId?: string;
+    handleMentorNotFound?: () => Promise<void>;
+    forceDetermineMentor?: boolean;
+    onComplete?: () => void;
+    skip?: boolean;
+};
+/**
+ * MentorProvider Component
+ *
+ * Main mentor provider that:
+ * 1. Determines the most appropriate mentor for the user
+ * 2. Handles mentor seeding for new tenants
+ * 3. Manages redirection based on mentor availability
+ * 4. Integrates with tenant context for access control
+ */
+export declare function MentorProvider({ children, fallback, onAuthSuccess, onAuthFailure, redirectToAuthSpa, redirectToMentor, onLoadMentorsPermissions, redirectToNoMentorsPage, redirectToCreateMentor, username, isAdmin, mainTenantKey, requestedMentorId, handleMentorNotFound, forceDetermineMentor, onComplete, skip, }: Props): string | number | bigint | boolean | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | import("react/jsx-runtime").JSX.Element | null | undefined;
+export {};

package/dist/auth/web-utils/src/providers/service-worker-provider.d.ts

@@ -0,0 +1,21 @@
+import { type ServiceWorkerStatus } from "../services/register-sw";
+interface ServiceWorkerContextValue {
+    status: ServiceWorkerStatus;
+    applyUpdate: () => void;
+    clearCache: () => void;
+    refreshCacheStatus: () => Promise<Record<string, number> | null>;
+    checkNetworkNow: () => Promise<boolean>;
+}
+export declare function useServiceWorker(): ServiceWorkerContextValue;
+interface ServiceWorkerProviderProps {
+    children: React.ReactNode;
+    /**
+     * Base path used when registering the service worker. The SW is fetched
+     * from `${basePath}/sw.js` and scoped to `basePath || '/'`. Pass the
+     * host app's bundler-resolved base path (e.g. Next.js's
+     * `process.env.NEXT_PUBLIC_BASE_PATH`). Defaults to '' (root).
+     */
+    basePath?: string;
+}
+export declare function ServiceWorkerProvider({ children, basePath, }: ServiceWorkerProviderProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/auth/web-utils/src/providers/tenant-provider.d.ts

@@ -0,0 +1,77 @@
+/**
+ * TenantProvider
+ *
+ * Provider that manages tenant-related state and access control.
+ * It handles:
+ * - Tenant validation and access control
+ * - Tenant switching logic
+ * - Tenant metadata retrieval
+ * - User-tenant relationship verification
+ */
+import React from "react";
+import { TokenResponse } from "@iblai/data-layer";
+import { Tenant } from "@web-utils/types";
+/**
+ * Type definition for the tenant context
+ * Tracks whether the user's path needs to be determined and provides a setter
+ */
+export type TenantContextType = {
+    determineUserPath: boolean;
+    setDetermineUserPath: (value: boolean) => void;
+    tenantKey: string;
+    setTenantKey: (tenantKey: string) => void;
+    metadata: Record<string, any>;
+    setMetadata: (metadata: Record<string, any>) => void;
+};
+export declare const TenantContext: React.Context<TenantContextType | undefined>;
+/**
+ * Context Provider component that wraps children with tenant context
+ */
+export declare const TenantContextProvider: React.FC<{
+    value: TenantContextType;
+    children: React.ReactNode;
+}>;
+/**
+ * Hook to access the tenant context
+ * @returns TenantContextType
+ */
+export declare const useTenantContext: () => TenantContextType;
+/**
+ * Props for the TenantProvider component
+ */
+type Props = {
+    children?: React.ReactNode;
+    fallback?: React.ReactNode;
+    onAuthSuccess?: () => void;
+    onAuthFailure?: (reason: string) => void;
+    currentTenant: string;
+    requestedTenant: string;
+    handleTenantSwitch: (tenant: string, saveRedirect: boolean, useCustomDomain?: boolean) => Promise<void>;
+    saveCurrentTenant: (tenant: Tenant) => void;
+    saveUserTenants: (tenants: Tenant[]) => void;
+    saveVisitingTenant?: (tenant: Tenant) => void;
+    removeVisitingTenant?: () => void;
+    saveUserTokens?: (tokens: TokenResponse) => void;
+    saveTenant?: (tenant: string) => void;
+    onAutoJoinUserToTenant?: (platformName: string) => void;
+    redirectToAuthSpa?: (redirectTo?: string, platformKey?: string, logout?: boolean, saveRedirect?: boolean) => void;
+    username?: string;
+    isIframed?: boolean;
+    setUseMentorProvider?: (useMentorProvider: boolean) => void;
+    skip?: boolean;
+    onLoadPlatformPermissions?: (rbacPermissions: Record<string, unknown> | undefined) => void;
+    skipCustomDomainCheck?: boolean;
+    onTenantMismatch?: () => void;
+};
+/**
+ * TenantProvider Component
+ *
+ * Main tenant provider that:
+ * 1. Validates user's access to requested tenant
+ * 2. Manages tenant switching
+ * 3. Retrieves and validates tenant metadata
+ * 4. Handles tenant-specific domain redirects
+ * 5. Maintains tenant access state
+ */
+export declare function TenantProvider({ children, fallback, onAuthSuccess, onAuthFailure, currentTenant, requestedTenant, saveCurrentTenant, saveUserTenants, handleTenantSwitch, saveVisitingTenant, removeVisitingTenant, saveUserTokens, saveTenant, onAutoJoinUserToTenant, redirectToAuthSpa, username, isIframed, setUseMentorProvider, skip, onLoadPlatformPermissions, skipCustomDomainCheck, onTenantMismatch, }: Props): string | number | bigint | boolean | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | import("react/jsx-runtime").JSX.Element | null | undefined;
+export {};

package/dist/auth/web-utils/src/services/__tests__/event-bus.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/auth/web-utils/src/services/__tests__/file-upload.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/auth/web-utils/src/services/__tests__/register-sw.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/auth/web-utils/src/services/event-bus.d.ts

@@ -0,0 +1,6 @@
+export declare const eventBus: import("mitt").Emitter<Record<import("mitt").EventType, unknown>>;
+export declare enum RemoteEvents {
+    newChat = "MENTOR:NEW_CHAT",
+    stopChatGenerating = "MENTOR:STOP_CHAT_GENERATING",
+    sendChatMessage = "MENTOR:SEND_CHAT_MESSAGE"
+}

package/dist/auth/web-utils/src/services/file-upload.d.ts

@@ -0,0 +1,60 @@
+import type { FileInfo, FileReference, UploadProgressCallback } from "../types/file-upload";
+import type { FileUploadURLResponse } from "@iblai/data-layer";
+/**
+ * Extract file information from File object
+ */
+export declare function getFileInfo(file: File): FileInfo;
+/**
+ * Request presigned S3 URL from backend
+ * Note: This function should be called via the RTK Query mutation hook
+ * This is a helper to show the data flow
+ */
+export declare function requestPresignedUrl(sessionId: string, file: File, getUploadUrlFn: (params: {
+    org: string;
+    userId: string;
+    requestBody: {
+        session_id: string;
+        file_name: string;
+        content_type: string;
+        file_size: number;
+    };
+}) => Promise<FileUploadURLResponse>, org: string, userId: string): Promise<FileUploadURLResponse>;
+/**
+ * Upload file directly to S3 using presigned URL
+ * Uses axios for cross-platform support (web + React Native)
+ */
+export declare function uploadToS3(presignedUrl: string, file: File, contentType: string, onProgress?: UploadProgressCallback): Promise<void>;
+/**
+ * Complete file upload flow:
+ * 1. Request presigned URL
+ * 2. Upload to S3
+ * 3. Return file reference
+ */
+export declare function createFileReference(file: File, sessionId: string, getUploadUrlFn: (params: {
+    org: string;
+    userId: string;
+    requestBody: {
+        session_id: string;
+        file_name: string;
+        content_type: string;
+        file_size: number;
+    };
+}) => Promise<FileUploadURLResponse>, org: string, userId: string, onProgress?: UploadProgressCallback): Promise<FileReference>;
+/**
+ * Upload multiple files and return their references
+ */
+export declare function createMultipleFileReferences(files: File[], sessionId: string, getUploadUrlFn: (params: {
+    org: string;
+    userId: string;
+    requestBody: {
+        session_id: string;
+        file_name: string;
+        content_type: string;
+        file_size: number;
+    };
+}) => Promise<FileUploadURLResponse>, org: string, userId: string, onFileProgress?: (fileIndex: number, progress: number) => void): Promise<FileReference[]>;
+/**
+ * Validate file before upload
+ * Returns error message if invalid, null if valid
+ */
+export declare function validateFile(file: File, maxSizeBytes?: number, allowedTypes?: string[]): string | null;

package/dist/auth/web-utils/src/services/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./file-upload";
+export * from "./register-sw";
+export * from "./event-bus";

package/dist/auth/web-utils/src/services/register-sw.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Service Worker Registration Helper
+ *
+ * Handles registration, updates, and communication with the service worker.
+ */
+export interface ServiceWorkerStatus {
+    isSupported: boolean;
+    isRegistered: boolean;
+    isOnline: boolean;
+    registration: ServiceWorkerRegistration | null;
+    updateAvailable: boolean;
+}
+type UpdateCallback = (registration: ServiceWorkerRegistration) => void;
+type StatusChangeCallback = (status: ServiceWorkerStatus) => void;
+/**
+ * Check if service workers are supported
+ */
+export declare function isServiceWorkerSupported(): boolean;
+/**
+ * Get current service worker status
+ */
+export declare function getServiceWorkerStatus(): ServiceWorkerStatus;
+/**
+ * Register the service worker.
+ * Defers registration until the page is fully loaded to avoid
+ * interfering with chunk loading — especially in WebKit/Safari where
+ * early SW registration can cause ChunkLoadError timeouts.
+ */
+export declare function registerServiceWorker(basePath?: string): Promise<ServiceWorkerRegistration | null>;
+/**
+ * Unregister the service worker
+ */
+export declare function unregisterServiceWorker(): Promise<boolean>;
+/**
+ * Skip waiting and activate new service worker immediately
+ */
+export declare function skipWaiting(): void;
+/**
+ * Clear all caches
+ */
+export declare function clearAllCaches(): void;
+/**
+ * Tell service worker we're running in Tauri
+ */
+export declare function setTauriMode(isTauri: boolean): void;
+/**
+ * Tell service worker about offline status (from Tauri)
+ */
+export declare function setOfflineStatus(isOffline: boolean): void;
+/**
+ * Request cache status from service worker
+ */
+export declare function getCacheStatus(): Promise<Record<string, number> | null>;
+/**
+ * Subscribe to service worker updates
+ */
+export declare function onUpdate(callback: UpdateCallback): () => void;
+/**
+ * Subscribe to status changes (online/offline, registration, updates)
+ */
+export declare function onStatusChange(callback: StatusChangeCallback): () => void;
+/**
+ * Setup online/offline listeners
+ */
+export declare function setupNetworkListeners(): () => void;
+/**
+ * Initialize service worker and network listeners
+ * Call this once when app loads
+ */
+export declare function initServiceWorker(basePath?: string): Promise<ServiceWorkerStatus>;
+export {};

package/dist/auth/web-utils/src/types/chat.d.ts

@@ -0,0 +1 @@
+export type ChatMode = "advanced" | "default";

package/dist/auth/web-utils/src/types/file-upload.d.ts

@@ -0,0 +1,62 @@
+/**
+ * File reference sent via WebSocket to backend
+ * Backend uses this to retrieve file from S3
+ */
+export interface FileReference {
+    /** Unique identifier for the ChatFile record */
+    file_id: string;
+    /** S3 object key for the uploaded file */
+    file_key: string;
+    /** Original filename */
+    file_name: string;
+    /** MIME type of the file */
+    content_type: string;
+    /** File size in bytes */
+    file_size: number;
+    /** Presigned URL for displaying the file (optional, for UI) */
+    upload_url?: string;
+}
+/**
+ * File upload state for UI tracking
+ */
+export interface FileUploadState {
+    /** Original File object */
+    file: File;
+    /** Upload/processing status */
+    status: "pending" | "uploading" | "processing" | "success" | "error";
+    /** Upload progress (0-100) */
+    progress: number;
+    /** File reference after successful upload */
+    fileReference?: FileReference;
+    /** Error message if upload failed */
+    error?: string;
+}
+/**
+ * File processing event from WebSocket
+ */
+export type FileProcessingEvent = {
+    type: "file_processing_progress";
+    file_name: string;
+    progress: string;
+} | {
+    type: "file_processing_success";
+    file_name: string;
+    file_url: string;
+} | {
+    type: "file_error";
+    file_name?: string;
+    error: string;
+    developer_error?: string;
+};
+/**
+ * Upload progress callback
+ */
+export type UploadProgressCallback = (progress: number) => void;
+/**
+ * File info extracted from File object
+ */
+export interface FileInfo {
+    fileName: string;
+    contentType: string;
+    fileSize: number;
+}

package/dist/auth/web-utils/src/types/index.d.ts

@@ -0,0 +1,68 @@
+import { z } from "zod";
+export declare const userDataSchema: z.ZodObject<{
+    user_display_name: z.ZodString;
+    user_email: z.ZodString;
+    user_fullname: z.ZodString;
+    user_id: z.ZodNumber;
+    user_nicename: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    user_display_name: string;
+    user_email: string;
+    user_fullname: string;
+    user_id: number;
+    user_nicename: string;
+}, {
+    user_display_name: string;
+    user_email: string;
+    user_fullname: string;
+    user_id: number;
+    user_nicename: string;
+}>;
+export declare const tenantSchema: z.ZodObject<{
+    key: z.ZodString;
+    is_admin: z.ZodBoolean;
+    org: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    key: string;
+    is_admin: boolean;
+    org: string;
+}, {
+    key: string;
+    is_admin: boolean;
+    org: string;
+}>;
+export declare const tenantKeySchema: z.ZodString;
+export type TenantKeyMentorIdParams = {
+    tenantKey: string;
+    mentorId: string;
+};
+export interface TopTrialBannerProps {
+    parentContainer: string;
+    bannerText?: string;
+    onUpgrade?: string;
+    loading?: boolean;
+    tooltipText?: string;
+}
+export interface Prompt {
+    type: "static" | "human" | "ai";
+    icon?: string;
+    summary?: string;
+    content?: string;
+    proactive?: boolean;
+    hide?: boolean;
+    tag?: string;
+}
+export interface Tenant {
+    key: string;
+    is_admin: boolean;
+    org: string;
+    name?: string;
+    platform_name: string;
+    is_advertising?: boolean;
+    is_enterprise?: boolean;
+    show_paywall?: boolean;
+    enable_monetization?: boolean;
+}
+export * from "./chat";
+export * from "./subscription";
+export * from "./file-upload";

package/dist/auth/web-utils/src/types/subscription.d.ts

@@ -0,0 +1,40 @@
+import { StripeCustomerPortalRequest } from "@iblai/iblai-api";
+import { AccessCheckResponse } from "@iblai/data-layer";
+export interface UseExternalPricingProps {
+    referenceId: string;
+    customerEmail: string;
+    publishableKey: string;
+    pricingId?: string;
+}
+export interface PricingModalData {
+    referenceId: string;
+    customerEmail: string;
+    publishableKey: string;
+    pricingTableId: string;
+}
+export interface CreateStripeCustomerPortalRequest {
+    org: string;
+    userId: string;
+    requestBody: StripeCustomerPortalRequest;
+}
+/**
+ * Shape of the 402 Payment Required error response body.
+ * Note: Only `error` is required. Other fields may not be present
+ * in all error scenarios (e.g., generic API 402 vs WebSocket 402).
+ */
+export interface Error402MessageData extends Partial<AccessCheckResponse> {
+    error: string;
+    message?: string;
+    details?: {
+        platform_key: string;
+        current_balance_usd: string;
+        required_usd: string;
+        deficit_usd: string;
+    };
+    pricing_table?: {
+        pricing_table_id: string;
+        pricing_table_js: string;
+        publishable_key?: string;
+        client_reference_id?: string;
+    };
+}

package/dist/auth/web-utils/src/utils/__tests__/auth.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/auth/web-utils/src/utils/__tests__/constants.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/auth/web-utils/src/utils/__tests__/helpers.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/auth/web-utils/src/utils/__tests__/platform.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/auth/web-utils/src/utils/__tests__/tauri-api-cache.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/auth/web-utils/src/utils/__tests__/tenant-switch.test.d.ts

@@ -0,0 +1 @@
+export {};