@lwrjs/module-bundler 0.9.0-alpha.12 → 0.9.0-alpha.14

package/build/cjs/amd-bundle-provider.cjs

@@ -0,0 +1,50 @@
+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/module-bundler/src/amd-bundle-provider.ts
+__markAsModule(exports);
+__export(exports, {
+  default: () => amd_bundle_provider_default
+});
+var import_amd_common = __toModule(require("./utils/amd-common.cjs"));
+var import_esbuild_utils = __toModule(require("./utils/esbuild-utils.cjs"));
+var AmdBundlerProvider = class {
+  constructor(options, {config, moduleRegistry}) {
+    this.name = "amd-bundle-provider";
+    this.config = config;
+    this.moduleRegistry = moduleRegistry;
+  }
+  async bundle(moduleId, runtimeEnvironment, runtimeParams = {}, bundleConfigOverrides) {
+    if (runtimeEnvironment.format === "amd") {
+      const {moduleRegistry, config} = this;
+      const bundle = await (0, import_amd_common.amdBundler)(moduleId, moduleRegistry, false, runtimeEnvironment, runtimeParams, config, bundleConfigOverrides);
+      const {minify, debug} = runtimeEnvironment;
+      const minified = !!minify && !debug;
+      if (minified) {
+        bundle.code = await (0, import_esbuild_utils.minifyJavascript)(bundle.code);
+      }
+      return bundle;
+    }
+  }
+};
+var amd_bundle_provider_default = AmdBundlerProvider;

package/build/cjs/amd-runtime-bundle-provider.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/module-bundler/src/amd-runtime-bundle-provider.ts
+__markAsModule(exports);
+__export(exports, {
+  default: () => amd_runtime_bundle_provider_default
+});
+var import_amd_common = __toModule(require("./utils/amd-common.cjs"));
+var AmdBundlerProvider = class {
+  constructor(options, {config, moduleRegistry}) {
+    this.name = "amd-runtime-bundle-provider";
+    this.config = config;
+    this.moduleRegistry = moduleRegistry;
+  }
+  async bundle(moduleId, runtimeEnvironment, runtimeParams = {}, bundleConfigOverrides) {
+    if (runtimeEnvironment.format === "amd") {
+      const {moduleRegistry, config} = this;
+      const {minify, debug} = runtimeEnvironment;
+      const minified = minify && !debug;
+      return await (0, import_amd_common.amdBundler)(moduleId, moduleRegistry, minified, runtimeEnvironment, runtimeParams, config, bundleConfigOverrides);
+    }
+  }
+};
+var amd_runtime_bundle_provider_default = AmdBundlerProvider;

package/build/cjs/{esm/esm-bundler.cjs → esm-bundle-provider.cjs}

@@ -21,15 +21,30 @@ 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/module-bundler/src/esm/esm-bundler.ts
+// packages/@lwrjs/module-bundler/src/esm-bundle-provider.ts
 __markAsModule(exports);
 __export(exports, {
-  esmBundler: () => esmBundler
+  default: () => esm_bundle_provider_default
 });
 var import_rollup = __toModule(require("rollup"));
