@elevasis/ui 1.0.0

package/dist/chunk-GDV44UWF.js

@@ -0,0 +1,138 @@
+import { APIClientError } from './chunk-7AI5ZYJ4.js';
+import { createContext, useContext, useMemo, useCallback } from 'react';
+import { jsx } from 'react/jsx-runtime';
+
+var ApiClientContext = createContext(null);
+function useApiClientContext() {
+  const context = useContext(ApiClientContext);
+  if (!context) {
+    throw new Error("useApiClient must be used within ApiClientProvider");
+  }
+  return context;
+}
+function ApiClientProvider({
+  children,
+  getAccessToken,
+  organizationId,
+  isOrganizationReady,
+  onError
+}) {
+  const value = useMemo(
+    () => ({
+      getAccessToken,
+      organizationId,
+      isOrganizationReady,
+      onError
+    }),
+    [getAccessToken, organizationId, isOrganizationReady, onError]
+  );
+  return /* @__PURE__ */ jsx(ApiClientContext.Provider, { value, children });
+}
+
+// ../core/src/platform/constants/http.ts
+var HTTP_HEADERS = {
+  /**
+   * Organization context header
+   * Note: Node.js normalizes all headers to lowercase, so we use lowercase consistently
+   */
+  WORKOS_ORGANIZATION_ID: "workos-organization-id",
+  AGENT_ORGANIZATION: "x-agent-organization",
+  AGENT_MODE: "x-agent-mode"
+};
+
+// src/api/hooks/useApiClient.ts
+var DEFAULT_TIMEOUT_MS = 6e4;
+function createUseApiClient(useOrganizations, apiUrl) {
+  return function useApiClient() {
+    const { getAccessToken, organizationId, isOrganizationReady, onError } = useApiClientContext();
+    const { isInitializing, isOrgRefreshing } = useOrganizations();
+    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(
+      async (endpoint, options = {}) => {
+        try {
+          const token = await getAccessToken();
+          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);
+          }
+          if (response.status === 204) {
+            return void 0;
+          }
+          const responseData = await response.json();
+          return responseData;
+        } catch (error) {
+          if (error instanceof Error && error.message.includes("No access token")) {
+            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 void 0;
+            }
+            return response.json();
+          }
+          throw error;
+        }
+      },
+      [getAccessToken, organizationId, handleResponseError, apiUrl]
+    );
+    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
+    };
+  };
+}
+
+export { ApiClientProvider, createUseApiClient, useApiClientContext };

package/dist/chunk-GEFB5YIR.js

