@lwrjs/core 0.9.0-alpha.2 → 0.9.0-alpha.21

package/build/cjs/middleware.cjs

@@ -0,0 +1,43 @@
+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/core/src/middleware.ts
+__markAsModule(exports);
+__export(exports, {
+  assetMiddleware: () => import_asset_middleware.assetMiddleware,
+  bundleMiddleware: () => import_bundle_middleware.bundleMiddleware,
+  hmrMiddleware: () => import_hmr_middleware.hmrMiddleware,
+  localeMiddleware: () => import_locale_middleware.localeMiddleware,
+  mappingMiddleware: () => import_mapping_middleware.mappingMiddleware,
+  moduleMiddleware: () => import_module_middleware.moduleMiddleware,
+  resourceMiddleware: () => import_resource_middleware.resourceMiddleware,
+  viewMiddleware: () => import_view_middleware.viewMiddleware
+});
+var import_locale_middleware = __toModule(require("./middleware/locale-middleware.cjs"));
+var import_hmr_middleware = __toModule(require("./middleware/hmr-middleware.cjs"));
+var import_module_middleware = __toModule(require("./middleware/module-middleware.cjs"));
+var import_bundle_middleware = __toModule(require("./middleware/bundle-middleware.cjs"));
+var import_mapping_middleware = __toModule(require("./middleware/mapping-middleware.cjs"));
+var import_asset_middleware = __toModule(require("./middleware/asset-middleware.cjs"));
+var import_view_middleware = __toModule(require("./middleware/view-middleware.cjs"));
+var import_resource_middleware = __toModule(require("./middleware/resource-middleware.cjs"));

package/build/cjs/tools/server-warmup.cjs

@@ -36,17 +36,10 @@ async function warmupServer(config, internalRequestKey) {
     import_shared_utils.logger.setOptions({dedupe: new Set([import_shared_utils.WARN])});
   }
   import_shared_utils.logger.info("[Server Warmup] starting");
-  const {routes, staticSiteGenerator, port, apiVersion, basePath, lwrVersion, serverMode} = config;
+  const {routes, staticSiteGenerator, port, basePath} = config;
   staticSiteGenerator.outputDir = import_dir.skipDirCreation;
   const urlRewriteMap = new Map();
-  const runtimeEnvironment = {
-    ...(0, import_config.explodeMode)(serverMode),
-    apiVersion,
-    basePath,
-    lwrVersion,
-    debug: false,
-    serverMode
-  };
+  const runtimeEnvironment = (0, import_config.getRuntimeEnvironment)(config);
   await new import_static_generation.default().generateRoutes(runtimeEnvironment, staticSiteGenerator, routes, basePath, new import_network_dispatcher.default(port, internalRequestKey), staticSiteGenerator.outputDir, urlRewriteMap);
   import_shared_utils.logger.info("[Server Warmup] complete");
 }

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

@@ -37,7 +37,7 @@ 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])});
     }
@@ -46,46 +46,50 @@ var SiteGenerator = class {
       staticSiteGenerator.outputDir = "__generated_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 {
+      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);
     await this.generateRoutes(runtimeEnvironment, staticSiteGenerator, routes, basePath, dispatcher, outputDir, urlRewriteMap);
     this.writeNetlifyRedirectConfig(outputDir, urlRewriteMap);
     this.copyAssets(assets, outputDir, basePath);
     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 +97,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 +111,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 +165,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,6 +175,50 @@ 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) => moduleRef.specifier) || [];
+      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();
+        siteAssets.assets[specifier] = resourceMetadata;
+      }
+    }
+  }
   async handleMappingResource(url, context, siteConfig, dispatcher) {
     const {importMetadata: importMetatdata} = siteConfig;
     const statusCode = context.response?.status;
@@ -179,29 +237,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 +303,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 +313,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 +329,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 +341,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);
@@ -323,14 +388,14 @@ var SiteGenerator = class {
         if (assetSrcDir && import_fs_extra.default.existsSync(assetSrcDir)) {
           import_fs_extra.default.copySync(assetSrcDir, assetOutputDir);
         } 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: " + assetSrcDir);
         }
       } 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);
       }
     }
   }
