@lwrjs/module-bundler 0.8.0-alpha.1 → 0.8.0-alpha.4

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

@@ -26,60 +26,83 @@ __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_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
+      })
+    ]
+  });
+  const {output} = await bundler.generate({
+    amd: {id, define: import_compiler.AMD_DEFINE},
+    exports: "named",
+    format: "amd"
+  });
+  return output[0].code;
+}
 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();
-  const moduleGraphs = await (0, import_shared_utils.getModuleGraphs)(moduleId.specifier, {
+  const includedModules = [];
+  const graphOptions = {
     includeLinkedDefinitions: true,
     depth: {
       static: import_shared_utils.GraphDepth.ALL,
       dynamic: 0,
       includeId: (moduleRef) => {
-        if (exclude && exclude.includes(moduleRef.specifier) || moduleRef.specifier === amdLoader) {
+        if (exclude?.includes(moduleRef.specifier) || moduleRef.specifier === amdLoader) {
           requiredImports.set(`${moduleId.specifier}_${moduleId.version}`, moduleRef);
           return false;
         }
         return true;
       }
     }
-  }, moduleRegistry, moduleRegistry, runtimeEnvironment, runtimeParams, visited);
+  };
+  const moduleGraphs = await (0, import_shared_utils.getModuleGraphs)(moduleId.specifier, graphOptions, moduleRegistry, moduleRegistry, runtimeEnvironment, runtimeParams);
   const rootModule = moduleGraphs.graphs[0];
-  const rootModuleDef = moduleGraphs.linkedDefinitions[rootModule.specifier];
-  const {id, name, namespace, version, specifier} = rootModuleDef;
-  rootModuleDef?.linkedModuleRecord.dynamicImports?.forEach((e) => {
-    dynamicImports.set(`${e.specifier}_${e.version}`, e);
-  });
-  moduleGraphs.graphs[0].static.forEach((m) => {
-    const d = moduleGraphs.linkedDefinitions[m];
-    d?.linkedModuleRecord.dynamicImports?.forEach((e) => {
-      dynamicImports.set(`${e.specifier}_${e.version}`, e);
+  const modules = [rootModule.specifier, ...moduleGraphs.graphs[0].static];
+  const bundles = await Promise.all(modules.reduce((filteredModules, specifier2) => {
+    const linkedDefinition = moduleGraphs.linkedDefinitions[specifier2];
+    if (!linkedDefinition) {
+      return filteredModules;
+    }
+    linkedDefinition.linkedModuleRecord.dynamicImports?.forEach((dynamicImport) => {
+      if (dynamicImport.moduleNameType !== "unresolved") {
+        dynamicImports.set(`${dynamicImport.specifier}_${dynamicImport.version}`, dynamicImport);
+      }
     });
-  });
-  const code = [];
-  const moduleSpecifiers = [];
-  for (let i = rootModule.static.length - 1; i >= 0; i--) {
-    const s = rootModule.static[i];
-    if (moduleGraphs.linkedDefinitions[s]) {
-      moduleSpecifiers.push(s);
-      code.push(moduleGraphs.linkedDefinitions[s].linkedSource.trimEnd());
+    if (specifier2.includes("#")) {
+      return filteredModules;
     }
-  }
-  code.push(rootModuleDef.linkedSource.trimEnd());
+    filteredModules.unshift(linkedDefinition);
+    return filteredModules;
+  }, []).map((linkedDefinition) => {
+    const id2 = (0, import_shared_utils.getSpecifier)(linkedDefinition);
+    if (id2 !== rootModule.specifier) {
+      includedModules.push(id2);
+    }
+    return bundle(id2, moduleGraphs);
+  }));
+  const {id, name, namespace, version, specifier} = moduleGraphs.linkedDefinitions[rootModule.specifier];
   return {
     id,
     name,
     namespace,
     version,
     specifier,
-    code: code.join(""),
+    code: bundles.join(""),
     config: {external, exclude},
     bundleRecord: {
       imports: Array.from(requiredImports.values()),
       dynamicImports: Array.from(dynamicImports.values()),
-      includedModules: moduleSpecifiers
+      includedModules
     }
   };
 }

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

@@ -0,0 +1,37 @@
+var __defProp = Object.defineProperty;
+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});
+};
+
+// packages/@lwrjs/module-bundler/src/amd/rollup-amd-bundler-plugin.ts
+__markAsModule(exports);
+__export(exports, {
+  bundleDefinitions: () => bundleDefinitions
+});
+function bundleDefinitions(options) {
+  const {moduleGraphs} = options;
+  let root;
+  return {
+    name: "bundle-plugin",
+    resolveDynamicImport() {
+      return false;
+    },
+    resolveId(id, importer) {
+      if (!importer) {
+        root = id;
+      }
+      if (importer && id !== root && !id.includes("#")) {
+        return {
+          id,
+          external: true
+        };
+      }
+      return id;
+    },
+    async load(id) {
+      return moduleGraphs.linkedDefinitions[id].linkedSource;
+    }
+  };
+}

