@cedarjs/router 0.0.4

package/dist/analyzeRoutes.js

@@ -0,0 +1,128 @@
+import { Children } from "react";
+import {
+  isNotFoundRoute,
+  isRedirectRoute,
+  isStandardRoute,
+  isValidRoute
+} from "./route-validators.js";
+import { isPrivateNode, isPrivateSetNode, isSetNode } from "./Set.js";
+import {
+  matchPath,
+  replaceParams,
+  validatePath
+} from "./util.js";
+function analyzeRoutes(children, { currentPathName, userParamTypes }) {
+  const pathRouteMap = {};
+  const namedRoutesMap = {};
+  let hasRootRoute = false;
+  let NotFoundPage;
+  let activeRoutePath;
+  const recurseThroughRouter = ({
+    nodes,
+    whileLoadingPageFromSet,
+    sets: previousSets = []
+  }) => {
+    let nextSetId = 0;
+    nodes.forEach((node) => {
+      if (isValidRoute(node)) {
+        const route = node;
+        if (isNotFoundRoute(route)) {
+          NotFoundPage = route.props.page;
+          return;
+        }
+        if (route.props.path === "/") {
+          hasRootRoute = true;
+        }
+        if (isRedirectRoute(route)) {
+          const { name, redirect, path } = route.props;
+          validatePath(path, name || path);
+          const { match } = matchPath(path, currentPathName, {
+            userParamTypes
+          });
+          if (match && !activeRoutePath) {
+            activeRoutePath = path;
+          }
+          pathRouteMap[path] = {
+            redirect,
+            name: name || null,
+            path,
+            page: null,
+            // Redirects don't need pages. We set this to null for consistency
+            sets: previousSets
+          };
+          if (name) {
+            namedRoutesMap[name] = (args = {}) => replaceParams(path, args);
+          }
+        }
+        if (isStandardRoute(route)) {
+          const { name, path, page } = route.props;
+          validatePath(path, name);
+          const { match } = matchPath(path, currentPathName, {
+            userParamTypes
+          });
+          if (match && !activeRoutePath) {
+            activeRoutePath = path;
+          }
+          pathRouteMap[path] = {
+            redirect: null,
+            name,
+            path,
+            whileLoadingPage: route.props.whileLoadingPage || whileLoadingPageFromSet,
+            page,
+            sets: previousSets
+          };
+          namedRoutesMap[name] = (args = {}) => replaceParams(path, args);
+        }
+      }
+      if (isSetNode(node)) {
+        const {
+          children: children2,
+          whileLoadingPage: whileLoadingPageFromCurrentSet,
+          wrap: wrapFromCurrentSet,
+          ...otherPropsFromCurrentSet
+        } = node.props;
+        let wrapperComponentsArray = [];
+        if (wrapFromCurrentSet) {
+          wrapperComponentsArray = Array.isArray(wrapFromCurrentSet) ? wrapFromCurrentSet : [wrapFromCurrentSet];
+        }
+        nextSetId = nextSetId + 1;
+        recurseThroughRouter({
+          nodes: Children.toArray(children2),
+          // When there's a whileLoadingPage prop on a Set, we pass it down to all its children
+          // If the parent node was also a Set with whileLoadingPage, we pass it down. The child's whileLoadingPage
+          // will always take precedence over the parent's
+          whileLoadingPageFromSet: whileLoadingPageFromCurrentSet || whileLoadingPageFromSet,
+          sets: [
+            ...previousSets,
+            {
+              id: createSetId(nextSetId, previousSets),
+              wrappers: wrapperComponentsArray,
+              isPrivate: isPrivateSetNode(node) || // The following two conditions can be removed when we remove
+              // the deprecated private prop
+              isPrivateNode(node) || !!otherPropsFromCurrentSet.private,
+              props: otherPropsFromCurrentSet
+            }
+          ]
+        });
+      }
+    });
+  };
+  recurseThroughRouter({ nodes: Children.toArray(children) });
+  return {
+    pathRouteMap,
+    namedRoutesMap,
+    hasRootRoute,
+    NotFoundPage,
+    activeRoutePath
+  };
+}
+function createSetId(nextSetId, previousSets) {
+  const firstLevel = previousSets.length === 0;
+  if (firstLevel) {
+    return nextSetId.toString();
+  }
+  return previousSets.at(-1)?.id + "." + nextSetId;
+}
+export {
+  analyzeRoutes
+};

