@lwrjs/router 0.6.2 → 0.7.0-alpha.1

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

@@ -0,0 +1,133 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __markAsModule = (target) => __defProp(target, "__esModule", {value: true});
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {get: all[name], enumerable: true});
+};
+var __exportStar = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, {get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable});
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __exportStar(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? {get: () => module2.default, enumerable: true} : {value: module2, enumerable: true})), module2);
+};
+
+// packages/@lwrjs/router/src/services/module-provider/index.ts
+__markAsModule(exports);
+__export(exports, {
+  default: () => module_provider_default
+});
+var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
+var import_utils = __toModule(require("./utils.cjs"));
+var import__ = __toModule(require("../index.cjs"));
+var DEFAULT_DIR = "$rootDir/src/routes";
+var RouterModuleProvider = class {
+  constructor({routesDir = DEFAULT_DIR}, context) {
+    this.name = "router-module-provider";
+    this.watchedFileMap = new Map();
+    this.routerConfigJsonCache = new Map();
+    this.routerModuleCache = new Map();
+    const {
+      appEmitter,
+      config: {rootDir, contentDir, layoutsDir},
+      runtimeEnvironment: {lwrVersion, watchFiles}
+    } = context;
+    this.version = lwrVersion;
+    this.routesDir = (0, import_shared_utils.normalizeResourcePath)(routesDir, {
+      rootDir,
+      assets: [],
+      contentDir,
+      layoutsDir
+    }).replace(/\/$/, "");
+    this.routerEmitter = appEmitter;
+    this.routerWatcher = watchFiles ? (0, import_utils.setUpWatcher)(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...");
+    }
+    this.routerConfigJsonCache.delete(configPath);
+    this.routerModuleCache.delete(configPath);
+    if (!deleted) {
+      const recompiledModule = await this.getModule(moduleId);
+      if (recompiledModule) {
+        this.routerEmitter.notifyModuleSourceChanged(recompiledModule);
+      }
+    }
+  }
+  watchConfigs(specifier, moduleId) {
+    if (this.routerWatcher) {
+      const configPath = (0, import_utils.getRouterConfigPath)(this.routesDir, specifier);
+      if (!this.watchedFileMap.has(configPath)) {
+        this.routerWatcher.add(configPath);
+      }
+      this.watchedFileMap.set(configPath, moduleId);
+    }
+  }
+  getRouterConfig(specifier) {
+    let config;
+    const routerId = (0, import_utils.parseSpecifier)(specifier);
+    if (routerId) {
+      const cacheKey = (0, import_utils.getRouterConfigPath)(this.routesDir, specifier);
+      if (this.routerConfigJsonCache.has(cacheKey)) {
+        config = this.routerConfigJsonCache.get(cacheKey);
+      } else {
+        config = (0, import__.getClientRoutes)(cacheKey);
+        if (config) {
+          this.routerConfigJsonCache.set(cacheKey, config);
+        }
+      }
+    }
+    return config;
+  }
+  async getModuleEntry({specifier}) {
+    const config = this.getRouterConfig(specifier);
+    if (config) {
+      return {
+        id: `${specifier}|${this.version}`,
+        virtual: true,
+        entry: `<virtual>/${specifier}.js`,
+        specifier,
+        version: this.version
+      };
+    }
+  }
+  async getModule(moduleId) {
+    const {specifier, namespace, name = specifier} = moduleId;
+    const moduleEntry = await this.getModuleEntry({specifier});
+    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 moduleCompiled = {
+      id: moduleEntry.id,
+      specifier,
+      namespace,
+      name,
+      version: this.version,
+      originalSource: compiledSource,
+      moduleEntry,
+      ownHash: (0, import_shared_utils.hashContent)(compiledSource),
+      compiledSource
+    };
+    this.watchConfigs(specifier, moduleId);
+    this.routerModuleCache.set(configPath, moduleCompiled);
+    return moduleCompiled;
+  }
+};
+var module_provider_default = RouterModuleProvider;

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

