@lwrjs/router 0.10.0-alpha.16 → 0.10.0-alpha.18

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

@@ -1,42 +0,0 @@
-import type { CompiledRouteDefinition, RouterSerializationConfig } from 'lwr/routerUtils';
-import type { QueryObject, CompiledQuery, QueryMatcher } from './types';
-/**
- * Parse the route definitions with path-to-regex functionality for paths, and
- * query parameter validation
- *
- * @example
- * {
- *      original: the user-defined route definition
- *      regex: regular expression based on the route definition path
- *      toPath: function which takes an object of parameters and creates a path
- *      params: an array of objects with info on each path parameter
- *      compiledQuery: an object that represents defined routeDefintion query params
- *      queryMatcher: a function that can be used to see if this route defintion
- *                   mataches against a given input QueryObject
- * }
- */
-export declare function parseRoutes<TAddress>(config: RouterSerializationConfig<TAddress>): CompiledRouteDefinition[];
-/**
- * Converts a QueryObject create from the routeDefintion.uri, and converts it into a
- * CompiledQuery object that represents the defined 1) queryStringKeys, 2) routeParameter name,
- * and 3) and what input is valid for this query. e.g.,
- *
- * Given the following uri: /path?someKey=:qParam, then "someKey" is the queryStringKey, ":qParam"
- * is the route parameter name, and any input would be valid.
- *
- * @param {QueryObject} queryObject - queryObject retrieved from the routeDefinition uri
- * @returns {CompiledQuery} - CompiledQuery
- */
-export declare function compileQueryObject(queryObject: QueryObject): CompiledQuery;
-/**
- * Takes a CompiledQuery a returns a QueryMatcher function that will match a QueryObject
- * against the CompiledQuery and returns either a MatchedQuery, representing all the
- * input values that match the CompiledQuery, or null if any input query parameter
- * doesn't match the CompiledQuery.
- *
- * @param compiledQuery - CompiledQuery object to use to create the matcher
- * @param {boolean} caseSensitive - true if this should case-sensitive match query values
- * @returns {QueryMatcher} - The queryMatcher function
- */
-export declare function getQueryMatcher(compiledQuery: CompiledQuery, caseSensitive?: boolean): QueryMatcher;
-//# sourceMappingURL=parseUtils.d.ts.map

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

