@lwrjs/config 0.9.0-alpha.9 → 0.9.0

package/build/cjs/utils/routes.cjs

@@ -24,27 +24,45 @@ var __toModule = (module2) => {
 // packages/@lwrjs/config/src/utils/routes.ts
 __markAsModule(exports);
 __export(exports, {
+  normalizeRouteHandlerPaths: () => normalizeRouteHandlerPaths,
   normalizeRoutePaths: () => normalizeRoutePaths,
   normalizeRoutes: () => normalizeRoutes
 });
 var import_path = __toModule(require("path"));
 var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
-function normalizeRoutes(routes = []) {
-  return routes.map((route) => ({
-    ...route,
-    bootstrap: {
-      ...import_shared_utils.DEFAULT_LWR_BOOTSTRAP_CONFIG,
-      ...route.bootstrap
+function normalizeRoutes(routes, routeHandlers) {
+  return routes.map((route) => {
+    if (route.routeHandler && !routeHandlers[route.routeHandler]) {
+      const handlerPath = route.routeHandler;
+      routeHandlers[handlerPath] = handlerPath;
     }
-  }));
+    return {
+      ...route,
+      bootstrap: {
+        ...import_shared_utils.DEFAULT_LWR_BOOTSTRAP_CONFIG,
+        ...route.bootstrap
+      }
+    };
+  });
 }
 function normalizeRoutePaths(routes = [], resourcePaths) {
   return routes.map((route) => {
-    const {routeHandler, contentTemplate, layoutTemplate, subRoutes} = route;
-    route.routeHandler = routeHandler && import_path.default.resolve((0, import_shared_utils.normalizeDirectory)(routeHandler, resourcePaths.rootDir));
-    route.contentTemplate = contentTemplate && import_path.default.resolve((0, import_shared_utils.normalizeResourcePath)(contentTemplate, resourcePaths));
-    route.layoutTemplate = layoutTemplate && import_path.default.resolve((0, import_shared_utils.normalizeResourcePath)(layoutTemplate, resourcePaths));
-    route.subRoutes = subRoutes && import_path.default.resolve((0, import_shared_utils.normalizeResourcePath)(subRoutes, resourcePaths));
+    const {contentTemplate, layoutTemplate, subRoutes} = route;
+    if (contentTemplate) {
+      route.contentTemplate = import_path.default.resolve((0, import_shared_utils.normalizeResourcePath)(contentTemplate, resourcePaths));
+    }
+    if (layoutTemplate) {
+      route.layoutTemplate = import_path.default.resolve((0, import_shared_utils.normalizeResourcePath)(layoutTemplate, resourcePaths));
+    }
+    if (subRoutes) {
+      route.subRoutes = import_path.default.resolve((0, import_shared_utils.normalizeResourcePath)(subRoutes, resourcePaths));
+    }
     return route;
   });
 }
+function normalizeRouteHandlerPaths(routeHandlers, resourcePaths) {
+  for (const [id, handlerPath] of Object.entries(routeHandlers)) {
+    routeHandlers[id] = import_path.default.resolve((0, import_shared_utils.normalizeDirectory)(handlerPath, resourcePaths.rootDir));
+  }
+  return routeHandlers;
+}

package/build/cjs/validation/app-config-context.cjs

@@ -47,6 +47,7 @@ var ROOT_ATTRIBUTE_KEYS = createKeys("root", [
   "assetProviders",
   "assetTransformers",
   "bundleConfig",
+  "bundleProviders",
   "cacheDir",
   "contentDir",
   "environment",
@@ -67,10 +68,11 @@ var ROOT_ATTRIBUTE_KEYS = createKeys("root", [
   "basePath",
   "resourceProviders",
   "rootDir",
+  "routeHandlers",
   "routes",
   "serverMode",
+  "minify",
   "serverType",
-  "templateEngine",
   "viewProviders",
   "viewTransformers"
 ]);
@@ -108,7 +110,9 @@ var BOOTSTRAP_ATTRIBUTE_KEYS = createKeys("bootstrap", [
   "workers",
   "services",
   "configAsSrc",
-  "ssr"
+  "ssr",
+  "module",
+  "preloadModules"
 ]);
 var SPECIFIER_REGEX = /^@?[\w-]+(\/[\w-]+)*$/;
 function isNotEmptyString(node) {

package/build/cjs/validation/app-config.cjs

@@ -41,9 +41,11 @@ function validateBootstrap(node, validationContext, propPrefix) {
     validationContext.assertIsObject(node, "bootstrap");
     validationContext.assertValidKeys(node, "bootstrap", import_app_config_context.BOOTSTRAP_ATTRIBUTE_KEYS);
     validationContext.assertArrayOfSpecifiers((0, import_jsonc_parser.findNodeAtLocation)(node, ["services"]), `${propPrefix}.services`);
+    validationContext.assertArrayOfSpecifiers((0, import_jsonc_parser.findNodeAtLocation)(node, ["preloadModules"]), `${propPrefix}.preloadModules`);
     validationContext.assertIsBoolean((0, import_jsonc_parser.findNodeAtLocation)(node, ["autoBoot"]), `${propPrefix}.autoBoot`);
     validationContext.assertIsBoolean((0, import_jsonc_parser.findNodeAtLocation)(node, ["ssr"]), `${propPrefix}.ssr`);
     validationContext.assertIsBoolean((0, import_jsonc_parser.findNodeAtLocation)(node, ["configAsSrc"]), `${propPrefix}.configAsSrc`);
+    validationContext.assertIsSpecifier((0, import_jsonc_parser.findNodeAtLocation)(node, ["module"]), `${propPrefix}.module`);
     validationContext.assertIsBoolean((0, import_jsonc_parser.findNodeAtLocation)(node, ["syntheticShadow"]), `${propPrefix}.syntheticShadow`);
     const workers = (0, import_jsonc_parser.findNodeAtLocation)(node, ["workers"]);
     if (workers && workers.children) {
@@ -68,9 +70,11 @@ function validateRouteCommon(node, validationContext, propPrefix) {
   validationContext.assertNotEmptyString((0, import_jsonc_parser.findNodeAtLocation)(node, ["routeHandler"]), `${propPrefix}.routeHandler`);
   validateBootstrap((0, import_jsonc_parser.findNodeAtLocation)(node, ["bootstrap"]), validationContext, `${propPrefix}.bootstrap`);
 }
-function validateRoutes(node, validationContext) {
+function validateRoutes(node, validationContext, preMerge) {
   if (node) {
-    validationContext.assertNotEmptyArray(node, "routes");
+    if (!preMerge) {
+      validationContext.assertNotEmptyArray(node, "routes");
+    }
     if (node.children) {
       node.children.forEach((n, index) => {
         const propPrefix = `routes[${index}]`;
@@ -99,6 +103,11 @@ function validateErrorRoutes(node, validationContext) {
     }
   }
 }
+function validateRouteHandlers(node, validationContext) {
+  if (node) {
+    validationContext.assertIsObject(node, "routeHandlers");
+  }
+}
 function validateAssets(node, validationContext, preMerge) {
   if (node) {
     if (preMerge && node.type === "string") {
@@ -143,8 +152,9 @@ function validateRoot(node, validationContext, preMerge) {
   const routes = (0, import_jsonc_parser.findNodeAtLocation)(node, ["routes"]);
   const errorRoutes = (0, import_jsonc_parser.findNodeAtLocation)(node, ["errorRoutes"]);
   validationContext.assertUniqueIds([...routes?.children || [], ...errorRoutes?.children || []], "routes");
-  validateRoutes(routes, validationContext);
+  validateRoutes(routes, validationContext, preMerge);
   validateErrorRoutes(errorRoutes, validationContext);
+  validateRouteHandlers((0, import_jsonc_parser.findNodeAtLocation)(node, ["routeHandlers"]), validationContext);
   validateAssets((0, import_jsonc_parser.findNodeAtLocation)(node, ["assets"]), validationContext, preMerge);
   validateLocker((0, import_jsonc_parser.findNodeAtLocation)(node, ["locker"]), validationContext);
   validationContext.assertNotEmptyString((0, import_jsonc_parser.findNodeAtLocation)(node, ["apiVersion"]), "apiVersion");
@@ -161,7 +171,7 @@ function validateRoot(node, validationContext, preMerge) {
   validationContext.assertNotEmptyString((0, import_jsonc_parser.findNodeAtLocation)(node, ["layoutsDir"]), "layoutsDir");
   validationContext.assertNotEmptyString((0, import_jsonc_parser.findNodeAtLocation)(node, ["globalDataDir"]), "globalDataDir");
   validationContext.assertArrayOfServices((0, import_jsonc_parser.findNodeAtLocation)(node, ["hooks"]), "hooks");
-  validationContext.assertNotEmptyString((0, import_jsonc_parser.findNodeAtLocation)(node, ["templateEngine"]), "templateEngine");
+  validationContext.assertArrayOfServices((0, import_jsonc_parser.findNodeAtLocation)(node, ["bundleProviders"]), "bundleProviders");
   validationContext.assertArrayOfServices((0, import_jsonc_parser.findNodeAtLocation)(node, ["moduleProviders"]), "moduleProviders");
   validationContext.assertArrayOfServices((0, import_jsonc_parser.findNodeAtLocation)(node, ["viewProviders"]), "viewProviders");
   validationContext.assertArrayOfServices((0, import_jsonc_parser.findNodeAtLocation)(node, ["resourceProviders"]), "resourceProviders");

package/build/es/defaults.d.ts

@@ -1,12 +1,17 @@
-import { LwrGlobalConfig } from '@lwrjs/types';
+import type { BundleConfig, LwrGlobalConfig } from '@lwrjs/types';
 export declare const LWR_VERSION: string;
 export declare const DEFAULT_LWR_CONFIG_JSON = "$rootDir/lwr.config.json";
 export declare const DEFAULT_GENERATOR_CONFIG: {
     outputDir: string;
     locales: string[];
+    skipCleanOutputDir: boolean;
+    skipBaseDocumentGeneration: boolean;
+    _additionalModules: never[];
     _additionalRoutePaths: never[];
 };
 export declare const DEFAULT_ROOT_DIR: string;
+export declare const SSR_MODULE_PROVIDER = "@lwrjs/lwc-ssr/moduleProvider";
+export declare const SSR_VIEW_TRANSFORM_PLUGIN = "@lwrjs/lwc-ssr/viewTransformer";
 export declare const DEFAULT_AMD_LOADER = "lwr/loader";
 export declare const DEFAULT_AMD_LOADER_LEGACY = "lwr/loaderLegacy";
 export declare const DEFAULT_ESM_LOADER = "lwr/esmLoader";
@@ -14,6 +19,6 @@ export declare const DEFAULT_SERVICE_PACKAGE_NAME: RegExp;
 export declare const DEFAULT_LWR_MODULES: {
     npm: string;
 }[];
-export declare const DEFAULT_BUNDLE_EXCLUSIONS: string[];
+export declare function getDefaultBundleConfig(mode?: string): BundleConfig;
 export declare const DEFAULT_LWR_CONFIG: Required<LwrGlobalConfig>;
 //# sourceMappingURL=defaults.d.ts.map

package/build/es/defaults.js

@@ -1,15 +1,19 @@
-import { DEFAULT_LWR_LOCKER_CONFIG } from '@lwrjs/shared-utils';
+import { DEFAULT_LWR_LOCKER_CONFIG, getFeatureFlags } from '@lwrjs/shared-utils';
 import { version } from '@lwrjs/config/package';
+import { getServerModeConfig } from './runtime-config.js';
 const PORT = process.env.PORT ? parseInt(process.env.PORT, 10) : 3000;
-const MODE = process.env.MODE || 'dev';
+const MODE = process.env.MODE || 'prod';
 const DEFAULT_BASE_PATH = '';
 const DEFAULT_API_VERSION = '1';
 export const LWR_VERSION = version;
 const DEFAULT_SERVER_TYPE = 'express';
 export const DEFAULT_LWR_CONFIG_JSON = '$rootDir/lwr.config.json';
 export const DEFAULT_GENERATOR_CONFIG = {
-    outputDir: '__generated_site__',
+    outputDir: 'site',
     locales: ['en-US'],
+    skipCleanOutputDir: false,
+    skipBaseDocumentGeneration: false,
+    _additionalModules: [],
     _additionalRoutePaths: [],
 };
 // Directories
@@ -22,11 +26,11 @@ const DEFAULT_DATA_DIR = '$rootDir/src/data';
 // Providers
 const DEFAULT_MODULE_PROVIDERS = [
     '@lwrjs/app-service/moduleProvider',
-    '@lwrjs/lwc-ssr/moduleProvider',
     '@lwrjs/router/module-provider',
     '@lwrjs/lwc-module-provider',
     '@lwrjs/npm-module-provider',
 ];
+export const SSR_MODULE_PROVIDER = '@lwrjs/lwc-ssr/moduleProvider';
 const DEFAULT_RESOURCE_PROVIDERS = ['@lwrjs/loader'];
 const DEFAULT_VIEW_PROVIDERS = [
     '@lwrjs/nunjucks-view-provider',
@@ -34,10 +38,14 @@ const DEFAULT_VIEW_PROVIDERS = [
     '@lwrjs/markdown-view-provider',
     '@lwrjs/base-view-provider',
 ];
-const DEFAULT_VIEW_TRANSFORM_PLUGINS = ['@lwrjs/base-view-transformer', '@lwrjs/lwc-ssr/viewTransformer'];
+const DEFAULT_BUNDLE_PROVIDERS = [
+    '@lwrjs/module-bundler/amd-bundle-provider',
+    '@lwrjs/module-bundler/esm-bundle-provider',
+];
+const DEFAULT_VIEW_TRANSFORM_PLUGINS = ['@lwrjs/base-view-transformer'];
+export const SSR_VIEW_TRANSFORM_PLUGIN = '@lwrjs/lwc-ssr/viewTransformer';
 const DEFAULT_ASSET_PROVIDERS = ['@lwrjs/fs-asset-provider'];
 const DEFAULT_ASSET_TRANSFORM_PLUGINS = ['@lwrjs/asset-transformer'];
-const DEFAULT_TEMPLATE_ENGINE = '@lwrjs/base-template-engine';
 export const DEFAULT_AMD_LOADER = 'lwr/loader';
 export const DEFAULT_AMD_LOADER_LEGACY = 'lwr/loaderLegacy';
 export const DEFAULT_ESM_LOADER = 'lwr/esmLoader';
@@ -50,13 +58,35 @@ export const DEFAULT_LWR_MODULES = [
     { npm: '@lwrjs/router' },
     { npm: '@lwc/synthetic-shadow' },
 ];
-export const DEFAULT_BUNDLE_EXCLUSIONS = [
+const DEFAULT_ESM_BUNDLE_EXCLUSIONS = [
     'lwc',
     '@lwc/synthetic-shadow',
     'lwr/navigation',
     'lwr/esmLoader',
     'lwr/profiler',
 ];
+const DEFAULT_AMD_BUNDLE_EXCLUSIONS = ['lwc', 'lwr/navigation'];
+const DEFAULT_ESM_BUNDLE_EXTERNALS = {};
+const DEFAULT_AMD_BUNDLE_EXTERNALS = {
+    'lwr/loader': 'lwr-loader-shim.bundle.min.js',
+    'lwr/profiler': 'lwr-loader-shim.bundle.min.js',
+};
+const DEFAULT_AMD_LEGACY_BUNDLE_EXTERNALS = {
+    'lwr/loaderLegacy': 'lwr-loader-shim-legacy.bundle.min.js',
+    'lwr/profiler': 'lwr-loader-shim-legacy.bundle.min.js',
+};
+export function getDefaultBundleConfig(mode) {
+    const format = getServerModeConfig(mode || MODE).format;
+    const loaderLegacy = getFeatureFlags().LEGACY_LOADER;
+    return {
+        exclude: format === 'esm' ? DEFAULT_ESM_BUNDLE_EXCLUSIONS : DEFAULT_AMD_BUNDLE_EXCLUSIONS,
+        external: format === 'esm'
+            ? DEFAULT_ESM_BUNDLE_EXTERNALS
+            : loaderLegacy
+                ? DEFAULT_AMD_LEGACY_BUNDLE_EXTERNALS
+                : DEFAULT_AMD_BUNDLE_EXTERNALS,
+    };
+}
 export const DEFAULT_LWR_CONFIG = {
     port: PORT,
     ignoreLwrConfigFile: false,
@@ -65,6 +95,7 @@ export const DEFAULT_LWR_CONFIG = {
     rootDir: DEFAULT_ROOT_DIR,
     cacheDir: DEFAULT_CACHE_FOLDER,
     serverMode: MODE,
+    minify: null,
     apiVersion: DEFAULT_API_VERSION,
     assets: DEFAULT_ASSETS_DIR,
     assetProviders: DEFAULT_ASSET_PROVIDERS,
@@ -75,16 +106,17 @@ export const DEFAULT_LWR_CONFIG = {
     globalDataDir: DEFAULT_DATA_DIR,
     globalData: {},
     hooks: [],
+    bundleProviders: DEFAULT_BUNDLE_PROVIDERS,
     moduleProviders: DEFAULT_MODULE_PROVIDERS,
     resourceProviders: DEFAULT_RESOURCE_PROVIDERS,
     viewProviders: DEFAULT_VIEW_PROVIDERS,
     viewTransformers: DEFAULT_VIEW_TRANSFORM_PLUGINS,
-    templateEngine: DEFAULT_TEMPLATE_ENGINE,
     environment: {},
     lwc: { modules: [] },
     routes: [],
     errorRoutes: [],
-    bundleConfig: { exclude: DEFAULT_BUNDLE_EXCLUSIONS },
+    routeHandlers: {},
+    bundleConfig: getDefaultBundleConfig(MODE),
     serverType: DEFAULT_SERVER_TYPE,
     locker: DEFAULT_LWR_LOCKER_CONFIG,
 };

package/build/es/global-config.d.ts

@@ -0,0 +1,65 @@
+import type { GlobalData, LwrGlobalConfig, NormalizedLwrGlobalConfig, RuntimeEnvironment } from '@lwrjs/types';
+export interface ResolveConfigOptions {
+    skipDirNormalization?: boolean;
+    skipCacheDirCreation?: boolean;
+    useStaticProviders?: boolean;
+}
+export interface Configurations {
+    appConfig: NormalizedLwrGlobalConfig;
+    runtimeEnvironment: RuntimeEnvironment;
+    globalData: GlobalData;
+}
+/**
+ * Load and validate the global config file.
+ *
+ * @remarks
+ * By default, this file is expected to be named `lwr.config.json` and be located at the root directory.
+ * This default expectation can be override with the `lwrConfigFile` configuration.
+ *
+ * @throws {LwrConfigValidationError} Validation errors will be swallowed when the
+ * `UNSAFE_IGNORE_CONFIG_VALIDATION` flag is set.
+ *
+ * @param {string} lwrConfigPath - config file path override
+ * @param {string} rootDir - the directory used to resolve `$rootDir`
+ * @returns {LwrGlobalConfig | undefined} the validated config file contents if it exists
+ */
+export declare function getLwrConfigFromFile(rootDir: string, lwrConfigPath?: string): LwrGlobalConfig | undefined;
+/**
+ * Add the SSR module provider and view transformer, if any route has `ssr` turned on.
+ *
+ * @param {NormalizedLwrGlobalConfig} config - a normalized global config to check / mutate
+ * @returns {NormalizedLwrGlobalConfig} an SSR-enabled normalized global config, if needed
+ */
+export declare function applySsrConfig(config: NormalizedLwrGlobalConfig): NormalizedLwrGlobalConfig;
+/**
+ * Apply Static Providers for MRT runtime (used exclusively by buildServer)
+ *
+ * @param {NormalizedLwrGlobalConfig} config - a normalized global config to check / mutate
+ * @returns {NormalizedLwrGlobalConfig} an SSR-enabled normalized global config, if needed
+ */
+export declare function applyStaticProviderConfig(config: NormalizedLwrGlobalConfig): NormalizedLwrGlobalConfig;
+/**
+ * Load, merge, and normalize all of the config sources.
+ *
+ * @remarks
+ * Config hooks are not loaded or applied during config resolution.
+ *
+ * @privateRemarks
+ * The `skipDirNormalization` and `skipCacheDirCreation` options are useful for generating
+ * a portable global config.  The directories can be normalized and the cache directory can
+ * be created at runtime.
+ *
+ * @param {LwrGlobalConfig} configArg - programmatic global config
+ * @param {ResolveConfigOptions} options - config resolution mutations
+ * @returns {NormalizedLwrGlobalConfig} a normalized global config relative to the provided options
+ */
+export declare function resolveGlobalConfig(configArg?: LwrGlobalConfig, options?: ResolveConfigOptions): NormalizedLwrGlobalConfig;
+/**
+ * Resolve all application configurations by loading and merging global data, applying config hooks, and
+ * importing configurable paths to javascript(ie. services and route handlers).
+ *
+ * @param {LwrGlobalConfig} config - programmatic global config
+ * @returns {Configurations} all of the fully resolved configurations
+ */
+export declare function loadConfig(config?: LwrGlobalConfig, options?: ResolveConfigOptions): Configurations;
+//# sourceMappingURL=global-config.d.ts.map

package/build/es/{env-config.js → global-config.js}

@@ -1,14 +1,17 @@
 import fs from 'fs';
 import path from 'path';
+import { parse } from 'jsonc-parser';
 import { readFile, normalizeDirectory, getFeatureFlags, logger, ASSETS_CACHE_DIR } from '@lwrjs/shared-utils';
+import { SSR_MODULE_PROVIDER, SSR_VIEW_TRANSFORM_PLUGIN } from './defaults.js';
 import { DEFAULT_AMD_LOADER, DEFAULT_AMD_LOADER_LEGACY, DEFAULT_ESM_LOADER, DEFAULT_LWR_CONFIG, DEFAULT_LWR_CONFIG_JSON, DEFAULT_ROOT_DIR, LWR_VERSION, } from './defaults.js';
 import { validateLwrAppConfig } from './validation/app-config.js';
 import { normalizeAssetPaths, normalizeAssets } from './utils/assets.js';
 import { normalizeServicePaths, normalizeServices } from './utils/services.js';
-import { normalizeRoutePaths, normalizeRoutes } from './utils/routes.js';
+import { normalizeRouteHandlerPaths, normalizeRoutePaths, normalizeRoutes } from './utils/routes.js';
 import { mergeBundleConfig, mergeLockerConfig, mergeLwcConfig, mergeStaticGenerationConfig, trimLwrConfig, } from './utils/merge.js';
 import { normalizeLwcConfig, normalizeModulePaths } from './utils/lwc.js';
-import { parse } from 'jsonc-parser';
+import { getRuntimeEnvironment } from './runtime-config.js';
+import { getGlobalData } from './utils/global-data.js';
 /**
  * Load and validate the global config file.
  *
@@ -23,7 +26,7 @@ import { parse } from 'jsonc-parser';
  * @param {string} rootDir - the directory used to resolve `$rootDir`
  * @returns {LwrGlobalConfig | undefined} the validated config file contents if it exists
  */
-function getLwrConfigFromFile(rootDir, lwrConfigPath = DEFAULT_LWR_CONFIG_JSON) {
+export function getLwrConfigFromFile(rootDir, lwrConfigPath = DEFAULT_LWR_CONFIG_JSON) {
     const resolvedLwrConfigPath = path.resolve(normalizeDirectory(lwrConfigPath, rootDir));
     if (!fs.existsSync(resolvedLwrConfigPath)) {
         logger.warn(`LWR Config not found on "${resolvedLwrConfigPath}"`);
@@ -59,7 +62,7 @@ function createCacheFolder(cache, rootDir) {
  * @param {LwrGlobalConfig} configArg - programmatic global config
  * @returns {Required<LwrGlobalConfig>} a complete(but not normalized) global config
  */
-function loadConfig(configArg) {
+function mergeConfig(configArg) {
     // process programmatic config
     if (configArg) {
         // the programmatic config is trimmed to prevent overriding properties with an undefined value
@@ -110,15 +113,16 @@ function normalizeConfig(config) {
         lwc: normalizeLwcConfig(config.lwc),
         // normalize all services
         hooks: normalizeServices(config.hooks),
+        bundleProviders: normalizeServices(config.bundleProviders),
         moduleProviders: normalizeServices(config.moduleProviders),
         assetProviders: normalizeServices(config.assetProviders),
         assetTransformers: normalizeServices(config.assetTransformers),
         resourceProviders: normalizeServices(config.resourceProviders),
         viewProviders: normalizeServices(config.viewProviders),
         viewTransformers: normalizeServices(config.viewTransformers),
-        // normalize all routes
-        routes: normalizeRoutes(config.routes),
-        errorRoutes: normalizeRoutes(config.errorRoutes),
+        // normalize routes and capture all route handlers
+        routes: normalizeRoutes(config.routes, config.routeHandlers),
+        errorRoutes: normalizeRoutes(config.errorRoutes, config.routeHandlers),
     };
 }
 /**
@@ -160,6 +164,53 @@ function normalizeConfigPaths(config) {
         // normalize all route paths
         routes: normalizeRoutePaths(config.routes, resourcePaths),
         errorRoutes: normalizeRoutePaths(config.errorRoutes, resourcePaths),
+        routeHandlers: normalizeRouteHandlerPaths(config.routeHandlers, resourcePaths),
+    };
+}
+/**
+ * Add the SSR module provider and view transformer, if any route has `ssr` turned on.
+ *
+ * @param {NormalizedLwrGlobalConfig} config - a normalized global config to check / mutate
+ * @returns {NormalizedLwrGlobalConfig} an SSR-enabled normalized global config, if needed
+ */
+export function applySsrConfig(config) {
+    // check if any route has SSR turned on
+    const hasSSR = config.routes.some((r) => r.bootstrap.ssr);
+    if (!hasSSR) {
+        return config;
+    }
+    // add the SSR configuration, if it's not already there
+    // note: this is a noop when called from an onStart hook of an LWR@MRT app,
+    //       since the app has already been built / rolled up
+    const hasSsrModuleProvider = config.moduleProviders.some(([m]) => m === SSR_MODULE_PROVIDER);
+    const hasSsrViewTransformer = config.viewTransformers.some(([v]) => v === SSR_VIEW_TRANSFORM_PLUGIN);
+    return {
+        ...config,
+        moduleProviders: hasSsrModuleProvider
+            ? config.moduleProviders
+            : [[SSR_MODULE_PROVIDER, undefined], ...config.moduleProviders],
+        viewTransformers: hasSsrViewTransformer
+            ? config.viewTransformers
+            : [...config.viewTransformers, [SSR_VIEW_TRANSFORM_PLUGIN, undefined]],
+    };
+}
+/**
+ * Apply Static Providers for MRT runtime (used exclusively by buildServer)
+ *
+ * @param {NormalizedLwrGlobalConfig} config - a normalized global config to check / mutate
+ * @returns {NormalizedLwrGlobalConfig} an SSR-enabled normalized global config, if needed
+ */
+export function applyStaticProviderConfig(config) {
+    return {
+        ...config,
+        resourceProviders: [['@lwrjs/lambda/mrt-static-resource-provider', {}]],
+        moduleProviders: [['@lwrjs/lambda/mrt-static-module-provider', undefined]],
+        assetProviders: [['@lwrjs/lambda/mrt-static-asset-provider', undefined]],
+        bundleProviders: [
+            ['@lwrjs/lambda/mrt-static-bundle-provider', undefined],
+            ['@lwrjs/module-bundler/amd-runtime-bundle-provider', undefined],
+        ],
+        assetTransformers: [],
     };
 }
 /**
@@ -177,19 +228,45 @@ function normalizeConfigPaths(config) {
  * @param {ResolveConfigOptions} options - config resolution mutations
  * @returns {NormalizedLwrGlobalConfig} a normalized global config relative to the provided options
  */
-export function resolveConfig(configArg, options) {
-    const skipDirNormalization = options?.skipDirNormalization;
-    const skipCacheDirCreation = options?.skipDirNormalization;
-    const mergedConfig = loadConfig(configArg);
-    const normalizedConfig = normalizeConfig(mergedConfig);
+export function resolveGlobalConfig(configArg, options) {
+    const mergedConfig = mergeConfig(configArg);
+    let normalizedConfig = normalizeConfig(mergedConfig);
+    // Add static providers if applicable
+    if (options?.useStaticProviders) {
+        normalizedConfig = applyStaticProviderConfig(normalizedConfig);
+    }
+    // Add SSR config if applicable
+    normalizedConfig = applySsrConfig(normalizedConfig);
     // skip cache dir creation when the option is set
-    if (!skipCacheDirCreation) {
+    if (!options?.skipCacheDirCreation) {
         createCacheFolder(normalizedConfig.cacheDir, normalizedConfig.rootDir);
     }
     // skip dir normalization when the option is set
-    if (skipDirNormalization) {
+    if (options?.skipDirNormalization) {
         return normalizedConfig;
     }
     return normalizeConfigPaths(normalizedConfig);
 }
-//# sourceMappingURL=env-config.js.map
+/**
+ * Resolve all application configurations by loading and merging global data, applying config hooks, and
+ * importing configurable paths to javascript(ie. services and route handlers).
+ *
+ * @param {LwrGlobalConfig} config - programmatic global config
+ * @returns {Configurations} all of the fully resolved configurations
+ */
+export function loadConfig(config, options) {
+    const appConfig = resolveGlobalConfig(config, options);
+    const runtimeEnvironment = getRuntimeEnvironment(appConfig);
+    const globalData = getGlobalData(appConfig.globalDataDir, appConfig.globalData);
+    // ensure post config hook validation is ran even if config hooks don't exist
+    if (!appConfig.hooks.length) {
+        // route length validation happens in the `post` phase of validation
+        validateLwrAppConfig(appConfig, 'post');
+    }
+    return {
+        appConfig,
+        runtimeEnvironment,
+        globalData,
+    };
+}
+//# sourceMappingURL=global-config.js.map

package/build/es/hooks.d.ts

@@ -0,0 +1,32 @@
+import type { GlobalData, HooksPlugin, NormalizedLwrGlobalConfig, RuntimeEnvironment } from '@lwrjs/types';
+/**
+ * Run `initConfigs` hooks
+ *
+ * @remarks
+ * Route normalization and validation will be executed after all config hooks have been executed.
+ *
+ * @privateRemarks
+ * Changes to configurations are made by reference.
+ *
+ * @param hooks - hooks plugins
+ * @param globalConfig - global configuration
+ * @param runtimeEnvironment - runtime environment resolved from programmatic config and config file
+ * @param globalData - resolved global data
+ */
+export declare function executeConfigHooks(hooks: HooksPlugin[], globalConfig: NormalizedLwrGlobalConfig, runtimeEnvironment: RuntimeEnvironment, globalData: GlobalData, skipValidate?: boolean): Promise<void>;
+/**
+ * Run `onStart` hooks
+ *
+ * @remarks
+ * Route normalization and validation will be executed after all config hooks have been executed.
+ *
+ * @privateRemarks
+ * Changes to configurations are made by reference.
+ *
+ * These hooks can only modify the `routes` property in the global config.
+ *
+ * @param hooks - hooks plugins
+ * @param globalConfig - global configuration
+ */
+export declare function executeStartHooks(hooks: HooksPlugin[], globalConfig: NormalizedLwrGlobalConfig, skipValidate?: boolean): void;
+//# sourceMappingURL=hooks.d.ts.map

package/build/es/hooks.js

@@ -0,0 +1,70 @@
+import { normalizeRoutes } from './utils/routes.js';
+import { validateLwrAppConfig } from './validation/app-config.js';
+import { applySsrConfig } from './global-config.js';
+/**
+ * Run `initConfigs` hooks
+ *
+ * @remarks
+ * Route normalization and validation will be executed after all config hooks have been executed.
+ *
+ * @privateRemarks
+ * Changes to configurations are made by reference.
+ *
+ * @param hooks - hooks plugins
+ * @param globalConfig - global configuration
+ * @param runtimeEnvironment - runtime environment resolved from programmatic config and config file
+ * @param globalData - resolved global data
+ */
+export async function executeConfigHooks(hooks, globalConfig, runtimeEnvironment, globalData, skipValidate = false) {
+    if (!hooks.length) {
+        return;
+    }
+    for (const hook of hooks) {
+        if (!hook.initConfigs) {
+            continue;
+        }
+        // eslint-disable-next-line no-await-in-loop
+        await hook.initConfigs(globalConfig, globalData, runtimeEnvironment);
+    }
+    globalConfig.routes = normalizeRoutes(globalConfig.routes, globalConfig.routeHandlers);
+    globalConfig.errorRoutes = normalizeRoutes(globalConfig.errorRoutes, globalConfig.routeHandlers);
+    const ssrConfig = applySsrConfig(globalConfig);
+    globalConfig.moduleProviders = ssrConfig.moduleProviders;
+    globalConfig.viewTransformers = ssrConfig.viewTransformers;
+    if (!skipValidate) {
+        validateLwrAppConfig(globalConfig, 'post');
+    }
+}
+/**
+ * Run `onStart` hooks
+ *
+ * @remarks
+ * Route normalization and validation will be executed after all config hooks have been executed.
+ *
+ * @privateRemarks
+ * Changes to configurations are made by reference.
+ *
+ * These hooks can only modify the `routes` property in the global config.
+ *
+ * @param hooks - hooks plugins
+ * @param globalConfig - global configuration
+ */
+export function executeStartHooks(hooks, globalConfig, skipValidate = false) {
+    if (!hooks.length) {
+        return;
+    }
+    for (const hook of hooks) {
+        if (!hook.onStart) {
+            continue;
+        }
+        hook.onStart(globalConfig.routes);
+    }
+    globalConfig.routes = normalizeRoutes(globalConfig.routes, globalConfig.routeHandlers);
+    const ssrConfig = applySsrConfig(globalConfig);
+    globalConfig.moduleProviders = ssrConfig.moduleProviders;
+    globalConfig.viewTransformers = ssrConfig.viewTransformers;
+    if (!skipValidate) {
+        validateLwrAppConfig(globalConfig, 'post');
+    }
+}
+//# sourceMappingURL=hooks.js.map

package/build/es/index.d.ts

@@ -1,5 +1,6 @@
-import { resolveConfig as normalizeConfig } from './env-config.js';
-import { getServerModeConfig as explodeMode } from './runtime-config.js';
-import { validateLwrAppConfig } from './validation/app-config.js';
-export { normalizeConfig, explodeMode, validateLwrAppConfig };
+export { version as LWR_VERSION, lwcVersion as LWC_VERSION } from '@lwrjs/config/package';
+export { loadConfig, resolveGlobalConfig as normalizeConfig, getLwrConfigFromFile } from './global-config.js';
+export { getRuntimeEnvironment } from './runtime-config.js';
+export { executeConfigHooks, executeStartHooks } from './hooks.js';
+export { validateLwrAppConfig } from './validation/app-config.js';
 //# sourceMappingURL=index.d.ts.map

package/build/es/index.js

@@ -1,6 +1,6 @@
-import { resolveConfig as normalizeConfig } from './env-config.js';
-import { getServerModeConfig as explodeMode } from './runtime-config.js';
-import { validateLwrAppConfig } from './validation/app-config.js';
-// Only export the functions we utilize internally
-export { normalizeConfig, explodeMode, validateLwrAppConfig };
+export { version as LWR_VERSION, lwcVersion as LWC_VERSION } from '@lwrjs/config/package';
+export { loadConfig, resolveGlobalConfig as normalizeConfig, getLwrConfigFromFile } from './global-config.js';
+export { getRuntimeEnvironment } from './runtime-config.js';
+export { executeConfigHooks, executeStartHooks } from './hooks.js';
+export { validateLwrAppConfig } from './validation/app-config.js';
 //# sourceMappingURL=index.js.map