@cedarjs/router 0.0.4

package/dist/cjs/active-route-loader.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import type { Spec } from './page.js';
+interface Props {
+    path: string;
+    spec: Spec;
+    params?: Record<string, string>;
+    whileLoadingPage?: () => React.ReactNode | null;
+    children?: React.ReactNode;
+}
+export declare const ActiveRouteLoader: ({ spec, params, whileLoadingPage, }: Props) => React.JSX.Element;
+export {};
+//# sourceMappingURL=active-route-loader.d.ts.map

package/dist/cjs/active-route-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"active-route-loader.d.ts","sourceRoot":"","sources":["../../src/active-route-loader.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAsC,MAAM,OAAO,CAAA;AAG1D,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AAIrC,UAAU,KAAK;IACb,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,IAAI,CAAA;IACV,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC/B,gBAAgB,CAAC,EAAE,MAAM,KAAK,CAAC,SAAS,GAAG,IAAI,CAAA;IAC/C,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAA;CAC3B;AAiCD,eAAO,MAAM,iBAAiB,wCAI3B,KAAK,sBAmEP,CAAA"}

package/dist/cjs/active-route-loader.js

@@ -0,0 +1,116 @@
+"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 active_route_loader_exports = {};
+__export(active_route_loader_exports, {
+  ActiveRouteLoader: () => ActiveRouteLoader
+});
+module.exports = __toCommonJS(active_route_loader_exports);
+var import_react = __toESM(require("react"), 1);
+var import_a11yUtils = require("./a11yUtils.js");
+var import_PageLoadingContext = require("./PageLoadingContext.js");
+var import_util = require("./util.js");
+let isPrerendered = false;
+if (typeof window !== "undefined") {
+  const redwoodAppElement = document.getElementById("redwood-app");
+  if (redwoodAppElement && redwoodAppElement.children.length > 0) {
+    isPrerendered = true;
+  }
+}
+let firstLoad = true;
+const Fallback = ({ children }) => {
+  const { loading, setPageLoadingContext, delay } = (0, import_PageLoadingContext.usePageLoadingContext)();
+  (0, import_react.useEffect)(() => {
+    const timer = setTimeout(() => {
+      setPageLoadingContext(true);
+    }, delay);
+    return () => {
+      clearTimeout(timer);
+      setPageLoadingContext(false);
+    };
+  }, [delay, setPageLoadingContext]);
+  return /* @__PURE__ */ import_react.default.createElement(import_react.default.Fragment, null, loading ? children : null);
+};
+const ActiveRouteLoader = ({
+  spec,
+  params,
+  whileLoadingPage
+}) => {
+  const announcementRef = (0, import_react.useRef)(null);
+  const usePrerenderLoader = (
+    // Prerendering doesn't work with Streaming/SSR yet. So we disable it.
+    !globalThis.RWJS_EXP_STREAMING_SSR && (globalThis.__REDWOOD__PRERENDERING || isPrerendered && firstLoad)
+  );
+  const LazyRouteComponent = usePrerenderLoader ? spec.prerenderLoader(spec.name).default : spec.LazyComponent;
+  if (firstLoad) {
+    firstLoad = false;
+  }
+  (0, import_react.useEffect)(() => {
+    if ((0, import_util.inIframe)()) {
+      return;
+    }
+    if (announcementRef.current) {
+      announcementRef.current.innerText = (0, import_a11yUtils.getAnnouncement)();
+    }
+    const routeFocus = (0, import_a11yUtils.getFocus)();
+    if (!routeFocus) {
+      (0, import_a11yUtils.resetFocus)();
+    } else {
+      routeFocus.focus();
+    }
+  }, [spec, params]);
+  if (params) {
+    delete params["ref"];
+    delete params["key"];
+  }
+  return /* @__PURE__ */ import_react.default.createElement(import_react.Suspense, { fallback: /* @__PURE__ */ import_react.default.createElement(Fallback, null, whileLoadingPage?.()) }, /* @__PURE__ */ import_react.default.createElement(LazyRouteComponent, { ...params }), /* @__PURE__ */ import_react.default.createElement(
+    "div",
+    {
+      id: "redwood-announcer",
+      style: {
+        position: "absolute",
+        top: 0,
+        width: 1,
+        height: 1,
+        padding: 0,
+        overflow: "hidden",
+        clip: "rect(0, 0, 0, 0)",
+        whiteSpace: "nowrap",
+        border: 0
+      },
+      role: "alert",
+      "aria-live": "assertive",
+      "aria-atomic": "true",
+      ref: announcementRef
+    }
+  ));
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ActiveRouteLoader
+});

