@lwrjs/router 0.10.0-alpha.12 → 0.10.0-alpha.13

package/build/bundle/prod/lwr/navigation/es/services/module-provider/index.d.ts

@@ -0,0 +1,22 @@
+import type { AbstractModuleId, ModuleCompiled, ModuleEntry, ModuleProvider, ProviderContext } from '@lwrjs/types';
+interface RouterProviderOptions {
+    routesDir?: string;
+}
+export default class RouterModuleProvider implements ModuleProvider {
+    name: string;
+    version: string;
+    routesDir: string;
+    appBasePath?: string;
+    private routerEmitter;
+    private routerWatcher?;
+    private watchedFileMap;
+    private routerModuleCache;
+    constructor({ routesDir }: RouterProviderOptions, context: ProviderContext);
+    onRouterModuleChange(configPath: string, deleted?: boolean): Promise<void>;
+    private watchConfigs;
+    private getRouterConfig;
+    getModuleEntry({ specifier }: AbstractModuleId): Promise<ModuleEntry | undefined>;
+    getModule(moduleId: AbstractModuleId): Promise<ModuleCompiled | undefined>;
+}
+export {};
+//# sourceMappingURL=index.d.ts.map

package/build/bundle/prod/lwr/navigation/es/services/module-provider/utils.d.ts

@@ -0,0 +1,27 @@
+import type { Watcher } from '@lwrjs/types';
+import type { LwrRouterConfig } from '../index.js';
+import type { WatcherFactory } from '@lwrjs/types';
+export declare const SPECIFIER_PREFIX = "@lwrjs/router/";
+/**
+ * Parse a specifier into its Router Config ID
+ * Return undefined if the specifier is invalid
+ * @param specifier - The raw specifier to parse
+ */
+export declare function parseSpecifier(specifier: string): string | undefined;
+/**
+ * Given a Router Config ID and directory, return the file path to the router metadata
+ * @param dir       - Path to directory containing Router Config files
+ * @param specifier - Specifier for the Router Config module
+ */
+export declare function getRouterConfigPath(dir: string, specifier: string): string;
+/**
+ * Set up a file system watcher; used to spy on Router Config file changes
+ * @param onModuleChange - File change callback function
+ */
+export declare function setUpWatcher(factory: WatcherFactory, onModuleChange: (file: string, deleted?: boolean) => void): Watcher;
+/**
+ * Generate a module string which fulfills a router request
+ * @param routes - The array of route definitions
+ */
+export declare function generateModule(config?: LwrRouterConfig): string;
+//# sourceMappingURL=utils.d.ts.map

package/build/bundle/prod/lwr/navigation/navigation.js