-var import_rollup_esm_bundler_plugin = __toModule(require("./rollup-esm-bundler-plugin.cjs"));
-async function esmBundler(moduleId, moduleRegistry, runtimeEnvironment, runtimeParams = {}, lwrConfig, bundleConfigOverride) {
-  const {exclude, external = {}, alias = {}} = bundleConfigOverride ?? lwrConfig.bundleConfig;
+var import_rollup_esm_bundler_plugin = __toModule(require("./utils/rollup-esm-bundler-plugin.cjs"));
+var import_esbuild_utils = __toModule(require("./utils/esbuild-utils.cjs"));
+var EsmBundlerProvider = class {
+  constructor(options, {config, moduleRegistry}) {
+    this.name = "esm-bundle-provider";
+    this.config = config;
+    this.moduleRegistry = moduleRegistry;
+  }
+  async bundle(moduleId, runtimeEnvironment, runtimeParams = {}, bundleConfigOverrides) {
+    if (runtimeEnvironment.format === "esm") {
+      const {moduleRegistry, config} = this;
+      return await esmBundler(moduleId, moduleRegistry, runtimeEnvironment, runtimeParams, config, bundleConfigOverrides);
+    }
+  }
+};
+var esm_bundle_provider_default = EsmBundlerProvider;
+async function esmBundler(moduleId, moduleRegistry, runtimeEnvironment, runtimeParams = {}, {bundleConfig}, bundleConfigOverride) {
+  const {exclude, external = {}, alias = {}} = bundleConfigOverride ?? bundleConfig;
   const {sourceMapUrl} = runtimeEnvironment;
   const requiredImports = new Map();
   const dynamicImports = new Map();
@@ -58,9 +73,14 @@ async function esmBundler(moduleId, moduleRegistry, runtimeEnvironment, runtimeP
   });
   const bundleCode = result.output[0].code;
   const bundleMap = result.output[0].map;
-  const code = sourceMapUrl ? `${bundleCode}
+  let code = sourceMapUrl ? `${bundleCode}
 //# sourceMappingURL=${sourceMapUrl}` : bundleCode;
   const {id, specifier, namespace, name, version} = rootModuleDef;
+  const {minify, debug} = runtimeEnvironment;
+  const minified = !!minify && !debug;
+  if (minified) {
+    code = await (0, import_esbuild_utils.minifyJavascript)(code);
+  }
   return {
     id,
     specifier,

package/build/cjs/index.cjs

@@ -26,24 +26,25 @@ __markAsModule(exports);
 __export(exports, {
   LwrModuleBundler: () => LwrModuleBundler
 });
+var import_diagnostics = __toModule(require("@lwrjs/diagnostics"));
 var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
-var import_amd_bundler = __toModule(require("./amd/amd-bundler.cjs"));
-var import_esm_bundler = __toModule(require("./esm/esm-bundler.cjs"));
 var TASK_POOL = new import_shared_utils.TaskPool();
 var LwrModuleBundler = class {
   constructor(config, globalConfig) {
     this.cache = new Map();
+    this.providers = [];
     this.inflightBundleDefinitions = new import_shared_utils.InflightTasks();
     this.config = globalConfig;
     this.moduleRegistry = config.moduleRegistry;
     this.appObserver = config.appObserver;
-    this.compiler = config.compiler;
     this.appObserver?.onModuleDefinitionChange(() => {
       this.cache.clear();
     });
   }
+  addBundleProviders(providers) {
+    this.providers.push(...providers);
+  }
   async getModuleBundle(moduleId, runtimeEnvironment, runtimeParams = {}, bundleConfigOverrides) {
-    const {moduleRegistry} = this;
     const {format, minify, debug} = runtimeEnvironment;
     const cacheKey = `${moduleId.specifier}|${moduleId.version}|${(0, import_shared_utils.getCacheKeyFromJson)({
       locale: runtimeParams.locale,
@@ -61,18 +62,22 @@ var LwrModuleBundler = class {
     }
     return this.inflightBundleDefinitions.execute(cacheKey, () => {
       return TASK_POOL.execute(async () => {
-        const pendingBundleDef = format === "amd" ? (0, import_amd_bundler.amdBundler)(moduleId, moduleRegistry, runtimeEnvironment, runtimeParams, this.config, bundleConfigOverrides) : (0, import_esm_bundler.esmBundler)(moduleId, moduleRegistry, runtimeEnvironment, runtimeParams, this.config, bundleConfigOverrides);
-        return pendingBundleDef.then(async (bundleDef) => {
-          const minified = !!minify && !debug;
-          if (minified) {
-            bundleDef.code = (await this.compiler.minifyJavascript(bundleDef.code)).code;
-          }
-          if (!cacheDisabled) {
-            this.cache.set(cacheKey, bundleDef);
+        for (const bundler of this.providers) {
+          const bundleDef = await bundler.bundle(moduleId, runtimeEnvironment, runtimeParams, bundleConfigOverrides);
+          if (bundleDef) {
+            if (!cacheDisabled) {
+              this.cache.set(cacheKey, bundleDef);
+            }
+            return bundleDef;
           }
-          return bundleDef;
-        });
+        }
+        throw (0, import_diagnostics.createSingleDiagnosticError)({
+          description: import_diagnostics.descriptions.UNRESOLVABLE.BUNDLE(moduleId.specifier)
+        }, import_diagnostics.LwrUnresolvableError);
       }, this);
     });
   }
+  resolveModuleUri(moduleId, runtimeEnvironment, runtimeParams, signature) {
+    return this.moduleRegistry.resolveModuleUri(moduleId, runtimeEnvironment, runtimeParams, signature);
+  }
 };

package/build/cjs/{amd/amd-bundler.cjs → utils/amd-common.cjs}

@@ -21,32 +21,32 @@ 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/module-bundler/src/amd/amd-bundler.ts
+// packages/@lwrjs/module-bundler/src/utils/amd-common.ts
 __markAsModule(exports);
 __export(exports, {
   amdBundler: () => amdBundler
 });
-var import_compiler = __toModule(require("@lwrjs/compiler"));
 var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
 var import_rollup = __toModule(require("rollup"));
+var import_plugin_replace = __toModule(require("@rollup/plugin-replace"));
+var import_rollup_plugin_terser = __toModule(require("rollup-plugin-terser"));
 var import_rollup_amd_bundler_plugin = __toModule(require("./rollup-amd-bundler-plugin.cjs"));
-async function bundle(id, moduleGraphs) {
-  const bundler = await (0, import_rollup.rollup)({
-    input: id,
-    plugins: [
-      (0, import_rollup_amd_bundler_plugin.bundleDefinitions)({
-        moduleGraphs
-      })
-    ]
-  });
+var AMD_DEFINE = "LWR.define";
+async function bundle(id, moduleGraphs, minify = false) {
+  const plugins = [(0, import_rollup_amd_bundler_plugin.bundleDefinitions)({moduleGraphs})];
+  minify && plugins.push((0, import_rollup_plugin_terser.terser)(), (0, import_plugin_replace.default)({
+    "process.env.NODE_ENV": JSON.stringify("production"),
+    preventAssignment: false
+  }));
+  const bundler = await (0, import_rollup.rollup)({input: id, plugins});
   const {output} = await bundler.generate({
-    amd: {id, define: import_compiler.AMD_DEFINE},
+    amd: {id, define: AMD_DEFINE},
     exports: "named",
     format: "amd"
   });
   return output[0].code;
 }
-async function amdBundler(moduleId, moduleRegistry, runtimeEnvironment, runtimeParams = {}, {bundleConfig, amdLoader}, bundleConfigOverride) {
+async function amdBundler(moduleId, moduleRegistry, minify = false, runtimeEnvironment, runtimeParams = {}, {bundleConfig, amdLoader}, bundleConfigOverride) {
   const {exclude, external} = bundleConfigOverride ?? bundleConfig;
   const requiredImports = new Map();
   const dynamicImports = new Map();
@@ -88,7 +88,7 @@ async function amdBundler(moduleId, moduleRegistry, runtimeEnvironment, runtimeP
     if (id2 !== rootModule.specifier) {
       includedModules.push(id2);
     }
-    return bundle(id2, moduleGraphs);
+    return bundle(id2, moduleGraphs, minify);
   }));
   const {id, name, namespace, version, specifier} = moduleGraphs.linkedDefinitions[rootModule.specifier];
   return {

package/build/cjs/utils/esbuild-utils.cjs

@@ -0,0 +1,50 @@
+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/module-bundler/src/utils/esbuild-utils.ts
+__markAsModule(exports);
+__export(exports, {
+  minifyJavascript: () => minifyJavascript
+});
+var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
+var import_esbuild = __toModule(require("esbuild"));
+var esbuild = import_esbuild.default;
+if (!import_esbuild.default) {
+  try {
+    esbuild = require("esbuild");
+  } catch {
+  }
+}
+async function minifyJavascript(source) {
+  try {
+    const {code} = await esbuild.transform(source, {
+      loader: "js",
+      minify: true,
+      define: {"process.env.NODE_ENV": JSON.stringify("production")}
+    });
+    return code;
+  } catch (error) {
+    import_shared_utils.logger.debug(error);
+    throw error;
+  }
+}

package/build/cjs/{amd → utils}/rollup-amd-bundler-plugin.cjs

@@ -5,7 +5,7 @@ var __export = (target, all) => {
     __defProp(target, name, {get: all[name], enumerable: true});
 };
 
-// packages/@lwrjs/module-bundler/src/amd/rollup-amd-bundler-plugin.ts
+// packages/@lwrjs/module-bundler/src/utils/rollup-amd-bundler-plugin.ts
 __markAsModule(exports);
 __export(exports, {
   bundleDefinitions: () => bundleDefinitions

package/build/cjs/{esm → utils}/rollup-esm-bundler-plugin.cjs

@@ -21,7 +21,7 @@ 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/module-bundler/src/esm/rollup-esm-bundler-plugin.ts
+// packages/@lwrjs/module-bundler/src/utils/rollup-esm-bundler-plugin.ts
 __markAsModule(exports);
 __export(exports, {
   bundleDefinitions: () => bundleDefinitions

package/build/es/amd-bundle-provider.d.ts

@@ -0,0 +1,9 @@
+import { AbstractModuleId, BundleConfig, BundleDefinition, BundleProvider, ProviderAppConfig, ProviderContext, PublicModuleRegistry, RuntimeEnvironment, RuntimeParams } from '@lwrjs/types';
+export default class AmdBundlerProvider implements BundleProvider {
+    name: string;
+    config: ProviderAppConfig;
+    moduleRegistry: PublicModuleRegistry;
+    constructor(options: {}, { config, moduleRegistry }: ProviderContext);
+    bundle<T extends AbstractModuleId, R extends RuntimeEnvironment>(moduleId: T, runtimeEnvironment: R, runtimeParams?: RuntimeParams, bundleConfigOverrides?: BundleConfig): Promise<BundleDefinition | undefined>;
+}
+//# sourceMappingURL=amd-bundle-provider.d.ts.map

package/build/es/amd-bundle-provider.js

@@ -0,0 +1,24 @@
+import { amdBundler } from './utils/amd-common.js';
+import { minifyJavascript } from './utils/esbuild-utils.js';
+export default class AmdBundlerProvider {
+    constructor(options, { config, moduleRegistry }) {
+        this.name = 'amd-bundle-provider';
+        this.config = config;
+        this.moduleRegistry = moduleRegistry;
+    }
+    async bundle(moduleId, runtimeEnvironment, runtimeParams = {}, bundleConfigOverrides) {
+        if (runtimeEnvironment.format === 'amd') {
+            const { moduleRegistry, config } = this;
+            const bundle = await amdBundler(moduleId, moduleRegistry, false, // we NEVER want to minify via rollup/terser with this bundler; it's too slow
+            runtimeEnvironment, runtimeParams, config, bundleConfigOverrides);
+            // Minification via esbuild for performance
+            const { minify, debug } = runtimeEnvironment;
+            const minified = !!minify && !debug;
+            if (minified) {
+                bundle.code = await minifyJavascript(bundle.code);
+            }
+            return bundle;
+        }
+    }
+}
+//# sourceMappingURL=amd-bundle-provider.js.map

package/build/es/amd-runtime-bundle-provider.d.ts

@@ -0,0 +1,9 @@
+import { AbstractModuleId, BundleConfig, BundleDefinition, BundleProvider, ProviderAppConfig, ProviderContext, PublicModuleRegistry, RuntimeEnvironment, RuntimeParams } from '@lwrjs/types';
+export default class AmdBundlerProvider implements BundleProvider {
+    name: string;
+    config: ProviderAppConfig;
+    moduleRegistry: PublicModuleRegistry;
+    constructor(options: {}, { config, moduleRegistry }: ProviderContext);
+    bundle<T extends AbstractModuleId, R extends RuntimeEnvironment>(moduleId: T, runtimeEnvironment: R, runtimeParams?: RuntimeParams, bundleConfigOverrides?: BundleConfig): Promise<BundleDefinition | undefined>;
+}
+//# sourceMappingURL=amd-runtime-bundle-provider.d.ts.map

package/build/es/amd-runtime-bundle-provider.js

@@ -0,0 +1,18 @@
+import { amdBundler } from './utils/amd-common.js';
+export default class AmdBundlerProvider {
+    constructor(options, { config, moduleRegistry }) {
+        this.name = 'amd-runtime-bundle-provider';
+        this.config = config;
+        this.moduleRegistry = moduleRegistry;
+    }
+    async bundle(moduleId, runtimeEnvironment, runtimeParams = {}, bundleConfigOverrides) {
+        if (runtimeEnvironment.format === 'amd') {
+            const { moduleRegistry, config } = this;
+            const { minify, debug } = runtimeEnvironment;
+            const minified = minify && !debug;
+            return await amdBundler(moduleId, moduleRegistry, minified, // will minify using rollup/terser if true - MRT runtime friendly
+            runtimeEnvironment, runtimeParams, config, bundleConfigOverrides);
+        }
+    }
+}
+//# sourceMappingURL=amd-runtime-bundle-provider.js.map

package/build/es/esm-bundle-provider.d.ts

@@ -0,0 +1,9 @@
+import type { AbstractModuleId, BundleConfig, BundleDefinition, BundleProvider, ProviderAppConfig, ProviderContext, PublicModuleRegistry, RuntimeEnvironment, RuntimeParams } from '@lwrjs/types';
+export default class EsmBundlerProvider implements BundleProvider {
+    name: string;
+    config: ProviderAppConfig;
+    moduleRegistry: PublicModuleRegistry;
+    constructor(options: {}, { config, moduleRegistry }: ProviderContext);
+    bundle<T extends AbstractModuleId, R extends RuntimeEnvironment>(moduleId: T, runtimeEnvironment: R, runtimeParams?: RuntimeParams, bundleConfigOverrides?: BundleConfig): Promise<BundleDefinition | undefined>;
+}
+//# sourceMappingURL=esm-bundle-provider.d.ts.map

package/build/es/{esm/esm-bundler.js → esm-bundle-provider.js}

@@ -1,7 +1,21 @@
 import { rollup } from 'rollup';
-import { bundleDefinitions } from './rollup-esm-bundler-plugin.js';
-export async function esmBundler(moduleId, moduleRegistry, runtimeEnvironment, runtimeParams = {}, lwrConfig, bundleConfigOverride) {
-    const { exclude, external = {}, alias = {} } = bundleConfigOverride ?? lwrConfig.bundleConfig;
+import { bundleDefinitions } from './utils/rollup-esm-bundler-plugin.js';
+import { minifyJavascript } from './utils/esbuild-utils.js';
+export default class EsmBundlerProvider {
+    constructor(options, { config, moduleRegistry }) {
+        this.name = 'esm-bundle-provider';
+        this.config = config;
+        this.moduleRegistry = moduleRegistry;
+    }
+    async bundle(moduleId, runtimeEnvironment, runtimeParams = {}, bundleConfigOverrides) {
+        if (runtimeEnvironment.format === 'esm') {
+            const { moduleRegistry, config } = this;
+            return await esmBundler(moduleId, moduleRegistry, runtimeEnvironment, runtimeParams, config, bundleConfigOverrides);
+        }
+    }
+}
+async function esmBundler(moduleId, moduleRegistry, runtimeEnvironment, runtimeParams = {}, { bundleConfig }, bundleConfigOverride) {
+    const { exclude, external = {}, alias = {} } = bundleConfigOverride ?? bundleConfig;
     const { sourceMapUrl } = runtimeEnvironment;
     const requiredImports = new Map();
     const dynamicImports = new Map();
@@ -32,8 +46,13 @@ export async function esmBundler(moduleId, moduleRegistry, runtimeEnvironment, r
     });
     const bundleCode = result.output[0].code;
     const bundleMap = result.output[0].map;
-    const code = sourceMapUrl ? `${bundleCode}\n//# sourceMappingURL=${sourceMapUrl}` : bundleCode;
+    let code = sourceMapUrl ? `${bundleCode}\n//# sourceMappingURL=${sourceMapUrl}` : bundleCode;
     const { id, specifier, namespace, name, version } = rootModuleDef;
+    const { minify, debug } = runtimeEnvironment;
+    const minified = !!minify && !debug;
+    if (minified) {
+        code = await minifyJavascript(code);
+    }
     return {
         id,
         specifier,
@@ -50,4 +69,4 @@ export async function esmBundler(moduleId, moduleRegistry, runtimeEnvironment, r
         },
     };
 }
-//# sourceMappingURL=esm-bundler.js.map
+//# sourceMappingURL=esm-bundle-provider.js.map

package/build/es/index.d.ts

@@ -1,18 +1,27 @@
-import { AbstractModuleId, BundleConfig, BundleDefinition, LwrAppObserver, ModuleBundler, ModuleRegistry, NormalizedLwrGlobalConfig, RuntimeParams, SourceMapRuntimeEnvironment, Compiler } from '@lwrjs/types';
+import { AbstractModuleId, BundleConfig, BundleDefinition, BundleProvider, LwrAppObserver, ModuleBundler, ModuleId, ModuleRegistry, NormalizedLwrGlobalConfig, RuntimeEnvironment, RuntimeParams, SourceMapRuntimeEnvironment } from '@lwrjs/types';
 interface LwrModuleBundlerConfig {
-    compiler: Compiler;
     moduleRegistry: ModuleRegistry;
     appObserver?: LwrAppObserver;
 }
 export declare class LwrModuleBundler implements ModuleBundler {
-    compiler: Compiler;
     moduleRegistry: ModuleRegistry;
     appObserver: LwrAppObserver | undefined;
     config: NormalizedLwrGlobalConfig;
     cache: Map<string, BundleDefinition>;
+    providers: BundleProvider[];
     private inflightBundleDefinitions;
     constructor(config: LwrModuleBundlerConfig, globalConfig: NormalizedLwrGlobalConfig);
+    addBundleProviders(providers: BundleProvider[]): void;
     getModuleBundle<T extends AbstractModuleId>(moduleId: T, runtimeEnvironment: SourceMapRuntimeEnvironment, runtimeParams?: RuntimeParams, bundleConfigOverrides?: BundleConfig): Promise<BundleDefinition>;
+    /**
+     * Resolve the URI to the bundle rooted at the `moduleId`
+     * @param moduleId - The id of the root module for the bundle
+     * @param runtimeEnvironment  - The runtime operating environnment
+     * @param runtimeParams  - The available runtime parameters provided in context to the request
+     * @param signature - The signature of the bundle instance being referenced
+     * @returns the URI
+     */
+    resolveModuleUri<R extends RuntimeEnvironment, S extends string | undefined>(moduleId: Required<Pick<ModuleId, 'specifier' | 'version'>>, runtimeEnvironment: R, runtimeParams?: RuntimeParams, signature?: S): S extends string ? string : Promise<string>;
 }
 export {};
 //# sourceMappingURL=index.d.ts.map

package/build/es/index.js

@@ -1,10 +1,10 @@
+import { LwrUnresolvableError, createSingleDiagnosticError, descriptions } from '@lwrjs/diagnostics';
 import { getCacheKeyFromJson, InflightTasks, TaskPool } from '@lwrjs/shared-utils';
-import { amdBundler } from './amd/amd-bundler.js';
-import { esmBundler } from './esm/esm-bundler.js';
 const TASK_POOL = new TaskPool();
 export class LwrModuleBundler {
     constructor(config, globalConfig) {
         this.cache = new Map();
+        this.providers = [];
         // Pending bundle definitions are tracked to prevent concurrent resolution of the same bundle.
         // Subsequent requests for the same bundle will await the original promise.
         // Cache entries will be removed once the bundle is resolved.
@@ -12,15 +12,16 @@ export class LwrModuleBundler {
         this.config = globalConfig;
         this.moduleRegistry = config.moduleRegistry;
         this.appObserver = config.appObserver;
-        this.compiler = config.compiler;
         this.appObserver?.onModuleDefinitionChange(() => {
             // TODO: This is a very naive approach however
             // this would only happen in non-prod environments
             this.cache.clear();
         });
     }
+    addBundleProviders(providers) {
+        this.providers.push(...providers);
+    }
     async getModuleBundle(moduleId, runtimeEnvironment, runtimeParams = {}, bundleConfigOverrides) {
-        const { moduleRegistry } = this;
         const { format, minify, debug } = runtimeEnvironment;
         const cacheKey = `${moduleId.specifier}|${moduleId.version}|${getCacheKeyFromJson({
             locale: runtimeParams.locale,
@@ -44,21 +45,34 @@ export class LwrModuleBundler {
             // console.log('[INFO] Create Bundle: ', cacheKey);
             // Run theses tasks in a task pool to throttle parallel requests.
             return TASK_POOL.execute(async () => {
-                const pendingBundleDef = format === 'amd'
-                    ? amdBundler(moduleId, moduleRegistry, runtimeEnvironment, runtimeParams, this.config, bundleConfigOverrides)
-                    : esmBundler(moduleId, moduleRegistry, runtimeEnvironment, runtimeParams, this.config, bundleConfigOverrides);
-                return pendingBundleDef.then(async (bundleDef) => {
-                    const minified = !!minify && !debug;
-                    if (minified) {
-                        bundleDef.code = (await this.compiler.minifyJavascript(bundleDef.code)).code;
-                    }
-                    if (!cacheDisabled) {
-                        this.cache.set(cacheKey, bundleDef);
+                for (const bundler of this.providers) {
+                    // eslint-disable-next-line no-await-in-loop
+                    const bundleDef = await bundler.bundle(moduleId, runtimeEnvironment, runtimeParams, bundleConfigOverrides);
+                    if (bundleDef) {
+                        if (!cacheDisabled) {
+                            this.cache.set(cacheKey, bundleDef);
+                        }
+                        return bundleDef;
                     }
-                    return bundleDef;
-                });
+                }
+                throw createSingleDiagnosticError({
+                    description: descriptions.UNRESOLVABLE.BUNDLE(moduleId.specifier),
+                }, LwrUnresolvableError);
             }, this);
         });
     }
+    /**
+     * Resolve the URI to the bundle rooted at the `moduleId`
+     * @param moduleId - The id of the root module for the bundle
+     * @param runtimeEnvironment  - The runtime operating environnment
+     * @param runtimeParams  - The available runtime parameters provided in context to the request
+     * @param signature - The signature of the bundle instance being referenced
+     * @returns the URI
+     */
+    resolveModuleUri(moduleId, runtimeEnvironment, runtimeParams, signature) {
+        // TODO: Integrate resolving from a site caches.
+        // Fallback to resolving the URI from the registry.
+        return this.moduleRegistry.resolveModuleUri(moduleId, runtimeEnvironment, runtimeParams, signature);
+    }
 }
 //# sourceMappingURL=index.js.map

package/build/es/utils/amd-common.d.ts

@@ -0,0 +1,3 @@
+import { AbstractModuleId, BundleConfig, BundleDefinition, ModuleRegistry, ProviderAppConfig, RuntimeEnvironment, RuntimeParams } from '@lwrjs/types';
+export declare function amdBundler(moduleId: AbstractModuleId, moduleRegistry: ModuleRegistry, minify: boolean | undefined, runtimeEnvironment: RuntimeEnvironment, runtimeParams: RuntimeParams | undefined, { bundleConfig, amdLoader }: ProviderAppConfig, bundleConfigOverride?: BundleConfig): Promise<BundleDefinition>;
+//# sourceMappingURL=amd-common.d.ts.map

package/build/es/{amd/amd-bundler.js → utils/amd-common.js}

@@ -1,16 +1,17 @@
-import { AMD_DEFINE } from '@lwrjs/compiler';
 import { GraphDepth, getModuleGraphs, getSpecifier } from '@lwrjs/shared-utils';
 import { rollup } from 'rollup';
+import replace from '@rollup/plugin-replace';
+import { terser } from 'rollup-plugin-terser';
 import { bundleDefinitions } from './rollup-amd-bundler-plugin.js';
-async function bundle(id, moduleGraphs) {
-    const bundler = await rollup({
-        input: id,
-        plugins: [
-            bundleDefinitions({
-                moduleGraphs,
-            }),
-        ],
-    });
+const AMD_DEFINE = 'LWR.define';
+async function bundle(id, moduleGraphs, minify = false) {
+    const plugins = [bundleDefinitions({ moduleGraphs })];
+    minify &&
+        plugins.push(terser(), replace({
+            'process.env.NODE_ENV': JSON.stringify('production'),
+            preventAssignment: false,
+        }));
+    const bundler = await rollup({ input: id, plugins });
     const { output } = await bundler.generate({
         amd: { id, define: AMD_DEFINE },
         exports: 'named',
@@ -18,7 +19,7 @@ async function bundle(id, moduleGraphs) {
     });
     return output[0].code;
 }
-export async function amdBundler(moduleId, moduleRegistry, runtimeEnvironment, runtimeParams = {}, { bundleConfig, amdLoader }, bundleConfigOverride) {
+export async function amdBundler(moduleId, moduleRegistry, minify = false, runtimeEnvironment, runtimeParams = {}, { bundleConfig, amdLoader }, bundleConfigOverride) {
     const { exclude, external } = bundleConfigOverride ?? bundleConfig;
     const requiredImports = new Map();
     const dynamicImports = new Map();
@@ -68,7 +69,7 @@ export async function amdBundler(moduleId, moduleRegistry, runtimeEnvironment, r
             includedModules.push(id);
         }
         // bundle all dependencies for the linked definition and convert to AMD
-        return bundle(id, moduleGraphs);
+        return bundle(id, moduleGraphs, minify);
     }));
     const { id, name, namespace, version, specifier } = moduleGraphs.linkedDefinitions[rootModule.specifier];
     return {
@@ -86,4 +87,4 @@ export async function amdBundler(moduleId, moduleRegistry, runtimeEnvironment, r
         },
     };
 }
-//# sourceMappingURL=amd-bundler.js.map
+//# sourceMappingURL=amd-common.js.map

package/build/es/utils/esbuild-utils.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Minification via esbuild.
+ * When importing this module make sure the optional library 'esbuild' is installed.
+ */
+export declare function minifyJavascript(source: string): Promise<string>;
+//# sourceMappingURL=esbuild-utils.d.ts.map

package/build/es/utils/esbuild-utils.js

@@ -0,0 +1,34 @@
+import { logger } from '@lwrjs/shared-utils';
+import esbuildEsm from 'esbuild';
+// https://github.com/evanw/esbuild/issues/706
+// Fixed in 0.11.0 but upgrading past 0.9.7 has caused breaking changes for consumers...
+// https://github.com/salesforce-experience-platform/lwr/issues/1014
+let esbuild = esbuildEsm;
+if (!esbuildEsm) {
+    try {
+        esbuild = require('esbuild');
+    }
+    catch {
+        /* this is to support mjs/cjs dual impl */
+    }
+}
+/**
+ * Minification via esbuild.
+ * When importing this module make sure the optional library 'esbuild' is installed.
+ */
+export async function minifyJavascript(source) {
+    try {
+        const { code } = await esbuild.transform(source, {
+            loader: 'js',
+            minify: true,
+            // Remove assertions by tree shaking the computed expression
+            define: { 'process.env.NODE_ENV': JSON.stringify('production') },
+        });
+        return code;
+    }
+    catch (error) {
+        logger.debug(error);
+        throw error;
+    }
+}
+//# sourceMappingURL=esbuild-utils.js.map

package/package.json

@@ -4,7 +4,7 @@
     "publishConfig": {
         "access": "public"
     },
-    "version": "0.9.0-alpha.12",
+    "version": "0.9.0-alpha.14",
     "homepage": "https://developer.salesforce.com/docs/platform/lwr/overview",
     "repository": {
         "type": "git",
@@ -22,6 +22,18 @@
         ".": {
             "import": "./build/es/index.js",
             "require": "./build/cjs/index.cjs"
+        },
+        "./amd-bundle-provider": {
+            "import": "./build/es/amd-bundle-provider.js",
+            "require": "./build/cjs/amd-bundle-provider.cjs"
+        },
+        "./amd-runtime-bundle-provider": {
+            "import": "./build/es/amd-runtime-bundle-provider.js",
+            "require": "./build/cjs/amd-runtime-bundle-provider.cjs"
+        },
+        "./esm-bundle-provider": {
+            "import": "./build/es/esm-bundle-provider.js",
+            "require": "./build/cjs/esm-bundle-provider.cjs"
         }
     },
     "files": [
@@ -30,15 +42,19 @@
         "build/**/*.d.ts"
     ],
     "dependencies": {
-        "@lwrjs/compiler": "0.9.0-alpha.12",
-        "@lwrjs/shared-utils": "0.9.0-alpha.12",
-        "rollup": "~2.45.2"
+        "@lwrjs/shared-utils": "0.9.0-alpha.14",
+        "@rollup/plugin-replace": "^2.4.2",
+        "rollup": "~2.45.2",
+        "rollup-plugin-terser": "^7.0.2"
     },
     "devDependencies": {
-        "@lwrjs/types": "0.9.0-alpha.12"
+        "@lwrjs/types": "0.9.0-alpha.14"
+    },
+    "optionalDependencies": {
+        "esbuild": "^0.9.7"
     },
     "engines": {
         "node": ">=14.15.4 <19"
     },
-    "gitHead": "f532aa80039acf04e9ad511ed090a2b368837014"
+    "gitHead": "64e0ba617151429da6e09f1a9686628f64183d25"
 }

package/build/es/amd/amd-bundler.d.ts

@@ -1,3 +0,0 @@
-import { AbstractModuleId, BundleConfig, BundleDefinition, ModuleRegistry, NormalizedLwrGlobalConfig, RuntimeEnvironment, RuntimeParams } from '@lwrjs/types';
-export declare function amdBundler(moduleId: AbstractModuleId, moduleRegistry: ModuleRegistry, runtimeEnvironment: RuntimeEnvironment, runtimeParams: RuntimeParams | undefined, { bundleConfig, amdLoader }: NormalizedLwrGlobalConfig, bundleConfigOverride?: BundleConfig): Promise<BundleDefinition>;
-//# sourceMappingURL=amd-bundler.d.ts.map

package/build/es/esm/esm-bundler.d.ts

@@ -1,3 +0,0 @@
-import { AbstractModuleId, ModuleRegistry, BundleDefinition, RuntimeParams, SourceMapRuntimeEnvironment, BundleConfig, NormalizedLwrGlobalConfig } from '@lwrjs/types';
-export declare function esmBundler(moduleId: AbstractModuleId, moduleRegistry: ModuleRegistry, runtimeEnvironment: SourceMapRuntimeEnvironment, runtimeParams: RuntimeParams | undefined, lwrConfig: NormalizedLwrGlobalConfig, bundleConfigOverride?: BundleConfig): Promise<BundleDefinition>;
-//# sourceMappingURL=esm-bundler.d.ts.map