package/dist/cjs/ActivePageContext.d.ts

@@ -0,0 +1,15 @@
+import type { LocationContextType } from './location.js';
+export type LoadingState = 'PRE_SHOW' | 'SHOW_LOADING' | 'DONE';
+export type LoadingStateRecord = Record<string, {
+    specName: string;
+    state: LoadingState;
+    page: React.ComponentType<unknown>;
+    location: LocationContextType;
+} | undefined>;
+interface ActivePageState {
+    loadingState: LoadingStateRecord;
+}
+export declare const ActivePageContextProvider: import("react").Provider<ActivePageState | undefined>;
+export declare const useActivePageContext: () => ActivePageState;
+export {};
+//# sourceMappingURL=ActivePageContext.d.ts.map

package/dist/cjs/ActivePageContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ActivePageContext.d.ts","sourceRoot":"","sources":["../../src/ActivePageContext.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAA;AAExD,MAAM,MAAM,YAAY,GAAG,UAAU,GAAG,cAAc,GAAG,MAAM,CAAA;AAC/D,MAAM,MAAM,kBAAkB,GAAG,MAAM,CACrC,MAAM,EACJ;IACE,QAAQ,EAAE,MAAM,CAAA;IAChB,KAAK,EAAE,YAAY,CAAA;IACnB,IAAI,EAAE,KAAK,CAAC,aAAa,CAAC,OAAO,CAAC,CAAA;IAClC,QAAQ,EAAE,mBAAmB,CAAA;CAC9B,GACD,SAAS,CACZ,CAAA;AAED,UAAU,eAAe;IACvB,YAAY,EAAE,kBAAkB,CAAA;CACjC;AAID,eAAO,MAAM,yBAAyB,uDAA6B,CAAA;AAEnE,eAAO,MAAM,oBAAoB,uBAUhC,CAAA"}

package/dist/cjs/ActivePageContext.js

@@ -0,0 +1,42 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ActivePageContext_exports = {};
+__export(ActivePageContext_exports, {
+  ActivePageContextProvider: () => ActivePageContextProvider,
+  useActivePageContext: () => useActivePageContext
+});
+module.exports = __toCommonJS(ActivePageContext_exports);
+var import_react = require("react");
+var import_createNamedContext = require("./createNamedContext.js");
+const ActivePageContext = (0, import_createNamedContext.createNamedContext)("ActivePage");
+const ActivePageContextProvider = ActivePageContext.Provider;
+const useActivePageContext = () => {
+  const activePageContext = (0, import_react.useContext)(ActivePageContext);
+  if (!activePageContext) {
+    throw new Error(
+      "useActivePageContext must be used within a ActivePageContext provider"
+    );
+  }
+  return activePageContext;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ActivePageContextProvider,
+  useActivePageContext
+});

package/dist/cjs/AuthenticatedRoute.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import type { GeneratedRoutesMap } from './analyzeRoutes.js';
+interface AuthenticatedRouteProps {
+    children: React.ReactNode | Thenable<React.ReactNode>;
+    roles?: string | string[];
+    unauthenticated: keyof GeneratedRoutesMap;
+    whileLoadingAuth?: () => React.ReactElement | null;
+}
+export declare const AuthenticatedRoute: React.FC<AuthenticatedRouteProps>;
+export {};
+//# sourceMappingURL=AuthenticatedRoute.d.ts.map

package/dist/cjs/AuthenticatedRoute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AuthenticatedRoute.d.ts","sourceRoot":"","sources":["../../src/AuthenticatedRoute.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAsB,MAAM,OAAO,CAAA;AAE1C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAA;AAK5D,UAAU,uBAAuB;IAC/B,QAAQ,EAAE,KAAK,CAAC,SAAS,GAAG,QAAQ,CAAC,KAAK,CAAC,SAAS,CAAC,CAAA;IACrD,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;IACzB,eAAe,EAAE,MAAM,kBAAkB,CAAA;IACzC,gBAAgB,CAAC,EAAE,MAAM,KAAK,CAAC,YAAY,GAAG,IAAI,CAAA;CACnD;AAED,eAAO,MAAM,kBAAkB,EAAE,KAAK,CAAC,EAAE,CAAC,uBAAuB,CA6DhE,CAAA"}

package/dist/cjs/AuthenticatedRoute.js

