@lwrjs/module-bundler 0.5.11-alpha.2 → 0.6.0-alpha.11

package/build/cjs/amd/amd-bundler.cjs

@@ -27,8 +27,8 @@ __export(exports, {
   amdBundler: () => amdBundler
 });
 var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
-async function amdBundler(moduleId, moduleRegistry, runtimeEnvironment, runtimeParams = {}, {bundleConfig, amdLoader}) {
-  const {exclude, external} = bundleConfig;
+async function amdBundler(moduleId, moduleRegistry, runtimeEnvironment, runtimeParams = {}, {bundleConfig, amdLoader}, bundleConfigOverride) {
+  const {exclude, external} = bundleConfigOverride ?? bundleConfig;
   const requiredImports = new Map();
   const dynamicImports = new Map();
   const visited = new Map();
@@ -50,16 +50,12 @@ async function amdBundler(moduleId, moduleRegistry, runtimeEnvironment, runtimeP
   const rootModuleDef = moduleGraphs.linkedDefinitions[rootModule.specifier];
   const {id, name, namespace, version, specifier} = rootModuleDef;
   rootModuleDef?.linkedModuleRecord.dynamicImports?.forEach((e) => {
-    if (e.moduleNameType !== "unresolved") {
-      dynamicImports.set(`${e.specifier}_${e.version}`, e);
-    }
+    dynamicImports.set(`${e.specifier}_${e.version}`, e);
   });
   moduleGraphs.graphs[0].static.forEach((m) => {
     const d = moduleGraphs.linkedDefinitions[m];
     d?.linkedModuleRecord.dynamicImports?.forEach((e) => {
-      if (e.moduleNameType !== "unresolved") {
-        dynamicImports.set(`${e.specifier}_${e.version}`, e);
-      }
+      dynamicImports.set(`${e.specifier}_${e.version}`, e);
     });
   });
   const code = [];

package/build/cjs/esm/esm-bundler.cjs

@@ -28,8 +28,8 @@ __export(exports, {
 });
 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 = {}, bundleConfig) {
-  const {exclude, external = {}} = bundleConfig;
+async function esmBundler(moduleId, moduleRegistry, runtimeEnvironment, runtimeParams = {}, lwrConfig, bundleConfigOverride) {
+  const {exclude, external = {}, alias = {}} = bundleConfigOverride ?? lwrConfig.bundleConfig;
   const {sourceMapUrl} = runtimeEnvironment;
   const requiredImports = new Map();
   const dynamicImports = new Map();
@@ -42,6 +42,7 @@ async function esmBundler(moduleId, moduleRegistry, runtimeEnvironment, runtimeP
         runtimeEnvironment,
         moduleRegistry,
         exclude,
+        alias,
         runtimeParams,
         requiredImports,
         dynamicImports

package/build/cjs/esm/rollup-esm-bundler-plugin.cjs

@@ -32,12 +32,14 @@ function bundleDefinitions(options) {
     rootModuleDef,
     moduleRegistry,
     exclude,
+    alias = {},
     runtimeEnvironment,
     runtimeParams,
     requiredImports,
     dynamicImports
   } = options;
   const visitedDefs = new Map([[rootModuleDef.specifier, rootModuleDef]]);
+  const visitedAliasUris = new Map();
   return {
     name: "bundle-plugin",
     resolveDynamicImport() {
@@ -45,20 +47,21 @@ function bundleDefinitions(options) {
     },
     resolveId(id, importer) {
       const moduleDef = visitedDefs.get(id);
+      if (visitedAliasUris.has(id)) {
+        return visitedAliasUris.get(id);
+      }
       if (moduleDef && moduleDef.linkedModuleRecord) {
         const d = moduleDef.linkedModuleRecord.dynamicImports || [];
         d.forEach((e) => {
-          if (e.moduleNameType !== "unresolved") {
-            const {namespace, name, version, sourceSpecifier, moduleNameType} = e;
-            dynamicImports.set(`${sourceSpecifier}_${version}`, {
-              namespace,
-              name,
-              specifier: sourceSpecifier,
-              version,
-              sourceSpecifier,
-              moduleNameType
-            });
-          }
+          const {namespace, name, version, sourceSpecifier, moduleNameType} = e;
+          dynamicImports.set(`${sourceSpecifier}_${version}`, {
+            namespace,
+            name,
+            specifier: sourceSpecifier,
+            version,
+            sourceSpecifier,
+            moduleNameType
+          });
         });
       }
       if (exclude && moduleDef && importer && exclude.includes(moduleDef.specifier)) {
@@ -82,16 +85,29 @@ function bundleDefinitions(options) {
       for (const refImport of imports) {
         let refModuleDef = visitedDefs.get(refImport.specifier);
         if (!refModuleDef) {
-          const {namespace, name, version, scope} = refImport;
-          const specifier = (0, import_shared_utils.getSpecifier)({namespace, name});
+          let specifier = (0, import_shared_utils.getSpecifier)({namespace: refImport.namespace, name: refImport.name});
+          let explodedSpecifier = refImport;
+          let aliasSpecifierUri;
+          const specifierUri = refImport.specifier;
+          const hasAlias = !!alias[specifier];
+          if (hasAlias) {
+            specifier = alias[specifier];
+            explodedSpecifier = (0, import_shared_utils.explodeSpecifier)(specifier);
+            const aliasModuleEntry = await moduleRegistry.getModuleEntry(explodedSpecifier, runtimeParams);
+            aliasSpecifierUri = await moduleRegistry.resolveModuleUri(aliasModuleEntry, runtimeEnvironment, runtimeParams);
+          }
           refModuleDef = await moduleRegistry.getLinkedModule({
             specifier,
-            namespace,
-            name,
-            scope,
-            version
+            namespace: explodedSpecifier.namespace,
+            name: explodedSpecifier.name,
+            scope: hasAlias ? void 0 : refImport.scope,
+            version: explodedSpecifier.version
           }, runtimeEnvironment, runtimeParams);
-          visitedDefs.set(refImport.specifier, refModuleDef);
+          visitedDefs.set(specifierUri, refModuleDef);
+          if (hasAlias) {
+            visitedDefs.set(aliasSpecifierUri, refModuleDef);
+            visitedAliasUris.set(specifierUri, aliasSpecifierUri);
+          }
         }
       }
       return moduleDef.linkedSource;

package/build/cjs/index.cjs

@@ -29,10 +29,11 @@ __export(exports, {
 var import_amd_bundler = __toModule(require("./amd/amd-bundler.cjs"));
 var import_esm_bundler = __toModule(require("./esm/esm-bundler.cjs"));
 var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
+var TASK_POOL = new import_shared_utils.TaskPool();
 var LwrModuleBundler = class {
   constructor(config, globalConfig) {
     this.cache = new Map();
-    this.inflightBundleDefinitions = new Map();
+    this.inflightBundleDefinitions = new import_shared_utils.InflightTasks();
     this.config = globalConfig;
     this.moduleRegistry = config.moduleRegistry;
     this.appObserver = config.appObserver;
@@ -40,32 +41,33 @@ var LwrModuleBundler = class {
       this.cache.clear();
     });
   }
-  async getModuleBundle(moduleId, runtimeEnvironment, runtimeParams = {}) {
+  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,
       format,
       minify,
-      debug
+      debug,
+      bundleConfigOverrides
     })}`;
     const cacheDisabled = process.env.NOCACHE === "true";
-    if (cacheDisabled === false) {
+    if (!cacheDisabled) {
       if (this.cache.has(cacheKey)) {
-        const bundleDef2 = this.cache.get(cacheKey);
-        return bundleDef2;
+        const bundleDef = this.cache.get(cacheKey);
+        return bundleDef;
       }
     }
-    if (this.inflightBundleDefinitions.has(cacheKey)) {
-      return this.inflightBundleDefinitions.get(cacheKey);
-    }
-    const bundleDefPromise = format === "amd" ? (0, import_amd_bundler.amdBundler)(moduleId, moduleRegistry, runtimeEnvironment, runtimeParams, this.config) : (0, import_esm_bundler.esmBundler)(moduleId, moduleRegistry, runtimeEnvironment, runtimeParams, this.config.bundleConfig);
-    this.inflightBundleDefinitions.set(cacheKey, bundleDefPromise);
-    const bundleDef = await bundleDefPromise;
-    if (cacheDisabled === false) {
-      this.cache.set(cacheKey, bundleDef);
-    }
-    this.inflightBundleDefinitions.delete(cacheKey);
-    return bundleDef;
+    const createBundlePromiseCtor = async () => {
+      return TASK_POOL.execute(async () => {
+        return 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).then((bundleDef) => {
+          if (!cacheDisabled) {
+            this.cache.set(cacheKey, bundleDef);
+          }
+          return bundleDef;
+        });
+      }, this);
+    };
+    return this.inflightBundleDefinitions.execute(cacheKey, createBundlePromiseCtor, this);
   }
 };

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

@@ -1,3 +1,3 @@
-import { AbstractModuleId, BundleDefinition, ModuleRegistry, NormalizedLwrGlobalConfig, RuntimeEnvironment } from '@lwrjs/types';
-export declare function amdBundler(moduleId: AbstractModuleId, moduleRegistry: ModuleRegistry, runtimeEnvironment: RuntimeEnvironment, runtimeParams: Record<string, string | number | boolean | null | undefined> | undefined, { bundleConfig, amdLoader }: NormalizedLwrGlobalConfig): Promise<BundleDefinition>;
+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/amd/amd-bundler.js

@@ -1,6 +1,6 @@
 import { getModuleGraphs, GraphDepth } from '@lwrjs/shared-utils';
-export async function amdBundler(moduleId, moduleRegistry, runtimeEnvironment, runtimeParams = {}, { bundleConfig, amdLoader }) {
-    const { exclude, external } = bundleConfig;
+export async function amdBundler(moduleId, moduleRegistry, runtimeEnvironment, runtimeParams = {}, { bundleConfig, amdLoader }, bundleConfigOverride) {
+    const { exclude, external } = bundleConfigOverride ?? bundleConfig;
     const requiredImports = new Map();
     const dynamicImports = new Map();
     const visited = new Map();
@@ -27,9 +27,7 @@ export async function amdBundler(moduleId, moduleRegistry, runtimeEnvironment, r
     // Collect dynamic imports
     // Add dynamic imports from the root module
     rootModuleDef?.linkedModuleRecord.dynamicImports?.forEach((e) => {
-        if (e.moduleNameType !== 'unresolved') {
-            dynamicImports.set(`${e.specifier}_${e.version}`, e);
-        }
+        dynamicImports.set(`${e.specifier}_${e.version}`, e);
     });
     // Add any dynamic imports from each of the linked static imports in the moduleGraph
     moduleGraphs.graphs[0].static.forEach((m) => {
@@ -37,9 +35,7 @@ export async function amdBundler(moduleId, moduleRegistry, runtimeEnvironment, r
         const d = moduleGraphs.linkedDefinitions[m];
         // D would be null if excluded from the bundle
         d?.linkedModuleRecord.dynamicImports?.forEach((e) => {
-            if (e.moduleNameType !== 'unresolved') {
-                dynamicImports.set(`${e.specifier}_${e.version}`, e);
-            }
+            dynamicImports.set(`${e.specifier}_${e.version}`, e);
         });
     });
     // loop in reverse for correct order

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

@@ -1,3 +1,3 @@
-import { AbstractModuleId, ModuleRegistry, BundleDefinition, SourceMapRuntimeEnvironment, BundleConfig } from '@lwrjs/types';
-export declare function esmBundler(moduleId: AbstractModuleId, moduleRegistry: ModuleRegistry, runtimeEnvironment: SourceMapRuntimeEnvironment, runtimeParams: Record<string, string | number | boolean | null | undefined> | undefined, bundleConfig: BundleConfig): Promise<BundleDefinition>;
+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

package/build/es/esm/esm-bundler.js

@@ -1,7 +1,7 @@
 import { rollup } from 'rollup';
 import { bundleDefinitions } from './rollup-esm-bundler-plugin.js';
-export async function esmBundler(moduleId, moduleRegistry, runtimeEnvironment, runtimeParams = {}, bundleConfig) {
-    const { exclude, external = {} } = bundleConfig;
+export async function esmBundler(moduleId, moduleRegistry, runtimeEnvironment, runtimeParams = {}, lwrConfig, bundleConfigOverride) {
+    const { exclude, external = {}, alias = {} } = bundleConfigOverride ?? lwrConfig.bundleConfig;
     const { sourceMapUrl } = runtimeEnvironment;
     const requiredImports = new Map();
     const dynamicImports = new Map();
@@ -14,12 +14,13 @@ export async function esmBundler(moduleId, moduleRegistry, runtimeEnvironment, r
                 runtimeEnvironment,
                 moduleRegistry,
                 exclude,
+                alias,
                 runtimeParams,
                 requiredImports,
                 dynamicImports,
             }),
         ],
-        makeAbsoluteExternalsRelative: 'ifRelativeSource',
+        makeAbsoluteExternalsRelative: 'ifRelativeSource', // Fix for breaking changes in https://github.com/rollup/rollup/pull/4021
     });
     const result = await bundle.generate({
         paths: (id) => {

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

@@ -7,6 +7,7 @@ export interface RollupBundlePluginOptions {
     moduleRegistry: ModuleRegistry;
     include?: string[];
     exclude?: string[];
+    alias?: Record<string, string>;
     requiredImports: Map<string, BaseModuleReference>;
     dynamicImports: Map<string, BaseDynamicModuleReference>;
 }

package/build/es/esm/rollup-esm-bundler-plugin.js

@@ -1,12 +1,14 @@
-import { getSpecifier } from '@lwrjs/shared-utils';
+/* eslint-disable no-await-in-loop */
+import { explodeSpecifier, getSpecifier } from '@lwrjs/shared-utils';
 /*
  * Note: The prefix "@bundle" is do allow rollup to pretty print the imports in case of an error
  * Otherwise since the imports start with a "/" it think its an absolute path doing "../" all over the place
  */
 export function bundleDefinitions(options) {
-    const { rootModuleDef, moduleRegistry, exclude, runtimeEnvironment, runtimeParams, requiredImports, dynamicImports, } = options;
+    const { rootModuleDef, moduleRegistry, exclude, alias = {}, runtimeEnvironment, runtimeParams, requiredImports, dynamicImports, } = options;
     // Manually add the root to visited so it can be found on the load hook
     const visitedDefs = new Map([[rootModuleDef.specifier, rootModuleDef]]);
+    const visitedAliasUris = new Map();
     return {
         name: 'bundle-plugin',
         resolveDynamicImport() {
@@ -15,22 +17,23 @@ export function bundleDefinitions(options) {
         },
         resolveId(id, importer) {
             const moduleDef = visitedDefs.get(id);
+            if (visitedAliasUris.has(id)) {
+                return visitedAliasUris.get(id);
+            }
             // Collect dynamic import information here
             if (moduleDef && moduleDef.linkedModuleRecord) {
                 const d = moduleDef.linkedModuleRecord.dynamicImports || [];
                 d.forEach((e) => {
-                    if (e.moduleNameType !== 'unresolved') {
-                        const { namespace, name, version, sourceSpecifier, moduleNameType } = e;
-                        // Not sure why this has to be source specifier but things break otherwise
-                        dynamicImports.set(`${sourceSpecifier}_${version}`, {
-                            namespace,
-                            name,
-                            specifier: sourceSpecifier,
-                            version,
-                            sourceSpecifier,
-                            moduleNameType,
-                        });
-                    }
+                    const { namespace, name, version, sourceSpecifier, moduleNameType } = e;
+                    // Not sure why this has to be source specifier but things break otherwise
+                    dynamicImports.set(`${sourceSpecifier}_${version}`, {
+                        namespace,
+                        name,
+                        specifier: sourceSpecifier,
+                        version,
+                        sourceSpecifier,
+                        moduleNameType,
+                    });
                 });
             }
             // if importer is null is the entry which we must ignore for externals
@@ -60,19 +63,38 @@ export function bundleDefinitions(options) {
                 let refModuleDef = visitedDefs.get(refImport.specifier);
                 if (!refModuleDef) {
                     // The refeference imports have the specifier pointing to a URI.
-                    // so we take the original instead
-                    const { namespace, name, version, scope } = refImport;
-                    const specifier = getSpecifier({ namespace, name });
+                    // so we take the original specifier instead
+                    let specifier = getSpecifier({ namespace: refImport.namespace, name: refImport.name });
+                    let explodedSpecifier = refImport;
+                    let aliasSpecifierUri;
+                    const specifierUri = refImport.specifier;
+                    const hasAlias = !!alias[specifier];
+                    if (hasAlias) {
+                        // Override the original raw specifier and the exploded version
+                        // so the code that will load will be the aliased
+                        specifier = alias[specifier];
+                        explodedSpecifier = explodeSpecifier(specifier);
+                        // We also need to remap the original URI to point to the aliased URI so
+                        // we endup having the same module identity (otherwise we will have duplicated code)
+                        const aliasModuleEntry = await moduleRegistry.getModuleEntry(explodedSpecifier, runtimeParams);
+                        aliasSpecifierUri = await moduleRegistry.resolveModuleUri(aliasModuleEntry, runtimeEnvironment, runtimeParams);
+                    }
                     // eslint-disable-next-line no-await-in-loop
                     refModuleDef = await moduleRegistry.getLinkedModule({
                         specifier,
-                        namespace,
-                        name,
-                        scope,
-                        version,
+                        namespace: explodedSpecifier.namespace,
+                        name: explodedSpecifier.name,
+                        scope: hasAlias ? undefined : refImport.scope,
+                        version: explodedSpecifier.version,
                     }, runtimeEnvironment, runtimeParams);
                     // This specifier is the final URI specifier
-                    visitedDefs.set(refImport.specifier, refModuleDef);
+                    visitedDefs.set(specifierUri, refModuleDef);
+                    // If there is an alias we need to point the alias URI to the same code
+                    // The resolveId must have both URIs (original, and alias) pointing to the same def
+                    if (hasAlias) {
+                        visitedDefs.set(aliasSpecifierUri, refModuleDef);
+                        visitedAliasUris.set(specifierUri, aliasSpecifierUri);
+                    }
                 }
             }
             return moduleDef.linkedSource;

package/build/es/index.d.ts

@@ -1,4 +1,4 @@
-import { AbstractModuleId, BundleDefinition, LwrAppObserver, ModuleBundler, ModuleRegistry, NormalizedLwrGlobalConfig, RuntimeParams, SourceMapRuntimeEnvironment } from '@lwrjs/types';
+import { AbstractModuleId, BundleConfig, BundleDefinition, LwrAppObserver, ModuleBundler, ModuleRegistry, NormalizedLwrGlobalConfig, RuntimeParams, SourceMapRuntimeEnvironment } from '@lwrjs/types';
 interface LwrModuleBundlerConfig {
     moduleRegistry: ModuleRegistry;
     appObserver: LwrAppObserver;
@@ -10,7 +10,7 @@ export declare class LwrModuleBundler implements ModuleBundler {
     cache: Map<string, BundleDefinition>;
     private inflightBundleDefinitions;
     constructor(config: LwrModuleBundlerConfig, globalConfig: NormalizedLwrGlobalConfig);
-    getModuleBundle<T extends AbstractModuleId>(moduleId: T, runtimeEnvironment: SourceMapRuntimeEnvironment, runtimeParams?: RuntimeParams): Promise<BundleDefinition>;
+    getModuleBundle<T extends AbstractModuleId>(moduleId: T, runtimeEnvironment: SourceMapRuntimeEnvironment, runtimeParams?: RuntimeParams, bundleConfigOverrides?: BundleConfig): Promise<BundleDefinition>;
 }
 export {};
 //# sourceMappingURL=index.d.ts.map

package/build/es/index.js

@@ -1,13 +1,14 @@
 import { amdBundler } from './amd/amd-bundler.js';
 import { esmBundler } from './esm/esm-bundler.js';
-import { getCacheKeyFromJson } from '@lwrjs/shared-utils';
+import { getCacheKeyFromJson, InflightTasks, TaskPool } from '@lwrjs/shared-utils';
+const TASK_POOL = new TaskPool();
 export class LwrModuleBundler {
     constructor(config, globalConfig) {
         this.cache = new Map();
         // 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.
-        this.inflightBundleDefinitions = new Map();
+        this.inflightBundleDefinitions = new InflightTasks();
         this.config = globalConfig;
         this.moduleRegistry = config.moduleRegistry;
         this.appObserver = config.appObserver;
@@ -17,7 +18,7 @@ export class LwrModuleBundler {
             this.cache.clear();
         });
     }
-    async getModuleBundle(moduleId, runtimeEnvironment, runtimeParams = {}) {
+    async getModuleBundle(moduleId, runtimeEnvironment, runtimeParams = {}, bundleConfigOverrides) {
         const { moduleRegistry } = this;
         const { format, minify, debug } = runtimeEnvironment;
         const cacheKey = `${moduleId.specifier}|${moduleId.version}|${getCacheKeyFromJson({
@@ -25,30 +26,35 @@ export class LwrModuleBundler {
             format,
             minify,
             debug,
+            bundleConfigOverrides,
         })}`;
         const cacheDisabled = process.env.NOCACHE === 'true';
-        if (cacheDisabled === false) {
+        if (!cacheDisabled) {
             // Return the cached bundle definition
             if (this.cache.has(cacheKey)) {
+                // TODO add to profiling
+                // console.log('[INFO] Bundle Cache Hit: ', cacheKey);
                 const bundleDef = this.cache.get(cacheKey);
                 return bundleDef;
             }
         }
-        // Return the inflight bundle definition
-        if (this.inflightBundleDefinitions.has(cacheKey)) {
-            return this.inflightBundleDefinitions.get(cacheKey);
-        }
         // Generate the bundle definition
-        const bundleDefPromise = format === 'amd'
-            ? amdBundler(moduleId, moduleRegistry, runtimeEnvironment, runtimeParams, this.config)
-            : esmBundler(moduleId, moduleRegistry, runtimeEnvironment, runtimeParams, this.config.bundleConfig);
-        this.inflightBundleDefinitions.set(cacheKey, bundleDefPromise);
-        const bundleDef = await bundleDefPromise;
-        if (cacheDisabled === false) {
-            this.cache.set(cacheKey, bundleDef);
-        }
-        this.inflightBundleDefinitions.delete(cacheKey);
-        return bundleDef;
+        const createBundlePromiseCtor = async () => {
+            // TODO add to profiling
+            // console.log('[INFO] Create Bundle: ', cacheKey);
+            // Run theses tasks in a task pool to throttle parallel requests.
+            return TASK_POOL.execute(async () => {
+                return format === 'amd'
+                    ? amdBundler(moduleId, moduleRegistry, runtimeEnvironment, runtimeParams, this.config, bundleConfigOverrides)
+                    : esmBundler(moduleId, moduleRegistry, runtimeEnvironment, runtimeParams, this.config, bundleConfigOverrides).then((bundleDef) => {
+                        if (!cacheDisabled) {
+                            this.cache.set(cacheKey, bundleDef);
+                        }
+                        return bundleDef;
+                    });
+            }, this);
+        };
+        return this.inflightBundleDefinitions.execute(cacheKey, createBundlePromiseCtor, this);
     }
 }
 //# sourceMappingURL=index.js.map

package/package.json

@@ -4,8 +4,8 @@
     "publishConfig": {
         "access": "public"
     },
-    "version": "0.5.11-alpha.2",
-    "homepage": "https://lwr.dev/",
+    "version": "0.6.0-alpha.11",
+    "homepage": "https://developer.salesforce.com/docs/platform/lwr/overview",
     "repository": {
         "type": "git",
         "url": "https://github.com/salesforce/lwr.git",
@@ -30,14 +30,14 @@
         "build/**/*.d.ts"
     ],
     "dependencies": {
-        "@lwrjs/shared-utils": "0.5.11-alpha.2",
+        "@lwrjs/shared-utils": "0.6.0-alpha.11",
         "rollup": "~2.45.2"
     },
     "devDependencies": {
-        "@lwrjs/types": "0.5.11-alpha.2"
+        "@lwrjs/types": "0.6.0-alpha.11"
     },
     "engines": {
         "node": ">=14.15.4 <17"
     },
-    "gitHead": "83785c79e6adbfb1ead85e0c23e9164a22cb5755"
+    "gitHead": "18ab72188c2d52e32cca47333951a9c76f996039"
 }