@@ -0,0 +1,338 @@
+import { useUserProfile } from './chunk-5UWFGBFM.js';
+import { useAuthContext } from './chunk-7PLEQFHO.js';
+import { useState, useRef, useEffect, useCallback } from 'react';
+import { Button, Loader, Menu, Text, Badge } from '@mantine/core';
+import { IconChevronDown, IconBuilding, IconCheck } from '@tabler/icons-react';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+
+// src/organization/store/organizationsSlice.ts
+var initialOrganizationsState = {
+  currentWorkOSOrganizationId: null,
+  currentSupabaseOrganizationId: null,
+  currentMembership: null,
+  isInitializing: true,
+  // Start as initializing
+  isOrgRefreshing: false,
+  error: null
+};
+var createOrganizationsSlice = (set, _get, _store) => ({
+  // Organizations state
+  organizations: initialOrganizationsState,
+  // Organization actions
+  setCurrentWorkOSOrganizationId: (workOSorgId) => {
+    set(
+      (state) => {
+        state.organizations.currentWorkOSOrganizationId = workOSorgId;
+      },
+      void 0,
+      "organizations/setCurrentWorkOSOrganizationId"
+    );
+  },
+  setCurrentMembership: (membership) => {
+    set(
+      (state) => {
+        state.organizations.currentMembership = membership;
+        state.organizations.currentSupabaseOrganizationId = membership?.organization?.id || null;
+      },
+      void 0,
+      "organizations/setCurrentMembership"
+    );
+  },
+  setOrganizationsInitializing: (initializing) => set(
+    (state) => {
+      state.organizations.isInitializing = initializing;
+    },
+    void 0,
+    "organizations/setInitializing"
+  ),
+  setOrganizationsLoading: (loading) => set(
+    (state) => {
+      state.organizations.isOrgRefreshing = loading;
+    },
+    void 0,
+    "organizations/setLoading"
+  ),
+  setOrganizationsError: (error) => set(
+    (state) => {
+      state.organizations.error = error;
+    },
+    void 0,
+    "organizations/setError"
+  )
+});
+
+// src/organization/hooks/useOrganizations.ts
+function createUseOrganizations(useStore) {
+  return () => {
+    const organizations = useStore((state) => state.organizations);
+    const setCurrentWorkOSOrganizationId = useStore((state) => state.setCurrentWorkOSOrganizationId);
+    const setCurrentMembership = useStore((state) => state.setCurrentMembership);
+    const setOrganizationsInitializing = useStore((state) => state.setOrganizationsInitializing);
+    const setOrganizationsLoading = useStore((state) => state.setOrganizationsLoading);
+    const setOrganizationsError = useStore((state) => state.setOrganizationsError);
+    return {
+      ...organizations,
+      setCurrentWorkOSOrganizationId,
+      setCurrentMembership,
+      setOrganizationsInitializing,
+      setOrganizationsLoading,
+      setOrganizationsError,
+      organizations
+      // Also return the full organizations object for easy access
+    };
+  };
+}
+function createUseOrgInitialization(useOrganizations, useApiClient) {
+  return function useOrgInitialization() {
+    const { user, organizationId: workosOrgId } = useAuthContext();
+    const { apiRequest } = useApiClient();
+    const { profile } = useUserProfile();
+    const {
+      currentWorkOSOrganizationId,
+      currentMembership,
+      setCurrentWorkOSOrganizationId,
+      setCurrentMembership,
+      setOrganizationsInitializing,
+      setOrganizationsLoading,
+      setOrganizationsError,
+      organizations
+    } = useOrganizations();
+    const [memberships, setMemberships] = useState([]);
+    const [profileLoaded, setProfileLoaded] = useState(false);
+    const hasInitializedRef = useRef(false);
+    const currentMembershipIdRef = useRef(null);
+    currentMembershipIdRef.current = currentMembership?.id ?? null;
+    useEffect(() => {
+      if (profile !== void 0 && profile !== null) {
+        setProfileLoaded(true);
+      }
+    }, [profile]);
+    const selectOrganization = useCallback(
+      async (data) => {
+        let selectedMembership = null;
+        if (profile?.last_visited_org) {
+          const supabaseLastVisitedOrgId = profile.last_visited_org;
+          selectedMembership = data.find((m) => m.organizationId === supabaseLastVisitedOrgId) || null;
+        }
+        if (!selectedMembership && workosOrgId) {
+          selectedMembership = data.find((m) => m.organization?.workos_org_id === workosOrgId) || null;
+        }
+        if (!selectedMembership && data.length > 0) {
+          selectedMembership = data[0];
+        }
+        if (selectedMembership) {
+          const workosSelectedOrgId = selectedMembership.organization?.workos_org_id;
+          if (workosSelectedOrgId) {
+            setCurrentWorkOSOrganizationId(workosSelectedOrgId);
+            setCurrentMembership(selectedMembership);
+          }
+        }
+      },
+      [profile?.last_visited_org, workosOrgId, setCurrentWorkOSOrganizationId, setCurrentMembership]
+    );
+    const validateCurrentOrganization = useCallback(
+      (data) => {
+        const workosCurrentOrgId = currentWorkOSOrganizationId;
+        const currentOrg = data.find((m) => m.organization?.workos_org_id === workosCurrentOrgId);
+        if (!currentOrg) {
+          setCurrentWorkOSOrganizationId(null);
+          setCurrentMembership(null);
+          if (data.length > 0) {
+            const fallbackOrg = data[0];
+            const workosFallbackOrgId = fallbackOrg.organization?.workos_org_id;
+            if (workosFallbackOrgId) {
+              setCurrentWorkOSOrganizationId(workosFallbackOrgId);
+              setCurrentMembership(fallbackOrg);
+            }
+          }
+        } else {
+          if (currentOrg.id !== currentMembershipIdRef.current) {
+            setCurrentMembership(currentOrg);
+          }
+        }
+      },
+      [currentWorkOSOrganizationId, setCurrentWorkOSOrganizationId, setCurrentMembership]
+    );
+    useEffect(() => {
+      const initializeOrganizations = async () => {
+        if (!user?.id || !profileLoaded) {
+          return;
+        }
+        if (hasInitializedRef.current) {
+          return;
+        }
+        if (memberships.length === 0) {
+          setOrganizationsInitializing(true);
+        } else {
+          setOrganizationsLoading(true);
+        }
+        setOrganizationsError(null);
+        try {
+          const data = await apiRequest("/memberships/my-memberships");
+          if (!Array.isArray(data)) {
+            throw new Error("Invalid memberships response");
+          }
+          setMemberships(data);
+          if (data.length === 0) {
+            setOrganizationsError("No organization memberships found. Please contact your administrator or try refreshing the page.");
+            hasInitializedRef.current = true;
+            return;
+          }
+          if (!currentWorkOSOrganizationId && data.length > 0) {
+            await selectOrganization(data);
+          } else if (currentWorkOSOrganizationId) {
+            validateCurrentOrganization(data);
+          }
+          hasInitializedRef.current = true;
+        } catch (error) {
+          setOrganizationsError(error instanceof Error ? error.message : "Failed to load organizations");
+        } finally {
+          setOrganizationsInitializing(false);
+          setOrganizationsLoading(false);
+        }
+      };
+      initializeOrganizations();
+    }, [
+      user?.id,
+      profileLoaded,
+      profile?.last_visited_org,
+      currentWorkOSOrganizationId,
+      apiRequest,
+      setOrganizationsInitializing,
+      setOrganizationsLoading,
+      setOrganizationsError,
+      selectOrganization,
+      validateCurrentOrganization
+      // REMOVED: memberships.length - causes feedback loop (memberships change as RESULT of effect, not INPUT)
+    ]);
+    const retryInitialization = useCallback(async () => {
+      hasInitializedRef.current = false;
+      setOrganizationsError(null);
+      setOrganizationsInitializing(true);
+      try {
+        const data = await apiRequest("/memberships/my-memberships");
+        if (!Array.isArray(data)) {
+          throw new Error("Invalid memberships response");
+        }
+        setMemberships(data);
+        if (!currentWorkOSOrganizationId && data.length > 0) {
+          await selectOrganization(data);
+        } else if (currentWorkOSOrganizationId) {
+          validateCurrentOrganization(data);
+        }
+        hasInitializedRef.current = true;
+      } catch (error) {
+        setOrganizationsError(error instanceof Error ? error.message : "Failed to load organizations");
+      } finally {
+        setOrganizationsInitializing(false);
+      }
+    }, [
+      apiRequest,
+      currentWorkOSOrganizationId,
+      setOrganizationsError,
+      setOrganizationsInitializing,
+      selectOrganization,
+      validateCurrentOrganization
+    ]);
+    return {
+      memberships,
+      isInitializing: organizations.isInitializing,
+      isLoading: organizations.isOrgRefreshing,
+      isInitialized: hasInitializedRef.current && !organizations.isInitializing && !organizations.isOrgRefreshing,
+      error: organizations.error,
+      currentOrganization: currentMembership?.organization || null,
+      retry: retryInitialization
+    };
+  };
+}
+function OrganizationSwitcher({
+  currentOrganization,
+  memberships,
+  isLoading,
+  onSwitch
+}) {
+  const [opened, setOpened] = useState(false);
+  const [switching, setSwitching] = useState(false);
+  const otherMemberships = memberships.filter((m) => m.organizationId !== currentOrganization?.id);
+  const handleSwitch = async (workosOrgId) => {
+    setSwitching(true);
+    try {
+      await onSwitch(workosOrgId);
+      setOpened(false);
+    } catch (error) {
+      console.error("Failed to switch organization:", error);
+    } finally {
+      setSwitching(false);
+    }
+  };
+  if (isLoading) {
+    return /* @__PURE__ */ jsx(Button, { variant: "light", size: "xs", disabled: true, children: /* @__PURE__ */ jsx(Loader, { size: 14 }) });
+  }
+  if (memberships.length === 0) {
+    return /* @__PURE__ */ jsx(Button, { variant: "light", size: "xs", disabled: true, children: "None" });
+  }
+  return /* @__PURE__ */ jsxs(Menu, { opened, onChange: setOpened, position: "bottom-start", withinPortal: true, children: [
+    /* @__PURE__ */ jsx(Menu.Target, { children: /* @__PURE__ */ jsx(
+      Button,
+      {
+        variant: "light",
+        size: "xs",
+        leftSection: /* @__PURE__ */ jsx(IconBuilding, { size: 16 }),
+        rightSection: /* @__PURE__ */ jsx(IconChevronDown, { size: 14 }),
+        loading: switching,
+        children: /* @__PURE__ */ jsx(Text, { truncate: true, style: { maxWidth: 200 }, size: "xs", children: currentOrganization?.name || "Select Organization" })
+      }
+    ) }),
+    /* @__PURE__ */ jsxs(Menu.Dropdown, { children: [
+      currentOrganization && /* @__PURE__ */ jsxs(Fragment, { children: [
+        /* @__PURE__ */ jsx(Menu.Label, { children: "Current Organization" }),
+        /* @__PURE__ */ jsx(Menu.Item, { disabled: true, rightSection: /* @__PURE__ */ jsx(IconCheck, { size: 14 }), leftSection: /* @__PURE__ */ jsx(IconBuilding, { size: 14 }), children: currentOrganization.name }),
+        otherMemberships.length > 0 && /* @__PURE__ */ jsxs(Fragment, { children: [
+          /* @__PURE__ */ jsx(Menu.Divider, {}),
+          /* @__PURE__ */ jsx(Menu.Label, { children: "Switch Organization" })
+        ] })
+      ] }),
+      otherMemberships.length > 0 && /* @__PURE__ */ jsx("div", { children: otherMemberships.map((membership, index) => /* @__PURE__ */ jsx(
+        Menu.Item,
+        {
+          leftSection: /* @__PURE__ */ jsx(IconBuilding, { size: 14 }),
+          rightSection: /* @__PURE__ */ jsx(Badge, { size: "xs", variant: "light", children: membership.role.slug }),
+          onClick: () => {
+            const workosOrgId = membership.organization?.workos_org_id;
+            if (!workosOrgId) {
+              console.error("Organization missing WorkOS ID:", membership.organization?.name);
+              return;
+            }
+            handleSwitch(workosOrgId);
+          },
+          disabled: switching,
+          children: membership.organization?.name || "Unknown Organization"
+        },
+        `${membership.organizationId}-${index}`
+      )) }, "other-memberships"),
+      !currentOrganization && memberships.length > 0 && /* @__PURE__ */ jsxs(Fragment, { children: [
+        /* @__PURE__ */ jsx(Menu.Label, { children: "Select Organization" }),
+        memberships.map((membership) => /* @__PURE__ */ jsx(
+          Menu.Item,
+          {
+            leftSection: /* @__PURE__ */ jsx(IconBuilding, { size: 14 }),
+            rightSection: /* @__PURE__ */ jsx(Badge, { size: "xs", variant: "light", children: membership.role.slug }),
+            onClick: () => {
+              const workosOrgId = membership.organization?.workos_org_id;
+              if (!workosOrgId) {
+                console.error("Organization missing WorkOS ID:", membership.organization?.name);
+                return;
+              }
+              handleSwitch(workosOrgId);
+            },
+            disabled: switching,
+            children: membership.organization?.name || "Unknown Organization"
+          },
+          membership.organizationId
+        ))
+      ] })
+    ] })
+  ] });
+}
+
+export { OrganizationSwitcher, createOrganizationsSlice, createUseOrgInitialization, createUseOrganizations };