@@ -1 +1,2 @@
 function e(e){if(null==e)throw new TypeError("Provider must be defined.")}class t{constructor(e){this.infoMap=new WeakMap,this.defaultValue=e}getInfo(e){let t=this.infoMap.get(e);return void 0===t&&(t={consumers:new Set},this.infoMap.set(e,t)),t}setContext(t,n){e(t);const o=n,r=this.getInfo(t);r.contextValue=n,r.consumers.forEach((e=>e.provide(o))),0===r.consumers.size&&o?.onComplete&&o.onComplete()}getContext(t){e(t);const{contextValue:n}=this.getInfo(t);return void 0!==n?n:this.defaultValue}clearContext(t){e(t),this.infoMap.delete(t)}subscribeContext(t,n){e(t);const{consumers:o,contextValue:r}=this.getInfo(t);o.has(n)||(o.add(n),n.provide(r))}unsubscribeContext(t,n){e(t),this.getInfo(t).consumers.delete(n)}}function n(e,t){var n=Object.keys(e);if(Object.getOwnPropertySymbols){var o=Object.getOwnPropertySymbols(e);t&&(o=o.filter((function(t){return Object.getOwnPropertyDescriptor(e,t).enumerable}))),n.push.apply(n,o)}return n}function o(e){for(var t=1;t<arguments.length;t++){var o=null!=arguments[t]?arguments[t]:{};t%2?n(Object(o),!0).forEach((function(t){r(e,t,o[t])})):Object.getOwnPropertyDescriptors?Object.defineProperties(e,Object.getOwnPropertyDescriptors(o)):n(Object(o)).forEach((function(t){Object.defineProperty(e,t,Object.getOwnPropertyDescriptor(o,t))}))}return e}function r(e,t,n){return(t=function(e){var t=function(e,t){if("object"!=typeof e||null===e)return e;var n=e[Symbol.toPrimitive];if(void 0!==n){var o=n.call(e,t||"default");if("object"!=typeof o)return o;throw new TypeError("@@toPrimitive must return a primitive value.")}return("string"===t?String:Number)(e)}(e,"string");return"symbol"==typeof t?t:String(t)}(t))in e?Object.defineProperty(e,t,{value:n,enumerable:!0,configurable:!0,writable:!0}):e[t]=n,e}const a="LWR",i=1;function s(e,t){return Array.isArray(t)?e.replace(/\{([0-9]+)\}/g,((e,n)=>t[n])):e}function c(e,t){return`${e.code}: ${s(e.message,t)}`}function l(e,t){const n=o(o({},e),{},{message:s(e.message,t)});return e.address&&(n.address=s(e.address,t)),e.stack&&(n.stack=s(e.stack,t)),n}const u={INVALID_MIXIN_CMP:{code:`${a}4001`,message:"{0} must be an Element type",level:i},MISSING_CONTEXT:{code:`${a}4002`,message:"Could not find context to perform navigation action.",level:i},INVALID_CONTEXT:{code:`${a}4003`,message:"Cannot register navigation context; it must have this shape: { navigate, generateUrl, subscribe }",level:i},MULTIPLE_ROOTS:{code:`${a}4004`,message:"Router connection failed. There can only be one root router.",level:i},MULTIPLE_CHILDREN:{code:`${a}4005`,message:"Could not add to the navigation hierarchy. There can only be one child per navigation node.",level:i},MISSING_ROUTE:{code:`${a}4006`,message:'A route cannot be created to navigate to URL "{0}"',level:i,address:"{0}"},MISSING_URL:{code:`${a}4007`,message:'A URL cannot be created to navigate to route "{0}"',level:i,address:"{0}"},PRENAV_FAILED:{code:`${a}4008`,message:'A preNavigate hook listener blocked routing to "{0}"',level:2,address:"{0}"},MISSING_ROUTE_TEMPLATE:{code:`${a}4009`,message:'A route definition must contain a "uri" property.',level:i},MISSING_ROUTE_CMP:{code:`${a}4016`,message:"Expected a route view component with a default export.",level:i},MISSING_DATA_CONTEXT:{code:`${a}4018`,message:"Could not find context to retrieve navigation data.",level:i},INVALID_ROUTE_QUERY:{code:`${a}4019`,message:"Invalid query param in route definition.",level:i},MISSING_PAGE_BINDING:{code:`${a}4020`,message:"Route definition must provide page binding",level:i},INVALID_PAGE_BINDING:{code:`${a}4021`,message:"Invalid page binding in route definition",level:i},INVALID_URI_SYNTAX:{code:`${a}4022`,message:"Invalid uri syntax. URI cannot contain *, +, (, ), ",level:i},VIEW_IMPORT_FAILED:{code:`${a}4023`,message:'Error importing view with name "{0}", failure was: {1}',level:i,stack:"{2}"},VIEW_MISSING:{code:`${a}4024`,message:'Expected a view with name "{0}" in the viewset',level:i},VIEW_IMPORT_FAILED_WITH_SPECIFIER:{code:`${a}4025`,message:'Error importing module "{0}" from view with name "{1}", failure was: {2}',level:i,stack:"{3}"},NO_ROUTE_MATCH:{code:`${a}4026`,message:"A routing match cannot be found for: {0}",level:i},INVALID_ROUTE_HANDLER:{code:`${a}4027`,message:'Route definition "{0}" does not have a valid route handler module',level:i},DESTINATION_NOT_FOUND:{code:`${a}4028`,message:"Route handler returned 404: Not Found",level:i},DESTINATION_ERROR:{code:`${a}4029`,message:"Route handler returned error status {0}: {1}",level:i,stack:"{2}"}},d=new WeakMap;function v(e){const t=d.get(e);if(!t||!t.value)throw new Error(c(u.MISSING_CONTEXT));return t.value}function I(e,t){const n={id:e,value:t,update:e=>{n.value=e}};return d.set(n.id,n),n}function g(e){var t;return(t=class{constructor(e){this._callback=e}connect(){}disconnect(){}update(e,t){t&&this._callback(t)}static setContext(t,n){e.setContext(t,n)}static getContext(t){return e.getContext(t)}static clearContext(t){e.clearContext(t)}static subscribeContext(t,n){e.subscribeContext(t,n)}static unsubscribeContext(t,n){e.unsubscribeContext(t,n)}}).contextSchema={value:"required"},t}const f=g(new t(void 0)),m=g(new t(void 0)),p=new t(void 0),h=class extends(g(p)){async update(e,t){if(t){const n=e&&e.viewName?e.viewName:"default",o=t.viewset[n],r=o,a=r&&r.module||o;let i;if(a)try{const e=await a(),t=e&&e.default;if(!t||void 0===t.constructor)throw new Error("error occurred with view import");this._callback(t)}catch(e){const t=e;i=r.specifier?l(u.VIEW_IMPORT_FAILED_WITH_SPECIFIER,[r.specifier,n,t.message,t.stack||""]):l(u.VIEW_IMPORT_FAILED,[n,t.message,t.stack||""])}else i=l(u.VIEW_MISSING,[n]);t.onComplete&&t.onComplete(i)}}};function b(e,t,n){v(e).navigate(t,n)}function E(e,t){return v(e).generateUrl(t)}const _=`universalcontainergetnavigationcontext${Math.floor(65536*(1+Math.random())).toString(16).substring(1)}`,N=Symbol("Navigate"),w=Symbol("GenerateUrl"),O=Symbol("NavContext"),S=Symbol("NavContext");function C(e){!function(e,t,n){if(!e)throw new Error(c(t,n))}("function"==typeof e.prototype.dispatchEvent,u.INVALID_MIXIN_CMP,[e.toString()]);return class extends e{[S](){if(!this[O]&&(this.dispatchEvent(new CustomEvent(_,{bubbles:!0,composed:!0,detail:{callback:e=>{this[O]=e}}})),!this[O]))throw new Error(c(u.MISSING_CONTEXT))}[N](e,t){this[S](),b(this[O],e,t)}async[w](e){return this[S](),E(this[O],e)}}}C.Navigate=N,C.GenerateUrl=w,C.NavContext=O;export{t as ContextInfo,m as CurrentPageReference,h as CurrentView,f as NavigationContext,C as NavigationMixin,g as generateContextualWireAdapter,E as generateUrl,v as getNavigationHelm,b as navigate,I as registerNavigationHelm};