@@ -1,128 +0,0 @@
-export interface ParseOptions {
-    /**
-     * Set the default delimiter for repeat parameters. (default: `'/'`)
-     */
-    delimiter?: string;
-    /**
-     * List of characters to automatically consider prefixes when parsing.
-     */
-    prefixes?: string;
-}
-/**
- * Parse a string for the raw tokens.
- */
-export declare function parse(str: string, options?: ParseOptions): Token[];
-export interface TokensToFunctionOptions {
-    /**
-     * When `true` the regexp will be case sensitive. (default: `false`)
-     */
-    sensitive?: boolean;
-    /**
-     * Function for encoding input strings for output.
-     */
-    encode?: (value: string, token: Key) => string;
-    /**
-     * When `false` the function can produce an invalid (unmatched) path. (default: `true`)
-     */
-    validate?: boolean;
-}
-export declare type PathFunction<P extends object = object> = (data?: P) => string;
-/**
- * Expose a method for transforming tokens into the path function.
- */
-export declare function tokensToFunction<P extends object = object>(tokens: Token[], options?: TokensToFunctionOptions): PathFunction<P>;
-/**
- * Compile a string to a template function for the path.
- */
-export declare function compile<P extends object = object>(str: string, options?: ParseOptions & TokensToFunctionOptions): PathFunction<P>;
-export interface RegexpToFunctionOptions {
-    /**
-     * Function for decoding strings for params.
-     */
-    decode?: (value: string, token: Key) => string;
-}
-/**
- * A match result contains data about the path match.
- */
-export interface MatchResult<P extends object = object> {
-    path: string;
-    index: number;
-    params: P;
-}
-/**
- * A match is either `false` (no match) or a match result.
- */
-export declare type Match<P extends object = object> = false | MatchResult<P>;
-/**
- * The match function takes a string and returns whether it matched the path.
- */
-export declare type MatchFunction<P extends object = object> = (path: string) => Match<P>;
-/**
- * Create a path match function from `path-to-regexp` output.
- */
-export declare function regexpToFunction<P extends object = object>(re: RegExp, keys: Key[], options?: RegexpToFunctionOptions): MatchFunction<P>;
-/**
- * Metadata about a key.
- */
-export interface Key {
-    name: string | number;
-    prefix: string;
-    suffix: string;
-    pattern: string;
-    modifier: string;
-}
-/**
- * A token is a string (nothing special) or key metadata (capture group).
- */
-export declare type Token = string | Key;
-export interface TokensToRegexpOptions {
-    /**
-     * When `true` the regexp will be case sensitive. (default: `false`)
-     */
-    sensitive?: boolean;
-    /**
-     * When `true` the regexp won't allow an optional trailing delimiter to match. (default: `false`)
-     */
-    strict?: boolean;
-    /**
-     * When `true` the regexp will match to the end of the string. (default: `true`)
-     */
-    end?: boolean;
-    /**
-     * When `true` the regexp will match from the beginning of the string. (default: `true`)
-     */
-    start?: boolean;
-    /**
-     * Sets the final character for non-ending optimistic matches. (default: `/`)
-     */
-    delimiter?: string;
-    /**
-     * List of characters that can also be "end" characters.
-     */
-    endsWith?: string;
-    /**
-     * Encode path tokens for use in the `RegExp`.
-     */
-    encode?: (value: string) => string;
-}
-/**
- * Expose a function for taking tokens and returning a RegExp.
- */
-export declare function tokensToRegexp(tokens: Token[], keys?: Key[], options?: TokensToRegexpOptions): RegExp;
-/**
- * Supported `path-to-regexp` input types.
- */
-export declare type Path = string | RegExp | Array<string | RegExp>;
-/**
- * Normalize the given path string, returning a regular expression.
- *
- * An empty array can be passed in for the keys, which will hold the
- * placeholder key descriptions. For example, using `/user/:id`, `keys` will
- * contain `[{ name: 'id', delimiter: '/', optional: false, repeat: false }]`.
- */
-export declare function pathToRegexp(path: Path, keys?: Key[], options?: TokensToRegexpOptions & ParseOptions): RegExp;
-/**
- * Create path match function from `path-to-regexp` spec.
- */
-export declare function match<P extends object = object>(str: Path, options?: ParseOptions & TokensToRegexpOptions & RegexpToFunctionOptions): MatchFunction<P>;
-//# sourceMappingURL=pathToRegexp.d.ts.map

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

@@ -1,43 +0,0 @@
-/**
- * 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 { CompiledRouteDefinition, PageReference, StringAttributes, QueryObject, NullableStringAttributes } from './types';
-/**
- * f(route, routes[]) -> RouteDef
- * Match a route's id to a Route Definition id from the given list.
- *
- * @param {object} route - Route to match to a Route Definition
- * @param {array[object]} routeDefs - List of Route Definitions to match to the url
- *
- * @returns {object | null}
- */
-export declare function matchRouteDefinitionByPageReference(pageReference: PageReference, routeDefs: CompiledRouteDefinition[]): CompiledRouteDefinition | null;
-/**
- * Returns an object of paramName->pathValue pairs based on the given path string
- * and the params defined within the routeDef uri
- * @param path
- * @param routeDef
- */
-export declare function getPathParams(path: string, routeDef: CompiledRouteDefinition): StringAttributes | null;
-/**
- * Returns an object of paramName->queryValue pairs based on the given queryObject
- * and bindings defined within the routeDef uri
- * @param queryObj
- * @param routeDef
- */
-export declare function getQueryParams(queryObj: QueryObject, routeDef: CompiledRouteDefinition): NullableStringAttributes | null;
-/**
- * f(path, routeDef) -> { "attr1": "one", "attr2": "two" }
- * Parse a path into an object of attributes based on the Route Definition's parameterized path.
- * URI decode the path parts that are parsed as attributes.
- *
- * @param {string} path - A path (hopefully) matching the Route Definition
- * @param {object} routeDef - Route Definition containing the path to parameterize
- *
- * @returns {object}
- */
-export declare function getPageReferenceFromUriAndRouteDef(uri: string, routeDef: CompiledRouteDefinition): PageReference | null;
-//# sourceMappingURL=routeDefUtils.d.ts.map

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

