@elevasis/ui 2.36.0 → 2.37.0

package/dist/chunk-IIMU5YAJ.js

@@ -0,0 +1,53 @@
+import { sidebarIconSize, sidebarIconStroke, sidebarIconInnerSize } from './chunk-DT3QYZVU.js';
+import { Box, Group, ThemeIcon } from '@mantine/core';
+import { jsx, jsxs } from 'react/jsx-runtime';
+
+var SubshellSidebarSection = ({
+  icon: Icon,
+  label,
+  rightSection,
+  withTopBorder = false
+}) => {
+  return /* @__PURE__ */ jsx(
+    Box,
+    {
+      p: "sm",
+      style: {
+        borderTop: withTopBorder ? "1px solid var(--color-border)" : void 0,
+        borderBottom: "1px solid var(--color-border)"
+      },
+      children: /* @__PURE__ */ jsxs(Group, { gap: "xs", children: [
+        /* @__PURE__ */ jsx(
+          ThemeIcon,
+          {
+            variant: "light",
+            size: sidebarIconSize,
+            style: {
+              backgroundColor: "var(--color-surface)",
+              color: "var(--color-primary)",
+              flexShrink: 0
+            },
+            children: /* @__PURE__ */ jsx(Icon, { size: sidebarIconInnerSize, stroke: sidebarIconStroke })
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          Box,
+          {
+            c: "var(--color-text)",
+            style: {
+              fontFamily: "var(--elevasis-font-family-subtitle)",
+              flex: 1,
+              fontSize: "var(--mantine-font-size-md)",
+              fontWeight: 500,
+              lineHeight: 1.2
+            },
+            children: label
+          }
+        ),
+        rightSection
+      ] })
+    }
+  );
+};
+
+export { SubshellSidebarSection };

package/dist/{chunk-VKIZUUPM.js → chunk-JPVZRZ3X.js}

@@ -1,3 +1,4 @@
+import { useAccess } from './chunk-LCJQ6OWC.js';
 import { useInitialization } from './chunk-533DUEQY.js';
 import { useAuthContext } from './chunk-BRJ3QZ4E.js';
 import { useRef, useCallback, useEffect } from 'react';
@@ -93,24 +94,40 @@ function ProtectedRoute({
   }
   return /* @__PURE__ */ jsx(Fragment, { children });
 }
-function AdminGuard({ children, redirectTo = "/", fallback = null }) {
-  const { userReady, profile } = useInitialization();
-  const navigate = useNavigate();
+function useOptionalNavigate() {
+  try {
+    return useNavigate();
+  } catch {
+    return null;
+  }
+}
+function renderFallback(fallback, answer) {
+  return typeof fallback === "function" ? fallback(answer) : fallback ?? null;
+}
+function AccessGuard({
+  accessKey,
+  children,
+  fallback = null,
+  loadingFallback = null,
+  redirectTo = null
+}) {
+  const answer = useAccess(accessKey);
+  const navigate = useOptionalNavigate();
+  const hasRedirected = useRef(false);
   useEffect(() => {
-    if (!userReady || !profile) {
+    if (!answer.isReady || answer.allowed || !redirectTo || hasRedirected.current) return;
+    hasRedirected.current = true;
+    if (navigate) {
+      navigate({ to: redirectTo });
       return;
     }
-    if (!profile.is_platform_admin) {
-      navigate({ to: redirectTo });
+    if (typeof window !== "undefined") {
+      window.location.assign(redirectTo);
     }
-  }, [userReady, profile, navigate, redirectTo]);
-  if (!userReady) {
-    return /* @__PURE__ */ jsx(Fragment, { children: fallback });
-  }
-  if (!profile?.is_platform_admin) {
-    return null;
-  }
+  }, [answer.allowed, answer.isReady, navigate, redirectTo]);
+  if (!answer.isReady) return /* @__PURE__ */ jsx(Fragment, { children: loadingFallback });
+  if (!answer.allowed) return /* @__PURE__ */ jsx(Fragment, { children: renderFallback(fallback, answer) });
   return /* @__PURE__ */ jsx(Fragment, { children });
 }
 
-export { AdminGuard, ProtectedRoute, useSessionCheck, useStableAccessToken };
+export { AccessGuard, ProtectedRoute, useSessionCheck, useStableAccessToken };

package/dist/chunk-JXVNHVK7.js

@@ -0,0 +1,79 @@
+import { useElevasisServices } from './chunk-KJ3QUBNU.js';
+import { useQuery, useQueryClient, useMutation } from '@tanstack/react-query';
+
+var PRIORITY_ORDER = {
+  urgent: 0,
+  high: 1,
+  normal: 2,
+  low: 3
+};
+function sortNotes(notes) {
+  return [...notes].sort((a, b) => {
+    if (a.pinned !== b.pinned) return a.pinned ? -1 : 1;
+    const pa = PRIORITY_ORDER[a.priority] ?? 2;
+    const pb = PRIORITY_ORDER[b.priority] ?? 2;
+    if (pa !== pb) return pa - pb;
+    return new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime();
+  });
+}
+var userNotesKeys = {
+  all: ["user-notes"],
+  list: (workOSOrgId) => [...userNotesKeys.all, "list", workOSOrgId]
+};
+function useUserNotes() {
+  const { apiRequest, isReady, workOSOrganizationId } = useElevasisServices();
+  return useQuery({
+    queryKey: userNotesKeys.list(workOSOrganizationId),
+    queryFn: async () => {
+      const response = await apiRequest("/user-notes");
+      return sortNotes(response.notes);
+    },
+    enabled: isReady
+  });
+}
+function useCreateUserNote() {
+  const queryClient = useQueryClient();
+  const { apiRequest, workOSOrganizationId } = useElevasisServices();
+  return useMutation({
+    mutationFn: (data) => apiRequest("/user-notes", {
+      method: "POST",
+      body: JSON.stringify(data)
+    }),
+    onSuccess: () => {
+      queryClient.invalidateQueries({
+        queryKey: userNotesKeys.list(workOSOrganizationId)
+      });
+    }
+  });
+}
+function useUpdateUserNote() {
+  const queryClient = useQueryClient();
+  const { apiRequest, workOSOrganizationId } = useElevasisServices();
+  return useMutation({
+    mutationFn: ({ id, ...data }) => apiRequest(`/user-notes/${id}`, {
+      method: "PATCH",
+      body: JSON.stringify(data)
+    }),
+    onSuccess: () => {
+      queryClient.invalidateQueries({
+        queryKey: userNotesKeys.list(workOSOrganizationId)
+      });
+    }
+  });
+}
+function useDeleteUserNote() {
+  const queryClient = useQueryClient();
+  const { apiRequest, workOSOrganizationId } = useElevasisServices();
+  return useMutation({
+    mutationFn: (id) => apiRequest(`/user-notes/${id}`, {
+      method: "DELETE"
+    }),
+    onSuccess: () => {
+      queryClient.invalidateQueries({
+        queryKey: userNotesKeys.list(workOSOrganizationId)
+      });
+    }
+  });
+}
+
+export { useCreateUserNote, useDeleteUserNote, useUpdateUserNote, useUserNotes, userNotesKeys };

package/dist/chunk-JZ2WID2G.js

@@ -0,0 +1,337 @@
+import { FeatureUnavailableState } from './chunk-I53EX4VU.js';
+import { SubshellContainer, SubshellSidebar, SubshellRightSideContainer } from './chunk-A7IG36LB.js';
+import { ApiClientProvider, useApiClient } from './chunk-Y3JQBSKQ.js';
+import { useRouterContext } from './chunk-Q7DJKLEN.js';
+import { getErrorInfo, getErrorTitle, formatErrorMessage } from './chunk-X66MVMZT.js';
+import { useElevasisSystems } from './chunk-NYNOMAAS.js';
+import { InitializationProvider } from './chunk-533DUEQY.js';
+import { OrganizationContext, useOrganization } from './chunk-DD3CCMCZ.js';
+import { useProfile, ProfileProvider } from './chunk-2Q2JQSQO.js';
+import { ElevasisServiceProvider } from './chunk-KJ3QUBNU.js';
+import { useAuthContext } from './chunk-BRJ3QZ4E.js';
+import { createContext, lazy, useState, useRef, useEffect, useCallback, createElement, useContext, Suspense } from 'react';
+import { useQueryClient, QueryClientProvider, QueryClient } from '@tanstack/react-query';
+import { jsx, Fragment, jsxs } from 'react/jsx-runtime';
+
+function OrganizationProvider({ apiRequest, children }) {
+  const { user, organizationId: workosOrgId } = useAuthContext();
+  const { profile, error: profileError } = useProfile();
+  const queryClient = useQueryClient();
+  const [memberships, setMemberships] = useState([]);
+  const [currentWorkOSOrganizationId, setCurrentWorkOSOrganizationId] = useState(null);
+  const [currentSupabaseOrganizationId, setCurrentSupabaseOrganizationId] = useState(null);
+  const [currentMembership, setCurrentMembership] = useState(null);
+  const [isInitializing, setIsInitializing] = useState(true);
+  const [isOrgRefreshing, setIsOrgRefreshing] = useState(false);
+  const [error, setError] = useState(null);
+  const hasInitializedRef = useRef(false);
+  const [profileLoaded, setProfileLoaded] = useState(false);
+  useEffect(() => {
+    if (profile !== void 0 && profile !== null) {
+      setProfileLoaded(true);
+    }
+  }, [profile]);
+  useEffect(() => {
+    if (profileError && isInitializing && !hasInitializedRef.current) {
+      setIsInitializing(false);
+    }
+  }, [profileError, isInitializing]);
+  useEffect(() => {
+    if (!user) {
+      setMemberships([]);
+      setCurrentWorkOSOrganizationId(null);
+      setCurrentSupabaseOrganizationId(null);
+      setCurrentMembership(null);
+      setIsInitializing(false);
+      setIsOrgRefreshing(false);
+      setError(null);
+      hasInitializedRef.current = false;
+      setProfileLoaded(false);
+    }
+  }, [user]);
+  const applyMembership = useCallback((membership) => {
+    setCurrentMembership(membership);
+    setCurrentSupabaseOrganizationId(membership?.organization?.id ?? null);
+    setCurrentWorkOSOrganizationId(membership?.organization?.workos_org_id ?? null);
+  }, []);
+  const selectOrganization = useCallback(
+    (data) => {
+      let selected = null;
+      if (profile?.last_visited_org) {
+        selected = data.find((m) => m.organizationId === profile.last_visited_org) ?? null;
+      }
+      if (!selected && workosOrgId) {
+        selected = data.find((m) => m.organization?.workos_org_id === workosOrgId) ?? null;
+      }
+      if (!selected && data.length > 0) {
+        selected = data[0];
+      }
+      if (selected) {
+        applyMembership(selected);
+      }
+    },
+    [profile?.last_visited_org, workosOrgId, applyMembership]
+  );
+  const fetchAndInitialize = useCallback(async () => {
+    if (!user?.id || !profileLoaded) return;
+    setError(null);
+    if (memberships.length === 0) {
+      setIsInitializing(true);
+    } else {
+      setIsOrgRefreshing(true);
+    }
+    try {
+      const data = await apiRequest("/memberships/my-memberships");
+      if (!Array.isArray(data)) {
+        throw new Error("Invalid memberships response");
+      }
+      setMemberships(data);
+      if (data.length === 0) {
+        hasInitializedRef.current = true;
+        return;
+      }
+      if (!currentWorkOSOrganizationId) {
+        selectOrganization(data);
+      } else {
+        const stillPresent = data.find((m) => m.organization?.workos_org_id === currentWorkOSOrganizationId);
+        if (!stillPresent) {
+          applyMembership(data[0] ?? null);
+        } else {
+          applyMembership(stillPresent);
+        }
+      }
+      hasInitializedRef.current = true;
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Failed to load organizations");
+    } finally {
+      setIsInitializing(false);
+      setIsOrgRefreshing(false);
+    }
+  }, [
+    user?.id,
+    profileLoaded,
+    memberships.length,
+    apiRequest,
+    currentWorkOSOrganizationId,
+    selectOrganization,
+    applyMembership
+  ]);
+  useEffect(() => {
+    if (!user?.id || !profileLoaded || hasInitializedRef.current) return;
+    fetchAndInitialize();
+  }, [user?.id, profileLoaded, fetchAndInitialize]);
+  useEffect(() => {
+    if (!hasInitializedRef.current) return;
+    if (!workosOrgId) return;
+    if (workosOrgId === currentWorkOSOrganizationId) return;
+    const target = memberships.find((m) => m.organization?.workos_org_id === workosOrgId);
+    if (!target) return;
+    applyMembership(target);
+    void queryClient.invalidateQueries();
+  }, [workosOrgId, currentWorkOSOrganizationId, memberships, applyMembership, queryClient]);
+  const switchOrganization = useCallback(
+    (workosOrgId2) => {
+      const target = memberships.find((m) => m.organization?.workos_org_id === workosOrgId2);
+      if (!target) return;
+      applyMembership(target);
+      void queryClient.invalidateQueries();
+      void apiRequest("/users/me", {
+        method: "PATCH",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ last_visited_org: target.organizationId })
+      }).catch((err) => {
+        console.warn("Failed to persist last_visited_org preference:", err);
+      });
+    },
+    [memberships, applyMembership, queryClient, apiRequest]
+  );
+  const retry = useCallback(async () => {
+    hasInitializedRef.current = false;
+    setError(null);
+    await fetchAndInitialize();
+  }, [fetchAndInitialize]);
+  const value = {
+    currentWorkOSOrganizationId,
+    currentSupabaseOrganizationId,
+    currentMembership,
+    memberships,
+    isInitializing,
+    isOrgRefreshing,
+    error,
+    switchOrganization,
+    retry
+  };
+  return createElement(OrganizationContext.Provider, { value }, children);
+}
+var consoleAdapter = {
+  success(title, message) {
+    console.log(`[Notification][Success] ${title}: ${message}`);
+  },
+  error(title, message) {
+    console.warn(`[Notification][Error] ${title}: ${message}`);
+  },
+  info(title, message) {
+    console.log(`[Notification][Info] ${title}: ${message}`);
+  },
+  warning(title, message) {
+    console.warn(`[Notification][Warning] ${title}: ${message}`);
+  },
+  apiError(error) {
+    const { message, code, requestId, fields, retryAfter } = getErrorInfo(error);
+    const title = getErrorTitle(code);
+    const formatted = formatErrorMessage(message, requestId, fields, retryAfter);
+    console.warn(`[Notification][API Error] ${title}: ${formatted}`);
+  }
+};
+var NotificationContext = createContext(consoleAdapter);
+function NotificationProvider({ adapter, children }) {
+  return /* @__PURE__ */ jsx(NotificationContext.Provider, { value: adapter, children });
+}
+function useNotificationAdapter() {
+  return useContext(NotificationContext);
+}
+var CrmActionsContext = createContext([]);
+function CrmActionsProvider({ actions, children }) {
+  return /* @__PURE__ */ jsx(CrmActionsContext.Provider, { value: actions, children });
+}
+function useCrmActions() {
+  return useContext(CrmActionsContext);
+}
+var EMPTY_LIST_ACTIONS = Object.freeze([]);
+var ListActionsContext = createContext(EMPTY_LIST_ACTIONS);
+function ListActionsProvider({
+  registry = EMPTY_LIST_ACTIONS,
+  children
+}) {
+  return /* @__PURE__ */ jsx(ListActionsContext.Provider, { value: registry, children });
+}
+function useListActions() {
+  return useContext(ListActionsContext);
+}
+function findListActionByAction(registry, actionKey) {
+  return registry.find((action) => action.actionKey === actionKey);
+}
+function getListActionWorkflowId(action) {
+  return action.workflowId ?? action.resourceId;
+}
+var LazyCoreAuthKitInner = lazy(() => import('./CoreAuthKitInner-QC62UHTZ.js').then((m) => ({ default: m.CoreAuthKitInner })));
+var defaultQueryClient = null;
+function getDefaultQueryClient() {
+  if (!defaultQueryClient) {
+    defaultQueryClient = new QueryClient({
+      defaultOptions: { queries: { retry: 1 } }
+    });
+  }
+  return defaultQueryClient;
+}
+var consoleNotificationAdapter = {
+  success(title, message) {
+    console.log(`[Notification][Success] ${title}: ${message}`);
+  },
+  error(title, message) {
+    console.warn(`[Notification][Error] ${title}: ${message}`);
+  },
+  info(title, message) {
+    console.log(`[Notification][Info] ${title}: ${message}`);
+  },
+  warning(title, message) {
+    console.warn(`[Notification][Warning] ${title}: ${message}`);
+  },
+  apiError(error) {
+    console.warn(`[Notification][API Error]`, error);
+  }
+};
+function ElevasisCoreProvider({
+  auth,
+  queryClient,
+  apiUrl,
+  onError,
+  notifications,
+  crmActions,
+  listActions,
+  children
+}) {
+  if (auth.mode === "apiKey") {
+    throw new Error(
+      `ElevasisCoreProvider: auth mode 'apiKey' is not yet implemented. Only 'authkit' mode is supported.`
+    );
+  }
+  const resolvedQueryClient = queryClient ?? getDefaultQueryClient();
+  const resolvedCrmActions = crmActions ?? [];
+  const resolvedListActions = listActions ?? EMPTY_LIST_ACTIONS;
+  const content = apiUrl ? /* @__PURE__ */ jsx(ServiceStack, { apiUrl, onError, notifications, children }) : children;
+  const AuthInner = /* @__PURE__ */ jsx(Suspense, { fallback: null, children: /* @__PURE__ */ jsx(LazyCoreAuthKitInner, { auth, children: content }) });
+  return /* @__PURE__ */ jsx(QueryClientProvider, { client: resolvedQueryClient, children: /* @__PURE__ */ jsx(CrmActionsProvider, { actions: resolvedCrmActions, children: /* @__PURE__ */ jsx(ListActionsProvider, { registry: resolvedListActions, children: AuthInner }) }) });
+}
+function ServiceStack({
+  apiUrl,
+  onError,
+  notifications,
+  children
+}) {
+  const { getAccessToken } = useAuthContext();
+  const orgIdRef = useRef(null);
+  const getOrganizationId = useRef(() => orgIdRef.current).current;
+  return /* @__PURE__ */ jsx(
+    ApiClientProvider,
+    {
+      getAccessToken,
+      getOrganizationId,
+      isOrganizationReady: false,
+      onError,
+      children: /* @__PURE__ */ jsx(ServiceStackInner, { apiUrl, orgIdRef, notifications, children })
+    }
+  );
+}
+function ServiceStackInner({
+  apiUrl,
+  orgIdRef,
+  notifications,
+  children
+}) {
+  const { apiRequest } = useApiClient(apiUrl);
+  const resolvedNotifications = notifications ?? consoleNotificationAdapter;
+  return /* @__PURE__ */ jsx(ProfileProvider, { apiRequest, children: /* @__PURE__ */ jsx(OrganizationProvider, { apiRequest, children: /* @__PURE__ */ jsx(OrgServiceBridge, { orgIdRef, apiRequest, notifications: resolvedNotifications, children }) }) });
+}
+function OrgServiceBridge({
+  orgIdRef,
+  apiRequest,
+  notifications,
+  children
+}) {
+  const { currentWorkOSOrganizationId, isInitializing, isOrgRefreshing } = useOrganization();
+  orgIdRef.current = currentWorkOSOrganizationId;
+  const isReady = !!currentWorkOSOrganizationId && !isInitializing && !isOrgRefreshing;
+  return /* @__PURE__ */ jsx(
+    ElevasisServiceProvider,
+    {
+      apiRequest,
+      workOSOrganizationId: currentWorkOSOrganizationId,
+      isReady,
+      children: /* @__PURE__ */ jsx(NotificationProvider, { adapter: notifications, children: /* @__PURE__ */ jsx(InitializationProvider, { children }) })
+    }
+  );
+}
+var defaultSystemSidebarWidth = 250;
+function SystemShell({ children }) {
+  const { shellRuntime } = useElevasisSystems();
+  const { currentPath } = useRouterContext();
+  const routeMatch = shellRuntime.resolveRoute(currentPath);
+  if (routeMatch.status === "hidden") {
+    return /* @__PURE__ */ jsx(FeatureUnavailableState, { path: currentPath });
+  }
+  if (routeMatch.status !== "matched" || !routeMatch.system?.sidebar) {
+    return /* @__PURE__ */ jsx(Fragment, { children });
+  }
+  const SidebarComponent = routeMatch.system.sidebar;
+  const sidebarWidth = typeof routeMatch.system.sidebarWidth === "function" ? routeMatch.system.sidebarWidth({ currentPath }) : routeMatch.system.sidebarWidth ?? defaultSystemSidebarWidth;
+  if (sidebarWidth === 0) {
+    return /* @__PURE__ */ jsx(Fragment, { children });
+  }
+  return /* @__PURE__ */ jsxs(SubshellContainer, { children: [
+    /* @__PURE__ */ jsx(SubshellSidebar, { width: sidebarWidth, children: /* @__PURE__ */ jsx(SidebarComponent, {}) }),
+    /* @__PURE__ */ jsx(SubshellRightSideContainer, { children })
+  ] });
+}
+
+export { CrmActionsProvider, EMPTY_LIST_ACTIONS, ElevasisCoreProvider, ListActionsProvider, NotificationProvider, OrganizationProvider, SystemShell, findListActionByAction, getListActionWorkflowId, useCrmActions, useListActions, useNotificationAdapter };