package/dist/cjs/analyzeRoutes.d.ts

@@ -0,0 +1,44 @@
+import type { ReactElement, ReactNode } from 'react';
+import type { PageType } from './page.js';
+import { type ParamType } from './util.js';
+type WhileLoadingPage = () => ReactElement | null;
+export type GeneratedRoutesMap = {
+    [key: string]: (args?: Record<string | number, string | number | boolean>) => string;
+};
+export type Wrappers = ((props: any) => ReactNode)[];
+interface Set {
+    id: string;
+    wrappers: Wrappers;
+    isPrivate: boolean;
+    props: {
+        private?: boolean;
+        [key: string]: unknown;
+    };
+}
+type RoutePath = string;
+/**
+ * This is essentially the same as RouteProps
+ * but it allows for page and redirect to be null or undefined
+ * Keeping the shape consistent makes it easier to use
+ */
+interface AnalyzedRoute {
+    path: RoutePath;
+    name: string | null;
+    whileLoadingPage?: WhileLoadingPage;
+    page: PageType | null;
+    redirect: string | null;
+    sets: Set[];
+}
+interface AnalyzeRoutesOptions {
+    currentPathName: string;
+    userParamTypes?: Record<string, ParamType>;
+}
+export declare function analyzeRoutes(children: ReactNode, { currentPathName, userParamTypes }: AnalyzeRoutesOptions): {
+    pathRouteMap: Record<string, AnalyzedRoute>;
+    namedRoutesMap: GeneratedRoutesMap;
+    hasRootRoute: boolean;
+    NotFoundPage: PageType | undefined;
+    activeRoutePath: string | undefined;
+};
+export {};
+//# sourceMappingURL=analyzeRoutes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"analyzeRoutes.d.ts","sourceRoot":"","sources":["../../src/analyzeRoutes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AAGpD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAA;AAQzC,OAAO,EAIL,KAAK,SAAS,EACf,MAAM,WAAW,CAAA;AAElB,KAAK,gBAAgB,GAAG,MAAM,YAAY,GAAG,IAAI,CAAA;AAIjD,MAAM,MAAM,kBAAkB,GAAG;IAC/B,CAAC,GAAG,EAAE,MAAM,GAAG,CACb,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,GAAG,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,KACtD,MAAM,CAAA;CACZ,CAAA;AAED,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,EAAE,GAAG,KAAK,SAAS,CAAC,EAAE,CAAA;AAEpD,UAAU,GAAG;IACX,EAAE,EAAE,MAAM,CAAA;IACV,QAAQ,EAAE,QAAQ,CAAA;IAClB,SAAS,EAAE,OAAO,CAAA;IAClB,KAAK,EAAE;QACL,OAAO,CAAC,EAAE,OAAO,CAAA;QACjB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;KACvB,CAAA;CACF;AAED,KAAK,SAAS,GAAG,MAAM,CAAA;AAEvB;;;;GAIG;AACH,UAAU,aAAa;IACrB,IAAI,EAAE,SAAS,CAAA;IACf,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;IACnB,gBAAgB,CAAC,EAAE,gBAAgB,CAAA;IACnC,IAAI,EAAE,QAAQ,GAAG,IAAI,CAAA;IACrB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IACvB,IAAI,EAAE,GAAG,EAAE,CAAA;CACZ;AAED,UAAU,oBAAoB;IAC5B,eAAe,EAAE,MAAM,CAAA;IACvB,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAA;CAC3C;AAED,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,SAAS,EACnB,EAAE,eAAe,EAAE,cAAc,EAAE,EAAE,oBAAoB;;;;;;EA6K1D"}

package/dist/cjs/analyzeRoutes.js

