@lwrjs/core 0.9.0-alpha.9 → 0.9.0

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

@@ -37,55 +37,60 @@ 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("[Static Generation] starting");
+    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])});
     }
     const {routes, staticSiteGenerator, rootDir, assets} = config;
     if (!staticSiteGenerator.outputDir) {
-      staticSiteGenerator.outputDir = "__generated_site__";
+      staticSiteGenerator.outputDir = "site";
     }
     const outputDir = (0, import_path.join)(rootDir, staticSiteGenerator.outputDir);
-    import_shared_utils.logger.info(`Clear Output Location: ${outputDir}`);
-    import_fs_extra.default.rmSync(outputDir, {recursive: true, force: true});
+    if (!staticSiteGenerator.skipCleanOutputDir) {
+      import_shared_utils.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}`);
+    }
     const urlRewriteMap = new Map();
-    const {apiVersion, basePath, lwrVersion, serverMode} = config;
-    const runtimeEnvironment = {
-      ...(0, import_config.explodeMode)(serverMode),
-      apiVersion,
-      basePath,
-      lwrVersion,
-      debug: false,
-      serverMode
-    };
+    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)`);
     await this.generateRoutes(runtimeEnvironment, staticSiteGenerator, routes, basePath, dispatcher, outputDir, urlRewriteMap);
     this.writeNetlifyRedirectConfig(outputDir, urlRewriteMap);
-    this.copyAssets(assets, outputDir, basePath);
+    await this.copyAssets(assets, outputDir, config);
     const endTime = import_perf_hooks.performance.now();
     const timeDiff = (endTime - startTime) / 1e3;
-    import_shared_utils.logger.info(`[Static Generation] complete in ${Math.round(timeDiff)} seconds`);
+    import_shared_utils.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, runtimeEnvironment);
+        const siteConfig = this.createSiteConfig(outputDir, locale, urlRewriteMap, skipBaseDocumentGeneration, runtimeEnvironment);
         await generateUrl(basePath + route.path, siteConfig);
       }
       if (staticSiteGenerator._additionalRoutePaths) {
         for (const uri of staticSiteGenerator._additionalRoutePaths) {
-          const siteConfig = this.createSiteConfig(outputDir, locale, urlRewriteMap, runtimeEnvironment);
+          const siteConfig = this.createSiteConfig(outputDir, locale, urlRewriteMap, skipBaseDocumentGeneration, runtimeEnvironment);
           await generateUrl(uri, siteConfig);
         }
       }
       const {_additionalModules} = staticSiteGenerator;
       if (_additionalModules) {
         for (const specifier of _additionalModules) {
-          const siteConfig = this.createSiteConfig(outputDir, locale, urlRewriteMap, runtimeEnvironment);
+          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`);
         }
       }
     }
@@ -93,10 +98,13 @@ var SiteGenerator = class {
   createGenerateURLFunction(dispatcher) {
     const generateRoute = async (uri, siteConfig) => {
       const locale = siteConfig.locale;
-      import_shared_utils.logger.info(`Start Generate: ${locale} ${uri}`);
+      import_shared_utils.logger.debug(`[SSG] Start Generate: ${locale} ${uri}`);
+      const startTime = import_perf_hooks.performance.now();
       await this.dispatchResourceRecursive(uri, dispatcher, {resourceType: "route"}, siteConfig);
-      this.addAdditionalImportMetadataToViewConfig(siteConfig);
-      import_shared_utils.logger.info(`End Generate ${locale} ${uri}`);
+      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`);
     };
     return generateRoute.bind(this);
   }
@@ -104,8 +112,12 @@ var SiteGenerator = class {
     const {visitedUrls} = siteConfig;
     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);
+        return;
+      }
       if (url.indexOf("/:") !== -1 || url.indexOf("*") !== -1) {
-        import_shared_utils.logger.warn("Skipped generation of url with variable path segment: " + url);
+        import_shared_utils.logger.warn("[SSG] Skipped generation of url with variable path segment: " + url);
         return;
       }
       let context;
@@ -154,6 +166,9 @@ var SiteGenerator = class {
         const jsUri = importModule.specifier.startsWith("/") ? importModule.specifier : (0, import_shared_utils.getSpecifier)(importModule);
         dispatchRequests.push(this.dispatchJSResourceRecursive(jsUri, dispatcher, siteConfig));
       }