@@ -0,0 +1,83 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var AuthenticatedRoute_exports = {};
+__export(AuthenticatedRoute_exports, {
+  AuthenticatedRoute: () => AuthenticatedRoute
+});
+module.exports = __toCommonJS(AuthenticatedRoute_exports);
+var import_react = __toESM(require("react"), 1);
+var import_namedRoutes = require("./namedRoutes.js");
+var import_redirect = require("./redirect.js");
+var import_router_context = require("./router-context.js");
+const AuthenticatedRoute = ({
+  unauthenticated,
+  roles,
+  whileLoadingAuth,
+  children
+}) => {
+  const routerState = (0, import_router_context.useRouterState)();
+  const {
+    loading: authLoading,
+    isAuthenticated,
+    hasRole
+  } = routerState.useAuth();
+  const unauthorized = (0, import_react.useCallback)(() => {
+    return !(isAuthenticated && (!roles || hasRole(roles)));
+  }, [isAuthenticated, roles, hasRole]);
+  if (unauthorized()) {
+    if (authLoading) {
+      return whileLoadingAuth?.() || null;
+    } else {
+      const currentLocation = globalThis.location.pathname + encodeURIComponent(globalThis.location.search);
+      const generatedRoutesMap = import_namedRoutes.namedRoutes;
+      if (!generatedRoutesMap[unauthenticated]) {
+        throw new Error(`We could not find a route named ${unauthenticated}`);
+      }
+      let unauthenticatedPath;
+      try {
+        unauthenticatedPath = generatedRoutesMap[unauthenticated]();
+      } catch (e) {
+        if (e instanceof Error && /Missing parameter .* for route/.test(e.message)) {
+          throw new Error(
+            `Redirecting to route "${unauthenticated}" would require route parameters, which currently is not supported. Please choose a different route`
+          );
+        }
+        throw new Error(
+          `Could not redirect to the route named ${unauthenticated}`
+        );
+      }
+      return /* @__PURE__ */ import_react.default.createElement(import_redirect.Redirect, { to: `${unauthenticatedPath}?redirectTo=${currentLocation}` });
+    }
+  }
+  return /* @__PURE__ */ import_react.default.createElement(import_react.default.Fragment, null, children);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AuthenticatedRoute
+});

package/dist/cjs/PageLoadingContext.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+export interface PageLoadingContextInterface {
+    loading: boolean;
+    setPageLoadingContext: (loading: boolean) => void;
+    delay?: number;
+}
+interface Props {
+    children: React.ReactNode;
+    delay?: number;
+}
+export declare const PageLoadingContextProvider: React.FC<Props>;
+export declare const usePageLoadingContext: () => PageLoadingContextInterface;
+export {};
+//# sourceMappingURL=PageLoadingContext.d.ts.map

package/dist/cjs/PageLoadingContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PageLoadingContext.d.ts","sourceRoot":"","sources":["../../src/PageLoadingContext.tsx"],"names":[],"mappings":"AAAA,OAAO,KAA+B,MAAM,OAAO,CAAA;AAInD,MAAM,WAAW,2BAA2B;IAC1C,OAAO,EAAE,OAAO,CAAA;IAChB,qBAAqB,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAA;IACjD,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAKD,UAAU,KAAK;IACb,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;IACzB,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAED,eAAO,MAAM,0BAA0B,EAAE,KAAK,CAAC,EAAE,CAAC,KAAK,CAatD,CAAA;AAED,eAAO,MAAM,qBAAqB,mCAUjC,CAAA"}

package/dist/cjs/PageLoadingContext.js

@@ -0,0 +1,64 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var PageLoadingContext_exports = {};
+__export(PageLoadingContext_exports, {
+  PageLoadingContextProvider: () => PageLoadingContextProvider,
+  usePageLoadingContext: () => usePageLoadingContext
+});
+module.exports = __toCommonJS(PageLoadingContext_exports);
+var import_react = __toESM(require("react"), 1);
+var import_createNamedContext = require("./createNamedContext.js");
+const PageLoadingContext = (0, import_createNamedContext.createNamedContext)("PageLoading");
+const PageLoadingContextProvider = ({
+  children,
+  delay = 1e3
+}) => {
+  const [loading, setPageLoadingContext] = (0, import_react.useState)(false);
+  return /* @__PURE__ */ import_react.default.createElement(
+    PageLoadingContext.Provider,
+    {
+      value: { loading, setPageLoadingContext, delay }
+    },
+    children
+  );
+};
+const usePageLoadingContext = () => {
+  const pageLoadingContext = (0, import_react.useContext)(PageLoadingContext);
+  if (!pageLoadingContext) {
+    throw new Error(
+      "usePageLoadingContext must be used within a PageLoadingContext provider"
+    );
+  }
+  return pageLoadingContext;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PageLoadingContextProvider,
+  usePageLoadingContext
+});