@@ -0,0 +1,143 @@
+"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 analyzeRoutes_exports = {};
+__export(analyzeRoutes_exports, {
+  analyzeRoutes: () => analyzeRoutes
+});
+module.exports = __toCommonJS(analyzeRoutes_exports);
+var import_react = require("react");
+var import_route_validators = require("./route-validators.js");
+var import_Set = require("./Set.js");
+var import_util = require("./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 ((0, import_route_validators.isValidRoute)(node)) {
+        const route = node;
+        if ((0, import_route_validators.isNotFoundRoute)(route)) {
+          NotFoundPage = route.props.page;
+          return;
+        }
+        if (route.props.path === "/") {
+          hasRootRoute = true;
+        }
+        if ((0, import_route_validators.isRedirectRoute)(route)) {
+          const { name, redirect, path } = route.props;
+          (0, import_util.validatePath)(path, name || path);
+          const { match } = (0, import_util.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 = {}) => (0, import_util.replaceParams)(path, args);
+          }
+        }
+        if ((0, import_route_validators.isStandardRoute)(route)) {
+          const { name, path, page } = route.props;
+          (0, import_util.validatePath)(path, name);
+          const { match } = (0, import_util.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 = {}) => (0, import_util.replaceParams)(path, args);
+        }
+      }
+      if ((0, import_Set.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: import_react.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: (0, import_Set.isPrivateSetNode)(node) || // The following two conditions can be removed when we remove
+              // the deprecated private prop
+              (0, import_Set.isPrivateNode)(node) || !!otherPropsFromCurrentSet.private,
+              props: otherPropsFromCurrentSet
+            }
+          ]
+        });
+      }
+    });
+  };
+  recurseThroughRouter({ nodes: import_react.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;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  analyzeRoutes
+});

package/dist/cjs/createNamedContext.d.ts

@@ -0,0 +1,3 @@
+/** Create a React Context with the given name. */
+export declare function createNamedContext<T>(name: string, defaultValue?: T): import("react").Context<T | undefined>;
+//# sourceMappingURL=createNamedContext.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createNamedContext.d.ts","sourceRoot":"","sources":["../../src/createNamedContext.ts"],"names":[],"mappings":"AAEA,kDAAkD;AAClD,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,CAAC,0CAInE"}

package/dist/cjs/createNamedContext.js

@@ -0,0 +1,33 @@
+"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 createNamedContext_exports = {};
+__export(createNamedContext_exports, {
+  createNamedContext: () => createNamedContext
+});
+module.exports = __toCommonJS(createNamedContext_exports);
+var import_react = require("react");
+function createNamedContext(name, defaultValue) {
+  const Ctx = (0, import_react.createContext)(defaultValue);
+  Ctx.displayName = name;
+  return Ctx;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createNamedContext
+});

package/dist/cjs/dummyComponent.d.ts

@@ -0,0 +1,3 @@
+declare const _default: () => null;
+export default _default;
+//# sourceMappingURL=dummyComponent.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dummyComponent.d.ts","sourceRoot":"","sources":["../../src/dummyComponent.ts"],"names":[],"mappings":";AAEA,wBAAyB"}

package/dist/cjs/dummyComponent.js

@@ -0,0 +1,24 @@
+"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 dummyComponent_exports = {};
+__export(dummyComponent_exports, {
+  default: () => dummyComponent_default
+});
+module.exports = __toCommonJS(dummyComponent_exports);
+var dummyComponent_default = () => null;

package/dist/cjs/history.d.ts

