@xyd-js/plugin-access-control 0.0.0-build-8804789-20260430104829

package/dist/client.d.ts

@@ -0,0 +1,167 @@
+import React from 'react';
+import { AccessControl } from '@xyd-js/core';
+
+type AccessLevel = "public" | "authenticated" | string;
+type AccessMap = Record<string, AccessLevel>;
+interface AccessEvaluation {
+    allowed: boolean;
+    reason: string;
+}
+/**
+ * Evaluate access for a specific page given its metadata and access control config.
+ * Returns the access level string for the access map.
+ */
+declare function resolvePageAccess(pagePath: string, metadata: {
+    public?: boolean;
+    accessGroups?: string[];
+}, config: AccessControl): AccessLevel;
+/**
+ * Evaluate whether a user has access to a page.
+ */
+declare function evaluateAccess(pagePath: string, accessMap: AccessMap, userGroups: string[]): AccessEvaluation;
+/**
+ * Build a complete access map from page path mapping and access control config.
+ * Used at build time to pre-compute access levels for all pages.
+ */
+declare function buildAccessMap(pagePathMapping: Record<string, string>, metadataMap: Record<string, {
+    public?: boolean;
+    accessGroups?: string[];
+}>, config: AccessControl): AccessMap;
+
+interface AuthState {
+    authenticated: boolean;
+    groups: string[];
+    token: string | null;
+}
+declare global {
+    interface Window {
+        __xydAuthState?: AuthState;
+        __xydAuthDebug?: any;
+    }
+}
+interface AuthGuardProps {
+    children: React.ReactNode;
+    accessMap: Record<string, string>;
+    config: {
+        provider: {
+            type: string;
+            loginUrl?: string;
+        };
+        unauthorizedBehavior?: "redirect" | "404";
+        session?: {
+            cookieName?: string;
+        };
+    };
+}
+/**
+ * AuthGuard wraps the application and enforces access control.
+ * It reads auth state from window.__xydAuthState (set by pre-hydration script)
+ * and checks the access map for the current route.
+ */
+declare function AuthGuard({ children, accessMap, config }: AuthGuardProps): React.JSX.Element;
+/**
+ * Hook to access authentication state.
+ */
+declare function useAuth(): AuthState & {
+    login: () => void;
+    logout: () => void;
+};
+
+/**
+ * Default login page. Wraps itself with AccessControlProvider
+ * so it works regardless of the host wrapper.
+ */
+declare function LoginPage(): React.JSX.Element;
+
+/**
+ * Handles both JWT and OAuth callback flows:
+ *
+ * JWT:   /auth/jwt-callback#eyJ...  → extract token from hash
+ * OAuth: /auth/callback?code=XXX&state=/page → exchange code for token
+ */
+declare function AuthCallbackPage(): React.JSX.Element;
+
+interface AccessControlActions {
+    /** Current auth config from docs.json */
+    config: any | null;
+    /** Whether config has loaded */
+    ready: boolean;
+    /** Last error message */
+    error: string;
+    /** Clear error */
+    clearError: () => void;
+    /** Redirect to external OAuth provider */
+    signInWithOAuth: () => void;
+    /** Redirect to external JWT login URL */
+    signInWithRedirect: () => void;
+    /** Sign in with test token (dev/edge server) */
+    signInAsUser: () => void;
+    /** Sign in as admin with test token (dev/edge server) */
+    signInAsAdmin: () => void;
+    /** Sign in with specific groups */
+    signInWithGroups: (groups: string[]) => void;
+    /** Provider type: "jwt" | "oauth" */
+    providerType: string;
+    /** Whether an external auth URL is configured */
+    hasExternalAuth: boolean;
+    /** Login page title from config */
+    title: string;
+    /** Login page description from config */
+    description: string;
+    /** Login page logo URL from config */
+    logo: string;
+    /** Login page background image from config */
+    backgroundImage: string;
+    /** The redirect URL (where to go after login) */
+    redirectUrl: string;
+}
+/**
+ * Hook to access auth actions in custom login pages.
+ *
+ * @example
+ * ```tsx
+ * import { useAccessControl } from "@xyd-js/plugin-access-control"
+ *
+ * function MyLoginPage() {
+ *   const { signInWithOAuth, title, logo, error } = useAccessControl()
+ *
+ *   return (
+ *     <div>
+ *       {logo && <img src={logo} />}
+ *       <h1>{title}</h1>
+ *       {error && <p>{error}</p>}
+ *       <button onClick={signInWithOAuth}>Sign in</button>
+ *     </div>
+ *   )
+ * }
+ * ```
+ */
+declare function useAccessControl(): AccessControlActions;
+declare function AccessControlProvider({ children }: {
+    children: React.ReactNode;
+}): React.JSX.Element;
+
+interface SidebarItem {
+    title: string;
+    href: string;
+    items?: SidebarItem[];
+    [key: string]: any;
+}
+interface SidebarGroup {
+    group: string;
+    groupIndex: number;
+    items: SidebarItem[];
+    icon?: string;
+    [key: string]: any;
+}
+/**
+ * Filters sidebar navigation groups to hide pages the user cannot access.
+ * This runs at runtime in the browser based on the user's auth state.
+ */
+declare function filterSidebarGroups(sidebarGroups: SidebarGroup[], accessMap: AccessMap, userGroups: string[]): SidebarGroup[];
+/**
+ * Filters an array of paths (used for sitemap/llms.txt) to exclude protected pages.
+ */
+declare function filterProtectedPaths(paths: string[], accessMap: AccessMap): string[];
+
+export { type AccessControlActions, AccessControlProvider, type AccessEvaluation, type AccessLevel, type AccessMap, AuthCallbackPage, AuthGuard, LoginPage, buildAccessMap, evaluateAccess, filterProtectedPaths, filterSidebarGroups, resolvePageAccess, useAccessControl, useAuth };