package/build/cjs/index.cjs

@@ -26,9 +26,9 @@ __markAsModule(exports);
 __export(exports, {
   LwrModuleBundler: () => LwrModuleBundler
 });
+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 import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
 var TASK_POOL = new import_shared_utils.TaskPool();
 var LwrModuleBundler = class {
   constructor(config, globalConfig) {
@@ -37,6 +37,7 @@ var LwrModuleBundler = class {
     this.config = globalConfig;
     this.moduleRegistry = config.moduleRegistry;
     this.appObserver = config.appObserver;
+    this.compiler = config.compiler;
     this.appObserver.onModuleDefinitionChange(() => {
       this.cache.clear();
     });
@@ -58,16 +59,21 @@ var LwrModuleBundler = class {
         return bundleDef;
       }
     }
-    const createBundlePromiseCtor = async () => {
+    return this.inflightBundleDefinitions.execute(cacheKey, () => {
       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) => {
+        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);
+        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);
           }
           return bundleDef;
         });
+        return pendingBundleDef;
       }, this);
-    };
-    return this.inflightBundleDefinitions.execute(cacheKey, createBundlePromiseCtor, this);
+    });
   }
 };

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

@@ -1,68 +1,88 @@
-import { getModuleGraphs, GraphDepth } from '@lwrjs/shared-utils';
+import { AMD_DEFINE } from '@lwrjs/compiler';
+import { GraphDepth, getModuleGraphs, getSpecifier } from '@lwrjs/shared-utils';
+import { rollup } from 'rollup';
+import { bundleDefinitions } from './rollup-amd-bundler-plugin.js';
+async function bundle(id, moduleGraphs) {
+    const bundler = await rollup({
+        input: id,
+        plugins: [
+            bundleDefinitions({
+                moduleGraphs,
+            }),
+        ],
+    });
+    const { output } = await bundler.generate({
+        amd: { id, define: AMD_DEFINE },
+        exports: 'named',
+        format: 'amd',
+    });
+    return output[0].code;
+}
 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();
