@lwrjs/core 0.9.0-alpha.1 → 0.9.0-alpha.10

package/build/cjs/middleware/view-middleware.cjs

@@ -0,0 +1,154 @@
+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/view-middleware.ts
+__markAsModule(exports);
+__export(exports, {
+  viewMiddleware: () => viewMiddleware
+});
+var import_diagnostics = __toModule(require("@lwrjs/diagnostics"));
+var import_router = __toModule(require("@lwrjs/router"));
+var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
+var import_error_handling = __toModule(require("./utils/error-handling.cjs"));
+var import_view_registry = __toModule(require("@lwrjs/view-registry"));
+var CANONICAL_VIEW_ROUTES = [
+  `/:apiVersion/application/:format/l/:locale/ai/:appId`,
+  `/:apiVersion/application/:format/l/:locale/e/:environment/ai/:appId`,
+  `/:apiVersion/application/:format/ai/:appId`,
+  `/:apiVersion/application/:format/e/:environment/ai/:appId`
+];
+function createViewMiddleware(route, context, viewHandler) {
+  const {appConfig} = context;
+  const errorRoute = appConfig.errorRoutes.find((route2) => route2.status === 500);
+  return async (req, res) => {
+    if (!req.validateEnvironmentRequest(context.appConfig)) {
+      res.status(400);
+      res.send(import_diagnostics.descriptions.UNRESOLVABLE.INVALID_ENVIRONMENT(req.params.environment).message);
+      return;
+    }
+    if (!req.validateJsonRequest()) {
+      res.status(400);
+      res.send(import_diagnostics.descriptions.UNRESOLVABLE.INVALID_JSON().message);
+      return;
+    }
+    const {runtimeEnvironment, runtimeParams} = req.getRuntimeContext(context.runtimeEnvironment);
+    const {environment: environmentConfig} = context.appConfig;
+    if (!runtimeParams.environment && environmentConfig?.default) {
+      runtimeParams.environment = environmentConfig.default;
+    }
+    const viewRequest = {
+      url: req.originalUrl,
+      params: req.params,
+      query: req.query,
+      requestPath: req.path
+    };
+    const resolve = req.isJsonRequest() ? viewHandler.getViewJson : viewHandler.getViewContent;
+    let viewResponse;
+    let resolvedRoute;
+    try {
+      viewResponse = await resolve.call(viewHandler, viewRequest, route, runtimeEnvironment, runtimeParams);
+      resolvedRoute = route;
+    } catch (err) {
+      if (!errorRoute) {
+        throw err;
+      }
+      viewResponse = await resolve.call(viewHandler, viewRequest, errorRoute, runtimeEnvironment, runtimeParams);
+      resolvedRoute = errorRoute;
+    }
+    if (req.isSiteGeneration()) {
+      res.setSiteGenerationMetadata(viewResponse.metadata);
+    }
+    res.type("text/html");
+    if (viewResponse.headers) {
+      res.set(viewResponse.headers);
+    }
+    const cacheTtl = (0, import_shared_utils.shortestTtl)(viewResponse.cache?.ttl, resolvedRoute.cache?.ttl);
+    if (cacheTtl) {
+      res.setHeader("cache-control", `public, max-age=${cacheTtl}`);
+    }
+    const status = resolvedRoute.status || viewResponse.status || 200;
+    res.status(status);
+    res.send(viewResponse.body);
+  };
+}
+function createConfigMiddleware(context, viewHandler) {
+  const {appConfig} = context;
+  const {routes} = appConfig;
+  return async (req, res) => {
+    const {runtimeEnvironment, runtimeParams} = req.getRuntimeContext(context.runtimeEnvironment);
+    const {appId, encodedViewPath} = req.params;
+    const route = routes.find((route2) => route2.id === appId);
+    if (!route) {
+      res.status(404).send(import_diagnostics.descriptions.UNRESOLVABLE.APP_CONFIG(appId).message);
+      return;
+    }
+    const url = (0, import_shared_utils.decodeViewPath)(encodedViewPath);
+    const requestPath = route.path;
+    const params = (0, import_shared_utils.extractRequestParams)(requestPath, url, req.params);
+    const viewRequest = {
+      url,
+      params,
+      query: req.query,
+      requestPath
+    };
+    const viewResponse = await viewHandler.getViewConfiguration(viewRequest, route, runtimeEnvironment, runtimeParams);
+    if (!viewResponse) {
+      res.status(404).send(import_diagnostics.descriptions.UNRESOLVABLE.VIEW_CONFIG(url).message);
+      return;
+    }
+    const cacheTtl = (0, import_shared_utils.shortestTtl)(viewResponse.cache?.ttl, route.cache?.ttl);
+    if (cacheTtl) {
+      res.setHeader("cache-control", `public, max-age=${cacheTtl}`);
+    }
+    res.status(200);
+    res.type("application/javascript");
+    res.status(viewResponse.status || 200);
+    res.send(viewResponse.body);
+  };
+}
+function createNotFoundMiddleware(context, viewHandler) {
+  const {errorRoutes} = context.appConfig;
+  const errorRoute = errorRoutes.find((route) => route.status === 404);
+  if (errorRoute) {
+    return createViewMiddleware(errorRoute, context, viewHandler);
+  }
+  return (req, res) => {
+    res.status(404).send(import_diagnostics.descriptions.UNRESOLVABLE.VIEW(req.originalUrl).message);
+  };
+}
+function viewMiddleware(app, context) {
+  const {appConfig, viewRegistry, moduleRegistry} = context;
+  const viewHandler = new import_view_registry.LwrViewHandler({viewRegistry, moduleRegistry}, appConfig);
+  for (const route of appConfig.routes) {
+    const paths = [route.path];
+    const subRoutes = route.subRoutes && (0, import_router.getClientRoutes)(route.subRoutes);
+    if (subRoutes) {
+      const prefix = route.path === "/" ? "" : route.path;
+      subRoutes.routes.forEach((subRoute) => subRoute.uri !== route.path && paths.push(`${prefix}${subRoute.uri}`));
+    }
+    paths.forEach((routePath) => paths.push(...CANONICAL_VIEW_ROUTES.map((viewRoute) => viewRoute + routePath)));
+    app.get(paths, (0, import_error_handling.handleErrors)(createViewMiddleware(route, context, viewHandler)));
+  }
+  app.get((0, import_shared_utils.getClientBootstrapConfigurationRoutes)(), (0, import_error_handling.handleErrors)(createConfigMiddleware(context, viewHandler)));
+  app.get("/" + app.getRegexWildcard(), (0, import_error_handling.handleErrors)(createNotFoundMiddleware(context, viewHandler)));
+}

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-build.cjs

