@lwrjs/config 0.9.0-alpha.8 → 0.9.0

package/build/cjs/defaults.cjs

@@ -26,7 +26,6 @@ __markAsModule(exports);
 __export(exports, {
   DEFAULT_AMD_LOADER: () => DEFAULT_AMD_LOADER,
   DEFAULT_AMD_LOADER_LEGACY: () => DEFAULT_AMD_LOADER_LEGACY,
-  DEFAULT_BUNDLE_EXCLUSIONS: () => DEFAULT_BUNDLE_EXCLUSIONS,
   DEFAULT_ESM_LOADER: () => DEFAULT_ESM_LOADER,
   DEFAULT_GENERATOR_CONFIG: () => DEFAULT_GENERATOR_CONFIG,
   DEFAULT_LWR_CONFIG: () => DEFAULT_LWR_CONFIG,
@@ -34,20 +33,27 @@ __export(exports, {
   DEFAULT_LWR_MODULES: () => DEFAULT_LWR_MODULES,
   DEFAULT_ROOT_DIR: () => DEFAULT_ROOT_DIR,
   DEFAULT_SERVICE_PACKAGE_NAME: () => DEFAULT_SERVICE_PACKAGE_NAME,
-  LWR_VERSION: () => LWR_VERSION
+  LWR_VERSION: () => LWR_VERSION,
+  SSR_MODULE_PROVIDER: () => SSR_MODULE_PROVIDER,
+  SSR_VIEW_TRANSFORM_PLUGIN: () => SSR_VIEW_TRANSFORM_PLUGIN,
+  getDefaultBundleConfig: () => getDefaultBundleConfig
 });
 var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
 var import_package = __toModule(require("@lwrjs/config/package"));
+var import_runtime_config = __toModule(require("./runtime-config.cjs"));
 var PORT = process.env.PORT ? parseInt(process.env.PORT, 10) : 3e3;
-var MODE = process.env.MODE || "dev";
+var MODE = process.env.MODE || "prod";
 var DEFAULT_BASE_PATH = "";
 var DEFAULT_API_VERSION = "1";
 var LWR_VERSION = import_package.version;
 var DEFAULT_SERVER_TYPE = "express";
 var DEFAULT_LWR_CONFIG_JSON = "$rootDir/lwr.config.json";
 var DEFAULT_GENERATOR_CONFIG = {
-  outputDir: "__generated_site__",
+  outputDir: "site",
   locales: ["en-US"],
+  skipCleanOutputDir: false,
+  skipBaseDocumentGeneration: false,
+  _additionalModules: [],
   _additionalRoutePaths: []
 };
 var DEFAULT_ROOT_DIR = process.cwd();
@@ -58,11 +64,11 @@ 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"
 ];
+var SSR_MODULE_PROVIDER = "@lwrjs/lwc-ssr/moduleProvider";
 var DEFAULT_RESOURCE_PROVIDERS = ["@lwrjs/loader"];
 var DEFAULT_VIEW_PROVIDERS = [
   "@lwrjs/nunjucks-view-provider",
@@ -70,10 +76,14 @@ 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_BUNDLE_PROVIDERS = [
+  "@lwrjs/module-bundler/amd-bundle-provider",
+  "@lwrjs/module-bundler/esm-bundle-provider"
+];
+var DEFAULT_VIEW_TRANSFORM_PLUGINS = ["@lwrjs/base-view-transformer"];
+var SSR_VIEW_TRANSFORM_PLUGIN = "@lwrjs/lwc-ssr/viewTransformer";
 var DEFAULT_ASSET_PROVIDERS = ["@lwrjs/fs-asset-provider"];
 var DEFAULT_ASSET_TRANSFORM_PLUGINS = ["@lwrjs/asset-transformer"];
-var DEFAULT_TEMPLATE_ENGINE = "@lwrjs/base-template-engine";
 var DEFAULT_AMD_LOADER = "lwr/loader";
 var DEFAULT_AMD_LOADER_LEGACY = "lwr/loaderLegacy";
 var DEFAULT_ESM_LOADER = "lwr/esmLoader";
@@ -86,13 +96,31 @@ var DEFAULT_LWR_MODULES = [
   {npm: "@lwrjs/router"},
   {npm: "@lwc/synthetic-shadow"}
 ];
-var DEFAULT_BUNDLE_EXCLUSIONS = [
+var DEFAULT_ESM_BUNDLE_EXCLUSIONS = [
   "lwc",
   "@lwc/synthetic-shadow",
   "lwr/navigation",
   "lwr/esmLoader",
   "lwr/profiler"
 ];
+var DEFAULT_AMD_BUNDLE_EXCLUSIONS = ["lwc", "lwr/navigation"];
+var DEFAULT_ESM_BUNDLE_EXTERNALS = {};
+var DEFAULT_AMD_BUNDLE_EXTERNALS = {
+  "lwr/loader": "lwr-loader-shim.bundle.min.js",
+  "lwr/profiler": "lwr-loader-shim.bundle.min.js"
+};
+var DEFAULT_AMD_LEGACY_BUNDLE_EXTERNALS = {
+  "lwr/loaderLegacy": "lwr-loader-shim-legacy.bundle.min.js",
+  "lwr/profiler": "lwr-loader-shim-legacy.bundle.min.js"
+};
+function getDefaultBundleConfig(mode) {
+  const format = (0, import_runtime_config.getServerModeConfig)(mode || MODE).format;
+  const loaderLegacy = (0, import_shared_utils.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
+  };
+}
 var DEFAULT_LWR_CONFIG = {
   port: PORT,
   ignoreLwrConfigFile: false,
@@ -101,6 +129,7 @@ var 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,
@@ -111,16 +140,17 @@ var 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: import_shared_utils.DEFAULT_LWR_LOCKER_CONFIG
 };

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

@@ -21,28 +21,38 @@ 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
+  applySsrConfig: () => applySsrConfig,
+  applyStaticProviderConfig: () => applyStaticProviderConfig,
+  getLwrConfigFromFile: () => getLwrConfigFromFile,
+  loadConfig: () => loadConfig,
+  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_defaults2 = __toModule(require("./defaults.cjs"));
 var import_app_config = __toModule(require("./validation/app-config.cjs"));
 var import_assets = __toModule(require("./utils/assets.cjs"));
 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"));
-function getLwrConfigFromFile(rootDir, lwrConfigPath = import_defaults.DEFAULT_LWR_CONFIG_JSON) {
+var import_runtime_config = __toModule(require("./runtime-config.cjs"));
+var import_global_data = __toModule(require("./utils/global-data.cjs"));
+function getLwrConfigFromFile(rootDir, lwrConfigPath = import_defaults2.DEFAULT_LWR_CONFIG_JSON) {
   const resolvedLwrConfigPath = import_path.default.resolve((0, import_shared_utils.normalizeDirectory)(lwrConfigPath, rootDir));
   if (!import_fs.default.existsSync(resolvedLwrConfigPath)) {
     import_shared_utils.logger.warn(`LWR Config not found on "${resolvedLwrConfigPath}"`);
     return void 0;
   }
-  return (0, import_app_config.validateLwrAppConfig)((0, import_shared_utils.readFile)(resolvedLwrConfigPath), "file");
+  const configSource = (0, import_shared_utils.readFile)(resolvedLwrConfigPath);
+  (0, import_app_config.validateLwrAppConfig)(configSource, "file");
+  return (0, import_jsonc_parser.parse)(configSource);
 }
 function createCacheFolder(cache, rootDir) {
   const cacheDir = (0, import_shared_utils.normalizeDirectory)(cache, rootDir);
@@ -50,15 +60,15 @@ 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)(JSON.stringify(configArg), "pre");
+    (0, import_app_config.validateLwrAppConfig)(configArg, "pre");
   }
-  const rootDir = import_path.default.resolve(configArg?.rootDir || import_defaults.DEFAULT_ROOT_DIR);
+  const rootDir = import_path.default.resolve(configArg?.rootDir || import_defaults2.DEFAULT_ROOT_DIR);
   const configFile = !configArg?.ignoreLwrConfigFile ? getLwrConfigFromFile(rootDir, configArg?.lwrConfigFile) : void 0;
   return {
-    ...import_defaults.DEFAULT_LWR_CONFIG,
+    ...import_defaults2.DEFAULT_LWR_CONFIG,
     ...configFile,
     ...configArg,
     lwc: (0, import_merge.mergeLwcConfig)(configFile, configArg),
@@ -69,27 +79,28 @@ function loadConfig(configArg) {
   };
 }
 function normalizeConfig(config) {
-  const amdLoader = (0, import_shared_utils.getFeatureFlags)().LEGACY_LOADER ? import_defaults.DEFAULT_AMD_LOADER_LEGACY : import_defaults.DEFAULT_AMD_LOADER;
+  const amdLoader = (0, import_shared_utils.getFeatureFlags)().LEGACY_LOADER ? import_defaults2.DEFAULT_AMD_LOADER_LEGACY : import_defaults2.DEFAULT_AMD_LOADER;
   return {
     ...config,
     amdLoader,
-    esmLoader: import_defaults.DEFAULT_ESM_LOADER,
-    lwrVersion: import_defaults.LWR_VERSION,
+    esmLoader: import_defaults2.DEFAULT_ESM_LOADER,
+    lwrVersion: import_defaults2.LWR_VERSION,
     assets: (0, import_assets.normalizeAssets)(config.assets),
     lwc: (0, import_lwc.normalizeLwcConfig)(config.lwc),
     hooks: (0, import_services.normalizeServices)(config.hooks),
+    bundleProviders: (0, import_services.normalizeServices)(config.bundleProviders),
     moduleProviders: (0, import_services.normalizeServices)(config.moduleProviders),
     assetProviders: (0, import_services.normalizeServices)(config.assetProviders),
     assetTransformers: (0, import_services.normalizeServices)(config.assetTransformers),
     resourceProviders: (0, import_services.normalizeServices)(config.resourceProviders),
     viewProviders: (0, import_services.normalizeServices)(config.viewProviders),
     viewTransformers: (0, import_services.normalizeServices)(config.viewTransformers),
-    routes: (0, import_routes.normalizeRoutes)(config.routes),
-    errorRoutes: (0, import_routes.normalizeRoutes)(config.errorRoutes)
+    routes: (0, import_routes.normalizeRoutes)(config.routes, config.routeHandlers),
+    errorRoutes: (0, import_routes.normalizeRoutes)(config.errorRoutes, config.routeHandlers)
   };
 }
 function normalizeConfigPaths(config) {
-  const rootDir = config.rootDir || import_defaults.DEFAULT_ROOT_DIR;
+  const rootDir = config.rootDir || import_defaults2.DEFAULT_ROOT_DIR;
   const resourcePaths = {
     rootDir,
     assets: (0, import_assets.normalizeAssetPaths)(config.assets, rootDir),
@@ -114,19 +125,61 @@ function normalizeConfigPaths(config) {
     viewProviders: (0, import_services.normalizeServicePaths)(config.viewProviders, rootDir),
     viewTransformers: (0, import_services.normalizeServicePaths)(config.viewTransformers, rootDir),
     routes: (0, import_routes.normalizeRoutePaths)(config.routes, resourcePaths),
-    errorRoutes: (0, import_routes.normalizeRoutePaths)(config.errorRoutes, resourcePaths)
+    errorRoutes: (0, import_routes.normalizeRoutePaths)(config.errorRoutes, resourcePaths),
+    routeHandlers: (0, import_routes.normalizeRouteHandlerPaths)(config.routeHandlers, resourcePaths)
   };
 }
-function resolveConfig(configArg, options) {
-  const skipDirNormalization = options?.skipDirNormalization;
-  const skipCacheDirCreation = options?.skipDirNormalization;
-  const mergedConfig = loadConfig(configArg);
-  const normalizedConfig = normalizeConfig(mergedConfig);
-  if (!skipCacheDirCreation) {
+function applySsrConfig(config) {
+  const hasSSR = config.routes.some((r) => r.bootstrap.ssr);
+  if (!hasSSR) {
+    return config;
+  }
+  const hasSsrModuleProvider = config.moduleProviders.some(([m]) => m === import_defaults.SSR_MODULE_PROVIDER);
+  const hasSsrViewTransformer = config.viewTransformers.some(([v]) => v === import_defaults.SSR_VIEW_TRANSFORM_PLUGIN);
+  return {
+    ...config,
+    moduleProviders: hasSsrModuleProvider ? config.moduleProviders : [[import_defaults.SSR_MODULE_PROVIDER, void 0], ...config.moduleProviders],
+    viewTransformers: hasSsrViewTransformer ? config.viewTransformers : [...config.viewTransformers, [import_defaults.SSR_VIEW_TRANSFORM_PLUGIN, void 0]]
+  };
+}
+function applyStaticProviderConfig(config) {
+  return {
+    ...config,
+    resourceProviders: [["@lwrjs/lambda/mrt-static-resource-provider", {}]],
+    moduleProviders: [["@lwrjs/lambda/mrt-static-module-provider", void 0]],
+    assetProviders: [["@lwrjs/lambda/mrt-static-asset-provider", void 0]],
+    bundleProviders: [
+      ["@lwrjs/lambda/mrt-static-bundle-provider", void 0],
+      ["@lwrjs/module-bundler/amd-runtime-bundle-provider", void 0]
+    ],
+    assetTransformers: []
+  };
+}
+function resolveGlobalConfig(configArg, options) {
+  const mergedConfig = mergeConfig(configArg);
+  let normalizedConfig = normalizeConfig(mergedConfig);
+  if (options?.useStaticProviders) {
+    normalizedConfig = applyStaticProviderConfig(normalizedConfig);
+  }
+  normalizedConfig = applySsrConfig(normalizedConfig);
+  if (!options?.skipCacheDirCreation) {
     createCacheFolder(normalizedConfig.cacheDir, normalizedConfig.rootDir);
   }
-  if (skipDirNormalization) {
+  if (options?.skipDirNormalization) {
     return normalizedConfig;
   }
   return normalizeConfigPaths(normalizedConfig);
 }
+function loadConfig(config, options) {
+  const appConfig = resolveGlobalConfig(config, options);
+  const runtimeEnvironment = (0, import_runtime_config.getRuntimeEnvironment)(appConfig);
+  const globalData = (0, import_global_data.getGlobalData)(appConfig.globalDataDir, appConfig.globalData);
+  if (!appConfig.hooks.length) {
+    (0, import_app_config.validateLwrAppConfig)(appConfig, "post");
+  }
+  return {
+    appConfig,
+    runtimeEnvironment,
+    globalData
+  };
+}

package/build/cjs/hooks.cjs

@@ -0,0 +1,69 @@
+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/hooks.ts
+__markAsModule(exports);
+__export(exports, {
+  executeConfigHooks: () => executeConfigHooks,
+  executeStartHooks: () => executeStartHooks
+});
+var import_routes = __toModule(require("./utils/routes.cjs"));
+var import_app_config = __toModule(require("./validation/app-config.cjs"));
+var import_global_config = __toModule(require("./global-config.cjs"));
+async function executeConfigHooks(hooks, globalConfig, runtimeEnvironment, globalData, skipValidate = false) {
+  if (!hooks.length) {
+    return;
+  }
+  for (const hook of hooks) {
+    if (!hook.initConfigs) {
+      continue;
+    }
+    await hook.initConfigs(globalConfig, globalData, runtimeEnvironment);
+  }
+  globalConfig.routes = (0, import_routes.normalizeRoutes)(globalConfig.routes, globalConfig.routeHandlers);
+  globalConfig.errorRoutes = (0, import_routes.normalizeRoutes)(globalConfig.errorRoutes, globalConfig.routeHandlers);
+  const ssrConfig = (0, import_global_config.applySsrConfig)(globalConfig);
+  globalConfig.moduleProviders = ssrConfig.moduleProviders;
+  globalConfig.viewTransformers = ssrConfig.viewTransformers;
+  if (!skipValidate) {
+    (0, import_app_config.validateLwrAppConfig)(globalConfig, "post");
+  }
+}
+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 = (0, import_routes.normalizeRoutes)(globalConfig.routes, globalConfig.routeHandlers);
+  const ssrConfig = (0, import_global_config.applySsrConfig)(globalConfig);
+  globalConfig.moduleProviders = ssrConfig.moduleProviders;
+  globalConfig.viewTransformers = ssrConfig.viewTransformers;
+  if (!skipValidate) {
+    (0, import_app_config.validateLwrAppConfig)(globalConfig, "post");
+  }
+}

package/build/cjs/index.cjs

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

package/build/cjs/modules.cjs

@@ -0,0 +1,92 @@
+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/modules.ts
+__markAsModule(exports);
+__export(exports, {
+  loadHooks: () => loadHooks,
+  loadRouteHandlers: () => loadRouteHandlers,
+  loadServices: () => loadServices
+});
+var import_path = __toModule(require("path"));
+var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
+var import_typescript = __toModule(require("@lwrjs/shared-utils/typescript"));
+async function importModule(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_typescript.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}`);
+  }
+}
+async function loadServiceEntries(entries, rootDir, cacheDir) {
+  return Promise.all(entries.map(async ([entry, config]) => {
+    const ctor = await importModule(entry, rootDir, import_path.default.join(cacheDir, "services"));
+    return [ctor, config];
+  }));
+}
+async function loadHooks(config) {
+  if (!config.hooks) {
+    return [];
+  }
+  const hookCtors = await loadServiceEntries(config.hooks, config.rootDir, config.cacheDir);
+  const hooks = hookCtors.map(([hookCtor, hookConfig = {}]) => {
+    return new hookCtor(hookConfig);
+  });
+  return hooks;
+}
+async function loadServices(config) {
+  const moduleProviders = await loadServiceEntries(config.moduleProviders, config.rootDir, config.cacheDir);
+  const bundleProviders = await loadServiceEntries(config.bundleProviders, 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,
+    bundleProviders,
+    assetProviders,
+    assetTransformers,
+    resourceProviders,
+    viewProviders,
+    viewTransformers
+  };
+}
+async function loadRouteHandlers(config) {
+  const routeHandlers = {};
+  await Promise.all(Object.keys(config.routeHandlers).map(async (id) => {
+    const handlerPath = config.routeHandlers[id];
+    const handler = await importModule(handlerPath, config.rootDir, import_path.default.join(config.cacheDir, "routeHandlers"));
+    routeHandlers[id] = handler;
+  }));
+  return routeHandlers;
+}

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,23 @@ 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, minify} = config;
+  const serverModeConfig = getServerModeConfig(config.serverMode);
+  return {
+    ...serverModeConfig,
+    minify: minify !== null ? minify : serverModeConfig.minify,
+    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,18 +53,22 @@ 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 mode = config2?.serverMode || config1?.serverMode;
+  const DEFAULT_BUNDLE_CONFIG = (0, import_defaults.getDefaultBundleConfig)(mode);
+  const defaultExclusions = config2?.bundleConfig?.UNSAFE_lwrDefaultExclude || config1?.bundleConfig?.UNSAFE_lwrDefaultExclude || DEFAULT_BUNDLE_CONFIG.exclude || [];
+  const configExclusions = config2?.bundleConfig?.exclude || config1?.bundleConfig?.exclude || [];
+  const configExternals = config2?.bundleConfig?.external || config1?.bundleConfig?.external || {};
   return {
-    ...jsonConfig?.bundleConfig,
-    ...config?.bundleConfig,
-    exclude: [...new Set([...defaultExclusions, ...configExclusions])]
+    ...config1?.bundleConfig,
+    ...config2?.bundleConfig,
+    exclude: [...new Set([...defaultExclusions, ...configExclusions])],
+    external: {...DEFAULT_BUNDLE_CONFIG.external, ...configExternals}
   };
 }
 function mergeLockerConfig(jsonConfig, config) {
@@ -74,9 +82,15 @@ function mergeLockerConfig(jsonConfig, config) {
   };
 }
 function mergeStaticGenerationConfig(configFile, configArg) {
+  const fileAdditionalModules = configFile?.staticSiteGenerator?._additionalModules || [];
+  const argAdditionalModules = configArg?.staticSiteGenerator?._additionalModules || [];
+  const fileAdditionalPaths = configFile?.staticSiteGenerator?._additionalRoutePaths || [];
+  const argAdditionalPaths = configArg?.staticSiteGenerator?._additionalRoutePaths || [];
   return {
     ...import_defaults.DEFAULT_GENERATOR_CONFIG,
     ...configFile?.staticSiteGenerator,
-    ...configArg?.staticSiteGenerator
+    ...configArg?.staticSiteGenerator,
+    _additionalModules: [...new Set([...fileAdditionalModules, ...argAdditionalModules])],
+    _additionalRoutePaths: [...new Set([...fileAdditionalPaths, ...argAdditionalPaths])]
   };
 }