-    const moduleGraphs = await getModuleGraphs(moduleId.specifier, {
+    const includedModules = [];
+    const graphOptions = {
         includeLinkedDefinitions: true,
         depth: {
             static: GraphDepth.ALL,
             dynamic: 0,
             includeId: (moduleRef) => {
-                if ((exclude && exclude.includes(moduleRef.specifier)) ||
-                    // loader should be auto bundled with shim already
-                    moduleRef.specifier === amdLoader) {
+                // loader should be auto bundled with shim already
+                if (exclude?.includes(moduleRef.specifier) || moduleRef.specifier === amdLoader) {
                     requiredImports.set(`${moduleId.specifier}_${moduleId.version}`, moduleRef);
                     return false;
                 }
                 return true;
             },
         },
-    }, moduleRegistry, moduleRegistry, runtimeEnvironment, runtimeParams, visited);
+    };
+    const moduleGraphs = await getModuleGraphs(moduleId.specifier, graphOptions, moduleRegistry, moduleRegistry, runtimeEnvironment, runtimeParams);
     const rootModule = moduleGraphs.graphs[0];
-    // type cast to LinkedModuleDefinition because only the moduleRegistry is used
-    const rootModuleDef = moduleGraphs.linkedDefinitions[rootModule.specifier];
-    const { id, name, namespace, version, specifier } = rootModuleDef;
-    // Collect dynamic imports
-    // Add dynamic imports from the root module
-    rootModuleDef?.linkedModuleRecord.dynamicImports?.forEach((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) => {
-        // type cast to LinkedModuleDefinition because only the moduleRegistry is used
-        const d = moduleGraphs.linkedDefinitions[m];
-        // D would be null if excluded from the bundle
-        d?.linkedModuleRecord.dynamicImports?.forEach((e) => {
-            dynamicImports.set(`${e.specifier}_${e.version}`, e);
+    const modules = [rootModule.specifier, ...moduleGraphs.graphs[0].static];
+    const bundles = await Promise.all(modules
+        .reduce((filteredModules, specifier) => {
+        const linkedDefinition = moduleGraphs.linkedDefinitions[specifier];
+        // skip modules that do not have a linked definition
+        if (!linkedDefinition) {
+            return filteredModules;
+        }
+        // add any dynamic imports from each of the linked definitions in the module graph
+        linkedDefinition.linkedModuleRecord.dynamicImports?.forEach((dynamicImport) => {
+            if (dynamicImport.moduleNameType !== 'unresolved') {
+                dynamicImports.set(`${dynamicImport.specifier}_${dynamicImport.version}`, dynamicImport);
+            }
         });
-    });
-    // loop in reverse for correct order
-    const code = [];
-    const moduleSpecifiers = [];
-    for (let i = rootModule.static.length - 1; i >= 0; i--) {
-        const s = rootModule.static[i];
-        // only included modules will be present in the linkedDefinitions
-        if (moduleGraphs.linkedDefinitions[s]) {
-            moduleSpecifiers.push(s);
-            // type cast to LinkedModuleDefinition becuase only the moduleRegistry is used
-            code.push(moduleGraphs.linkedDefinitions[s].linkedSource.trimEnd());
+        // skip relative dependencies
+        if (specifier.includes('#')) {
+            return filteredModules;
+        }
+        // prepend the linked definition for the correct order
+        filteredModules.unshift(linkedDefinition);
+        return filteredModules;
+    }, [])
+        .map((linkedDefinition) => {
+        const id = getSpecifier(linkedDefinition);
+        if (id !== rootModule.specifier) {
+            includedModules.push(id);
         }
-    }
-    code.push(rootModuleDef.linkedSource.trimEnd());
+        // bundle all dependencies for the linked definition and convert to AMD
+        return bundle(id, moduleGraphs);
+    }));
+    const { id, name, namespace, version, specifier } = moduleGraphs.linkedDefinitions[rootModule.specifier];
     return {
         id,
         name,
         namespace,
         version,
         specifier,
-        code: code.join(''),
+        code: bundles.join(''),
         config: { external, exclude },
         bundleRecord: {
             imports: Array.from(requiredImports.values()),
             dynamicImports: Array.from(dynamicImports.values()),
-            includedModules: moduleSpecifiers,
+            includedModules,
         },
     };
 }

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

@@ -0,0 +1,7 @@
+import { Plugin } from 'rollup';
+import { FlattenedModuleGraphs } from '@lwrjs/types';
+export interface RollupBundlePluginOptions {
+    moduleGraphs: FlattenedModuleGraphs;
+}
+export declare function bundleDefinitions(options: RollupBundlePluginOptions): Plugin;
+//# sourceMappingURL=rollup-amd-bundler-plugin.d.ts.map

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

@@ -0,0 +1,27 @@
+export function bundleDefinitions(options) {
+    const { moduleGraphs } = options;
+    let root;
+    return {
+        name: 'bundle-plugin',
+        resolveDynamicImport() {
+            // NOTE: This might be configurable in the future
+            return false;
+        },
+        resolveId(id, importer) {
+            if (!importer) {
+                root = id;
+            }
+            if (importer && id !== root && !id.includes('#')) {
+                return {
+                    id,
+                    external: true,
+                };
+            }
+            return id;
+        },
+        async load(id) {
+            return moduleGraphs.linkedDefinitions[id].linkedSource;
+        },
+    };
+}
+//# sourceMappingURL=rollup-amd-bundler-plugin.js.map

package/build/es/index.d.ts

@@ -1,9 +1,11 @@
-import { AbstractModuleId, BundleConfig, BundleDefinition, LwrAppObserver, ModuleBundler, ModuleRegistry, NormalizedLwrGlobalConfig, RuntimeParams, SourceMapRuntimeEnvironment } from '@lwrjs/types';
+import { AbstractModuleId, BundleConfig, BundleDefinition, LwrAppObserver, ModuleBundler, ModuleRegistry, NormalizedLwrGlobalConfig, RuntimeParams, SourceMapRuntimeEnvironment, Compiler } from '@lwrjs/types';
 interface LwrModuleBundlerConfig {
+    compiler: Compiler;
     moduleRegistry: ModuleRegistry;
     appObserver: LwrAppObserver;
 }
 export declare class LwrModuleBundler implements ModuleBundler {
+    compiler: Compiler;
     moduleRegistry: ModuleRegistry;
     appObserver: LwrAppObserver;
     config: NormalizedLwrGlobalConfig;

package/build/es/index.js

@@ -1,6 +1,6 @@
+import { getCacheKeyFromJson, InflightTasks, TaskPool } from '@lwrjs/shared-utils';
 import { amdBundler } from './amd/amd-bundler.js';
 import { esmBundler } from './esm/esm-bundler.js';
-import { getCacheKeyFromJson, InflightTasks, TaskPool } from '@lwrjs/shared-utils';
 const TASK_POOL = new TaskPool();
 export class LwrModuleBundler {
     constructor(config, globalConfig) {
@@ -12,6 +12,7 @@ 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
@@ -38,23 +39,27 @@ export class LwrModuleBundler {
                 return bundleDef;
             }
         }
-        // Generate the bundle definition
-        const createBundlePromiseCtor = async () => {
+        return this.inflightBundleDefinitions.execute(cacheKey, () => {
             // 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'
+                const pendingBundleDef = 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;
-                    });
+                    : esmBundler(moduleId, moduleRegistry, runtimeEnvironment, runtimeParams, this.config, bundleConfigOverrides);
+                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);
+                    }
+                    return bundleDef;
+                });
+                return pendingBundleDef;
             }, this);
