@axcode/axcloud-sdk 0.1.7-dev.87ea138 → 0.1.7-dev.bf490b9

package/dist/index.js

@@ -30,19 +30,9 @@ var AxCloudError = class _AxCloudError extends Error {
           details
         );
       case 403:
-        return new _AxCloudError(
-          message || "Access denied",
-          "FORBIDDEN",
-          status,
-          details
-        );
+        return new _AxCloudError(message || "Access denied", "FORBIDDEN", status, details);
       case 404:
-        return new _AxCloudError(
-          message || "Resource not found",
-          "NOT_FOUND",
-          status,
-          details
-        );
+        return new _AxCloudError(message || "Resource not found", "NOT_FOUND", status, details);
       case 422:
         return new _AxCloudError(
           message || "Validation failed",
@@ -52,19 +42,9 @@ var AxCloudError = class _AxCloudError extends Error {
         );
       default:
         if (status >= 500) {
-          return new _AxCloudError(
-            message || "Server error",
-            "SERVER_ERROR",
-            status,
-            details
-          );
+          return new _AxCloudError(message || "Server error", "SERVER_ERROR", status, details);
         }
-        return new _AxCloudError(
-          message || "An error occurred",
-          "UNKNOWN_ERROR",
-          status,
-          details
-        );
+        return new _AxCloudError(message || "An error occurred", "UNKNOWN_ERROR", status, details);
     }
   }
   static networkError(originalError) {
@@ -78,12 +58,9 @@ var AxCloudError = class _AxCloudError extends Error {
     );
   }
   static timeoutError(timeoutMs) {
-    return new _AxCloudError(
-      `Request timed out after ${timeoutMs}ms`,
-      "TIMEOUT_ERROR",
-      0,
-      { timeout: timeoutMs }
-    );
+    return new _AxCloudError(`Request timed out after ${timeoutMs}ms`, "TIMEOUT_ERROR", 0, {
+      timeout: timeoutMs
+    });
   }
 };
 function isAxCloudError(error) {
@@ -238,6 +215,130 @@ function getClient(key) {
   throw new Error("AxCloud client not found. Make sure AxCloudProvider is mounted and use useAxCloudContext() to get the client.");
 }
 
+// src/core/analytics.ts
+var EVENT_NAME_PATTERN = /^[a-z][a-z0-9_]{1,63}$/;
+var PROPERTY_KEY_PATTERN = /^[a-z][a-z0-9_]{0,47}$/;
+var SENSITIVE_PROPERTY_PATTERN = /(^|_)(auth0|email|name|password|query|search|secret|token|trace|user|userid)($|_)/;
+var EMAIL_VALUE_PATTERN = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+var OPAQUE_SEGMENT_PATTERNS = [
+  /^[0-9a-f]{8}-[0-9a-f-]{27,}$/i,
+  /^(org|user|section|document|content|poll|invitation|invite|trace|chan)[_-][a-z0-9_-]+$/i,
+  /^[a-f0-9]{20,}$/i,
+  /^[a-z0-9_-]{32,}$/i
+];
+var scriptLoads = /* @__PURE__ */ new Map();
+function isLocalAnalyticsHostname(hostname) {
+  return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1";
+}
+function sanitizeAnalyticsPath(pathname, customNormalizer) {
+  const rawPath = pathname.split(/[?#]/, 1)[0] || "/";
+  const normalizedInput = rawPath.startsWith("/") ? rawPath : `/${rawPath}`;
+  const custom = customNormalizer?.(normalizedInput);
+  if (custom === null) return null;
+  const path = custom ?? normalizedInput;
+  const cleanPath = path.split(/[?#]/, 1)[0] || "/";
+  const segments = cleanPath.split("/").map((segment) => {
+    if (!segment) return segment;
+    let decoded = segment;
+    try {
+      decoded = decodeURIComponent(segment);
+    } catch {
+    }
+    return OPAQUE_SEGMENT_PATTERNS.some((pattern) => pattern.test(decoded)) ? ":id" : segment;
+  });
+  return segments.join("/") || "/";
+}
+function sanitizeAnalyticsEventData(data) {
+  if (!data) return void 0;
+  const sanitized = {};
+  for (const [rawKey, rawValue] of Object.entries(data).slice(0, 20)) {
+    const key = rawKey.trim().toLowerCase();
+    if (!PROPERTY_KEY_PATTERN.test(key) || SENSITIVE_PROPERTY_PATTERN.test(key)) continue;
+    if (typeof rawValue === "string") {
+      const value = rawValue.trim();
+      if (!value || value.length > 100 || EMAIL_VALUE_PATTERN.test(value)) continue;
+      sanitized[key] = value;
+      continue;
+    }
+    if (typeof rawValue === "number" && Number.isFinite(rawValue)) {
+      sanitized[key] = rawValue;
+      continue;
+    }
+    if (typeof rawValue === "boolean") sanitized[key] = rawValue;
+  }
+  return Object.keys(sanitized).length > 0 ? sanitized : void 0;
+}
+function isAllowedAnalyticsEvent(eventName, allowedEvents) {
+  return EVENT_NAME_PATTERN.test(eventName) && Boolean(allowedEvents?.includes(eventName));
+}
+async function fetchAnalyticsPublicConfig(input) {
+  const baseUrl = input.apiUrl.replace(/\/$/, "");
+  const url = new URL(`${baseUrl}/analytics/public/config`);
+  url.searchParams.set("orgId", input.orgId);
+  url.searchParams.set("siteKey", input.siteKey);
+  url.searchParams.set("stage", input.stage);
+  url.searchParams.set("hostname", input.hostname);
+  const response = await fetch(url, {
+    method: "GET",
+    headers: { Accept: "application/json" },
+    signal: input.signal
+  });
+  if (!response.ok) throw new Error(`Analytics configuration returned ${response.status}`);
+  return response.json();
+}
+function loadAnalyticsScript(config, doc = document) {
+  if (!config.enabled || !config.websiteId || !config.scriptUrl) {
+    return Promise.reject(new Error("Analytics tracker configuration is incomplete"));
+  }
+  const key = `${config.scriptUrl}|${config.websiteId}`;
+  const existingPromise = scriptLoads.get(key);
+  if (existingPromise) return existingPromise;
+  const existing = doc.querySelector(
+    `script[data-axcloud-analytics-site="${config.websiteId}"]`
+  );
+  if (existing && doc.defaultView?.umami) {
+    return Promise.resolve();
+  }
+  const promise = new Promise((resolve, reject) => {
+    const script = existing || doc.createElement("script");
+    const onLoad = () => resolve();
+    const onError = () => reject(new Error("Analytics tracker failed to load"));
+    script.addEventListener("load", onLoad, { once: true });
+    script.addEventListener("error", onError, { once: true });
+    if (!existing) {
+      script.src = config.scriptUrl;
+      script.defer = true;
+      script.dataset.websiteId = config.websiteId;
+      script.dataset.axcloudAnalyticsSite = config.websiteId;
+      script.dataset.autoTrack = String(config.autoTrack === true);
+      if (config.hostUrl) script.dataset.hostUrl = config.hostUrl;
+      if (config.domains?.length) script.dataset.domains = config.domains.join(",");
+      if (config.respectDoNotTrack !== false) script.dataset.doNotTrack = "true";
+      if (config.excludeSearch !== false) script.dataset.excludeSearch = "true";
+      if (config.excludeHash !== false) script.dataset.excludeHash = "true";
+      doc.head.appendChild(script);
+    }
+  }).catch((error) => {
+    scriptLoads.delete(key);
+    throw error;
+  });
+  scriptLoads.set(key, promise);
+  return promise;
+}
+function sendAnalyticsPageView(pathname, options, targetWindow = window) {
+  const path = sanitizeAnalyticsPath(pathname, options.normalizePath);
+  const umami = targetWindow.umami;
+  if (!path || !umami) return false;
+  umami.track({ url: path, title: targetWindow.document.title });
+  return true;
+}
+function sendAnalyticsEvent(eventName, data, allowedEvents, targetWindow = window) {
+  const umami = targetWindow.umami;
+  if (!umami || !isAllowedAnalyticsEvent(eventName, allowedEvents)) return false;
+  umami.track(eventName, sanitizeAnalyticsEventData(data));
+  return true;
+}
+
 // src/core/contentSlots.ts
 var SLOT_ATTRIBUTE_KEYS = ["slot", "field", "key", "name"];
 function getContentSlotMap(content) {
@@ -533,6 +634,127 @@ function useAxCloudContext() {
   }
   return context;
 }
+var NAVIGATION_EVENT = "axcloud-sdk:navigation";
+var historySubscriberCount = 0;
+var originalPushState = null;
+var originalReplaceState = null;
+function subscribeToNavigation(callback) {
+  if (typeof window === "undefined") return () => void 0;
+  if (historySubscriberCount === 0) {
+    originalPushState = window.history.pushState.bind(window.history);
+    originalReplaceState = window.history.replaceState.bind(window.history);
+    window.history.pushState = ((...args) => {
+      originalPushState?.(...args);
+      window.dispatchEvent(new Event(NAVIGATION_EVENT));
+    });
+    window.history.replaceState = ((...args) => {
+      originalReplaceState?.(...args);
+      window.dispatchEvent(new Event(NAVIGATION_EVENT));
+    });
+  }
+  historySubscriberCount += 1;
+  window.addEventListener("popstate", callback);
+  window.addEventListener(NAVIGATION_EVENT, callback);
+  return () => {
+    window.removeEventListener("popstate", callback);
+    window.removeEventListener(NAVIGATION_EVENT, callback);
+    historySubscriberCount = Math.max(0, historySubscriberCount - 1);
+    if (historySubscriberCount === 0) {
+      if (originalPushState) window.history.pushState = originalPushState;
+      if (originalReplaceState) window.history.replaceState = originalReplaceState;
+      originalPushState = null;
+      originalReplaceState = null;
+    }
+  };
+}
+function doNotTrackEnabled(config) {
+  if (config.respectDoNotTrack === false || typeof navigator === "undefined") return false;
+  return navigator.doNotTrack === "1";
+}
+function useAnalyticsRuntime(config) {
+  const [enabled, setEnabled] = react.useState(false);
+  const [ready, setReady] = react.useState(false);
+  const publicConfigRef = react.useRef(null);
+  const optionsRef = react.useRef(config.analytics);
+  optionsRef.current = config.analytics;
+  const trackPageView = react.useCallback(
+    (pathname) => {
+      if (!ready || !optionsRef.current || typeof window === "undefined") return false;
+      return sendAnalyticsPageView(pathname || window.location.pathname, optionsRef.current);
+    },
+    [ready]
+  );
+  const track = react.useCallback(
+    (eventName, data) => {
+      if (!ready || typeof window === "undefined") return false;
+      return sendAnalyticsEvent(eventName, data, publicConfigRef.current?.allowedEvents);
+    },
+    [ready]
+  );
+  react.useEffect(() => {
+    const options = config.analytics;
+    setEnabled(false);
+    setReady(false);
+    publicConfigRef.current = null;
+    if (!options?.enabled || !options.siteKey || typeof window === "undefined") return void 0;
+    if (isLocalAnalyticsHostname(window.location.hostname) && !options.trackLocalhost)
+      return void 0;
+    const controller = new AbortController();
+    let cancelled = false;
+    let unsubscribe = () => void 0;
+    const initialize = async () => {
+      try {
+        const publicConfig = await fetchAnalyticsPublicConfig({
+          apiUrl: config.apiUrl,
+          orgId: config.orgId,
+          siteKey: options.siteKey,
+          stage: config.stage,
+          hostname: window.location.hostname,
+          signal: controller.signal
+        });
+        if (cancelled || !publicConfig.enabled || doNotTrackEnabled(publicConfig)) return;
+        publicConfigRef.current = publicConfig;
+        setEnabled(true);
+        await loadAnalyticsScript(publicConfig);
+        if (cancelled) return;
+        setReady(true);
+        if (!publicConfig.autoTrack) {
+          const trackCurrentPage = () => {
+            sendAnalyticsPageView(window.location.pathname, options);
+          };
+          trackCurrentPage();
+          unsubscribe = subscribeToNavigation(trackCurrentPage);
+        }
+      } catch (error) {
+        if (!cancelled && !(error instanceof Error && error.name === "AbortError")) {
+          setEnabled(false);
+          setReady(false);
+        }
+      }
+    };
+    void initialize();
+    return () => {
+      cancelled = true;
+      controller.abort();
+      unsubscribe();
+    };
+  }, [
+    config.analytics?.enabled,
+    config.analytics?.siteKey,
+    config.analytics?.trackLocalhost,
+    config.analytics?.normalizePath,
+    config.apiUrl,
+    config.orgId,
+    config.stage
+  ]);
+  return react.useMemo(
+    () => ({ enabled, ready, track, trackPageView }),
+    [enabled, ready, track, trackPageView]
+  );
+}
+function useAnalytics() {
+  return useAxCloudContext().analytics;
+}
 var defaultQueryClient = new reactQuery.QueryClient({
   defaultOptions: {
     queries: {
@@ -551,6 +773,7 @@ function AxCloudInnerProvider({
   timeout
 }) {
   const { getAccessTokenSilently, isAuthenticated } = auth0React.useAuth0();
+  const analytics = useAnalyticsRuntime(config);
   const tokenGetterRef = react.useRef(async () => void 0);
   tokenGetterRef.current = isAuthenticated ? async () => {
     try {
@@ -580,9 +803,10 @@ function AxCloudInnerProvider({
       client,
       orgId: config.orgId,
       stage: config.stage,
-      isPublicMode: Boolean(config.apiKey) && !isAuthenticated
+      isPublicMode: Boolean(config.apiKey) && !isAuthenticated,
+      analytics
     }),
-    [config, client, isAuthenticated]
+    [config, client, isAuthenticated, analytics]
   );
   return /* @__PURE__ */ jsxRuntime.jsx(AxCloudContext.Provider, { value: contextValue, children });
 }
@@ -592,6 +816,7 @@ function AxCloudProvider({
   apiUrl,
   stage = "dev",
   apiKey,
+  analytics,
   auth0,
   queryClient = defaultQueryClient,
   timeout
@@ -602,9 +827,10 @@ function AxCloudProvider({
       apiUrl,
       stage,
       apiKey,
+      analytics,
       auth0
     }),
-    [orgId, apiUrl, stage, apiKey, auth0]
+    [orgId, apiUrl, stage, apiKey, analytics, auth0]
   );
   return /* @__PURE__ */ jsxRuntime.jsx(reactQuery.QueryClientProvider, { client: queryClient, children: /* @__PURE__ */ jsxRuntime.jsx(
     auth0React.Auth0Provider,
@@ -613,14 +839,15 @@ function AxCloudProvider({
       clientId: auth0.clientId,
       authorizationParams: {
         redirect_uri: auth0.redirectUri,
-        audience: auth0.audience
+        audience: auth0.audience,
+        ...auth0.organization ? { organization: auth0.organization } : {}
       },
       children: /* @__PURE__ */ jsxRuntime.jsx(AxCloudInnerProvider, { config, timeout, children })
     }
   ) });
 }
 function useAuth() {
-  const { config } = useAxCloudContext();
+  const { config, client } = useAxCloudContext();
   const {
     isAuthenticated,
     isLoading,
@@ -636,10 +863,15 @@ function useAuth() {
       return loginWithRedirect({
         appState: {
           returnTo: options?.returnTo || window.location.pathname
-        }
+        },
+        ...config.auth0.organization ? {
+          authorizationParams: {
+            organization: config.auth0.organization
+          }
+        } : {}
       });
     },
-    [loginWithRedirect]
+    [config.auth0.organization, loginWithRedirect]
   );
   const logout = react.useCallback(
     (options) => {
@@ -658,6 +890,60 @@ function useAuth() {
       return void 0;
     }
   }, [getAccessTokenSilently]);
+  const refreshUser = react.useCallback(async () => {
+    await getAccessTokenSilently({ cacheMode: "off" });
+    const claims = await getIdTokenClaims();
+    return claims?.email_verified === true;
+  }, [getAccessTokenSilently, getIdTokenClaims]);
+  const requestEmailVerification = react.useCallback(
+    async (options) => {
+      if (!isAuthenticated || !auth0User) {
+        return {
+          success: false,
+          status: "failed",
+          message: "You must be signed in to verify your email."
+        };
+      }
+      if (auth0User.email_verified === true) {
+        return {
+          success: true,
+          status: "already_verified",
+          message: "Your email address is already verified."
+        };
+      }
+      try {
+        const response = await client.post("/email/identity/verification-email", {
+          return_to: options?.returnTo || window.location.href
+        });
+        const data = response.data || {};
+        return {
+          success: true,
+          status: data.status || "sent",
+          message: data.message || "A verification email has been sent.",
+          ...data.retry_after_seconds !== void 0 ? { retryAfterSeconds: data.retry_after_seconds } : {}
+        };
+      } catch (requestError) {
+        if (isAxCloudError(requestError) && requestError.status === 429) {
+          const responseDetails = requestError.details?.details;
+          const retryAfterSeconds = Number(
+            responseDetails && typeof responseDetails === "object" ? responseDetails.retry_after_seconds : void 0
+          );
+          return {
+            success: false,
+            status: "rate_limited",
+            message: "Please wait before requesting another verification email.",
+            ...Number.isFinite(retryAfterSeconds) ? { retryAfterSeconds } : {}
+          };
+        }
+        return {
+          success: false,
+          status: "failed",
+          message: "Failed to send the verification email. Please try again."
+        };
+      }
+    },
+    [auth0User, client, isAuthenticated]
+  );
   const getAuth0Client = react.useCallback(() => {
     return {
       loginWithRedirect,
@@ -731,24 +1017,28 @@ function useAuth() {
       id: auth0User.sub || "",
       email: auth0User.email || "",
       name: auth0User.name || "",
-      avatar: auth0User.picture
+      avatar: auth0User.picture,
+      ...typeof auth0User.email_verified === "boolean" ? { emailVerified: auth0User.email_verified } : {}
     } : null,
+    needsEmailVerification: isAuthenticated && auth0User?.email_verified === false,
     login,
     logout,
     // Escape hatch for advanced use cases
     getAccessToken,
     getAuth0Client,
+    refreshUser,
+    requestEmailVerification,
     // Password management
     requestPasswordReset
   };
 }
 function useUser() {
-  const { isAuthenticated, isLoading: isAuthLoading } = auth0React.useAuth0();
+  const { isAuthenticated, isLoading: isAuthLoading, user: auth0User } = auth0React.useAuth0();
   const { client, stage, orgId } = useAxCloudContext();
   const query = reactQuery.useQuery({
-    queryKey: ["axcloud", "user", "me", stage],
+    queryKey: ["axcloud", "user", "me", stage, orgId, auth0User?.sub],
     queryFn: async () => {
-      return client.get(`/${stage}/api/users/me`);
+      return client.get("/api/users/me");
     },
     enabled: isAuthenticated && !isAuthLoading,
     staleTime: 1e3 * 60 * 5
@@ -757,7 +1047,7 @@ function useUser() {
   const userData = query.data;
   const userOrgIds = userData?.all_org_ids ?? [];
   const isSuperAdmin = userData?.isSuperAdmin === true;
-  const hasOrgAccess = isSuperAdmin || userOrgIds.includes(orgId);
+  const hasOrgAccess = userOrgIds.includes(orgId);
   const orgMembership = userData?.organization_memberships?.[orgId];
   const roleInOrg = orgMembership?.role ?? null;
   return {
@@ -1375,6 +1665,73 @@ function useDocumentDownload(documentId) {
     refetch: query.refetch
   };
 }
+function useMemberDocuments(options) {
+  const { client, orgId } = useAxCloudContext();
+  const params = buildDocumentParams(options);
+  const folderId = options?.folderId;
+  const query = reactQuery.useQuery({
+    queryKey: ["axcloud", "documents", "member", "list", orgId, options],
+    queryFn: async () => {
+      return client.get(`/documents/members/${orgId}/documents`, params);
+    },
+    staleTime: 1e3 * 60 * 5
+  });
+  const allItems = query.data?.items ?? [];
+  const items = folderId ? allItems.filter((doc) => doc.folder_ids?.includes(folderId)) : allItems;
+  return {
+    documents: items,
+    items,
+    count: folderId ? items.length : query.data?.count ?? 0,
+    isLoading: query.isLoading,
+    isError: query.isError,
+    error: query.error,
+    refetch: query.refetch
+  };
+}
+function useMemberDocumentFolders() {
+  const { client, orgId } = useAxCloudContext();
+  const query = reactQuery.useQuery({
+    queryKey: ["axcloud", "documents", "member", "folders", orgId],
+    queryFn: async () => {
+      return client.get(
+        `/documents/members/${orgId}/document-folders`
+      );
+    },
+    staleTime: 1e3 * 60 * 5
+  });
+  return {
+    folders: query.data?.folders ?? [],
+    isLoading: query.isLoading,
+    isError: query.isError,
+    error: query.error,
+    refetch: query.refetch
+  };
+}
+function useMemberDocumentDownload(documentId) {
+  const { client, orgId } = useAxCloudContext();
+  const query = reactQuery.useQuery({
+    queryKey: ["axcloud", "documents", "member", "download", orgId, documentId],
+    queryFn: async () => {
+      return client.get(
+        `/documents/members/${orgId}/documents/${encodeURIComponent(documentId || "")}/download`
+      );
+    },
+    enabled: !!documentId,
+    staleTime: 1e3 * 60 * 10,
+    gcTime: 1e3 * 60 * 14
+  });
+  return {
+    url: query.data?.url ?? null,
+    documentUrl: query.data?.url ?? null,
+    filename: query.data?.filename ?? null,
+    mimeType: query.data?.mimeType ?? null,
+    expiresIn: query.data?.expiresIn ?? null,
+    isLoading: query.isLoading,
+    isError: query.isError,
+    error: query.error,
+    refetch: query.refetch
+  };
+}
 function useBarnsportMunicipalities() {
   const { client, orgId } = useAxCloudContext();
   const query = reactQuery.useQuery({
@@ -1411,6 +1768,24 @@ function useBarnsportSports() {
     refetch: query.refetch
   };
 }
+function useBarnsportSport(slug) {
+  const { client, orgId } = useAxCloudContext();
+  const query = reactQuery.useQuery({
+    queryKey: ["axcloud", "barnsport", "sport", orgId, slug],
+    queryFn: () => client.get(
+      `/barnsport/public/${orgId}/sports/${slug || ""}`
+    ),
+    enabled: Boolean(slug),
+    staleTime: 1e3 * 60 * 15
+  });
+  return {
+    sport: query.data?.sport ?? null,
+    isLoading: query.isLoading,
+    isError: query.isError,
+    error: query.error,
+    refetch: query.refetch
+  };
+}
 function useBarnsportActivities(filters = {}) {
   const { client, orgId } = useAxCloudContext();
   const params = { ...filters };
@@ -1735,12 +2110,19 @@ exports.checkVotingCode = checkVotingCode;
 exports.createClient = createClient;
 exports.createContentSlotReader = createContentSlotReader;
 exports.createFormHelper = createFormHelper;
+exports.fetchAnalyticsPublicConfig = fetchAnalyticsPublicConfig;
 exports.getBallot = getBallot;
 exports.getClient = getClient;
 exports.getContentSlotMap = getContentSlotMap;
 exports.getVotingReceipt = getVotingReceipt;
+exports.isAllowedAnalyticsEvent = isAllowedAnalyticsEvent;
 exports.isAxCloudError = isAxCloudError;
+exports.isLocalAnalyticsHostname = isLocalAnalyticsHostname;
+exports.sanitizeAnalyticsEventData = sanitizeAnalyticsEventData;
+exports.sanitizeAnalyticsPath = sanitizeAnalyticsPath;
 exports.submitForm = submitForm;
+exports.useAnalytics = useAnalytics;
+exports.useAnalyticsRuntime = useAnalyticsRuntime;
 exports.useAuth = useAuth;
 exports.useAvatar = useAvatar;
 exports.useAxCloudContext = useAxCloudContext;
@@ -1748,6 +2130,7 @@ exports.useBarnsportActivities = useBarnsportActivities;
 exports.useBarnsportActivity = useBarnsportActivity;
 exports.useBarnsportMunicipalities = useBarnsportMunicipalities;
 exports.useBarnsportSitemap = useBarnsportSitemap;
+exports.useBarnsportSport = useBarnsportSport;
 exports.useBarnsportSports = useBarnsportSports;
 exports.useBranding = useBranding;
 exports.useCodeBallot = useCodeBallot;
@@ -1761,6 +2144,9 @@ exports.useLinkedAccounts = useLinkedAccounts;
 exports.useLogo = useLogo;
 exports.useMedia = useMedia;
 exports.useMediaList = useMediaList;
+exports.useMemberDocumentDownload = useMemberDocumentDownload;
+exports.useMemberDocumentFolders = useMemberDocumentFolders;
+exports.useMemberDocuments = useMemberDocuments;
 exports.useModuleAccess = useModuleAccess;
 exports.useMySection = useMySection;
 exports.useNews = useNews;