package/dist/chunk-HBRMWW6V.js

@@ -0,0 +1,43 @@
+import { useAuthContext } from './chunk-7PLEQFHO.js';
+import { useRef, useCallback, useEffect } from 'react';
+import { useQueryClient } from '@tanstack/react-query';
+
+function useStableAccessToken() {
+  const { getAccessToken } = useAuthContext();
+  const getAccessTokenRef = useRef(getAccessToken);
+  getAccessTokenRef.current = getAccessToken;
+  return useCallback(() => {
+    return getAccessTokenRef.current();
+  }, []);
+}
+function useSessionCheck() {
+  const { user } = useAuthContext();
+  const queryClient = useQueryClient();
+  const isCheckingRef = useRef(false);
+  useEffect(() => {
+    const handleVisibilityChange = async () => {
+      if (isCheckingRef.current || document.visibilityState !== "visible") {
+        return;
+      }
+      isCheckingRef.current = true;
+      try {
+        if (!user) {
+          window.location.replace("/login");
+          return;
+        }
+        await queryClient.cancelQueries();
+        queryClient.invalidateQueries();
+      } finally {
+        isCheckingRef.current = false;
+      }
+    };
+    document.addEventListener("visibilitychange", handleVisibilityChange);
+    window.addEventListener("focus", handleVisibilityChange);
+    return () => {
+      document.removeEventListener("visibilitychange", handleVisibilityChange);
+      window.removeEventListener("focus", handleVisibilityChange);
+    };
+  }, [user, queryClient]);
+}
+
+export { useSessionCheck, useStableAccessToken };