@lwrjs/core 0.11.0-alpha.8 → 0.11.0

package/build/cjs/tools/static-generation.cjs

@@ -28,6 +28,7 @@ __export(exports, {
   default: () => static_generation_default
 });
 var import_perf_hooks = __toModule(require("perf_hooks"));
+var import_diagnostics = __toModule(require("@lwrjs/diagnostics"));
 var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
 var import_site_metadata = __toModule(require("@lwrjs/static/site-metadata"));
 var import_path = __toModule(require("path"));
@@ -38,74 +39,82 @@ var import_config = __toModule(require("@lwrjs/config"));
 var SiteGenerator = class {
   async buildStaticApplication(config, dispatcher) {
     const startTime = import_perf_hooks.performance.now();
-    import_shared_utils.logger.info("[SSG] Static Site Generation");
-    if (!import_shared_utils.logger.currentLevel || import_shared_utils.logger.currentLevel == import_shared_utils.WARN || import_shared_utils.logger.currentLevel == import_shared_utils.INFO) {
-      import_shared_utils.logger.setOptions({dedupe: new Set([import_shared_utils.WARN])});
+    import_diagnostics.logger.info("[SSG] Static Site Generation");
+    if (!import_diagnostics.logger.currentLevel || import_diagnostics.logger.currentLevel == import_diagnostics.WARN || import_diagnostics.logger.currentLevel == import_diagnostics.INFO) {
+      import_diagnostics.logger.setOptions({dedupe: new Set([import_diagnostics.WARN])});
     }
-    const {routes, staticSiteGenerator, rootDir, assets} = config;
+    const {assets, basePath, rootDir, routes, staticSiteGenerator} = config;
     if (!staticSiteGenerator.outputDir) {
       staticSiteGenerator.outputDir = "site";
     }
     const outputDir = (0, import_path.join)(rootDir, staticSiteGenerator.outputDir);
     if (!staticSiteGenerator.skipCleanOutputDir) {
-      import_shared_utils.logger.info(`[SSG] Clearing output directory: ${outputDir}`);
+      import_diagnostics.logger.info(`[SSG] Clearing output directory: ${outputDir}`);
       import_fs_extra.default.rmSync(outputDir, {recursive: true, force: true});
     } else if (import_fs_extra.default.existsSync(outputDir)) {
-      import_shared_utils.logger.info(`[SSG] Reusing existing output directory: ${outputDir}`);
+      import_diagnostics.logger.info(`[SSG] Reusing existing output directory: ${outputDir}`);
     }
     const urlRewriteMap = new Map();
-    const {basePath} = config;
     const runtimeEnvironment = (0, import_config.getRuntimeEnvironment)(config);
-    import_shared_utils.logger.info(`[SSG] Building routes (this may take some time to complete)`);
+    import_diagnostics.logger.info(`[SSG] Building routes (this may take some time to complete)`);
     await this.generateRoutes(runtimeEnvironment, staticSiteGenerator, routes, basePath, dispatcher, outputDir, urlRewriteMap);
     this.writeNetlifyRedirectConfig(outputDir, urlRewriteMap);
     await this.copyAssets(assets, outputDir, config);
     const endTime = import_perf_hooks.performance.now();
     const timeDiff = (endTime - startTime) / 1e3;
-    import_shared_utils.logger.info(`[SSG] Static Site Generation complete in ${Math.round(timeDiff)} seconds`);
+    import_diagnostics.logger.info(`[SSG] Static Site Generation complete in ${Math.round(timeDiff)} seconds`);
   }
   async generateRoutes(runtimeEnvironment, staticSiteGenerator, routes, basePath, dispatcher, outputDir, urlRewriteMap = new Map()) {
-    if (!staticSiteGenerator.locales) {
-      staticSiteGenerator.locales = ["en-US"];
-    }
     const generateUrl = this.createGenerateURLFunction(dispatcher);
     const {skipBaseDocumentGeneration = false} = staticSiteGenerator;
-    for (const locale of staticSiteGenerator.locales) {
-      for (const route of routes) {
-        const siteConfig = this.createSiteConfig(outputDir, locale, urlRewriteMap, skipBaseDocumentGeneration, runtimeEnvironment);
-        await generateUrl(basePath + route.path, siteConfig);
+    const i18n = runtimeEnvironment.i18n;
+    if (!i18n.uriPattern) {
+      await this.generateRoutesForLocale(routes, outputDir, {id: i18n.defaultLocale}, urlRewriteMap, skipBaseDocumentGeneration, runtimeEnvironment, basePath, generateUrl, staticSiteGenerator, dispatcher);
+    } else {
+      const sortedLocales = (0, import_shared_utils.sortLocalesByFallback)(i18n);
+      for (const locale of sortedLocales) {
+        import_diagnostics.logger.debug(`[SSG] Generate routes of locale: ${locale.id}`);
+        await this.generateRoutesForLocale(routes, outputDir, locale, urlRewriteMap, skipBaseDocumentGeneration, runtimeEnvironment, basePath, generateUrl, staticSiteGenerator, dispatcher);
       }
-      if (staticSiteGenerator._additionalRoutePaths) {
-        for (const uri of staticSiteGenerator._additionalRoutePaths) {
-          const siteConfig = this.createSiteConfig(outputDir, locale, urlRewriteMap, skipBaseDocumentGeneration, runtimeEnvironment);
-          await generateUrl(uri, siteConfig);
-        }
+    }
+  }
+  async generateRoutesForLocale(routes, outputDir, locale, urlRewriteMap, skipBaseDocumentGeneration, runtimeEnvironment, basePath, generateUrl, staticSiteGenerator, dispatcher) {
+    const i18n = runtimeEnvironment.i18n;
+    for (const route of routes) {
+      const siteConfig = this.createSiteConfig(outputDir, locale.id, urlRewriteMap, skipBaseDocumentGeneration, runtimeEnvironment, i18n);
+      const localizedPath = (0, import_shared_utils.getViewUri)(route.path, basePath, locale.id, i18n);
+      await generateUrl(localizedPath, siteConfig);
+    }
+    if (staticSiteGenerator._additionalRoutePaths) {
+      for (const uri of staticSiteGenerator._additionalRoutePaths) {
+        const siteConfig = this.createSiteConfig(outputDir, locale.id, urlRewriteMap, skipBaseDocumentGeneration, runtimeEnvironment, i18n);
+        await generateUrl(uri, siteConfig);
       }
-      const {_additionalModules} = staticSiteGenerator;
-      if (_additionalModules) {
-        for (const specifier of _additionalModules) {
-          import_shared_utils.logger.debug(`[SSG] Additional Module: ${locale} ${specifier}`);
-          const startTime = import_perf_hooks.performance.now();
-          const siteConfig = this.createSiteConfig(outputDir, locale, urlRewriteMap, skipBaseDocumentGeneration, runtimeEnvironment);
-          await this.dispatchJSResourceRecursive(specifier, dispatcher, siteConfig, true);
-          await this.captureAdditionalRouteMetadata(siteConfig);
-          const endTime = import_perf_hooks.performance.now();
-          const timeDiff = endTime - startTime;
-          import_shared_utils.logger.info(`[SSG] Additional Module ${locale} ${specifier} in ${Math.round(timeDiff)} ms`);
-        }
+    }
+    const {_additionalModules} = staticSiteGenerator;
+    if (_additionalModules) {
+      for (const specifier of _additionalModules) {
+        import_diagnostics.logger.debug(`[SSG] Additional Module: ${locale.id} ${specifier}`);
+        const startTime = import_perf_hooks.performance.now();
+        const siteConfig = this.createSiteConfig(outputDir, locale.id, urlRewriteMap, skipBaseDocumentGeneration, runtimeEnvironment, i18n);
+        await this.dispatchJSResourceRecursive(specifier, dispatcher, siteConfig, true);
+        await this.captureAdditionalRouteMetadata(siteConfig);
+        const endTime = import_perf_hooks.performance.now();
+        const timeDiff = endTime - startTime;
+        import_diagnostics.logger.info(`[SSG] Additional Module ${locale.id} ${specifier} in ${Math.round(timeDiff)} ms`);
       }
     }
   }
   createGenerateURLFunction(dispatcher) {
     const generateRoute = async (uri, siteConfig) => {
       const locale = siteConfig.locale;
-      import_shared_utils.logger.debug(`[SSG] Start Generate: ${locale} ${uri}`);
+      import_diagnostics.logger.debug(`[SSG] Start Generate: ${locale} ${uri}`);
       const startTime = import_perf_hooks.performance.now();
       await this.dispatchResourceRecursive(uri, dispatcher, {resourceType: "route"}, siteConfig);
       await this.captureAdditionalRouteMetadata(siteConfig);
       const endTime = import_perf_hooks.performance.now();
       const timeDiff = endTime - startTime;
-      import_shared_utils.logger.info(`[SSG] ${locale} ${uri} in ${Math.round(timeDiff)} ms`);
+      import_diagnostics.logger.info(`[SSG] ${locale} ${uri} in ${Math.round(timeDiff)} ms`);
     };
     return generateRoute.bind(this);
   }
@@ -114,11 +123,11 @@ var SiteGenerator = class {
     if (!visitedUrls.has(url)) {
       visitedUrls.add(url);
       if ((0, import_shared_utils.isExternalUrl)(url)) {
-        import_shared_utils.logger.warn("[SSG] Skipped generation of external url: " + url);
+        import_diagnostics.logger.warn("[SSG] Skipped generation of external url: " + url);
         return;
       }
       if (url.indexOf("/:") !== -1 || url.indexOf("*") !== -1) {
-        import_shared_utils.logger.warn("[SSG] Skipped generation of url with variable path segment: " + url);
+        import_diagnostics.logger.warn("[SSG] Skipped generation of url with variable path segment: " + url);
         return;
       }
       let context;
@@ -179,13 +188,16 @@ var SiteGenerator = class {
   }
   addBundleToSiteMetadata(bundleDefinition, url, siteConfig) {
     if (siteConfig.siteMetadata) {
-      const specifier = bundleDefinition.specifier;
+      const locale = siteConfig.locale;
+      const specifier = siteConfig.i18n.defaultLocale === locale ? bundleDefinition.specifier : `${bundleDefinition.specifier}|l/${locale}`;
       const imports = bundleDefinition.bundleRecord.imports?.map((moduleRef) => (0, import_shared_utils.getSpecifier)(moduleRef)) || [];
+      const dynamicImports = bundleDefinition.bundleRecord.dynamicImports?.map((moduleRef) => (0, import_shared_utils.getSpecifier)(moduleRef));
       const bundleMetadata = {
         version: bundleDefinition.version,
         path: decodeURIComponent(url),
         includedModules: bundleDefinition.bundleRecord.includedModules || [],
-        imports
+        imports,
+        dynamicImports
       };
       const siteBundles = siteConfig.siteMetadata.getSiteBundles().bundles;
       siteBundles[specifier] = bundleMetadata;
@@ -194,7 +206,7 @@ var SiteGenerator = class {
   addResourceToSiteMetadata(resourceDefinition, url, siteConfig) {
     if (siteConfig.siteMetadata) {
       if (!resourceDefinition.specifier) {
-        import_shared_utils.logger.warn("[SSG] Could not save resource metadata.  There was no specifier.", resourceDefinition);
+        import_diagnostics.logger.warn("[SSG] Could not save resource metadata.  There was no specifier.", resourceDefinition);
       } else {
         const specifier = resourceDefinition.specifier;
         const resourceMetadata = {
@@ -210,7 +222,7 @@ var SiteGenerator = class {
   addAssetToSiteMetadata(assetDefinition, url, siteConfig) {
     if (siteConfig.siteMetadata) {
       if (!assetDefinition.uri) {
-        import_shared_utils.logger.warn("[SSG] Could not save asset metadata.  There was no uri.", assetDefinition);
+        import_diagnostics.logger.warn("[SSG] Could not save asset metadata.  There was no uri.", assetDefinition);
       } else {
         const specifier = assetDefinition.uri;
         const resourceMetadata = {
@@ -221,7 +233,7 @@ var SiteGenerator = class {
         if (!siteAssets.assets[specifier]) {
           siteAssets.assets[specifier] = resourceMetadata;
         } else {
-          import_shared_utils.logger.debug(`[SSG] Ignore asset redefinition ${specifier}`);
+          import_diagnostics.logger.debug(`[SSG] Ignore asset redefinition ${specifier}`);
         }
       }
     }
@@ -244,7 +256,7 @@ var SiteGenerator = class {
       await Promise.all(dispatchRequests);
     } else {
       const body = context.fs?.body;
-      import_shared_utils.logger.warn(`[SSG] Failed to fetch ${url}: (${statusCode}) ${body}`);
+      import_diagnostics.logger.warn(`[SSG] Failed to fetch ${url}: (${statusCode}) ${body}`);
     }
   }
   async handleHtmlResource(url, context, siteConfig, dispatcher) {
@@ -258,16 +270,9 @@ var SiteGenerator = class {
         directoryPath = url.substring(0, lastPathIndex);
       }
       const dir = (0, import_dir.createResourceDir)(directoryPath, outputDir);
-      const localeDir = (0, import_dir.createResourceDir)(directoryPath, (0, import_path.join)(outputDir, siteConfig.locale));
       const filePath = (0, import_path.join)(dir, fileName);
-      const fileLocalePath = (0, import_path.join)(localeDir, fileName);
-      if (siteConfig.locale.toLowerCase().startsWith("en")) {
-        siteConfig.viewPaths.add(filePath);
-        await (0, import_stream.writeResponse)(context, filePath);
-      }
-      (0, import_dir.createDir)(localeDir);
-      siteConfig.viewPaths.add(fileLocalePath);
-      await (0, import_stream.writeResponse)(context, fileLocalePath);
+      siteConfig.viewPaths.add(filePath);
+      await (0, import_stream.writeResponse)(context, filePath);
     }
     const viewDefinition = context.fs?.metadata?.viewDefinition;
     if (viewDefinition) {
@@ -310,7 +315,7 @@ var SiteGenerator = class {
             siteConfig.viewConfigPath = this.getResourcePathFromUrl(siteConfig, resourceUri);
           }
         } else {
-          import_shared_utils.logger.warn("[SSG] Skipped inline bootstrap resource: %j", resource);
+          import_diagnostics.logger.warn("[SSG] Skipped inline bootstrap resource: %j", resource);
         }
       }
     }
@@ -320,7 +325,7 @@ var SiteGenerator = class {
       if (resourceUri.startsWith("/")) {
         dispatchRequests.push(this.dispatchResourceRecursive(resourceUri, dispatcher, {resourceType: "resource"}, siteConfig));
       } else {
-        import_shared_utils.logger.warn("[SSG] Skipped resource: %j", resource);
+        import_diagnostics.logger.warn("[SSG] Skipped resource: %j", resource);
       }
     }
     await Promise.all(dispatchRequests);
@@ -336,7 +341,7 @@ var SiteGenerator = class {
           const mappingURL = siteConfig.endpoints?.uris?.mapping + encodeURIComponent(jsUri);
           await this.dispatchResourceRecursive(mappingURL, dispatcher, {resourceType: "mapping"}, siteConfig);
         } else {
-          import_shared_utils.logger.warn('[SSG] Unable to fetch mapping for bare specifier or variable dynamic import: "' + jsUri + '"');
+          import_diagnostics.logger.warn('[SSG] Unable to fetch mapping for bare specifier or variable dynamic import: "' + jsUri + '"');
         }
       } else if (isAdditionalModulesRequest) {
         const uri = `${siteConfig.endpoints?.uris.legacyDefault}${encodeURIComponent(jsUri)}`;
@@ -358,7 +363,7 @@ var SiteGenerator = class {
     for (const ref of assetReferences) {
       const refUrl = ref.override?.uri || ref.url;
       dispatchRequests.push(this.dispatchResourceRecursive(refUrl, dispatcher, {resourceType: "asset", asset: metadata?.asset}, siteConfig).catch((err) => {
-        import_shared_utils.logger.warn(`[SSG] Failed to fetch asset reference => ${refUrl} from ${url}`, err);
+        import_diagnostics.logger.warn(`[SSG] Failed to fetch asset reference => ${refUrl} from ${url}`, err);
       }));
     }
     return Promise.all(dispatchRequests);
@@ -391,7 +396,7 @@ var SiteGenerator = class {
   async copyAssets(assets, outputDir, config) {
     const {basePath} = config;
     const runtimeEnvironment = (0, import_config.getRuntimeEnvironment)(config);
-    const siteConfig = this.createSiteConfig(outputDir, "en-US", new Map(), true, runtimeEnvironment);
+    const siteConfig = this.createSiteConfig(outputDir, "en-US", new Map(), true, runtimeEnvironment, config.i18n);
     for (const asset of assets) {
       try {
         const assetSrcFile = asset.file;
@@ -418,11 +423,11 @@ var SiteGenerator = class {
           import_fs_extra.default.copySync(assetSrcFile, assetsPath);
           this.addAssetToMetadata(assetsPath, siteConfig);
         } else {
-          import_shared_utils.logger.warn("[SSG] Could not find assets to copy at path: " + assetsPath);
+          import_diagnostics.logger.warn("[SSG] Could not find assets to copy at path: " + assetsPath);
         }
       } catch (e) {
-        import_shared_utils.logger.error("[SSG] Error occurred processing asset config: " + JSON.stringify(asset));
-        import_shared_utils.logger.error(e);
+        import_diagnostics.logger.error("[SSG] Error occurred processing asset config: " + JSON.stringify(asset));
+        import_diagnostics.logger.error(e);
       }
     }
     await siteConfig.siteMetadata?.persistSiteMetadata();
@@ -439,7 +444,7 @@ var SiteGenerator = class {
         }
       }
     } catch (err) {
-      import_shared_utils.logger.warn(`[SSG] Unexpected error collecting asset directory metadata for ${directoryPath}`, err);
+      import_diagnostics.logger.warn(`[SSG] Unexpected error collecting asset directory metadata for ${directoryPath}`, err);
     }
   }
   addAssetToMetadata(filePath, siteConfig) {
@@ -448,22 +453,22 @@ var SiteGenerator = class {
       this.addAssetToSiteMetadata({
         uri,
         type: "asset",
-        stream: function(encoding) {
+        stream: function(_encoding) {
           throw new Error("Function not implemented.");
         },
         entry: filePath,
         ext: (0, import_path.extname)(filePath),
         mime: (0, import_shared_utils.mimeLookup)(filePath),
         ownHash: "not-provided",
-        content: function(encoding) {
+        content: function(_encoding) {
           throw new Error("Function not implemented.");
         }
       }, uri, siteConfig);
     } catch (err) {
-      import_shared_utils.logger.warn(`[SSG] Unexpected error collecting asset metadata for ${filePath}`, err);
+      import_diagnostics.logger.warn(`[SSG] Unexpected error collecting asset metadata for ${filePath}`, err);
     }
   }
-  createSiteConfig(outputDir, locale, urlRewriteMap, skipBaseDocumentGeneration, runtimeEnvironment) {
+  createSiteConfig(outputDir, locale, urlRewriteMap, skipBaseDocumentGeneration, runtimeEnvironment, i18n) {
     const featureFlags = this.filterFeatureFlags();
     const endpoints = {
       uris: {
@@ -480,7 +485,8 @@ var SiteGenerator = class {
       endpoints,
       skipBaseDocumentGeneration,
       ...featureFlags,
-      siteMetadata: new import_site_metadata.SiteMetadataImpl({rootDir: outputDir})
+      siteMetadata: new import_site_metadata.SiteMetadataImpl({rootDir: outputDir}),
+      i18n
     };
   }
   filterFeatureFlags() {

package/build/cjs/tools/utils/network-dispatcher.cjs

@@ -28,6 +28,7 @@ __export(exports, {
 });
 var import_http = __toModule(require("http"));
 var import_https = __toModule(require("https"));
+var import_diagnostics = __toModule(require("@lwrjs/diagnostics"));
 var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
 var NetworkDispatcher = class {
   constructor(port, internalRequestKey) {
@@ -59,46 +60,46 @@ var NetworkDispatcher = class {
     return new Promise((resolve, reject) => {
       const httpClient = options.port == 443 ? import_https.default : import_http.default;
       const bodyChunks = [];
-      import_shared_utils.logger.verbose(`[NetworkDispatcher] Request: [${method}][${lang}] ${url}`);
+      import_diagnostics.logger.verbose(`[NetworkDispatcher] Request: [${method}][${lang}] ${url}`);
       const req = httpClient.request(options, (res) => {
         res.on("data", (chunk) => {
           bodyChunks.push(chunk);
         });
         res.on("end", () => {
-          import_shared_utils.logger.verbose(`[END][NetworkDispatcher] Request: [${method}][${lang}] ${url}`);
+          import_diagnostics.logger.verbose(`[END][NetworkDispatcher] Request: [${method}][${lang}] ${url}`);
           if (!res.statusCode || res.statusCode >= 200 && res.statusCode < 300) {
             const body = Buffer.concat(bodyChunks).toString();
             try {
               const jsonResponse = JSON.parse(body);
               resolve(jsonResponse);
             } catch (err) {
-              if (import_shared_utils.logger.currentLevel == import_shared_utils.DEBUG || import_shared_utils.logger.currentLevel == import_shared_utils.VERBOSE) {
-                import_shared_utils.logger.warn(`[NetworkDispatcher] unexpected response body: [${method}][${lang}] ${url}: '${body}'`, err);
+              if (import_diagnostics.logger.currentLevel == import_diagnostics.DEBUG || import_diagnostics.logger.currentLevel == import_diagnostics.VERBOSE) {
+                import_diagnostics.logger.warn(`[NetworkDispatcher] unexpected response body: [${method}][${lang}] ${url}: '${body}'`, err);
               } else {
-                import_shared_utils.logger.warn(`[NetworkDispatcher] unexpected response body: [${method}][${lang}] ${url}: '${body}'`);
+                import_diagnostics.logger.warn(`[NetworkDispatcher] unexpected response body: [${method}][${lang}] ${url}: '${body}'`);
               }
               resolve({});
             }
           } else if (res.statusCode === 301 || res.statusCode === 302) {
             if (res.headers?.location && (0, import_shared_utils.isModuleOrBundleUrl)(res.headers?.location)) {
-              import_shared_utils.logger.debug(`[NetworkDispatcher] Follow redirect: [${method}][${lang}][${res.statusCode}] ${url} -> ${res.headers.location}`);
+              import_diagnostics.logger.debug(`[NetworkDispatcher] Follow redirect: [${method}][${lang}][${res.statusCode}] ${url} -> ${res.headers.location}`);
               const location = res.headers.location;
               return this.handleRequest(this.createRequestOptions(location, method, lang), location, method, lang).then((resRedirect) => resolve(resRedirect)).catch((rejectRedirect) => reject(rejectRedirect));
             } else {
-              import_shared_utils.logger.warn(`Redirect not followed: [${method}][${lang}][${res.statusCode}] ${url} -> ${res.headers.location}`);
+              import_diagnostics.logger.warn(`Redirect not followed: [${method}][${lang}][${res.statusCode}] ${url} -> ${res.headers.location}`);
               resolve({});
             }
           } else {
-            import_shared_utils.logger.warn(`Unexpected status code: [${method}][${lang}][${res.statusCode}] ${url}`);
+            import_diagnostics.logger.warn(`Unexpected status code: [${method}][${lang}][${res.statusCode}] ${url}`);
             resolve({});
           }
         });
       });
       req.on("error", (err) => {
-        if (import_shared_utils.logger.currentLevel == import_shared_utils.DEBUG || import_shared_utils.logger.currentLevel == import_shared_utils.VERBOSE) {
-          import_shared_utils.logger.warn(`[NetworkDispatcher] Request Failed: [${method}][${lang}] ${url}`, err);
+        if (import_diagnostics.logger.currentLevel == import_diagnostics.DEBUG || import_diagnostics.logger.currentLevel == import_diagnostics.VERBOSE) {
+          import_diagnostics.logger.warn(`[NetworkDispatcher] Request Failed: [${method}][${lang}] ${url}`, err);
         } else {
-          import_shared_utils.logger.warn(`[NetworkDispatcher] Request  Failed: [${method}][${lang}] ${url}`);
+          import_diagnostics.logger.warn(`[NetworkDispatcher] Request  Failed: [${method}][${lang}] ${url}`);
         }
         resolve({});
       });

package/build/es/context/server.js

@@ -4,8 +4,7 @@ import { LwrModuleRegistry } from '@lwrjs/module-registry';
 import { LwrResourceRegistry } from '@lwrjs/resource-registry';
 import { LwrApplicationObserver } from '@lwrjs/shared-utils';
 import { LwrViewRegistry } from '@lwrjs/view-registry';
-// dependency chokidar in this package.json is to statisfy the optional dependency in shared-utils for fs-watch.
-import { WatcherFactoryImpl } from '@lwrjs/shared-utils/fs-watch';
+import { WatcherFactoryImpl } from '@lwrjs/fs-watch';
 export function createServerContext(appConfig, runtimeEnvironment, globalData) {
     const appObserver = new LwrApplicationObserver();
     const appEmitter = appObserver.createLwrEmitter();

package/build/es/index.js

@@ -1,12 +1,13 @@
-import { getFeatureFlags, DEFAULT_LWR_BOOTSTRAP_CONFIG, logger } from '@lwrjs/shared-utils';
+import { getFeatureFlags, DEFAULT_LWR_BOOTSTRAP_CONFIG } from '@lwrjs/shared-utils';
 import { createInternalServer } from '@lwrjs/server';
-import { LwrServerError, createSingleDiagnosticError, descriptions } from '@lwrjs/diagnostics';
+import { LwrServerError, createSingleDiagnosticError, descriptions, logger } from '@lwrjs/diagnostics';
 import { loadConfig, executeConfigHooks, executeStartHooks, executeInstrumentationHooks, } from '@lwrjs/config';
 import { loadHooks, loadServices, loadRouteHandlers } from '@lwrjs/config/modules';
 import SiteGenerator from './tools/static-generation.js';
 import { warmupServer } from './tools/server-warmup.js';
 import { createServerContext } from './context/server.js';
 import { createProviderContext } from './context/provider.js';
+import { requestProcessorMiddleware } from './middleware/request-processor-middleware.js';
 import { localeMiddleware } from './middleware/locale-middleware.js';
 import { moduleMiddleware } from './middleware/module-middleware.js';
 import { bundleMiddleware } from './middleware/bundle-middleware.js';
@@ -17,6 +18,8 @@ import { resourceMiddleware } from './middleware/resource-middleware.js';
 import { hmrMiddleware } from './middleware/hmr-middleware.js';
 import { getTracer, CoreSpan } from '@lwrjs/instrumentation';
 function initMiddleware(app, server, serverContext) {
+    // TODO if we knew the target here we could make this middleware optional to target=mrt
+    requestProcessorMiddleware(app, serverContext);
     localeMiddleware(app, serverContext);
     moduleMiddleware(app, serverContext);
     bundleMiddleware(app, serverContext);

package/build/es/middleware/asset-middleware.js

@@ -1,7 +1,8 @@
 import path from 'path';
+import { DiagnosticsError } from '@lwrjs/diagnostics';
+import { RequestHandlerSpan, getTracer } from '@lwrjs/instrumentation';
 import { getAssetIdentity } from './utils/identity.js';
 import { handleErrors } from './utils/error-handling.js';
-import { DiagnosticsError } from '@lwrjs/diagnostics';
 function createAssetMiddleware(context) {
     const { assetRegistry, runtimeEnvironment: { basePath }, } = context;
     return async (req, res, next) => {
@@ -21,7 +22,14 @@ function createAssetMiddleware(context) {
                 res.sendStatus(302);
                 return;
             }
-            const asset = await assetRegistry.getAsset({ ...assetId, signature }, runtimeEnvironment, req.isSiteGeneration());
+            const asset = await getTracer().trace({
+                name: RequestHandlerSpan.GetAsset,
+                attributes: {
+                    specifier: assetId.specifier,
+                },
+            }, () => {
+                return assetRegistry.getAsset({ ...assetId, signature }, runtimeEnvironment, req.isSiteGeneration());
+            });
             if (req.isSiteGeneration()) {
                 res.setSiteGenerationMetadata({ asset });
             }

package/build/es/middleware/bundle-middleware.js

@@ -1,15 +1,16 @@
 import { LATEST_SIGNATURE } from '@lwrjs/shared-utils';
 import { descriptions } from '@lwrjs/diagnostics';
+import { RequestHandlerSpan, getTracer } from '@lwrjs/instrumentation';
 import { getRequestImporter } from './utils/request.js';
 import { getModuleIdentity } from './utils/identity.js';
 import { normalizeResolvedUris } from './utils/metadata.js';
 import { createUnsignedBundleRedirect } from './redirects/unsigned-module-redirect.js';
 import { handleErrors } from './utils/error-handling.js';
 function createBundleMiddleware(context) {
-    const { moduleRegistry, moduleBundler } = context;
+    const { appConfig, moduleRegistry, moduleBundler, runtimeEnvironment: defaultRuntimeEnvironment, } = context;
     const unsignedBundleRedirect = createUnsignedBundleRedirect(moduleBundler);
     return async (req, res) => {
-        if (!req.validateEnvironmentRequest(context.appConfig)) {
+        if (!req.validateEnvironmentRequest(appConfig)) {
             res.status(400);
             res.send(descriptions.UNRESOLVABLE.INVALID_ENVIRONMENT(req.params.environment).message);
             return;
@@ -19,7 +20,7 @@ function createBundleMiddleware(context) {
             res.send(descriptions.UNRESOLVABLE.INVALID_JSON().message);
             return;
         }
-        const { runtimeEnvironment, runtimeParams } = req.getRuntimeContext(context.runtimeEnvironment);
+        const { runtimeEnvironment, runtimeParams } = req.getRuntimeContext(defaultRuntimeEnvironment);
         const importer = req.query.importer
             ? await getRequestImporter(req, moduleRegistry, runtimeParams)
             : undefined;
@@ -29,9 +30,16 @@ function createBundleMiddleware(context) {
             return;
         }
         const sourceMapUrl = req.path.replace('/bundle/', '/sourcemaps/bundle/');
-        const bundleDefinition = await moduleBundler.getModuleBundle(moduleId, 
-        // bundle must be `true` to properly resolve bundles in amd
-        { ...runtimeEnvironment, bundle: true, sourceMapUrl }, runtimeParams);
+        const bundleDefinition = await getTracer().trace({
+            name: RequestHandlerSpan.GetBundle,
+            attributes: {
+                specifier: moduleId.specifier,
+            },
+        }, () => {
+            return moduleBundler.getModuleBundle(moduleId, 
+            // bundle must be `true` to properly resolve bundles in amd
+            { ...runtimeEnvironment, bundle: true, sourceMapUrl }, runtimeParams);
+        });
         if (req.isSiteGeneration()) {
             res.setSiteGenerationMetadata({
                 moduleDefinition: bundleDefinition,
@@ -45,14 +53,14 @@ function createBundleMiddleware(context) {
     };
 }
 function createSourceMapMiddleware(context) {
-    const { moduleBundler } = context;
+    const { appConfig, moduleBundler, runtimeEnvironment: defaultRuntimeEnvironment } = context;
     return async (req, res) => {
-        if (!req.validateEnvironmentRequest(context.appConfig)) {
+        if (!req.validateEnvironmentRequest(appConfig)) {
             res.status(400);
             res.send(descriptions.UNRESOLVABLE.INVALID_ENVIRONMENT(req.params.environment).message);
             return;
         }
-        const { runtimeEnvironment } = req.getRuntimeContext(context.runtimeEnvironment);
+        const { runtimeEnvironment } = req.getRuntimeContext(defaultRuntimeEnvironment);
         const { moduleId, signature } = getModuleIdentity(req);
         const bundleDef = await moduleBundler.getModuleBundle(moduleId, runtimeEnvironment);
         if (signature !== LATEST_SIGNATURE) {

package/build/es/middleware/hmr-middleware.js

@@ -1,4 +1,5 @@
 import { WebSocketServer } from 'ws';
+import { logger } from '@lwrjs/diagnostics';
 import { getCacheKeyFromJson } from '@lwrjs/shared-utils';
 import { getRequestProperties } from './utils/request.js';
 let hmr;
@@ -33,10 +34,10 @@ class Hmr {
         });
         wss.on('error', (error) => {
             if (error.code === 'EADDRINUSE') {
-                console.error(`HMR Socket Server: Port ${this.context.appConfig.port} already in use.`);
+                logger.error(`HMR Socket Server: Port ${this.context.appConfig.port} already in use.`);
             }
             else {
-                console.error(error);
+                logger.error(error);
             }
         });
     }
@@ -44,7 +45,7 @@ class Hmr {
         const { moduleRegistry } = this;
         const { specifier, namespace, name, version, ownHash: signature, runtimeEnvironment, runtimeParams, } = moduleDefinition;
         const { format, debug, compat } = runtimeEnvironment;
-        console.log('Recompiled module:', specifier, signature);
+        logger.info(`Recompiled module: ${specifier}, ${signature}`);
         const moduleId = {
             specifier,
             namespace,
@@ -72,7 +73,7 @@ class Hmr {
         }
     }
     updateTemplateOnClients(compiledView) {
-        console.log('Recompiled view source:', compiledView.viewId);
+        logger.info('Recompiled view source', compiledView.viewId);
         const { contentTemplate } = compiledView.viewId;
         if (this.connectedClients && contentTemplate) {
             for (const ws of this.connectedClients.keys()) {
@@ -87,7 +88,7 @@ class Hmr {
     }
     updateAssetOnClients(asset) {
         const assetId = asset.entry;
-        console.log('Updated asset:', assetId);
+        logger.info(`Updated asset: ${assetId}`);
         if (this.connectedClients) {
             for (const ws of this.connectedClients.keys()) {
                 ws.send(JSON.stringify({

package/build/es/middleware/locale-middleware.js

@@ -1,5 +1,5 @@
 export function localeMiddleware(app, context) {
-    const { defaultLocale } = context.runtimeEnvironment;
+    const { i18n: { defaultLocale }, } = context.runtimeEnvironment;
     app.use(async (req, _res, next) => {
         const langs = req.acceptsLanguages();
         req.locale = langs?.length > 0 && langs[0] != '*' ? langs[0] : defaultLocale;

package/build/es/middleware/mapping-middleware.js

@@ -1,18 +1,23 @@
 import { getImportMetadataMappings } from '@lwrjs/shared-utils';
 import { descriptions } from '@lwrjs/diagnostics';
+import { RequestHandlerSpan, getTracer } from '@lwrjs/instrumentation';
 import { getMappingIdentity } from './utils/identity.js';
 import { handleErrors } from './utils/error-handling.js';
 function createMappingMiddleware(context) {
-    const { moduleBundler, moduleRegistry } = context;
+    const { appConfig, moduleBundler, moduleRegistry, runtimeEnvironment: defaultRuntimeEnvironment, } = context;
     return async (req, res) => {
-        if (!req.validateEnvironmentRequest(context.appConfig)) {
+        if (!req.validateEnvironmentRequest(appConfig)) {
             res.status(400);
             res.send(descriptions.UNRESOLVABLE.INVALID_ENVIRONMENT(req.params.environment).message);
             return;
         }
-        const { runtimeEnvironment, runtimeParams } = req.getRuntimeContext(context.runtimeEnvironment);
+        const { runtimeEnvironment, runtimeParams } = req.getRuntimeContext(defaultRuntimeEnvironment);
         const { moduleIds } = getMappingIdentity(req);
-        const importMetadata = await getImportMetadataMappings(moduleIds, runtimeEnvironment, runtimeParams, moduleRegistry, moduleBundler);
+        const importMetadata = await getTracer().trace({
+            name: RequestHandlerSpan.GetMapping,
+        }, () => {
+            return getImportMetadataMappings(moduleIds, runtimeEnvironment, runtimeParams, moduleRegistry, moduleBundler);
+        });
         if (req.isSiteGeneration()) {
             res.setSiteGenerationMetadata({ importMetadata });
         }

package/build/es/middleware/module-middleware.js

@@ -1,14 +1,15 @@
 import { descriptions } from '@lwrjs/diagnostics';
 import { LATEST_SIGNATURE, serializeModuleToJson } from '@lwrjs/shared-utils';
+import { RequestHandlerSpan, getTracer } from '@lwrjs/instrumentation';
 import { getRequestImporter } from './utils/request.js';
 import { getModuleIdentity } from './utils/identity.js';
 import { createUnsignedModuleRedirect } from './redirects/unsigned-module-redirect.js';
 import { handleErrors } from './utils/error-handling.js';
 function createModuleMiddleware(context) {
-    const { moduleRegistry } = context;
+    const { appConfig, moduleRegistry, runtimeEnvironment: defaultRuntimeEnvironment } = context;
     const unsignedRedirect = createUnsignedModuleRedirect(moduleRegistry);
     return async (req, res) => {
-        if (!req.validateEnvironmentRequest(context.appConfig)) {
+        if (!req.validateEnvironmentRequest(appConfig)) {
             res.status(400);
             res.send(descriptions.UNRESOLVABLE.INVALID_ENVIRONMENT(req.params.environment).message);
             return;
@@ -18,7 +19,7 @@ function createModuleMiddleware(context) {
             res.send(descriptions.UNRESOLVABLE.INVALID_JSON().message);
             return;
         }
-        const { runtimeEnvironment, runtimeParams } = req.getRuntimeContext(context.runtimeEnvironment);
+        const { runtimeEnvironment, runtimeParams } = req.getRuntimeContext(defaultRuntimeEnvironment);
         const importer = req.query.importer
             ? await getRequestImporter(req, moduleRegistry, runtimeParams)
             : undefined;
@@ -27,9 +28,16 @@ function createModuleMiddleware(context) {
             await unsignedRedirect(req, res, moduleId, runtimeEnvironment, runtimeParams);
             return;
         }
-        const moduleDefinition = await moduleRegistry.getLinkedModule(moduleId, 
-        // bundle must be `false` to resolve amd modules in `prod-compat` mode
-        { ...runtimeEnvironment, bundle: false }, runtimeParams);
+        const moduleDefinition = await getTracer().trace({
+            name: RequestHandlerSpan.GetModule,
+            attributes: {
+                specifier: moduleId.specifier,
+            },
+        }, () => {
+            return moduleRegistry.getLinkedModule(moduleId, 
+            // bundle must be `false` to resolve amd modules in `prod-compat` mode
+            { ...runtimeEnvironment, bundle: false }, runtimeParams);
+        });
         const { ownHash, linkedSource } = moduleDefinition;
         // validate the requested instances exists
         if (signature !== LATEST_SIGNATURE && ownHash !== signature) {