@@ -1,39 +0,0 @@
-/**
- * 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 { CompiledRouteDefinition, CompiledRoutingMatch, PageReference } from './types';
-/**
- * f(URL, routes[]?) -> route
- * Match a URL's path to a Route Definition, use these to build a route.
- *
- * @param {string} url - URL string to turn into a route
- * @param {array[object]} routeDefs - List of Route Definitions to match to the url
- * @param {string} basePath - Optional: if provided, remove the base path before conversion.
- *
- * @returns {object}
- */
-export declare function matchRouteByUrl(url: string, routeDefs: CompiledRouteDefinition[], basePath?: string): CompiledRoutingMatch | null;
-/**
- * Serializes the given pageReference into a url based on the first route definition
- * with a binding the pageReference matches against.
- * @param pageReference pageReference to serialize into url
- * @param routeDefs RouteDefs to match pageReference against
- * @param basePath Base path for the url
- * @returns the url or null if no match
- */
-export declare function getUrlFromPageReference(pageReference: PageReference, routeDefs: CompiledRouteDefinition[], basePath?: string): string | null;
-/**
- * Generates a url for the given pageReference using the given routeDef
- * @param pageReference pageReference to serialize
- * @param routeDef routeDef to that defines how serialize the given pageReference
- * @returns url for the given pageReference
- */
-export declare function getUrlFromPageReferenceAndRouteDef(pageReference: PageReference, routeDef: CompiledRouteDefinition, basePath?: string): string;
-/**
- * Obtains the pageReference for the given URL
- */
-export declare function getPageReferenceFromUrl(url: string, routeDefs: CompiledRouteDefinition[], basePath?: string): PageReference | null;
-//# sourceMappingURL=routeUtils.d.ts.map

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

@@ -1,22 +0,0 @@
-/**
- * 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 { createFilterChain } from './filterUtils';
-export { getPageReferenceFromUriAndRouteDef } from './routeDefUtils';
-export { getUrlFromPageReference, getPageReferenceFromUrl, matchRouteByUrl, getUrlFromPageReferenceAndRouteDef, } from './routeUtils';
-export { isObject, freeze, guid, isValidRoute } from './typeUtils';
-export { parseRoutes } from './parseUtils';
-import { pathToRegexp as ptr, compile as ptrCompile } from './pathToRegexp';
-export declare const pathToRegexp: {
-    pathToRegexp: typeof ptr;
-    compile: typeof ptrCompile;
-};
-export { getPathFromUrl, getQueryFromUrl, getQueryString, encode, decode } from './uriUtils';
-export { hasDocument } from './domUtils';
-export type { Key } from './pathToRegexp';
-export type { Filter, FilterChain } from './filterUtils';
-export type { CompiledRouteDefinition, CompiledRoutingMatch, Constructor, Constructable, MessageObject, Module, PageReference, RouteCallback, RouteDefinition, RouteHandler, RouteHandlerCallback, RouteHandlerClass, RouteHandlerModule, Router, RouterConfig, RouteDestination, RouteInstance, RoutingMatch, RoutingResult, StringAttributes, UrlMapper, ViewSet, ViewInfo, RouterSerializationConfig, } from './types';
-//# sourceMappingURL=routerUtils.d.ts.map

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

@@ -1,38 +0,0 @@
-/**
- * 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
- */
-/**
- * @param {*} o - Item to check if it's an object
- * @returns {boolean}
- */
-export declare function isObject(o: unknown): boolean;
-/**
- * true if input is string
- * @param o
- */
-export declare function isString(o: unknown): boolean;
-/**
- * @param {*} o - Object to freeze N layers deep (e.g. { prop: 'p', o: { one: 1, two: 2 } })
- */
-export declare function freeze(o: object, depthLimit?: number): object;
-/**
- * Return a 4 character identifier.
- */
-export declare function guid(): string;
-/**
- * f(route) -> true/false
- *
- * @param {*} route - Item to check if it's a valid route
- *
- * @returns {boolean}
- */
-export declare function isValidRoute(object: unknown): boolean;
-/**
- * Returns true if the given object is a valid pageReference.
- * @param object
- */
-export declare function isValidPageReference(object: unknown): boolean;
-//# sourceMappingURL=typeUtils.d.ts.map

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