-        };
-        return this.inflightBundleDefinitions.execute(cacheKey, createBundlePromiseCtor, this);
+        });
     }
 }
 //# sourceMappingURL=index.js.map

package/package.json

@@ -4,7 +4,7 @@
     "publishConfig": {
         "access": "public"
     },
-    "version": "0.8.0-alpha.1",
+    "version": "0.8.0-alpha.4",
     "homepage": "https://developer.salesforce.com/docs/platform/lwr/overview",
     "repository": {
         "type": "git",
@@ -30,14 +30,15 @@
         "build/**/*.d.ts"
     ],
     "dependencies": {
-        "@lwrjs/shared-utils": "0.8.0-alpha.1",
+        "@lwrjs/compiler": "0.8.0-alpha.4",
+        "@lwrjs/shared-utils": "0.8.0-alpha.4",
         "rollup": "~2.45.2"
     },
     "devDependencies": {
-        "@lwrjs/types": "0.8.0-alpha.1"
+        "@lwrjs/types": "0.8.0-alpha.4"
     },
     "engines": {
         "node": ">=14.15.4 <19"
     },
-    "gitHead": "2718cc5abe11d0d6fd5375cf9205167b6f69e244"
+    "gitHead": "a0cca59d2ab1e7596f03812d00180f898217ce4d"
 }