@fluid-app/portal-sdk 0.1.11

package/dist/MessagingScreen-BklF48Fn.mjs

@@ -0,0 +1,1281 @@
+import { n as __reExport, t as __exportAll } from "./chunk-D1SwGrFN.mjs";
+import { createContext, useCallback, useContext, useEffect, useMemo, useReducer, useRef, useState } from "react";
+import { QueryClient, QueryClientProvider, useQuery } from "@tanstack/react-query";
+import { AUTH_REDIRECT_TOKEN_KEY, DEFAULT_AUTH_URL, cleanTokenFromUrl, clearTokens, createDefaultAuthRedirect, createDevUser, extractTokenFromUrl, getStoredToken, isDevBypassActive, isTokenExpired, resolveAuthFailureHandler, storeToken, validateToken, verifyToken } from "@fluid-app/auth";
+import { buildThemeDefinition, getActiveThemeId, getActiveThemeId as getActiveThemeId$1, transformThemes, transformThemes as transformThemes$1 } from "@fluid-app/portal-core/theme";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { DataSourceRegistryProvider } from "@fluid-app/portal-core/data-sources/registry-context";
+import { RegistryProvider } from "@fluid-app/portal-widgets/contexts";
+import { createWidgetRegistry } from "@fluid-app/portal-core/widget-utils";
+import { AlertWidget, CalendarWidget, CarouselWidget, CatchUpWidget, ChartWidget, ContainerWidget, EmbedWidget, ImageWidget, LayoutWidget, ListWidget, MySiteWidget, NestedWidget, QuickShareWidget, RecentActivityWidget, SpacerWidget, TableWidget, TextWidget, ToDoWidget, VideoWidget } from "@fluid-app/portal-widgets/widgets";
+import { getFileTypeFromMimetype } from "@fluid-app/messaging-core";
+import { MessagingApp } from "@fluid-app/messaging-ui/app";
+import { extractEmoji, formatMessageChannelName } from "@fluid-app/messaging-ui";
+import { listConnectedRecipients, searchConversations } from "@fluid-app/messaging-api-client";
+//#region ../../platform/api-client-core/src/fetch-client.ts
+/**
+* API Error class compatible with fluid-admin's ApiError
+*/
+var ApiError$1 = class ApiError$1 extends Error {
+	status;
+	data;
+	constructor(message, status, data) {
+		super(message);
+		this.name = "ApiError";
+		this.status = status;
+		this.data = data;
+		if ("captureStackTrace" in Error) Error.captureStackTrace(this, ApiError$1);
+	}
+	toJSON() {
+		return {
+			name: this.name,
+			message: this.message,
+			status: this.status,
+			data: this.data
+		};
+	}
+};
+/**
+* Creates a configured fetch client instance
+*/
+function createFetchClient(config) {
+	const { baseUrl, getAuthToken, onAuthError, defaultHeaders = {} } = config;
+	/**
+	* Build headers for a request
+	*/
+	async function buildHeaders(customHeaders) {
+		const headers = {
+			Accept: "application/json",
+			"Content-Type": "application/json",
+			...defaultHeaders,
+			...customHeaders
+		};
+		if (getAuthToken) {
+			const token = await getAuthToken();
+			if (token) headers.Authorization = `Bearer ${token}`;
+		}
+		return headers;
+	}
+	/**
+	* Join baseUrl + endpoint via string concatenation (matches fetchApi).
+	* Using `new URL(endpoint, baseUrl)` would strip any path prefix from
+	* baseUrl (e.g. "/api") when the endpoint starts with "/".
+	*/
+	function joinUrl(endpoint) {
+		return `${baseUrl}${endpoint}`;
+	}
+	/**
+	* Build URL with query parameters for GET requests
+	* Compatible with fluid-admin's query param handling
+	*/
+	function buildUrl(endpoint, params) {
+		const fullUrl = joinUrl(endpoint);
+		if (!params || Object.keys(params).length === 0) return fullUrl;
+		const queryString = new URLSearchParams();
+		Object.entries(params).forEach(([key, value]) => {
+			if (value === void 0 || value === null) return;
+			if (Array.isArray(value)) value.forEach((item) => queryString.append(`${key}[]`, String(item)));
+			else if (typeof value === "object") Object.entries(value).forEach(([subKey, subValue]) => {
+				if (subValue === void 0 || subValue === null) return;
+				if (Array.isArray(subValue)) subValue.forEach((item) => queryString.append(`${key}[${subKey}][]`, String(item)));
+				else queryString.append(`${key}[${subKey}]`, String(subValue));
+			});
+			else queryString.append(key, String(value));
+		});
+		const qs = queryString.toString();
+		return qs ? `${fullUrl}?${qs}` : fullUrl;
+	}
+	/**
+	* Shared response handler for both JSON and FormData requests.
+	* Handles auth errors, non-OK responses, 204 No Content, and JSON parsing.
+	*/
+	async function handleResponse(response, method, _url) {
+		if (response.status === 401 && onAuthError) onAuthError();
+		if (!response.ok) try {
+			if (response.headers.get("content-type")?.includes("application/json")) {
+				const data = await response.json();
+				throw new ApiError$1(data.message || data.error_message || `${method} request failed`, response.status, data.errors || data);
+			} else throw new ApiError$1(`${method} request failed with status ${response.status}`, response.status, null);
+		} catch (error) {
+			if (error instanceof ApiError$1) throw error;
+			throw new ApiError$1(`${method} request failed with status ${response.status}`, response.status, null);
+		}
+		if (response.status === 204 || response.headers.get("content-length") === "0") return null;
+		if (response.headers.get("content-type")?.includes("application/json")) try {
+			return await response.json();
+		} catch {
+			try {
+				return await response.text();
+			} catch {
+				return null;
+			}
+		}
+		return null;
+	}
+	/**
+	* Main request function
+	*/
+	async function request(endpoint, options = {}) {
+		const { method = "GET", headers: customHeaders, params, body, signal } = options;
+		const url = params ? buildUrl(endpoint, params) : joinUrl(endpoint);
+		const headers = await buildHeaders(customHeaders);
+		let response;
+		try {
+			const fetchOptions = {
+				method,
+				headers
+			};
+			const serializedBody = body && method !== "GET" ? JSON.stringify(body) : null;
+			if (serializedBody) fetchOptions.body = serializedBody;
+			if (signal) fetchOptions.signal = signal;
+			response = await fetch(url, fetchOptions);
+		} catch (networkError) {
+			throw new ApiError$1(`Network error: ${networkError instanceof Error ? networkError.message : "Unknown network error"}`, 0, null);
+		}
+		return handleResponse(response, method, url);
+	}
+	/**
+	* Request with FormData (for file uploads)
+	*/
+	async function requestWithFormData(endpoint, formData, options = {}) {
+		const { method = "POST", headers: customHeaders, signal } = options;
+		const url = joinUrl(endpoint);
+		const headers = await buildHeaders(customHeaders);
+		delete headers["Content-Type"];
+		let response;
+		try {
+			const fetchOptions = {
+				method,
+				headers,
+				body: formData
+			};
+			if (signal) fetchOptions.signal = signal;
+			response = await fetch(url, fetchOptions);
+		} catch (networkError) {
+			throw new ApiError$1(`Network error: ${networkError instanceof Error ? networkError.message : "Unknown network error"}`, 0, null);
+		}
+		return handleResponse(response, method, url);
+	}
+	return {
+		request,
+		requestWithFormData,
+		get: (endpoint, params, options) => request(endpoint, {
+			...options,
+			method: "GET",
+			...params && { params }
+		}),
+		post: (endpoint, body, options) => request(endpoint, {
+			...options,
+			method: "POST",
+			body
+		}),
+		put: (endpoint, body, options) => request(endpoint, {
+			...options,
+			method: "PUT",
+			body
+		}),
+		patch: (endpoint, body, options) => request(endpoint, {
+			...options,
+			method: "PATCH",
+			body
+		}),
+		delete: (endpoint, options) => request(endpoint, {
+			...options,
+			method: "DELETE"
+		})
+	};
+}
+//#endregion
+//#region ../../fluidos/api-client/src/namespaces/fluid_os.ts
+/**
+* Get active Fluid OS definition
+* Retrieve the active Fluid OS definition manifest for a specific platform
+*
+* @param client - Fetch client instance
+* @param params - params
+*/
+async function getFluidOSManifest(client, params) {
+	return client.get(`/api/fluid_os/definitions/active`, params);
+}
+//#endregion
+//#region src/client/types.ts
+/**
+* HTTP methods supported by the API client.
+* Use `as const` for literal type inference and type safety.
+*/
+const HTTP_METHODS = {
+	GET: "GET",
+	POST: "POST",
+	PUT: "PUT",
+	PATCH: "PATCH",
+	DELETE: "DELETE"
+};
+//#endregion
+//#region src/transforms/screen-transforms.ts
+/**
+* Normalize component_tree to always be an array.
+* The API stores component_tree as a hash (object), but the frontend expects an array.
+*/
+function normalizeComponentTree(componentTree) {
+	if (!componentTree) return [];
+	if (Array.isArray(componentTree)) return componentTree;
+	if (typeof componentTree === "object") return [componentTree];
+	return [];
+}
+/**
+* Convert a raw FluidOS screen to ScreenDefinition.
+* Normalizes component_tree and converts string IDs to numbers.
+*/
+function toScreenDefinition(screen) {
+	return {
+		id: Number(screen.id),
+		slug: screen.slug ?? "",
+		name: screen.name ?? "",
+		component_tree: normalizeComponentTree(screen.component_tree)
+	};
+}
+//#endregion
+//#region src/transforms/navigation-transforms.ts
+/**
+* Convert a raw FluidOS navigation item to NavigationItem.
+* Recursively transforms children and sorts by position.
+*/
+function toNavigationItem(item) {
+	const children = (item.children ?? []).map(toNavigationItem).sort((a, b) => (a.position ?? 0) - (b.position ?? 0));
+	return {
+		id: Number(item.id),
+		label: item.label ?? "Untitled",
+		...item.slug != null ? { slug: String(item.slug) } : {},
+		...item.icon != null ? { icon: String(item.icon) } : {},
+		...item.screen_id != null ? { screen_id: Number(item.screen_id) } : {},
+		...item.parent_id != null ? { parent_id: Number(item.parent_id) } : {},
+		...item.source != null ? { source: item.source } : {},
+		position: item.position ?? 0,
+		children
+	};
+}
+//#endregion
+//#region src/transforms/index.ts
+/**
+* Transform a raw FluidOS manifest API response into RepAppData.
+*
+* This is the top-level transform used by `FluidClient.app.get()`.
+* It handles:
+* - Theme transformation (legacy and new formats)
+* - Screen normalization (component_tree array wrapping)
+* - Navigation item transformation (recursive with position sorting)
+*/
+function transformManifestToRepAppData(response) {
+	const manifest = response.manifest;
+	const rawProfile = manifest.profile;
+	const rawThemes = Array.isArray(rawProfile?.themes) ? rawProfile.themes : [];
+	const screens = (manifest.screens ?? []).map((screen) => toScreenDefinition(screen));
+	const navigationItems = (rawProfile?.navigation?.navigation_items ?? []).map(toNavigationItem);
+	const nav = rawProfile?.navigation;
+	const mobileNav = rawProfile?.mobile_navigation;
+	const mobileNavigationItems = (mobileNav?.navigation_items ?? []).map(toNavigationItem);
+	const activeThemeId = getActiveThemeId(rawThemes);
+	return {
+		definition_id: manifest.definition_id,
+		published_version: manifest.published_version ?? 0,
+		screens,
+		profile: {
+			name: rawProfile?.name ?? "Default",
+			definition_id: rawProfile?.definition_id ?? manifest.definition_id,
+			themes: transformThemes(rawThemes),
+			...activeThemeId !== void 0 ? { activeThemeId } : {},
+			navigation: {
+				definition_id: nav?.definition_id ?? manifest.definition_id,
+				id: nav?.id ?? 0,
+				name: nav?.name ?? "Main Navigation",
+				navigation_items: navigationItems,
+				screens
+			},
+			...mobileNav ? { mobile_navigation: {
+				definition_id: mobileNav.definition_id ?? manifest.definition_id,
+				id: mobileNav.id ?? 0,
+				name: mobileNav.name ?? "Mobile Navigation",
+				navigation_items: mobileNavigationItems,
+				screens
+			} } : {}
+		}
+	};
+}
+//#endregion
+//#region src/client/fluid-client.ts
+/**
+* API Error class for structured error handling
+*/
+var ApiError = class ApiError extends Error {
+	status;
+	data;
+	constructor(message, status, data) {
+		super(message);
+		this.name = "ApiError";
+		this.status = status;
+		this.data = data;
+		const errorWithCapture = Error;
+		if (errorWithCapture.captureStackTrace) errorWithCapture.captureStackTrace(this, ApiError);
+	}
+	toJSON() {
+		return {
+			name: this.name,
+			message: this.message,
+			status: this.status,
+			data: this.data
+		};
+	}
+};
+/**
+* Type guard for ApiError
+*/
+function isApiError(error) {
+	return error instanceof ApiError;
+}
+/**
+* Type guard to check if a value is a non-null string
+*/
+function isString(value) {
+	return typeof value === "string";
+}
+/**
+* Extract error message from API response data using `in` operator narrowing.
+* Checks common error message field names in order of precedence.
+*/
+function extractErrorMessage(data, fallback) {
+	if ("message" in data && isString(data.message)) return data.message;
+	if ("error_message" in data && isString(data.error_message)) return data.error_message;
+	if ("error" in data && isString(data.error)) return data.error;
+	return fallback;
+}
+/**
+* Creates a configured Fluid API client instance
+*/
+function createFluidClient(config) {
+	const { baseUrl, getAuthToken, onAuthError, defaultHeaders = {} } = config;
+	const effectiveOnAuthError = onAuthError ?? createDefaultAuthRedirect();
+	const fetchClient = createFetchClient({
+		baseUrl,
+		...getAuthToken ? { getAuthToken } : {},
+		onAuthError: effectiveOnAuthError,
+		defaultHeaders
+	});
+	/**
+	* Build headers for a request
+	*/
+	async function buildHeaders(customHeaders) {
+		const headers = {
+			"Content-Type": "application/json",
+			...defaultHeaders,
+			...customHeaders
+		};
+		if (getAuthToken) {
+			const token = await getAuthToken();
+			if (token) headers.Authorization = `Bearer ${token}`;
+		}
+		return headers;
+	}
+	/**
+	* Build URL with query parameters (Rails-compatible)
+	*/
+	function buildUrl(endpoint, params) {
+		const normalizedBase = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+		const normalizedEndpoint = endpoint.startsWith("/") ? endpoint : `/${endpoint}`;
+		const url = new URL(normalizedBase + normalizedEndpoint);
+		if (params) for (const [key, value] of Object.entries(params)) {
+			if (value === void 0 || value === null) continue;
+			if (Array.isArray(value)) for (const item of value) url.searchParams.append(`${key}[]`, String(item));
+			else if (typeof value === "object") for (const [subKey, subValue] of Object.entries(value)) {
+				if (subValue === void 0 || subValue === null) continue;
+				if (Array.isArray(subValue)) for (const item of subValue) url.searchParams.append(`${key}[${subKey}][]`, String(item));
+				else url.searchParams.append(`${key}[${subKey}]`, String(subValue));
+			}
+			else url.searchParams.append(key, String(value));
+		}
+		return url.toString();
+	}
+	/**
+	* Default request options for type-safe defaults.
+	* Uses `satisfies` to validate against RequestOptions while preserving literal types.
+	*/
+	const defaultRequestOptions = { method: HTTP_METHODS.GET };
+	/**
+	* Main request function
+	*/
+	async function request(endpoint, options = {}) {
+		const { method = defaultRequestOptions.method, headers: customHeaders, params, body, signal } = options;
+		const url = buildUrl(endpoint, method === HTTP_METHODS.GET ? params : void 0);
+		const headers = await buildHeaders(customHeaders);
+		let response;
+		try {
+			const fetchOptions = {
+				method,
+				headers
+			};
+			if (signal !== void 0) fetchOptions.signal = signal;
+			if (body && method !== HTTP_METHODS.GET) fetchOptions.body = JSON.stringify(body);
+			response = await fetch(url, fetchOptions);
+		} catch (networkError) {
+			throw new ApiError(`Network error: ${networkError instanceof Error ? networkError.message : "Unknown network error"}`, 0, null);
+		}
+		if (response.status === 401) {
+			effectiveOnAuthError();
+			throw new ApiError("Authentication required", 401, null);
+		}
+		if (!response.ok) try {
+			if (response.headers.get("content-type")?.includes("application/json")) {
+				const data = await response.json();
+				throw new ApiError(extractErrorMessage(data, `${method} request failed`), response.status, "errors" in data ? data.errors : data);
+			} else throw new ApiError(`${method} request failed with status ${response.status}`, response.status, null);
+		} catch (error) {
+			if (isApiError(error)) throw error;
+			throw new ApiError(`${method} request failed with status ${response.status}`, response.status, null);
+		}
+		if (response.status === 204 || response.headers.get("content-length") === "0") return null;
+		try {
+			const data = await response.json();
+			if (data === null || data === void 0) throw new ApiError("Unexpected null/undefined in JSON response", response.status, null);
+			return data;
+		} catch (parseError) {
+			if (isApiError(parseError)) throw parseError;
+			throw new ApiError("Failed to parse response as JSON", response.status, null);
+		}
+	}
+	/**
+	* Request function for endpoints that may return null (204 No Content).
+	* Properly types the return as T | null.
+	*/
+	async function requestNullable(endpoint, options = {}) {
+		return request(endpoint, options);
+	}
+	/**
+	* Safe request wrapper that returns a discriminated union instead of throwing.
+	* Use `isApiSuccess` or `isApiFailure` to narrow the result.
+	*/
+	async function safeRequest(endpoint, options = {}) {
+		try {
+			return {
+				success: true,
+				data: await request(endpoint, options)
+			};
+		} catch (error) {
+			if (isApiError(error)) return {
+				success: false,
+				error
+			};
+			return {
+				success: false,
+				error: new ApiError(error instanceof Error ? error.message : "Unknown error", 0, null)
+			};
+		}
+	}
+	/**
+	* Helper to safely convert typed params to Record<string, unknown>.
+	* Type assertion required: TypeScript's structural typing allows any object
+	* to be treated as Record<string, unknown> when we only need to iterate
+	* over its entries. This is safe because buildUrl only reads properties.
+	*/
+	function toParams(params) {
+		return params;
+	}
+	const get = (endpoint, params, options) => {
+		const baseOptions = {
+			...options,
+			method: HTTP_METHODS.GET
+		};
+		const convertedParams = toParams(params);
+		return request(endpoint, convertedParams !== void 0 ? {
+			...baseOptions,
+			params: convertedParams
+		} : baseOptions);
+	};
+	const post = (endpoint, body, options) => request(endpoint, {
+		...options,
+		method: HTTP_METHODS.POST,
+		body
+	});
+	const put = (endpoint, body, options) => request(endpoint, {
+		...options,
+		method: HTTP_METHODS.PUT,
+		body
+	});
+	const patch = (endpoint, body, options) => request(endpoint, {
+		...options,
+		method: HTTP_METHODS.PATCH,
+		body
+	});
+	const del = (endpoint, options) => request(endpoint, {
+		...options,
+		method: HTTP_METHODS.DELETE
+	});
+	return {
+		fetchClient,
+		request,
+		requestNullable,
+		safeRequest,
+		get,
+		post,
+		put,
+		patch,
+		delete: del,
+		products: {
+			list: (params) => get("/company/v1/products", params),
+			get: (id) => get(`/company/v1/products/${id}`),
+			search: (query, params) => get("/company/v1/products", {
+				search_query: query,
+				...params
+			})
+		},
+		orders: {
+			list: (params) => get("/orders", params),
+			get: (id) => get(`/orders/${id}`),
+			create: (data) => post("/orders", data)
+		},
+		users: { me: () => get("/api/me") },
+		reps: {
+			current: () => get("/reps/me"),
+			updateProfile: (data) => patch("/reps/me", data)
+		},
+		profile: { get: () => get("/rep_app/manifest") },
+		app: {
+			getRaw: async () => {
+				return await getFluidOSManifest(fetchClient, { platform: "browser" });
+			},
+			get: async () => {
+				return transformManifestToRepAppData(await getFluidOSManifest(fetchClient, { platform: "browser" }));
+			}
+		},
+		permissions: { get: () => get("/company/roles/my_permissions") },
+		analytics: {
+			dashboard: () => get("/analytics/dashboard"),
+			sales: (params) => get("/analytics/sales", params)
+		}
+	};
+}
+//#endregion
+//#region src/themes/index.ts
+var themes_exports = /* @__PURE__ */ __exportAll({});
+import * as import__fluid_app_portal_core_theme from "@fluid-app/portal-core/theme";
+__reExport(themes_exports, import__fluid_app_portal_core_theme);
+//#endregion
+//#region src/providers/FluidThemeProvider.tsx
+/**
+* Theme Provider for Fluid SDK
+* Handles CSS variable injection using portal-core's theme engine.
+* Accepts ThemeDefinition objects and resolves them into CSS via generateThemeCSS.
+*/
+const ThemeContext = createContext(null);
+/**
+* Apply a theme to the DOM using the shared portal-core pipeline.
+* Also sets data attributes on the container for CSS selector targeting.
+*/
+function applyThemeToDOM(theme, mode, container) {
+	const target = container ?? document.documentElement;
+	(0, themes_exports.applyTheme)((0, themes_exports.resolveTheme)(theme));
+	target.dataset.theme = theme.id;
+	if (mode) target.dataset.themeMode = mode;
+	else delete target.dataset.themeMode;
+}
+function FluidThemeProvider({ children, initialTheme, container }) {
+	const [currentTheme, setCurrentTheme] = useState(initialTheme ?? null);
+	const [mode, setMode] = useState(void 0);
+	useEffect(() => {
+		if (currentTheme) applyThemeToDOM(currentTheme, mode, container ?? null);
+		return () => {
+			(0, themes_exports.removeAllThemes)();
+		};
+	}, [
+		currentTheme,
+		mode,
+		container
+	]);
+	const setTheme = useCallback((theme) => {
+		setCurrentTheme(theme);
+	}, []);
+	const setThemeMode = useCallback((newMode) => {
+		setMode(newMode);
+	}, []);
+	const value = useMemo(() => ({
+		currentTheme,
+		setTheme,
+		setThemeMode,
+		mode
+	}), [
+		currentTheme,
+		setTheme,
+		setThemeMode,
+		mode
+	]);
+	return /* @__PURE__ */ jsx(ThemeContext.Provider, {
+		value,
+		children
+	});
+}
+/**
+* Hook to access theme context
+* Must be used within a FluidThemeProvider
+*/
+function useThemeContext() {
+	const context = useContext(ThemeContext);
+	if (!context) throw new Error("useThemeContext must be used within a FluidThemeProvider");
+	return context;
+}
+//#endregion
+//#region src/providers/FluidAuthProvider.tsx
+/**
+* FluidAuthProvider - Authentication Provider for Fluid Portal SDK
+*
+* Handles JWT token extraction from URL, validation, storage, and
+* provides authentication context to child components.
+*/
+/**
+* Auth context - null when outside provider
+*/
+const FluidAuthContext = createContext(null);
+function authReducer(state, action) {
+	switch (action.type) {
+		case "SET_AUTH": return {
+			isLoading: false,
+			token: action.token,
+			user: action.user,
+			error: action.error
+		};
+		case "CLEAR_AUTH": return {
+			...state,
+			token: null,
+			user: null,
+			error: null
+		};
+		case "DONE_LOADING": return {
+			...state,
+			isLoading: false
+		};
+	}
+}
+const initialAuthState = {
+	isLoading: true,
+	token: null,
+	user: null,
+	error: null
+};
+/**
+* Authentication provider for Fluid portal applications.
+*
+* On mount, this provider:
+* 1. Checks for a token in the URL (passed from parent app)
+* 2. Cleans token from URL immediately (security)
+* 3. Falls back to stored token (cookie/localStorage)
+* 4. Validates the token (checks expiration)
+* 5. Stores valid tokens for future use
+* 6. Calls onAuthFailure if no valid token found
+*
+* @example
+* ```tsx
+* import { FluidAuthProvider } from "@fluid-app/portal-sdk";
+*
+* function App() {
+*   return (
+*     <FluidAuthProvider
+*       config={{
+*         onAuthFailure: () => {
+*           window.location.href = "/login";
+*         },
+*       }}
+*     >
+*       <YourApp />
+*     </FluidAuthProvider>
+*   );
+* }
+* ```
+*/
+function FluidAuthProvider({ children, config }) {
+	const configRef = useRef(config);
+	configRef.current = config;
+	const [state, dispatch] = useReducer(authReducer, initialAuthState);
+	const { isLoading, token, user, error } = state;
+	useEffect(() => {
+		const initializeAuth = async () => {
+			const handleAuthFailure = () => {
+				const current = configRef.current;
+				resolveAuthFailureHandler(current?.onAuthFailure, current?.authUrl)();
+			};
+			try {
+				if (isDevBypassActive(config?.devBypass)) {
+					const envToken = import.meta.env.VITE_DEV_TOKEN;
+					if (envToken) {
+						const validation = validateToken(envToken, config?.gracePeriodMs);
+						if (validation.isValid && validation.payload) {
+							storeToken(envToken, config);
+							dispatch({
+								type: "SET_AUTH",
+								token: envToken,
+								user: validation.payload,
+								error: null
+							});
+							return;
+						}
+						console.warn("[FluidAuth] VITE_DEV_TOKEN is invalid or expired, falling back to mock user");
+					}
+					console.warn("[FluidAuth] Dev bypass active - using mock user. API calls will fail without a real token.");
+					dispatch({
+						type: "SET_AUTH",
+						token: null,
+						user: createDevUser(),
+						error: null
+					});
+					return;
+				}
+				const tokenKey = config?.tokenKey ?? "fluidUserToken";
+				let candidateToken = extractTokenFromUrl(tokenKey);
+				if (!candidateToken && tokenKey !== AUTH_REDIRECT_TOKEN_KEY) candidateToken = extractTokenFromUrl(AUTH_REDIRECT_TOKEN_KEY);
+				cleanTokenFromUrl(tokenKey);
+				cleanTokenFromUrl(AUTH_REDIRECT_TOKEN_KEY);
+				if (!candidateToken) candidateToken = getStoredToken(config);
+				if (candidateToken) {
+					let payload = null;
+					if (config?.jwksUrl) {
+						payload = await verifyToken(candidateToken, config.jwksUrl);
+						if (!payload) {
+							clearTokens(config);
+							dispatch({
+								type: "SET_AUTH",
+								token: null,
+								user: null,
+								error: /* @__PURE__ */ new Error("JWT signature verification failed")
+							});
+							handleAuthFailure();
+							return;
+						}
+						if (isTokenExpired(candidateToken, config?.gracePeriodMs)) {
+							clearTokens(config);
+							dispatch({
+								type: "SET_AUTH",
+								token: null,
+								user: null,
+								error: /* @__PURE__ */ new Error("Token has expired")
+							});
+							handleAuthFailure();
+							return;
+						}
+					} else {
+						const validation = validateToken(candidateToken, config?.gracePeriodMs);
+						if (validation.isValid && validation.payload) payload = validation.payload;
+						else {
+							clearTokens(config);
+							dispatch({
+								type: "SET_AUTH",
+								token: null,
+								user: null,
+								error: new Error(validation.error ?? "Invalid token")
+							});
+							handleAuthFailure();
+							return;
+						}
+					}
+					storeToken(candidateToken, config);
+					dispatch({
+						type: "SET_AUTH",
+						token: candidateToken,
+						user: payload,
+						error: null
+					});
+				} else {
+					dispatch({
+						type: "SET_AUTH",
+						token: null,
+						user: null,
+						error: /* @__PURE__ */ new Error("No authentication token found")
+					});
+					handleAuthFailure();
+				}
+			} catch (err) {
+				dispatch({
+					type: "SET_AUTH",
+					token: null,
+					user: null,
+					error: err instanceof Error ? err : /* @__PURE__ */ new Error("Authentication error")
+				});
+				handleAuthFailure();
+			} finally {
+				dispatch({ type: "DONE_LOADING" });
+			}
+		};
+		initializeAuth();
+	}, []);
+	const clearAuth = useCallback(() => {
+		clearTokens(configRef.current);
+		dispatch({ type: "CLEAR_AUTH" });
+	}, []);
+	const contextValue = useMemo(() => ({
+		isAuthenticated: user !== null,
+		isLoading,
+		user,
+		token,
+		clearAuth,
+		error
+	}), [
+		token,
+		isLoading,
+		user,
+		clearAuth,
+		error
+	]);
+	return /* @__PURE__ */ jsx(FluidAuthContext.Provider, {
+		value: contextValue,
+		children
+	});
+}
+/**
+* Hook to access the auth context directly.
+* Prefer using `useFluidAuth` for most use cases.
+*
+* @throws Error if used outside FluidAuthProvider
+*/
+function useFluidAuthContext() {
+	const context = useContext(FluidAuthContext);
+	if (!context) throw new Error("useFluidAuthContext must be used within a FluidAuthProvider. Wrap your app with <FluidAuthProvider> to use authentication features.");
+	return context;
+}
+/** Safe accessor — returns null when outside FluidAuthProvider (no throw) */
+function useFluidAuthOptional() {
+	return useContext(FluidAuthContext);
+}
+//#endregion
+//#region src/core/default-widget-registry.ts
+const DEFAULT_SDK_WIDGET_REGISTRY = createWidgetRegistry({
+	AlertWidget,
+	CalendarWidget,
+	CarouselWidget,
+	CatchUpWidget,
+	ChartWidget,
+	ContainerWidget,
+	EmbedWidget,
+	ImageWidget,
+	LayoutWidget,
+	ListWidget,
+	MySiteWidget,
+	NestedWidget,
+	QuickShareWidget,
+	RecentActivityWidget,
+	SpacerWidget,
+	TableWidget,
+	TextWidget,
+	ToDoWidget,
+	VideoWidget
+});
+//#endregion
+//#region src/providers/FluidProvider.tsx
+/**
+* Main Fluid SDK Provider
+* Wraps QueryClientProvider and FluidThemeProvider
+*/
+const FluidContext = createContext(null);
+/**
+* Main provider for the Fluid Portal SDK
+*
+* @example
+* ```tsx
+* import { FluidProvider } from "@fluid-app/portal-sdk";
+*
+* function App() {
+*   return (
+*     <FluidProvider
+*       config={{
+*         baseUrl: "https://api.fluid.app/api",
+*         getAuthToken: () => localStorage.getItem("token"),
+*       }}
+*     >
+*       <YourApp />
+*     </FluidProvider>
+*   );
+* }
+* ```
+*/
+function FluidProvider({ config, children, queryClient, initialTheme, themeContainer, widgetRegistry, variables }) {
+	const defaultQueryClient = useMemo(() => new QueryClient({ defaultOptions: { queries: {
+		staleTime: 1e3 * 60,
+		retry: 1
+	} } }), []);
+	const configRef = useRef(config);
+	configRef.current = config;
+	const client = useMemo(() => createFluidClient({
+		...configRef.current,
+		getAuthToken: () => configRef.current.getAuthToken?.() ?? null,
+		onAuthError: () => configRef.current.onAuthError?.()
+	}), [config.baseUrl]);
+	const contextValue = useMemo(() => ({
+		client,
+		config: configRef.current
+	}), [client]);
+	const getApiHeaders = useCallback(() => {
+		const headers = { "Content-Type": "application/json" };
+		const getAuthToken = configRef.current.getAuthToken;
+		if (typeof getAuthToken === "function") {
+			const tokenOrPromise = getAuthToken();
+			if (typeof tokenOrPromise === "string") headers.Authorization = `Bearer ${tokenOrPromise}`;
+		}
+		return headers;
+	}, []);
+	const dataSourceBaseUrl = useMemo(() => {
+		const base = config.baseUrl.replace(/\/+$/, "");
+		return base.endsWith("/api") ? base : `${base}/api`;
+	}, [config.baseUrl]);
+	const authContext = useFluidAuthOptional();
+	const autoVariables = useMemo(() => {
+		if (authContext?.user?.id != null) return { rep_id: String(authContext.user.id) };
+	}, [authContext?.user?.id]);
+	const effectiveVariables = variables ?? autoVariables;
+	const themeProviderProps = {
+		...initialTheme !== void 0 && { initialTheme },
+		...themeContainer !== void 0 && { container: themeContainer }
+	};
+	const registry = widgetRegistry ?? DEFAULT_SDK_WIDGET_REGISTRY;
+	return /* @__PURE__ */ jsx(QueryClientProvider, {
+		client: queryClient ?? defaultQueryClient,
+		children: /* @__PURE__ */ jsx(FluidContext.Provider, {
+			value: contextValue,
+			children: /* @__PURE__ */ jsx(DataSourceRegistryProvider, {
+				baseUrl: dataSourceBaseUrl,
+				getApiHeaders,
+				variables: effectiveVariables,
+				children: /* @__PURE__ */ jsx(RegistryProvider, {
+					registry,
+					children: /* @__PURE__ */ jsx(FluidThemeProvider, {
+						...themeProviderProps,
+						children
+					})
+				})
+			})
+		})
+	});
+}
+/**
+* Hook to access the Fluid context
+* Must be used within a FluidProvider
+*/
+function useFluidContext() {
+	const context = useContext(FluidContext);
+	if (!context) throw new Error("useFluidContext must be used within a FluidProvider");
+	return context;
+}
+//#endregion
+//#region src/hooks/use-fluid-api.ts
+/**
+* Hook to access the Fluid API client
+*
+* @example
+* ```tsx
+* function ProductList() {
+*   const api = useFluidApi();
+*
+*   const { data: products } = useQuery({
+*     queryKey: ["products"],
+*     queryFn: () => api.products.list(),
+*   });
+*
+*   return <ul>{products?.map(p => <li key={p.id}>{p.name}</li>)}</ul>;
+* }
+* ```
+*/
+function useFluidApi() {
+	const { client } = useFluidContext();
+	return client;
+}
+//#endregion
+//#region src/messaging/use-messaging-auth.ts
+/**
+* Bridge hook: maps portal SDK auth context to MessagingAuthContext.
+*
+* The messaging system identifies users by `recipient_id`, which is NOT in the
+* JWT payload or the /reps/me endpoint. It IS returned by GET /api/me.
+* This hook fetches that data and maps it into the shape MessagingApp expects.
+*/
+const USERS_ME_QUERY_KEY = [
+	"fluid",
+	"users",
+	"me"
+];
+function useMessagingAuth() {
+	const auth = useFluidAuthContext();
+	const api = useFluidApi();
+	const { data: userMe, isLoading: isUserMeLoading, isError } = useQuery({
+		queryKey: USERS_ME_QUERY_KEY,
+		queryFn: () => api.users.me(),
+		enabled: auth.isAuthenticated,
+		staleTime: Infinity,
+		retry: 1
+	});
+	if (auth.isLoading || auth.isAuthenticated && isUserMeLoading) return {
+		recipientId: null,
+		companyId: null,
+		currentUser: null,
+		isLoading: true
+	};
+	if (!auth.isAuthenticated || isError || !userMe) return {
+		recipientId: null,
+		companyId: null,
+		currentUser: null,
+		isLoading: false
+	};
+	const currentUser = userMe.recipient_id ? {
+		id: userMe.id,
+		recipientId: userMe.recipient_id,
+		firstName: userMe.first_name ?? "",
+		lastName: userMe.last_name ?? "",
+		email: userMe.email,
+		...userMe.image_url != null && { imageUrl: userMe.image_url },
+		...userMe.affiliate_id != null && { affiliateId: userMe.affiliate_id }
+	} : null;
+	return {
+		recipientId: userMe.recipient_id,
+		companyId: userMe.company_id ?? null,
+		currentUser,
+		isLoading: false
+	};
+}
+//#endregion
+//#region src/messaging/use-messaging-config.ts
+/**
+* Hook that derives MessagingApiConfig from the portal SDK's FluidProvider context.
+*
+* Maps FluidSDKConfig fields to the shape expected by MessagingApp:
+* - baseUrl  -> from config.baseUrl
+* - getHeaders -> builds Authorization header from config.getAuthToken()
+* - onAuthError -> from config.onAuthError
+* - websocketUrl -> config.websocketUrl or derived from baseUrl
+* - token -> from auth context
+*/
+function deriveWebsocketUrl(baseUrl) {
+	return `${baseUrl.replace(/\/+$/, "").replace(/\/api$/, "")}/cable`;
+}
+function useMessagingConfig() {
+	const { config } = useFluidContext();
+	const auth = useFluidAuthContext();
+	const getHeaders = useCallback(async () => {
+		const headers = {
+			"Content-Type": "application/json",
+			...config.defaultHeaders
+		};
+		if (config.getAuthToken) {
+			const token = await config.getAuthToken();
+			if (token) headers.Authorization = `Bearer ${token}`;
+		}
+		return headers;
+	}, [config]);
+	const apiBaseUrl = useMemo(() => {
+		const base = config.baseUrl.replace(/\/+$/, "");
+		return base.endsWith("/api") ? base : `${base}/api`;
+	}, [config.baseUrl]);
+	return {
+		apiConfig: useMemo(() => ({
+			baseUrl: apiBaseUrl,
+			getHeaders,
+			...config.onAuthError != null && { onAuthError: config.onAuthError }
+		}), [
+			apiBaseUrl,
+			config.onAuthError,
+			getHeaders
+		]),
+		websocketUrl: useMemo(() => config.websocketUrl ?? deriveWebsocketUrl(config.baseUrl), [config.websocketUrl, config.baseUrl]),
+		token: auth.token
+	};
+}
+//#endregion
+//#region src/messaging/fluid-file-uploader.ts
+const FILESTACK_UPLOAD_URL = "https://www.filestackapi.com/api/store/S3";
+function getImageDimensions(file) {
+	if (!file.type.startsWith("image/")) return Promise.resolve(null);
+	return new Promise((resolve) => {
+		const img = new Image();
+		const url = URL.createObjectURL(file);
+		img.onload = () => {
+			URL.revokeObjectURL(url);
+			resolve({
+				width: img.naturalWidth,
+				height: img.naturalHeight
+			});
+		};
+		img.onerror = () => {
+			URL.revokeObjectURL(url);
+			resolve(null);
+		};
+		img.src = url;
+	});
+}
+function uploadToFilestack(file, apiKey, callbacks) {
+	const xhr = new XMLHttpRequest();
+	let aborted = false;
+	getImageDimensions(file).then((metadata) => {
+		if (aborted) return;
+		const url = `${FILESTACK_UPLOAD_URL}?key=${encodeURIComponent(apiKey)}`;
+		xhr.open("POST", url);
+		xhr.setRequestHeader("Content-Type", file.type);
+		xhr.upload.onprogress = (event) => {
+			if (event.lengthComputable) {
+				const progress = Math.round(event.loaded / event.total * 100);
+				callbacks.onProgress(progress);
+			}
+		};
+		xhr.onload = () => {
+			if (xhr.status >= 200 && xhr.status < 300) try {
+				const result = {
+					url: JSON.parse(xhr.responseText).url,
+					size: file.size,
+					mimetype: file.type,
+					kind: getFileTypeFromMimetype(file.type),
+					metadata
+				};
+				callbacks.onSuccess(result);
+			} catch {
+				callbacks.onError(/* @__PURE__ */ new Error("Failed to parse upload response"));
+			}
+			else callbacks.onError(/* @__PURE__ */ new Error(`Upload failed with status ${xhr.status}`));
+		};
+		xhr.onerror = () => {
+			if (!aborted) callbacks.onError(/* @__PURE__ */ new Error("Upload failed due to a network error"));
+		};
+		xhr.onabort = () => {};
+		xhr.send(file);
+	}).catch((error) => {
+		if (!aborted) callbacks.onError(error instanceof Error ? error : /* @__PURE__ */ new Error("Upload preparation failed"));
+	});
+	return { abort: () => {
+		aborted = true;
+		xhr.abort();
+	} };
+}
+/**
+* Creates a FileUploader that uploads to Filestack using the REST API.
+*
+* @param apiKey - Filestack API key. If falsy, returns a noop uploader
+*                 that rejects uploads with a helpful error message.
+*/
+function createFluidFileUploader(apiKey) {
+	if (!apiKey) return { uploadFile: (_file, callbacks) => {
+		callbacks.onError(/* @__PURE__ */ new Error("File uploads are not configured. Set filestackApiKey in your SDK config to enable attachments."));
+		return { abort: () => {} };
+	} };
+	return { uploadFile: (file, callbacks) => uploadToFilestack(file, apiKey, callbacks) };
+}
+//#endregion
+//#region src/screens/MessagingScreen.tsx
+var MessagingScreen_exports = /* @__PURE__ */ __exportAll({
+	MessagingScreen: () => MessagingScreen,
+	messagingScreenPropertySchema: () => messagingScreenPropertySchema
+});
+function renderImage(props) {
+	return /* @__PURE__ */ jsx("img", {
+		src: props.src,
+		alt: props.alt,
+		width: props.width,
+		height: props.height,
+		className: props.className
+	});
+}
+function defaultToast(message, type) {
+	if (type === "error") console.warn("[Messaging]", message);
+}
+function MessagingScreen({ onToast, filestackApiKey, websocketUrl: websocketUrlOverride, background, textColor, accentColor, padding, borderRadius, ...divProps }) {
+	const { config } = useFluidContext();
+	const { apiConfig, websocketUrl, token } = useMessagingConfig();
+	const messagingAuth = useMessagingAuth();
+	const effectiveApiKey = filestackApiKey ?? config.filestackApiKey;
+	const uploader = useMemo(() => createFluidFileUploader(effectiveApiKey), [effectiveApiKey]);
+	const effectiveWsUrl = websocketUrlOverride ?? websocketUrl;
+	const effectiveToast = onToast ?? defaultToast;
+	const searchUsers = useCallback(async (query) => {
+		return ((await listConnectedRecipients(apiConfig, {
+			filterrific: { search_query: query },
+			per_page: 10,
+			page: 1
+		}))?.[1]?.items ?? []).map((user) => {
+			const name = [user.first_name, user.last_name].filter(Boolean).length > 0 ? [user.first_name, user.last_name].filter(Boolean).join(" ") : `User ${user.id}`;
+			return {
+				id: String(user.id),
+				label: name,
+				imageType: "user",
+				userData: {
+					first_name: user.first_name,
+					last_name: user.last_name,
+					image_url: user.avatar_url,
+					phone: user.phone || void 0,
+					email: user.email || void 0
+				},
+				conversationName: name
+			};
+		});
+	}, [apiConfig]);
+	const searchChannels = useCallback(async (query) => {
+		return (await searchConversations(apiConfig, { filterrific: { search_query: query } }) ?? []).map((channel) => {
+			const { text: nameWithoutEmoji } = extractEmoji(channel.name);
+			return {
+				id: `channel-${channel.id}`,
+				label: formatMessageChannelName(nameWithoutEmoji),
+				imageType: "channel",
+				userData: {
+					first_name: channel.name,
+					last_name: null,
+					image_url: channel.avatar_url
+				},
+				conversationName: channel.name
+			};
+		});
+	}, [apiConfig]);
+	if (messagingAuth.isLoading) return /* @__PURE__ */ jsx("div", {
+		...divProps,
+		className: `flex h-full items-center justify-center ${divProps.className ?? ""}`,
+		children: /* @__PURE__ */ jsx("div", {
+			className: "text-muted-foreground",
+			children: "Loading messaging..."
+		})
+	});
+	if (!messagingAuth.recipientId) return /* @__PURE__ */ jsx("div", {
+		...divProps,
+		className: `flex h-full items-center justify-center ${divProps.className ?? ""}`,
+		children: /* @__PURE__ */ jsxs("div", {
+			className: "border-border max-w-sm rounded-lg border border-dashed p-8 text-center",
+			children: [/* @__PURE__ */ jsx("h2", {
+				className: "text-foreground text-xl font-semibold",
+				children: "Messaging"
+			}), /* @__PURE__ */ jsx("p", {
+				className: "text-muted-foreground mt-2",
+				children: "Messaging is not available for your account"
+			})]
+		})
+	});
+	return /* @__PURE__ */ jsx("div", {
+		...divProps,
+		className: `h-full ${divProps.className ?? ""}`,
+		children: /* @__PURE__ */ jsx(MessagingApp, {
+			config: apiConfig,
+			auth: messagingAuth,
+			websocketUrl: effectiveWsUrl,
+			token,
+			renderImage,
+			showAdminFeatures: false,
+			onToast: effectiveToast,
+			messagesViewProps: {
+				uploader,
+				saveDrafts: true,
+				onToast: effectiveToast
+			},
+			newMessageViewProps: {
+				searchUsers,
+				searchChannels
+			}
+		})
+	});
+}
+const messagingScreenPropertySchema = {
+	widgetType: "MessagingScreen",
+	displayName: "Messaging Screen",
+	tabsConfig: [{
+		id: "styling",
+		label: "Styling"
+	}],
+	fields: []
+};
+//#endregion
+export { toNavigationItem as C, createDefaultAuthRedirect as D, DEFAULT_AUTH_URL as E, transformThemes$1 as S, toScreenDefinition as T, createFluidClient as _, useMessagingConfig as a, getActiveThemeId$1 as b, FluidProvider as c, FluidAuthProvider as d, useFluidAuthContext as f, ApiError as g, themes_exports as h, createFluidFileUploader as i, useFluidContext as l, useThemeContext as m, MessagingScreen_exports as n, useMessagingAuth as o, FluidThemeProvider as p, messagingScreenPropertySchema as r, useFluidApi as s, MessagingScreen as t, DEFAULT_SDK_WIDGET_REGISTRY as u, isApiError as v, normalizeComponentTree as w, transformManifestToRepAppData as x, buildThemeDefinition as y };
+
+//# sourceMappingURL=MessagingScreen-BklF48Fn.mjs.map