@elevasis/ui 1.2.0 → 1.3.0

package/dist/api/hooks/useApiClient.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Return type of useOrganizations hook (subset needed by the factory)
+ */
+interface UseOrganizationsReturn {
+    isInitializing: boolean;
+    isOrgRefreshing: boolean;
+}
+/**
+ * Hook that returns apiRequest and deferredApiRequest bound to the current
+ * ApiClientContext. apiUrl is the only parameter because org ID is resolved
+ * at call time via getOrganizationId() from context.
+ *
+ * Usage:
+ * ```typescript
+ * import { useApiClient } from '@repo/ui/api'
+ *
+ * const API_URL = import.meta.env.VITE_API_SERVER || 'http://localhost:5170'
+ *
+ * function useMyClient() {
+ *   return useApiClient(API_URL)
+ * }
+ * ```
+ */
+export declare function useApiClient(apiUrl: string): {
+    apiRequest: <T>(endpoint: string, options?: RequestInit) => Promise<T>;
+    deferredApiRequest: <T>(endpoint: string, options?: RequestInit) => Promise<T>;
+    isOrganizationReady: boolean;
+    isInitializing: boolean;
+};
+/**
+ * Factory function to create a useApiClient hook for your app.
+ *
+ * @deprecated Use the plain `useApiClient(apiUrl)` hook instead.
+ * The factory pattern is no longer needed because org ID is resolved at
+ * call time via getOrganizationId() from ApiClientContext.
+ *
+ * Migration:
+ * ```typescript
+ * // Before
+ * export const useApiClient = createUseApiClient(useOrganizations, API_URL)
+ *
+ * // After
+ * import { useApiClient } from '@repo/ui/api'
+ * // call useApiClient(API_URL) directly in your hook/component
+ * ```
+ */
+export declare function createUseApiClient(useOrganizations: () => UseOrganizationsReturn, apiUrl: string): () => {
+    apiRequest: <T>(endpoint: string, options?: RequestInit) => Promise<T>;
+    deferredApiRequest: <T>(endpoint: string, options?: RequestInit) => Promise<T>;
+    isOrganizationReady: boolean;
+    isInitializing: boolean;
+};
+export {};
+//# sourceMappingURL=useApiClient.d.ts.map

package/dist/api/hooks/useApiClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useApiClient.d.ts","sourceRoot":"","sources":["../../../src/api/hooks/useApiClient.ts"],"names":[],"mappings":"AAOA;;GAEG;AACH,UAAU,sBAAsB;IAC9B,cAAc,EAAE,OAAO,CAAA;IACvB,eAAe,EAAE,OAAO,CAAA;CACzB;AA+FD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM;iBA+BtC,CAAC,YAAY,MAAM,YAAW,WAAW,KAAQ,OAAO,CAAC,CAAC,CAAC;yBAMrD,CAAC,YAAY,MAAM,YAAW,WAAW,KAAQ,OAAO,CAAC,CAAC,CAAC;;;EAerE;AAMD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,kBAAkB,CAAC,gBAAgB,EAAE,MAAM,sBAAsB,EAAE,MAAM,EAAE,MAAM;iBAqC1F,CAAC,YAAY,MAAM,YAAW,WAAW,KAAQ,OAAO,CAAC,CAAC,CAAC;yBAMrD,CAAC,YAAY,MAAM,YAAW,WAAW,KAAQ,OAAO,CAAC,CAAC,CAAC;;;EAqBvE"}

package/dist/api/hooks/useApiClient.js

