@lwrjs/router 0.24.2 → 0.24.3

package/build/cjs/modules/lwr/router/router.cjs

@@ -1,35 +1,37 @@
-var __create = Object.create;
+"use strict";
 var __defProp = Object.defineProperty;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __markAsModule = (target) => __defProp(target, "__esModule", {value: true});
+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});
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __exportStar = (target, module2, desc) => {
-  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
-    for (let key of __getOwnPropNames(module2))
-      if (!__hasOwnProp.call(target, key) && key !== "default")
-        __defProp(target, key, {get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable});
+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 target;
-};
-var __toModule = (module2) => {
-  return __exportStar(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? {get: () => module2.default, enumerable: true} : {value: module2, enumerable: true})), module2);
+  return to;
 };
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // packages/@lwrjs/router/src/modules/lwr/router/router.ts
-__markAsModule(exports);
-__export(exports, {
+var router_exports = {};
+__export(router_exports, {
   createRouter: () => createRouter
 });
-var import_routerUtils = __toModule(require("lwr/routerUtils"));
-var import_routerErrors = __toModule(require("lwr/routerErrors"));
-var import_observable = __toModule(require("lwr/observable"));
+module.exports = __toCommonJS(router_exports);
+var import_routerUtils = require("lwr/routerUtils");
+var import_routerErrors = require("lwr/routerErrors");
+var import_observable = require("lwr/observable");
 var RouterImpl = class {
+  /**
+   * Create and configure the Router.
+   *
+   * @param {object} config - The router config object, all properties are optional
+   */
   constructor(config) {
     this.deprecatedConfig = {};
     this.routeHandlerId = 0;
@@ -41,10 +43,21 @@ var RouterImpl = class {
       i18n: config.i18n || import_routerUtils.DEFAULT_I18N_ROUTER_CONFIG,
       caseSensitive: Boolean(config.caseSensitive),
       routes: config.routes || [],
-      generateUrl: (address, options) => (0, import_routerUtils.getUrlFromPageReference)(address, this.compiledRoutes, this.config.basePath, this.config.i18n, options),
-      parseUrl: (url) => (0, import_routerUtils.getPageReferenceFromUrl)(url, this.compiledRoutes, this.config.basePath, this.config.i18n)
+      generateUrl: (address, options) => (0, import_routerUtils.getUrlFromPageReference)(
+        address,
+        this.compiledRoutes,
+        this.config.basePath,
+        this.config.i18n,
+        options
+      ),
+      parseUrl: (url) => (0, import_routerUtils.getPageReferenceFromUrl)(
+        url,
+        this.compiledRoutes,
+        this.config.basePath,
+        this.config.i18n
+      )
     };
-    const {generateUrlFilter, DEPRECATED_getRouteFromUrl, DEPRECATED_getUrlFromRoute} = config;
+    const { generateUrlFilter, DEPRECATED_getRouteFromUrl, DEPRECATED_getUrlFromRoute } = config;
     if (generateUrlFilter) {
       this.config.generateUrlFilter = generateUrlFilter;
     }
@@ -56,37 +69,69 @@ var RouterImpl = class {
     }
     this.compiledRoutes = (0, import_routerUtils.parseRoutes)(this.config);
   }
+  /**
+   * Convert address to url string.
+   *
+   * @param address
+   */
   generateUrl(address, options) {
-    const {DEPRECATED_getUrlFromRoute: getUrlFromRoute} = this.deprecatedConfig;
+    const { DEPRECATED_getUrlFromRoute: getUrlFromRoute } = this.deprecatedConfig;
     if (getUrlFromRoute) {
       return getUrlFromRoute(address, this.config.generateUrl, options);
     } else {
       return this.config.generateUrl(address, options);
     }
   }
+  /**
+   * Async version of generateUrl.
+   * @returns {Promise<string | null>}
+   */
   generateUrlAsync(address, options) {
-    const {generateUrlFilter} = this.config;
+    const { generateUrlFilter } = this.config;
     if (generateUrlFilter) {
       return generateUrlFilter(address, this.config.generateUrl, options);
     } else {
       return Promise.resolve(this.generateUrl(address, options));
     }
   }
+  /**
+   * Convert url string to address.
+   *
+   * @param url
+   */
   parseUrl(url) {
-    const {DEPRECATED_getRouteFromUrl: getRouteFromUrl} = this.deprecatedConfig;
+    const { DEPRECATED_getRouteFromUrl: getRouteFromUrl } = this.deprecatedConfig;
     if (getRouteFromUrl) {
       return getRouteFromUrl(url, this.config.parseUrl);
     } else {
       return this.config.parseUrl(url);
     }
   }
+  /**
+   * Match the given url against the internal route definitions and return info
+   * on the match.
+   *
+   * @param address - The address to match
+   */
   matchRoute(address, options) {
     const url = typeof address === "string" ? address : this.generateUrl(address, options);
     if (url === null) {
       return null;
     }
-    const match = (0, import_routerUtils.matchRouteByUrl)(url, this.compiledRoutes, this.config.basePath, this.config.i18n, options);
-    const pathMatch = match && (0, import_routerUtils.getUrlFromPageReferenceAndRouteDef)(match.route.pageReference, match.routeDefinition, this.config.basePath, this.config.i18n, options);
+    const match = (0, import_routerUtils.matchRouteByUrl)(
+      url,
+      this.compiledRoutes,
+      this.config.basePath,
+      this.config.i18n,
+      options
+    );
+    const pathMatch = match && (0, import_routerUtils.getUrlFromPageReferenceAndRouteDef)(
+      match.route.pageReference,
+      match.routeDefinition,
+      this.config.basePath,
+      this.config.i18n,
+      options
+    );
     if (!match || !pathMatch) {
       return null;
     }
@@ -96,6 +141,11 @@ var RouterImpl = class {
       routeDefinition: match.routeDefinition.original
     };
   }
+  /**
+   * Given an address, return the associated viewset by calling the route handler.
+   *
+   * @param address - The address to match to a viewset
+   */
   async resolveView(address, options) {
     return new Promise((resolve, reject) => {
       const routingMatch = this.matchRoute(address, options);
@@ -105,7 +155,9 @@ var RouterImpl = class {
       return routingMatch.routeDefinition.handler?.().then((handlerModule) => {
         const routeHandlerClass = handlerModule.default;
         if (!routeHandlerClass) {
-          return reject((0, import_routerErrors.generateMessage)(import_routerErrors.messages.INVALID_ROUTE_HANDLER, [routingMatch.routeDefinition.id]));
+          return reject(
+            (0, import_routerErrors.generateMessage)(import_routerErrors.messages.INVALID_ROUTE_HANDLER, [routingMatch.routeDefinition.id])
+          );
         }
         const routeHandler = new routeHandlerClass(resolve);
         if (routeHandler) {
@@ -114,30 +166,57 @@ var RouterImpl = class {
       });
     });
   }
+  /**
+   * Process the given URL by matching it to an existing route and looking up
+   * the associated view
+   *
+   * @param {object} address
+   */
   navigate(address, options) {
     const routingMatch = this.matchRoute(address, options);
     if (!routingMatch) {
       throw new Error((0, import_routerErrors.generateMessage)(import_routerErrors.messages.MISSING_ROUTE, [JSON.stringify(address)]));
     }
-    this.pendingRoute = {...routingMatch};
+    this.pendingRoute = { ...routingMatch };
     this._mapView(this.pendingRoute);
   }
+  /**
+   * lightning/navigation
+   * Subscribe a callback to the Observable on the current route of this router.
+   *
+   * @param {function} callback - A callback function invoked when the navigation state changes
+   *                     callback(route, routeDef)
+   * @param {boolean} replay - Flag to determine if callback should be called with current route and data immediately
+   */
   subscribe(callback, replay) {
-    return this.routeObservable.subscribe({
-      next: callback,
-      error: () => {
+    return this.routeObservable.subscribe(
+      {
+        next: callback,
+        error: () => {
+        },
+        complete: () => {
+        }
       },
-      complete: () => {
-      }
-    }, Boolean(replay));
+      Boolean(replay)
+    );
   }
+  /**
+   * Map the given route to a view set that can be emitted to subscribers. After the correct handler
+   * is determined (picked from the routers routes in the config), view mapping is delegated to the
+   * handler with a callback to finish processing and emit the final result.
+   *
+   * @param {*} route
+   * @param {*} routeInfo
+   */
   async _mapView(routingMatch) {
     const routeHandlerId = Math.random();
     this.routeHandlerId = routeHandlerId;
     const handlerModule = await routingMatch.routeDefinition.handler?.();
     const routeHandlerClass = handlerModule?.default;
     if (!routeHandlerClass) {
-      throw new Error((0, import_routerErrors.generateMessage)(import_routerErrors.messages.INVALID_ROUTE_HANDLER, [routingMatch.routeDefinition.id]));
+      throw new Error(
+        (0, import_routerErrors.generateMessage)(import_routerErrors.messages.INVALID_ROUTE_HANDLER, [routingMatch.routeDefinition.id])
+      );
     }
     this.routeHandler = new routeHandlerClass((routeDestination) => {
       this._updateView(routeHandlerId, routeDestination);
@@ -147,6 +226,11 @@ var RouterImpl = class {
     }
     return true;
   }
+  /**
+   * Set internal state, notify observable with frozen data, and propagate to child router
+   *
+   * @param {*} viewDestination
+   */
   _updateView(viewHandlerId, routeDestination) {
     if (!routeDestination || viewHandlerId !== this.routeHandlerId) {
       return;
@@ -155,7 +239,7 @@ var RouterImpl = class {
       throw new Error("Trying to commit route state without a route");
     }
     const viewset = (0, import_routerUtils.freeze)(routeDestination.viewset);
-    this.routeObservable.next({...this.pendingRoute, ...routeDestination, viewset});
+    this.routeObservable.next({ ...this.pendingRoute, ...routeDestination, viewset });
   }
 };
 function createRouter(config = {}) {

package/build/cjs/modules/lwr/routerBridge/routerBridge.cjs

@@ -1,34 +1,36 @@
-var __create = Object.create;
+"use strict";
 var __defProp = Object.defineProperty;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __markAsModule = (target) => __defProp(target, "__esModule", {value: true});
+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});
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __exportStar = (target, module2, desc) => {
-  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
-    for (let key of __getOwnPropNames(module2))
-      if (!__hasOwnProp.call(target, key) && key !== "default")
-        __defProp(target, key, {get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable});
+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 target;
-};
-var __toModule = (module2) => {
-  return __exportStar(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? {get: () => module2.default, enumerable: true} : {value: module2, enumerable: true})), module2);
+  return to;
 };
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // packages/@lwrjs/router/src/modules/lwr/routerBridge/routerBridge.ts
-__markAsModule(exports);
-__export(exports, {
+var routerBridge_exports = {};
+__export(routerBridge_exports, {
   createBridge: () => createBridge
 });
-var import_domRouter = __toModule(require("lwr/domRouter"));
+module.exports = __toCommonJS(routerBridge_exports);
+var import_domRouter = require("lwr/domRouter");
 var DomRouterBridge = class {
   constructor(config = {}, target = window) {
+    // Routers send out the PARENT_EVENT to build a router hierarchy
+    // Listen for this event to find the topmost router located beneath the bridge in the DOM
+    // NOTE: because of the restrictions on "lwr/router" hierachy, this is only called 0 or 1 time(s)
+    //       - only ONE root router is allowed in a document
+    //       - sibling routers are NOT allowed
     this.handleParentEvent = (event) => {
       const parentEvent = event;
       if (parentEvent && parentEvent.detail && typeof parentEvent.detail === "function") {
@@ -52,9 +54,10 @@ var DomRouterBridge = class {
     this.target = target;
     this.target.addEventListener(import_domRouter.PARENT_EVENT, this.handleParentEvent);
   }
+  // Save an observed router and subscribe to its navigation and error updates
   async addChild(child) {
     this.bridgedRouter = child;
-    this.bridgedRouter.subscribe(({route: {pageReference}}) => {
+    this.bridgedRouter.subscribe(({ route: { pageReference } }) => {
       this.config.onPostNavigate(pageReference);
     });
     this.bridgedRouter.addErrorNavigate(this.config.onError);
@@ -68,6 +71,9 @@ var DomRouterBridge = class {
       }, 0);
     });
   }
+  // Use the observed router to navigate to the given page reference
+  // Return true if the router is connected and the navigation event was sent
+  // False is returned if there are no mounted routers to observe (yet)
   navigate(pageRef) {
     if (this.bridgedRouter && this.bridgedRouter.connected) {
       this.bridgedRouter.navigate(pageRef);

package/build/cjs/modules/lwr/routerContainer/routerContainer.cjs

@@ -1,49 +1,51 @@
-var __create = Object.create;
+"use strict";
 var __defProp = Object.defineProperty;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __markAsModule = (target) => __defProp(target, "__esModule", {value: true});
+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});
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __exportStar = (target, module2, desc) => {
-  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
-    for (let key of __getOwnPropNames(module2))
-      if (!__hasOwnProp.call(target, key) && key !== "default")
-        __defProp(target, key, {get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable});
+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 target;
-};
-var __toModule = (module2) => {
-  return __exportStar(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? {get: () => module2.default, enumerable: true} : {value: module2, enumerable: true})), module2);
+  return to;
 };
-var __decorate = (decorators, target, key, kind) => {
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __decorateClass = (decorators, target, key, kind) => {
   var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
   for (var i = decorators.length - 1, decorator; i >= 0; i--)
     if (decorator = decorators[i])
       result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-  if (kind && result)
-    __defProp(target, key, result);
+  if (kind && result) __defProp(target, key, result);
   return result;
 };
 
 // packages/@lwrjs/router/src/modules/lwr/routerContainer/routerContainer.ts
-__markAsModule(exports);
-__export(exports, {
-  default: () => routerContainer_default
+var routerContainer_exports = {};
+__export(routerContainer_exports, {
+  default: () => RouterContainer
 });
-var import_lwc = __toModule(require("lwc"));
-var import_utils = __toModule(require("./utils.cjs"));
-var import_routerUtils = __toModule(require("lwr/routerUtils"));
+module.exports = __toCommonJS(routerContainer_exports);
+var import_lwc = require("lwc");
+var import_utils = require("./utils.cjs");
+var import_routerUtils = require("lwr/routerUtils");
 var RouterContainer = class extends import_lwc.LightningElement {
   constructor() {
     super();
     this.historyDisabled = false;
     this.currentTitle = import_routerUtils.hasDocument ? document.title : "";
   }
+  static {
+    this.renderMode = "light";
+  }
+  /**
+   * Create a router attached to this component.
+   */
   connectedCallback() {
     const config = {
       historyDisabled: this.historyDisabled,
@@ -54,11 +56,19 @@ var RouterContainer = class extends import_lwc.LightningElement {
       this.routerApi.addPreNavigate(this.preNavigate.bind(this)).addPostNavigate(this.postNavigate.bind(this)).addErrorNavigate(this.errorNavigate.bind(this)).connect();
     }
   }
+  /**
+   * The preNavigate hook surfaced as a cancelable CustomEvent.
+   * @param {RouteChange} - the current and proposed route information
+   */
   preNavigate(routeChange) {
     const event = this._createEvent("prenavigate", routeChange, true);
     this.dispatchEvent(event);
     return !event.defaultPrevented;
   }
+  /**
+   * The postNavigate hook surfaced as a CustomEvent.
+   * @param {RoutingResult} - the resulting navigation information
+   */
   postNavigate(routingResult) {
     this.dispatchEvent(this._createEvent("postnavigate", routingResult));
     const title = routingResult.routeDefinition.metadata && routingResult.routeDefinition.metadata.title;
@@ -89,15 +99,27 @@ var RouterContainer = class extends import_lwc.LightningElement {
       }, 500);
     }
   }
+  /**
+   * The errorNavigate hook surfaced as a CustomEvent.
+   * @param {MessageObject} - error, the error encountered while navigating (if applicable)
+   */
   errorNavigate(error) {
     this.dispatchEvent(this._createEvent("errornavigate", error));
     return true;
   }
+  /**
+   * The preNavigate hook surfaced as a cancelable CustomEvent.
+   * @param {object} - address: The address being navigated to
+   * @param {boolean} - shouldReplace
+   */
   handleNavigation(address, replace) {
-    const event = this._createEvent("handlenavigation", {address, replace}, true);
+    const event = this._createEvent("handlenavigation", { address, replace }, true);
     this.dispatchEvent(event);
     return !event.defaultPrevented;
   }
+  /**
+   * Disconnect the router after DOM removal.
+   */
   disconnectedCallback() {
     if (this.routerApi) {
       this.routerApi.disconnect();
@@ -112,11 +134,9 @@ var RouterContainer = class extends import_lwc.LightningElement {
     });
   }
 };
-RouterContainer.renderMode = "light";
-__decorate([
+__decorateClass([
   import_lwc.api
 ], RouterContainer.prototype, "router", 2);
-__decorate([
+__decorateClass([
   import_lwc.api
 ], RouterContainer.prototype, "historyDisabled", 2);
-var routerContainer_default = RouterContainer;

package/build/cjs/modules/lwr/routerContainer/utils.cjs

@@ -1,56 +1,77 @@
-var __create = Object.create;
+"use strict";
 var __defProp = Object.defineProperty;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __markAsModule = (target) => __defProp(target, "__esModule", {value: true});
+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});
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __exportStar = (target, module2, desc) => {
-  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
-    for (let key of __getOwnPropNames(module2))
-      if (!__hasOwnProp.call(target, key) && key !== "default")
-        __defProp(target, key, {get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable});
+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 target;
-};
-var __toModule = (module2) => {
-  return __exportStar(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? {get: () => module2.default, enumerable: true} : {value: module2, enumerable: true})), module2);
+  return to;
 };
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // packages/@lwrjs/router/src/modules/lwr/routerContainer/utils.ts
-__markAsModule(exports);
-__export(exports, {
+var utils_exports = {};
+__export(utils_exports, {
   createNavigationContext: () => createNavigationContext
 });
-var import_historyRouter = __toModule(require("lwr/historyRouter"));
-var import_routerErrors = __toModule(require("lwr/routerErrors"));
-var import_domRouter = __toModule(require("lwr/domRouter"));
+module.exports = __toCommonJS(utils_exports);
+var import_historyRouter = require("lwr/historyRouter");
+var import_routerErrors = require("lwr/routerErrors");
+var import_domRouter = require("lwr/domRouter");
 var hasRoot = false;
 function createNavigationContext(node, config = {}, portableRouter) {
   const newRouter = config.historyDisabled ? new import_domRouter.DomRouterImpl(config, portableRouter, node) : new import_historyRouter.HistoryRouter(config, portableRouter, node);
   const routerAPI = {
+    /**
+     * Surface the preNavigate hook register function.
+     *
+     * @param {function} listener - The preNavigate hook listener function
+     * @returns {object} - This bag of Router functions, for chaining
+     */
     addPreNavigate: (listener) => {
       newRouter.addPreNavigate(listener);
       return routerAPI;
     },
+    /**
+     * Surface the postNavigate hook register function.
+     *
+     * @param {function} listener - The postNavigate hook listener function
+     * @returns {object} - This bag of Router functions, for chaining
+     */
     addPostNavigate: (listener) => {
       newRouter.subscribe(listener);
       return routerAPI;
     },
+    /**
+     * Surface the errorNavigate hook register function.
+     *
+     * @param {function} listener - The errorNavigate hook listener function
+     * @returns {object} - This bag of Router functions, for chaining
+     */
     addErrorNavigate: (listener) => {
       newRouter.addErrorNavigate(listener);
       return routerAPI;
     },
+    /**
+     * Connect the root router if there isn't already one connected.
+     */
     connect: () => {
       newRouter.connect();
       (0, import_routerErrors.invariant)(!hasRoot || !!newRouter.parent, import_routerErrors.messages.MULTIPLE_ROOTS);
       hasRoot = hasRoot || !newRouter.parent;
       routerAPI.id = newRouter.contextId;
     },
+    /**
+     * Disconnect the router, and reset the root tracking variable.
+     */
     disconnect: () => {
       hasRoot = hasRoot && !!newRouter.parent;
       newRouter.disconnect();

package/build/cjs/modules/lwr/routerErrors/routerErrors.cjs

@@ -1,18 +1,31 @@
+"use strict";
 var __defProp = Object.defineProperty;
-var __markAsModule = (target) => __defProp(target, "__esModule", {value: true});
+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});
+    __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);
 
 // packages/@lwrjs/router/src/modules/lwr/routerErrors/routerErrors.ts
-__markAsModule(exports);
-__export(exports, {
+var routerErrors_exports = {};
+__export(routerErrors_exports, {
   generateMessage: () => generateMessage,
   generateMessageObject: () => generateMessageObject,
   invariant: () => invariant,
   messages: () => messages
 });
+module.exports = __toCommonJS(routerErrors_exports);
 var ERROR_CODE_PREFIX = "LWR";
 var DiagnosticLevel = {
   Fatal: 0,

package/build/cjs/modules/lwr/routerUtils/domUtils.cjs

@@ -1,13 +1,26 @@
+"use strict";
 var __defProp = Object.defineProperty;
-var __markAsModule = (target) => __defProp(target, "__esModule", {value: true});
+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});
+    __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);
 
 // packages/@lwrjs/router/src/modules/lwr/routerUtils/domUtils.ts
-__markAsModule(exports);
-__export(exports, {
+var domUtils_exports = {};
+__export(domUtils_exports, {
   hasDocument: () => hasDocument
 });
+module.exports = __toCommonJS(domUtils_exports);
 var hasDocument = typeof document !== "undefined";