@@ -1,133 +0,0 @@
-import type { Key, PathFunction } from './pathToRegexp';
-import type { ContextId } from 'lwr/navigationContext';
-import { Unsubscriber } from 'lwr/observable';
-export declare type Module = Record<string | symbol | number, unknown>;
-export declare type Constructor<T = object> = new (...args: any[]) => T;
-export interface Constructable<T = object> {
-    constructor: Constructor<T>;
-}
-export declare type UrlMapper<TAddress> = {
-    generateUrl(address: TAddress): string | null;
-    parseUrl(url: string): TAddress | null;
-};
-export declare type RouteMatcher<TAddress> = {
-    matchRoute(address: TAddress): RoutingMatch | null;
-};
-export declare type ViewMapper<TAddress> = {
-    navigate(address: TAddress): void;
-    subscribe(callback: RouteCallback, replay?: boolean): Unsubscriber;
-    resolveView(address: TAddress): Promise<RouteDestination>;
-    contextId?: ContextId;
-};
-export declare type Router<TAddress = string> = ViewMapper<TAddress> & UrlMapper<TAddress> & RouteMatcher<TAddress>;
-export interface DEPRECATED_getRouteFromUrl {
-    <TAddress>(url: string, defaultImpl: Function): TAddress | null;
-}
-export interface DEPRECATED_getUrlFromRoute {
-    <TAddress>(route: TAddress, defaultImpl: Function): string | null;
-}
-export declare type RouterConfig = {
-    basePath?: string;
-    routes?: RouteDefinition[];
-    caseSensitive?: boolean;
-    DEPRECATED_getRouteFromUrl?: DEPRECATED_getRouteFromUrl;
-    DEPRECATED_getUrlFromRoute?: DEPRECATED_getUrlFromRoute;
-};
-export declare type RouterSerializationConfig<TAddress> = Required<Omit<RouterConfig, 'DEPRECATED_getRouteFromUrl' | 'DEPRECATED_getUrlFromRoute'> & UrlMapper<TAddress>>;
-export declare type RouteParameterPatterns = {
-    [paramName: string]: string;
-};
-export interface RouteDefinition<TMetadata = Record<string, any>> {
-    id: string;
-    uri: string;
-    patterns?: RouteParameterPatterns;
-    exact?: boolean;
-    page: Partial<PageReference>;
-    handler: () => Promise<RouteHandlerModule>;
-    metadata?: TMetadata;
-}
-export declare type PageBindings = {
-    attributeBindings: NullableStringAttributes;
-    stateBindings: NullableStringAttributes;
-};
-declare type CompiledQueryResult = {
-    literalValue?: string | null;
-    routeParamName?: string;
-};
-export declare type CompiledQuery = Record<string, CompiledQueryResult>;
-declare type MatchedQueryResult = {
-    value: string | null;
-    routeParamName?: string;
-};
-export declare type MatchedQuery = Record<string, MatchedQueryResult>;
-export declare type QueryMatcher = (queryObject: QueryObject) => MatchedQuery | null;
-export interface CompiledRouteDefinition {
-    original: RouteDefinition;
-    regex: RegExp;
-    params: Key[];
-    toPath: PathFunction<object>;
-    compiledQuery: CompiledQuery;
-    queryMatcher: QueryMatcher;
-}
-export declare type RouteHandlerCallback = (routeDestination: RouteDestination) => void;
-export declare type RouteHandlerClass = {
-    new (callback: RouteHandlerCallback): RouteHandler;
-};
-export declare type RouteHandlerModule = {
-    default: RouteHandlerClass;
-};
-export interface RouteInstance {
-    id: string;
-    attributes: NullableStringAttributes;
-    state: NullableStringAttributes;
-    pageReference: PageReference;
-}
-export declare type RouteDestination = {
-    status?: 200 | 404 | 500;
-    viewset: ViewSet;
-    error?: Error;
-};
-export declare type RoutingMatch = {
-    pathMatch: string;
-    route: RouteInstance;
-    routeDefinition: RouteDefinition;
-};
-export interface CompiledRoutingMatch {
-    route: RouteInstance;
-    routeDefinition: CompiledRouteDefinition;
-}
-export declare type RoutingResult = RoutingMatch & RouteDestination;
-export interface ViewSet {
-    [viewName: string]: (() => Promise<Module>) | ViewInfo;
-}
-export interface ViewInfo {
-    module: () => Promise<Module>;
-    specifier: string;
-}
-export declare type RouteCallback = (result: RoutingResult) => void;
-export interface RouteHandler {
-    dispose(): void;
-    update(routeInfo: RouteInstance): void;
-}
-export interface PageReference {
-    type: string;
-    attributes: NullableStringAttributes;
-    state: NullableStringAttributes;
-}
-export interface MessageObject {
-    code: string | number;
-    message: string;
-    level: number;
-    stack?: string;
-    url?: string;
-    address?: string;
-}
-export declare type QueryObject = NullableStringAttributes;
-export interface StringAttributes {
-    [key: string]: string;
-}
-export interface NullableStringAttributes {
-    [key: string]: string | null;
-}
-export {};
-//# sourceMappingURL=types.d.ts.map

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

