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

package/build/bundle/prod/lwr/navigation/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/navigation/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/navigation/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/navigation/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/navigation/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/navigation/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/navigation/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/navigation/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/navigation/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/navigation/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/navigation/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/navigation/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/navigation/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/navigation/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/navigation/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/navigation/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/navigation/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/navigation/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

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

@@ -0,0 +1,19 @@
+import { LightningElement } from 'lwc';
+import type { Constructable } from 'lwr/routerUtils';
+export interface OutletErrorCallback {
+    (error: Error, stack: string): void;
+}
+export default class Outlet extends LightningElement {
+    static renderMode: string;
+    refocusOff: boolean;
+    outletErrorCallback?: OutletErrorCallback;
+    viewName: string;
+    viewCtor?: Constructable;
+    previousViewCtor?: Constructable;
+    hasError: boolean;
+    setView(currentView: Constructable): void;
+    renderedCallback(): void;
+    errorCallback(e: Error, stack: string): void;
+    refocus(): void;
+}
+//# sourceMappingURL=outlet.d.ts.map

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

@@ -0,0 +1,11 @@
+/**
+ * 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 { PageReference, RouteCallback, RouteDefinition, RouteHandler, RouteHandlerClass, Router, RouterConfig, RouteDestination, RoutingMatch, RoutingResult, ViewSet, ViewInfo } from 'lwr/routerUtils';
+export declare function createRouter(config?: RouterConfig): Router<PageReference>;
+export type { PageReference, Router, RouterConfig, RouteCallback, RouteDefinition, RouteDestination, RouteHandler, RouteHandlerClass, RoutingMatch, RoutingResult, ViewSet, ViewInfo, };
+export type { Module, RouteHandlerCallback, RouteHandlerModule, RouteInstance, StringAttributes, } from 'lwr/routerUtils';
+//# sourceMappingURL=router.d.ts.map

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

@@ -0,0 +1,13 @@
+import type { PageReference } from 'lwr/router';
+import type { MessageObject } from 'lwr/routerUtils';
+export interface RouterBridgeApi {
+    navigate: (pageRef: PageReference) => boolean;
+}
+export interface RouterBridgeConfig {
+    historyDisabled?: boolean;
+    onReady?: () => void;
+    onPostNavigate?: (pageRef: PageReference | undefined) => void;
+    onError?: (error: MessageObject) => boolean;
+}
+export declare function createBridge(config?: RouterBridgeConfig, target?: globalThis.EventTarget): RouterBridgeApi;
+//# sourceMappingURL=routerBridge.d.ts.map