@lwrjs/module-bundler 0.10.0-alpha.13 → 0.10.0-alpha.14

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

@@ -32,7 +32,8 @@ 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();
+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 +45,18 @@ async function bundle(id, moduleGraphs, minify = false) {
     exports: "named",
     format: "amd"
   });
+  if (unVersionedAliases) {
+    const idObject = (0, import_shared_utils.explodeSpecifier)(id);
+    const specifier = idObject.specifier;
+    const aliasModule = ` LWR.define('${specifier}',['${id}'],function(m){return m;});`;
+    output[0].code += aliasModule;
+  }
   return output[0].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;
-        }
-        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];
+async function getBundleCode(rootModule, moduleGraphs, includedModules, bundleGroupsIncludedModules, dynamicImports, minify, unVersionedAliases) {
+  const modules = [rootModule, ...moduleGraphs.graphs[0].static];
+  const bundles = await Promise.all(modules.reduce((filteredModules, specifier) => {
+    const linkedDefinition = moduleGraphs.linkedDefinitions[specifier];
     if (!linkedDefinition) {
       return filteredModules;
     }
@@ -81,18 +65,95 @@ 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 (id !== rootModule) {
+      includedModules.push(id);
+    } else {
+      bundleGroupsIncludedModules.push(id);
     }
-    return bundle(id2, moduleGraphs, minify);
+    return bundle(id, moduleGraphs, minify, unVersionedAliases);
   }));
+  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 externalsArray = Object.keys(external);
+  const requiredImports = new Map();
+  const dynamicImports = new Map();
+  const groupName = (0, import_shared_utils.getGroupName)(rootModuleId.specifier, groups);
+  const groupies = groupName && groups[groupName];
+  const cachedGroupieCode = groupName && groupieCodeCache.get(groupName);
+  const getModuleGraphsWrapper = (graphSpecifier) => {
+    const graphOptions = {
+      includeLinkedDefinitions: true,
+      depth: {
+        static: import_shared_utils.GraphDepth.ALL,
+        dynamic: 0,
+        includeId: (moduleRef) => {
+          if (externalsArray.includes(moduleRef.specifier)) {
+            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;
+        }
+      }
+    };
+    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;
+  if (!cachedBundleGroupCode) {
+    includedModules = [], bundleGroupsIncludedModules = [];
+    const bundles = await getBundleCode(rootModule.specifier, moduleGraphs, includedModules, bundleGroupsIncludedModules, dynamicImports, minify, !!runtimeEnvironment.featureFlags?.UNVERSIONED_ALIASES);
+    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?.UNVERSIONED_ALIASES);
+          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 +161,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/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,15 @@
-import { GraphDepth, getModuleGraphs, getSpecifier } from '@lwrjs/shared-utils';
+import { GraphDepth, explodeSpecifier, getModuleGraphs, getSpecifier, getGroupName, isGroupie, } 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();
+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,39 +20,16 @@ async function bundle(id, moduleGraphs, minify = false) {
         exports: 'named',
         format: 'amd',
     });
+    if (unVersionedAliases) {
+        const idObject = explodeSpecifier(id);
+        const specifier = idObject.specifier;
+        const aliasModule = ` LWR.define('${specifier}',['${id}'],function(m){return m;});`;
+        output[0].code += aliasModule;
+    }
     return output[0].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;
-                }
-                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];
+async function getBundleCode(rootModule, moduleGraphs, includedModules, bundleGroupsIncludedModules, dynamicImports, minify, unVersionedAliases) {
+    const modules = [rootModule, ...moduleGraphs.graphs[0].static];
     const bundles = await Promise.all(modules
         .reduce((filteredModules, specifier) => {
         const linkedDefinition = moduleGraphs.linkedDefinitions[specifier];
@@ -75,12 +53,107 @@ export async function amdBundler(moduleId, moduleRegistry, minify = false, runti
     }, [])
         .map((linkedDefinition) => {
         const id = getSpecifier(linkedDefinition);
-        if (id !== rootModule.specifier) {
+        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);
     }));
+    return bundles;
+}
+export async function amdBundler(rootModuleId, moduleRegistry, minify = false, runtimeEnvironment, runtimeParams = {}, { bundleConfig }, bundleConfigOverrides) {
+    const { exclude, external = {}, groups = {} } = overrideBundleConfig(bundleConfig, bundleConfigOverrides);
+    const externalsArray = Object.keys(external);
+    // 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];
+    const cachedGroupieCode = groupName && groupieCodeCache.get(groupName);
+    const getModuleGraphsWrapper = (graphSpecifier) => {
+        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;
+                    }
+                    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;
+                },
+            },
+        };
+        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;
+    if (!cachedBundleGroupCode) {
+        (includedModules = []), (bundleGroupsIncludedModules = []);
+        const bundles = await getBundleCode(rootModule.specifier, moduleGraphs, includedModules, bundleGroupsIncludedModules, dynamicImports, minify, !!runtimeEnvironment.featureFlags?.UNVERSIONED_ALIASES);
+        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?.UNVERSIONED_ALIASES);
+                    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 +161,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/package.json

@@ -4,7 +4,7 @@
     "publishConfig": {
         "access": "public"
     },
-    "version": "0.10.0-alpha.13",
+    "version": "0.10.0-alpha.14",
     "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",
@@ -46,12 +48,15 @@
     ],
     "dependencies": {
         "@lwc/features": "2.45.2",
-        "@lwrjs/shared-utils": "0.10.0-alpha.13",
+        "@lwrjs/shared-utils": "0.10.0-alpha.14",
         "@rollup/plugin-replace": "^2.4.2",
         "rollup": "^2.78.0"
     },
     "devDependencies": {
-        "@lwrjs/types": "0.10.0-alpha.13"
+        "@lwrjs/types": "0.10.0-alpha.14",
+        "jest": "^26.6.3",
+        "ts-jest": "^26.5.6",
+        "typescript": "~4.3.5"
     },
     "optionalDependencies": {
         "esbuild": "^0.9.7"
@@ -59,5 +64,8 @@
     "engines": {
         "node": ">=16.0.0 <20"
     },
-    "gitHead": "f6d142d5a027554cb1685389e0b173734149683d"
+    "volta": {
+        "extends": "../../../package.json"
+    },
+    "gitHead": "f80dc1c18719b77c183f339027313be11d69f9dc"
 }