@lwrjs/module-bundler 0.10.0-alpha.9 → 0.10.1

package/build/cjs/index.cjs

@@ -28,11 +28,13 @@ __export(exports, {
 });
 var import_diagnostics = __toModule(require("@lwrjs/diagnostics"));
 var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
+var import_path = __toModule(require("path"));
 var TASK_POOL = new import_shared_utils.TaskPool();
 var LwrModuleBundler = class {
   constructor(config, globalConfig) {
     this.cache = new Map();
     this.providers = [];
+    this.transformers = [];
     this.inflightBundleDefinitions = new import_shared_utils.InflightTasks();
     this.moduleRegistry = config.moduleRegistry;
     this.appObserver = config.appObserver;
@@ -44,6 +46,9 @@ var LwrModuleBundler = class {
   addBundleProviders(providers) {
     this.providers.push(...providers);
   }
+  addBundleTransformers(transformers) {
+    this.transformers.push(...transformers);
+  }
   async getModuleBundle(moduleId, runtimeEnvironment, runtimeParams = {}, bundleConfigOverrides) {
     const {format, minify, debug} = runtimeEnvironment;
     const cacheKey = `${moduleId.specifier}|${moduleId.version}|${(0, import_shared_utils.getCacheKeyFromJson)({
@@ -95,6 +100,18 @@ var LwrModuleBundler = class {
       }
       uri = String(await this.moduleRegistry.resolveModuleUri({...moduleId, version: resolvedVersion}, runtimeEnvironment, runtimeParams, signature));
     }
+    const bundleUri = {
+      artifactType: "bundle",
+      uri: (0, import_path.join)(runtimeEnvironment.basePath || "", uri),
+      immutable: runtimeEnvironment.immutableAssets,
+      entry: uri
+    };
+    for (const transformPlugin of this.transformers) {
+      const resolveUriResult = await transformPlugin.transformUri?.(bundleUri, bundleDefinition, runtimeEnvironment);
+      if (resolveUriResult && resolveUriResult.uri) {
+        uri = resolveUriResult.uri;
+      }
+    }
     return uri;
   }
   getPublicApi() {

package/build/cjs/utils/amd-common.cjs

@@ -32,7 +32,30 @@ var import_plugin_replace = __toModule(require("@rollup/plugin-replace"));
 var import_rollup_amd_bundler_plugin = __toModule(require("./rollup-amd-bundler-plugin.cjs"));
 var import_bundle_common = __toModule(require("./bundle-common.cjs"));
 var AMD_DEFINE = "LWR.define";
-async function bundle(id, moduleGraphs, minify = false) {
+var groupieCodeCache = new Map();
+function includeIdFactory(graphSpecifier, external, exclude = [], requiredImports, groups) {
+  return (moduleRef) => {
+    if (external[moduleRef.specifier] !== void 0) {
+      return false;
+    }
+    const moduleRefIsGroupie = (0, import_shared_utils.isGroupie)(moduleRef.specifier, groups);
+    const rootModuleIsGroupie = (0, import_shared_utils.isGroupie)(graphSpecifier, groups);
+    const moduleIsNotRoot = graphSpecifier !== moduleRef.specifier;
+    if (moduleRefIsGroupie) {
+      if (moduleIsNotRoot && !rootModuleIsGroupie) {
+        requiredImports.set(`${moduleRef.specifier}_${moduleRef.version}`, moduleRef);
+      }
+      return false;
+    } else if (exclude?.includes(moduleRef.specifier)) {
+      if (moduleIsNotRoot) {
+        requiredImports.set(`${moduleRef.specifier}_${moduleRef.version}`, moduleRef);
+      }
+      return false;
+    }
+    return true;
+  };
+}
+async function bundle(id, moduleGraphs, minify = false, unVersionedAliases = false) {
   const plugins = [(0, import_rollup_amd_bundler_plugin.bundleDefinitions)({moduleGraphs})];
   minify && plugins.push((0, import_plugin_replace.default)({
     "process.env.NODE_ENV": JSON.stringify("production"),
@@ -44,35 +67,36 @@ async function bundle(id, moduleGraphs, minify = false) {
     exports: "named",
     format: "amd"
   });
-  return output[0].code;
+  let code = output[0].code;
+  if (unVersionedAliases) {
+    const idObject = (0, import_shared_utils.explodeSpecifier)(id);
+    const specifier = idObject.specifier;
+    const aliasModule = (0, import_shared_utils.createAmdAlias)(specifier, id);
+    code += aliasModule;
+  }
+  return code;
 }
-async function amdBundler(moduleId, moduleRegistry, minify = false, runtimeEnvironment, runtimeParams = {}, {bundleConfig}, bundleConfigOverrides) {
-  const {exclude, external = {}} = (0, import_bundle_common.overrideBundleConfig)(bundleConfig, bundleConfigOverrides);
-  const externalsArray = Object.keys(external);
-  const requiredImports = new Map();
-  const dynamicImports = new Map();
-  const includedModules = [];
-  const graphOptions = {
-    includeLinkedDefinitions: true,
-    depth: {
-      static: import_shared_utils.GraphDepth.ALL,
-      dynamic: 0,
-      includeId: (moduleRef) => {
-        if (externalsArray.includes(moduleRef.specifier)) {
-          return false;
-        } else if (exclude?.includes(moduleRef.specifier)) {
-          requiredImports.set(`${moduleRef.specifier}_${moduleRef.version}`, moduleRef);
-          return false;
+async function getBundleCode(rootModule, moduleGraphs, includedModules, bundleGroupsIncludedModules, dynamicImports, minify, unVersionedAliases, includeId, moduleRegistry, runtimeEnvironment, runtimeParams = {}, visitedSpecifiers) {
+  const modules = [rootModule, ...moduleGraphs.graphs[0].static];
+  const {moduleRecord} = await moduleRegistry.getModule((0, import_shared_utils.explodeSpecifier)(rootModule));
+  if (moduleRecord.importMeta) {
+    for (const specifier of modules) {
+      const linkedDefinition = moduleGraphs.linkedDefinitions[specifier];
+      const imports = linkedDefinition?.linkedModuleRecord.imports || [];
+      for (const imp of imports) {
+        const modId = (0, import_shared_utils.explodeSpecifier)(imp.specifier);
+        if (!modules.includes(imp.specifier) && includeId(modId)) {
+          modules.push(imp.specifier);
+          if (!moduleGraphs.linkedDefinitions[imp.specifier]) {
+            const missingLinkedModule = await moduleRegistry.getLinkedModule({specifier: modId.specifier, version: modId.version}, runtimeEnvironment, runtimeParams);
+            moduleGraphs.linkedDefinitions[imp.specifier] = missingLinkedModule;
+          }
         }
-        return true;
       }
     }
-  };
-  const moduleGraphs = await (0, import_shared_utils.getModuleGraphs)(moduleId.specifier, graphOptions, moduleRegistry, moduleRegistry, runtimeEnvironment, runtimeParams);
-  const rootModule = moduleGraphs.graphs[0];
-  const modules = [rootModule.specifier, ...moduleGraphs.graphs[0].static];
-  const bundles = await Promise.all(modules.reduce((filteredModules, specifier2) => {
-    const linkedDefinition = moduleGraphs.linkedDefinitions[specifier2];
+  }
+  const bundles = (await Promise.all(modules.reduce((filteredModules, specifier) => {
+    const linkedDefinition = moduleGraphs.linkedDefinitions[specifier];
     if (!linkedDefinition) {
       return filteredModules;
     }
@@ -81,18 +105,82 @@ async function amdBundler(moduleId, moduleRegistry, minify = false, runtimeEnvir
         dynamicImports.set(`${dynamicImport.specifier}_${dynamicImport.version}`, dynamicImport);
       }
     });
-    if (specifier2.includes("#")) {
+    if (specifier.includes("#")) {
       return filteredModules;
     }
     filteredModules.unshift(linkedDefinition);
     return filteredModules;
   }, []).map((linkedDefinition) => {
-    const id2 = (0, import_shared_utils.getSpecifier)(linkedDefinition);
-    if (id2 !== rootModule.specifier) {
-      includedModules.push(id2);
+    const id = (0, import_shared_utils.getSpecifier)(linkedDefinition);
+    if (visitedSpecifiers?.has(id)) {
+      return false;
+    } else {
+      visitedSpecifiers?.set(id, true);
     }
-    return bundle(id2, moduleGraphs, minify);
-  }));
+    if (id !== rootModule) {
+      includedModules.push(id);
+    } else {
+      bundleGroupsIncludedModules.push(id);
+    }
+    return bundle(id, moduleGraphs, minify, unVersionedAliases);
+  }))).filter((x) => typeof x === "string");
+  return bundles;
+}
+async function amdBundler(rootModuleId, moduleRegistry, minify = false, runtimeEnvironment, runtimeParams = {}, {bundleConfig}, bundleConfigOverrides) {
+  const {exclude, external = {}, groups = {}} = (0, import_bundle_common.overrideBundleConfig)(bundleConfig, bundleConfigOverrides);
+  const requiredImports = new Map();
+  const dynamicImports = new Map();
+  const groupName = (0, import_shared_utils.getGroupName)(rootModuleId.specifier, groups);
+  const groupies = groupName && groups[groupName];
+  const cacheKey = (0, import_shared_utils.getCacheKeyFromJson)({groupName, exclude, external});
+  const cachedGroupieCode = groupName && groupieCodeCache.get(cacheKey);
+  const getModuleGraphsWrapper = (graphSpecifier) => {
+    const graphOptions = {
+      includeLinkedDefinitions: true,
+      depth: {
+        static: import_shared_utils.GraphDepth.ALL,
+        dynamic: 0,
+        includeId: includeIdFactory(graphSpecifier, external, exclude, requiredImports, groups)
+      }
+    };
+    return (0, import_shared_utils.getModuleGraphs)(graphSpecifier, graphOptions, moduleRegistry, moduleRegistry, runtimeEnvironment, runtimeParams);
+  };
+  const moduleGraphs = await getModuleGraphsWrapper(rootModuleId.specifier);
+  const rootModule = moduleGraphs.graphs[0];
+  const groupModuleGraphsMap = new Map();
+  if (!cachedGroupieCode && groupies && groupies.length) {
+    for (const specifier2 of groupies) {
+      if (specifier2 !== rootModuleId.specifier) {
+        const groupieModuleGraph = await getModuleGraphsWrapper(specifier2);
+        groupModuleGraphsMap.set(specifier2, groupieModuleGraph);
+      }
+    }
+  }
+  let bundleCode, includedModules, bundleGroupsIncludedModules;
+  const cachedBundleGroupCode = cachedGroupieCode;
+  const bundledSpecifiersMap = new Map();
+  if (!cachedBundleGroupCode) {
+    includedModules = [], bundleGroupsIncludedModules = [];
+    const bundles = await getBundleCode(rootModule.specifier, moduleGraphs, includedModules, bundleGroupsIncludedModules, dynamicImports, minify, !!runtimeEnvironment.featureFlags?.EXPERIMENTAL_UNVERSIONED_ALIASES, includeIdFactory(rootModuleId.specifier, external, exclude, requiredImports, groups), moduleRegistry, runtimeEnvironment, runtimeParams, bundledSpecifiersMap);
+    if (groupName) {
+      for (const rawGroupieSpecifier of groupies) {
+        if (rawGroupieSpecifier !== rootModuleId.specifier) {
+          const groupieModuleGraph = groupModuleGraphsMap.get(rawGroupieSpecifier);
+          const groupieSpecifer = groupieModuleGraph.graphs[0].specifier;
+          const groupieBundles = await getBundleCode(groupieSpecifer, groupieModuleGraph, includedModules, bundleGroupsIncludedModules, dynamicImports, minify, !!runtimeEnvironment.featureFlags?.EXPERIMENTAL_UNVERSIONED_ALIASES, includeIdFactory(rawGroupieSpecifier, external, exclude, requiredImports, groups), moduleRegistry, runtimeEnvironment, runtimeParams, bundledSpecifiersMap);
+          bundles.push(...groupieBundles);
+        }
+      }
+    }
+    bundleCode = bundles.join("");
+    if (groupName) {
+      includedModules.push(...bundleGroupsIncludedModules);
+      groupieCodeCache.set(groupName, {code: bundleCode, includedModules});
+    }
+  } else {
+    bundleCode = cachedBundleGroupCode.code;
+    includedModules = cachedBundleGroupCode.includedModules;
+  }
   const {id, name, namespace, version, specifier} = moduleGraphs.linkedDefinitions[rootModule.specifier];
   return {
     id,
@@ -100,7 +188,7 @@ async function amdBundler(moduleId, moduleRegistry, minify = false, runtimeEnvir
     namespace,
     version,
     specifier,
-    code: bundles.join(""),
+    code: bundleCode,
     config: {external, exclude},
     bundleRecord: {
       imports: Array.from(requiredImports.values()),

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

@@ -1,4 +1,4 @@
-import { AbstractModuleId, BundleConfigOverrides, BundleDefinition, BundleProvider, ProviderAppConfig, ProviderContext, PublicModuleRegistry, RuntimeEnvironment, RuntimeParams } from '@lwrjs/types';
+import type { AbstractModuleId, BundleConfigOverrides, BundleDefinition, BundleProvider, ProviderAppConfig, ProviderContext, PublicModuleRegistry, RuntimeEnvironment, RuntimeParams } from '@lwrjs/types';
 export default class AmdBundlerProvider implements BundleProvider {
     name: string;
     config: ProviderAppConfig;

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

@@ -1,4 +1,4 @@
-import { AbstractModuleId, BundleConfigOverrides, BundleDefinition, BundleProvider, ProviderAppConfig, ProviderContext, PublicModuleRegistry, RuntimeEnvironment, RuntimeParams } from '@lwrjs/types';
+import type { AbstractModuleId, BundleConfigOverrides, BundleDefinition, BundleProvider, ProviderAppConfig, ProviderContext, PublicModuleRegistry, RuntimeEnvironment, RuntimeParams } from '@lwrjs/types';
 export default class AmdBundlerProvider implements BundleProvider {
     name: string;
     config: ProviderAppConfig;

package/build/es/index.d.ts

@@ -1,4 +1,4 @@
-import { AbstractModuleId, BundleConfig, BundleConfigOverrides, BundleDefinition, BundleProvider, LwrAppObserver, ModuleBundler, ModuleId, ModuleRegistry, NormalizedLwrGlobalConfig, PublicModuleBundler, RuntimeEnvironment, RuntimeParams, SourceMapRuntimeEnvironment } from '@lwrjs/types';
+import type { AbstractModuleId, BundleConfig, BundleConfigOverrides, BundleDefinition, BundleProvider, LwrAppObserver, ModuleBundler, ModuleId, ModuleRegistry, NormalizedLwrGlobalConfig, PublicModuleBundler, RuntimeEnvironment, RuntimeParams, SourceMapRuntimeEnvironment, UriTransformPlugin } from '@lwrjs/types';
 interface LwrModuleBundlerConfig {
     moduleRegistry: ModuleRegistry;
     appObserver?: LwrAppObserver;
@@ -8,10 +8,12 @@ export declare class LwrModuleBundler implements ModuleBundler {
     appObserver: LwrAppObserver | undefined;
     cache: Map<string, BundleDefinition>;
     providers: BundleProvider[];
+    transformers: UriTransformPlugin[];
     bundleConfig: BundleConfig;
     private inflightBundleDefinitions;
     constructor(config: LwrModuleBundlerConfig, globalConfig: NormalizedLwrGlobalConfig);
     addBundleProviders(providers: BundleProvider[]): void;
+    addBundleTransformers(transformers: UriTransformPlugin[]): void;
     getModuleBundle<T extends AbstractModuleId>(moduleId: T, runtimeEnvironment: SourceMapRuntimeEnvironment, runtimeParams?: RuntimeParams, bundleConfigOverrides?: BundleConfigOverrides): Promise<BundleDefinition>;
     /**
      * Resolve the URI to the bundle rooted at the `moduleId`

package/build/es/index.js

@@ -1,10 +1,12 @@
 import { LwrUnresolvableError, createSingleDiagnosticError, descriptions } from '@lwrjs/diagnostics';
 import { getCacheKeyFromJson, InflightTasks, TaskPool } from '@lwrjs/shared-utils';
+import { join } from 'path';
 const TASK_POOL = new TaskPool();
 export class LwrModuleBundler {
     constructor(config, globalConfig) {
         this.cache = new Map();
         this.providers = [];
+        this.transformers = [];
         // 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.
@@ -22,6 +24,9 @@ export class LwrModuleBundler {
     addBundleProviders(providers) {
         this.providers.push(...providers);
     }
+    addBundleTransformers(transformers) {
+        this.transformers.push(...transformers);
+    }
     async getModuleBundle(moduleId, runtimeEnvironment, runtimeParams = {}, bundleConfigOverrides) {
         const { format, minify, debug } = runtimeEnvironment;
         const cacheKey = `${moduleId.specifier}|${moduleId.version}|${getCacheKeyFromJson({
@@ -85,13 +90,27 @@ export class LwrModuleBundler {
         }
         else {
             let resolvedVersion = moduleId.version || bundleDefinition.version;
-            // If we do not know the verison, look it up.
+            // If we do not know the version, look it up.
             if (!resolvedVersion) {
                 const { version } = await this.moduleRegistry.getModuleEntry(moduleId);
                 resolvedVersion = version;
             }
             uri = String(await this.moduleRegistry.resolveModuleUri({ ...moduleId, version: resolvedVersion }, runtimeEnvironment, runtimeParams, signature));
         }
+        const bundleUri = {
+            artifactType: 'bundle',
+            uri: join(runtimeEnvironment.basePath || '', uri),
+            immutable: runtimeEnvironment.immutableAssets,
+            entry: uri,
+        };
+        // Perform any transforms
+        for (const transformPlugin of this.transformers) {
+            // eslint-disable-next-line no-await-in-loop
+            const resolveUriResult = await transformPlugin.transformUri?.(bundleUri, bundleDefinition, runtimeEnvironment);
+            if (resolveUriResult && resolveUriResult.uri) {
+                uri = resolveUriResult.uri;
+            }
+        }
         return uri;
     }
     getPublicApi() {

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

@@ -1,3 +1,3 @@
 import type { AbstractModuleId, BundleConfigOverrides, 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 }: ProviderAppConfig, bundleConfigOverrides?: BundleConfigOverrides): Promise<BundleDefinition>;
+export declare function amdBundler(rootModuleId: AbstractModuleId, moduleRegistry: ModuleRegistry, minify: boolean | undefined, runtimeEnvironment: RuntimeEnvironment, runtimeParams: RuntimeParams | undefined, { bundleConfig }: ProviderAppConfig, bundleConfigOverrides?: BundleConfigOverrides): Promise<BundleDefinition>;
 //# sourceMappingURL=amd-common.d.ts.map

package/build/es/utils/amd-common.js

@@ -1,14 +1,46 @@
-import { GraphDepth, getModuleGraphs, getSpecifier } from '@lwrjs/shared-utils';
+import { GraphDepth, createAmdAlias, explodeSpecifier, getModuleGraphs, getSpecifier, getGroupName, isGroupie, getCacheKeyFromJson, } from '@lwrjs/shared-utils';
 import { rollup } from 'rollup';
 import replace from '@rollup/plugin-replace';
 import { bundleDefinitions } from './rollup-amd-bundler-plugin.js';
 import { overrideBundleConfig } from './bundle-common.js';
 const AMD_DEFINE = 'LWR.define';
-async function bundle(id, moduleGraphs, minify = false) {
+const groupieCodeCache = new Map();
+function includeIdFactory(graphSpecifier, external, exclude = [], requiredImports, groups) {
+    return (moduleRef) => {
+        // Do not bundle externals, including the loader module, which is auto bundled
+        // with the shim + loader combo
+        if (external[moduleRef.specifier] !== undefined) {
+            // Do not include externals in the required imports but also return false to indicate it should not be in the bundle
+            return false;
+        }
+        const moduleRefIsGroupie = isGroupie(moduleRef.specifier, groups);
+        const rootModuleIsGroupie = isGroupie(graphSpecifier, groups);
+        const moduleIsNotRoot = graphSpecifier !== moduleRef.specifier;
+        if (moduleRefIsGroupie) {
+            // If this is part of bundle group return false to indicate it should not be in the bundle
+            // but add it to the requriedImports so it shows up as a static dependency of the bundle.
+            // However, skip this if the requested specifier is also part of the same group.
+            if (moduleIsNotRoot && !rootModuleIsGroupie) {
+                requiredImports.set(`${moduleRef.specifier}_${moduleRef.version}`, moduleRef);
+            }
+            return false;
+        }
+        else if (exclude?.includes(moduleRef.specifier)) {
+            // If this is a bundle exclude return false to indicate it should not be in the bundle
+            // but add it to the requriedImports so it shows up as a static dependency of the bundle.
+            if (moduleIsNotRoot) {
+                requiredImports.set(`${moduleRef.specifier}_${moduleRef.version}`, moduleRef);
+            }
+            return false;
+        }
+        return true;
+    };
+}
+async function bundle(id, moduleGraphs, minify = false, unVersionedAliases = false) {
     const plugins = [bundleDefinitions({ moduleGraphs })];
     minify &&
         plugins.push(
-        // terser(), // Do not minify until needed for client modules. Server/SSR modules do not need to be minifed.
+        // terser(), // Do not minify until needed for client modules. Server/SSR modules do not need to be minified.
         replace({
             'process.env.NODE_ENV': JSON.stringify('production'),
             preventAssignment: false,
@@ -19,40 +51,39 @@ async function bundle(id, moduleGraphs, minify = false) {
         exports: 'named',
         format: 'amd',
     });
-    return output[0].code;
+    let code = output[0].code;
+    if (unVersionedAliases) {
+        const idObject = explodeSpecifier(id);
+        const specifier = idObject.specifier;
+        const aliasModule = createAmdAlias(specifier, id);
+        code += aliasModule;
+    }
+    return code;
 }
-export async function amdBundler(moduleId, moduleRegistry, minify = false, runtimeEnvironment, runtimeParams = {}, { bundleConfig }, bundleConfigOverrides) {
-    const { exclude, external = {} } = overrideBundleConfig(bundleConfig, bundleConfigOverrides);
-    const externalsArray = Object.keys(external);
-    const requiredImports = new Map();
-    const dynamicImports = new Map();
-    const includedModules = [];
-    const graphOptions = {
-        includeLinkedDefinitions: true,
-        depth: {
-            static: GraphDepth.ALL,
-            dynamic: 0,
-            includeId: (moduleRef) => {
-                // Do not bundle externals, including the loader module, which is auto bundled
-                // with the shim + loader combo
-                if (externalsArray.includes(moduleRef.specifier)) {
-                    // Do not include externals in the required imports but also return false to indicate it should not be in the bundle
-                    return false;
-                }
-                else if (exclude?.includes(moduleRef.specifier)) {
-                    // If this is a bundle exclude return false to indicate it should not be in the bundle
-                    // but add it to the requriedImports so it shows up as a static dependency of the bundle.
-                    requiredImports.set(`${moduleRef.specifier}_${moduleRef.version}`, moduleRef);
-                    return false;
+async function getBundleCode(rootModule, moduleGraphs, includedModules, bundleGroupsIncludedModules, dynamicImports, minify, unVersionedAliases, includeId, moduleRegistry, runtimeEnvironment, runtimeParams = {}, visitedSpecifiers) {
+    const modules = [rootModule, ...moduleGraphs.graphs[0].static];
+    const { moduleRecord } = await moduleRegistry.getModule(explodeSpecifier(rootModule));
+    // add static imports from the LinkedModuleDefinitions added during module linking
+    // they're not in the ModuleGraph imports b/c those are based on raw module source
+    if (moduleRecord.importMeta) {
+        // the only use case for this is "lwr/environment", so skip the logic when it's not needed
+        for (const specifier of modules) {
+            const linkedDefinition = moduleGraphs.linkedDefinitions[specifier];
+            const imports = linkedDefinition?.linkedModuleRecord.imports || [];
+            for (const imp of imports) {
+                const modId = explodeSpecifier(imp.specifier);
+                if (!modules.includes(imp.specifier) && includeId(modId)) {
+                    modules.push(imp.specifier);
+                    if (!moduleGraphs.linkedDefinitions[imp.specifier]) {
+                        // eslint-disable-next-line no-await-in-loop
+                        const missingLinkedModule = await moduleRegistry.getLinkedModule({ specifier: modId.specifier, version: modId.version }, runtimeEnvironment, runtimeParams);
+                        moduleGraphs.linkedDefinitions[imp.specifier] = missingLinkedModule;
+                    }
                 }
-                return true;
-            },
-        },
-    };
-    const moduleGraphs = await getModuleGraphs(moduleId.specifier, graphOptions, moduleRegistry, moduleRegistry, runtimeEnvironment, runtimeParams);
-    const rootModule = moduleGraphs.graphs[0];
-    const modules = [rootModule.specifier, ...moduleGraphs.graphs[0].static];
-    const bundles = await Promise.all(modules
+            }
+        }
+    }
+    const bundles = (await Promise.all(modules
         .reduce((filteredModules, specifier) => {
         const linkedDefinition = moduleGraphs.linkedDefinitions[specifier];
         // skip modules that do not have a linked definition
@@ -75,12 +106,88 @@ export async function amdBundler(moduleId, moduleRegistry, minify = false, runti
     }, [])
         .map((linkedDefinition) => {
         const id = getSpecifier(linkedDefinition);
-        if (id !== rootModule.specifier) {
+        if (visitedSpecifiers?.has(id)) {
+            return false;
+        }
+        else {
+            visitedSpecifiers?.set(id, true);
+        }
+        if (id !== rootModule) {
             includedModules.push(id);
         }
+        else {
+            // we need to still keep track of roots for bundle groups
+            bundleGroupsIncludedModules.push(id);
+        }
         // bundle all dependencies for the linked definition and convert to AMD
-        return bundle(id, moduleGraphs, minify);
-    }));
+        return bundle(id, moduleGraphs, minify, unVersionedAliases);
+    }))).filter((x) => typeof x === 'string');
+    return bundles;
+}
+export async function amdBundler(rootModuleId, moduleRegistry, minify = false, runtimeEnvironment, runtimeParams = {}, { bundleConfig }, bundleConfigOverrides) {
+    const { exclude, external = {}, groups = {} } = overrideBundleConfig(bundleConfig, bundleConfigOverrides);
+    // Note: the maps must be cleared each time we call getModuleGraph
+    const requiredImports = new Map();
+    const dynamicImports = new Map();
+    const groupName = getGroupName(rootModuleId.specifier, groups);
+    const groupies = groupName && groups[groupName];
+    // Note: in reality, bundleConfig cannot change at runtime, but
+    // use it as a cacheKey anyways in case we want to support it in the future
+    const cacheKey = getCacheKeyFromJson({ groupName, exclude, external });
+    const cachedGroupieCode = groupName && groupieCodeCache.get(cacheKey);
+    const getModuleGraphsWrapper = (graphSpecifier) => {
+        const graphOptions = {
+            includeLinkedDefinitions: true,
+            depth: {
+                static: GraphDepth.ALL,
+                dynamic: 0,
+                includeId: includeIdFactory(graphSpecifier, external, exclude, requiredImports, groups),
+            },
+        };
+        return getModuleGraphs(graphSpecifier, graphOptions, moduleRegistry, moduleRegistry, runtimeEnvironment, runtimeParams);
+    };
+    const moduleGraphs = await getModuleGraphsWrapper(rootModuleId.specifier);
+    const rootModule = moduleGraphs.graphs[0];
+    // we also need to get moduleGraphs for any group members this module belongs to
+    const groupModuleGraphsMap = new Map();
+    if (!cachedGroupieCode && groupies && groupies.length) {
+        for (const specifier of groupies) {
+            if (specifier !== rootModuleId.specifier) {
+                // eslint-disable-next-line no-await-in-loop
+                const groupieModuleGraph = await getModuleGraphsWrapper(specifier);
+                groupModuleGraphsMap.set(specifier, groupieModuleGraph);
+            }
+        }
+    }
+    let bundleCode, includedModules, bundleGroupsIncludedModules;
+    // we don't need to recompute the bundle code if it already exists for this group
+    const cachedBundleGroupCode = cachedGroupieCode;
+    const bundledSpecifiersMap = new Map();
+    if (!cachedBundleGroupCode) {
+        (includedModules = []), (bundleGroupsIncludedModules = []);
+        const bundles = await getBundleCode(rootModule.specifier, moduleGraphs, includedModules, bundleGroupsIncludedModules, dynamicImports, minify, !!runtimeEnvironment.featureFlags?.EXPERIMENTAL_UNVERSIONED_ALIASES, includeIdFactory(rootModuleId.specifier, external, exclude, requiredImports, groups), moduleRegistry, runtimeEnvironment, runtimeParams, bundledSpecifiersMap);
+        if (groupName) {
+            // add groupies to bundles
+            for (const rawGroupieSpecifier of groupies) {
+                if (rawGroupieSpecifier !== rootModuleId.specifier) {
+                    const groupieModuleGraph = groupModuleGraphsMap.get(rawGroupieSpecifier);
+                    const groupieSpecifer = groupieModuleGraph.graphs[0].specifier;
+                    // eslint-disable-next-line no-await-in-loop
+                    const groupieBundles = await getBundleCode(groupieSpecifer, groupieModuleGraph, includedModules, bundleGroupsIncludedModules, dynamicImports, minify, !!runtimeEnvironment.featureFlags?.EXPERIMENTAL_UNVERSIONED_ALIASES, includeIdFactory(rawGroupieSpecifier, external, exclude, requiredImports, groups), moduleRegistry, runtimeEnvironment, runtimeParams, bundledSpecifiersMap);
+                    bundles.push(...groupieBundles);
+                }
+            }
+        }
+        bundleCode = bundles.join('');
+        if (groupName) {
+            includedModules.push(...bundleGroupsIncludedModules);
+            groupieCodeCache.set(groupName, { code: bundleCode, includedModules });
+        }
+    }
+    else {
+        bundleCode = cachedBundleGroupCode.code;
+        includedModules = cachedBundleGroupCode.includedModules;
+    }
     const { id, name, namespace, version, specifier } = moduleGraphs.linkedDefinitions[rootModule.specifier];
     return {
         id,
@@ -88,7 +195,7 @@ export async function amdBundler(moduleId, moduleRegistry, minify = false, runti
         namespace,
         version,
         specifier,
-        code: bundles.join(''),
+        code: bundleCode,
         config: { external, exclude },
         bundleRecord: {
             imports: Array.from(requiredImports.values()),

package/build/es/utils/rollup-amd-bundler-plugin.d.ts

@@ -1,5 +1,5 @@
-import { Plugin } from 'rollup';
-import { FlattenedModuleGraphs } from '@lwrjs/types';
+import type { Plugin } from 'rollup';
+import type { FlattenedModuleGraphs } from '@lwrjs/types';
 export interface RollupBundlePluginOptions {
     moduleGraphs: FlattenedModuleGraphs;
 }

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

@@ -1,5 +1,5 @@
-import { LinkedModuleDefinition, RuntimeEnvironment, ModuleRegistry, RuntimeParams, BaseModuleReference, BaseDynamicModuleReference } from '@lwrjs/types';
-import { Plugin } from 'rollup';
+import type { LinkedModuleDefinition, RuntimeEnvironment, ModuleRegistry, RuntimeParams, BaseModuleReference, BaseDynamicModuleReference } from '@lwrjs/types';
+import type { Plugin } from 'rollup';
 export interface RollupBundlePluginOptions {
     rootModuleDef: LinkedModuleDefinition;
     runtimeEnvironment: RuntimeEnvironment;

package/package.json

@@ -4,7 +4,7 @@
     "publishConfig": {
         "access": "public"
     },
-    "version": "0.10.0-alpha.9",
+    "version": "0.10.1",
     "homepage": "https://developer.salesforce.com/docs/platform/lwr/overview",
     "repository": {
         "type": "git",
@@ -37,7 +37,9 @@
         }
     },
     "scripts": {
-        "build": "tsc -b"
+        "build": "tsc -b",
+        "clean": "rm -rf build",
+        "test": "jest"
     },
     "files": [
         "build/**/*.js",
@@ -45,19 +47,24 @@
         "build/**/*.d.ts"
     ],
     "dependencies": {
-        "@lwc/features": "2.45.2",
-        "@lwrjs/shared-utils": "0.10.0-alpha.9",
+        "@lwc/features": "~2.50.0",
+        "@lwrjs/shared-utils": "0.10.1",
         "@rollup/plugin-replace": "^2.4.2",
         "rollup": "^2.78.0"
     },
     "devDependencies": {
-        "@lwrjs/types": "0.10.0-alpha.9"
+        "@lwrjs/types": "0.10.1",
+        "jest": "^26.6.3",
+        "ts-jest": "^26.5.6"
     },
     "optionalDependencies": {
         "esbuild": "^0.9.7"
     },
     "engines": {
-        "node": ">=16.0.0 <20"
+        "node": ">=16.0.0"
     },
-    "gitHead": "6da48f5164ac881396055096a6c1e3d0f8d981aa"
+    "volta": {
+        "extends": "../../../package.json"
+    },
+    "gitHead": "7251846486eb5a1f60bc418fac7967effea57898"
 }