package/dist/cjs/Route.d.ts

@@ -0,0 +1,32 @@
+import type { ReactElement } from 'react';
+import type { PageType } from './page.js';
+export type RenderMode = 'stream' | 'html';
+export interface RedirectRouteProps {
+    redirect: string;
+    path: string;
+    name?: string;
+}
+export interface NotFoundRouteProps {
+    notfound: boolean;
+    page: PageType;
+    prerender?: boolean;
+    renderMode?: RenderMode;
+}
+export interface RouteProps {
+    path: string;
+    page: PageType;
+    name: string;
+    prerender?: boolean;
+    renderMode?: RenderMode;
+    whileLoadingPage?: () => ReactElement | null;
+}
+export type InternalRouteProps = Partial<RouteProps & RedirectRouteProps & NotFoundRouteProps>;
+/**
+ * Route is now a "virtual" component
+ * it is actually never rendered. All the page loading logic happens in active-route-loader
+ * and all the validation happens within utility functions called from the Router
+ */
+export declare function Route(props: RouteProps): JSX.Element;
+export declare function Route(props: RedirectRouteProps): JSX.Element;
+export declare function Route(props: NotFoundRouteProps): JSX.Element;
+//# sourceMappingURL=Route.d.ts.map

package/dist/cjs/Route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Route.d.ts","sourceRoot":"","sources":["../../src/Route.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,OAAO,CAAA;AAEzC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAA;AAEzC,MAAM,MAAM,UAAU,GAAG,QAAQ,GAAG,MAAM,CAAA;AAE1C,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,MAAM,CAAA;IAChB,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,OAAO,CAAA;IACjB,IAAI,EAAE,QAAQ,CAAA;IACd,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,UAAU,CAAC,EAAE,UAAU,CAAA;CACxB;AAED,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,QAAQ,CAAA;IACd,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,UAAU,CAAC,EAAE,UAAU,CAAA;IACvB,gBAAgB,CAAC,EAAE,MAAM,YAAY,GAAG,IAAI,CAAA;CAC7C;AAED,MAAM,MAAM,kBAAkB,GAAG,OAAO,CACtC,UAAU,GAAG,kBAAkB,GAAG,kBAAkB,CACrD,CAAA;AAED;;;;GAIG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,UAAU,GAAG,GAAG,CAAC,OAAO,CAAA;AACrD,wBAAgB,KAAK,CAAC,KAAK,EAAE,kBAAkB,GAAG,GAAG,CAAC,OAAO,CAAA;AAC7D,wBAAgB,KAAK,CAAC,KAAK,EAAE,kBAAkB,GAAG,GAAG,CAAC,OAAO,CAAA"}

package/dist/cjs/Route.js

@@ -0,0 +1,41 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Route_exports = {};
+__export(Route_exports, {
+  Route: () => Route
+});
+module.exports = __toCommonJS(Route_exports);
+var import_react = __toESM(require("react"), 1);
+function Route(_props) {
+  return /* @__PURE__ */ import_react.default.createElement(import_react.default.Fragment, null);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Route
+});

package/dist/cjs/Set.d.ts