@@ -0,0 +1,185 @@
+import { useCallback } from 'react';
+import { HTTP_HEADERS } from '@repo/core';
+import { APIClientError } from '../../utils';
+import { useApiClientContext } from '../context/ApiClientProvider';
+const DEFAULT_TIMEOUT_MS = 60_000;
+// ---------------------------------------------------------------------------
+// Shared request logic builder — used by both the plain hook and the factory.
+// ---------------------------------------------------------------------------
+function buildApiRequest(getAccessToken, getOrganizationId, apiUrl, handleResponseError) {
+    return async function apiRequest(endpoint, options = {}) {
+        try {
+            // Get the access token from context
+            const token = await getAccessToken();
+            // Read org ID at call time — reflects org switches without re-render
+            const organizationId = getOrganizationId();
+            // DEBUG
+            if (organizationId)
+                console.log('[apiRequest]', endpoint, 'org:', organizationId);
+            // Only set Content-Type if there's a body
+            const headers = {
+                ...(options.body ? { 'Content-Type': 'application/json' } : {}),
+                ...(token ? { Authorization: `Bearer ${token}` } : {}),
+                ...(organizationId && { [HTTP_HEADERS.WORKOS_ORGANIZATION_ID]: organizationId }),
+                ...options.headers
+            };
+            const timeoutSignal = AbortSignal.timeout(DEFAULT_TIMEOUT_MS);
+            const signal = options.signal ? AbortSignal.any([options.signal, timeoutSignal]) : timeoutSignal;
+            const response = await fetch(`${apiUrl}/api${endpoint}`, {
+                ...options,
+                headers,
+                signal
+            });
+            if (!response.ok) {
+                await handleResponseError(endpoint, response, options);
+            }
+            // Handle 204 No Content responses
+            if (response.status === 204) {
+                return undefined;
+            }
+            const data = await response.json();
+            // DEBUG
+            if (organizationId && endpoint.includes('dashboard'))
+                console.log('[apiResponse] dashboard:', data);
+            return data;
+        }
+        catch (error) {
+            // If getAccessToken fails, still make the request without auth
+            // This allows public endpoints to work
+            if (error instanceof Error && error.message.includes('No access token')) {
+                // Only set Content-Type if there's a body
+                const headers = {
+                    ...(options.body ? { 'Content-Type': 'application/json' } : {}),
+                    ...options.headers
+                };
+                const fallbackTimeoutSignal = AbortSignal.timeout(DEFAULT_TIMEOUT_MS);
+                const fallbackSignal = options.signal
+                    ? AbortSignal.any([options.signal, fallbackTimeoutSignal])
+                    : fallbackTimeoutSignal;
+                const response = await fetch(`${apiUrl}/api${endpoint}`, {
+                    ...options,
+                    headers,
+                    signal: fallbackSignal
+                });
+                if (!response.ok) {
+                    await handleResponseError(endpoint, response, options);
+                }
+                if (response.status === 204) {
+                    return undefined;
+                }
+                return response.json();
+            }
+            throw error;
+        }
+    };
+}
+// ---------------------------------------------------------------------------
+// Plain hook — reads everything from ApiClientContext directly.
+// apiUrl must be provided because the context does not store it.
+// ---------------------------------------------------------------------------
+/**
+ * Hook that returns apiRequest and deferredApiRequest bound to the current
+ * ApiClientContext. apiUrl is the only parameter because org ID is resolved
+ * at call time via getOrganizationId() from context.
+ *
+ * Usage:
+ * ```typescript
+ * import { useApiClient } from '@repo/ui/api'
+ *
+ * const API_URL = import.meta.env.VITE_API_SERVER || 'http://localhost:5170'
+ *
+ * function useMyClient() {
+ *   return useApiClient(API_URL)
+ * }
+ * ```
+ */
+export function useApiClient(apiUrl) {
+    const { getAccessToken, getOrganizationId, isOrganizationReady, onError } = useApiClientContext();
+    const handleResponseError = useCallback(async (endpoint, response, options) => {
+        const errorData = await response.json().catch(() => ({
+            error: `HTTP ${response.status}`,
+            code: 'INTERNAL_SERVER_ERROR'
+        }));
+        if (response.status >= 500 && onError) {
+            onError(endpoint, new Error(errorData.error), {
+                method: options.method || 'GET',
+                statusCode: response.status,
+                requestId: errorData.requestId
+            });
+        }
+        throw new APIClientError(errorData.error, errorData.code, response.status, errorData.requestId, errorData.fields, errorData.retryAfter);
+    }, [onError]);
+    const apiRequest = useCallback((endpoint, options = {}) => buildApiRequest(getAccessToken, getOrganizationId, apiUrl, handleResponseError)(endpoint, options), [getAccessToken, getOrganizationId, apiUrl, handleResponseError]);
+    const deferredApiRequest = useCallback(async (endpoint, options = {}) => {
+        if (!isOrganizationReady) {
+            throw new Error('No organization selected. Please select an organization.');
+        }
+        return apiRequest(endpoint, options);
+    }, [apiRequest, isOrganizationReady]);
+    return {
+        apiRequest,
+        deferredApiRequest,
+        isOrganizationReady,
+        isInitializing: false
+    };
+}
+// ---------------------------------------------------------------------------
+// Factory — kept for backwards compatibility during migration.
+// ---------------------------------------------------------------------------
+/**
+ * Factory function to create a useApiClient hook for your app.
+ *
+ * @deprecated Use the plain `useApiClient(apiUrl)` hook instead.
+ * The factory pattern is no longer needed because org ID is resolved at
+ * call time via getOrganizationId() from ApiClientContext.
+ *
+ * Migration:
+ * ```typescript
+ * // Before
+ * export const useApiClient = createUseApiClient(useOrganizations, API_URL)
+ *
+ * // After
+ * import { useApiClient } from '@repo/ui/api'
+ * // call useApiClient(API_URL) directly in your hook/component
+ * ```
+ */
+export function createUseApiClient(useOrganizations, apiUrl) {
+    return function useApiClientCompat() {
+        const { getAccessToken, getOrganizationId, isOrganizationReady, onError } = useApiClientContext();
+        const { isInitializing, isOrgRefreshing } = useOrganizations();
+        /**
+         * Handle API response errors
+         * Logs 5xx errors via onError callback and throws APIClientError
+         */
+        const handleResponseError = useCallback(async (endpoint, response, options) => {
+            const errorData = await response.json().catch(() => ({
+                error: `HTTP ${response.status}`,
+                code: 'INTERNAL_SERVER_ERROR'
+            }));
+            if (response.status >= 500 && onError) {
+                onError(endpoint, new Error(errorData.error), {
+                    method: options.method || 'GET',
+                    statusCode: response.status,
+                    requestId: errorData.requestId
+                });
+            }
+            throw new APIClientError(errorData.error, errorData.code, response.status, errorData.requestId, errorData.fields, errorData.retryAfter);
+        }, [onError]);
+        const apiRequest = useCallback((endpoint, options = {}) => buildApiRequest(getAccessToken, getOrganizationId, apiUrl, handleResponseError)(endpoint, options), [getAccessToken, getOrganizationId, handleResponseError]);
+        const deferredApiRequest = useCallback(async (endpoint, options = {}) => {
+            if (isInitializing || isOrgRefreshing) {
+                throw new Error('Organization context is still initializing. Please wait.');
+            }
+            if (!isOrganizationReady) {
+                throw new Error('No organization selected. Please select an organization.');
+            }
+            return apiRequest(endpoint, options);
+        }, [apiRequest, isInitializing, isOrgRefreshing, isOrganizationReady]);
+        return {
+            apiRequest,
+            deferredApiRequest,
+            isOrganizationReady,
+            isInitializing: isInitializing || isOrgRefreshing
+        };
+    };
+}