package/dist/client.js

@@ -0,0 +1,484 @@
+// src/components/AccessControlContext.tsx
+import React, { createContext, useContext, useEffect, useState, useCallback } from "react";
+
+// src/devOnly.ts
+function isDevEnvironment() {
+  if (typeof window === "undefined") {
+    return process.env.NODE_ENV !== "production";
+  }
+  try {
+    return !!import.meta.env?.DEV;
+  } catch {
+    return false;
+  }
+}
+
+// src/components/AccessControlContext.tsx
+var AccessControlCtx = createContext(null);
+function useAccessControl() {
+  const ctx = useContext(AccessControlCtx);
+  if (!ctx) {
+    throw new Error("useAccessControl must be used inside <AccessControlProvider>");
+  }
+  return ctx;
+}
+function AccessControlProvider({ children }) {
+  const [config, setConfig] = useState(null);
+  const [error, setError] = useState("");
+  const [ready, setReady] = useState(false);
+  useEffect(() => {
+    const globalConfig = window.__xydAccessControlSettings?.accessControlConfig;
+    if (globalConfig) {
+      setConfig(globalConfig);
+      setReady(true);
+      return;
+    }
+    import("virtual:xyd-access-control-settings").then((mod) => {
+      setConfig(mod.accessControlConfig);
+      setReady(true);
+    }).catch(() => setReady(true));
+  }, []);
+  const providerType = config?.provider?.type || "jwt";
+  const loginUrl = config?.provider?.loginUrl || "";
+  const authorizationUrl = config?.provider?.authorizationUrl || "";
+  const hasExternalAuth = providerType === "oauth" ? !!authorizationUrl : !!loginUrl && loginUrl !== "/login";
+  const loginConfig = typeof config?.login === "string" ? {} : config?.login || {};
+  const title = loginConfig.title || "Sign in to access documentation";
+  const description = loginConfig.description || "";
+  const logo = loginConfig.logo || "";
+  const backgroundImage = loginConfig.backgroundImage || "";
+  const params = typeof window !== "undefined" ? new URLSearchParams(window.location.search) : null;
+  const redirectUrl = params?.get("redirect") || "/";
+  const storeTokenAndRedirect = useCallback((token) => {
+    const cookieName = config?.session?.cookieName || "xyd-auth-token";
+    localStorage.setItem(cookieName, token);
+    document.cookie = `${cookieName}=${token}; path=/; max-age=86400; SameSite=Lax`;
+    window.location.href = redirectUrl;
+  }, [config, redirectUrl]);
+  const signInWithOAuth = useCallback(() => {
+    if (!authorizationUrl) {
+      setError("No OAuth authorization URL configured");
+      return;
+    }
+    const callbackPath = config?.provider?.callbackPath || "/auth/callback";
+    const redirectUri = window.location.origin + callbackPath;
+    const scopes = config?.provider?.scopes || [];
+    const clientId = config?.provider?.clientId || "";
+    const oauthParams = new URLSearchParams({
+      client_id: clientId,
+      redirect_uri: redirectUri,
+      response_type: "code",
+      scope: scopes.join(" "),
+      state: redirectUrl
+    });
+    window.location.href = `${authorizationUrl}?${oauthParams.toString()}`;
+  }, [config, authorizationUrl, redirectUrl]);
+  const signInWithRedirect = useCallback(() => {
+    if (!loginUrl || loginUrl === "/login") {
+      setError("No external login URL configured");
+      return;
+    }
+    const sep = loginUrl.includes("?") ? "&" : "?";
+    window.location.href = `${loginUrl}${sep}redirect=${encodeURIComponent(redirectUrl)}`;
+  }, [loginUrl, redirectUrl]);
+  const signInWithGroups = useCallback((groups) => {
+    const hasDeploy = !!config?.deploy;
+    if (hasDeploy) {
+      const groupsParam = groups.length ? `&groups=${groups.join(",")}` : "";
+      window.location.href = `/auth/test-login?redirect=${encodeURIComponent(redirectUrl)}${groupsParam}`;
+      return;
+    }
+    if (!isDevEnvironment()) {
+      setError("Test login is only available in development mode.");
+      return;
+    }
+    const header = btoa(JSON.stringify({ alg: "HS256", typ: "JWT" }));
+    const payload = btoa(JSON.stringify({
+      sub: "test-user",
+      groups,
+      exp: Math.floor(Date.now() / 1e3) + 86400,
+      iat: Math.floor(Date.now() / 1e3)
+    }));
+    storeTokenAndRedirect(`${header}.${payload}.dGVzdA`);
+  }, [config, redirectUrl, storeTokenAndRedirect]);
+  const signInAsUser = useCallback(() => signInWithGroups([]), [signInWithGroups]);
+  const signInAsAdmin = useCallback(() => signInWithGroups(["admin"]), [signInWithGroups]);
+  const value = {
+    config,
+    ready,
+    error,
+    clearError: () => setError(""),
+    signInWithOAuth,
+    signInWithRedirect,
+    signInAsUser,
+    signInAsAdmin,
+    signInWithGroups,
+    providerType,
+    hasExternalAuth,
+    title,
+    description,
+    logo,
+    backgroundImage,
+    redirectUrl
+  };
+  return /* @__PURE__ */ React.createElement(AccessControlCtx.Provider, { value }, children);
+}
+
+// src/components/AuthGuard.tsx
+import React2, {
+  createContext as createContext2,
+  useContext as useContext2,
+  useEffect as useEffect2,
+  useState as useState2,
+  useMemo
+} from "react";
+var AuthContext = createContext2({
+  authenticated: false,
+  groups: [],
+  token: null
+});
+function buildLoginUrl(loginUrl, returnPath) {
+  const separator = loginUrl.includes("?") ? "&" : "?";
+  return `${loginUrl}${separator}redirect=${encodeURIComponent(returnPath)}`;
+}
+function AuthGuard({ children, accessMap, config }) {
+  const [authState, setAuthState] = useState2(() => {
+    if (typeof window !== "undefined" && window.__xydAuthState) {
+      return window.__xydAuthState;
+    }
+    return { authenticated: false, groups: [], token: null };
+  });
+  useEffect2(() => {
+    const handleStorage = (e) => {
+      const cookieName = config.session?.cookieName || "xyd-auth-token";
+      if (e.key === cookieName) {
+        if (e.newValue) {
+          try {
+            const payload = JSON.parse(atob(e.newValue.split(".")[1]));
+            setAuthState({
+              authenticated: true,
+              groups: payload.groups || [],
+              token: e.newValue
+            });
+          } catch {
+            setAuthState({ authenticated: false, groups: [], token: null });
+          }
+        } else {
+          setAuthState({ authenticated: false, groups: [], token: null });
+        }
+      }
+    };
+    window.addEventListener("storage", handleStorage);
+    return () => window.removeEventListener("storage", handleStorage);
+  }, [config.session?.cookieName]);
+  const value = useMemo(() => authState, [authState]);
+  return /* @__PURE__ */ React2.createElement(AuthContext.Provider, { value }, /* @__PURE__ */ React2.createElement(AuthEnforcer, { accessMap, config }, children));
+}
+function AuthEnforcer({
+  children,
+  accessMap,
+  config
+}) {
+  const authState = useContext2(AuthContext);
+  useEffect2(() => {
+    if (typeof window === "undefined") return;
+    const pathname = window.location.pathname;
+    const pageAccess = accessMap[pathname];
+    if (!pageAccess || pageAccess === "public") return;
+    if (!authState.authenticated) {
+      const loginUrl = config.provider.loginUrl;
+      if (loginUrl) {
+        window.location.href = buildLoginUrl(loginUrl, pathname);
+      }
+      return;
+    }
+    if (pageAccess !== "authenticated") {
+      const requiredGroups = pageAccess.split(",");
+      const hasAccess = requiredGroups.some(
+        (g) => authState.groups.includes(g)
+      );
+      if (!hasAccess) {
+        if (config.unauthorizedBehavior === "404") {
+          window.location.href = "/404";
+        } else {
+          const loginUrl = config.provider.loginUrl;
+          if (loginUrl) {
+            window.location.href = buildLoginUrl(loginUrl, pathname);
+          }
+        }
+      }
+    }
+  }, [authState, accessMap, config]);
+  return /* @__PURE__ */ React2.createElement(React2.Fragment, null, children);
+}
+function useAuth() {
+  const state = useContext2(AuthContext);
+  return {
+    ...state,
+    login() {
+      console.warn("[xyd:access-control] login() called without config");
+    },
+    logout() {
+      if (typeof window === "undefined") return;
+      const cookieName = "xyd-auth-token";
+      localStorage.removeItem(cookieName);
+      document.cookie = `${cookieName}=; expires=Thu, 01 Jan 1970 00:00:00 GMT; path=/`;
+      document.cookie = `${cookieName}-state=; expires=Thu, 01 Jan 1970 00:00:00 GMT; path=/`;
+      window.__xydAuthState = {
+        authenticated: false,
+        groups: [],
+        token: null
+      };
+      document.documentElement.setAttribute("data-auth", "anonymous");
+      window.location.reload();
+    }
+  };
+}
+
+// src/components/LoginPage.tsx
+import React3 from "react";
+function LoginPage() {
+  return /* @__PURE__ */ React3.createElement(AccessControlProvider, null, /* @__PURE__ */ React3.createElement(LoginPageUI, null));
+}
+function LoginPageUI() {
+  const {
+    providerType,
+    hasExternalAuth,
+    title,
+    description,
+    logo,
+    backgroundImage,
+    error,
+    signInWithOAuth,
+    signInWithRedirect,
+    signInAsUser,
+    signInAsAdmin
+  } = useAccessControl();
+  const handleSignIn = () => {
+    if (providerType === "oauth") signInWithOAuth();
+    else signInWithRedirect();
+  };
+  const bgOverride = backgroundImage ? { backgroundImage: `url(${backgroundImage})`, backgroundSize: "cover", backgroundPosition: "center", background: "none" } : void 0;
+  return /* @__PURE__ */ React3.createElement("div", { className: "xyd-login-page", style: bgOverride }, /* @__PURE__ */ React3.createElement("div", { part: "card" }, logo && /* @__PURE__ */ React3.createElement("img", { part: "logo", src: logo, alt: "" }), /* @__PURE__ */ React3.createElement("h1", { part: "title" }, title), description && /* @__PURE__ */ React3.createElement("p", { part: "description" }, description), error && /* @__PURE__ */ React3.createElement("p", { part: "error" }, error), hasExternalAuth ? /* @__PURE__ */ React3.createElement("button", { part: "button", onClick: handleSignIn }, "Sign in") : /* @__PURE__ */ React3.createElement("div", { part: "actions" }, /* @__PURE__ */ React3.createElement("button", { part: "button", onClick: signInAsUser }, "Sign in as User"), /* @__PURE__ */ React3.createElement("button", { part: "button", "data-kind": "secondary", onClick: signInAsAdmin }, "Sign in as Admin"))));
+}
+
+// src/components/AuthCallbackPage.tsx
+import React4, { useEffect as useEffect3, useState as useState3 } from "react";
+function AuthCallbackPage() {
+  const [error, setError] = useState3("");
+  useEffect3(() => {
+    if (typeof window === "undefined") return;
+    import("virtual:xyd-access-control-settings").then((mod) => {
+      const config = mod.accessControlConfig;
+      handleCallback(config);
+    }).catch(() => {
+      handleCallback(null);
+    });
+  }, []);
+  function storeTokenAndRedirect(token, groups, redirect, cookieName) {
+    localStorage.setItem(cookieName, token);
+    document.cookie = `${cookieName}=${token}; path=/; max-age=86400; SameSite=Lax`;
+    window.__xydAuthState = {
+      authenticated: true,
+      groups,
+      token
+    };
+    document.documentElement.setAttribute("data-auth", "authenticated");
+    window.location.href = redirect;
+  }
+  async function handleCallback(config) {
+    const params = new URLSearchParams(window.location.search);
+    const hash = window.location.hash.slice(1);
+    const code = params.get("code");
+    const state = params.get("state") || "/";
+    const cookieName = config?.session?.cookieName || "xyd-auth-token";
+    const groupsClaim = config?.provider?.groupsClaim || "groups";
+    if (code && config?.provider?.type === "oauth") {
+      try {
+        await handleOAuthCallback(code, state, config, cookieName, groupsClaim);
+      } catch (e) {
+        setError(e instanceof Error ? e.message : "OAuth authentication failed");
+      }
+      return;
+    }
+    const token = params.get("token") || hash;
+    const redirect = params.get("redirect") || state;
+    if (token) {
+      try {
+        handleJWTCallback(token, redirect, cookieName, groupsClaim);
+      } catch (e) {
+        setError(e instanceof Error ? e.message : "JWT authentication failed");
+      }
+      return;
+    }
+    setError("No authentication data found in callback URL.");
+  }
+  function handleJWTCallback(hash, redirect, cookieName, groupsClaim) {
+    const parts = hash.split(".");
+    if (parts.length !== 3) throw new Error("Invalid JWT format");
+    const payload = JSON.parse(atob(parts[1]));
+    if (payload.exp && payload.exp * 1e3 < Date.now()) {
+      throw new Error("Token has expired");
+    }
+    storeTokenAndRedirect(hash, payload[groupsClaim] || [], redirect, cookieName);
+  }
+  async function handleOAuthCallback(code, redirect, config, cookieName, groupsClaim) {
+    const tokenUrl = config.provider.tokenUrl;
+    const userInfoUrl = config.provider.userInfoUrl;
+    const clientId = config.provider.clientId || "";
+    const callbackPath = config.provider.callbackPath || "/auth/callback";
+    const redirectUri = window.location.origin + callbackPath;
+    if (!tokenUrl) throw new Error("No token URL configured");
+    const tokenRes = await fetch(tokenUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: new URLSearchParams({
+        grant_type: "authorization_code",
+        code,
+        client_id: clientId,
+        redirect_uri: redirectUri
+      }).toString()
+    });
+    if (!tokenRes.ok) {
+      throw new Error(`Token exchange failed: ${tokenRes.status}`);
+    }
+    const tokenData = await tokenRes.json();
+    const accessToken = tokenData.access_token;
+    if (!accessToken) throw new Error("No access token in response");
+    let groups = [];
+    if (userInfoUrl) {
+      try {
+        const userRes = await fetch(userInfoUrl, {
+          headers: { Authorization: `Bearer ${accessToken}` }
+        });
+        if (userRes.ok) {
+          const userInfo = await userRes.json();
+          groups = userInfo[groupsClaim] || userInfo.roles || userInfo.groups || [];
+        }
+      } catch {
+      }
+    }
+    const header = btoa(JSON.stringify({ alg: "HS256", typ: "JWT" }));
+    const payload = btoa(JSON.stringify({
+      sub: "oauth-user",
+      [groupsClaim]: groups,
+      exp: Math.floor(Date.now() / 1e3) + 86400,
+      iat: Math.floor(Date.now() / 1e3),
+      access_token: accessToken
+    }));
+    const sessionToken = `${header}.${payload}.oauth`;
+    storeTokenAndRedirect(sessionToken, groups, redirect, cookieName);
+  }
+  if (error) {
+    return /* @__PURE__ */ React4.createElement("div", { className: "xyd-callback-page" }, /* @__PURE__ */ React4.createElement("div", { part: "card" }, /* @__PURE__ */ React4.createElement("h2", { part: "title", "data-error": "" }, "Authentication Error"), /* @__PURE__ */ React4.createElement("p", { part: "message" }, error), /* @__PURE__ */ React4.createElement("button", { part: "button", onClick: () => window.location.href = "/" }, "Go to homepage")));
+  }
+  return /* @__PURE__ */ React4.createElement("div", { className: "xyd-callback-page" }, /* @__PURE__ */ React4.createElement("div", { part: "card" }, /* @__PURE__ */ React4.createElement("p", { part: "message" }, "Authenticating...")));
+}
+
+// src/access.ts
+function matchPattern(pattern, path) {
+  const regexStr = pattern.replace(/\*\*/g, "___GLOBSTAR___").replace(/\*/g, "[^/]*").replace(/___GLOBSTAR___/g, ".*");
+  const regex = new RegExp(`^${regexStr}$`);
+  return regex.test(path);
+}
+function resolvePageAccess(pagePath, metadata, config) {
+  const normalizedPath = pagePath.startsWith("/") ? pagePath : `/${pagePath}`;
+  if (metadata.public === true) {
+    return "public";
+  }
+  if (metadata.public === false) {
+    if (metadata.accessGroups?.length) {
+      return metadata.accessGroups.join(",");
+    }
+    return "authenticated";
+  }
+  if (config.rules) {
+    for (const rule of config.rules) {
+      if (matchPattern(rule.match, normalizedPath)) {
+        if (rule.access === "public") {
+          return "public";
+        }
+        if (rule.groups?.length) {
+          return rule.groups.join(",");
+        }
+        return "authenticated";
+      }
+    }
+  }
+  return config.defaultAccess === "protected" ? "authenticated" : "public";
+}
+function evaluateAccess(pagePath, accessMap, userGroups) {
+  const access = accessMap[pagePath];
+  if (!access || access === "public") {
+    return { allowed: true, reason: `access:public` };
+  }
+  if (access === "authenticated") {
+    return {
+      allowed: userGroups.length > 0 || false,
+      reason: "access:authenticated"
+    };
+  }
+  const requiredGroups = access.split(",");
+  const hasGroup = requiredGroups.some((g) => userGroups.includes(g));
+  return {
+    allowed: hasGroup,
+    reason: `access:groups:${access}`
+  };
+}
+function buildAccessMap(pagePathMapping, metadataMap, config) {
+  const accessMap = {};
+  for (const pagePath of Object.keys(pagePathMapping)) {
+    const metadata = metadataMap[pagePath] || {};
+    accessMap[pagePath] = resolvePageAccess(pagePath, metadata, config);
+  }
+  return accessMap;
+}
+
+// src/navigation.ts
+function filterSidebarGroups(sidebarGroups, accessMap, userGroups) {
+  return sidebarGroups.map((group) => ({
+    ...group,
+    items: filterItems(group.items, accessMap, userGroups)
+  })).filter((group) => group.items.length > 0);
+}
+function filterItems(items, accessMap, userGroups) {
+  return items.filter((item) => {
+    const href = item.href;
+    if (!href) return true;
+    const normalizedHref = href.startsWith("/") ? href : `/${href}`;
+    const access = accessMap[normalizedHref] || accessMap[href];
+    if (!access || access === "public") return true;
+    if (access === "authenticated") return userGroups.length > 0;
+    const requiredGroups = access.split(",");
+    return requiredGroups.some((g) => userGroups.includes(g));
+  }).map((item) => {
+    if (item.items?.length) {
+      return {
+        ...item,
+        items: filterItems(item.items, accessMap, userGroups)
+      };
+    }
+    return item;
+  });
+}
+function filterProtectedPaths(paths, accessMap) {
+  return paths.filter((p) => {
+    const normalizedPath = p.startsWith("/") ? p : `/${p}`;
+    const access = accessMap[normalizedPath] || accessMap[p];
+    return !access || access === "public";
+  });
+}
+export {
+  AccessControlProvider,
+  AuthCallbackPage,
+  AuthGuard,
+  LoginPage,
+  buildAccessMap,
+  evaluateAccess,
+  filterProtectedPaths,
+  filterSidebarGroups,
+  resolvePageAccess,
+  useAccessControl,
+  useAuth
+};
+//# sourceMappingURL=client.js.map