@@ -0,0 +1,58 @@
+import type { ReactElement, ReactNode } from 'react';
+import React from 'react';
+export type WrapperType<WTProps> = (props: Omit<WTProps, 'wrap' | 'children'> & {
+    children: ReactNode;
+}) => ReactElement | null;
+type SetProps<P> = P & {
+    /**
+     * P is the interface for the props that are forwarded to the wrapper
+     * components. TypeScript will most likely infer this for you, but if you
+     * need to you can specify it yourself in your JSX like so:
+     *   <Set<{theme: string}> wrap={ThemableLayout} theme="dark">
+     */
+    wrap?: WrapperType<P> | WrapperType<P>[];
+    /**
+     *`Routes` nested in a `<Set>` with `private` specified require
+     * authentication. When a user is not authenticated and attempts to visit
+     * the wrapped route they will be redirected to `unauthenticated` route.
+     *
+     * @deprecated Please use `<PrivateSet>` instead
+     */
+    private?: boolean;
+    /**
+     * The page name where a user will be redirected when not authenticated
+     *
+     * @deprecated Please use `<PrivateSet>` instead and specify this prop there
+     */
+    unauthenticated?: string;
+    /**
+     * Route is permitted when authenticated and user has any of the provided
+     * roles such as "admin" or ["admin", "editor"]
+     */
+    roles?: string | string[];
+    /** Prerender all pages in the set */
+    prerender?: boolean;
+    children: ReactNode;
+    /** Loading state for auth to distinguish with whileLoading */
+    whileLoadingAuth?: () => ReactElement | null;
+    whileLoadingPage?: () => ReactElement | null;
+};
+/**
+ * TypeScript will often infer the type of the props you can forward to the
+ * wrappers for you, but if you need to you can specify it yourself in your
+ * JSX like so:
+ *   <Set<{theme: string}> wrap={ThemeableLayout} theme="dark">
+ */
+export declare function Set<WrapperProps>(props: SetProps<WrapperProps>): React.JSX.Element;
+type PrivateSetProps<P> = P & Omit<SetProps<P>, 'private' | 'unauthenticated'> & {
+    /** The page name where a user will be redirected when not authenticated */
+    unauthenticated: string;
+};
+/** @deprecated Please use `<PrivateSet>` instead */
+export declare function Private<WrapperProps>(props: PrivateSetProps<WrapperProps>): React.JSX.Element;
+export declare function PrivateSet<WrapperProps>(props: PrivateSetProps<WrapperProps>): React.JSX.Element;
+export declare const isSetNode: (node: ReactNode) => node is ReactElement<SetProps<any>>;
+export declare const isPrivateSetNode: (node: ReactNode) => node is ReactElement<PrivateSetProps<unknown>>;
+export declare const isPrivateNode: (node: ReactNode) => node is ReactElement<SetProps<any>>;
+export {};
+//# sourceMappingURL=Set.d.ts.map

package/dist/cjs/Set.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Set.d.ts","sourceRoot":"","sources":["../../src/Set.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AACpD,OAAO,KAAK,MAAM,OAAO,CAAA;AAEzB,MAAM,MAAM,WAAW,CAAC,OAAO,IAAI,CACjC,KAAK,EAAE,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU,CAAC,GAAG;IAC1C,QAAQ,EAAE,SAAS,CAAA;CACpB,KACE,YAAY,GAAG,IAAI,CAAA;AAExB,KAAK,QAAQ,CAAC,CAAC,IAAI,CAAC,GAAG;IACrB;;;;;OAKG;IACH,IAAI,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,EAAE,CAAA;IACxC;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB;;;;OAIG;IACH,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;IACzB,qCAAqC;IACrC,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,QAAQ,EAAE,SAAS,CAAA;IACnB,8DAA8D;IAC9D,gBAAgB,CAAC,EAAE,MAAM,YAAY,GAAG,IAAI,CAAA;IAC5C,gBAAgB,CAAC,EAAE,MAAM,YAAY,GAAG,IAAI,CAAA;CAC7C,CAAA;AAED;;;;;GAKG;AACH,wBAAgB,GAAG,CAAC,YAAY,EAAE,KAAK,EAAE,QAAQ,CAAC,YAAY,CAAC,qBAI9D;AAED,KAAK,eAAe,CAAC,CAAC,IAAI,CAAC,GACzB,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,SAAS,GAAG,iBAAiB,CAAC,GAAG;IACjD,2EAA2E;IAC3E,eAAe,EAAE,MAAM,CAAA;CACxB,CAAA;AAEH,oDAAoD;AACpD,wBAAgB,OAAO,CAAC,YAAY,EAAE,KAAK,EAAE,eAAe,CAAC,YAAY,CAAC,qBAIzE;AAED,wBAAgB,UAAU,CAAC,YAAY,EAAE,KAAK,EAAE,eAAe,CAAC,YAAY,CAAC,qBAI5E;AAED,eAAO,MAAM,SAAS,SACd,SAAS,KACd,IAAI,IAAI,YAAY,CAAC,QAAQ,CAAC,GAAG,CAAC,CAOpC,CAAA;AAED,eAAO,MAAM,gBAAgB,SACrB,SAAS,KACd,IAAI,IAAI,YAAY,CAAC,eAAe,CAAC,OAAO,CAAC,CAE/C,CAAA;AAGD,eAAO,MAAM,aAAa,SAClB,SAAS,KACd,IAAI,IAAI,YAAY,CAAC,QAAQ,CAAC,GAAG,CAAC,CAEpC,CAAA"}