@@ -0,0 +1,182 @@
+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/tools/server-build.ts
+__markAsModule(exports);
+__export(exports, {
+  buildServer: () => buildServer
+});
+var import_path = __toModule(require("path"));
+var import_fs_extra = __toModule(require("fs-extra"));
+var import_esbuild = __toModule(require("esbuild"));
+var import_config = __toModule(require("@lwrjs/config"));
+var import_configurations = __toModule(require("../context/configurations.cjs"));
+var import_provider = __toModule(require("../context/provider.cjs"));
+var import_server = __toModule(require("../context/server.cjs"));
+function getBuildMetadata(appConfig) {
+  const moduleProviders = processServiceEntries("moduleProvider", appConfig.moduleProviders);
+  const resourceProviders = processServiceEntries("resourceProvider", appConfig.resourceProviders);
+  const viewProviders = processServiceEntries("viewProvider", appConfig.viewProviders);
+  const viewTransformers = processServiceEntries("viewTransformer", appConfig.viewTransformers);
+  const assetProviders = processServiceEntries("assetProvider", appConfig.assetProviders);
+  const assetTransformers = processServiceEntries("assetTransformer", appConfig.assetTransformers);
+  const imports = [
+    ...moduleProviders.imports,
+    ...resourceProviders.imports,
+    ...viewProviders.imports,
+    ...viewTransformers.imports,
+    ...assetProviders.imports,
+    ...assetTransformers.imports
+  ];
+  return {
+    imports,
+    moduleProviders: moduleProviders.services,
+    resourceProviders: resourceProviders.services,
+    viewProviders: viewProviders.services,
+    viewTransformers: viewTransformers.services,
+    assetProviders: assetProviders.services,
+    assetTransformers: assetTransformers.services
+  };
+}
+function processServiceEntries(serviceType, entries) {
+  const imports = [];
+  const services = [];
+  for (const [index, [pkg, config]] of entries.entries()) {
+    const name = serviceType + index;
+    imports.push(`import ${name} from '${pkg}';`);
+    services.push(`[${name}, ${JSON.stringify(config)}]`);
+  }
+  return {
+    imports,
+    services
+  };
+}
+function generateServices(providerContext) {
+  return ([ServiceCtor, serviceConfig = {}]) => new ServiceCtor(serviceConfig, providerContext);
+}
+function isRemote() {
+  return process.env.AWS_LAMBDA_FUNCTION_NAME !== void 0;
+}
+function generateServerContextModule(appConfig, runtimeEnvironment, globalData, metadata) {
+  const {
+    imports,
+    moduleProviders,
+    resourceProviders,
+    viewProviders,
+    viewTransformers,
+    assetProviders,
+    assetTransformers
+  } = metadata;
+  const config = {
+    ...appConfig,
+    rootDir: void 0,
+    ignoreLwrConfigFile: true
+  };
+  return [
+    `/* This module is generated */`,
+    `import { LwrCompiler } from '@lwrjs/compiler';`,
+    `import { LwrModuleBundler } from '@lwrjs/module-bundler';`,
+    `import { LwrModuleRegistry } from '@lwrjs/module-registry';`,
+    `import { LwrResourceRegistry } from '@lwrjs/resource-registry';`,
+    `import { LwrAssetRegistry } from '@lwrjs/asset-registry';`,
+    `import { LwrViewRegistry } from '@lwrjs/view-registry';`,
+    `import { LwrApplicationObserver, deepFreeze } from '@lwrjs/shared-utils';`,
+    `import { normalizeConfig } from '@lwrjs/config';`,
+    ...imports,
+    import_server.createServerContext.toString(),
+    import_provider.createProviderContext.toString(),
+    generateServices.toString(),
+    isRemote.toString(),
+    `const config = ${JSON.stringify(config, null, 4)}`,
+    `const runtimeEnvironment = ${JSON.stringify(runtimeEnvironment, null, 4)}`,
+    `const globalData = ${JSON.stringify(globalData, null, 4)}`,
+    `isRemote() && process.chdir(__dirname);`,
+    `isRemote() && (config.rootDir = __dirname);`,
+    `isRemote() && (config.cacheDir = '/tmp/__lwr_cache__');`,
+    `const normalizedConfig = normalizeConfig(config);`,
+    `const serverContext = createServerContext(normalizedConfig, runtimeEnvironment, globalData);`,
+    `const providerContext = createProviderContext(serverContext);`,
+    `const generate = generateServices(providerContext);`,
+    `const moduleProviders = [${moduleProviders}].map(generate);`,
+    `const resourceProviders = [${resourceProviders}].map(generate);`,
+    `const viewProviders = [${viewProviders}].map(generate);`,
+    `const viewTransformers = [${viewTransformers}].map(generate);`,
+    `const assetProviders = [${assetProviders}].map(generate);`,
+    `const assetTransformers = [${assetTransformers}].map(generate);`,
+    `serverContext.moduleRegistry.addModuleProviders(moduleProviders);`,
+    `serverContext.resourceRegistry.addResourceProviders(resourceProviders);`,
+    `serverContext.viewRegistry.addViewProviders(viewProviders);`,
+    `serverContext.viewRegistry.addViewTransformers(viewTransformers);`,
+    `serverContext.assetRegistry.addAssetProviders(assetProviders);`,
+    `serverContext.assetRegistry.addAssetTransformers(assetTransformers);`,
+    `export default serverContext;`
+  ].join("\n");
+}
+function generateServerSource(target) {
+  if (target !== "lambda") {
+    throw `Unsupported server build target: ${target}`;
+  }
+  return [
+    `/* This module is generated */`,
+    `import { createHandler } from '@lwrjs/lambda';`,
+    `import build from './lwr.build.js';`,
+    `const handler = createHandler(build);`,
+    `export { handler as get };`
+  ].join("\n");
+}
+async function bundleServer(entryPoint, outputPath) {
+  await import_esbuild.default.build({
+    entryPoints: [entryPoint],
+    bundle: true,
+    sourcemap: true,
+    logLevel: "silent",
+    external: [
+      "node:*",
+      "fsevents",
+      "iltorb",
+      "esbuild*",
+      "esinstall",
+      "jsonc-parser",
+      "node-fetch",
+      "rollup",
+      "rollup-plugin-node-polyfills",
+      "@lwrjs/config",
+      "@lwrjs/loader"
+    ],
+    format: "cjs",
+    platform: "node",
+    outfile: outputPath
+  });
+}
+async function buildServer(configArg, options) {
+  const config = (0, import_config.normalizeConfig)(configArg, {skipDirNormalization: true, skipCacheDirCreation: true});
+  const {appConfig, runtimeEnvironment, globalData} = await (0, import_configurations.resolveConfigurations)(config);
+  const metadata = getBuildMetadata(appConfig);
+  const serverContext = generateServerContextModule(appConfig, runtimeEnvironment, globalData, metadata);
+  const outputDir = import_path.default.join(appConfig.rootDir, options?.outputDir || "/build");
+  const serverSource = generateServerSource(options?.target || "lambda");
+  await import_fs_extra.default.ensureDir(outputDir);
+  await import_fs_extra.default.writeFile(import_path.default.join(outputDir, "lwr.build.js"), serverContext);
+  await import_fs_extra.default.writeFile(import_path.default.join(outputDir, "entry.js"), serverSource);
+  await bundleServer(import_path.default.join(outputDir, "entry.js"), import_path.default.join(outputDir, "ssr.js"));
+}

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