+      if (moduleDefinition.bundleRecord) {
+        this.addBundleToSiteMetadata(moduleDefinition, url, siteConfig);
+      }
     }
     const uris = context.fs?.metadata?.resolvedUris || [];
     for (const jsUri of uris) {
@@ -161,16 +176,64 @@ var SiteGenerator = class {
     }
     await Promise.all(dispatchRequests);
   }
+  addBundleToSiteMetadata(bundleDefinition, url, siteConfig) {
+    if (siteConfig.siteMetadata) {
+      const specifier = bundleDefinition.specifier;
+      const imports = bundleDefinition.bundleRecord.imports?.map((moduleRef) => (0, import_shared_utils.getSpecifier)(moduleRef)) || [];
+      const bundleMetadata = {
+        version: bundleDefinition.version,
+        path: decodeURIComponent(url),
+        includedModules: bundleDefinition.bundleRecord.includedModules || [],
+        imports
+      };
+      const siteBundles = siteConfig.siteMetadata.getSiteBundles().bundles;
+      siteBundles[specifier] = bundleMetadata;
+    }
+  }
+  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);
+      } else {
+        const specifier = resourceDefinition.specifier;
+        const resourceMetadata = {
+          path: decodeURIComponent(url),
+          mimeType: resourceDefinition.type
+        };
+        const siteResources = siteConfig.siteMetadata.getSiteResources();
+        siteResources.resources[specifier] = resourceMetadata;
+      }
+    }
+  }
+  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);
+      } else {
+        const specifier = assetDefinition.uri;
+        const resourceMetadata = {
+          path: decodeURIComponent(url),
+          mimeType: String(assetDefinition.mime)
+        };
+        const siteAssets = siteConfig.siteMetadata.getSiteAssets();
+        if (!siteAssets.assets[specifier]) {
+          siteAssets.assets[specifier] = resourceMetadata;
+        } else {
+          import_shared_utils.logger.debug(`[SSG] Ignore asset redefinition ${specifier}`);
+        }
+      }
+    }
+  }
   async handleMappingResource(url, context, siteConfig, dispatcher) {
-    const {importMetadata: importMetatdata} = siteConfig;
+    const {importMetadata} = siteConfig;
     const statusCode = context.response?.status;
     if (statusCode === 200) {
       const newImportMetadata = context.fs?.body;
       let filteredImportMetadata;
-      if (!importMetatdata) {
+      if (!importMetadata) {
         filteredImportMetadata = newImportMetadata;
       } else {
-        filteredImportMetadata = importMetatdata.addAdditionalMetadata(newImportMetadata);
+        filteredImportMetadata = importMetadata.addAdditionalMetadata(newImportMetadata);
       }
       const dispatchRequests = [];
       for (const uri of Object.keys(filteredImportMetadata.imports)) {
@@ -179,29 +242,31 @@ var SiteGenerator = class {
       await Promise.all(dispatchRequests);
     } else {
       const body = context.fs?.body;
-      import_shared_utils.logger.warn(`Failed to fetch ${url}: (${statusCode}) ${body}`);
+      import_shared_utils.logger.warn(`[SSG] Failed to fetch ${url}: (${statusCode}) ${body}`);
     }
   }
   async handleHtmlResource(url, context, siteConfig, dispatcher) {
-    const {outputDir} = siteConfig;
-    let fileName = "index.html";
-    let directoryPath = url;
-    if (url.endsWith(".html") || url.endsWith(".xml")) {
-      const lastPathIndex = url.lastIndexOf("/") + 1;
-      fileName = url.substring(lastPathIndex, url.length);
-      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);
+    const {outputDir, skipBaseDocumentGeneration} = siteConfig;
+    if (!skipBaseDocumentGeneration) {
+      let fileName = "index.html";
+      let directoryPath = url;
+      if (url.endsWith(".html") || url.endsWith(".xml")) {
+        const lastPathIndex = url.lastIndexOf("/") + 1;
+        fileName = url.substring(lastPathIndex, url.length);
+        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);
     }
-    (0, import_dir.createDir)(localeDir);
-    siteConfig.viewPaths.add(fileLocalePath);
-    await (0, import_stream.writeResponse)(context, fileLocalePath);
     const viewDefinition = context.fs?.metadata?.viewDefinition;
     if (viewDefinition) {
       await this.handleViewDefinition(viewDefinition, siteConfig, dispatcher);
@@ -243,7 +308,7 @@ var SiteGenerator = class {
             siteConfig.viewConfigPath = this.getResourcePathFromUrl(siteConfig, resourceUri);
           }
         } else {
-          import_shared_utils.logger.warn("Skipped inline bootstrap resource: %j", resource);
+          import_shared_utils.logger.warn("[SSG] Skipped inline bootstrap resource: %j", resource);
         }
       }
     }
@@ -253,7 +318,7 @@ var SiteGenerator = class {
       if (resourceUri.startsWith("/")) {
         dispatchRequests.push(this.dispatchResourceRecursive(resourceUri, dispatcher, {resourceType: "resource"}, siteConfig));
       } else {
-        import_shared_utils.logger.warn("Skipped resource: %j", resource);
+        import_shared_utils.logger.warn("[SSG] Skipped resource: %j", resource);
       }
     }
     await Promise.all(dispatchRequests);
@@ -269,7 +334,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('Unable to fetch mapping for bare specifier or variable dynamic import: "' + jsUri + '"');
+          import_shared_utils.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)}`;
@@ -281,12 +346,17 @@ var SiteGenerator = class {
     const metadata = context.fs?.metadata;
     const fullPath = this.getResourcePathFromUrl(siteConfig, url);
     await (0, import_stream.writeResponse)(context, fullPath);
+    if (metadata?.resource) {
+      this.addResourceToSiteMetadata(metadata?.resource, url, siteConfig);
+    } else if (metadata?.asset) {
+      this.addAssetToSiteMetadata(metadata?.asset, url, siteConfig);
+    }
     const assetReferences = metadata?.asset?.metadata?.assetReferences || [];
     const dispatchRequests = [];
     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(`Failed to fetch asset reference => ${refUrl} from ${url}`, err);
+        import_shared_utils.logger.warn(`[SSG] Failed to fetch asset reference => ${refUrl} from ${url}`, err);
       }));
     }
     return Promise.all(dispatchRequests);
@@ -315,22 +385,67 @@ var SiteGenerator = class {
     });
     import_fs_extra.default.writeFileSync(serveJsonPath, JSON.stringify({rewrites, directoryListing: false, renderSingle: true}, null, 1));
   }
-  copyAssets(assets, outputDir, basePath) {
+  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);
     for (const asset of assets) {
       try {
-        const assetSrcDir = asset.dir || asset.file;
-        const assetOutputDir = (0, import_path.join)(outputDir, basePath ? basePath + asset.urlPath : asset.urlPath);
+        const assetSrcFile = asset.file;
+        const assetSrcDir = asset.dir;
+        const assetsPath = (0, import_path.join)(outputDir, basePath ? basePath + asset.urlPath : asset.urlPath);
         if (assetSrcDir && import_fs_extra.default.existsSync(assetSrcDir)) {
-          import_fs_extra.default.copySync(assetSrcDir, assetOutputDir);
+          import_fs_extra.default.copySync(assetSrcDir, assetsPath);
+          this.addAssetsToMetadata(assetsPath, siteConfig);
+        } else if (assetSrcFile && import_fs_extra.default.existsSync(assetSrcFile)) {
+          import_fs_extra.default.copySync(assetSrcFile, assetsPath);
+          this.addAssetToMetadata(assetsPath, siteConfig);
         } else {
-          import_shared_utils.logger.warn("Could not find assets to copy at path: " + assetSrcDir);
+          import_shared_utils.logger.warn("[SSG] Could not find assets to copy at path: " + assetsPath);
         }
       } catch (e) {
-        import_shared_utils.logger.error("Error occurred processing asset config: " + JSON.stringify(asset), e);
+        import_shared_utils.logger.error("[SSG] Error occurred processing asset config: " + JSON.stringify(asset), e);
+      }
+    }
+    await siteConfig.siteMetadata?.persistSiteMetadata();
+  }
+  addAssetsToMetadata(directoryPath, siteConfig) {
+    try {
+      const files = import_fs_extra.default.readdirSync(directoryPath);
+      for (const file of files) {
+        const filePath = (0, import_path.join)(directoryPath, file);
+        if (import_fs_extra.default.statSync(filePath).isDirectory()) {
+          this.addAssetsToMetadata(filePath, siteConfig);
+        } else {
+          this.addAssetToMetadata(filePath, siteConfig);
+        }
       }
+    } catch (err) {
+      import_shared_utils.logger.warn(`[SSG] Unexpected error collecting asset directory metadata for ${directoryPath}`, err);
+    }
+  }
+  addAssetToMetadata(filePath, siteConfig) {
+    try {
+      const uri = encodeURI((0, import_path.normalize)(filePath).replace(siteConfig.outputDir, ""));
+      this.addAssetToSiteMetadata({
+        uri,
+        type: "asset",
+        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) {
+          throw new Error("Function not implemented.");
+        }
+      }, uri, siteConfig);
+    } catch (err) {
+      import_shared_utils.logger.warn(`[SSG] Unexpected error collecting asset metadata for ${filePath}`, err);
     }
   }
-  createSiteConfig(outputDir, locale, urlRewriteMap, runtimeEnvironment) {
+  createSiteConfig(outputDir, locale, urlRewriteMap, skipBaseDocumentGeneration, runtimeEnvironment) {
     const featureFlags = this.filterFeatureFlags();
     const endpoints = {
       uris: {
@@ -345,12 +460,21 @@ var SiteGenerator = class {
       locale,
       urlRewriteMap,
       endpoints,
-      ...featureFlags
+      skipBaseDocumentGeneration,
+      ...featureFlags,
+      siteMetadata: new import_shared_utils.SiteMetadataImpl({rootDir: outputDir})
     };
   }
   filterFeatureFlags() {
-    if ((0, import_shared_utils.getFeatureFlags)().LEGACY_LOADER) {
-      return {featureFlags: {LEGACY_LOADER: true}};
+    const ffs = (0, import_shared_utils.getFeatureFlags)();
+    if (ffs && Object.keys(ffs).length) {
+      const accumulator = {};
+      for (const [key, value] of Object.entries(ffs)) {
+        if (value) {
+          accumulator[key] = true;
+        }
+      }
+      return {featureFlags: accumulator};
     } else {
       return void 0;
     }
@@ -387,6 +511,10 @@ ${mergeIndex}
       });
     }
   }
+  async captureAdditionalRouteMetadata(siteConfig) {
+    this.addAdditionalImportMetadataToViewConfig(siteConfig);
+    await siteConfig.siteMetadata?.persistSiteMetadata();
+  }
 };
 var static_generation_default = SiteGenerator;
 var ViewImportMetadataImpl = class {
@@ -414,10 +542,10 @@ var ViewImportMetadataImpl = class {
       index
     };
   }
-  mergeImportMetadata(targetImportMetdadata, newImportMetadata) {
-    Object.assign(targetImportMetdadata.imports, newImportMetadata.imports);
-    if (targetImportMetdadata.index) {
-      Object.assign(targetImportMetdadata.index, newImportMetadata.index || {});
+  mergeImportMetadata(targetImportMetadata, newImportMetadata) {
+    Object.assign(targetImportMetadata.imports, newImportMetadata.imports);
+    if (targetImportMetadata.index) {
+      Object.assign(targetImportMetadata.index, newImportMetadata.index || {});
     }
   }
 };

package/build/es/context/provider.js

@@ -1,11 +1,10 @@
 import { deepFreeze } from '@lwrjs/shared-utils';
 export function createProviderContext(serverContext) {
     // This is a subset of config to user-land code
-    const { cacheDir, lwc: { modules = [] }, routes, errorRoutes, rootDir, contentDir, layoutsDir, locker, amdLoader, esmLoader, environment, basePath, } = serverContext.appConfig;
+    const { assets, cacheDir, lwc: { modules = [] }, routes, errorRoutes, rootDir, contentDir, layoutsDir, locker, amdLoader, esmLoader, environment, basePath, bundleConfig, } = serverContext.appConfig;
     const { onModuleDefinitionChange, onModuleSourceChange } = serverContext.appObserver;
     const { notifyModuleDefinitionChanged, notifyModuleSourceChanged, notifyViewSourceChanged, notifyAssetSourceChanged, } = serverContext.appEmitter;
     return {
-        compiler: serverContext.compiler,
         appObserver: deepFreeze({ onModuleDefinitionChange, onModuleSourceChange }),
         appEmitter: {
             notifyModuleDefinitionChanged: (payload) => notifyModuleDefinitionChanged.call(serverContext.appEmitter, payload),
@@ -14,11 +13,12 @@ export function createProviderContext(serverContext) {
             notifyAssetSourceChanged: (payload) => notifyAssetSourceChanged.call(serverContext.appEmitter, payload),
         },
         moduleRegistry: serverContext.moduleRegistry.getPublicApi(),
-        moduleBundler: serverContext.moduleBundler,
+        moduleBundler: serverContext.moduleBundler.getPublicApi(),
         resourceRegistry: serverContext.resourceRegistry.getPublicApi(),
         viewRegistry: serverContext.viewRegistry.getPublicApi(),
         assetRegistry: serverContext.assetRegistry.getPublicApi(),
         config: deepFreeze({
+            assets,
             cacheDir,
             modules,
             routes,
@@ -31,8 +31,10 @@ export function createProviderContext(serverContext) {
             amdLoader,
             esmLoader,
             environment,
+            bundleConfig,
         }),
         runtimeEnvironment: deepFreeze(serverContext.runtimeEnvironment),
+        watcherFactory: serverContext.watcherFactory,
     };
 }
 //# sourceMappingURL=provider.js.map

package/build/es/context/server.d.ts

@@ -1,3 +1,3 @@
-import { GlobalData, NormalizedLwrGlobalConfig, RuntimeEnvironment, ServerContext } from '@lwrjs/types';
+import type { GlobalData, NormalizedLwrGlobalConfig, RuntimeEnvironment, ServerContext } from '@lwrjs/types';
 export declare function createServerContext(appConfig: NormalizedLwrGlobalConfig, runtimeEnvironment: RuntimeEnvironment, globalData: GlobalData): ServerContext;
 //# sourceMappingURL=server.d.ts.map

package/build/es/context/server.js

@@ -1,26 +1,25 @@
 import { LwrAssetRegistry } from '@lwrjs/asset-registry';
-import { LwrCompiler } from '@lwrjs/compiler';
 import { LwrModuleBundler } from '@lwrjs/module-bundler';
 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';
 export function createServerContext(appConfig, runtimeEnvironment, globalData) {
     const appObserver = new LwrApplicationObserver();
     const appEmitter = appObserver.createLwrEmitter();
-    const compiler = new LwrCompiler();
     const assetRegistry = new LwrAssetRegistry({
         appObserver,
         appEmitter,
         runtimeEnvironment,
     }, appConfig);
     const moduleRegistry = new LwrModuleRegistry({
-        compiler,
         appObserver,
         appEmitter,
         runtimeEnvironment,
     }, appConfig);
-    const moduleBundler = new LwrModuleBundler({ compiler, moduleRegistry, appObserver }, appConfig);
+    const moduleBundler = new LwrModuleBundler({ moduleRegistry, appObserver }, appConfig);
     const resourceRegistry = new LwrResourceRegistry();
     const viewRegistry = new LwrViewRegistry({
         moduleRegistry,
@@ -32,8 +31,8 @@ export function createServerContext(appConfig, runtimeEnvironment, globalData) {
         globalData,
         runtimeEnvironment,
     }, appConfig);
+    const watcherFactory = new WatcherFactoryImpl();
     return {
-        compiler,
         appObserver,
         appEmitter,
         moduleRegistry,
@@ -41,8 +40,10 @@ export function createServerContext(appConfig, runtimeEnvironment, globalData) {
         resourceRegistry,
         assetRegistry,
         viewRegistry,
+        watcherFactory,
         appConfig,
         runtimeEnvironment,
+        routeHandlers: {},
     };
 }
 //# sourceMappingURL=server.js.map

package/build/es/index.d.ts

@@ -1,9 +1,11 @@
-import { LwrGlobalConfig, NormalizedLwrGlobalConfig, ServerTypeImpl, PublicAppServer, ServerTypes } from '@lwrjs/types';
+import type { LwrGlobalConfig, NormalizedLwrGlobalConfig, ServerTypeImpl, PublicAppServer, ServerTypes } from '@lwrjs/types';
 export declare class LwrApp {
     private app;
     private server;
     private initialized;
     private config;
+    private runtimeEnvironment;
+    private globalData;
     constructor(config?: LwrGlobalConfig);
     setConfig(config: LwrGlobalConfig): void;
     getConfig(): NormalizedLwrGlobalConfig;
@@ -21,5 +23,4 @@ export declare class LwrApp {
 }
 export declare function createServer(config?: LwrGlobalConfig): LwrApp;
 export declare function generateStaticSite(config?: LwrGlobalConfig): Promise<NormalizedLwrGlobalConfig>;
-export { buildServer } from './tools/server-build.js';
 //# sourceMappingURL=index.d.ts.map