package/dist/cjs/Set.js

@@ -0,0 +1,67 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Set_exports = {};
+__export(Set_exports, {
+  Private: () => Private,
+  PrivateSet: () => PrivateSet,
+  Set: () => Set,
+  isPrivateNode: () => isPrivateNode,
+  isPrivateSetNode: () => isPrivateSetNode,
+  isSetNode: () => isSetNode
+});
+module.exports = __toCommonJS(Set_exports);
+var import_react = __toESM(require("react"), 1);
+function Set(props) {
+  return /* @__PURE__ */ import_react.default.createElement(import_react.default.Fragment, null, props.children);
+}
+function Private(props) {
+  return /* @__PURE__ */ import_react.default.createElement(import_react.default.Fragment, null, props.children);
+}
+function PrivateSet(props) {
+  return /* @__PURE__ */ import_react.default.createElement(import_react.default.Fragment, null, props.children);
+}
+const isSetNode = (node) => {
+  return import_react.default.isValidElement(node) && (node.type === Set || node.type === PrivateSet || node.type === Private) && // Don't even bother including Sets without children. They're useless.
+  node.props.children;
+};
+const isPrivateSetNode = (node) => {
+  return import_react.default.isValidElement(node) && node.type === PrivateSet;
+};
+const isPrivateNode = (node) => {
+  return import_react.default.isValidElement(node) && node.type === Private;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Private,
+  PrivateSet,
+  Set,
+  isPrivateNode,
+  isPrivateSetNode,
+  isSetNode
+});

package/dist/cjs/a11yUtils.d.ts

@@ -0,0 +1,14 @@
+/**
+ * gets the announcement for the new page.
+ * called in one of active-route-loader's `useEffect`.
+ *
+ * the order of priority is:
+ * 1. RouteAnnouncement (the most specific one)
+ * 2. h1
+ * 3. document.title
+ * 4. location.pathname
+ */
+export declare const getAnnouncement: () => string;
+export declare const getFocus: () => HTMLElement | null;
+export declare const resetFocus: () => void;
+//# sourceMappingURL=a11yUtils.d.ts.map

package/dist/cjs/a11yUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"a11yUtils.d.ts","sourceRoot":"","sources":["../../src/a11yUtils.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe,cAkB3B,CAAA;AAED,eAAO,MAAM,QAAQ,0BAapB,CAAA;AAGD,eAAO,MAAM,UAAU,YAItB,CAAA"}

package/dist/cjs/a11yUtils.js

@@ -0,0 +1,61 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var a11yUtils_exports = {};
+__export(a11yUtils_exports, {
+  getAnnouncement: () => getAnnouncement,
+  getFocus: () => getFocus,
+  resetFocus: () => resetFocus
+});
+module.exports = __toCommonJS(a11yUtils_exports);
+const getAnnouncement = () => {
+  const routeAnnouncement = globalThis?.document.querySelectorAll(
+    "[data-redwood-route-announcement]"
+  )?.[0];
+  if (routeAnnouncement?.textContent) {
+    return routeAnnouncement.textContent;
+  }
+  const pageHeading = globalThis?.document.querySelector(`h1`);
+  if (pageHeading?.textContent) {
+    return pageHeading.textContent;
+  }
+  if (globalThis?.document.title) {
+    return document.title;
+  }
+  return `new page at ${globalThis?.location.pathname}`;
+};
+const getFocus = () => {
+  const routeFocus = globalThis?.document.querySelectorAll(
+    "[data-redwood-route-focus]"
+  )?.[0];
+  if (!routeFocus?.children.length || routeFocus.children[0].tabIndex < 0) {
+    return null;
+  }
+  return routeFocus.children[0];
+};
+const resetFocus = () => {
+  globalThis?.document.body.setAttribute("tabindex", "-1");
+  globalThis?.document.body.focus();
+  globalThis?.document.body.removeAttribute("tabindex");
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getAnnouncement,
+  getFocus,
+  resetFocus
+});