@@ -1,66 +0,0 @@
-/**
- * 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 { QueryObject, CompiledQuery } from './types';
-/**
- * f("one two &") -> "one%20two%20%26"
- *
- * @param str - String to URI encode
- *
- * @returns {string}
- */
-export declare function encode(str?: string): string;
-/**
- * f("one%20two%20%26") -> "one two &"
- *
- * @param str - String to URI decode
- *
- * @returns {string}
- */
-export declare function decode(str?: string): string;
-/**
- * f(url) -> "/some/relative/path"
- * Output will...
- * - always start with '/'
- * - not contain query params or fragment
- * - akin to window.location.pathname
- *
- * @param   {string} url - URL string to parse for a path
- *
- * @returns {string}
- */
-export declare function getPathFromUrl(url: string): string;
-/**
- * f(url) -> { "param1": "one", "param2": "two", param3: "" }
- * Parameters without values get set to an empty string.
- *
- * @param {string} url - URL string to parse for a query object
- *
- * @returns {object}
- */
-export declare function getQueryFromUrl(url: string): QueryObject;
-/**
- * f({ "param1": "one", "param2": "two", param3: "" }) -> "?param1=one&param2=two&param3"
- * Query parameter values, but not keys, get URI encoded.
- *
- * @param {object} queryObject - Query object to turn into a string
- *
- * @returns {string}
- */
-export declare function getQueryString(queryObj?: QueryObject): string;
-/**
- * Determines if the given string is a paramter name (":paramName")
- * @param str string to test
- * @returns true if string starts with ":"
- */
-export declare function isParam(str: string | null | undefined): boolean;
-/**
- * @param routeParamName - routeParamName from CompiledQueryResult
- * @returns the paramName without prefix; or undefined
- */
-export declare function getParamName(routeParamName: string | undefined | null): string | false;
-export declare function getQueryNames(compiledQuery: CompiledQuery): string[];
-//# sourceMappingURL=uriUtils.d.ts.map

package/build/bundle/prod/lwr/router/es/services/index.d.ts

@@ -1,28 +0,0 @@
-export declare const DEFAULT_SCHEMA = "pageReference_v1";
-export interface LwrRouterConfig {
-    basePath?: string;
-    caseSensitive?: boolean;
-    routes: LwrConfigRouteDefinition[];
-}
-export interface LwrConfigRouteDefinition {
-    id: string;
-    uri: string;
-    patterns?: Record<string, string>;
-    exact?: boolean;
-    page: Partial<PageReference>;
-    metadata?: Record<string, any>;
-    handler?: string;
-    component?: string;
-}
-export interface PageReference {
-    type: string;
-    attributes: Record<string, string | null>;
-    state: Record<string, string | null>;
-}
-export declare function deleteRouterConfigJsonCacheEntry(path: string): void;
-/**
- * Given a Routes Config path, return the array of Config Route Definitions
- * @param path - A path to a Route Config files
- */
-export declare function getClientRoutes(path: string): LwrRouterConfig | undefined;
-//# sourceMappingURL=index.d.ts.map

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

@@ -1,22 +0,0 @@
-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/router/es/services/module-provider/utils.d.ts

@@ -1,27 +0,0 @@
-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/routerContainer/es/modules/lwr/contextProvider/contextProvider.d.ts

@@ -1,14 +0,0 @@
-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/routerContainer/es/modules/lwr/contextUtils/contextInfo.d.ts

@@ -1,60 +0,0 @@
-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