+//# sourceMappingURL=navigation.js.map

package/build/bundle/prod/lwr/router/es/modules/lwr/contextProvider/contextProvider.d.ts

@@ -0,0 +1,14 @@
+import { Contextualizer } from 'lwc';
+import type { ContextualWireAdapter } from 'lwr/contextUtils';
+export declare const currentPageReferenceContextualizer: Contextualizer | undefined;
+export declare const currentViewContextualizer: Contextualizer | undefined;
+export declare const navigationContextContextualizer: Contextualizer | undefined;
+/**
+ *
+ * @param {TContext} contextValue - Context API object
+ * @param {EventTarget} providerNode - Context DOM element
+ * @param {Contextualizer} contextualizer - Function for providing this context to subtree nodes wired to a specific adapter
+ * @param {ContextualWireAdapter<TContext, TEmit, TConfig>} contextualAdapter - Contextual wire adapter capable of subscribing to context changes
+ */
+export declare function provideContext<TContext, TEmit, TConfig>(contextValue: TContext, providerNode: EventTarget, contextualizer?: Contextualizer, contextualAdapter?: ContextualWireAdapter<TContext, TEmit, TConfig>): void;
+//# sourceMappingURL=contextProvider.d.ts.map

package/build/bundle/prod/lwr/router/es/modules/lwr/contextUtils/contextInfo.d.ts

