@lwrjs/config 0.9.0-alpha.11 → 0.9.0-alpha.13

package/build/cjs/defaults.cjs

@@ -48,6 +48,7 @@ var DEFAULT_LWR_CONFIG_JSON = "$rootDir/lwr.config.json";
 var DEFAULT_GENERATOR_CONFIG = {
   outputDir: "__generated_site__",
   locales: ["en-US"],
+  skipCleanOutputDir: false,
   skipBaseDocumentGeneration: false,
   _additionalRoutePaths: []
 };
@@ -59,7 +60,6 @@ var DEFAULT_LAYOUTS_DIR = "$rootDir/src/layouts";
 var DEFAULT_DATA_DIR = "$rootDir/src/data";
 var DEFAULT_MODULE_PROVIDERS = [
   "@lwrjs/app-service/moduleProvider",
-  "@lwrjs/lwc-ssr/moduleProvider",
   "@lwrjs/router/module-provider",
   "@lwrjs/lwc-module-provider",
   "@lwrjs/npm-module-provider"
@@ -71,7 +71,7 @@ var DEFAULT_VIEW_PROVIDERS = [
   "@lwrjs/markdown-view-provider",
   "@lwrjs/base-view-provider"
 ];
-var DEFAULT_VIEW_TRANSFORM_PLUGINS = ["@lwrjs/base-view-transformer", "@lwrjs/lwc-ssr/viewTransformer"];
+var DEFAULT_VIEW_TRANSFORM_PLUGINS = ["@lwrjs/base-view-transformer"];
 var DEFAULT_ASSET_PROVIDERS = ["@lwrjs/fs-asset-provider"];
 var DEFAULT_ASSET_TRANSFORM_PLUGINS = ["@lwrjs/asset-transformer"];
 var DEFAULT_AMD_LOADER = "lwr/loader";

package/build/cjs/{env-config.cjs → global-config.cjs}

@@ -21,13 +21,17 @@ 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/config/src/env-config.ts
+// packages/@lwrjs/config/src/global-config.ts
 __markAsModule(exports);
 __export(exports, {
-  resolveConfig: () => resolveConfig
+  loadConfig: () => loadConfig,
+  loadRoutes: () => loadRoutes,
+  loadServices: () => loadServices,
+  resolveGlobalConfig: () => resolveGlobalConfig
 });
 var import_fs = __toModule(require("fs"));
 var import_path = __toModule(require("path"));
+var import_jsonc_parser = __toModule(require("jsonc-parser"));
 var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
 var import_defaults = __toModule(require("./defaults.cjs"));
 var import_app_config = __toModule(require("./validation/app-config.cjs"));
@@ -36,7 +40,8 @@ var import_services = __toModule(require("./utils/services.cjs"));
 var import_routes = __toModule(require("./utils/routes.cjs"));
 var import_merge = __toModule(require("./utils/merge.cjs"));
 var import_lwc = __toModule(require("./utils/lwc.cjs"));
-var import_jsonc_parser = __toModule(require("jsonc-parser"));
+var import_runtime_config = __toModule(require("./runtime-config.cjs"));
+var import_global_data = __toModule(require("./utils/global-data.cjs"));
 function getLwrConfigFromFile(rootDir, lwrConfigPath = import_defaults.DEFAULT_LWR_CONFIG_JSON) {
   const resolvedLwrConfigPath = import_path.default.resolve((0, import_shared_utils.normalizeDirectory)(lwrConfigPath, rootDir));
   if (!import_fs.default.existsSync(resolvedLwrConfigPath)) {
@@ -53,7 +58,7 @@ function createCacheFolder(cache, rootDir) {
   import_fs.default.mkdirSync(import_path.default.join(absPath, import_shared_utils.ASSETS_CACHE_DIR), {recursive: true});
   return absPath;
 }
-function loadConfig(configArg) {
+function mergeConfig(configArg) {
   if (configArg) {
     configArg = (0, import_merge.trimLwrConfig)(configArg);
     (0, import_app_config.validateLwrAppConfig)(configArg, "pre");
@@ -120,10 +125,19 @@ function normalizeConfigPaths(config) {
     errorRoutes: (0, import_routes.normalizeRoutePaths)(config.errorRoutes, resourcePaths)
   };
 }
-function resolveConfig(configArg, options) {
+async function applyConfigHooks(globalConfig, runtimeEnvironment, globalData) {
+  const hooks = await (0, import_services.loadServiceEntries)(globalConfig.hooks, globalConfig.rootDir, globalConfig.cacheDir);
+  for (const [hook, hookConfig = {}] of hooks) {
+    await new hook(hookConfig).initConfigs(globalConfig, globalData, runtimeEnvironment);
+  }
+  globalConfig.routes = (0, import_routes.normalizeRoutes)(globalConfig.routes);
+  globalConfig.errorRoutes = (0, import_routes.normalizeRoutes)(globalConfig.errorRoutes);
+  (0, import_app_config.validateLwrAppConfig)(JSON.stringify(globalConfig), "post");
+}
+function resolveGlobalConfig(configArg, options) {
   const skipDirNormalization = options?.skipDirNormalization;
   const skipCacheDirCreation = options?.skipDirNormalization;
-  const mergedConfig = loadConfig(configArg);
+  const mergedConfig = mergeConfig(configArg);
   const normalizedConfig = normalizeConfig(mergedConfig);
   if (!skipCacheDirCreation) {
     createCacheFolder(normalizedConfig.cacheDir, normalizedConfig.rootDir);
@@ -133,3 +147,38 @@ function resolveConfig(configArg, options) {
   }
   return normalizeConfigPaths(normalizedConfig);
 }
+async function loadConfig(config, options) {
+  const globalConfig = await resolveGlobalConfig(config, options);
+  const runtimeEnvironment = (0, import_runtime_config.getRuntimeEnvironment)(globalConfig);
+  const globalData = await (0, import_global_data.getGlobalData)(globalConfig.globalDataDir, globalConfig.globalData);
+  await applyConfigHooks(globalConfig, runtimeEnvironment, globalData);
+  return {
+    appConfig: globalConfig,
+    runtimeEnvironment,
+    globalData
+  };
+}
+async function loadServices(config) {
+  const moduleProviders = await (0, import_services.loadServiceEntries)(config.moduleProviders, config.rootDir, config.cacheDir);
+  const assetProviders = await (0, import_services.loadServiceEntries)(config.assetProviders, config.rootDir, config.cacheDir);
+  const assetTransformers = await (0, import_services.loadServiceEntries)(config.assetTransformers, config.rootDir, config.cacheDir);
+  const resourceProviders = await (0, import_services.loadServiceEntries)(config.resourceProviders, config.rootDir, config.cacheDir);
+  const viewProviders = await (0, import_services.loadServiceEntries)(config.viewProviders, config.rootDir, config.cacheDir);
+  const viewTransformers = await (0, import_services.loadServiceEntries)(config.viewTransformers, config.rootDir, config.cacheDir);
+  return {
+    moduleProviders,
+    assetProviders,
+    assetTransformers,
+    resourceProviders,
+    viewProviders,
+    viewTransformers
+  };
+}
+async function loadRoutes(config) {
+  const routes = await (0, import_routes.loadRouteHandlers)(config.routes, config.rootDir, config.cacheDir);
+  const errorRoutes = await (0, import_routes.loadRouteHandlers)(config.errorRoutes, config.rootDir, config.cacheDir);
+  return {
+    routes,
+    errorRoutes
+  };
+}

package/build/cjs/index.cjs

@@ -24,10 +24,13 @@ var __toModule = (module2) => {
 // packages/@lwrjs/config/src/index.ts
 __markAsModule(exports);
 __export(exports, {
-  explodeMode: () => import_runtime_config.getServerModeConfig,
-  normalizeConfig: () => import_env_config.resolveConfig,
-  validateLwrAppConfig: () => import_app_config.validateLwrAppConfig
+  LWR_VERSION: () => import_package.version,
+  getRuntimeEnvironment: () => import_runtime_config.getRuntimeEnvironment,
+  loadConfig: () => import_global_config.loadConfig,
+  loadRoutes: () => import_global_config.loadRoutes,
+  loadServices: () => import_global_config.loadServices,
+  normalizeConfig: () => import_global_config.resolveGlobalConfig
 });
-var import_env_config = __toModule(require("./env-config.cjs"));
+var import_global_config = __toModule(require("./global-config.cjs"));
 var import_runtime_config = __toModule(require("./runtime-config.cjs"));
-var import_app_config = __toModule(require("./validation/app-config.cjs"));
+var import_package = __toModule(require("@lwrjs/config/package"));

package/build/cjs/runtime-config.cjs

@@ -25,15 +25,18 @@ var __toModule = (module2) => {
 __markAsModule(exports);
 __export(exports, {
   RUNTIME_CONFIGS: () => RUNTIME_CONFIGS,
+  getRuntimeEnvironment: () => getRuntimeEnvironment,
   getServerModeConfig: () => getServerModeConfig
 });
 var import_diagnostics = __toModule(require("@lwrjs/diagnostics"));
+var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
 var RUNTIME_CONFIGS = {
   dev: {
     bundle: false,
     minify: false,
     format: "esm",
     compat: "0",
+    debug: false,
     watchFiles: true,
     defaultLocale: "en_US",
     hmrEnabled: true,
@@ -47,6 +50,7 @@ var RUNTIME_CONFIGS = {
     minify: true,
     format: "esm",
     compat: "0",
+    debug: false,
     watchFiles: false,
     defaultLocale: "en_US",
     hmrEnabled: false,
@@ -60,6 +64,7 @@ var RUNTIME_CONFIGS = {
     minify: false,
     format: "amd",
     compat: "1",
+    debug: false,
     watchFiles: true,
     defaultLocale: "en_US",
     hmrEnabled: false,
@@ -73,6 +78,7 @@ var RUNTIME_CONFIGS = {
     minify: true,
     format: "amd",
     compat: "1",
+    debug: false,
     watchFiles: false,
     defaultLocale: "en_US",
     hmrEnabled: false,
@@ -82,10 +88,21 @@ var RUNTIME_CONFIGS = {
     }
   }
 };
-function getServerModeConfig(mode) {
-  const selectedMode = RUNTIME_CONFIGS[mode];
+function getServerModeConfig(serverMode) {
+  const selectedMode = RUNTIME_CONFIGS[serverMode];
   if (!selectedMode) {
-    throw (0, import_diagnostics.createSingleDiagnosticError)({description: import_diagnostics.descriptions.SERVER.INVALID_MODE(mode)}, import_diagnostics.LwrServerError);
+    throw (0, import_diagnostics.createSingleDiagnosticError)({description: import_diagnostics.descriptions.SERVER.INVALID_MODE(serverMode)}, import_diagnostics.LwrServerError);
   }
   return selectedMode;
 }
+function getRuntimeEnvironment(config) {
+  const {serverMode, lwrVersion, apiVersion, basePath} = config;
+  return {
+    ...getServerModeConfig(config.serverMode),
+    featureFlags: (0, import_shared_utils.getFeatureFlags)(),
+    serverMode,
+    lwrVersion,
+    apiVersion,
+    basePath
+  };
+}

package/build/cjs/utils/global-data.cjs

@@ -0,0 +1,54 @@
+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/config/src/utils/global-data.ts
+__markAsModule(exports);
+__export(exports, {
+  getGlobalData: () => getGlobalData
+});
+var import_fs = __toModule(require("fs"));
+var import_path = __toModule(require("path"));
+function recursiveJsonCollector(resources, currentPath, collector) {
+  for (const resource of resources) {
+    const resourcePath = import_path.default.join(currentPath, resource);
+    if (resource.endsWith(".json")) {
+      const resourceName = import_path.default.basename(resource, ".json");
+      const jsonSource = JSON.parse(import_fs.default.readFileSync(resourcePath, "utf-8"));
+      collector[resourceName] = jsonSource;
+    } else if (import_fs.default.statSync(resourcePath).isDirectory()) {
+      const dirContentList = import_fs.default.readdirSync(resourcePath);
+      collector[resource] = recursiveJsonCollector(dirContentList, resourcePath, {});
+    }
+  }
+  return collector;
+}
+function getGlobalData(globalDataDir, defaultData = {}) {
+  if (!import_fs.default.existsSync(globalDataDir) || !import_fs.default.statSync(globalDataDir).isDirectory()) {
+    return defaultData;
+  }
+  const dirContentList = import_fs.default.readdirSync(globalDataDir);
+  return {
+    ...recursiveJsonCollector(dirContentList, globalDataDir, {}),
+    ...defaultData
+  };
+}

package/build/cjs/utils/merge.cjs

@@ -32,6 +32,9 @@ __export(exports, {
 });
 var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
 var import_defaults = __toModule(require("../defaults.cjs"));
+function isNormalizedLwrGlobalConfig(config) {
+  return config?.lwrVersion !== void 0;
+}
 function trimLwrConfig(config) {
   Object.keys(config).forEach((k) => {
     if (config[k] === void 0)
@@ -40,6 +43,7 @@ function trimLwrConfig(config) {
   return config;
 }
 function mergeLwcConfig(config1, config2) {
+  const defaultModules = !isNormalizedLwrGlobalConfig(config1) && !isNormalizedLwrGlobalConfig(config2) ? import_defaults.DEFAULT_LWR_MODULES : [];
   const modules1 = config1?.lwc?.modules || [];
   const modules2 = config2?.lwc?.modules || [];
   const interchangeable1 = config1?.lwc?.interchangeable || [];
@@ -49,17 +53,17 @@ function mergeLwcConfig(config1, config2) {
   const interchangeableModules2 = config2?.lwc?.interchangeableModules || [];
   const mergedInterchangeableModules = [...interchangeableModules1, ...interchangeableModules2];
   return {
-    modules: [...import_defaults.DEFAULT_LWR_MODULES, ...modules1, ...modules2],
+    modules: [...defaultModules, ...modules1, ...modules2],
     interchangeable: mergedInterchangeable.length ? mergedInterchangeable : void 0,
     interchangeableModules: mergedInterchangeableModules.length ? mergedInterchangeableModules : void 0
   };
 }
-function mergeBundleConfig(jsonConfig, config) {
-  const defaultExclusions = config?.bundleConfig?.UNSAFE_lwrDefaultExclude || jsonConfig?.bundleConfig?.UNSAFE_lwrDefaultExclude || import_defaults.DEFAULT_BUNDLE_EXCLUSIONS;
-  const configExclusions = config?.bundleConfig?.exclude || jsonConfig?.bundleConfig?.exclude || [];
+function mergeBundleConfig(config1, config2) {
+  const defaultExclusions = config2?.bundleConfig?.UNSAFE_lwrDefaultExclude || config1?.bundleConfig?.UNSAFE_lwrDefaultExclude || import_defaults.DEFAULT_BUNDLE_EXCLUSIONS;
+  const configExclusions = config2?.bundleConfig?.exclude || config1?.bundleConfig?.exclude || [];
   return {
-    ...jsonConfig?.bundleConfig,
-    ...config?.bundleConfig,
+    ...config1?.bundleConfig,
+    ...config2?.bundleConfig,
     exclude: [...new Set([...defaultExclusions, ...configExclusions])]
   };
 }

package/build/cjs/utils/module-loader.cjs

@@ -0,0 +1,45 @@
+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/config/src/utils/module-loader.ts
+__markAsModule(exports);
+__export(exports, {
+  loadModule: () => loadModule
+});
+var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
+async function loadModule(filepath, rootDir, cacheDir) {
+  let resolvedFilePath = (0, import_shared_utils.normalizeDirectory)(filepath, rootDir);
+  const resolvedCacheDir = (0, import_shared_utils.normalizeDirectory)(cacheDir, rootDir);
+  try {
+    if (resolvedFilePath.endsWith(".ts")) {
+      const fullPath = (0, import_shared_utils.resolveFileExtension)(resolvedFilePath);
+      resolvedFilePath = await (0, import_shared_utils.transpileTs)(fullPath, {rootDir, cacheDir: resolvedCacheDir});
+    }
+    const moduleEntry = await Promise.resolve().then(() => __toModule(require(resolvedFilePath)));
+    const output = moduleEntry.default || moduleEntry;
+    return output;
+  } catch (err) {
+    console.log(err);
+    throw new Error(`Unable to load configurable module: ${filepath}`);
+  }
+}

package/build/cjs/utils/routes.cjs

@@ -24,11 +24,13 @@ var __toModule = (module2) => {
 // packages/@lwrjs/config/src/utils/routes.ts
 __markAsModule(exports);
 __export(exports, {
+  loadRouteHandlers: () => loadRouteHandlers,
   normalizeRoutePaths: () => normalizeRoutePaths,
   normalizeRoutes: () => normalizeRoutes
 });
 var import_path = __toModule(require("path"));
 var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
+var import_module_loader = __toModule(require("./module-loader.cjs"));
 function normalizeRoutes(routes = []) {
   return routes.map((route) => ({
     ...route,
@@ -48,3 +50,23 @@ function normalizeRoutePaths(routes = [], resourcePaths) {
     return route;
   });
 }
+async function loadRouteHandlers(routes, rootDir, cacheDir) {
+  const cache = {};
+  return Promise.all(routes.map(async (route) => {
+    if (!route.routeHandler) {
+      return route;
+    }
+    if (cache[route.routeHandler]) {
+      return {
+        ...route,
+        routeHandler: cache[route.routeHandler]
+      };
+    }
+    const routeHandler = await (0, import_module_loader.loadModule)(route.routeHandler, rootDir, import_path.default.join(cacheDir, "routeHandlers"));
+    cache[route.routeHandler] = routeHandler;
+    return {
+      ...route,
+      routeHandler
+    };
+  }));
+}

package/build/cjs/utils/services.cjs

@@ -24,12 +24,14 @@ var __toModule = (module2) => {
 // packages/@lwrjs/config/src/utils/services.ts
 __markAsModule(exports);
 __export(exports, {
+  loadServiceEntries: () => loadServiceEntries,
   normalizeServicePaths: () => normalizeServicePaths,
   normalizeServices: () => normalizeServices
 });
 var import_path = __toModule(require("path"));
 var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
 var import_defaults = __toModule(require("../defaults.cjs"));
+var import_module_loader = __toModule(require("./module-loader.cjs"));
 function normalizeServices(services = []) {
   return services.map((service) => Array.isArray(service) ? service : [service, void 0]);
 }
@@ -43,3 +45,9 @@ function normalizeServicePaths(services, rootDir) {
     return [serviceName, serviceConfig];
   });
 }
+async function loadServiceEntries(entries, rootDir, cacheDir) {
+  return Promise.all(entries.map(async ([entry, config]) => {
+    const ctor = await (0, import_module_loader.loadModule)(entry, rootDir, import_path.default.join(cacheDir, "services"));
+    return [ctor, config];
+  }));
+}

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

@@ -68,9 +68,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}]`;
@@ -143,7 +145,7 @@ 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);
   validateAssets((0, import_jsonc_parser.findNodeAtLocation)(node, ["assets"]), validationContext, preMerge);
   validateLocker((0, import_jsonc_parser.findNodeAtLocation)(node, ["locker"]), validationContext);

package/build/es/defaults.d.ts

@@ -4,6 +4,7 @@ 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;
     _additionalRoutePaths: never[];
 };

package/build/es/defaults.js

@@ -10,6 +10,7 @@ export const DEFAULT_LWR_CONFIG_JSON = '$rootDir/lwr.config.json';
 export const DEFAULT_GENERATOR_CONFIG = {
     outputDir: '__generated_site__',
     locales: ['en-US'],
+    skipCleanOutputDir: false,
     skipBaseDocumentGeneration: false,
     _additionalRoutePaths: [],
 };
@@ -23,7 +24,6 @@ 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',
@@ -35,7 +35,7 @@ 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_VIEW_TRANSFORM_PLUGINS = ['@lwrjs/base-view-transformer'];
 const DEFAULT_ASSET_PROVIDERS = ['@lwrjs/fs-asset-provider'];
 const DEFAULT_ASSET_TRANSFORM_PLUGINS = ['@lwrjs/asset-transformer'];
 export const DEFAULT_AMD_LOADER = 'lwr/loader';

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

@@ -0,0 +1,53 @@
+import type { GlobalData, LwrGlobalConfig, NormalizedLwrGlobalConfig, RuntimeEnvironment, NormalizedLwrRoute, NormalizedLwrErrorRoute, Services, Route } from '@lwrjs/types';
+export interface ResolveConfigOptions {
+    skipDirNormalization?: boolean;
+    skipCacheDirCreation?: boolean;
+}
+export interface Configurations {
+    appConfig: NormalizedLwrGlobalConfig;
+    runtimeEnvironment: RuntimeEnvironment;
+    globalData: GlobalData;
+}
+export interface Routes {
+    routes: Route<NormalizedLwrRoute>[];
+    errorRoutes: Route<NormalizedLwrErrorRoute>[];
+}
+/**
+ * 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): Promise<Configurations>;
+/**
+ * Load service modules from the filepaths configured in the global config
+ *
+ * @param config - global config
+ * @returns {Services} all of the imported service constructors
+ */
+export declare function loadServices(config: NormalizedLwrGlobalConfig): Promise<Services>;
+/**
+ * Load all route handlers from the filepaths configured in the global config
+ *
+ * @param config - global config
+ * @returns {Routes} all routes with resolved route handlers
+ */
+export declare function loadRoutes(config: NormalizedLwrGlobalConfig): Promise<Routes>;
+//# sourceMappingURL=global-config.d.ts.map

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

@@ -1,14 +1,16 @@
 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 { 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 { loadServiceEntries, normalizeServicePaths, normalizeServices } from './utils/services.js';
+import { loadRouteHandlers, 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.
  *
@@ -59,7 +61,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
@@ -162,6 +164,16 @@ function normalizeConfigPaths(config) {
         errorRoutes: normalizeRoutePaths(config.errorRoutes, resourcePaths),
     };
 }
+async function applyConfigHooks(globalConfig, runtimeEnvironment, globalData) {
+    const hooks = await loadServiceEntries(globalConfig.hooks, globalConfig.rootDir, globalConfig.cacheDir);
+    for (const [hook, hookConfig = {}] of hooks) {
+        // eslint-disable-next-line no-await-in-loop
+        await new hook(hookConfig).initConfigs(globalConfig, globalData, runtimeEnvironment);
+    }
+    globalConfig.routes = normalizeRoutes(globalConfig.routes);
+    globalConfig.errorRoutes = normalizeRoutes(globalConfig.errorRoutes);
+    validateLwrAppConfig(JSON.stringify(globalConfig), 'post');
+}
 /**
  * Load, merge, and normalize all of the config sources.
  *
@@ -177,10 +189,10 @@ 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) {
+export function resolveGlobalConfig(configArg, options) {
     const skipDirNormalization = options?.skipDirNormalization;
     const skipCacheDirCreation = options?.skipDirNormalization;
-    const mergedConfig = loadConfig(configArg);
+    const mergedConfig = mergeConfig(configArg);
     const normalizedConfig = normalizeConfig(mergedConfig);
     // skip cache dir creation when the option is set
     if (!skipCacheDirCreation) {
@@ -192,4 +204,58 @@ export function resolveConfig(configArg, options) {
     }
     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 async function loadConfig(config, options) {
+    const globalConfig = await resolveGlobalConfig(config, options);
+    const runtimeEnvironment = getRuntimeEnvironment(globalConfig);
+    const globalData = await getGlobalData(globalConfig.globalDataDir, globalConfig.globalData);
+    await applyConfigHooks(globalConfig, runtimeEnvironment, globalData);
+    return {
+        appConfig: globalConfig,
+        runtimeEnvironment: runtimeEnvironment,
+        globalData: globalData,
+    };
+}
+/**
+ * Load service modules from the filepaths configured in the global config
+ *
+ * @param config - global config
+ * @returns {Services} all of the imported service constructors
+ */
+export async function loadServices(config) {
+    const moduleProviders = await loadServiceEntries(config.moduleProviders, config.rootDir, config.cacheDir);
+    const assetProviders = await loadServiceEntries(config.assetProviders, config.rootDir, config.cacheDir);
+    const assetTransformers = await loadServiceEntries(config.assetTransformers, config.rootDir, config.cacheDir);
+    const resourceProviders = await loadServiceEntries(config.resourceProviders, config.rootDir, config.cacheDir);
+    const viewProviders = await loadServiceEntries(config.viewProviders, config.rootDir, config.cacheDir);
+    const viewTransformers = await loadServiceEntries(config.viewTransformers, config.rootDir, config.cacheDir);
+    return {
+        moduleProviders,
+        assetProviders,
+        assetTransformers,
+        resourceProviders,
+        viewProviders,
+        viewTransformers,
+    };
+}
+/**
+ * Load all route handlers from the filepaths configured in the global config
+ *
+ * @param config - global config
+ * @returns {Routes} all routes with resolved route handlers
+ */
+export async function loadRoutes(config) {
+    const routes = await loadRouteHandlers(config.routes, config.rootDir, config.cacheDir);
+    const errorRoutes = await loadRouteHandlers(config.errorRoutes, config.rootDir, config.cacheDir);
+    return {
+        routes,
+        errorRoutes,
+    };
+}
+//# sourceMappingURL=global-config.js.map

package/build/es/index.d.ts

@@ -1,5 +1,5 @@
-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 };
+import { resolveGlobalConfig as normalizeConfig, loadConfig, loadRoutes, loadServices } from './global-config.js';
+import { getRuntimeEnvironment } from './runtime-config.js';
+export { version as LWR_VERSION } from '@lwrjs/config/package';
+export { normalizeConfig, loadConfig, loadRoutes, loadServices, getRuntimeEnvironment };
 //# 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';
+import { resolveGlobalConfig as normalizeConfig, loadConfig, loadRoutes, loadServices, } from './global-config.js';
+import { getRuntimeEnvironment } from './runtime-config.js';
+export { version as LWR_VERSION } from '@lwrjs/config/package';
 // Only export the functions we utilize internally
-export { normalizeConfig, explodeMode, validateLwrAppConfig };
+export { normalizeConfig, loadConfig, loadRoutes, loadServices, getRuntimeEnvironment };
 //# sourceMappingURL=index.js.map

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

@@ -1,12 +1,19 @@
-import { ServerModeConfig } from '@lwrjs/types';
+import type { ServerModeConfig, NormalizedLwrGlobalConfig, RuntimeEnvironment } from '@lwrjs/types';
 export declare const RUNTIME_CONFIGS: Record<string, ServerModeConfig>;
 /**
- * Get the runtime environment config for the mode.
+ * Get server mode config by name
  *
  * @throws {LwrServerError} Mode must be supported by LWR.
  *
- * @param {string} mode - the name of the server mode
- * @returns {ServerModeConfig} the runtime environment config for the mode
+ * @param {string} serverMode - the name of the server mode
+ * @returns {ServerModeConfig} the server mode config
  */
-export declare function getServerModeConfig(mode: string): ServerModeConfig;
+export declare function getServerModeConfig(serverMode: string): ServerModeConfig;
+/**
+ * Get runtime environment
+ *
+ * @param {NormalizedLwrGlobalConfig} config - the normalized global config object
+ * @returns {RuntimeEnvironment} the complete runtime environment
+ */
+export declare function getRuntimeEnvironment(config: NormalizedLwrGlobalConfig): RuntimeEnvironment;
 //# sourceMappingURL=runtime-config.d.ts.map

package/build/es/runtime-config.js

@@ -1,10 +1,12 @@
 import { createSingleDiagnosticError, descriptions, LwrServerError } from '@lwrjs/diagnostics';
+import { getFeatureFlags } from '@lwrjs/shared-utils';
 export const RUNTIME_CONFIGS = {
     dev: {
         bundle: false,
         minify: false,
         format: 'esm',
         compat: '0',
+        debug: false,
         watchFiles: true,
         defaultLocale: 'en_US',
         hmrEnabled: true,
@@ -18,6 +20,7 @@ export const RUNTIME_CONFIGS = {
         minify: true,
         format: 'esm',
         compat: '0',
+        debug: false,
         watchFiles: false,
         defaultLocale: 'en_US',
         hmrEnabled: false,
@@ -31,6 +34,7 @@ export const RUNTIME_CONFIGS = {
         minify: false,
         format: 'amd',
         compat: '1',
+        debug: false,
         watchFiles: true,
         defaultLocale: 'en_US',
         hmrEnabled: false,
@@ -44,6 +48,7 @@ export const RUNTIME_CONFIGS = {
         minify: true,
         format: 'amd',
         compat: '1',
+        debug: false,
         watchFiles: false,
         defaultLocale: 'en_US',
         hmrEnabled: false,
@@ -54,18 +59,35 @@ export const RUNTIME_CONFIGS = {
     },
 };
 /**
- * Get the runtime environment config for the mode.
+ * Get server mode config by name
  *
  * @throws {LwrServerError} Mode must be supported by LWR.
  *
- * @param {string} mode - the name of the server mode
- * @returns {ServerModeConfig} the runtime environment config for the mode
+ * @param {string} serverMode - the name of the server mode
+ * @returns {ServerModeConfig} the server mode config
  */
-export function getServerModeConfig(mode) {
-    const selectedMode = RUNTIME_CONFIGS[mode];
+export function getServerModeConfig(serverMode) {
+    const selectedMode = RUNTIME_CONFIGS[serverMode];
     if (!selectedMode) {
-        throw createSingleDiagnosticError({ description: descriptions.SERVER.INVALID_MODE(mode) }, LwrServerError);
+        throw createSingleDiagnosticError({ description: descriptions.SERVER.INVALID_MODE(serverMode) }, LwrServerError);
     }
     return selectedMode;
 }
+/**
+ * Get runtime environment
+ *
+ * @param {NormalizedLwrGlobalConfig} config - the normalized global config object
+ * @returns {RuntimeEnvironment} the complete runtime environment
+ */
+export function getRuntimeEnvironment(config) {
+    const { serverMode, lwrVersion, apiVersion, basePath } = config;
+    return {
+        ...getServerModeConfig(config.serverMode),
+        featureFlags: getFeatureFlags(),
+        serverMode,
+        lwrVersion,
+        apiVersion,
+        basePath,
+    };
+}
 //# sourceMappingURL=runtime-config.js.map

package/build/es/utils/global-data.d.ts

@@ -0,0 +1,3 @@
+import { GlobalData } from '@lwrjs/types';
+export declare function getGlobalData(globalDataDir: string, defaultData?: GlobalData): GlobalData;
+//# sourceMappingURL=global-data.d.ts.map

package/build/es/utils/global-data.js

@@ -0,0 +1,29 @@
+import fs from 'fs';
+import path from 'path';
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function recursiveJsonCollector(resources, currentPath, collector) {
+    for (const resource of resources) {
+        const resourcePath = path.join(currentPath, resource);
+        if (resource.endsWith('.json')) {
+            const resourceName = path.basename(resource, '.json');
+            const jsonSource = JSON.parse(fs.readFileSync(resourcePath, 'utf-8'));
+            collector[resourceName] = jsonSource;
+        }
+        else if (fs.statSync(resourcePath).isDirectory()) {
+            const dirContentList = fs.readdirSync(resourcePath);
+            collector[resource] = recursiveJsonCollector(dirContentList, resourcePath, {});
+        }
+    }
+    return collector;
+}
+export function getGlobalData(globalDataDir, defaultData = {}) {
+    if (!fs.existsSync(globalDataDir) || !fs.statSync(globalDataDir).isDirectory()) {
+        return defaultData;
+    }
+    const dirContentList = fs.readdirSync(globalDataDir);
+    return {
+        ...recursiveJsonCollector(dirContentList, globalDataDir, {}),
+        ...defaultData,
+    };
+}
+//# sourceMappingURL=global-data.js.map

package/build/es/utils/merge.d.ts

@@ -1,7 +1,7 @@
 import type { BundleConfig, LwcConfig, LwrGlobalConfig, LwrLockerConfig, StaticSiteGenerator } from '@lwrjs/types';
 export declare function trimLwrConfig(config: LwrGlobalConfig): LwrGlobalConfig;
 export declare function mergeLwcConfig(config1: LwrGlobalConfig | undefined, config2: LwrGlobalConfig | undefined): LwcConfig;
-export declare function mergeBundleConfig(jsonConfig: LwrGlobalConfig | undefined, config: LwrGlobalConfig | undefined): BundleConfig;
+export declare function mergeBundleConfig(config1: LwrGlobalConfig | undefined, config2: LwrGlobalConfig | undefined): BundleConfig;
 export declare function mergeLockerConfig(jsonConfig: LwrGlobalConfig | undefined, config: LwrGlobalConfig | undefined): LwrLockerConfig;
 export declare function mergeStaticGenerationConfig(configFile?: LwrGlobalConfig, configArg?: LwrGlobalConfig): StaticSiteGenerator;
 //# sourceMappingURL=merge.d.ts.map

package/build/es/utils/merge.js

@@ -1,5 +1,8 @@
 import { DEFAULT_LOCKER_TRUSTED_CMP, DEFAULT_LWR_LOCKER_CONFIG } from '@lwrjs/shared-utils';
 import { DEFAULT_BUNDLE_EXCLUSIONS, DEFAULT_GENERATOR_CONFIG, DEFAULT_LWR_MODULES } from '../defaults.js';
+function isNormalizedLwrGlobalConfig(config) {
+    return config?.lwrVersion !== undefined;
+}
 export function trimLwrConfig(config) {
     Object.keys(config).forEach((k) => {
         if (config[k] === undefined)
@@ -9,6 +12,10 @@ export function trimLwrConfig(config) {
 }
 // deep merge LWC configs
 export function mergeLwcConfig(config1, config2) {
+    // normalized config already contains the defaults
+    const defaultModules = !isNormalizedLwrGlobalConfig(config1) && !isNormalizedLwrGlobalConfig(config2)
+        ? DEFAULT_LWR_MODULES
+        : [];
     const modules1 = config1?.lwc?.modules || [];
     const modules2 = config2?.lwc?.modules || [];
     const interchangeable1 = config1?.lwc?.interchangeable || [];
@@ -18,7 +25,7 @@ export function mergeLwcConfig(config1, config2) {
     const interchangeableModules2 = config2?.lwc?.interchangeableModules || [];
     const mergedInterchangeableModules = [...interchangeableModules1, ...interchangeableModules2];
     return {
-        modules: [...DEFAULT_LWR_MODULES, ...modules1, ...modules2],
+        modules: [...defaultModules, ...modules1, ...modules2],
         interchangeable: mergedInterchangeable.length ? mergedInterchangeable : undefined,
         interchangeableModules: mergedInterchangeableModules.length
             ? mergedInterchangeableModules
@@ -26,14 +33,14 @@ export function mergeLwcConfig(config1, config2) {
     };
 }
 // merge default bundle exclusions with any bundle exclusions specified in config
-export function mergeBundleConfig(jsonConfig, config) {
-    const defaultExclusions = config?.bundleConfig?.UNSAFE_lwrDefaultExclude ||
-        jsonConfig?.bundleConfig?.UNSAFE_lwrDefaultExclude ||
+export function mergeBundleConfig(config1, config2) {
+    const defaultExclusions = config2?.bundleConfig?.UNSAFE_lwrDefaultExclude ||
+        config1?.bundleConfig?.UNSAFE_lwrDefaultExclude ||
         DEFAULT_BUNDLE_EXCLUSIONS;
-    const configExclusions = config?.bundleConfig?.exclude || jsonConfig?.bundleConfig?.exclude || [];
+    const configExclusions = config2?.bundleConfig?.exclude || config1?.bundleConfig?.exclude || [];
     return {
-        ...jsonConfig?.bundleConfig,
-        ...config?.bundleConfig,
+        ...config1?.bundleConfig,
+        ...config2?.bundleConfig,
         exclude: [...new Set([...defaultExclusions, ...configExclusions])],
     };
 }

package/build/es/utils/module-loader.d.ts

@@ -0,0 +1,2 @@
+export declare function loadModule<T>(filepath: string, rootDir: string, cacheDir: string): Promise<T>;
+//# sourceMappingURL=module-loader.d.ts.map

package/build/es/utils/module-loader.js

@@ -0,0 +1,20 @@
+import { normalizeDirectory, resolveFileExtension, transpileTs } from '@lwrjs/shared-utils';
+export async function loadModule(filepath, rootDir, cacheDir) {
+    // ensure paths are fully resolved before loading source
+    let resolvedFilePath = normalizeDirectory(filepath, rootDir);
+    const resolvedCacheDir = normalizeDirectory(cacheDir, rootDir);
+    try {
+        if (resolvedFilePath.endsWith('.ts')) {
+            const fullPath = resolveFileExtension(resolvedFilePath);
+            resolvedFilePath = await transpileTs(fullPath, { rootDir, cacheDir: resolvedCacheDir });
+        }
+        const moduleEntry = await import(resolvedFilePath);
+        const output = moduleEntry.default || moduleEntry;
+        return output;
+    }
+    catch (err) {
+        console.log(err);
+        throw new Error(`Unable to load configurable module: ${filepath}`);
+    }
+}
+//# sourceMappingURL=module-loader.js.map

package/build/es/utils/routes.d.ts

@@ -1,7 +1,8 @@
-import type { LwrErrorRoute, LwrRoute, NormalizedLwrErrorRoute, NormalizedLwrRoute, ResourcePaths } from '@lwrjs/types';
+import type { LwrErrorRoute, LwrRoute, NormalizedLwrErrorRoute, NormalizedLwrRoute, ResourcePaths, Route } from '@lwrjs/types';
 declare type ViewOrErrorRoute = LwrRoute | LwrErrorRoute;
 declare type NormalizedRoute<T extends ViewOrErrorRoute> = T extends LwrRoute ? NormalizedLwrRoute : NormalizedLwrErrorRoute;
 export declare function normalizeRoutes<T extends ViewOrErrorRoute>(routes?: T[]): NormalizedRoute<T>[];
 export declare function normalizeRoutePaths<T extends ViewOrErrorRoute>(routes: T[] | undefined, resourcePaths: ResourcePaths): NormalizedRoute<T>[];
+export declare function loadRouteHandlers<T extends ViewOrErrorRoute>(routes: T[], rootDir: string, cacheDir: string): Promise<Route<T>[]>;
 export {};
 //# sourceMappingURL=routes.d.ts.map

package/build/es/utils/routes.js

@@ -1,5 +1,6 @@
 import path from 'path';
 import { DEFAULT_LWR_BOOTSTRAP_CONFIG, normalizeDirectory, normalizeResourcePath } from '@lwrjs/shared-utils';
+import { loadModule } from './module-loader.js';
 export function normalizeRoutes(routes = []) {
     return routes.map((route) => ({
         ...route,
@@ -22,4 +23,24 @@ export function normalizeRoutePaths(routes = [], resourcePaths) {
         return route;
     });
 }
+export async function loadRouteHandlers(routes, rootDir, cacheDir) {
+    const cache = {};
+    return Promise.all(routes.map(async (route) => {
+        if (!route.routeHandler) {
+            return route;
+        }
+        if (cache[route.routeHandler]) {
+            return {
+                ...route,
+                routeHandler: cache[route.routeHandler],
+            };
+        }
+        const routeHandler = await loadModule(route.routeHandler, rootDir, path.join(cacheDir, 'routeHandlers'));
+        cache[route.routeHandler] = routeHandler;
+        return {
+            ...route,
+            routeHandler,
+        };
+    }));
+}
 //# sourceMappingURL=routes.js.map

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

@@ -1,4 +1,5 @@
-import type { ServiceConfig, ServiceEntry } from '@lwrjs/types';
+import type { LwrService, ServiceConfig, ServiceEntry, ResolvedServiceEntry } from '@lwrjs/types';
 export declare function normalizeServices(services?: ServiceConfig[]): ServiceEntry[];
 export declare function normalizeServicePaths(services: ServiceConfig[], rootDir: string): ServiceEntry[];
+export declare function loadServiceEntries<T extends LwrService>(entries: ServiceEntry[], rootDir: string, cacheDir: string): Promise<ResolvedServiceEntry<T>[]>;
 //# sourceMappingURL=services.d.ts.map

package/build/es/utils/services.js

@@ -1,6 +1,7 @@
 import path from 'path';
 import { normalizeDirectory } from '@lwrjs/shared-utils';
 import { DEFAULT_SERVICE_PACKAGE_NAME } from '../defaults.js';
+import { loadModule } from './module-loader.js';
 export function normalizeServices(services = []) {
     return services.map((service) => (Array.isArray(service) ? service : [service, undefined]));
 }
@@ -16,4 +17,10 @@ export function normalizeServicePaths(services, rootDir) {
         return [serviceName, serviceConfig];
     });
 }
+export async function loadServiceEntries(entries, rootDir, cacheDir) {
+    return Promise.all(entries.map(async ([entry, config]) => {
+        const ctor = await loadModule(entry, rootDir, path.join(cacheDir, 'services'));
+        return [ctor, config];
+    }));
+}
 //# sourceMappingURL=services.js.map

package/build/es/validation/app-config.js

@@ -68,9 +68,12 @@ function validateRouteCommon(node, validationContext, propPrefix) {
  *      - path: required path segment string
  *      - method: optional 'get' | 'post'
  */
-function validateRoutes(node, validationContext) {
+function validateRoutes(node, validationContext, preMerge) {
     if (node) {
-        validationContext.assertNotEmptyArray(node, 'routes');
+        // routes may not be defined until after config hooks are applied
+        if (!preMerge) {
+            validationContext.assertNotEmptyArray(node, 'routes');
+        }
         if (node.children) {
             node.children.forEach((n, index) => {
                 const propPrefix = `routes[${index}]`;
@@ -191,7 +194,7 @@ function validateRoot(node, validationContext, preMerge) {
     const routes = findNode(node, ['routes']);
     const errorRoutes = findNode(node, ['errorRoutes']);
     validationContext.assertUniqueIds([...(routes?.children || []), ...(errorRoutes?.children || [])], 'routes');
-    validateRoutes(routes, validationContext);
+    validateRoutes(routes, validationContext, preMerge);
     validateErrorRoutes(errorRoutes, validationContext);
     validateAssets(findNode(node, ['assets']), validationContext, preMerge);
     validateLocker(findNode(node, ['locker']), validationContext);

package/package.cjs

@@ -1,7 +1,13 @@
 const fs = require('fs');
 const path = require('path');
 const rootPath = path.join(__dirname, './');
-const version = JSON.parse(fs.readFileSync(path.join(rootPath, 'package.json'), 'utf-8')).version;
+
+let version;
+if (globalThis.LWR_VERSION) {
+    version = globalThis.LWR_VERSION;
+} else {
+    version = JSON.parse(fs.readFileSync(path.join(rootPath, 'package.json'), 'utf-8')).version;
+}
 
 module.exports = {
     rootPath,

package/package.json

@@ -4,7 +4,7 @@
     "publishConfig": {
         "access": "public"
     },
-    "version": "0.9.0-alpha.11",
+    "version": "0.9.0-alpha.13",
     "homepage": "https://developer.salesforce.com/docs/platform/lwr/overview",
     "repository": {
         "type": "git",
@@ -32,16 +32,16 @@
         "package.cjs"
     ],
     "dependencies": {
-        "@lwrjs/diagnostics": "0.9.0-alpha.11",
-        "@lwrjs/shared-utils": "0.9.0-alpha.11",
+        "@lwrjs/diagnostics": "0.9.0-alpha.13",
+        "@lwrjs/shared-utils": "0.9.0-alpha.13",
         "fs-extra": "^10.1.0",
         "jsonc-parser": "^3.0.0"
     },
     "devDependencies": {
-        "@lwrjs/types": "0.9.0-alpha.11"
+        "@lwrjs/types": "0.9.0-alpha.13"
     },
     "engines": {
         "node": ">=14.15.4 <19"
     },
-    "gitHead": "3cb1275b364ae7373c1868c79e6082a122dbef9c"
+    "gitHead": "fa30915a685f6e8c5c2895d0c053d59145780123"
 }

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

@@ -1,22 +0,0 @@
-import type { LwrGlobalConfig, NormalizedLwrGlobalConfig } from '@lwrjs/types';
-export interface ResolveConfigOptions {
-    skipDirNormalization?: boolean;
-    skipCacheDirCreation?: boolean;
-}
-/**
- * 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 resolveConfig(configArg?: LwrGlobalConfig, options?: ResolveConfigOptions): NormalizedLwrGlobalConfig;
-//# sourceMappingURL=env-config.d.ts.map