@lwrjs/config 0.9.0-alpha.15 → 0.9.0-alpha.17

package/build/cjs/defaults.cjs

@@ -64,10 +64,6 @@ var DEFAULT_MODULE_PROVIDERS = [
   "@lwrjs/lwc-module-provider",
   "@lwrjs/npm-module-provider"
 ];
-var DEFAULT_BUNDLE_PROVIDERS = [
-  "@lwrjs/module-bundler/amd-bundle-provider",
-  "@lwrjs/module-bundler/esm-bundle-provider"
-];
 var DEFAULT_RESOURCE_PROVIDERS = ["@lwrjs/loader"];
 var DEFAULT_VIEW_PROVIDERS = [
   "@lwrjs/nunjucks-view-provider",
@@ -95,8 +91,7 @@ var DEFAULT_BUNDLE_EXCLUSIONS = [
   "@lwc/synthetic-shadow",
   "lwr/navigation",
   "lwr/esmLoader",
-  "lwr/profiler",
-  "lwc_ssr_placeholder"
+  "lwr/profiler"
 ];
 var DEFAULT_LWR_CONFIG = {
   port: PORT,
@@ -117,7 +112,6 @@ var DEFAULT_LWR_CONFIG = {
   globalData: {},
   hooks: [],
   moduleProviders: DEFAULT_MODULE_PROVIDERS,
-  bundleProviders: DEFAULT_BUNDLE_PROVIDERS,
   resourceProviders: DEFAULT_RESOURCE_PROVIDERS,
   viewProviders: DEFAULT_VIEW_PROVIDERS,
   viewTransformers: DEFAULT_VIEW_TRANSFORM_PLUGINS,

package/build/cjs/global-config.cjs

@@ -25,8 +25,6 @@ var __toModule = (module2) => {
 __markAsModule(exports);
 __export(exports, {
   loadConfig: () => loadConfig,
-  loadRoutes: () => loadRoutes,
-  loadServices: () => loadServices,
   resolveGlobalConfig: () => resolveGlobalConfig
 });
 var import_fs = __toModule(require("fs"));
@@ -87,7 +85,6 @@ function normalizeConfig(config) {
     lwc: (0, import_lwc.normalizeLwcConfig)(config.lwc),
     hooks: (0, import_services.normalizeServices)(config.hooks),
     moduleProviders: (0, import_services.normalizeServices)(config.moduleProviders),
-    bundleProviders: (0, import_services.normalizeServices)(config.bundleProviders),
     assetProviders: (0, import_services.normalizeServices)(config.assetProviders),
     assetTransformers: (0, import_services.normalizeServices)(config.assetTransformers),
     resourceProviders: (0, import_services.normalizeServices)(config.resourceProviders),
@@ -117,7 +114,6 @@ function normalizeConfigPaths(config) {
     },
     hooks: (0, import_services.normalizeServicePaths)(config.hooks, rootDir),
     moduleProviders: (0, import_services.normalizeServicePaths)(config.moduleProviders, rootDir),
-    bundleProviders: (0, import_services.normalizeServicePaths)(config.bundleProviders, rootDir),
     assetProviders: (0, import_services.normalizeServicePaths)(config.assetProviders, rootDir),
     assetTransformers: (0, import_services.normalizeServicePaths)(config.assetTransformers, rootDir),
     resourceProviders: (0, import_services.normalizeServicePaths)(config.resourceProviders, rootDir),
@@ -127,15 +123,6 @@ function normalizeConfigPaths(config) {
     errorRoutes: (0, import_routes.normalizeRoutePaths)(config.errorRoutes, resourcePaths)
   };
 }
-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;
@@ -149,40 +136,16 @@ function resolveGlobalConfig(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);
+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: globalConfig,
+    appConfig,
     runtimeEnvironment,
     globalData
   };
 }
-async function loadServices(config) {
-  const moduleProviders = await (0, import_services.loadServiceEntries)(config.moduleProviders, config.rootDir, config.cacheDir);
-  const bundleProviders = await (0, import_services.loadServiceEntries)(config.bundleProviders, 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,
-    bundleProviders,
-    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/{utils/module-loader.cjs → hooks.cjs}

@@ -21,26 +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/utils/module-loader.ts
+// packages/@lwrjs/config/src/hooks.ts
 __markAsModule(exports);
 __export(exports, {
-  loadModule: () => loadModule
+  executeConfigHooks: () => executeConfigHooks,
+  executeStartHooks: () => executeStartHooks
 });
-var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
-var import_typescript = __toModule(require("@lwrjs/shared-utils/typescript"));
-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_typescript.transpileTs)(fullPath, {rootDir, cacheDir: resolvedCacheDir});
+var import_routes = __toModule(require("./utils/routes.cjs"));
+var import_app_config = __toModule(require("./validation/app-config.cjs"));
+async function executeConfigHooks(hooks, globalConfig, runtimeEnvironment, globalData) {
+  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.errorRoutes = (0, import_routes.normalizeRoutes)(globalConfig.errorRoutes);
+  (0, import_app_config.validateLwrAppConfig)(globalConfig, "post");
+}
+function executeStartHooks(hooks, globalConfig) {
+  if (!hooks.length) {
+    return;
+  }
+  for (const hook of hooks) {
+    if (!hook.onStart) {
+      continue;
     }
-    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}`);
+    hook.onStart(globalConfig.routes);
   }
+  globalConfig.routes = (0, import_routes.normalizeRoutes)(globalConfig.routes);
+  (0, import_app_config.validateLwrAppConfig)(globalConfig, "post");
 }

package/build/cjs/index.cjs

@@ -25,12 +25,13 @@ var __toModule = (module2) => {
 __markAsModule(exports);
 __export(exports, {
   LWR_VERSION: () => import_package.version,
+  executeConfigHooks: () => import_hooks.executeConfigHooks,
+  executeStartHooks: () => import_hooks.executeStartHooks,
   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_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_package = __toModule(require("@lwrjs/config/package"));
+var import_hooks = __toModule(require("./hooks.cjs"));

package/build/cjs/modules.cjs

@@ -0,0 +1,115 @@
+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,
+  loadRoutes: () => loadRoutes,
+  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"));
+var BUNDLE_PROVIDERS = [
+  ["@lwrjs/module-bundler/amd-bundle-provider", void 0],
+  ["@lwrjs/module-bundler/esm-bundle-provider", void 0]
+];
+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 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 importModule(route.routeHandler, rootDir, import_path.default.join(cacheDir, "routeHandlers"));
+    cache[route.routeHandler] = routeHandler;
+    return {
+      ...route,
+      routeHandler
+    };
+  }));
+}
+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(BUNDLE_PROVIDERS, 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 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
+  };
+}

package/build/cjs/utils/routes.cjs

@@ -24,13 +24,11 @@ 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,
@@ -50,23 +48,3 @@ 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,14 +24,12 @@ 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]);
 }
@@ -45,9 +43,3 @@ 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-context.cjs

@@ -47,7 +47,6 @@ var ROOT_ATTRIBUTE_KEYS = createKeys("root", [
   "assetProviders",
   "assetTransformers",
   "bundleConfig",
-  "bundleProviders",
   "cacheDir",
   "contentDir",
   "environment",

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

@@ -164,7 +164,6 @@ function validateRoot(node, validationContext, preMerge) {
   validationContext.assertNotEmptyString((0, import_jsonc_parser.findNodeAtLocation)(node, ["globalDataDir"]), "globalDataDir");
   validationContext.assertArrayOfServices((0, import_jsonc_parser.findNodeAtLocation)(node, ["hooks"]), "hooks");
   validationContext.assertArrayOfServices((0, import_jsonc_parser.findNodeAtLocation)(node, ["moduleProviders"]), "moduleProviders");
-  validationContext.assertArrayOfServices((0, import_jsonc_parser.findNodeAtLocation)(node, ["bundleProviders"]), "bundleProviders");
   validationContext.assertArrayOfServices((0, import_jsonc_parser.findNodeAtLocation)(node, ["viewProviders"]), "viewProviders");
   validationContext.assertArrayOfServices((0, import_jsonc_parser.findNodeAtLocation)(node, ["resourceProviders"]), "resourceProviders");
   validationContext.assertArrayOfServices((0, import_jsonc_parser.findNodeAtLocation)(node, ["assetProviders"]), "assetProviders");

package/build/es/defaults.js

@@ -28,10 +28,6 @@ const DEFAULT_MODULE_PROVIDERS = [
     '@lwrjs/lwc-module-provider',
     '@lwrjs/npm-module-provider',
 ];
-const DEFAULT_BUNDLE_PROVIDERS = [
-    '@lwrjs/module-bundler/amd-bundle-provider',
-    '@lwrjs/module-bundler/esm-bundle-provider',
-];
 const DEFAULT_RESOURCE_PROVIDERS = ['@lwrjs/loader'];
 const DEFAULT_VIEW_PROVIDERS = [
     '@lwrjs/nunjucks-view-provider',
@@ -60,7 +56,6 @@ export const DEFAULT_BUNDLE_EXCLUSIONS = [
     'lwr/navigation',
     'lwr/esmLoader',
     'lwr/profiler',
-    'lwc_ssr_placeholder',
 ];
 export const DEFAULT_LWR_CONFIG = {
     port: PORT,
@@ -81,7 +76,6 @@ export const DEFAULT_LWR_CONFIG = {
     globalData: {},
     hooks: [],
     moduleProviders: DEFAULT_MODULE_PROVIDERS,
-    bundleProviders: DEFAULT_BUNDLE_PROVIDERS,
     resourceProviders: DEFAULT_RESOURCE_PROVIDERS,
     viewProviders: DEFAULT_VIEW_PROVIDERS,
     viewTransformers: DEFAULT_VIEW_TRANSFORM_PLUGINS,

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

@@ -1,4 +1,4 @@
-import type { GlobalData, LwrGlobalConfig, NormalizedLwrGlobalConfig, RuntimeEnvironment, NormalizedLwrRoute, NormalizedLwrErrorRoute, Services, Route } from '@lwrjs/types';
+import type { GlobalData, LwrGlobalConfig, NormalizedLwrGlobalConfig, RuntimeEnvironment } from '@lwrjs/types';
 export interface ResolveConfigOptions {
     skipDirNormalization?: boolean;
     skipCacheDirCreation?: boolean;
@@ -8,10 +8,6 @@ export interface Configurations {
     runtimeEnvironment: RuntimeEnvironment;
     globalData: GlobalData;
 }
-export interface Routes {
-    routes: Route<NormalizedLwrRoute>[];
-    errorRoutes: Route<NormalizedLwrErrorRoute>[];
-}
 /**
  * Load, merge, and normalize all of the config sources.
  *
@@ -35,19 +31,5 @@ export declare function resolveGlobalConfig(configArg?: LwrGlobalConfig, options
  * @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>;
+export declare function loadConfig(config?: LwrGlobalConfig, options?: ResolveConfigOptions): Configurations;
 //# sourceMappingURL=global-config.d.ts.map

package/build/es/global-config.js

@@ -5,8 +5,8 @@ import { readFile, normalizeDirectory, getFeatureFlags, logger, ASSETS_CACHE_DIR
 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 { loadServiceEntries, normalizeServicePaths, normalizeServices } from './utils/services.js';
-import { loadRouteHandlers, normalizeRoutePaths, normalizeRoutes } from './utils/routes.js';
+import { normalizeServicePaths, normalizeServices } from './utils/services.js';
+import { normalizeRoutePaths, normalizeRoutes } from './utils/routes.js';
 import { mergeBundleConfig, mergeLockerConfig, mergeLwcConfig, mergeStaticGenerationConfig, trimLwrConfig, } from './utils/merge.js';
 import { normalizeLwcConfig, normalizeModulePaths } from './utils/lwc.js';
 import { getRuntimeEnvironment } from './runtime-config.js';
@@ -113,7 +113,6 @@ function normalizeConfig(config) {
         // normalize all services
         hooks: normalizeServices(config.hooks),
         moduleProviders: normalizeServices(config.moduleProviders),
-        bundleProviders: normalizeServices(config.bundleProviders),
         assetProviders: normalizeServices(config.assetProviders),
         assetTransformers: normalizeServices(config.assetTransformers),
         resourceProviders: normalizeServices(config.resourceProviders),
@@ -155,7 +154,6 @@ function normalizeConfigPaths(config) {
         // normalize all service paths
         hooks: normalizeServicePaths(config.hooks, rootDir),
         moduleProviders: normalizeServicePaths(config.moduleProviders, rootDir),
-        bundleProviders: normalizeServicePaths(config.bundleProviders, rootDir),
         assetProviders: normalizeServicePaths(config.assetProviders, rootDir),
         assetTransformers: normalizeServicePaths(config.assetTransformers, rootDir),
         resourceProviders: normalizeServicePaths(config.resourceProviders, rootDir),
@@ -166,16 +164,6 @@ 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.
  *
@@ -213,53 +201,19 @@ export function resolveGlobalConfig(configArg, options) {
  * @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 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,
-    };
-}
-/**
- * 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);
+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 {
-        routes,
-        errorRoutes,
+        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): 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): void;
+//# sourceMappingURL=hooks.d.ts.map

package/build/es/hooks.js

@@ -0,0 +1,59 @@
+import { normalizeRoutes } from './utils/routes.js';
+import { validateLwrAppConfig } from './validation/app-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) {
+    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.errorRoutes = normalizeRoutes(globalConfig.errorRoutes);
+    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) {
+    if (!hooks.length) {
+        return;
+    }
+    for (const hook of hooks) {
+        if (!hook.onStart) {
+            continue;
+        }
+        hook.onStart(globalConfig.routes);
+    }
+    globalConfig.routes = normalizeRoutes(globalConfig.routes);
+    validateLwrAppConfig(globalConfig, 'post');
+}
+//# sourceMappingURL=hooks.js.map

package/build/es/index.d.ts

@@ -1,5 +1,5 @@
-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 };
+export { loadConfig, resolveGlobalConfig as normalizeConfig } from './global-config.js';
+export { getRuntimeEnvironment } from './runtime-config.js';
+export { executeConfigHooks, executeStartHooks } from './hooks.js';
 //# sourceMappingURL=index.d.ts.map

package/build/es/index.js

@@ -1,6 +1,5 @@
-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, loadConfig, loadRoutes, loadServices, getRuntimeEnvironment };
+export { loadConfig, resolveGlobalConfig as normalizeConfig } from './global-config.js';
+export { getRuntimeEnvironment } from './runtime-config.js';
+export { executeConfigHooks, executeStartHooks } from './hooks.js';
 //# sourceMappingURL=index.js.map

package/build/es/modules.d.ts

@@ -0,0 +1,36 @@
+import type { HooksPlugin, NormalizedLwrErrorRoute, NormalizedLwrGlobalConfig, NormalizedLwrRoute, Route, Services } from '@lwrjs/types';
+export interface Routes {
+    routes: Route<NormalizedLwrRoute>[];
+    errorRoutes: Route<NormalizedLwrErrorRoute>[];
+}
+/**
+ * Import and instantiate hooks defined in the global config
+ *
+ * @remarks
+ * The optional dependency `esbuild` MUST be installed to load hook modules.
+ *
+ * @param config - global config
+ * @returns {HooksPlugin[]} all instantiated hooks
+ */
+export declare function loadHooks(config: NormalizedLwrGlobalConfig): Promise<HooksPlugin[]>;
+/**
+ * Load service modules from the filepaths configured in the global config
+ *
+ * @remarks
+ * The optional dependency `esbuild` MUST be installed to load service modules.
+ *
+ * @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
+ *
+ * @remarks
+ * The optional dependency `esbuild` MUST be installed to load route handler modules.
+ *
+ * @param config - global config
+ * @returns {Routes} all routes with resolved route handlers
+ */
+export declare function loadRoutes(config: NormalizedLwrGlobalConfig): Promise<Routes>;
+//# sourceMappingURL=modules.d.ts.map

package/build/es/modules.js

@@ -0,0 +1,116 @@
+import path from 'path';
+import { normalizeDirectory, resolveFileExtension } from '@lwrjs/shared-utils';
+import { transpileTs } from '@lwrjs/shared-utils/typescript';
+// Bundle Providers are not configurable
+const BUNDLE_PROVIDERS = [
+    ['@lwrjs/module-bundler/amd-bundle-provider', undefined],
+    ['@lwrjs/module-bundler/esm-bundle-provider', undefined],
+];
+async function importModule(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}`);
+    }
+}
+async function loadServiceEntries(entries, rootDir, cacheDir) {
+    return Promise.all(entries.map(async ([entry, config]) => {
+        const ctor = await importModule(entry, rootDir, path.join(cacheDir, 'services'));
+        return [ctor, config];
+    }));
+}
+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 importModule(route.routeHandler, rootDir, path.join(cacheDir, 'routeHandlers'));
+        cache[route.routeHandler] = routeHandler;
+        return {
+            ...route,
+            routeHandler,
+        };
+    }));
+}
+/**
+ * Import and instantiate hooks defined in the global config
+ *
+ * @remarks
+ * The optional dependency `esbuild` MUST be installed to load hook modules.
+ *
+ * @param config - global config
+ * @returns {HooksPlugin[]} all instantiated hooks
+ */
+export 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;
+}
+/**
+ * Load service modules from the filepaths configured in the global config
+ *
+ * @remarks
+ * The optional dependency `esbuild` MUST be installed to load service modules.
+ *
+ * @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 bundleProviders = await loadServiceEntries(BUNDLE_PROVIDERS, 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,
+    };
+}
+/**
+ * Load all route handlers from the filepaths configured in the global config
+ *
+ * @remarks
+ * The optional dependency `esbuild` MUST be installed to load route handler modules.
+ *
+ * @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=modules.js.map

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

@@ -1,8 +1,7 @@
-import type { LwrErrorRoute, LwrRoute, NormalizedLwrErrorRoute, NormalizedLwrRoute, ResourcePaths, Route } from '@lwrjs/types';
+import type { LwrErrorRoute, LwrRoute, NormalizedLwrErrorRoute, NormalizedLwrRoute, ResourcePaths } 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,6 +1,5 @@
 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,
@@ -23,24 +22,4 @@ 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,5 +1,4 @@
-import type { LwrService, ServiceConfig, ServiceEntry, ResolvedServiceEntry } from '@lwrjs/types';
+import type { ServiceConfig, ServiceEntry } 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,7 +1,6 @@
 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]));
 }
@@ -17,10 +16,4 @@ 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-context.d.ts

@@ -15,7 +15,7 @@ interface ConfigMap {
     bootstrap: NormalizedLwrAppBootstrapConfig;
     locker: RequiredLwrLockerConfig;
 }
-export declare const ROOT_ATTRIBUTE_KEYS: ["amdLoader", "apiVersion", "assets", "assetProviders", "assetTransformers", "bundleConfig", "bundleProviders", "cacheDir", "contentDir", "environment", "errorRoutes", "esmLoader", "staticSiteGenerator", "globalData", "globalDataDir", "hooks", "ignoreLwrConfigFile", "lwrConfigFile", "layoutsDir", "locker", "lwc", "lwrVersion", "moduleProviders", "port", "basePath", "resourceProviders", "rootDir", "routes", "serverMode", "serverType", "viewProviders", "viewTransformers"];
+export declare const ROOT_ATTRIBUTE_KEYS: ["amdLoader", "apiVersion", "assets", "assetProviders", "assetTransformers", "bundleConfig", "cacheDir", "contentDir", "environment", "errorRoutes", "esmLoader", "staticSiteGenerator", "globalData", "globalDataDir", "hooks", "ignoreLwrConfigFile", "lwrConfigFile", "layoutsDir", "locker", "lwc", "lwrVersion", "moduleProviders", "port", "basePath", "resourceProviders", "rootDir", "routes", "serverMode", "serverType", "viewProviders", "viewTransformers"];
 export declare const ASSET_DIR_ATTRIBUTE_KEYS: ["alias", "dir", "urlPath"];
 export declare const ASSET_FILE_ATTRIBUTE_KEYS: ["alias", "file", "urlPath"];
 export declare const LOCKER_ATTRIBUTE_KEYS: ["enabled", "trustedComponents", "clientOnly"];

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

@@ -13,7 +13,6 @@ export const ROOT_ATTRIBUTE_KEYS = createKeys('root', [
     'assetProviders',
     'assetTransformers',
     'bundleConfig',
-    'bundleProviders',
     'cacheDir',
     'contentDir',
     'environment',

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

@@ -178,7 +178,6 @@ function validateLocker(node, validationContext) {
  *      - rootDir, cacheDir, contentDir, layoutsDir, globalDataDir: strings
  *      - hooks: array of strings
  *      - moduleProviders: array of services
- *      - bundleProviders: array of services
  *      - viewProviders: array of services
  *      - resourceProviders: array of services
  *      - assetProviders: array of services
@@ -214,7 +213,6 @@ function validateRoot(node, validationContext, preMerge) {
     validationContext.assertNotEmptyString(findNode(node, ['globalDataDir']), 'globalDataDir');
     validationContext.assertArrayOfServices(findNode(node, ['hooks']), 'hooks');
     validationContext.assertArrayOfServices(findNode(node, ['moduleProviders']), 'moduleProviders');
-    validationContext.assertArrayOfServices(findNode(node, ['bundleProviders']), 'bundleProviders');
     validationContext.assertArrayOfServices(findNode(node, ['viewProviders']), 'viewProviders');
     validationContext.assertArrayOfServices(findNode(node, ['resourceProviders']), 'resourceProviders');
     validationContext.assertArrayOfServices(findNode(node, ['assetProviders']), 'assetProviders');

package/package.json

@@ -4,15 +4,15 @@
     "publishConfig": {
         "access": "public"
     },
-    "version": "0.9.0-alpha.15",
+    "version": "0.9.0-alpha.17",
     "homepage": "https://developer.salesforce.com/docs/platform/lwr/overview",
     "repository": {
         "type": "git",
-        "url": "https://github.com/salesforce/lwr.git",
+        "url": "https://github.com/salesforce-experience-platform-emu/lwr.git",
         "directory": "packages/@lwrjs/config"
     },
     "bugs": {
-        "url": "https://github.com/salesforce/lwr/issues"
+        "url": "https://github.com/salesforce-experience-platform-emu/lwr/issues"
     },
     "type": "module",
     "types": "build/es/index.d.ts",
@@ -23,6 +23,10 @@
             "import": "./build/es/index.js",
             "require": "./build/cjs/index.cjs"
         },
+        "./modules": {
+            "import": "./build/es/modules.js",
+            "require": "./build/cjs/modules.cjs"
+        },
         "./package": "./package.cjs"
     },
     "files": [
@@ -32,17 +36,16 @@
         "package.cjs"
     ],
     "dependencies": {
-        "@lwrjs/diagnostics": "0.9.0-alpha.15",
-        "@lwrjs/shared-utils": "0.9.0-alpha.15",
-        "esbuild": "^0.9.7",
+        "@lwrjs/diagnostics": "0.9.0-alpha.17",
+        "@lwrjs/shared-utils": "0.9.0-alpha.17",
         "fs-extra": "^10.1.0",
         "jsonc-parser": "^3.0.0"
     },
     "devDependencies": {
-        "@lwrjs/types": "0.9.0-alpha.15"
+        "@lwrjs/types": "0.9.0-alpha.17"
     },
     "engines": {
         "node": ">=14.15.4 <19"
     },
-    "gitHead": "f32f103d2d5e516daccce1be69f68acd7b4b86fb"
+    "gitHead": "447417ff091802927b25cfc1bcb01da02264f41b"
 }

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

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

@@ -1,21 +0,0 @@
-import { normalizeDirectory, resolveFileExtension } from '@lwrjs/shared-utils';
-import { transpileTs } from '@lwrjs/shared-utils/typescript';
-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