@@ -0,0 +1,60 @@
+import type { ContextConsumer } from 'lwc';
+/**
+ * Manages context for various providers
+ */
+export declare class ContextInfo<TContext> {
+    private infoMap;
+    /**
+     * The default value to be returned in the absence of a defined context
+     */
+    private defaultValue;
+    constructor(defaultValue: TContext);
+    /**
+     * Gets the stored info for a context provider
+     * @param targetProvider the context provider
+     */
+    getInfo(targetProvider: object): {
+        consumers: Set<ContextConsumer>;
+        contextValue: TContext;
+    };
+    /**
+     * Set the context value directly associated with the target as a context provider.
+     *
+     * @param {Object} targetProvider
+     * @param {FeatureContext} contextValue
+     */
+    setContext(targetProvider: object, contextValue: TContext): void;
+    /**
+     * Get the context value directly associated with the target as a context provider.
+     *
+     * @param {Object} targetProvider
+     */
+    getContext(targetProvider: object): TContext;
+    /**
+     * Clear the context value and registered subscribers directly associated with the
+     * target as a context provider.
+     *
+     * @param {Object} targetProvider
+     */
+    clearContext(targetProvider: object): void;
+    /**
+     * Subscribe a consumer to the context value directly associated with the target as
+     * a context provider. Calls to #set(targetProvider, contextValue) with the same
+     * target will invoke the consumer.provide(contextValue) function.
+     *
+     * NOTE: Mutations to the contextValue directly do not result in calls to
+     * consumer.provide(contextValue).
+     *
+     * @param {Object} targetProvider
+     * @param {ContextConsumer} consumer object with a provide(context) function property.
+     */
+    subscribeContext(targetProvider: object, consumer: ContextConsumer): void;
+    /**
+     * Unsubscribe a previously subscribed consumer from listening to changes on the
+     * target
+     * @param {Object} targetProvider
+     * @param {ContextConsumer} consumer
+     */
+    unsubscribeContext(targetProvider: object, consumer: ContextConsumer): void;
+}
+//# sourceMappingURL=contextInfo.d.ts.map

package/build/bundle/prod/lwr/router/es/modules/lwr/contextUtils/contextUtils.d.ts

@@ -0,0 +1,24 @@
+import type { ContextConsumer } from 'lwc';
+import { ContextInfo } from './contextInfo';
+export { ContextInfo };
+export type { NavigationHelm } from './navigationApiStore';
+export { getNavigationHelm, registerNavigationHelm } from './navigationApiStore';
+export interface WireAdapter<TContext, TConfig, TEmit> {
+    _callback(value: TEmit): void;
+    update(config: TConfig, context: TContext): void;
+    connect(): void;
+    disconnect(): void;
+}
+/**
+ * Interface for contextual wire adapters to subscribe to context changes
+ */
+export interface ContextualWireAdapter<TContext, TConfig, TEmit> {
+    new (callback: (value: TEmit) => void): WireAdapter<TContext, TConfig, TEmit>;
+    setContext: (targetProvider: globalThis.EventTarget, contextValue: TContext) => void;
+    getContext: (targetProvider: globalThis.EventTarget) => TContext;
+    clearContext: (targetProvider: globalThis.EventTarget) => void;
+    subscribeContext: (targetProvider: globalThis.EventTarget, consumer: ContextConsumer) => void;
+    unsubscribeContext: (targetProvider: globalThis.EventTarget, consumer: ContextConsumer) => void;
+}
+export declare function generateContextualWireAdapter<TContext, TConfig = unknown, TEmit = TContext>(contextInstance: ContextInfo<TContext>): ContextualWireAdapter<TContext, TConfig, TEmit>;
+//# sourceMappingURL=contextUtils.d.ts.map

package/build/bundle/prod/lwr/router/es/modules/lwr/contextUtils/navigationApiStore.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Copyright (c) 2019, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: MIT
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
+ */
+import type { RouteCallback, PageReference } from 'lwr/router';
+import type { Unsubscriber } from 'lwr/observable';
+import type { ContextId } from 'lwr/navigationContext';
+/**
+ * Provides the ability for a given context provider to find its NavigationHelm
+ * provider by just an ID. Having access to the NavigationHelm allows the consumer
+ * to direct navigation. Generally, the Helm is more powerful than the exposed APIs.
+ */
+export interface NavigationHelm {
+    navigate: (address: PageReference, replace?: boolean) => void;
+    generateUrl: (address: PageReference) => string | null;
+    subscribe: (callback: RouteCallback, replay?: boolean) => Unsubscriber;
+}
+interface NavigationContextData {
+    id: ContextId;
+    value: NavigationHelm;
+    update: (newValue: NavigationHelm) => void;
+}
+/**
+ * Return a navigation context by ID.
+ * Exported API.
+ *
+ * @param {*} id - The ID of a navigation context.
+ *
+ * @return {object} - { navigate(), generateUrl(), subscribe() }
+ */
+export declare function getNavigationHelm(id: ContextId): NavigationHelm;
+/**
+ * Create and return the metadata for this context provider.
+ * Cache the metadata by ID.
+ *
+ * @param {object} contextValue - Context API object
+ * @param {RouteDefinition[]} data - Route data for this context
+ *
+ * @return {object} - The metadata object
+ */
+export declare function registerNavigationHelm(contextId: ContextId, contextValue: NavigationHelm): NavigationContextData;
+export {};
+//# sourceMappingURL=navigationApiStore.d.ts.map