@@ -0,0 +1,24 @@
+export interface NavigateOptions {
+    replace?: boolean;
+    scroll?: boolean;
+}
+export type Listener = (ev?: PopStateEvent, options?: NavigateOptions) => any;
+export type BeforeUnloadListener = (ev: BeforeUnloadEvent) => any;
+export type BlockerCallback = (tx: {
+    retry: () => void;
+}) => void;
+export type Blocker = {
+    id: string;
+    callback: BlockerCallback;
+};
+declare const gHistory: {
+    listen: (listener: Listener) => string;
+    navigate: (to: string, options?: NavigateOptions) => void;
+    back: () => void;
+    remove: (listenerId: string) => void;
+    block: (id: string, callback: BlockerCallback) => void;
+    unblock: (id: string) => void;
+};
+declare const navigate: (to: string, options?: NavigateOptions) => void, back: () => void, block: (id: string, callback: BlockerCallback) => void, unblock: (id: string) => void;
+export { gHistory, navigate, back, block, unblock };
+//# sourceMappingURL=history.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"history.d.ts","sourceRoot":"","sources":["../../src/history.tsx"],"names":[],"mappings":"AAAA,MAAM,WAAW,eAAe;IAC9B,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,MAAM,CAAC,EAAE,OAAO,CAAA;CACjB;AAED,MAAM,MAAM,QAAQ,GAAG,CAAC,EAAE,CAAC,EAAE,aAAa,EAAE,OAAO,CAAC,EAAE,eAAe,KAAK,GAAG,CAAA;AAC7E,MAAM,MAAM,oBAAoB,GAAG,CAAC,EAAE,EAAE,iBAAiB,KAAK,GAAG,CAAA;AACjE,MAAM,MAAM,eAAe,GAAG,CAAC,EAAE,EAAE;IAAE,KAAK,EAAE,MAAM,IAAI,CAAA;CAAE,KAAK,IAAI,CAAA;AACjE,MAAM,MAAM,OAAO,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,eAAe,CAAA;CAAE,CAAA;AAgI/D,QAAA,MAAM,QAAQ;uBAxHS,QAAQ;mBAOrB,MAAM,YACD,eAAe;;yBA8CL,MAAM;gBAWf,MAAM,YAAY,eAAe;kBAa/B,MAAM;CA0CQ,CAAA;AAEhC,QAAA,MAAQ,QAAQ,OAnHN,MAAM,YACD,eAAe,WAkHZ,IAAI,cAAE,KAAK,OAzDb,MAAM,YAAY,eAAe,WAyDlB,OAAO,OA5CpB,MAAM,SA4C2B,CAAA;AAEnD,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE,CAAA"}

package/dist/cjs/history.js

@@ -0,0 +1,146 @@
+"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 history_exports = {};
+__export(history_exports, {
+  back: () => back,
+  block: () => block,
+  gHistory: () => gHistory,
+  navigate: () => navigate,
+  unblock: () => unblock
+});
+module.exports = __toCommonJS(history_exports);
+const createHistory = () => {
+  const listeners = {};
+  const blockers = [];
+  let beforeUnloadListener = null;
+  const history = {
+    listen: (listener) => {
+      const listenerId = "RW_HISTORY_LISTENER_ID_" + Date.now();
+      listeners[listenerId] = listener;
+      globalThis.addEventListener("popstate", listener);
+      return listenerId;
+    },
+    navigate: (to, options = {
+      scroll: true
+    }) => {
+      const performNavigation = () => {
+        const { pathname, search, hash } = new URL(
+          globalThis?.location?.origin + to
+        );
+        if (globalThis?.location?.pathname !== pathname || globalThis?.location?.search !== search || globalThis?.location?.hash !== hash) {
+          if (options?.replace) {
+            globalThis.history.replaceState({}, "", to);
+          } else {
+            globalThis.history.pushState({}, "", to);
+          }
+        }
+        for (const listener of Object.values(listeners)) {
+          listener(void 0, options);
+        }
+      };
+      if (blockers.length > 0) {
+        processBlockers(0, performNavigation);
+      } else {
+        performNavigation();
+      }
+    },
+    back: () => {
+      const performBack = () => {
+        globalThis.history.back();
+        for (const listener of Object.values(listeners)) {
+          listener();
+        }
+      };
+      if (blockers.length > 0) {
+        processBlockers(0, performBack);
+      } else {
+        performBack();
+      }
+    },
+    remove: (listenerId) => {
+      if (listeners[listenerId]) {
+        const listener = listeners[listenerId];
+        globalThis.removeEventListener("popstate", listener);
+        delete listeners[listenerId];
+      } else {
+        console.warn(
+          "History Listener with ID: " + listenerId + " does not exist."
+        );
+      }
+    },
+    block: (id, callback) => {
+      const existingBlockerIndex = blockers.findIndex(
+        (blocker) => blocker.id === id
+      );
+      if (existingBlockerIndex !== -1) {
+        blockers[existingBlockerIndex] = { id, callback };
+      } else {
+        blockers.push({ id, callback });
+        if (blockers.length === 1) {
+          addBeforeUnloadListener();
+        }
+      }
+    },
+    unblock: (id) => {
+      const index = blockers.findIndex((blocker) => blocker.id === id);
+      if (index !== -1) {
+        blockers.splice(index, 1);
+        if (blockers.length === 0) {
+          removeBeforeUnloadListener();
+        }
+      }
+    }
+  };
+  const processBlockers = (index, navigate2) => {
+    if (index < blockers.length) {
+      blockers[index].callback({
+        retry: () => processBlockers(index + 1, navigate2)
+      });
+    } else {
+      navigate2();
+    }
+  };
+  const addBeforeUnloadListener = () => {
+    if (!beforeUnloadListener) {
+      beforeUnloadListener = (event) => {
+        if (blockers.length > 0) {
+          event.preventDefault();
+        }
+      };
+      globalThis.addEventListener("beforeunload", beforeUnloadListener);
+    }
+  };
+  const removeBeforeUnloadListener = () => {
+    if (beforeUnloadListener) {
+      globalThis.removeEventListener("beforeunload", beforeUnloadListener);
+      beforeUnloadListener = null;
+    }
+  };
+  return history;
+};
+const gHistory = createHistory();
+const { navigate, back, block, unblock } = gHistory;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  back,
+  block,
+  gHistory,
+  navigate,
+  unblock
+});

