@axcode/axcloud-sdk 0.1.7-dev.bf490b9 → 0.2.0-dev.1e6c3d5

package/dist/index.js

@@ -20,7 +20,7 @@ var AxCloudError = class _AxCloudError extends Error {
   }
   static fromResponse(status, body) {
     const details = typeof body === "object" ? body : void 0;
-    const message = details?.message;
+    const message = (typeof details?.message === "string" ? details.message : void 0) || (typeof details?.error === "string" ? details.error : void 0);
     switch (status) {
       case 401:
         return new _AxCloudError(
@@ -346,7 +346,7 @@ function getContentSlotMap(content) {
   for (const block of content?.blocks || []) {
     const slot = getBlockSlot(block);
     if (!slot) continue;
-    fields[slot] = blockToSlotValue(block);
+    if (!(slot in fields)) fields[slot] = blockToSlotValue(block);
   }
   return fields;
 }
@@ -355,11 +355,13 @@ function createContentSlotReader(content) {
   const value = (key, fallback) => {
     return key in fields ? fields[key] : fallback;
   };
+  const unsafeHtml = (key, fallback = "") => stringifySlotValue(value(key, fallback));
   return {
     fields,
     value,
     text: (key, fallback = "") => stringifySlotValue(value(key, fallback)),
-    html: (key, fallback = "") => stringifySlotValue(value(key, fallback)),
+    html: unsafeHtml,
+    unsafeHtml,
     list: (key, fallback = []) => slotValueToList(value(key, fallback)),
     image: (key, fallback) => slotValueToImage(value(key, fallback))
   };
@@ -755,25 +757,74 @@ function useAnalyticsRuntime(config) {
 function useAnalytics() {
   return useAxCloudContext().analytics;
 }
-var defaultQueryClient = new reactQuery.QueryClient({
-  defaultOptions: {
-    queries: {
-      staleTime: 1e3 * 60 * 5,
-      // 5 minutes
-      gcTime: 1e3 * 60 * 30,
-      // 30 minutes (garbage collection)
-      retry: 2,
-      refetchOnWindowFocus: false
-    }
+
+// src/react/auth/auth0Invitation.ts
+var AUTH0_INVITATION_PATTERN = /^[A-Za-z0-9_-]{1,2048}$/;
+function readAuth0InvitationAuthorizationParams(configuredOrganization, search = typeof window === "undefined" ? "" : window.location.search) {
+  if (!configuredOrganization || !search) return {};
+  const params = new URLSearchParams(search);
+  const invitation = params.get("invitation")?.trim();
+  const organization = params.get("organization")?.trim();
+  if (organization !== configuredOrganization || !invitation || !AUTH0_INVITATION_PATTERN.test(invitation)) {
+    return {};
   }
-});
+  return { invitation };
+}
+function createDefaultQueryClient() {
+  return new reactQuery.QueryClient({
+    defaultOptions: {
+      queries: {
+        staleTime: 1e3 * 60,
+        gcTime: 1e3 * 60 * 30,
+        retry: (failureCount, error) => {
+          if (isAxCloudError(error) && error.status >= 400 && error.status < 500) {
+            return false;
+          }
+          return failureCount < 2;
+        },
+        refetchOnWindowFocus: true
+      }
+    }
+  });
+}
+var queryClientAxCloudOwners = /* @__PURE__ */ new WeakMap();
+function createQueryClientOwnerSignature(config, subject) {
+  return JSON.stringify([
+    subject === null ? "public" : "authenticated",
+    subject,
+    config.orgId,
+    config.stage,
+    config.apiUrl,
+    config.apiKey ?? null,
+    config.auth0.domain,
+    config.auth0.clientId,
+    config.auth0.audience ?? null,
+    config.auth0.organization ?? null,
+    config.auth0.connection ?? null
+  ]);
+}
 function AxCloudInnerProvider({
   children,
   config,
+  queryClient,
   timeout
 }) {
-  const { getAccessTokenSilently, isAuthenticated } = auth0React.useAuth0();
+  const { getAccessTokenSilently, isAuthenticated, isLoading, user } = auth0React.useAuth0();
   const analytics = useAnalyticsRuntime(config);
+  const [, setOwnerGeneration] = react.useState(0);
+  const currentSubject = isLoading ? void 0 : isAuthenticated ? user?.sub : null;
+  const currentOwnerSignature = currentSubject === void 0 ? void 0 : createQueryClientOwnerSignature(config, currentSubject);
+  const hasKnownOwner = queryClientAxCloudOwners.has(queryClient);
+  const ownerNeedsActivation = currentOwnerSignature !== void 0 && (!hasKnownOwner || queryClientAxCloudOwners.get(queryClient) !== currentOwnerSignature);
+  const clearContentCache = react.useCallback(() => {
+    queryClient.removeQueries({ queryKey: ["axcloud"] });
+  }, [queryClient]);
+  react.useLayoutEffect(() => {
+    if (currentOwnerSignature === void 0 || !ownerNeedsActivation) return;
+    clearContentCache();
+    queryClientAxCloudOwners.set(queryClient, currentOwnerSignature);
+    setOwnerGeneration((generation) => generation + 1);
+  }, [clearContentCache, currentOwnerSignature, ownerNeedsActivation, queryClient]);
   const tokenGetterRef = react.useRef(async () => void 0);
   tokenGetterRef.current = isAuthenticated ? async () => {
     try {
@@ -803,12 +854,17 @@ function AxCloudInnerProvider({
       client,
       orgId: config.orgId,
       stage: config.stage,
-      isPublicMode: Boolean(config.apiKey) && !isAuthenticated,
+      isPublicMode: !isAuthenticated,
+      isAuthLoading: isLoading,
+      isAuthenticated,
+      authSubject: isAuthenticated ? user?.sub : void 0,
+      clearContentCache,
       analytics
     }),
-    [config, client, isAuthenticated, analytics]
+    [config, client, isAuthenticated, isLoading, user?.sub, clearContentCache, analytics]
   );
-  return /* @__PURE__ */ jsxRuntime.jsx(AxCloudContext.Provider, { value: contextValue, children });
+  const identityReady = currentOwnerSignature !== void 0 && !ownerNeedsActivation;
+  return /* @__PURE__ */ jsxRuntime.jsx(AxCloudContext.Provider, { value: contextValue, children: identityReady ? children : null });
 }
 function AxCloudProvider({
   children,
@@ -818,9 +874,12 @@ function AxCloudProvider({
   apiKey,
   analytics,
   auth0,
-  queryClient = defaultQueryClient,
+  queryClient: providedQueryClient,
   timeout
 }) {
+  const [ownedQueryClient] = react.useState(createDefaultQueryClient);
+  const queryClient = providedQueryClient || ownedQueryClient;
+  const invitationAuthorizationParams = readAuth0InvitationAuthorizationParams(auth0.organization);
   const config = react.useMemo(
     () => ({
       orgId,
@@ -840,14 +899,15 @@ function AxCloudProvider({
       authorizationParams: {
         redirect_uri: auth0.redirectUri,
         audience: auth0.audience,
-        ...auth0.organization ? { organization: auth0.organization } : {}
+        ...auth0.organization ? { organization: auth0.organization } : {},
+        ...invitationAuthorizationParams
       },
-      children: /* @__PURE__ */ jsxRuntime.jsx(AxCloudInnerProvider, { config, timeout, children })
+      children: /* @__PURE__ */ jsxRuntime.jsx(AxCloudInnerProvider, { config, queryClient, timeout, children })
     }
   ) });
 }
 function useAuth() {
-  const { config, client } = useAxCloudContext();
+  const { config, client, clearContentCache } = useAxCloudContext();
   const {
     isAuthenticated,
     isLoading,
@@ -860,13 +920,17 @@ function useAuth() {
   } = auth0React.useAuth0();
   const login = react.useCallback(
     (options) => {
+      const invitationAuthorizationParams = readAuth0InvitationAuthorizationParams(
+        config.auth0.organization
+      );
       return loginWithRedirect({
         appState: {
           returnTo: options?.returnTo || window.location.pathname
         },
         ...config.auth0.organization ? {
           authorizationParams: {
-            organization: config.auth0.organization
+            organization: config.auth0.organization,
+            ...invitationAuthorizationParams
           }
         } : {}
       });
@@ -875,13 +939,14 @@ function useAuth() {
   );
   const logout = react.useCallback(
     (options) => {
+      clearContentCache?.();
       return auth0Logout({
         logoutParams: {
           returnTo: options?.returnTo || window.location.origin
         }
       });
     },
-    [auth0Logout]
+    [auth0Logout, clearContentCache]
   );
   const getAccessToken = react.useCallback(async () => {
     try {
@@ -1032,24 +1097,167 @@ function useAuth() {
     requestPasswordReset
   };
 }
+var currentUserQueryKey = (stage, orgId, subject) => ["axcloud", "user", "me", stage, orgId, subject];
+function asRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function asString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : null;
+}
+function asStringArray(value) {
+  if (!Array.isArray(value)) return [];
+  return Array.from(new Set(value.map(asString).filter((item) => item !== null)));
+}
+function normalizeMembershipSections(rawMembership) {
+  const sections = /* @__PURE__ */ new Map();
+  const addSection = (idValue, nameValue, roleValue) => {
+    const id = asString(idValue);
+    if (!id) return;
+    const existing = sections.get(id);
+    sections.set(id, {
+      id,
+      name: asString(nameValue) || existing?.name || id,
+      role: asString(roleValue) || existing?.role || "member"
+    });
+  };
+  const directSections = rawMembership.sections;
+  if (Array.isArray(directSections)) {
+    for (const rawSection of directSections) {
+      if (typeof rawSection === "string") {
+        addSection(rawSection);
+        continue;
+      }
+      const section = asRecord(rawSection);
+      addSection(
+        section.id ?? section.sectionId ?? section.section_id,
+        section.name ?? section.sectionName ?? section.section_name,
+        section.role
+      );
+    }
+  }
+  const sectionMemberships = asRecord(
+    rawMembership.sectionMemberships ?? rawMembership.section_memberships
+  );
+  for (const [sectionId, rawSectionMembership] of Object.entries(sectionMemberships)) {
+    const sectionMembership = asRecord(rawSectionMembership);
+    addSection(
+      sectionId,
+      sectionMembership.name ?? sectionMembership.sectionName ?? sectionMembership.section_name,
+      sectionMembership.role
+    );
+  }
+  for (const sectionId of asStringArray(rawMembership.sectionIds ?? rawMembership.section_ids)) {
+    addSection(sectionId);
+  }
+  const primarySectionId = asString(rawMembership.sectionId ?? rawMembership.section_id);
+  if (primarySectionId) addSection(primarySectionId);
+  const normalized = Array.from(sections.values());
+  if (!primarySectionId) return normalized;
+  return normalized.sort((left, right) => {
+    if (left.id === primarySectionId) return -1;
+    if (right.id === primarySectionId) return 1;
+    return 0;
+  });
+}
+function normalizeMembership(rawValue) {
+  const raw = asRecord(rawValue);
+  const role = asString(raw.role) || "member";
+  const roles = asStringArray(raw.roles);
+  const sections = normalizeMembershipSections(raw);
+  const sectionId = asString(raw.sectionId ?? raw.section_id) || sections[0]?.id || null;
+  const joinedAt = asString(raw.joinedAt ?? raw.joined_at);
+  return {
+    role,
+    roles: roles.length > 0 ? roles : [role],
+    title: asString(raw.title),
+    status: asString(raw.status),
+    joinedAt,
+    memberSince: asString(raw.memberSince ?? raw.member_since) || joinedAt,
+    sectionId,
+    sectionIds: sections.map((section) => section.id),
+    sections
+  };
+}
+function normalizeCurrentUserResponse(raw, configuredOrgId) {
+  const rawMemberships = asRecord(
+    raw.organizationMemberships ?? raw.organization_memberships
+  );
+  const organizationMemberships = Object.fromEntries(
+    Object.entries(rawMemberships).map(([organizationId2, membership]) => [
+      organizationId2,
+      normalizeMembership(membership)
+    ])
+  );
+  const allOrgIds = Array.from(
+    /* @__PURE__ */ new Set([
+      ...asStringArray(raw.allOrgIds ?? raw.all_org_ids),
+      ...Object.keys(organizationMemberships)
+    ])
+  );
+  const effectiveOrganizationId = asString(
+    raw.effectiveOrganizationId ?? raw.effective_org_id
+  );
+  const primaryOrganizationId = asString(
+    raw.organizationId ?? raw.primary_org_id ?? raw.org_id
+  );
+  const organizationId = effectiveOrganizationId || primaryOrganizationId || (organizationMemberships[configuredOrgId] ? configuredOrgId : null) || allOrgIds[0] || configuredOrgId;
+  const configuredMembership = organizationMemberships[configuredOrgId];
+  const firstName = asString(raw.firstName ?? raw.first_name ?? raw.given_name) || "";
+  const lastName = asString(raw.lastName ?? raw.last_name ?? raw.family_name) || "";
+  const email = asString(raw.email) || "";
+  const createdAt = asString(raw.createdAt ?? raw.created_at) || "";
+  const updatedAt = asString(raw.updatedAt ?? raw.updated_at) || createdAt;
+  const role = configuredMembership?.role || asString(raw.role) || "member";
+  const sectionId = configuredMembership?.sectionId || asString(raw.sectionId ?? raw.section_id);
+  const permissions = asStringArray(raw.permissions ?? raw.effective_permissions);
+  const metadata = asRecord(raw.metadata);
+  return {
+    id: asString(raw.id ?? raw.userId ?? raw.user_id ?? raw.sub) || "",
+    email,
+    name: asString(raw.name) || [firstName, lastName].filter(Boolean).join(" ") || email,
+    firstName,
+    lastName,
+    title: configuredMembership?.title ?? asString(raw.title),
+    phone: asString(raw.phone ?? raw.phoneNumber ?? raw.phone_number),
+    address: asString(raw.address ?? raw.location),
+    avatar: asString(raw.avatar ?? raw.avatarUrl ?? raw.avatar_url ?? raw.picture) || void 0,
+    organizationId,
+    ...sectionId ? { sectionId } : {},
+    role,
+    permissions,
+    ...Object.keys(metadata).length > 0 ? { metadata } : {},
+    createdAt,
+    updatedAt,
+    allOrgIds,
+    organizationMemberships,
+    effectiveOrganizationId,
+    isSuperAdmin: raw.isSuperAdmin === true || raw.is_super_admin === true || asString(raw.global_role) === "super_admin" || role === "super_admin"
+  };
+}
 function useUser() {
   const { isAuthenticated, isLoading: isAuthLoading, user: auth0User } = auth0React.useAuth0();
   const { client, stage, orgId } = useAxCloudContext();
+  const queryKey = currentUserQueryKey(stage, orgId, auth0User?.sub);
   const query = reactQuery.useQuery({
-    queryKey: ["axcloud", "user", "me", stage, orgId, auth0User?.sub],
+    queryKey,
     queryFn: async () => {
-      return client.get("/api/users/me");
+      const response = await client.get("/api/users/me");
+      return normalizeCurrentUserResponse(response, orgId);
     },
     enabled: isAuthenticated && !isAuthLoading,
     staleTime: 1e3 * 60 * 5
     // 5 minutes
   });
   const userData = query.data;
-  const userOrgIds = userData?.all_org_ids ?? [];
+  const userOrgIds = userData?.allOrgIds ?? [];
   const isSuperAdmin = userData?.isSuperAdmin === true;
-  const hasOrgAccess = userOrgIds.includes(orgId);
-  const orgMembership = userData?.organization_memberships?.[orgId];
+  const orgMembership = userData?.organizationMemberships?.[orgId];
+  const hasOrgAccess = userOrgIds.includes(orgId) && orgMembership?.status?.trim().toLowerCase() === "active";
   const roleInOrg = orgMembership?.role ?? null;
+  const sectionId = orgMembership?.sectionId ?? userData?.sectionId ?? null;
+  const sections = orgMembership?.sections?.length ? orgMembership.sections : sectionId ? [{ id: sectionId, name: sectionId, role: roleInOrg ?? "member" }] : [];
+  const section = sections.find((item) => item.id === sectionId) ?? sections[0] ?? null;
+  const memberSince = orgMembership?.memberSince ?? null;
   return {
     user: query.data ?? null,
     isLoading: isAuthLoading || query.isLoading,
@@ -1059,15 +1267,35 @@ function useUser() {
     // Organization access
     hasOrgAccess,
     roleInOrg,
+    organizationMembership: orgMembership ?? null,
+    title: orgMembership?.title ?? query.data?.title ?? null,
+    section,
+    sections,
+    sectionIds: orgMembership?.sectionIds?.length ? orgMembership.sectionIds : sectionId ? [sectionId] : [],
+    joinedAt: orgMembership?.joinedAt ?? null,
+    memberSince,
     // Convenience properties
     isAuthenticated,
-    role: query.data?.role ?? null,
+    role: roleInOrg ?? query.data?.role ?? null,
     organizationId: query.data?.organizationId ?? null,
-    sectionId: query.data?.sectionId ?? null,
+    sectionId,
     permissions: query.data?.permissions ?? [],
     isSuperAdmin
   };
 }
+function useUpdateMyProfile() {
+  const { client, stage } = useAxCloudContext();
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: (updates) => client.patch("/api/users/me/profile", updates),
+    onSuccess: async () => {
+      await queryClient.invalidateQueries({
+        queryKey: ["axcloud", "user", "me", stage],
+        exact: false
+      });
+    }
+  });
+}
 function useOrg() {
   const { client, orgId, stage, isPublicMode } = useAxCloudContext();
   const usePublicEndpoint = isPublicMode;
@@ -1114,152 +1342,169 @@ function useOrg() {
     modules
   };
 }
-function useNews(options = {}) {
-  const { client, orgId, isPublicMode } = useAxCloudContext();
-  const {
-    page = 1,
-    pageSize = 20,
-    status = "published",
-    visibility,
-    sectionId,
-    search,
-    sortBy = "publishedAt",
-    sortOrder = "desc",
-    lang,
-    publicOnly = false
-  } = options;
-  const usePublicEndpoint = isPublicMode || publicOnly;
-  const query = reactQuery.useQuery({
-    queryKey: [
-      "axcloud",
-      "news",
-      orgId,
-      usePublicEndpoint,
-      page,
-      pageSize,
-      status,
-      visibility,
-      sectionId,
-      search,
-      sortBy,
-      sortOrder,
-      lang
-    ],
-    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,
-        lang
-      });
-    },
-    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
-  };
+
+// src/react/contentQueryPolicy.ts
+var CONTENT_STALE_TIME_MS = 6e4;
+function shouldRetryContentRequest(failureCount, error) {
+  if (isAxCloudError(error) && error.status >= 400 && error.status < 500) {
+    return false;
+  }
+  return failureCount < 2;
+}
+function normalizeContentCollectionType(contentType) {
+  switch (contentType.toLowerCase()) {
+    case "news":
+      return "news";
+    case "page":
+    case "pages":
+      return "pages";
+    case "event":
+    case "events":
+      return "events";
+    default:
+      throw new Error(`Unsupported AxCloud content collection type: ${contentType}`);
+  }
+}
+function normalizeContentDetailType(contentType) {
+  switch (contentType.toLowerCase()) {
+    case "news":
+      return "news";
+    case "page":
+    case "pages":
+      return "page";
+    case "event":
+    case "events":
+      return "event";
+    default:
+      throw new Error(`Unsupported AxCloud content detail type: ${contentType}`);
+  }
 }
-var MEMBER_ENDPOINT_TYPES = ["news", "pages", "events"];
-var PAGE_CONTENT_TYPES = ["page", "pages"];
+function getContentAccessState(context, publicOnly) {
+  if (publicOnly) {
+    return { mode: "public", enabled: true, subject: "anonymous" };
+  }
+  const isLoading = context.isAuthLoading ?? false;
+  if (isLoading) {
+    return { mode: "pending", enabled: false, subject: "auth-loading" };
+  }
+  const hasExplicitAuthState = typeof context.isAuthenticated === "boolean";
+  const isAuthenticated = context.isAuthenticated ?? !context.isPublicMode;
+  if (!isAuthenticated) {
+    return { mode: "public", enabled: true, subject: "anonymous" };
+  }
+  if (hasExplicitAuthState && !context.authSubject) {
+    return { mode: "pending", enabled: false, subject: "auth-subject-pending" };
+  }
+  const subject = context.authSubject || "legacy-authenticated-session";
+  return { mode: "member", enabled: Boolean(subject), subject };
+}
+
+// src/react/hooks/useContent.ts
 function useContent(contentType, options = {}) {
-  const { client, orgId, isPublicMode } = useAxCloudContext();
+  const context = useAxCloudContext();
+  const { client, config, orgId, stage } = context;
+  const collectionType = normalizeContentCollectionType(contentType);
   const {
     publicOnly = false,
     page = 1,
     pageSize = 20,
-    status = "published",
-    visibility,
-    sectionId,
     search,
-    sortBy = "createdAt",
+    sortBy = collectionType === "news" ? "publishedAt" : "createdAt",
     sortOrder = "desc",
+    tags,
     lang
   } = options;
+  const access = getContentAccessState(context, publicOnly);
+  const deliveryScope = access.mode === "member" ? "members" : "public";
+  const params = {
+    page,
+    pageSize,
+    search,
+    sort: sortBy,
+    order: sortOrder,
+    tags: tags?.length ? tags.join(",") : void 0,
+    lang
+  };
   const query = reactQuery.useQuery({
     queryKey: [
       "axcloud",
       "content",
+      "collection",
+      stage,
+      config.apiUrl,
       orgId,
-      contentType,
-      isPublicMode,
-      publicOnly,
-      page,
-      pageSize,
-      status,
-      visibility,
-      sectionId,
-      search,
-      sortBy,
-      sortOrder,
-      lang
+      access.mode,
+      access.subject,
+      collectionType,
+      params
     ],
-    queryFn: async () => {
-      const useMemberEndpoint = !isPublicMode && !publicOnly && 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,
-        lang
-      });
-    },
-    staleTime: 1e3 * 60 * 5
-    // 5 minutes
+    queryFn: () => client.get(
+      `/content/${deliveryScope}/${orgId}/${collectionType}`,
+      params
+    ),
+    enabled: access.enabled,
+    staleTime: CONTENT_STALE_TIME_MS,
+    refetchOnWindowFocus: true,
+    retry: shouldRetryContentRequest
   });
+  const items = query.data?.items ?? [];
   return {
-    data: query.data?.items ?? [],
-    total: query.data?.total ?? 0,
+    data: items,
+    count: query.data?.count ?? items.length,
+    total: query.data?.total ?? items.length,
+    page: query.data?.page ?? page,
+    pageSize: query.data?.pageSize ?? pageSize,
     hasMore: query.data?.hasMore ?? false,
-    isLoading: query.isLoading,
+    nextCursor: query.data?.nextCursor,
+    isLoading: access.mode === "pending" || query.isLoading,
+    isFetching: query.isFetching,
     isError: query.isError,
     error: query.error,
     refetch: query.refetch
   };
 }
 function useContentItem(contentType, idOrSlug, options = {}) {
-  const { client, orgId, isPublicMode } = useAxCloudContext();
+  const context = useAxCloudContext();
+  const { client, config, orgId, stage } = context;
+  const detailType = normalizeContentDetailType(contentType);
   const { publicOnly = false, lang } = options;
-  const useMemberEndpoint = !isPublicMode && !publicOnly && (MEMBER_ENDPOINT_TYPES.includes(contentType) || PAGE_CONTENT_TYPES.includes(contentType));
+  const access = getContentAccessState(context, publicOnly);
+  const deliveryScope = access.mode === "member" ? "members" : "public";
   const query = reactQuery.useQuery({
-    queryKey: ["axcloud", "content", orgId, contentType, idOrSlug, useMemberEndpoint, lang],
-    queryFn: async () => {
-      const basePath = useMemberEndpoint ? "members" : "public";
+    queryKey: [
+      "axcloud",
+      "content",
+      "item",
+      stage,
+      config.apiUrl,
+      orgId,
+      access.mode,
+      access.subject,
+      detailType,
+      idOrSlug,
+      lang
+    ],
+    queryFn: () => {
       const encodedIdOrSlug = encodeURIComponent(idOrSlug);
-      const endpoint = PAGE_CONTENT_TYPES.includes(contentType) ? `/content/${basePath}/${orgId}/page/${encodedIdOrSlug}` : `/content/${basePath}/${orgId}/${contentType}/${encodedIdOrSlug}`;
+      const endpoint = `/content/${deliveryScope}/${orgId}/items/${detailType}/${encodedIdOrSlug}`;
       return lang ? client.get(endpoint, { lang }) : client.get(endpoint);
     },
-    enabled: !!idOrSlug,
-    staleTime: 1e3 * 60 * 5
-    // 5 minutes
+    enabled: access.enabled && Boolean(idOrSlug),
+    staleTime: CONTENT_STALE_TIME_MS,
+    refetchOnWindowFocus: true,
+    retry: shouldRetryContentRequest
   });
   return {
     data: query.data ?? null,
-    isLoading: query.isLoading,
+    isLoading: access.mode === "pending" || query.isLoading,
+    isFetching: query.isFetching,
     isError: query.isError,
     error: query.error,
     refetch: query.refetch
   };
 }
 function usePageContent(slug, options = {}) {
-  const state = useContentItem("pages", slug, options);
+  const state = useContentItem("page", slug, options);
   const reader = react.useMemo(() => createContentSlotReader(state.data), [state.data]);
   return {
     ...state,
@@ -1267,6 +1512,11 @@ function usePageContent(slug, options = {}) {
     ...reader
   };
 }
+
+// src/react/hooks/useNews.ts
+function useNews(options = {}) {
+  return useContent("news", options);
+}
 function useMySection(options = {}) {
   const { includeMembers = true } = options;
   const { isAuthenticated } = auth0React.useAuth0();
@@ -1905,7 +2155,7 @@ function ProtectedRoute({
   returnTo
 }) {
   const { isAuthenticated, isLoading: isAuthLoading, login } = useAuth();
-  const { user, role, isLoading: isUserLoading } = useUser();
+  const { role, isLoading: isUserLoading } = useUser();
   const isLoading = isAuthLoading || isAuthenticated && isUserLoading;
   if (isLoading) {
     return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: loadingComponent ?? /* @__PURE__ */ jsxRuntime.jsx(DefaultLoadingComponent, {}) });
@@ -1917,9 +2167,9 @@ function ProtectedRoute({
     }
     return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: unauthenticatedComponent ?? /* @__PURE__ */ jsxRuntime.jsx(DefaultUnauthenticatedComponent, {}) });
   }
-  if (roles && role) {
+  if (roles) {
     const requiredRoles = Array.isArray(roles) ? roles : [roles];
-    const hasRequiredRole = requiredRoles.includes(role);
+    const hasRequiredRole = role !== null && role !== void 0 && requiredRoles.includes(role);
     if (!hasRequiredRole) {
       return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: unauthorizedComponent ?? /* @__PURE__ */ jsxRuntime.jsx(DefaultUnauthorizedComponent, {}) });
     }
@@ -2155,6 +2405,7 @@ exports.usePageContent = usePageContent;
 exports.useSections = useSections;
 exports.useSubmitBarnsportInterest = useSubmitBarnsportInterest;
 exports.useUpdateFormSubmission = useUpdateFormSubmission;
+exports.useUpdateMyProfile = useUpdateMyProfile;
 exports.useUser = useUser;
 exports.userHasAllPermissions = userHasAllPermissions;
 exports.userHasAnyPermission = userHasAnyPermission;