@axcode/axcloud-sdk 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1246 @@
+import { createContext, useContext, useMemo, useCallback, useRef } from 'react';
+import { Auth0Provider, useAuth0 } from '@auth0/auth0-react';
+import { QueryClient, QueryClientProvider, useQuery, useQueryClient, useMutation } from '@tanstack/react-query';
+import { jsx, Fragment, jsxs } from 'react/jsx-runtime';
+
+// src/core/errors.ts
+var AxCloudError = class _AxCloudError extends Error {
+  constructor(message, code, status, details) {
+    super(message);
+    this.name = "AxCloudError";
+    this.code = code;
+    this.status = status;
+    this.details = details;
+    const ErrorWithCapture = Error;
+    if (ErrorWithCapture.captureStackTrace) {
+      ErrorWithCapture.captureStackTrace(this, _AxCloudError);
+    }
+  }
+  static fromResponse(status, body) {
+    const details = typeof body === "object" ? body : void 0;
+    const message = details?.message;
+    switch (status) {
+      case 401:
+        return new _AxCloudError(
+          message || "Authentication required",
+          "UNAUTHORIZED",
+          status,
+          details
+        );
+      case 403:
+        return new _AxCloudError(
+          message || "Access denied",
+          "FORBIDDEN",
+          status,
+          details
+        );
+      case 404:
+        return new _AxCloudError(
+          message || "Resource not found",
+          "NOT_FOUND",
+          status,
+          details
+        );
+      case 422:
+        return new _AxCloudError(
+          message || "Validation failed",
+          "VALIDATION_ERROR",
+          status,
+          details
+        );
+      default:
+        if (status >= 500) {
+          return new _AxCloudError(
+            message || "Server error",
+            "SERVER_ERROR",
+            status,
+            details
+          );
+        }
+        return new _AxCloudError(
+          message || "An error occurred",
+          "UNKNOWN_ERROR",
+          status,
+          details
+        );
+    }
+  }
+  static networkError(originalError) {
+    const isDev = typeof process !== "undefined" && process.env?.NODE_ENV === "development";
+    const message = isDev && originalError?.message ? originalError.message : "Network request failed";
+    return new _AxCloudError(
+      message,
+      "NETWORK_ERROR",
+      0,
+      isDev ? { originalError: originalError?.message } : void 0
+    );
+  }
+  static timeoutError(timeoutMs) {
+    return new _AxCloudError(
+      `Request timed out after ${timeoutMs}ms`,
+      "TIMEOUT_ERROR",
+      0,
+      { timeout: timeoutMs }
+    );
+  }
+};
+function isAxCloudError(error) {
+  return error instanceof AxCloudError;
+}
+
+// src/core/client.ts
+var AxCloudClient = class {
+  constructor(config) {
+    this.baseUrl = config.baseUrl.replace(/\/$/, "");
+    this.getAccessToken = config.getAccessToken;
+    this.apiKey = config.apiKey;
+    this.defaultTimeout = config.timeout ?? 3e4;
+  }
+  /**
+   * Update the access token getter (used when auth state changes)
+   */
+  setAccessTokenGetter(getter) {
+    this.getAccessToken = getter;
+  }
+  /**
+   * Build URL with query parameters
+   */
+  buildUrl(path, params) {
+    const url = new URL(`${this.baseUrl}${path}`);
+    if (params) {
+      Object.entries(params).forEach(([key, value]) => {
+        if (value !== void 0) {
+          url.searchParams.append(key, String(value));
+        }
+      });
+    }
+    return url.toString();
+  }
+  /**
+   * Make an authenticated request
+   */
+  async request(path, options = {}) {
+    const { body, params, headers: customHeaders, timeout, ...restOptions } = options;
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (customHeaders) {
+      const customHeadersRecord = customHeaders;
+      Object.assign(headers, customHeadersRecord);
+    }
+    if (this.apiKey) {
+      headers["x-api-key"] = this.apiKey;
+    }
+    if (this.getAccessToken) {
+      try {
+        const token = await this.getAccessToken();
+        if (token) {
+          headers["Authorization"] = `Bearer ${token}`;
+        }
+      } catch (error) {
+        if (typeof process !== "undefined" && process.env?.NODE_ENV === "development") {
+          console.warn(
+            "[AxCloud SDK] Failed to fetch access token:",
+            error instanceof Error ? error.message : error
+          );
+        }
+      }
+    }
+    const url = this.buildUrl(path, params);
+    const controller = new AbortController();
+    const requestTimeout = timeout ?? this.defaultTimeout;
+    const timeoutId = setTimeout(() => controller.abort(), requestTimeout);
+    try {
+      const response = await fetch(url, {
+        ...restOptions,
+        headers,
+        body: body ? JSON.stringify(body) : void 0,
+        signal: controller.signal
+      });
+      const contentType = response.headers.get("content-type");
+      const isJson = contentType?.includes("application/json");
+      if (!response.ok) {
+        const errorBody = isJson ? await response.json().catch(() => null) : null;
+        throw AxCloudError.fromResponse(response.status, errorBody);
+      }
+      if (response.status === 204) {
+        return {};
+      }
+      return isJson ? await response.json() : {};
+    } catch (error) {
+      if (error instanceof AxCloudError) {
+        throw error;
+      }
+      if (error instanceof Error && error.name === "AbortError") {
+        throw AxCloudError.timeoutError(requestTimeout);
+      }
+      throw AxCloudError.networkError(error instanceof Error ? error : void 0);
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  /**
+   * GET request
+   */
+  get(path, params) {
+    return this.request(path, { method: "GET", params });
+  }
+  /**
+   * POST request
+   */
+  post(path, body) {
+    return this.request(path, { method: "POST", body });
+  }
+  /**
+   * PUT request
+   */
+  put(path, body) {
+    return this.request(path, { method: "PUT", body });
+  }
+  /**
+   * PATCH request
+   */
+  patch(path, body) {
+    return this.request(path, { method: "PATCH", body });
+  }
+  /**
+   * DELETE request
+   */
+  delete(path) {
+    return this.request(path, { method: "DELETE" });
+  }
+};
+var clientRegistry = /* @__PURE__ */ new WeakMap();
+function createClient(config, key) {
+  const client = new AxCloudClient(config);
+  if (key) {
+    clientRegistry.set(key, client);
+  }
+  return client;
+}
+function getClient(key) {
+  if (key) {
+    const client = clientRegistry.get(key);
+    if (client) {
+      return client;
+    }
+  }
+  throw new Error("AxCloud client not found. Make sure AxCloudProvider is mounted and use useAxCloudContext() to get the client.");
+}
+
+// src/core/types.ts
+function userHasPermission(user, permission) {
+  if (user.permissions && user.permissions.length > 0) {
+    return user.permissions.includes(permission);
+  }
+  if (user.customRole?.effectivePermissions) {
+    return user.customRole.effectivePermissions.includes(permission);
+  }
+  return false;
+}
+function userHasAnyPermission(user, permissions) {
+  return permissions.some((p) => userHasPermission(user, p));
+}
+function userHasAllPermissions(user, permissions) {
+  return permissions.every((p) => userHasPermission(user, p));
+}
+
+// src/core/forms.ts
+async function submitForm(apiUrl, submission) {
+  const url = `${apiUrl.replace(/\/$/, "")}/public/submit`;
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      api_key: submission.apiKey,
+      site: submission.site,
+      form_type: submission.formType,
+      email: submission.email,
+      data: submission.data || {}
+    })
+  });
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({ message: "Form submission failed" }));
+    throw new Error(error.message || "Form submission failed");
+  }
+  const result = await response.json();
+  return {
+    success: result.success,
+    message: result.message,
+    submissionId: result.submission_id
+  };
+}
+function createFormHelper(config) {
+  return {
+    /**
+     * Submit a waitlist form
+     */
+    submitWaitlist: (email, data) => submitForm(config.apiUrl, {
+      apiKey: config.apiKey,
+      site: config.site,
+      formType: "waitlist",
+      email,
+      data
+    }),
+    /**
+     * Submit a contact form
+     */
+    submitContact: (email, data) => submitForm(config.apiUrl, {
+      apiKey: config.apiKey,
+      site: config.site,
+      formType: "contact",
+      email,
+      data
+    }),
+    /**
+     * Submit a membership application
+     */
+    submitMembership: (email, data) => submitForm(config.apiUrl, {
+      apiKey: config.apiKey,
+      site: config.site,
+      formType: "membership",
+      email,
+      data
+    }),
+    /**
+     * Generic submit function
+     */
+    submit: (formType, email, data) => submitForm(config.apiUrl, {
+      apiKey: config.apiKey,
+      site: config.site,
+      formType,
+      email,
+      data
+    })
+  };
+}
+var AxCloudContext = createContext(null);
+function useAxCloudContext() {
+  const context = useContext(AxCloudContext);
+  if (!context) {
+    throw new Error("useAxCloudContext must be used within a AxCloudProvider");
+  }
+  return context;
+}
+var defaultQueryClient = new QueryClient({
+  defaultOptions: {
+    queries: {
+      staleTime: 1e3 * 60 * 5,
+      // 5 minutes
+      gcTime: 1e3 * 60 * 30,
+      // 30 minutes (garbage collection)
+      retry: 2,
+      refetchOnWindowFocus: false
+    }
+  }
+});
+function AxCloudInnerProvider({
+  children,
+  config,
+  timeout
+}) {
+  const { getAccessTokenSilently, isAuthenticated } = useAuth0();
+  const tokenGetterRef = useRef(async () => void 0);
+  tokenGetterRef.current = isAuthenticated ? async () => {
+    try {
+      return await getAccessTokenSilently();
+    } catch {
+      return void 0;
+    }
+  } : async () => void 0;
+  const client = useMemo(() => {
+    return new AxCloudClient({
+      baseUrl: config.apiUrl,
+      apiKey: config.apiKey,
+      timeout,
+      // Use a wrapper function that delegates to the ref
+      // This ensures the client always uses the current auth state
+      getAccessToken: async () => {
+        if (tokenGetterRef.current) {
+          return tokenGetterRef.current();
+        }
+        return void 0;
+      }
+    });
+  }, [config.apiUrl, config.apiKey, timeout]);
+  const contextValue = useMemo(
+    () => ({
+      config,
+      client,
+      orgId: config.orgId,
+      stage: config.stage,
+      isPublicMode: Boolean(config.apiKey) && !isAuthenticated
+    }),
+    [config, client, isAuthenticated]
+  );
+  return /* @__PURE__ */ jsx(AxCloudContext.Provider, { value: contextValue, children });
+}
+function AxCloudProvider({
+  children,
+  orgId,
+  apiUrl,
+  stage = "dev",
+  apiKey,
+  auth0,
+  queryClient = defaultQueryClient,
+  timeout
+}) {
+  const config = useMemo(
+    () => ({
+      orgId,
+      apiUrl,
+      stage,
+      apiKey,
+      auth0
+    }),
+    [orgId, apiUrl, stage, apiKey, auth0]
+  );
+  return /* @__PURE__ */ jsx(QueryClientProvider, { client: queryClient, children: /* @__PURE__ */ jsx(
+    Auth0Provider,
+    {
+      domain: auth0.domain,
+      clientId: auth0.clientId,
+      authorizationParams: {
+        redirect_uri: auth0.redirectUri,
+        audience: auth0.audience
+      },
+      children: /* @__PURE__ */ jsx(AxCloudInnerProvider, { config, timeout, children })
+    }
+  ) });
+}
+function useAuth() {
+  const { config } = useAxCloudContext();
+  const {
+    isAuthenticated,
+    isLoading,
+    user: auth0User,
+    error,
+    loginWithRedirect,
+    logout: auth0Logout,
+    getAccessTokenSilently,
+    getIdTokenClaims
+  } = useAuth0();
+  const login = useCallback(
+    (options) => {
+      return loginWithRedirect({
+        appState: {
+          returnTo: options?.returnTo || window.location.pathname
+        }
+      });
+    },
+    [loginWithRedirect]
+  );
+  const logout = useCallback(
+    (options) => {
+      return auth0Logout({
+        logoutParams: {
+          returnTo: options?.returnTo || window.location.origin
+        }
+      });
+    },
+    [auth0Logout]
+  );
+  const getAccessToken = useCallback(async () => {
+    try {
+      return await getAccessTokenSilently();
+    } catch {
+      return void 0;
+    }
+  }, [getAccessTokenSilently]);
+  const getAuth0Client = useCallback(() => {
+    return {
+      loginWithRedirect,
+      logout: auth0Logout,
+      getAccessTokenSilently,
+      getIdTokenClaims,
+      user: auth0User,
+      isAuthenticated,
+      isLoading,
+      error
+    };
+  }, [
+    loginWithRedirect,
+    auth0Logout,
+    getAccessTokenSilently,
+    getIdTokenClaims,
+    auth0User,
+    isAuthenticated,
+    isLoading,
+    error
+  ]);
+  const requestPasswordReset = useCallback(
+    async (email) => {
+      const targetEmail = email || auth0User?.email;
+      if (!targetEmail) {
+        return {
+          success: false,
+          message: "Email address is required"
+        };
+      }
+      try {
+        const auth0Domain = config.auth0.domain;
+        const clientId = config.auth0.clientId;
+        const connection = config.auth0.connection || "Username-Password-Authentication";
+        const response = await fetch(`https://${auth0Domain}/dbconnections/change_password`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            client_id: clientId,
+            email: targetEmail.toLowerCase(),
+            connection
+          })
+        });
+        if (response.ok) {
+          return {
+            success: true,
+            message: "If an account exists with this email, a password reset link has been sent."
+          };
+        }
+        return {
+          success: true,
+          message: "If an account exists with this email, a password reset link has been sent."
+        };
+      } catch {
+        return {
+          success: false,
+          message: "Failed to send password reset email. Please try again."
+        };
+      }
+    },
+    [auth0User?.email, config.auth0.domain, config.auth0.clientId]
+  );
+  return {
+    // Simple, abstracted API
+    isAuthenticated,
+    isLoading,
+    error,
+    user: auth0User ? {
+      id: auth0User.sub || "",
+      email: auth0User.email || "",
+      name: auth0User.name || "",
+      avatar: auth0User.picture
+    } : null,
+    login,
+    logout,
+    // Escape hatch for advanced use cases
+    getAccessToken,
+    getAuth0Client,
+    // Password management
+    requestPasswordReset
+  };
+}
+function useUser() {
+  const { isAuthenticated, isLoading: isAuthLoading } = useAuth0();
+  const { client, stage, orgId } = useAxCloudContext();
+  const query = useQuery({
+    queryKey: ["axcloud", "user", "me", stage],
+    queryFn: async () => {
+      return client.get(`/${stage}/api/users/me`);
+    },
+    enabled: isAuthenticated && !isAuthLoading,
+    staleTime: 1e3 * 60 * 5
+    // 5 minutes
+  });
+  const userData = query.data;
+  const userOrgIds = userData?.all_org_ids ?? [];
+  const isSuperAdmin = userData?.isSuperAdmin === true;
+  const hasOrgAccess = isSuperAdmin || userOrgIds.includes(orgId);
+  const orgMembership = userData?.organization_memberships?.[orgId];
+  const roleInOrg = orgMembership?.role ?? null;
+  return {
+    user: query.data ?? null,
+    isLoading: isAuthLoading || query.isLoading,
+    isError: query.isError,
+    error: query.error,
+    refetch: query.refetch,
+    // Organization access
+    hasOrgAccess,
+    roleInOrg,
+    // Convenience properties
+    isAuthenticated,
+    role: query.data?.role ?? null,
+    organizationId: query.data?.organizationId ?? null,
+    sectionId: query.data?.sectionId ?? null,
+    permissions: query.data?.permissions ?? [],
+    isSuperAdmin
+  };
+}
+function useOrg() {
+  const { client, orgId, stage, config } = useAxCloudContext();
+  const usePublicEndpoint = Boolean(config.apiKey);
+  const query = useQuery({
+    queryKey: ["axcloud", "organization", orgId, stage, usePublicEndpoint],
+    queryFn: async () => {
+      if (usePublicEndpoint) {
+        return client.get(`/content/public/${orgId}/org`);
+      } else {
+        return client.get(`/${stage}/api/organizations/${orgId}`);
+      }
+    },
+    staleTime: 1e3 * 60 * 10
+    // 10 minutes (org data rarely changes)
+  });
+  const orgData = query.data;
+  const normalizedOrg = orgData ? {
+    id: orgData.id || orgData.org_id,
+    org_id: orgData.org_id || orgData.id,
+    name: orgData.name,
+    description: orgData.description,
+    branding: orgData.branding || orgData.settings?.theme,
+    modules: orgData.modules || [],
+    contact: orgData.contact,
+    social: orgData.social
+  } : null;
+  const hasModule = useCallback(
+    (module) => {
+      const mods = normalizedOrg?.modules || [];
+      return mods.includes(module);
+    },
+    [normalizedOrg?.modules]
+  );
+  const modules = normalizedOrg?.modules ?? [];
+  return {
+    org: normalizedOrg,
+    orgId,
+    isLoading: query.isLoading,
+    isError: query.isError,
+    error: query.error,
+    refetch: query.refetch,
+    // Module helpers
+    hasModule,
+    modules
+  };
+}
+function useNews(options = {}) {
+  const { client, orgId, isPublicMode } = useAxCloudContext();
+  const {
+    page = 1,
+    pageSize = 20,
+    status = "published",
+    visibility,
+    sectionId,
+    search,
+    sortBy = "publishedAt",
+    sortOrder = "desc",
+    publicOnly = false
+  } = options;
+  const usePublicEndpoint = isPublicMode || publicOnly;
+  const query = useQuery({
+    queryKey: ["axcloud", "news", orgId, usePublicEndpoint, options],
+    queryFn: async () => {
+      const endpoint = usePublicEndpoint ? `/content/public/${orgId}/news` : `/content/members/${orgId}/news`;
+      return client.get(endpoint, {
+        page,
+        pageSize,
+        status,
+        visibility,
+        sectionId,
+        search,
+        sortBy,
+        sortOrder
+      });
+    },
+    staleTime: 1e3 * 60 * 5
+    // 5 minutes
+  });
+  return {
+    data: query.data?.items ?? [],
+    total: query.data?.total ?? 0,
+    hasMore: query.data?.hasMore ?? false,
+    isLoading: query.isLoading,
+    isError: query.isError,
+    error: query.error,
+    refetch: query.refetch
+  };
+}
+var MEMBER_ENDPOINT_TYPES = ["news", "pages", "events"];
+function useContent(contentType, options = {}) {
+  const { client, orgId, isPublicMode } = useAxCloudContext();
+  const {
+    page = 1,
+    pageSize = 20,
+    status = "published",
+    visibility,
+    sectionId,
+    search,
+    sortBy = "createdAt",
+    sortOrder = "desc"
+  } = options;
+  const query = useQuery({
+    queryKey: ["axcloud", "content", orgId, contentType, isPublicMode, options],
+    queryFn: async () => {
+      const useMemberEndpoint = !isPublicMode && MEMBER_ENDPOINT_TYPES.includes(contentType);
+      const endpoint = useMemberEndpoint ? `/content/members/${orgId}/${contentType}` : `/content/public/${orgId}/${contentType}`;
+      return client.get(endpoint, {
+        page,
+        pageSize,
+        status,
+        visibility,
+        sectionId,
+        search,
+        sortBy,
+        sortOrder
+      });
+    },
+    staleTime: 1e3 * 60 * 5
+    // 5 minutes
+  });
+  return {
+    data: query.data?.items ?? [],
+    total: query.data?.total ?? 0,
+    hasMore: query.data?.hasMore ?? false,
+    isLoading: query.isLoading,
+    isError: query.isError,
+    error: query.error,
+    refetch: query.refetch
+  };
+}
+function useContentItem(contentType, idOrSlug, options = {}) {
+  const { client, orgId, isPublicMode } = useAxCloudContext();
+  const { publicOnly = false } = options;
+  const useMemberEndpoint = !isPublicMode && !publicOnly && MEMBER_ENDPOINT_TYPES.includes(contentType);
+  const query = useQuery({
+    queryKey: ["axcloud", "content", orgId, contentType, idOrSlug, useMemberEndpoint],
+    queryFn: async () => {
+      const basePath = useMemberEndpoint ? "members" : "public";
+      return client.get(`/content/${basePath}/${orgId}/${contentType}/${idOrSlug}`);
+    },
+    enabled: !!idOrSlug,
+    staleTime: 1e3 * 60 * 5
+    // 5 minutes
+  });
+  return {
+    data: query.data ?? null,
+    isLoading: query.isLoading,
+    isError: query.isError,
+    error: query.error,
+    refetch: query.refetch
+  };
+}
+function useMySection(options = {}) {
+  const { includeMembers = true } = options;
+  const { isAuthenticated } = useAuth0();
+  const { client, orgId, stage } = useAxCloudContext();
+  const { user, sectionId, isLoading: isUserLoading } = useUser();
+  const query = useQuery({
+    queryKey: ["axcloud", "mySection", orgId, sectionId, includeMembers, stage],
+    queryFn: async () => {
+      if (!sectionId) {
+        throw new Error("User is not assigned to a section");
+      }
+      const section = await client.get(
+        `/${stage}/api/sections/${sectionId}`,
+        { includeMembers: includeMembers ? "true" : void 0 }
+      );
+      return section;
+    },
+    enabled: isAuthenticated && !isUserLoading && !!sectionId,
+    staleTime: 1e3 * 60 * 5
+    // 5 minutes
+  });
+  return {
+    section: query.data ?? null,
+    sectionId,
+    members: query.data?.members ?? [],
+    memberCount: query.data?.memberCount ?? 0,
+    isLoading: isUserLoading || query.isLoading,
+    isError: query.isError,
+    error: query.error,
+    refetch: query.refetch,
+    // Helper: Does the user have a section?
+    hasSection: !!sectionId,
+    // The current user in context
+    user
+  };
+}
+function useSections() {
+  const { client, orgId, stage } = useAxCloudContext();
+  const query = useQuery({
+    queryKey: ["axcloud", "sections", orgId, stage],
+    queryFn: async () => {
+      return client.get(`/${stage}/api/organizations/${orgId}/sections`);
+    },
+    staleTime: 1e3 * 60 * 10
+    // 10 minutes
+  });
+  return {
+    sections: query.data ?? [],
+    isLoading: query.isLoading,
+    isError: query.isError,
+    error: query.error,
+    refetch: query.refetch
+  };
+}
+function useForms(options = {}) {
+  const { client, stage } = useAxCloudContext();
+  const { formType, status, limit = 50, cursor } = options;
+  const query = useQuery({
+    queryKey: ["axcloud", "forms", "submissions", stage, options],
+    queryFn: async () => {
+      const params = { limit };
+      if (formType) params.form_type = formType;
+      if (status) params.status = status;
+      if (cursor) params.cursor = cursor;
+      return client.get(`/${stage}/api/admin/forms/submissions`, params);
+    },
+    staleTime: 1e3 * 30
+    // 30 seconds
+  });
+  return {
+    data: query.data?.items ?? [],
+    total: query.data?.total ?? 0,
+    hasMore: query.data?.hasMore ?? false,
+    cursor: query.data?.cursor,
+    isLoading: query.isLoading,
+    isError: query.isError,
+    error: query.error,
+    refetch: query.refetch
+  };
+}
+function useFormStats(options = {}) {
+  const { client, stage } = useAxCloudContext();
+  const { days = 30 } = options;
+  const query = useQuery({
+    queryKey: ["axcloud", "forms", "stats", stage, days],
+    queryFn: async () => {
+      return client.get(`/${stage}/api/admin/forms/stats`, { days });
+    },
+    staleTime: 1e3 * 60 * 5
+    // 5 minutes
+  });
+  return {
+    stats: query.data?.stats,
+    summary: query.data?.summary,
+    period: query.data?.period,
+    isLoading: query.isLoading,
+    isError: query.isError,
+    error: query.error,
+    refetch: query.refetch
+  };
+}
+function useUpdateFormSubmission() {
+  const { client, stage } = useAxCloudContext();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async ({
+      submissionId,
+      status,
+      notes
+    }) => {
+      return client.patch(`/${stage}/api/admin/forms/submissions/${submissionId}`, { status, notes });
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["axcloud", "forms"] });
+    }
+  });
+}
+var LINKED_ACCOUNTS_QUERY_KEY = ["axcloud", "linked-accounts"];
+function useLinkedAccounts() {
+  const { isAuthenticated } = useAuth();
+  const queryClient = useQueryClient();
+  const query = useQuery({
+    queryKey: LINKED_ACCOUNTS_QUERY_KEY,
+    queryFn: async () => {
+      const client = getClient();
+      return client.get("/api/users/me/identities");
+    },
+    enabled: isAuthenticated,
+    staleTime: 1e3 * 60 * 5
+    // 5 minutes
+  });
+  const linkMutation = useMutation({
+    mutationFn: async (provider) => {
+      const client = getClient();
+      const response = await client.post(
+        `/api/users/me/identities/${provider}/link`,
+        {}
+      );
+      if (response.authorization_url) {
+        window.location.href = response.authorization_url;
+      }
+      return response;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: LINKED_ACCOUNTS_QUERY_KEY });
+    }
+  });
+  const unlinkMutation = useMutation({
+    mutationFn: async (provider) => {
+      const client = getClient();
+      return client.delete(
+        `/api/users/me/identities/${provider}`
+      );
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: LINKED_ACCOUNTS_QUERY_KEY });
+    }
+  });
+  return {
+    identities: query.data?.identities ?? [],
+    availableProviders: query.data?.available_providers ?? [],
+    canUnlink: query.data?.can_unlink ?? false,
+    isLoading: query.isLoading,
+    error: query.error,
+    linkAccount: linkMutation.mutate,
+    unlinkAccount: unlinkMutation.mutate,
+    isLinking: linkMutation.isPending,
+    isUnlinking: unlinkMutation.isPending,
+    refetch: query.refetch
+  };
+}
+function useBranding() {
+  const { client, orgId } = useAxCloudContext();
+  const query = useQuery({
+    queryKey: ["axcloud", "media", "branding", orgId],
+    queryFn: async () => {
+      return client.get(`/media/public/${orgId}/branding`);
+    },
+    staleTime: 1e3 * 60 * 30,
+    // 30 minutes (logo URL valid for 1 hour)
+    gcTime: 1e3 * 60 * 55
+    // Garbage collect before URL expires
+  });
+  return {
+    branding: query.data?.branding ?? null,
+    logoUrl: query.data?.branding?.logoUrl ?? null,
+    organizationName: query.data?.name ?? null,
+    isLoading: query.isLoading,
+    isError: query.isError,
+    error: query.error,
+    refetch: query.refetch
+  };
+}
+function useLogo() {
+  const { client, orgId } = useAxCloudContext();
+  const query = useQuery({
+    queryKey: ["axcloud", "media", "logo", orgId],
+    queryFn: async () => {
+      return client.get(`/media/public/${orgId}/logo`);
+    },
+    staleTime: 1e3 * 60 * 30,
+    // 30 minutes
+    gcTime: 1e3 * 60 * 55
+    // Garbage collect before URL expires
+  });
+  return {
+    logoUrl: query.data?.url ?? null,
+    expiresIn: query.data?.expiresIn ?? null,
+    isLoading: query.isLoading,
+    isError: query.isError,
+    error: query.error,
+    refetch: query.refetch
+  };
+}
+function useAvatar(userId) {
+  const { client, orgId } = useAxCloudContext();
+  const query = useQuery({
+    queryKey: ["axcloud", "media", "avatar", orgId, userId],
+    queryFn: async () => {
+      return client.get(`/media/public/${orgId}/avatar/${userId}`);
+    },
+    enabled: !!userId,
+    staleTime: 1e3 * 60 * 30,
+    gcTime: 1e3 * 60 * 55,
+    retry: false
+    // Don't retry if avatar doesn't exist
+  });
+  return {
+    avatarUrl: query.data?.url ?? null,
+    isLoading: query.isLoading,
+    isError: query.isError,
+    error: query.error,
+    refetch: query.refetch
+  };
+}
+function useMediaList(type = "media", limit = 50) {
+  const { client, orgId } = useAxCloudContext();
+  const query = useQuery({
+    queryKey: ["axcloud", "media", "list", orgId, type, limit],
+    queryFn: async () => {
+      return client.get(`/media/public/${orgId}/list`, {
+        type,
+        limit
+      });
+    },
+    staleTime: 1e3 * 60 * 5
+    // 5 minutes
+  });
+  return {
+    items: query.data?.items ?? [],
+    count: query.data?.count ?? 0,
+    isLoading: query.isLoading,
+    isError: query.isError,
+    error: query.error,
+    refetch: query.refetch
+  };
+}
+function useMedia(mediaId) {
+  const { client, orgId } = useAxCloudContext();
+  const query = useQuery({
+    queryKey: ["axcloud", "media", "file", orgId, mediaId],
+    queryFn: async () => {
+      return client.get(`/media/public/${orgId}/media/${mediaId}`);
+    },
+    enabled: !!mediaId,
+    staleTime: 1e3 * 60 * 30,
+    gcTime: 1e3 * 60 * 55
+  });
+  return {
+    mediaUrl: query.data?.url ?? null,
+    expiresIn: query.data?.expiresIn ?? null,
+    isLoading: query.isLoading,
+    isError: query.isError,
+    error: query.error,
+    refetch: query.refetch
+  };
+}
+function LoginButton({
+  children = "Log in",
+  returnTo,
+  className,
+  style
+}) {
+  const { login, isLoading } = useAuth();
+  const handleClick = () => {
+    login({ returnTo });
+  };
+  return /* @__PURE__ */ jsx(
+    "button",
+    {
+      onClick: handleClick,
+      disabled: isLoading,
+      className,
+      style,
+      type: "button",
+      children: isLoading ? "Loading..." : children
+    }
+  );
+}
+function LogoutButton({
+  children = "Log out",
+  returnTo,
+  className,
+  style
+}) {
+  const { logout } = useAuth();
+  const handleClick = () => {
+    logout({ returnTo });
+  };
+  return /* @__PURE__ */ jsx(
+    "button",
+    {
+      onClick: handleClick,
+      className,
+      style,
+      type: "button",
+      children
+    }
+  );
+}
+function ProtectedRoute({
+  children,
+  roles,
+  loadingComponent,
+  unauthenticatedComponent,
+  unauthorizedComponent,
+  redirectToLogin = false,
+  returnTo
+}) {
+  const { isAuthenticated, isLoading: isAuthLoading, login } = useAuth();
+  const { user, role, isLoading: isUserLoading } = useUser();
+  const isLoading = isAuthLoading || isAuthenticated && isUserLoading;
+  if (isLoading) {
+    return /* @__PURE__ */ jsx(Fragment, { children: loadingComponent ?? /* @__PURE__ */ jsx(DefaultLoadingComponent, {}) });
+  }
+  if (!isAuthenticated) {
+    if (redirectToLogin) {
+      login({ returnTo: returnTo || window.location.pathname });
+      return /* @__PURE__ */ jsx(Fragment, { children: loadingComponent ?? /* @__PURE__ */ jsx(DefaultLoadingComponent, {}) });
+    }
+    return /* @__PURE__ */ jsx(Fragment, { children: unauthenticatedComponent ?? /* @__PURE__ */ jsx(DefaultUnauthenticatedComponent, {}) });
+  }
+  if (roles && role) {
+    const requiredRoles = Array.isArray(roles) ? roles : [roles];
+    const hasRequiredRole = requiredRoles.includes(role);
+    if (!hasRequiredRole) {
+      return /* @__PURE__ */ jsx(Fragment, { children: unauthorizedComponent ?? /* @__PURE__ */ jsx(DefaultUnauthorizedComponent, {}) });
+    }
+  }
+  return /* @__PURE__ */ jsx(Fragment, { children });
+}
+function DefaultLoadingComponent() {
+  return /* @__PURE__ */ jsx("div", { style: { padding: "20px", textAlign: "center" }, children: "Loading..." });
+}
+function DefaultUnauthenticatedComponent() {
+  return /* @__PURE__ */ jsx("div", { style: { padding: "20px", textAlign: "center" }, children: /* @__PURE__ */ jsx("p", { children: "Please log in to view this content." }) });
+}
+function DefaultUnauthorizedComponent() {
+  return /* @__PURE__ */ jsx("div", { style: { padding: "20px", textAlign: "center" }, children: /* @__PURE__ */ jsx("p", { children: "You don't have permission to view this content." }) });
+}
+function ModuleGate({
+  module,
+  children,
+  fallback = null,
+  requireAll = false
+}) {
+  const { hasModule, isLoading } = useOrg();
+  if (isLoading) {
+    return null;
+  }
+  const requiredModules = Array.isArray(module) ? module : [module];
+  const hasAccess = requireAll ? requiredModules.every((m) => hasModule(m)) : requiredModules.some((m) => hasModule(m));
+  if (!hasAccess) {
+    return /* @__PURE__ */ jsx(Fragment, { children: fallback });
+  }
+  return /* @__PURE__ */ jsx(Fragment, { children });
+}
+function useModuleAccess() {
+  const { hasModule, modules, isLoading } = useOrg();
+  return {
+    hasModule,
+    modules,
+    isLoading
+  };
+}
+var SUPPORTED_OAUTH_PROVIDERS = ["google", "microsoft", "apple"];
+function isSupportedOAuthProvider(provider) {
+  return SUPPORTED_OAUTH_PROVIDERS.includes(provider);
+}
+var ProviderIcons = {
+  google: ({ className }) => /* @__PURE__ */ jsxs("svg", { viewBox: "0 0 24 24", className, fill: "currentColor", children: [
+    /* @__PURE__ */ jsx("path", { d: "M22.56 12.25c0-.78-.07-1.53-.2-2.25H12v4.26h5.92c-.26 1.37-1.04 2.53-2.21 3.31v2.77h3.57c2.08-1.92 3.28-4.74 3.28-8.09z", fill: "#4285F4" }),
+    /* @__PURE__ */ jsx("path", { d: "M12 23c2.97 0 5.46-.98 7.28-2.66l-3.57-2.77c-.98.66-2.23 1.06-3.71 1.06-2.86 0-5.29-1.93-6.16-4.53H2.18v2.84C3.99 20.53 7.7 23 12 23z", fill: "#34A853" }),
+    /* @__PURE__ */ jsx("path", { d: "M5.84 14.09c-.22-.66-.35-1.36-.35-2.09s.13-1.43.35-2.09V7.07H2.18C1.43 8.55 1 10.22 1 12s.43 3.45 1.18 4.93l2.85-2.22.81-.62z", fill: "#FBBC05" }),
+    /* @__PURE__ */ jsx("path", { d: "M12 5.38c1.62 0 3.06.56 4.21 1.64l3.15-3.15C17.45 2.09 14.97 1 12 1 7.7 1 3.99 3.47 2.18 7.07l3.66 2.84c.87-2.6 3.3-4.53 6.16-4.53z", fill: "#EA4335" })
+  ] }),
+  microsoft: ({ className }) => /* @__PURE__ */ jsxs("svg", { viewBox: "0 0 24 24", className, children: [
+    /* @__PURE__ */ jsx("path", { fill: "#F25022", d: "M1 1h10v10H1z" }),
+    /* @__PURE__ */ jsx("path", { fill: "#00A4EF", d: "M1 13h10v10H1z" }),
+    /* @__PURE__ */ jsx("path", { fill: "#7FBA00", d: "M13 1h10v10H13z" }),
+    /* @__PURE__ */ jsx("path", { fill: "#FFB900", d: "M13 13h10v10H13z" })
+  ] }),
+  apple: ({ className }) => /* @__PURE__ */ jsx("svg", { viewBox: "0 0 24 24", className, fill: "currentColor", children: /* @__PURE__ */ jsx("path", { d: "M18.71 19.5c-.83 1.24-1.71 2.45-3.05 2.47-1.34.03-1.77-.79-3.29-.79-1.53 0-2 .77-3.27.82-1.31.05-2.3-1.32-3.14-2.53C4.25 17 2.94 12.45 4.7 9.39c.87-1.52 2.43-2.48 4.12-2.51 1.28-.02 2.5.87 3.29.87.78 0 2.26-1.07 3.81-.91.65.03 2.47.26 3.64 1.98-.09.06-2.17 1.28-2.15 3.81.03 3.02 2.65 4.03 2.68 4.04-.03.07-.42 1.44-1.38 2.83M13 3.5c.73-.83 1.94-1.46 2.94-1.5.13 1.17-.34 2.35-1.04 3.19-.69.85-1.83 1.51-2.95 1.42-.15-1.15.41-2.35 1.05-3.11z" }) }),
+  email: ({ className }) => /* @__PURE__ */ jsxs("svg", { viewBox: "0 0 24 24", className, fill: "none", stroke: "currentColor", strokeWidth: "2", children: [
+    /* @__PURE__ */ jsx("path", { d: "M4 4h16c1.1 0 2 .9 2 2v12c0 1.1-.9 2-2 2H4c-1.1 0-2-.9-2-2V6c0-1.1.9-2 2-2z" }),
+    /* @__PURE__ */ jsx("polyline", { points: "22,6 12,13 2,6" })
+  ] })
+};
+function LinkedAccountsList({
+  providers,
+  showConnectButtons = true,
+  className,
+  onUnlink,
+  onLinkInitiated,
+  renderIdentity,
+  renderAvailableProvider
+}) {
+  const {
+    identities,
+    availableProviders,
+    canUnlink,
+    isLoading,
+    error,
+    linkAccount,
+    unlinkAccount
+  } = useLinkedAccounts();
+  const filteredIdentities = providers ? identities.filter(
+    (i) => providers.some(
+      (p) => i.provider.toLowerCase().includes(p) || i.provider_icon === p
+    )
+  ) : identities;
+  const filteredAvailableProviders = providers ? availableProviders.filter(
+    (p) => providers.some(
+      (provider) => p.provider.toLowerCase().includes(provider) || p.icon === provider
+    )
+  ) : availableProviders;
+  const handleUnlink = (provider) => {
+    unlinkAccount(provider);
+    onUnlink?.(provider);
+  };
+  const handleLink = (provider) => {
+    onLinkInitiated?.(provider);
+    linkAccount(provider);
+  };
+  if (isLoading) {
+    return /* @__PURE__ */ jsx("div", { className: `axcloud-linked-accounts__loading ${className || ""}`, children: "Loading linked accounts..." });
+  }
+  if (error) {
+    return /* @__PURE__ */ jsx("div", { className: `axcloud-linked-accounts__error ${className || ""}`, children: "Failed to load linked accounts. Please try again." });
+  }
+  const getIcon = (iconName, muted = false) => {
+    const IconComponent = ProviderIcons[iconName] || ProviderIcons.email;
+    const iconClass = muted ? "axcloud-linked-accounts__icon axcloud-linked-accounts__icon--muted" : "axcloud-linked-accounts__icon";
+    return /* @__PURE__ */ jsx(IconComponent, { className: iconClass });
+  };
+  return /* @__PURE__ */ jsxs("div", { className: `axcloud-linked-accounts ${className || ""}`, children: [
+    filteredIdentities.map((identity) => {
+      if (renderIdentity) {
+        return renderIdentity(identity, () => handleUnlink(identity.provider));
+      }
+      return /* @__PURE__ */ jsxs("div", { className: "axcloud-linked-accounts__item", children: [
+        /* @__PURE__ */ jsxs("div", { className: "axcloud-linked-accounts__info", children: [
+          getIcon(identity.provider_icon),
+          /* @__PURE__ */ jsxs("div", { children: [
+            /* @__PURE__ */ jsxs("div", { className: "axcloud-linked-accounts__name-row", children: [
+              /* @__PURE__ */ jsx("span", { className: "axcloud-linked-accounts__provider-name", children: identity.provider_display_name }),
+              identity.is_primary && /* @__PURE__ */ jsx("span", { className: "axcloud-linked-accounts__badge", children: "Primary" })
+            ] }),
+            identity.profile_data?.email && /* @__PURE__ */ jsx("div", { className: "axcloud-linked-accounts__email", children: identity.profile_data.email })
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxs("div", { className: "axcloud-linked-accounts__actions", children: [
+          /* @__PURE__ */ jsxs("span", { className: "axcloud-linked-accounts__connected", children: [
+            /* @__PURE__ */ jsx("svg", { width: "16", height: "16", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", children: /* @__PURE__ */ jsx("polyline", { points: "20 6 9 17 4 12" }) }),
+            "Connected"
+          ] }),
+          canUnlink && !identity.is_primary && /* @__PURE__ */ jsx(
+            "button",
+            {
+              onClick: () => handleUnlink(identity.provider),
+              className: "axcloud-linked-accounts__button axcloud-linked-accounts__button--disconnect",
+              children: "Disconnect"
+            }
+          )
+        ] })
+      ] }, `${identity.provider}-${identity.user_id}`);
+    }),
+    showConnectButtons && filteredAvailableProviders.map((provider) => {
+      if (renderAvailableProvider) {
+        return renderAvailableProvider(provider, () => {
+          if (isSupportedOAuthProvider(provider.provider)) {
+            handleLink(provider.provider);
+          }
+        });
+      }
+      return /* @__PURE__ */ jsxs("div", { className: "axcloud-linked-accounts__available", children: [
+        /* @__PURE__ */ jsxs("div", { className: "axcloud-linked-accounts__info", children: [
+          getIcon(provider.icon, true),
+          /* @__PURE__ */ jsxs("div", { children: [
+            /* @__PURE__ */ jsx("span", { className: "axcloud-linked-accounts__provider-name", children: provider.display_name }),
+            /* @__PURE__ */ jsx("div", { className: "axcloud-linked-accounts__email", children: "Not connected" })
+          ] })
+        ] }),
+        /* @__PURE__ */ jsx(
+          "button",
+          {
+            onClick: () => {
+              if (isSupportedOAuthProvider(provider.provider)) {
+                handleLink(provider.provider);
+              }
+            },
+            className: "axcloud-linked-accounts__button axcloud-linked-accounts__button--connect",
+            children: "Connect"
+          }
+        )
+      ] }, provider.provider);
+    })
+  ] });
+}
+
+export { AxCloudClient, AxCloudError, AxCloudProvider, LinkedAccountsList, LoginButton, LogoutButton, ModuleGate, ProtectedRoute, createClient, createFormHelper, getClient, isAxCloudError, submitForm, useAuth, useAvatar, useAxCloudContext, useBranding, useContent, useContentItem, useFormStats, useForms, useLinkedAccounts, useLogo, useMedia, useMediaList, useModuleAccess, useMySection, useNews, useOrg, useSections, useUpdateFormSubmission, useUser, userHasAllPermissions, userHasAnyPermission, userHasPermission };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map