-  createSiteConfig(outputDir, locale, urlRewriteMap, runtimeEnvironment) {
+  createSiteConfig(outputDir, locale, urlRewriteMap, skipBaseDocumentGeneration, runtimeEnvironment) {
     const featureFlags = this.filterFeatureFlags();
     const endpoints = {
       uris: {
@@ -345,12 +410,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 accumlator = {};
+      for (const [key, value] of Object.entries(ffs)) {
+        if (value) {
+          accumlator[key] = true;
+        }
+      }
+      return {featureFlags: accumlator};
     } else {
       return void 0;
     }
@@ -387,6 +461,10 @@ ${mergeIndex}
       });
     }
   }
+  async captureAdditionalRouteMetadata(siteConfig) {
+    this.addAdditionalImportMetadataToViewConfig(siteConfig);
+    await siteConfig.siteMetadata?.persistSiteMetadata();
+  }
 };
 var static_generation_default = SiteGenerator;
 var ViewImportMetadataImpl = class {

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

@@ -0,0 +1,3 @@
+import { ProviderContext, ServerContext } from '@lwrjs/types';
+export declare function createProviderContext(serverContext: ServerContext): ProviderContext;
+//# sourceMappingURL=provider.d.ts.map

package/build/es/context/provider.js

@@ -0,0 +1,39 @@
+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, bundleConfig, } = serverContext.appConfig;
+    const { onModuleDefinitionChange, onModuleSourceChange } = serverContext.appObserver;
+    const { notifyModuleDefinitionChanged, notifyModuleSourceChanged, notifyViewSourceChanged, notifyAssetSourceChanged, } = serverContext.appEmitter;
+    return {
+        appObserver: deepFreeze({ onModuleDefinitionChange, onModuleSourceChange }),
+        appEmitter: {
+            notifyModuleDefinitionChanged: (payload) => notifyModuleDefinitionChanged.call(serverContext.appEmitter, payload),
+            notifyModuleSourceChanged: (payload) => notifyModuleSourceChanged.call(serverContext.appEmitter, payload),
+            notifyViewSourceChanged: (payload) => notifyViewSourceChanged.call(serverContext.appEmitter, payload),
+            notifyAssetSourceChanged: (payload) => notifyAssetSourceChanged.call(serverContext.appEmitter, payload),
+        },
+        moduleRegistry: serverContext.moduleRegistry.getPublicApi(),
+        moduleBundler: serverContext.moduleBundler.getPublicApi(),
+        resourceRegistry: serverContext.resourceRegistry.getPublicApi(),
+        viewRegistry: serverContext.viewRegistry.getPublicApi(),
+        assetRegistry: serverContext.assetRegistry.getPublicApi(),
+        config: deepFreeze({
+            cacheDir,
+            modules,
+            routes,
+            errorRoutes,
+            rootDir,
+            basePath,
+            contentDir,
+            layoutsDir,
+            locker,
+            amdLoader,
+            esmLoader,
+            environment,
+            bundleConfig,
+        }),
+        runtimeEnvironment: deepFreeze(serverContext.runtimeEnvironment),
+        watcherFactory: serverContext.watcherFactory,
+    };
+}
+//# sourceMappingURL=provider.js.map

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

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

@@ -0,0 +1,49 @@
+import { LwrAssetRegistry } from '@lwrjs/asset-registry';
+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 assetRegistry = new LwrAssetRegistry({
+        appObserver,
+        appEmitter,
+        runtimeEnvironment,
+    }, appConfig);
+    const moduleRegistry = new LwrModuleRegistry({
+        appObserver,
+        appEmitter,
+        runtimeEnvironment,
+    }, appConfig);
+    const moduleBundler = new LwrModuleBundler({ moduleRegistry, appObserver }, appConfig);
+    const resourceRegistry = new LwrResourceRegistry();
+    const viewRegistry = new LwrViewRegistry({
+        moduleRegistry,
+        moduleBundler,
+        resourceRegistry,
+        assetRegistry,
+        appObserver,
+        appEmitter,
+        globalData,
+        runtimeEnvironment,
+    }, appConfig);
+    const watcherFactory = new WatcherFactoryImpl();
+    return {
+        appObserver,
+        appEmitter,
+        moduleRegistry,
+        moduleBundler,
+        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;
@@ -20,5 +22,5 @@ export declare class LwrApp {
     getServer(): PublicAppServer<ServerTypes>;
 }
 export declare function createServer(config?: LwrGlobalConfig): LwrApp;
-export declare function generateStaticSite(config?: LwrGlobalConfig): Promise<void>;
+export declare function generateStaticSite(config?: LwrGlobalConfig): Promise<NormalizedLwrGlobalConfig>;
 //# sourceMappingURL=index.d.ts.map