@@ -70,25 +70,31 @@ var SiteGenerator = class {
       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);
+          const siteConfig = this.createSiteConfig(outputDir, locale, urlRewriteMap, skipBaseDocumentGeneration, runtimeEnvironment);
           await this.dispatchJSResourceRecursive(specifier, dispatcher, siteConfig, true);
         }
       }
     }
+    const willSSR = routes.some((r) => r.bootstrap?.ssr);
+    if (willSSR) {
+      const siteConfig = this.createSiteConfig(outputDir, staticSiteGenerator.locales[0], urlRewriteMap, skipBaseDocumentGeneration, runtimeEnvironment);
+      await this.dispatchJSResourceRecursive("@lwrjs/lwc-ssr/lwc_ssr_placeholder", dispatcher, siteConfig, true);
+    }
   }
   createGenerateURLFunction(dispatcher) {
     const generateRoute = async (uri, siteConfig) => {
@@ -183,25 +189,27 @@ var SiteGenerator = class {
     }
   }
   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);
@@ -330,7 +338,7 @@ var SiteGenerator = class {
       }
     }
   }
-  createSiteConfig(outputDir, locale, urlRewriteMap, runtimeEnvironment) {
+  createSiteConfig(outputDir, locale, urlRewriteMap, skipBaseDocumentGeneration, runtimeEnvironment) {
     const featureFlags = this.filterFeatureFlags();
     const endpoints = {
       uris: {
@@ -345,12 +353,14 @@ var SiteGenerator = class {
       locale,
       urlRewriteMap,
       endpoints,
+      skipBaseDocumentGeneration,
       ...featureFlags
     };
   }
   filterFeatureFlags() {
-    if ((0, import_shared_utils.getFeatureFlags)().LEGACY_LOADER) {
-      return {featureFlags: {LEGACY_LOADER: true}};
+    const ffs = (0, import_shared_utils.getFeatureFlags)();
+    if (ffs.LEGACY_LOADER) {
+      return {featureFlags: {LEGACY_LOADER: true, SSR_STATIC_BUNDLES: ffs.SSR_STATIC_BUNDLES}};
     } else {
       return void 0;
     }

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

@@ -0,0 +1,9 @@
+import { NormalizedLwrGlobalConfig, RuntimeEnvironment, GlobalData } from '@lwrjs/types';
+interface Configurations {
+    appConfig: NormalizedLwrGlobalConfig;
+    globalData: GlobalData;
+    runtimeEnvironment: RuntimeEnvironment;
+}
+export declare function resolveConfigurations(config: NormalizedLwrGlobalConfig): Promise<Configurations>;
+export {};
+//# sourceMappingURL=configurations.d.ts.map

package/build/es/context/configurations.js

@@ -0,0 +1,53 @@
+import { DEFAULT_LWR_BOOTSTRAP_CONFIG, getFeatureFlags, logger } from '@lwrjs/shared-utils';
+import { explodeMode, validateLwrAppConfig } from '@lwrjs/config';
+import { getGlobalData } from './global-data.js';
+import { getServices } from './services.js';
+// Add missing bootstrap objects to routes
+function normalizeRoutesBootstrap({ routes, errorRoutes }) {
+    [...routes, ...errorRoutes].forEach((route) => {
+        if (!route.bootstrap) {
+            route.bootstrap = { ...DEFAULT_LWR_BOOTSTRAP_CONFIG };
+        }
+    });
+}
+async function runConfigurationsHook(hookPlugins, appConfig, globalData, runtimeEnvironment) {
+    for (const hookPlugin of hookPlugins) {
+        // eslint-disable-next-line no-await-in-loop
+        await hookPlugin.initConfigs(appConfig, globalData, runtimeEnvironment);
+    }
+    try {
+        validateLwrAppConfig(JSON.stringify(appConfig), 'post');
+    }
+    catch (e) {
+        // TODO: temporary workaround for https://github.com/salesforce/lwr/issues/825
+        if (process.env.UNSAFE_IGNORE_CONFIG_VALIDATION === 'true') {
+            logger.warn('ignoring config validation errors due to UNSAFE_IGNORE_CONFIG_VALIDATION flag...proceed with caution');
+            console.dir(e, { depth: null });
+        }
+        else {
+            throw e;
+        }
+    }
+    normalizeRoutesBootstrap(appConfig);
+    return {
+        appConfig,
+        globalData,
+        runtimeEnvironment,
+    };
+}
+export async function resolveConfigurations(config) {
+    const { apiVersion, basePath, lwrVersion, serverMode, globalDataDir, globalData: globalDataConfig, } = config;
+    const globalData = getGlobalData(globalDataDir, globalDataConfig);
+    const runtimeEnvironment = {
+        ...explodeMode(serverMode),
+        apiVersion,
+        basePath,
+        lwrVersion,
+        debug: false,
+        serverMode,
+        featureFlags: getFeatureFlags(),
+    };
+    const hookProviders = await getServices(config.hooks, undefined, config);
+    return runConfigurationsHook(hookProviders, config, globalData, runtimeEnvironment);
+}
+//# sourceMappingURL=configurations.js.map

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,38 @@
+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 { 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),
+            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,
+        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,
+        }),
+        runtimeEnvironment: deepFreeze(serverContext.runtimeEnvironment),
+    };
+}
+//# sourceMappingURL=provider.js.map

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

@@ -0,0 +1,3 @@
+import { 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,48 @@
+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';
+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 resourceRegistry = new LwrResourceRegistry();
+    const viewRegistry = new LwrViewRegistry({
+        moduleRegistry,
+        moduleBundler,
+        resourceRegistry,
+        assetRegistry,
+        appObserver,
+        appEmitter,
+        globalData,
+        runtimeEnvironment,
+    }, appConfig);
+    return {
+        compiler,
+        appObserver,
+        appEmitter,
+        moduleRegistry,
+        moduleBundler,
+        resourceRegistry,
+        assetRegistry,
+        viewRegistry,
+        appConfig,
+        runtimeEnvironment,
+    };
+}
+//# sourceMappingURL=server.js.map

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

@@ -1,8 +1,3 @@
-import { LwrService, ServiceCtor } from '@lwrjs/types';
-interface SubLwrConfig {
-    cacheDir: string;
-    rootDir: string;
-}
-export declare function getServiceModule<T extends LwrService>(path: string, { cacheDir, rootDir }: SubLwrConfig): Promise<ServiceCtor<T>>;
-export {};
+import { LwrService, NormalizedLwrGlobalConfig, ProviderContext, ServiceConfig } from '@lwrjs/types';
+export declare function getServices<T extends LwrService>(services: ServiceConfig[], providerContext: ProviderContext | undefined, lwrConfig: NormalizedLwrGlobalConfig): Promise<T[]>;
 //# sourceMappingURL=services.d.ts.map