package/build/bundle/prod/lwr/router/es/modules/lwr/currentPageReference/currentPageReference.d.ts

@@ -0,0 +1,9 @@
+import type { PageReference } from 'lwr/router';
+declare type PageReferenceContext = PageReference | undefined;
+/**
+ * Services @wire(CurrentPageReference) requests.
+ * Hooks up to an Observable from the current navigation context.
+ */
+export declare const CurrentPageReference: import("lwr/contextUtils").ContextualWireAdapter<PageReferenceContext, unknown, PageReferenceContext>;
+export {};
+//# sourceMappingURL=currentPageReference.d.ts.map

package/build/bundle/prod/lwr/router/es/modules/lwr/currentView/currentView.d.ts

@@ -1,10 +1,11 @@
+/// <reference types="lwc" />
 import type { ViewSet } from 'lwr/router';
 import type { Constructable } from 'lwr/routerUtils';
-type ViewContext = {
+declare type ViewContext = {
     viewset: ViewSet;
     onComplete?: Function;
 } | undefined;
-type CurrentViewConfig = {
+declare type CurrentViewConfig = {
     viewName?: string;
 };
 /**

package/build/bundle/prod/lwr/router/es/modules/lwr/domRouter/domRouter.d.ts

@@ -0,0 +1,192 @@
+/**
+ * Copyright (c) 2019, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: MIT
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
+ */
+import type { RouteChange, DomRouterConfig } from 'lwr/domRouterUtils';
+import type { ContextId } from 'lwr/navigationContext';
+import type { Filter, MessageObject } from 'lwr/routerUtils';
+import type { PageReference, Router, RouteCallback, RoutingMatch, RoutingResult } from 'lwr/router';
+import type { Observable, Unsubscriber } from 'lwr/observable';
+export declare const NAV_EVENT: string;
+export declare const PARENT_EVENT: string;
+interface RouterParent {
+    addChild(child: DomRouter): Promise<void>;
+}
+export declare type ParentRouterEvent = CustomEvent<(router: RouterParent) => void>;
+declare type DomRoutingMatch = RoutingMatch & {
+    url: string;
+};
+interface DomRouterNode extends RouterParent {
+    root: DomRouter;
+    parent?: DomRouter;
+    child?: DomRouter;
+    connected: boolean;
+    process(url: string, replace?: boolean): Promise<boolean>;
+    processError(messageObject: MessageObject): void;
+    preProcess(url: string): Promise<boolean>;
+}
+export interface DomRouter extends DomRouterNode {
+    router: Router<PageReference>;
+    pendingRoute: DomRoutingMatch | null;
+    committedRoute: DomRoutingMatch | null;
+    contextId: ContextId;
+    historyDisabled?: boolean;
+    connect(): void;
+    disconnect(): void;
+    addPreNavigate(filters: Filter<RouteChange> | Filter<RouteChange>[]): void;
+    addErrorNavigate(filters: Filter<MessageObject> | Filter<MessageObject>[]): void;
+    navigate(address: PageReference, replace?: boolean): void;
+    generateUrl(address: PageReference): string | null;
+    subscribe(callback: RouteCallback, replay?: boolean): Unsubscriber;
+}
+export declare class DomRouterImpl implements DomRouter {
+    config: Required<DomRouterConfig>;
+    target: EventTarget;
+    router: Router<PageReference>;
+    pendingRoute: DomRoutingMatch | null;
+    committedRoute: DomRoutingMatch | null;
+    routeObservable: Observable<RoutingResult>;
+    eventId?: string;
+    contextId: ContextId;
+    connected: boolean;
+    parent?: DomRouter;
+    child?: DomRouter;
+    preNavFilters: import("lwr/routerUtils").FilterChain<RouteChange>;
+    errorNavFilters: import("lwr/routerUtils").FilterChain<MessageObject>;
+    /**
+     * Create and configure the Router.
+     *
+     * @param {object} config - The domRouter config object, all properties are optional
+     * @param {object} router - an optional Router
+     * @param {HTMLElement} target - DOM node to attach to
+     */
+    constructor(config: DomRouterConfig, router: Router<PageReference>, target?: EventTarget);
+    /**
+     * Search up the node chain until the root node is hit
+     */
+    get root(): DomRouter;
+    /**
+     * Informs an wire listeners of routing changes/errors
+     *
+     * @param {RoutingResult} result - result object from navigation event
+     * @param {string} url - url from the page reference that triggered the navigation event
+     * @param {MessageObject} error - if an error occurred during the navigation
+     */
+    updateWires(result: RoutingResult, url: string, error?: MessageObject): void;
+    /**
+     * Override to provide this router as a navigation context
+     */
+    connect(): void;
+    disconnect(): void;
+    /**
+     * Add listeners to this router hook which run BEFORE a new URL is processed (root -> leaf).
+     *
+     * @param {object | object[]} filters
+     */
+    addPreNavigate(filters: Filter<RouteChange> | Filter<RouteChange>[]): void;
+    /**
+     * Add listeners to this router hook which run when there is an error navigating.
+     *
+     * @param {object | object[]} filters
+     */
+    addErrorNavigate(filters: Filter<MessageObject> | Filter<MessageObject>[]): void;
+    /**
+     * Override parent implementation.
+     * Pass the current state down to a new child.
+     *
+     * @param {child} child - Child router
+     */
+    addChild(child: DomRouter): Promise<void>;
+    /**
+     * Process the current URL passed down by the parent router.
+     * Stop propagation of the navigation event if a preNavigate filter returns false.
+     *
+     * Update the current path and route matches.
+     * Update the observable to hold the new route.
+     *
+     * After processing, delegate to a child router, if it exists.
+     *
+     * @param {string} url - Relative URL string to process
+     * @returns {boolean} - True if the processing was NOT blocked by a preNavigate listener
+     */
+    process(url: string, replace?: boolean): Promise<boolean>;
+    /**
+     * Run the preNavigate filters for this router.
+     * After processing, delegate to a child router, if it exists.
+     *
+     * @param {string} url - Relative URL string to process,
+     *                   cannot use a route since the processing is done in context
+     *
+     * @returns {Promise<boolean>} - Resolves to true if successful
+     */
+    preProcess(url: string): Promise<boolean>;
+    /**
+     * Run the errorNavigate filters for this router.
+     * After processing, delegate to a child router, if it exists.
+     *
+     * @param {object} e - An error object to pass into the error hook listeners.
+     */
+    processError(messageObject: MessageObject): void;
+    /**
+     * lightning/navigation
+     * Fire an event to send the navigation event up the DOM.
+     * The root router will be the last to catch the event if it is not stopped.
+     *
+     * @param {object} address - Address to navigate to
+     * @param {*} options - Usually a boolean; when true the previous browser history
+     *                    entry should be replaced by this one
+     */
+    navigate(address: PageReference, replace?: boolean): void;
+    /**
+     * lightning/navigation
+     * Generate a URL based on the given route.
+     * Return a Promise containing the URL string.
+     *
+     * @param   {object} route - Route to generate a url for
+     *
+     * @returns {Promise<string>}
+     */
+    generateUrl(address: PageReference): string | null;
+    /**
+     * 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: RouteCallback, replay?: boolean): Unsubscriber;
+    /**
+     * Inspect a navigation event bubbling up from a descendent component.
+     * This node can choose to stop the event by returning false.
+     * If propagation is not stopped, and this node is the root (no parent),
+     *      then begin the root -> leaf processing of this new route.
+     *      This will update the navigation event subscribers in each DomRouter, top down.
+     *
+     * @param {Event} event - With detail: { url, options }
+     */
+    private _handleNavigationEvent;
+    /**
+     * Be discovered as a parent for descendent components.
+     * Stop immediate propagation because we only want 1 parent to be found.
+     *
+     * @param {Event} event - With detail: callback
+     */
+    private _handleParentEvent;
+    private _sendEvent;
+    private _stripUrlForChild;
+}
+/**
+ * Create a new root Router, attach to the Window.
+ * This is the public, programmatic API for root router creation.
+ * An application can only have ONE root router.
+ *
+ * @param {object} config - The router config object
+ *
+ * @returns {object} - { addPreNavigate, addErrorNavigate, connect, disconnect }
+ */
+export declare function createDomRouter(config: DomRouterConfig, router: Router<PageReference>, target?: EventTarget): DomRouter;
+export {};
+//# sourceMappingURL=domRouter.d.ts.map

package/build/bundle/prod/lwr/router/es/modules/lwr/domRouterUtils/domRouterUtils.d.ts

@@ -0,0 +1,4 @@
+export { getRelativeUrl } from './uriUtils';
+export { set, replace } from './historyUtils';
+export type { DomRouterConfig, NavigationHandler, RouteChange } from './types';
+//# sourceMappingURL=domRouterUtils.d.ts.map

package/build/bundle/prod/lwr/router/es/modules/lwr/domRouterUtils/historyUtils.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Copyright (c) 2019, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: MIT
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
+ */
+import { RouteInstance } from '../routerUtils/types';
+/**
+ * Sets a history state.
+
+ * @param {string} path - query to set
+ * @param {object} route - history state object
+ */
+export declare function set(path: string, route?: RouteInstance): void;
+/**
+ * Replaces the current history state.
+ * @param {string} path - query to use as a replacement
+ * @param {object} route - history state object
+ */
+export declare function replace(path: string, route?: RouteInstance): void;
+//# sourceMappingURL=historyUtils.d.ts.map

package/build/bundle/prod/lwr/router/es/modules/lwr/domRouterUtils/types.d.ts

@@ -0,0 +1,16 @@
+import type { RoutingMatch, PageReference, StringAttributes } from 'lwr/router';
+export interface RouteChange {
+    current?: RoutingMatch;
+    next: RoutingMatch;
+}
+export declare type NavigationHandler = (address: PageReference, replace?: boolean) => boolean;
+export interface DomRouterConfig {
+    handleNavigation?: NavigationHandler;
+}
+export interface UrlObject {
+    href: string;
+    origin: string;
+    pathname: string;
+    searchParams: StringAttributes;
+}
+//# sourceMappingURL=types.d.ts.map

package/build/bundle/prod/lwr/router/es/modules/lwr/domRouterUtils/uriUtils.d.ts

@@ -0,0 +1,30 @@
+import type { UrlObject } from './types';
+/**
+ * helper: f(url) -> new URL
+ * Query parameter values are URI decoded.
+
+ * @param {string} url - URL string to turn into a URL object
+
+ * @returns {object} { href, pathname, searchParams }
+
+ * @example
+ * {
+ *      href: 'http://localhost:3001/products?lwr.mode=prod&lwr.locale=es#section',
+ *      origin: 'http://localhost:3001',
+ *      pathname: '/products',
+ *      searchParams: {
+ *          'lwr.mode': 'prod',
+ *          'lwr.locale': 'es'
+ *      }
+ * }
+ */
+export declare function getUrlObject(url?: string): UrlObject;
+/**
+ * f(url) -> "/some/relative/path?param1=one&param2=two&param3"
+
+ * @param {string} url - URL string to make relative, may be a no-op
+
+ * @return {string}
+ */
+export declare function getRelativeUrl(url: string): string;
+//# sourceMappingURL=uriUtils.d.ts.map

package/build/bundle/prod/lwr/router/es/modules/lwr/historyRouter/historyRouter.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Copyright (c) 2019, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: MIT
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
+ */
+import { DomRouterImpl } from 'lwr/domRouter';
+import type { Router, PageReference } from 'lwr/router';
+import type { DomRouterConfig } from 'lwr/domRouterUtils';
+export declare class HistoryRouter extends DomRouterImpl {
+    historyDisabled: boolean;
+    /**
+     * Override.
+     * Initialize with the current route and listen to the popstate event for future changes.
+     */
+    connect(): void;
+    onpopstate(): void;
+    disconnect(): void;
+    /**
+     * Override.
+     * Update the browser history if the preNavigate hooks.
+     *
+     * @param {string} url - The URL to go to
+     * @param {boolean} shouldReplace - True if the current history state should be replaced
+     * @param {boolean} updateHistory - True if the browser history should be updated with the new URL
+     *
+     * @returns {boolean} - True if the processing was NOT blocked by a preNavigate listener
+     */
+    process(url: string, shouldReplace: boolean, updateHistory?: boolean): Promise<boolean>;
+    /**
+     * Update the root route, and trickle down the router tree.
+     * Redirect to use the base path, if it is missing.
+     *
+     * @param {string} url - The URL to go to
+     */
+    catchBrowserUpdate(url: string): void;
+}
+/**
+ * Create a new root Router, attach to the Window.
+ * This is the public, programmitic API for root router creation.
+ * An application can only have ONE root router.
+ *
+ * @param {object} config - The router config object
+ *
+ * @returns {object} - { addPreNavigate, addPostNavigate, addErrorNavigate, connect, disconnect }
+ */
+export declare function createHistoryRouter(config: DomRouterConfig, router: Router<PageReference>, target?: EventTarget): HistoryRouter;
+//# sourceMappingURL=historyRouter.d.ts.map

package/build/bundle/prod/lwr/router/es/modules/lwr/navigation/navigation.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Copyright (c) 2019, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: MIT
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
+ */
+export { NavigationContext } from 'lwr/navigationContext';
+export { CurrentPageReference } from 'lwr/currentPageReference';
+export { CurrentView } from 'lwr/currentView';
+export type { ContextId } from 'lwr/navigationContext';
+export type { PageReference, RouteInstance } from 'lwr/router';
+export type { Constructable } from 'lwr/routerUtils';
+export { ContextInfo, getNavigationHelm, registerNavigationHelm, generateContextualWireAdapter, } from 'lwr/contextUtils';
+export { navigate, generateUrl } from './navigationApi';
+export { NavigationMixin } from './navigationMixin';
+//# sourceMappingURL=navigation.d.ts.map

package/build/bundle/prod/lwr/router/es/modules/lwr/navigation/navigationApi.d.ts

@@ -0,0 +1,22 @@
+import type { ContextId } from 'lwr/navigationContext';
+import type { PageReference } from 'lwr/router';
+/**
+ * Navigate programmatically.
+ * The Promise used within is deliberately not returned.
+ *
+ * @param {HTMLElement} context - The navigation context
+ * @param {object | string} loc - A route or URL for navigating
+ * @param {*} options - Usually a boolean; when true the previous browser history
+ *              entry should be replaced by this one
+ */
+export declare function navigate(context: ContextId, pageReference: PageReference, replace?: boolean): void;
+/**
+ * Generate a URL for the given route.
+ *
+ * @param {HTMLElement} context - The navigation context
+ * @param {object} route - A route
+ *
+ * @returns {Promise<string>}
+ */
+export declare function generateUrl(context: ContextId, pageReference: PageReference): string | null;
+//# sourceMappingURL=navigationApi.d.ts.map

package/build/bundle/prod/lwr/router/es/modules/lwr/navigation/navigationMixin.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Copyright (c) 2019, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: MIT
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
+ */
+import type { Constructor } from 'lwr/routerUtils';
+declare function NavigationMixin<TBase extends Constructor>(Base: TBase): TBase;
+declare namespace NavigationMixin {
+    var Navigate: unique symbol;
+    var GenerateUrl: unique symbol;
+    var NavContext: unique symbol;
+}
+export { NavigationMixin };
+//# sourceMappingURL=navigationMixin.d.ts.map

package/build/bundle/prod/lwr/router/es/modules/lwr/navigationContext/navigationContext.d.ts

@@ -0,0 +1,5 @@
+export declare type ContextId = () => void;
+declare type NavigationContextType = ContextId | undefined;
+export declare const NavigationContext: import("lwr/contextUtils").ContextualWireAdapter<NavigationContextType, unknown, NavigationContextType>;
+export {};
+//# sourceMappingURL=navigationContext.d.ts.map

package/build/bundle/prod/lwr/router/es/modules/lwr/navigationMixinHacks/navigationMixinHacks.d.ts

@@ -0,0 +1,7 @@
+export declare const CONTEXT_ID_BACKDOOR: string;
+export declare type NavigationContextBackdoorEvent = globalThis.CustomEvent<NavigationContextBackdoorEventPayload>;
+import type { ContextId } from 'lwr/navigation';
+export declare type NavigationContextBackdoorEventPayload = {
+    callback: (contextId: ContextId) => void;
+};
+//# sourceMappingURL=navigationMixinHacks.d.ts.map

package/build/bundle/prod/lwr/router/es/modules/lwr/observable/observable.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Copyright (c) 2019, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: MIT
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
+ */
+import type { Observer, Observable, Unsubscriber } from '@lwrjs/types';
+/**
+ * Creates a simple observable object, which can have any number of observers.
+ * @returns {object}
+ */
+export declare function createObservable<V>(): Observable<V>;
+export type { Observer, Observable, Unsubscriber };
+//# sourceMappingURL=observable.d.ts.map