package/dist/api/index.d.ts

@@ -5,8 +5,10 @@ import * as react_jsx_runtime from 'react/jsx-runtime';
  */
 interface ApiClientContextValue {
     getAccessToken: () => Promise<string | undefined>;
+    /** @deprecated Read via getOrganizationId() instead. Kept for downstream context consumers during migration. */
     organizationId: string | null;
     isOrganizationReady: boolean;
+    getOrganizationId: () => string | null;
     onError?: (endpoint: string, error: Error, details?: ApiErrorDetails) => void;
 }
 interface ApiErrorDetails {
@@ -17,7 +19,19 @@ interface ApiErrorDetails {
 interface ApiClientProviderProps {
     children: React.ReactNode;
     getAccessToken: () => Promise<string | undefined>;
-    organizationId: string | null;
+    /**
+     * Static org ID. Used when org ID is stable at render time.
+     * Cannot reflect org switches without re-rendering the provider.
+     * Prefer getOrganizationId for dynamic org context.
+     * @deprecated Pass getOrganizationId instead for dynamic org resolution.
+     */
+    organizationId?: string | null;
+    /**
+     * Callback invoked on every request to read the current org ID.
+     * Takes precedence over organizationId when provided.
+     * Allows org switching without re-rendering the provider tree.
+     */
+    getOrganizationId?: () => string | null;
     isOrganizationReady: boolean;
     onError?: (endpoint: string, error: Error, details?: ApiErrorDetails) => void;
 }
@@ -52,28 +66,52 @@ declare function useApiClientContext(): ApiClientContextValue;
  * }
  * ```
  */
-declare function ApiClientProvider({ children, getAccessToken, organizationId, isOrganizationReady, onError }: ApiClientProviderProps): react_jsx_runtime.JSX.Element;
+declare function ApiClientProvider({ children, getAccessToken, organizationId, getOrganizationId: getOrganizationIdProp, isOrganizationReady, onError }: ApiClientProviderProps): react_jsx_runtime.JSX.Element;
 
 /**
- * Return type of useOrganizations hook (subset needed by useApiClient)
+ * Return type of useOrganizations hook (subset needed by the factory)
  */
 interface UseOrganizationsReturn {
     isInitializing: boolean;
     isOrgRefreshing: boolean;
 }
 /**
- * Factory function to create a useApiClient hook for your app.
- *
- * This pattern allows the shared package to provide the hook logic
- * while each app provides its own useOrganizations hook and API URL.
+ * Hook that returns apiRequest and deferredApiRequest bound to the current
+ * ApiClientContext. apiUrl is the only parameter because org ID is resolved
+ * at call time via getOrganizationId() from context.
  *
- * Usage in app:
+ * Usage:
  * ```typescript
- * import { createUseApiClient } from '@repo/ui/api'
- * import { useOrganizations } from './organization/hooks/useOrganizations'
+ * import { useApiClient } from '@repo/ui/api'
  *
  * const API_URL = import.meta.env.VITE_API_SERVER || 'http://localhost:5170'
+ *
+ * function useMyClient() {
+ *   return useApiClient(API_URL)
+ * }
+ * ```
+ */
+declare function useApiClient(apiUrl: string): {
+    apiRequest: <T>(endpoint: string, options?: RequestInit) => Promise<T>;
+    deferredApiRequest: <T>(endpoint: string, options?: RequestInit) => Promise<T>;
+    isOrganizationReady: boolean;
+    isInitializing: boolean;
+};
+/**
+ * Factory function to create a useApiClient hook for your app.
+ *
+ * @deprecated Use the plain `useApiClient(apiUrl)` hook instead.
+ * The factory pattern is no longer needed because org ID is resolved at
+ * call time via getOrganizationId() from ApiClientContext.
+ *
+ * Migration:
+ * ```typescript
+ * // Before
  * export const useApiClient = createUseApiClient(useOrganizations, API_URL)
+ *
+ * // After
+ * import { useApiClient } from '@repo/ui/api'
+ * // call useApiClient(API_URL) directly in your hook/component
  * ```
  */
 declare function createUseApiClient(useOrganizations: () => UseOrganizationsReturn, apiUrl: string): () => {
@@ -83,5 +121,5 @@ declare function createUseApiClient(useOrganizations: () => UseOrganizationsRetu
     isInitializing: boolean;
 };
 
-export { ApiClientProvider, createUseApiClient, useApiClientContext };
+export { ApiClientProvider, createUseApiClient, useApiClient, useApiClientContext };
 export type { ApiClientContextValue, ApiClientProviderProps, ApiErrorDetails };

package/dist/api/index.js

@@ -1,3 +1,4 @@
 import '../chunk-XCYKC6OZ.js';
-export { ApiClientProvider, createUseApiClient, useApiClientContext } from '../chunk-GDV44UWF.js';
-import '../chunk-7AI5ZYJ4.js';
+export { ApiClientProvider, createUseApiClient, useApiClient, useApiClientContext } from '../chunk-BWCC6ZJC.js';
+import '../chunk-JVAZHVNV.js';
+import '../chunk-4VGWQ5AN.js';

package/dist/auth/index.d.ts

@@ -83,5 +83,91 @@ declare function useStableAccessToken(): () => Promise<string>;
  */
 declare function useSessionCheck(): void;
 
-export { AuthProvider, WorkOSAuthBridge, useAuthContext, useOAuthContext, useSessionCheck as useRefocusSessionCheck, useSessionCheck, useStableAccessToken };
-export type { AuthAdapter, OAuthContextValue };
+interface InitializationError {
+    layer: 'auth' | 'profile' | 'organization';
+    message: string;
+    originalError?: Error;
+}
+
+interface ProtectedRouteProps {
+    children: ReactNode;
+    /**
+     * Path to redirect to when user is unauthenticated.
+     * @default '/login'
+     */
+    redirectTo?: string;
+    /**
+     * Rendered while initialization is in progress.
+     * When not provided, nothing is rendered during initialization.
+     */
+    fallback?: ReactNode;
+    /**
+     * Rendered when initialization fails with a non-organization error.
+     * Receives the error and a retry callback.
+     * When not provided, the error is silently swallowed (children not rendered).
+     */
+    errorFallback?: (error: InitializationError, retry: () => void) => ReactNode;
+    /**
+     * When true (default), waits for both user AND organization to be ready
+     * before rendering children. When false, only waits for user readiness.
+     * @default true
+     */
+    waitForOrganization?: boolean;
+}
+/**
+ * Headless route guard for authenticated pages.
+ *
+ * Reads initialization state from the nearest InitializationProvider.
+ * Redirects unauthenticated users to `redirectTo` (default: '/login')
+ * with a `returnTo` search param preserving the current location.
+ *
+ * Organization-layer errors are allowed through — routes like /invitations
+ * must be accessible even when the user has no org membership.
+ *
+ * @example
+ * // With custom fallback (your Mantine loader):
+ * <ProtectedRoute fallback={<AppShellLoader />}>
+ *   <DashboardPage />
+ * </ProtectedRoute>
+ *
+ * @example
+ * // Wait only for user, not org (e.g. /invitations route):
+ * <ProtectedRoute waitForOrganization={false}>
+ *   <InvitationsPage />
+ * </ProtectedRoute>
+ */
+declare function ProtectedRoute({ children, redirectTo, fallback, errorFallback, waitForOrganization }: ProtectedRouteProps): react_jsx_runtime.JSX.Element | null;
+
+interface AdminGuardProps {
+    children: ReactNode;
+    /**
+     * Path to redirect non-admin users to.
+     * @default '/'
+     */
+    redirectTo?: string;
+    /**
+     * Rendered while user readiness is being determined.
+     * When not provided, nothing is rendered during initialization.
+     */
+    fallback?: ReactNode;
+}
+/**
+ * Headless route guard for platform admin pages.
+ *
+ * Reads `profile.is_platform_admin` from the nearest InitializationProvider.
+ * Non-admin users are redirected to `redirectTo` (default: '/').
+ *
+ * Must be nested inside a ProtectedRoute (or equivalent) so that
+ * `userReady` is guaranteed to be true when this guard runs.
+ *
+ * @example
+ * <ProtectedRoute>
+ *   <AdminGuard fallback={<AppShellLoader />}>
+ *     <AdminDashboard />
+ *   </AdminGuard>
+ * </ProtectedRoute>
+ */
+declare function AdminGuard({ children, redirectTo, fallback }: AdminGuardProps): react_jsx_runtime.JSX.Element | null;
+
+export { AdminGuard, AuthProvider, ProtectedRoute, WorkOSAuthBridge, useAuthContext, useOAuthContext, useSessionCheck as useRefocusSessionCheck, useSessionCheck, useStableAccessToken };
+export type { AdminGuardProps, AuthAdapter, OAuthContextValue, ProtectedRouteProps };

package/dist/auth/index.js

@@ -1,4 +1,8 @@
-export { useSessionCheck as useRefocusSessionCheck, useSessionCheck, useStableAccessToken } from '../chunk-HBRMWW6V.js';
+export { AdminGuard, ProtectedRoute, useSessionCheck as useRefocusSessionCheck, useSessionCheck, useStableAccessToken } from '../chunk-FDCVFCOQ.js';
 export { WorkOSAuthBridge } from '../chunk-NIAVTSMB.js';
-export { useOAuthContext } from '../chunk-KSG4C5DD.js';
+export { useOAuthContext } from '../chunk-QSVZP2NU.js';
+import '../chunk-QQOLC46E.js';
+import '../chunk-DD3CCMCZ.js';
+import '../chunk-4KAG5U7A.js';
+import '../chunk-KA7LO7U5.js';
 export { AuthProvider, useAuthContext } from '../chunk-7PLEQFHO.js';

package/dist/{chunk-5UWFGBFM.js → chunk-4KAG5U7A.js}

@@ -1,6 +1,6 @@
 import { useElevasisServices } from './chunk-KA7LO7U5.js';
 import { useAuthContext } from './chunk-7PLEQFHO.js';
-import { useState, useEffect } from 'react';
+import { createContext, useState, useEffect, useContext, createElement } from 'react';
 
 // src/profile/services/UserProfileService.ts
 var UserProfileService = class {
@@ -65,8 +65,6 @@ var UserProfileService = class {
     }
   }
 };
-
-// src/profile/hooks/useUserProfile.ts
 var useUserProfile = (options) => {
   const { user, isLoading: authLoading } = useAuthContext();
   const { apiRequest } = useElevasisServices();
@@ -125,5 +123,21 @@ var useUserProfile = (options) => {
     refetch
   };
 };
+var ProfileContext = createContext(null);
+function useProfile() {
+  const ctx = useContext(ProfileContext);
+  if (!ctx) {
+    throw new Error(
+      "useProfile must be used within a ProfileProvider. Wrap your app (or the relevant subtree) with <ProfileProvider>."
+    );
+  }
+  return ctx;
+}
+function ProfileProvider({ children }) {
+  const value = useUserProfile();
+  if (!value.loading && value.profile) console.log("[ProfileProvider] ready, profile:", value.profile.id);
+  if (!value.loading && value.error) console.log("[ProfileProvider] error:", value.error.message);
+  return createElement(ProfileContext.Provider, { value }, children);
+}
 
-export { UserProfileService, useUserProfile };
+export { ProfileProvider, UserProfileService, useProfile, useUserProfile };

package/dist/chunk-4VGWQ5AN.js

@@ -0,0 +1,91 @@
+// src/utils/error-utils.ts
+var APIClientError = class extends Error {
+  statusCode;
+  code;
+  requestId;
+  fields;
+  retryAfter;
+  constructor(message, code, statusCode, requestId, fields, retryAfter) {
+    super(message);
+    this.name = "APIClientError";
+    this.code = code;
+    this.statusCode = statusCode;
+    this.requestId = requestId;
+    this.fields = fields;
+    this.retryAfter = retryAfter;
+  }
+};
+function isAPIClientError(error) {
+  return error instanceof APIClientError;
+}
+function getErrorInfo(error) {
+  if (isAPIClientError(error)) {
+    return {
+      message: error.message,
+      code: error.code,
+      requestId: error.requestId,
+      statusCode: error.statusCode,
+      fields: error.fields,
+      retryAfter: error.retryAfter
+    };
+  }
+  if (error instanceof Error) {
+    return {
+      message: error.message
+    };
+  }
+  return {
+    message: String(error)
+  };
+}
+function getErrorTitle(code) {
+  if (!code) return "Error";
+  switch (code) {
+    case "VALIDATION_ERROR":
+      return "Validation Error";
+    case "AUTHENTICATION_FAILED":
+      return "Authentication Required";
+    case "FORBIDDEN":
+      return "Access Denied";
+    case "NOT_FOUND":
+      return "Not Found";
+    case "CONFLICT":
+      return "Conflict";
+    case "RATE_LIMIT_EXCEEDED":
+      return "Rate Limit Exceeded";
+    case "INTERNAL_SERVER_ERROR":
+      return "Server Error";
+    case "SERVICE_UNAVAILABLE":
+      return "Service Temporarily Unavailable";
+    default:
+      return "Error";
+  }
+}
+function formatErrorMessage(message, requestId, fields, retryAfter) {
+  let formatted = message;
+  if (fields && Object.keys(fields).length > 0) {
+    const fieldErrors = [];
+    for (const [field, errors] of Object.entries(fields)) {
+      const fieldName = field === "root" || field === "_root" ? "Request" : field;
+      errors.forEach((error) => {
+        fieldErrors.push(`\u2022 ${fieldName}: ${error}`);
+      });
+    }
+    if (fieldErrors.length > 0) {
+      formatted = fieldErrors.join("\n");
+    }
+  }
+  if (retryAfter) {
+    formatted += `
+
+Please wait ${retryAfter} seconds before retrying.`;
+  }
+  if (requestId) {
+    formatted += `
+
+Request ID: ${requestId}`;
+  }
+  return formatted;
+}
+
+export { APIClientError, formatErrorMessage, getErrorInfo, getErrorTitle, isAPIClientError };

package/dist/{chunk-JKERRYVS.js → chunk-BLO4SISK.js}

@@ -1,5 +1,5 @@
+import { useNotificationAdapter } from './chunk-TIRMFDM4.js';
 import { useElevasisServices } from './chunk-KA7LO7U5.js';
-import { showApiErrorNotification } from './chunk-7AI5ZYJ4.js';
 import { useQueryClient, useMutation, useQuery } from '@tanstack/react-query';
 import { z } from 'zod';
 
@@ -26,6 +26,8 @@ z.object({
   startDate: z.string().datetime(),
   endDate: z.string().datetime()
 });
+
+// ../core/src/operations/notifications/api-schemas.ts
 var NotificationCategorySchema = z.enum(["info", "queue", "alert", "error", "system"]);
 var GetNotificationsQuerySchema = z.object({
   limit: z.coerce.number().int().min(1).max(100).default(50),
@@ -47,6 +49,7 @@ z.object({
 function useMarkAsRead() {
   const queryClient = useQueryClient();
   const { apiRequest } = useElevasisServices();
+  const notify = useNotificationAdapter();
   return useMutation({
     mutationFn: async (notificationId) => {
       MarkAsReadParamsSchema.parse({ id: notificationId });
@@ -58,13 +61,14 @@ function useMarkAsRead() {
       queryClient.invalidateQueries({ queryKey: ["notifications"] });
     },
     onError: (error) => {
-      showApiErrorNotification(error);
+      notify.apiError(error);
     }
   });
 }
 function useMarkAllAsRead() {
   const queryClient = useQueryClient();
   const { apiRequest } = useElevasisServices();
+  const notify = useNotificationAdapter();
   return useMutation({
     mutationFn: async () => {
       await apiRequest("/notifications/mark-all-read", {
@@ -75,7 +79,7 @@ function useMarkAllAsRead() {
       queryClient.invalidateQueries({ queryKey: ["notifications"] });
     },
     onError: (error) => {
-      showApiErrorNotification(error);
+      notify.apiError(error);
     }
   });
 }