@lwrjs/router 0.12.0-alpha.1 → 0.12.0-alpha.10

package/build/cjs/services/module-provider/index.cjs

@@ -33,46 +33,31 @@ var DEFAULT_DIR = "$rootDir/src/routes";
 var RouterModuleProvider = class {
   constructor({routesDir = DEFAULT_DIR}, context) {
     this.name = "router-module-provider";
-    this.watchedFileMap = new Map();
-    this.routerModuleCache = new Map();
+    this.watchedFileSet = new Set();
     const {
-      appEmitter,
-      config: {basePath, rootDir, contentDir, layoutsDir},
+      config: {rootDir, contentDir, i18n, layoutsDir},
       runtimeEnvironment: {lwrVersion, watchFiles},
       watcherFactory
     } = context;
     this.version = lwrVersion;
+    this.i18n = i18n;
     this.routesDir = (0, import_shared_utils.normalizeResourcePath)(routesDir, {
       rootDir,
       assets: [],
       contentDir,
       layoutsDir
     }).replace(/\/$/, "");
-    this.appBasePath = basePath ? basePath : void 0;
-    this.routerEmitter = appEmitter;
     this.routerWatcher = watchFiles && watcherFactory ? (0, import_utils.setUpWatcher)(watcherFactory, this.onRouterModuleChange.bind(this)) : void 0;
   }
-  async onRouterModuleChange(configPath, deleted = false) {
-    const moduleId = this.watchedFileMap.get(configPath);
-    if (!moduleId) {
-      throw new Error("We are observing an unprocessed Router Config file, this should not happen...");
-    }
+  async onRouterModuleChange(configPath) {
     (0, import__.deleteRouterConfigJsonCacheEntry)(configPath);
-    this.routerModuleCache.delete(configPath);
-    if (!deleted) {
-      const recompiledModule = await this.getModule(moduleId);
-      if (recompiledModule) {
-        this.routerEmitter.notifyModuleSourceChanged(recompiledModule);
-      }
-    }
   }
-  watchConfigs(specifier, moduleId) {
+  watchConfigs(configPath) {
     if (this.routerWatcher) {
-      const configPath = (0, import_utils.getRouterConfigPath)(this.routesDir, specifier);
-      if (!this.watchedFileMap.has(configPath)) {
+      if (!this.watchedFileSet.has(configPath)) {
         this.routerWatcher.add(configPath);
+        this.watchedFileSet.add(configPath);
       }
-      this.watchedFileMap.set(configPath, moduleId);
     }
   }
   getRouterConfig(specifier) {
@@ -81,17 +66,15 @@ var RouterModuleProvider = class {
     if (routerId) {
       const configPath = (0, import_utils.getRouterConfigPath)(this.routesDir, specifier);
       config = (0, import__.getClientRoutes)(configPath);
-      if (config && !config.basePath && this.appBasePath) {
-        config.basePath = this.appBasePath;
-      }
+      this.watchConfigs(configPath);
     }
     return config;
   }
-  async getModuleEntry({specifier}) {
+  async getModuleEntry({specifier}, runtimeParams) {
     const config = this.getRouterConfig(specifier);
     if (config) {
       return {
-        id: `${specifier}|${this.version}`,
+        id: `${specifier}|${this.version}|${runtimeParams.basePath}|${runtimeParams.locale}`,
         virtual: true,
         entry: `<virtual>/${specifier}.js`,
         specifier,
@@ -99,18 +82,14 @@ var RouterModuleProvider = class {
       };
     }
   }
-  async getModule(moduleId) {
+  async getModule(moduleId, runtimeParams) {
     const {specifier, namespace, name = specifier} = moduleId;
-    const moduleEntry = await this.getModuleEntry({specifier});
+    const moduleEntry = await this.getModuleEntry({specifier}, runtimeParams);
     if (!moduleEntry) {
       return;
     }
-    const configPath = (0, import_utils.getRouterConfigPath)(this.routesDir, specifier);
-    if (this.routerModuleCache.has(configPath)) {
-      return this.routerModuleCache.get(configPath);
-    }
     const config = this.getRouterConfig(specifier);
-    const compiledSource = (0, import_utils.generateModule)(config);
+    const compiledSource = (0, import_utils.generateModule)(config, this.i18n, runtimeParams);
     const moduleCompiled = {
       id: moduleEntry.id,
       specifier,
@@ -122,8 +101,6 @@ var RouterModuleProvider = class {
       ownHash: (0, import_shared_utils.hashContent)(compiledSource),
       compiledSource
     };
-    this.watchConfigs(specifier, moduleId);
-    this.routerModuleCache.set(configPath, moduleCompiled);
     return moduleCompiled;
   }
 };

package/build/cjs/services/module-provider/utils.cjs

@@ -52,10 +52,19 @@ function getHandlerClassName(specifier) {
 }
 function generateHandlerClasses(routes) {
   let handlerClasses = "";
-  routes.forEach((r) => {
+  const seenComponents = new Set();
+  const filteredAndDeDupedArray = routes.filter((item) => {
+    if (!item.component)
+      return false;
+    if (!seenComponents.has(item.component)) {
+      seenComponents.add(item.component);
+      return true;
+    }
+    return false;
+  });
+  filteredAndDeDupedArray.forEach((r) => {
     const component = r.component;
-    if (component) {
-      handlerClasses += `class ${getHandlerClassName(component)} {
+    handlerClasses += `class ${getHandlerClassName(component)} {
     callback;
     constructor(callback) {
         this.callback = callback;
@@ -73,7 +82,6 @@ function generateHandlerClasses(routes) {
     }
 }
 `;
-    }
   });
   return handlerClasses;
 }
@@ -92,14 +100,16 @@ function generateRouteDefinitions(routes) {
   });
   return `${routeDefs}	]`;
 }
-function generateModule(config = {routes: []}) {
-  const {basePath = "", caseSensitive, routes: jsonRoutes} = config;
+function generateModule(config = {routes: []}, {defaultLocale, uriPattern}, runtimeParams) {
+  const {caseSensitive, routes: jsonRoutes} = config;
   const csString = caseSensitive ? "true" : "false";
   const routes = generateRouteDefinitions(jsonRoutes);
   const handlers = generateHandlerClasses(jsonRoutes);
+  const basePath = runtimeParams?.basePath || "";
+  const i18nRouterConfig = uriPattern === "path-prefix" ? `${JSON.stringify({locale: runtimeParams?.locale, defaultLocale})}` : void 0;
   return `import { createRouter as createLwrRouter } from 'lwr/router';
 ${handlers}
-export function createRouter({ basePath = '${basePath}', caseSensitive = ${csString} } = {}) {
-    return createLwrRouter({ basePath, caseSensitive, routes: ${routes} });
+export function createRouter({ basePath = '${basePath}', caseSensitive = ${csString}, DEPRECATED_getRouteFromUrl, DEPRECATED_getUrlFromRoute } = {}) {
+    return createLwrRouter({ basePath, caseSensitive, i18n: ${i18nRouterConfig}, routes: ${routes}, DEPRECATED_getRouteFromUrl, DEPRECATED_getUrlFromRoute });
 }`;
 }

package/build/es/modules/lwr/contextUtils/navigationApiStore.d.ts

@@ -7,14 +7,15 @@
 import type { RouteCallback, PageReference } from 'lwr/router';
 import type { Unsubscriber } from 'lwr/observable';
 import type { ContextId } from 'lwr/navigationContext';
+import type { NavigateOptions } from '../routerUtils/types';
 /**
  * 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;
+    navigate: (address: PageReference, replace?: boolean, options?: NavigateOptions) => void;
+    generateUrl: (address: PageReference, options?: NavigateOptions) => string | null;
     subscribe: (callback: RouteCallback, replay?: boolean) => Unsubscriber;
 }
 interface NavigationContextData {

package/build/es/modules/lwr/domRouter/domRouter.d.ts

@@ -9,6 +9,7 @@ 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';
+import type { NavigateOptions } from '../routerUtils/types';
 export declare const NAV_EVENT: string;
 export declare const PARENT_EVENT: string;
 interface RouterParent {
@@ -23,9 +24,9 @@ interface DomRouterNode extends RouterParent {
     parent?: DomRouter;
     child?: DomRouter;
     connected: boolean;
-    process(url: string, replace?: boolean): Promise<boolean>;
+    process(url: string, replace?: boolean, options?: NavigateOptions, updateHistory?: boolean): Promise<boolean>;
     processError(messageObject: MessageObject): void;
-    preProcess(url: string): Promise<boolean>;
+    preProcess(url: string, options?: NavigateOptions): Promise<boolean>;
 }
 export interface DomRouter extends DomRouterNode {
     router: Router<PageReference>;
@@ -37,8 +38,8 @@ export interface DomRouter extends DomRouterNode {
     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;
+    navigate(address: PageReference, replace?: boolean, options?: NavigateOptions): void;
+    generateUrl(address: PageReference, options?: NavigateOptions): string | null;
     subscribe(callback: RouteCallback, replay?: boolean): Unsubscriber;
 }
 export declare class DomRouterImpl implements DomRouter {
@@ -109,9 +110,10 @@ export declare class DomRouterImpl implements DomRouter {
      * After processing, delegate to a child router, if it exists.
      *
      * @param {string} url - Relative URL string to process
+     * @param {NavigateOptions} options - Additional navigation options (i.e. switch root locale)
      * @returns {boolean} - True if the processing was NOT blocked by a preNavigate listener
      */
-    process(url: string, replace?: boolean): Promise<boolean>;
+    process(url: string, _shouldReplace?: boolean, options?: NavigateOptions, _updateHistory?: boolean): Promise<boolean>;
     /**
      * Run the preNavigate filters for this router.
      * After processing, delegate to a child router, if it exists.
@@ -121,7 +123,7 @@ export declare class DomRouterImpl implements DomRouter {
      *
      * @returns {Promise<boolean>} - Resolves to true if successful
      */
-    preProcess(url: string): Promise<boolean>;
+    preProcess(url: string, options?: NavigateOptions): Promise<boolean>;
     /**
      * Run the errorNavigate filters for this router.
      * After processing, delegate to a child router, if it exists.
@@ -138,7 +140,7 @@ export declare class DomRouterImpl implements DomRouter {
      * @param {*} options - Usually a boolean; when true the previous browser history
      *                    entry should be replaced by this one
      */
-    navigate(address: PageReference, replace?: boolean): void;
+    navigate(address: PageReference, replace?: boolean, options?: NavigateOptions): void;
     /**
      * lightning/navigation
      * Generate a URL based on the given route.
@@ -148,7 +150,7 @@ export declare class DomRouterImpl implements DomRouter {
      *
      * @returns {Promise<string>}
      */
-    generateUrl(address: PageReference): string | null;
+    generateUrl(address: PageReference, options?: NavigateOptions): string | null;
     /**
      * lightning/navigation
      * Subscribe a callback to the Observable on the current route of this router.
@@ -177,6 +179,10 @@ export declare class DomRouterImpl implements DomRouter {
     private _handleParentEvent;
     private _sendEvent;
     private _stripUrlForChild;
+    /**
+     * Filter the navigate options based on if this is a root router or not.
+     */
+    private filterNavigateOptions;
 }
 /**
  * Create a new root Router, attach to the Window.

package/build/es/modules/lwr/domRouter/domRouter.js

@@ -148,7 +148,7 @@ export class DomRouterImpl {
         });
         const contextApi = {
             navigate: (address, replace) => this.navigate(address, replace),
-            generateUrl: (address) => this.generateUrl(address),
+            generateUrl: (address, options) => this.generateUrl(address, options),
             subscribe: (callback, replay) => this.subscribe(callback, replay),
         };
         registerNavigationHelm(this.contextId, contextApi);
@@ -269,10 +269,11 @@ export class DomRouterImpl {
      * After processing, delegate to a child router, if it exists.
      *
      * @param {string} url - Relative URL string to process
+     * @param {NavigateOptions} options - Additional navigation options (i.e. switch root locale)
      * @returns {boolean} - True if the processing was NOT blocked by a preNavigate listener
      */
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    async process(url, replace) {
+    async process(url, _shouldReplace, options, _updateHistory) {
         // Mark the navigation event here instead of in navigate()
         // This way, we catch ALL navigation events, since they all must go through process():
         //      1. A component calls navigate()
@@ -284,7 +285,7 @@ export class DomRouterImpl {
         // Run the root -> leaf chain of pre navigate filters, if this is the root.
         try {
             if (!this.parent) {
-                await this.preProcess(url);
+                await this.preProcess(url, options);
             }
         }
         catch (e) {
@@ -298,7 +299,7 @@ export class DomRouterImpl {
         // trigger the child to navigate afterwards
         const address = this.router.parseUrl(url);
         if (address) {
-            this.router.navigate(address);
+            this.router.navigate(address, options);
         }
         return true;
     }
@@ -311,9 +312,9 @@ export class DomRouterImpl {
      *
      * @returns {Promise<boolean>} - Resolves to true if successful
      */
-    preProcess(url) {
+    preProcess(url, options) {
         const address = this.router.parseUrl(url);
-        const routingMatch = address && this.router.matchRoute(address);
+        const routingMatch = address && this.router.matchRoute(address, options);
         // Check that the URL has a matching route, otherwise it is an error.
         if (!routingMatch) {
             return Promise.reject(generateMessageObject(messages.MISSING_ROUTE, [url]));
@@ -360,9 +361,10 @@ export class DomRouterImpl {
      * @param {*} options - Usually a boolean; when true the previous browser history
      *                    entry should be replaced by this one
      */
-    navigate(address, replace) {
+    navigate(address, replace, options) {
+        const routerOptions = this.filterNavigateOptions(options);
         // Ensure there is a string URL to pass to the navigation event.
-        let url = this.router.generateUrl(address);
+        let url = this.router.generateUrl(address, routerOptions);
         if (url) {
             // If this router is a child, we need to prepend the parent's matching portion
             // of the url before sending the navigate event up
@@ -381,8 +383,9 @@ export class DomRouterImpl {
      *
      * @returns {Promise<string>}
      */
-    generateUrl(address) {
-        const url = this.router.generateUrl(address);
+    generateUrl(address, options) {
+        const routerOptions = this.filterNavigateOptions(options);
+        const url = this.router.generateUrl(address, routerOptions);
         // Invalid addresses need to return null to indicate they are invalid
         if (!url) {
             return null;
@@ -425,6 +428,18 @@ export class DomRouterImpl {
         }
         return url;
     }
+    /**
+     * Filter the navigate options based on if this is a root router or not.
+     */
+    filterNavigateOptions(options) {
+        const isRoot = !this.parent;
+        const routerOptions = {
+            ...options,
+            // Only allow switch locales if this is a root router
+            locale: isRoot ? options?.locale : undefined,
+        };
+        return routerOptions;
+    }
 }
 /**
  * Create a new root Router, attach to the Window.

package/build/es/modules/lwr/historyRouter/historyRouter.d.ts

@@ -7,6 +7,7 @@
 import { DomRouterImpl } from 'lwr/domRouter';
 import type { Router, PageReference } from 'lwr/router';
 import type { DomRouterConfig } from 'lwr/domRouterUtils';
+import type { NavigateOptions } from '../routerUtils/types';
 export declare class HistoryRouter extends DomRouterImpl {
     historyDisabled: boolean;
     /**
@@ -26,7 +27,7 @@ export declare class HistoryRouter extends DomRouterImpl {
      *
      * @returns {boolean} - True if the processing was NOT blocked by a preNavigate listener
      */
-    process(url: string, shouldReplace: boolean, updateHistory?: boolean): Promise<boolean>;
+    process(url: string, shouldReplace: boolean, options?: NavigateOptions, updateHistory?: boolean): Promise<boolean>;
     /**
      * Update the root route, and trickle down the router tree.
      * Redirect to use the base path, if it is missing.
@@ -37,7 +38,7 @@ export declare class HistoryRouter extends DomRouterImpl {
 }
 /**
  * Create a new root Router, attach to the Window.
- * This is the public, programmitic API for root router creation.
+ * 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

package/build/es/modules/lwr/historyRouter/historyRouter.js

@@ -48,9 +48,9 @@ export class HistoryRouter extends DomRouterImpl {
      *
      * @returns {boolean} - True if the processing was NOT blocked by a preNavigate listener
      */
-    async process(url, shouldReplace, updateHistory = true) {
+    async process(url, shouldReplace, options, updateHistory = true) {
         // Run the preNavigate hooks to check if this event should be processed.
-        const canContinue = await super.process(url);
+        const canContinue = await super.process(url, shouldReplace, options, updateHistory);
         // Update the window location if this router is connected and is the root router
         if (canContinue && !this.historyDisabled && updateHistory && this.connected && !this.parent) {
             // Update the window history.
@@ -70,12 +70,12 @@ export class HistoryRouter extends DomRouterImpl {
      * @param {string} url - The URL to go to
      */
     catchBrowserUpdate(url) {
-        this.process(url, false, false);
+        this.process(url, false, {}, false);
     }
 }
 /**
  * Create a new root Router, attach to the Window.
- * This is the public, programmitic API for root router creation.
+ * 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

package/build/es/modules/lwr/navigation/navigationApi.d.ts

@@ -1,22 +1,23 @@
 import type { ContextId } from 'lwr/navigationContext';
 import type { PageReference } from 'lwr/router';
+import type { NavigateOptions } from '../routerUtils/types';
 /**
- * Navigate programmatically.
+ * Navigate programmatically to a page reference.
  * 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
+ * @param {PageReference} pageReference - A page reference location
+ * @param {boolean} replace - When true the previous browser history entry should be replaced by this one
+ * @param {NavigateOptions} options - Additional navigation options (i.e. switch locale)
  */
-export declare function navigate(context: ContextId, pageReference: PageReference, replace?: boolean): void;
+export declare function navigate(context: ContextId, pageReference: PageReference, replace?: boolean, options?: NavigateOptions): void;
 /**
- * Generate a URL for the given route.
+ * Generate a URL for the given page reference.
  *
  * @param {HTMLElement} context - The navigation context
- * @param {object} route - A route
+ * @param {PageReference} pageReference - A page reference location
  *
  * @returns {Promise<string>}
  */
-export declare function generateUrl(context: ContextId, pageReference: PageReference): string | null;
+export declare function generateUrl(context: ContextId, pageReference: PageReference, options?: NavigateOptions): string | null;
 //# sourceMappingURL=navigationApi.d.ts.map

package/build/es/modules/lwr/navigation/navigationApi.js

@@ -1,27 +1,27 @@
 import { getNavigationHelm } from 'lwr/contextUtils';
 /**
- * Navigate programmatically.
+ * Navigate programmatically to a page reference.
  * 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
+ * @param {PageReference} pageReference - A page reference location
+ * @param {boolean} replace - When true the previous browser history entry should be replaced by this one
+ * @param {NavigateOptions} options - Additional navigation options (i.e. switch locale)
  */
-export function navigate(context, pageReference, replace) {
+export function navigate(context, pageReference, replace, options) {
     const api = getNavigationHelm(context);
-    api.navigate(pageReference, replace);
+    api.navigate(pageReference, replace, options);
 }
 /**
- * Generate a URL for the given route.
+ * Generate a URL for the given page reference.
  *
  * @param {HTMLElement} context - The navigation context
- * @param {object} route - A route
+ * @param {PageReference} pageReference - A page reference location
  *
  * @returns {Promise<string>}
  */
-export function generateUrl(context, pageReference) {
+export function generateUrl(context, pageReference, options) {
     const api = getNavigationHelm(context);
-    return api.generateUrl(pageReference);
+    return api.generateUrl(pageReference, options);
 }
 //# sourceMappingURL=navigationApi.js.map

package/build/es/modules/lwr/navigation/navigationMixin.js

@@ -60,16 +60,16 @@ function NavigationMixin(Base) {
                 }
             }
         }
-        [Navigate](pageRef, replace) {
+        [Navigate](pageRef, replace, options) {
             if (!isSSR) {
                 this[GetContext]();
-                navigate(this[NavContext], pageRef, replace);
+                navigate(this[NavContext], pageRef, replace, options);
             }
         }
-        async [GenerateUrl](pageRef) {
+        async [GenerateUrl](pageRef, options) {
             if (!isSSR) {
                 this[GetContext]();
-                return generateUrl(this[NavContext], pageRef);
+                return generateUrl(this[NavContext], pageRef, options);
             }
             else {
                 return null;

package/build/es/modules/lwr/router/router.d.ts

@@ -5,7 +5,7 @@
  * 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 declare function createRouter(config?: RouterConfig<PageReference>): 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/es/modules/lwr/router/router.js

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: MIT
  * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
  */
-import { freeze, getUrlFromPageReference, getPageReferenceFromUrl, matchRouteByUrl, getUrlFromPageReferenceAndRouteDef, parseRoutes, } from 'lwr/routerUtils';
+import { freeze, getUrlFromPageReference, getPageReferenceFromUrl, matchRouteByUrl, getUrlFromPageReferenceAndRouteDef, parseRoutes, DEFAULT_I18N_ROUTER_CONFIG, } from 'lwr/routerUtils';
 import { generateMessage, messages } from 'lwr/routerErrors';
 import { createObservable } from 'lwr/observable';
 class RouterImpl {
@@ -20,10 +20,11 @@ class RouterImpl {
         this.routeObservable = createObservable();
         this.config = {
             basePath: config.basePath || '',
+            i18n: config.i18n || DEFAULT_I18N_ROUTER_CONFIG,
             caseSensitive: Boolean(config.caseSensitive),
             routes: config.routes || [],
-            generateUrl: (address) => getUrlFromPageReference(address, this.compiledRoutes, this.config.basePath),
-            parseUrl: (url) => getPageReferenceFromUrl(url, this.compiledRoutes, this.config.basePath),
+            generateUrl: (address, options) => getUrlFromPageReference(address, this.compiledRoutes, this.config.basePath, this.config.i18n, options),
+            parseUrl: (url) => getPageReferenceFromUrl(url, this.compiledRoutes, this.config.basePath, this.config.i18n),
         };
         const { DEPRECATED_getRouteFromUrl, DEPRECATED_getUrlFromRoute } = config;
         if (DEPRECATED_getRouteFromUrl) {
@@ -39,13 +40,13 @@ class RouterImpl {
      *
      * @param address
      */
-    generateUrl(address) {
+    generateUrl(address, options) {
         const { DEPRECATED_getUrlFromRoute: getUrlFromRoute } = this.deprecatedConfig;
         if (getUrlFromRoute) {
-            return getUrlFromRoute(address, this.config.generateUrl);
+            return getUrlFromRoute(address, this.config.generateUrl, options);
         }
         else {
-            return this.config.generateUrl(address);
+            return this.config.generateUrl(address, options);
         }
     }
     /**
@@ -68,14 +69,14 @@ class RouterImpl {
      *
      * @param address - The address to match
      */
-    matchRoute(address) {
-        const url = typeof address === 'string' ? address : this.generateUrl(address);
+    matchRoute(address, options) {
+        const url = typeof address === 'string' ? address : this.generateUrl(address, options);
         if (url === null) {
             return null;
         }
-        const match = matchRouteByUrl(url, this.compiledRoutes, this.config.basePath);
+        const match = matchRouteByUrl(url, this.compiledRoutes, this.config.basePath, this.config.i18n, options);
         const pathMatch = match &&
-            getUrlFromPageReferenceAndRouteDef(match.route.pageReference, match.routeDefinition, this.config.basePath);
+            getUrlFromPageReferenceAndRouteDef(match.route.pageReference, match.routeDefinition, this.config.basePath, this.config.i18n, options);
         if (!match || !pathMatch) {
             return null;
         }
@@ -90,10 +91,10 @@ class RouterImpl {
      *
      * @param address - The address to match to a viewset
      */
-    async resolveView(address) {
+    async resolveView(address, options) {
         return new Promise((resolve, reject) => {
             // get the RoutingMatch: { pathMatch, route, routeDefinition }
-            const routingMatch = this.matchRoute(address);
+            const routingMatch = this.matchRoute(address, options);
             if (!routingMatch) {
                 return reject(generateMessage(messages.NO_ROUTE_MATCH, [JSON.stringify(address)]));
             }
@@ -121,8 +122,8 @@ class RouterImpl {
      *
      * @param {object} address
      */
-    navigate(address) {
-        const routingMatch = this.matchRoute(address);
+    navigate(address, options) {
+        const routingMatch = this.matchRoute(address, options);
         if (!routingMatch) {
             throw new Error(generateMessage(messages.MISSING_ROUTE, [JSON.stringify(address)]));
         }

package/build/es/modules/lwr/routerUtils/routeUtils.d.ts

@@ -4,7 +4,8 @@
  * 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';
+import type { CompiledRouteDefinition, CompiledRoutingMatch, I18nRouterConfig, NavigateOptions, PageReference } from './types';
+export declare const DEFAULT_I18N_ROUTER_CONFIG: I18nRouterConfig;
 /**
  * f(URL, routes[]?) -> route
  * Match a URL's path to a Route Definition, use these to build a route.
@@ -12,10 +13,11 @@ import type { CompiledRouteDefinition, CompiledRoutingMatch, PageReference } fro
  * @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.
+ * @param {object} i18n - Optional: if provided, remove the non-default locale before conversion.
  *
  * @returns {object}
  */
-export declare function matchRouteByUrl(url: string, routeDefs: CompiledRouteDefinition[], basePath?: string): CompiledRoutingMatch | null;
+export declare function matchRouteByUrl(url: string, routeDefs: CompiledRouteDefinition[], basePath?: string, i18n?: I18nRouterConfig, options?: NavigateOptions): CompiledRoutingMatch | null;
 /**
  * Serializes the given pageReference into a url based on the first route definition
  * with a binding the pageReference matches against.
@@ -24,16 +26,16 @@ export declare function matchRouteByUrl(url: string, routeDefs: CompiledRouteDef
  * @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;
+export declare function getUrlFromPageReference(pageReference: PageReference, routeDefs: CompiledRouteDefinition[], basePath?: string, i18n?: I18nRouterConfig, options?: NavigateOptions): 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;
+export declare function getUrlFromPageReferenceAndRouteDef(pageReference: PageReference, routeDef: CompiledRouteDefinition, basePath?: string, i18n?: I18nRouterConfig, options?: NavigateOptions): string;
 /**
  * Obtains the pageReference for the given URL
  */
-export declare function getPageReferenceFromUrl(url: string, routeDefs: CompiledRouteDefinition[], basePath?: string): PageReference | null;
+export declare function getPageReferenceFromUrl(url: string, routeDefs: CompiledRouteDefinition[], basePath?: string, i18n?: I18nRouterConfig): PageReference | null;
 //# sourceMappingURL=routeUtils.d.ts.map