package/dist/cjs/index.d.ts

@@ -0,0 +1,35 @@
+export { navigate, back } from './history.js';
+export { NavLink } from './navLink.js';
+export { Link } from './link.js';
+export { useLocation, LocationProvider } from './location.js';
+export { Redirect } from './redirect.js';
+export { usePageLoadingContext, PageLoadingContextProvider, } from './PageLoadingContext.js';
+export { useParams, ParamsProvider, ParamsContext } from './params.js';
+export { Router } from './router.js';
+export { Route } from './Route.js';
+export { namedRoutes as routes } from './namedRoutes.js';
+export * from './Set.js';
+export { default as RouteAnnouncement } from './route-announcement.js';
+export * from './route-announcement.js';
+export { default as RouteFocus } from './route-focus.js';
+export * from './route-focus.js';
+export * from './useRouteName.js';
+export * from './useRoutePaths.js';
+export * from './useMatch.js';
+export * from './useBlocker.js';
+export { parseSearch, getRouteRegexAndParams, matchPath } from './util.js';
+export { SkipNavLink, SkipNavContent } from './skipNav.js';
+/**
+ * A more specific interface is created in `.redwood/types/includes/web-routerRoutes`
+ * when the site is built, which will describe all known routes.
+ *
+ * @example
+ * interface AvailableRoutes {
+ *   home: (params?: RouteParams<"/">) => "/"
+ *   post: (params?: RouteParams<"/posts/{id:Int}">) => "/posts/{id:Int}"
+ * }
+ */
+export interface AvailableRoutes {
+}
+export * from './routeParamsTypes.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,cAAc,CAAA;AAC7C,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AACtC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AAChC,OAAO,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAA;AAC7D,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AACxC,OAAO,EACL,qBAAqB,EACrB,0BAA0B,GAC3B,MAAM,yBAAyB,CAAA;AAChC,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AACtE,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AACpC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAClC,OAAO,EAAE,WAAW,IAAI,MAAM,EAAE,MAAM,kBAAkB,CAAA;AAExD,cAAc,UAAU,CAAA;AAExB,OAAO,EAAE,OAAO,IAAI,iBAAiB,EAAE,MAAM,yBAAyB,CAAA;AACtE,cAAc,yBAAyB,CAAA;AACvC,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,kBAAkB,CAAA;AACxD,cAAc,kBAAkB,CAAA;AAChC,cAAc,mBAAmB,CAAA;AACjC,cAAc,oBAAoB,CAAA;AAClC,cAAc,eAAe,CAAA;AAC7B,cAAc,iBAAiB,CAAA;AAE/B,OAAO,EAAE,WAAW,EAAE,sBAAsB,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAE1E,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAE1D;;;;;;;;;GASG;AAGH,MAAM,WAAW,eAAe;CAAG;AAGnC,cAAc,uBAAuB,CAAA"}