@@ -0,0 +1,104 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __markAsModule = (target) => __defProp(target, "__esModule", {value: true});
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {get: all[name], enumerable: true});
+};
+var __exportStar = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, {get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable});
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __exportStar(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? {get: () => module2.default, enumerable: true} : {value: module2, enumerable: true})), module2);
+};
+
+// packages/@lwrjs/router/src/services/module-provider/utils.ts
+__markAsModule(exports);
+__export(exports, {
+  SPECIFIER_PREFIX: () => SPECIFIER_PREFIX,
+  generateModule: () => generateModule,
+  getRouterConfigPath: () => getRouterConfigPath,
+  parseSpecifier: () => parseSpecifier,
+  setUpWatcher: () => setUpWatcher
+});
+var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
+var SPECIFIER_PREFIX = "@lwrjs/router/";
+function parseSpecifier(specifier) {
+  return specifier.startsWith(SPECIFIER_PREFIX) ? specifier.replace(SPECIFIER_PREFIX, "") : void 0;
+}
+function getRouterConfigPath(dir, specifier) {
+  const routerId = parseSpecifier(specifier);
+  return `${dir}/${routerId}.json`;
+}
+function setUpWatcher(onModuleChange) {
+  const watcher = (0, import_shared_utils.createFileWatcher)();
+  watcher.on("change", (0, import_shared_utils.debounce)((file) => onModuleChange(file), 500));
+  watcher.on("unlink", (0, import_shared_utils.debounce)((file) => onModuleChange(file, true), 500));
+  watcher.on("add", (file) => console.log(`Watching Router Config file at "${file}"`));
+  return watcher;
+}
+function getHandlerClassName(specifier) {
+  return specifier.replace(/\//g, "_").replace("@", "");
+}
+function generateHandlerClasses(routes) {
+  let handlerClasses = "";
+  routes.forEach((r) => {
+    const component = r.component;
+    if (component) {
+      handlerClasses += `class ${getHandlerClassName(component)} {
+    callback;
+    constructor(callback) {
+        this.callback = callback;
+    }
+    dispose() {}
+    update() {
+        this.callback({
+            viewset: {
+                default: {
+                    module: () => import('${component}'),
+                    specifier: '${component}',
+                },
+            },
+        });
+    }
+}
+`;
+    }
+  });
+  return handlerClasses;
+}
+function generateRouteDefinitions(routes) {
+  let routeDefs = "[\n";
+  routes.forEach((r) => {
+    const {handler, component, ...routeDef} = r;
+    const portableProps = JSON.stringify(routeDef);
+    if (handler) {
+      routeDefs += portableProps.slice(0, portableProps.length - 1) + `, handler: () => import('${handler}') },
+`;
+    } else if (component) {
+      routeDefs += portableProps.slice(0, portableProps.length - 1) + `, handler: () => Promise.resolve({ default: ${getHandlerClassName(component)} }) },
+`;
+    }
+  });
+  return `${routeDefs}	]`;
+}
+function generateModule(config = {routes: []}) {
+  const {basePath = "", caseSensitive, routes: jsonRoutes} = config;
+  const csString = caseSensitive ? "true" : "false";
+  const routes = generateRouteDefinitions(jsonRoutes);
+  const handlers = generateHandlerClasses(jsonRoutes);
+  return `import { createRouter as createLwrRouter } from 'lwr/router';
+${handlers}
+export function createRouter({ basePath = '${basePath}', caseSensitive = ${csString} } = {}) {
+    return createLwrRouter({ basePath, caseSensitive, routes: ${routes} });
+}`;
+}

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

@@ -48,6 +48,7 @@ export declare class DomRouterImpl implements DomRouter {
     pendingRoute: DomRoutingMatch | null;
     committedRoute: DomRoutingMatch | null;
     routeObservable: Observable<RoutingResult>;
+    eventId?: string;
     contextId: ContextId;
     connected: boolean;
     parent?: DomRouter;

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

@@ -1,3 +1,5 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+
 /**
  * Copyright (c) 2019, salesforce.com, inc.
  * All rights reserved.
@@ -8,7 +10,11 @@ import { CurrentPageReference, CurrentRoute, CurrentView, NavigationContext, reg
 import { currentPageReferenceContextualizer, currentRouteContextualizer, currentViewContextualizer, navigationContextContextualizer, provideContext } from 'lwr/contextProvider';
 import { generateMessageObject, invariant, messages } from 'lwr/routerErrors';
 import { createFilterChain, guid } from 'lwr/routerUtils';
-import { createObservable } from 'lwr/observable';
+import { createObservable } from 'lwr/observable'; // @ts-ignore Need to import from client-modules package
+
+import { ROUTER_ERROR, ROUTER_NAV, ROUTER_VIEW } from 'lwr/metrics'; // @ts-ignore
+
+import { logOperationStart, logOperationEnd } from 'lwr/profiler';
 import { CONTEXT_ID_BACKDOOR } from 'lwr/navigationMixinHacks';
 // Event fired when a component calls navigate()
 export const NAV_EVENT = `universalcontainernavigationevent${guid()}`;
@@ -17,6 +23,7 @@ export const PARENT_EVENT = `universalcontainerparentevent${guid()}`;
 export class DomRouterImpl {
   pendingRoute = null;
   committedRoute = null;
+  // used for instrumentation
   contextId = Object.freeze(() => undefined);
   connected = false;
   preNavFilters = createFilterChain();
@@ -84,9 +91,13 @@ export class DomRouterImpl {
       if (this.committedRoute && result.route === this.committedRoute.route) {
         // This nav event has already been processed, DO NOT do it again #957
         return;
-      } // if there's no pending route (the router was called to navigate independently of the DomRouter)
-      // then provide the result page reference -> url as the default
+      }
 
+      logOperationEnd({
+        id: ROUTER_VIEW,
+        specifier: this.eventId
+      }); // if there's no pending route (the router was called to navigate independently of the DomRouter)
+      // then provide the result page reference -> url as the default
 
       this.pendingRoute = this.pendingRoute || { ...result,
         url
@@ -98,6 +109,10 @@ export class DomRouterImpl {
       CurrentRoute.setContext(this.target, this.committedRoute.route);
       this.routeObservable.next({ ...this.committedRoute,
         viewset: result.viewset
+      });
+      logOperationEnd({
+        id: ROUTER_NAV,
+        specifier: this.eventId
       }); // kick off child node processing (if necessary)
 
       if (this.child) {
@@ -131,6 +146,10 @@ export class DomRouterImpl {
     this.router.subscribe(result => {
       const pageReference = result.route.pageReference || {};
       const url = this.router.generateUrl(pageReference) || '';
+      logOperationStart({
+        id: ROUTER_VIEW,
+        specifier: this.eventId
+      });
 
       if (result.viewset) {
         // If result includes a viewset, wait to emit pageReference until the view is resolved.
@@ -243,7 +262,18 @@ export class DomRouterImpl {
 
 
   async process(url, replace) {
-    // Run the root -> leaf chain of pre navigate filters, if this is the root.
+    // 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()
+    //      2. The HistoryRouter catches a popstate event
+    //      3. Nested router processing
+    // Note: The < 1ms worth of logic in navigate() and _handleNavigationEvent() is excluded
+    this.eventId = new Date().getTime().toString();
+    logOperationStart({
+      id: ROUTER_NAV,
+      specifier: this.eventId
+    }); // Run the root -> leaf chain of pre navigate filters, if this is the root.
+
     try {
       if (!this.parent) {
         await this.preProcess(url);
@@ -312,6 +342,9 @@ export class DomRouterImpl {
 
 
   processError(messageObject) {
+    logOperationStart({
+      id: ROUTER_ERROR
+    });
     this.errorNavFilters.compile(messageObject);
 
     if (this.child) {

package/build/modules/lwr/routerUtils/types.d.ts

@@ -97,7 +97,7 @@ export declare type RoutingResult = RoutingMatch & {
     viewset: ViewSet;
 };
 export interface ViewSet {
-    [namedView: string]: (() => Promise<Module>) | ViewInfo;
+    [viewName: string]: (() => Promise<Module>) | ViewInfo;
 }
 export interface ViewInfo {
     module: () => Promise<Module>;

package/build/services/index.d.ts

@@ -0,0 +1,27 @@
+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>;
+}
+/**
+ * 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/services/index.js

@@ -0,0 +1,103 @@
+import Ajv from 'ajv';
+import { existsSync } from 'fs';
+import { readFile } from '@lwrjs/shared-utils';
+import { LwrUnresolvableError, createSingleDiagnosticError, descriptions } from '@lwrjs/diagnostics';
+export const DEFAULT_SCHEMA = 'pageReference_v1';
+// JSON Schema for the interfaces above
+const RouteDefinitionSchema = {
+    definitions: {
+        map: {
+            type: 'object',
+            patternProperties: {
+                '^.+$': { type: 'string', minLength: 1 },
+            },
+        },
+        nullableMap: {
+            type: 'object',
+            patternProperties: {
+                '^.+$': {
+                    anyOf: [{ type: 'string', minLength: 1 }, { type: 'null' }],
+                },
+            },
+        },
+        specifier: {
+            type: 'string',
+            pattern: '^@?[a-zA-Z_\\d]+[/]{1}[a-z-A-Z_\\d]+$',
+        },
+        routeDef: {
+            type: 'object',
+            properties: {
+                id: { type: 'string', minLength: 1 },
+                uri: { type: 'string', minLength: 1 },
+                patterns: { $ref: '#/definitions/map' },
+                exact: { type: 'boolean' },
+                page: {
+                    type: 'object',
+                    properties: {
+                        type: { type: 'string', minLength: 1 },
+                        attributes: { $ref: '#/definitions/nullableMap' },
+                        state: { $ref: '#/definitions/nullableMap' },
+                    },
+                },
+                metadata: {},
+                handler: { $ref: '#/definitions/specifier' },
+                component: { $ref: '#/definitions/specifier' },
+            },
+            required: ['id', 'uri', 'page'],
+            additionalProperties: false,
+        },
+    },
+    type: 'object',
+    properties: {
+        schema: { type: 'string', pattern: `^${DEFAULT_SCHEMA}$` },
+        basePath: { type: 'string', minLength: 1 },
+        caseSensitive: { type: 'boolean' },
+        routes: {
+            type: 'array',
+            items: { $ref: '#/definitions/routeDef' },
+        },
+    },
+    required: ['routes'],
+    additionalProperties: false,
+};
+const ajv = new Ajv();
+const validate = ajv.compile(RouteDefinitionSchema);
+/**
+ * Given a Routes Config path, return the array of Config Route Definitions
+ * @param path - A path to a Route Config files
+ */
+export function getClientRoutes(path) {
+    if (!existsSync(path)) {
+        return undefined;
+    }
+    try {
+        // Validate the JSON schema
+        const json = JSON.parse(readFile(path));
+        if (!validate(json)) {
+            throw new Error(ajv.errorsText(validate.errors, { separator: '\n' }));
+        }
+        // Additional validation:
+        // 1. Ensure each route definition "id" is unique
+        // 2. Ensure each route definition has either a "handler" or a "component", but NOT BOTH
+        const routes = json.routes;
+        routes.forEach((route, index) => {
+            const { id, handler, component } = route;
+            if (routes.findIndex((r) => r.id === id) !== index) {
+                throw new Error(`Duplicate route definition id: ${id}`);
+            }
+            if (handler && component) {
+                throw new Error('A route definition cannot contain both "handler" and "component"');
+            }
+            if (!handler && !component) {
+                throw new Error('A route definition must contain either "handler" or "component"');
+            }
+        });
+        return json;
+    }
+    catch (e) {
+        throw createSingleDiagnosticError({
+            description: descriptions.UNRESOLVABLE.ROUTES_MODULE(path, e.message),
+        }, LwrUnresolvableError);
+    }
+}
+//# sourceMappingURL=index.js.map

package/build/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;
+    private routerEmitter;
+    private routerWatcher?;
+    private watchedFileMap;
+    private routerConfigJsonCache;
+    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/services/module-provider/index.js

@@ -0,0 +1,126 @@
+import { hashContent, normalizeResourcePath } from '@lwrjs/shared-utils';
+import { generateModule, getRouterConfigPath, parseSpecifier, setUpWatcher } from './utils.js';
+import { getClientRoutes } from '../index.js';
+const DEFAULT_DIR = '$rootDir/src/routes';
+export default class RouterModuleProvider {
+    constructor({ routesDir = DEFAULT_DIR }, context) {
+        this.name = 'router-module-provider';
+        this.watchedFileMap = new Map(); // <config path, module id>
+        // Two layers of caching:
+        //      1. Cache the Router Config JSON objects read from the file system, by config path
+        //      2. Cache the modules generated from the config, by config path
+        this.routerConfigJsonCache = new Map();
+        this.routerModuleCache = new Map();
+        const { appEmitter, config: { rootDir, contentDir, layoutsDir }, runtimeEnvironment: { lwrVersion, watchFiles }, } = context;
+        this.version = lwrVersion;
+        // Replace aliases and remove trailing slash from the routes directory
+        this.routesDir = normalizeResourcePath(routesDir, {
+            rootDir,
+            assets: [],
+            contentDir,
+            layoutsDir,
+        }).replace(/\/$/, '');
+        // Set up watcher on Router Config files
+        this.routerEmitter = appEmitter;
+        this.routerWatcher = watchFiles ? setUpWatcher(this.onRouterModuleChange.bind(this)) : undefined;
+    }
+    // When Router Metadata changes on the file system:
+    //      1. delete the config data from the routerConfigJsonCache
+    //      2. delete the module from the routerModuleCache
+    //      3. recompile the module based on the new data and emit
+    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...');
+        }
+        this.routerConfigJsonCache.delete(configPath);
+        this.routerModuleCache.delete(configPath);
+        if (!deleted) {
+            const recompiledModule = await this.getModule(moduleId);
+            if (recompiledModule) {
+                this.routerEmitter.notifyModuleSourceChanged(recompiledModule);
+            }
+        }
+    }
+    // Watch Router Config files:
+    //      1. Add files to the watcher
+    //      2. Track watched files in the watchedFileMap with the associated module ID object
+    watchConfigs(specifier, moduleId) {
+        if (this.routerWatcher) {
+            const configPath = getRouterConfigPath(this.routesDir, specifier);
+            if (!this.watchedFileMap.has(configPath)) {
+                this.routerWatcher.add(configPath);
+            }
+            this.watchedFileMap.set(configPath, moduleId);
+        }
+    }
+    // 1. Check that:
+    //      a. the specifier is in the correct format: "@lwrjs/router/{routerId}"
+    //      b. the config JSON addressed by "routerId" is available on the file system
+    // 2. Maintain the Router Config cache
+    getRouterConfig(specifier) {
+        let config;
+        const routerId = parseSpecifier(specifier);
+        if (routerId) {
+            // Fetch the Router Config JSON from the cache or file system
+            const cacheKey = getRouterConfigPath(this.routesDir, specifier);
+            if (this.routerConfigJsonCache.has(cacheKey)) {
+                // Cache hit
+                config = this.routerConfigJsonCache.get(cacheKey);
+            }
+            else {
+                // Cache miss, read from file system
+                config = getClientRoutes(cacheKey);
+                if (config) {
+                    this.routerConfigJsonCache.set(cacheKey, config);
+                }
+            }
+        }
+        return config;
+    }
+    async getModuleEntry({ specifier }) {
+        const config = this.getRouterConfig(specifier);
+        if (config) {
+            return {
+                id: `${specifier}|${this.version}`,
+                virtual: true,
+                entry: `<virtual>/${specifier}.js`,
+                specifier,
+                version: this.version,
+            };
+        }
+    }
+    async getModule(moduleId) {
+        // Retrieve the Module Entry
+        const { specifier, namespace, name = specifier } = moduleId;
+        const moduleEntry = await this.getModuleEntry({ specifier });
+        if (!moduleEntry) {
+            return;
+        }
+        // Check the module cache first
+        const configPath = getRouterConfigPath(this.routesDir, specifier);
+        if (this.routerModuleCache.has(configPath)) {
+            return this.routerModuleCache.get(configPath);
+        }
+        // Generate code for the requested module
+        const config = this.getRouterConfig(specifier);
+        const compiledSource = generateModule(config);
+        // Construct a Compiled Module
+        const moduleCompiled = {
+            id: moduleEntry.id,
+            specifier,
+            namespace,
+            name,
+            version: this.version,
+            originalSource: compiledSource,
+            moduleEntry,
+            ownHash: hashContent(compiledSource),
+            compiledSource,
+        };
+        // Watch Router Config file, add cache entries, and return
+        this.watchConfigs(specifier, moduleId);
+        this.routerModuleCache.set(configPath, moduleCompiled);
+        return moduleCompiled;
+    }
+}
+//# sourceMappingURL=index.js.map

package/build/services/module-provider/utils.d.ts

@@ -0,0 +1,26 @@
+import type { Watcher } from '@lwrjs/types';
+import type { LwrRouterConfig } from '../index.js';
+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(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