@lwrjs/module-bundler 0.9.0-alpha.15 → 0.9.0-alpha.17

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

@@ -38,10 +38,16 @@ var AmdBundlerProvider = class {
     if (runtimeEnvironment.format === "amd") {
       const {moduleRegistry, config} = this;
       const bundle = await (0, import_amd_common.amdBundler)(moduleId, moduleRegistry, false, runtimeEnvironment, runtimeParams, config, bundleConfigOverrides);
-      const {minify, debug} = runtimeEnvironment;
+      const {
+        minify,
+        debug,
+        env: {NODE_ENV: envMode} = {NODE_ENV: "production"}
+      } = runtimeEnvironment;
       const minified = !!minify && !debug;
       if (minified) {
         bundle.code = await (0, import_esbuild_utils.minifyJavascript)(bundle.code);
+      } else {
+        bundle.code = await (0, import_esbuild_utils.parseJavascript)(bundle.code, {envMode});
       }
       return bundle;
     }

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

@@ -29,6 +29,7 @@ __export(exports, {
 var import_rollup = __toModule(require("rollup"));
 var import_rollup_esm_bundler_plugin = __toModule(require("./utils/rollup-esm-bundler-plugin.cjs"));
 var import_esbuild_utils = __toModule(require("./utils/esbuild-utils.cjs"));
+var import_bundle_common = __toModule(require("./utils/bundle-common.cjs"));
 var EsmBundlerProvider = class {
   constructor(options, {config, moduleRegistry}) {
     this.name = "esm-bundle-provider";
@@ -43,8 +44,8 @@ var EsmBundlerProvider = class {
   }
 };
 var esm_bundle_provider_default = EsmBundlerProvider;
-async function esmBundler(moduleId, moduleRegistry, runtimeEnvironment, runtimeParams = {}, {bundleConfig}, bundleConfigOverride) {
-  const {exclude, external = {}, alias = {}} = bundleConfigOverride ?? bundleConfig;
+async function esmBundler(moduleId, moduleRegistry, runtimeEnvironment, runtimeParams = {}, {bundleConfig}, bundleConfigOverrides) {
+  const {exclude, external = {}, alias = {}} = (0, import_bundle_common.overrideBundleConfig)(bundleConfig, bundleConfigOverrides);
   const {sourceMapUrl} = runtimeEnvironment;
   const requiredImports = new Map();
   const dynamicImports = new Map();

package/build/cjs/index.cjs

@@ -34,9 +34,9 @@ var LwrModuleBundler = class {
     this.cache = new Map();
     this.providers = [];
     this.inflightBundleDefinitions = new import_shared_utils.InflightTasks();
-    this.config = globalConfig;
     this.moduleRegistry = config.moduleRegistry;
     this.appObserver = config.appObserver;
+    this.bundleConfig = Object.freeze(globalConfig.bundleConfig);
     this.appObserver?.onModuleDefinitionChange(() => {
       this.cache.clear();
     });
@@ -77,8 +77,25 @@ var LwrModuleBundler = class {
       }, this);
     });
   }
-  resolveModuleUri(moduleId, runtimeEnvironment, runtimeParams, signature) {
-    return this.moduleRegistry.resolveModuleUri(moduleId, runtimeEnvironment, runtimeParams, signature);
+  async resolveModuleUri(moduleId, runtimeEnvironment, runtimeParams, signature) {
+    const bundleDefinition = await this.getModuleBundle(moduleId, runtimeEnvironment, runtimeParams);
+    if (!bundleDefinition) {
+      throw (0, import_diagnostics.createSingleDiagnosticError)({
+        description: import_diagnostics.descriptions.UNRESOLVABLE.BUNDLE(moduleId.specifier)
+      }, import_diagnostics.LwrUnresolvableError);
+    }
+    let uri;
+    if (bundleDefinition.src) {
+      uri = bundleDefinition.src;
+    } else {
+      let resolvedVersion = moduleId.version || bundleDefinition.version;
+      if (!resolvedVersion) {
+        const {version} = await this.moduleRegistry.getModuleEntry(moduleId);
+        resolvedVersion = version;
+      }
+      uri = String(await this.moduleRegistry.resolveModuleUri({...moduleId, version: resolvedVersion}, runtimeEnvironment, runtimeParams, signature));
+    }
+    return uri;
   }
   getPublicApi() {
     return {

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

@@ -31,6 +31,7 @@ var import_rollup = __toModule(require("rollup"));
 var import_plugin_replace = __toModule(require("@rollup/plugin-replace"));
 var import_rollup_plugin_terser = __toModule(require("rollup-plugin-terser"));
 var import_rollup_amd_bundler_plugin = __toModule(require("./rollup-amd-bundler-plugin.cjs"));
+var import_bundle_common = __toModule(require("./bundle-common.cjs"));
 var AMD_DEFINE = "LWR.define";
 async function bundle(id, moduleGraphs, minify = false) {
   const plugins = [(0, import_rollup_amd_bundler_plugin.bundleDefinitions)({moduleGraphs})];
@@ -46,8 +47,9 @@ async function bundle(id, moduleGraphs, minify = false) {
   });
   return output[0].code;
 }
-async function amdBundler(moduleId, moduleRegistry, minify = false, runtimeEnvironment, runtimeParams = {}, {bundleConfig, amdLoader}, bundleConfigOverride) {
-  const {exclude, external} = bundleConfigOverride ?? bundleConfig;
+async function amdBundler(moduleId, moduleRegistry, minify = false, runtimeEnvironment, runtimeParams = {}, {bundleConfig, amdLoader}, 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 = [];
@@ -57,8 +59,10 @@ async function amdBundler(moduleId, moduleRegistry, minify = false, runtimeEnvir
       static: import_shared_utils.GraphDepth.ALL,
       dynamic: 0,
       includeId: (moduleRef) => {
-        if (exclude?.includes(moduleRef.specifier) || moduleRef.specifier === amdLoader) {
-          requiredImports.set(`${moduleId.specifier}_${moduleId.version}`, moduleRef);
+        if (externalsArray.includes(moduleRef.specifier) || moduleRef.specifier === amdLoader) {
+          return false;
+        } else if (exclude?.includes(moduleRef.specifier)) {
+          requiredImports.set(`${moduleRef.specifier}_${moduleRef.version}`, moduleRef);
           return false;
         }
         return true;

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

@@ -0,0 +1,44 @@
+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/utils/bundle-common.ts
+__markAsModule(exports);
+__export(exports, {
+  overrideBundleConfig: () => overrideBundleConfig
+});
+function overrideBundleConfig(bundleConfig, bundleConfigOverrides) {
+  if (!bundleConfigOverrides) {
+    return bundleConfig;
+  }
+  const newBundleConfig = {
+    UNSAFE_lwrDefaultExclude: [
+      ...bundleConfigOverrides.UNSAFE_lwrDefaultExclude || [
+        ...bundleConfig.UNSAFE_lwrDefaultExclude || []
+      ]
+    ],
+    external: {...bundleConfigOverrides.external || {...bundleConfig.external || {}}},
+    alias: {...bundleConfigOverrides.alias || {...bundleConfig.alias || {}}}
+  };
+  if (bundleConfigOverrides.appendExcludes) {
+    newBundleConfig.exclude = appendAndDedupArrays(bundleConfig.exclude, bundleConfigOverrides.exclude);
+  } else {
+    newBundleConfig.exclude = [...bundleConfigOverrides.exclude || [...bundleConfig.exclude || []]];
+  }
+  return newBundleConfig;
+}
+function appendAndDedupArrays(a1, a2) {
+  let ret;
+  if (!a1 && a2) {
+    return a2.filter((item, pos) => a2.indexOf(item) === pos);
+  } else if (!a2 && a1) {
+    return a1.filter((item, pos) => a1.indexOf(item) === pos);
+  } else if (a1 && a2) {
+    const c = a1?.concat(a2);
+    return c.filter((item, pos) => c.indexOf(item) === pos);
+  }
+  return ret;
+}

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

@@ -24,7 +24,8 @@ var __toModule = (module2) => {
 // packages/@lwrjs/module-bundler/src/utils/esbuild-utils.ts
 __markAsModule(exports);
 __export(exports, {
-  minifyJavascript: () => minifyJavascript
+  minifyJavascript: () => minifyJavascript,
+  parseJavascript: () => parseJavascript
 });
 var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
 var import_esbuild = __toModule(require("esbuild"));
@@ -48,3 +49,16 @@ async function minifyJavascript(source) {
     throw error;
   }
 }
+async function parseJavascript(source, options) {
+  try {
+    const {code} = await esbuild.transform(source, {
+      loader: "js",
+      minify: false,
+      define: {"process.env.NODE_ENV": JSON.stringify(options.envMode)}
+    });
+    return code;
+  } catch (error) {
+    import_shared_utils.logger.debug(error);
+    throw error;
+  }
+}

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

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

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

@@ -1,5 +1,5 @@
 import { amdBundler } from './utils/amd-common.js';
-import { minifyJavascript } from './utils/esbuild-utils.js';
+import { minifyJavascript, parseJavascript } from './utils/esbuild-utils.js';
 export default class AmdBundlerProvider {
     constructor(options, { config, moduleRegistry }) {
         this.name = 'amd-bundle-provider';
@@ -12,11 +12,14 @@ export default class AmdBundlerProvider {
             const bundle = await amdBundler(moduleId, moduleRegistry, false, // we NEVER want to minify via rollup/terser with this bundler; it's too slow
             runtimeEnvironment, runtimeParams, config, bundleConfigOverrides);
             // Minification via esbuild for performance
-            const { minify, debug } = runtimeEnvironment;
+            const { minify, debug, env: { NODE_ENV: envMode } = { NODE_ENV: 'production' }, } = runtimeEnvironment;
             const minified = !!minify && !debug;
             if (minified) {
                 bundle.code = await minifyJavascript(bundle.code);
             }
+            else {
+                bundle.code = await parseJavascript(bundle.code, { envMode });
+            }
             return bundle;
         }
     }

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

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

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

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

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

@@ -1,6 +1,7 @@
 import { rollup } from 'rollup';
 import { bundleDefinitions } from './utils/rollup-esm-bundler-plugin.js';
 import { minifyJavascript } from './utils/esbuild-utils.js';
+import { overrideBundleConfig } from './utils/bundle-common.js';
 export default class EsmBundlerProvider {
     constructor(options, { config, moduleRegistry }) {
         this.name = 'esm-bundle-provider';
@@ -14,8 +15,8 @@ export default class EsmBundlerProvider {
         }
     }
 }
-async function esmBundler(moduleId, moduleRegistry, runtimeEnvironment, runtimeParams = {}, { bundleConfig }, bundleConfigOverride) {
-    const { exclude, external = {}, alias = {} } = bundleConfigOverride ?? bundleConfig;
+async function esmBundler(moduleId, moduleRegistry, runtimeEnvironment, runtimeParams = {}, { bundleConfig }, bundleConfigOverrides) {
+    const { exclude, external = {}, alias = {} } = overrideBundleConfig(bundleConfig, bundleConfigOverrides);
     const { sourceMapUrl } = runtimeEnvironment;
     const requiredImports = new Map();
     const dynamicImports = new Map();

package/build/es/index.d.ts

@@ -1,4 +1,4 @@
-import { AbstractModuleId, BundleConfig, BundleDefinition, BundleProvider, LwrAppObserver, ModuleBundler, ModuleId, ModuleRegistry, NormalizedLwrGlobalConfig, PublicModuleBundler, RuntimeEnvironment, RuntimeParams, SourceMapRuntimeEnvironment } from '@lwrjs/types';
+import { AbstractModuleId, BundleConfig, BundleConfigOverrides, BundleDefinition, BundleProvider, LwrAppObserver, ModuleBundler, ModuleId, ModuleRegistry, NormalizedLwrGlobalConfig, PublicModuleBundler, RuntimeEnvironment, RuntimeParams, SourceMapRuntimeEnvironment } from '@lwrjs/types';
 interface LwrModuleBundlerConfig {
     moduleRegistry: ModuleRegistry;
     appObserver?: LwrAppObserver;
@@ -6,13 +6,13 @@ interface LwrModuleBundlerConfig {
 export declare class LwrModuleBundler implements ModuleBundler {
     moduleRegistry: ModuleRegistry;
     appObserver: LwrAppObserver | undefined;
-    config: NormalizedLwrGlobalConfig;
     cache: Map<string, BundleDefinition>;
     providers: BundleProvider[];
+    bundleConfig: BundleConfig;
     private inflightBundleDefinitions;
     constructor(config: LwrModuleBundlerConfig, globalConfig: NormalizedLwrGlobalConfig);
     addBundleProviders(providers: BundleProvider[]): void;
-    getModuleBundle<T extends AbstractModuleId>(moduleId: T, runtimeEnvironment: SourceMapRuntimeEnvironment, runtimeParams?: RuntimeParams, bundleConfigOverrides?: BundleConfig): Promise<BundleDefinition>;
+    getModuleBundle<T extends AbstractModuleId>(moduleId: T, runtimeEnvironment: SourceMapRuntimeEnvironment, runtimeParams?: RuntimeParams, bundleConfigOverrides?: BundleConfigOverrides): Promise<BundleDefinition>;
     /**
      * Resolve the URI to the bundle rooted at the `moduleId`
      * @param moduleId - The id of the root module for the bundle
@@ -21,7 +21,7 @@ export declare class LwrModuleBundler implements ModuleBundler {
      * @param signature - The signature of the bundle instance being referenced
      * @returns the URI
      */
-    resolveModuleUri<R extends RuntimeEnvironment, S extends string | undefined>(moduleId: Required<Pick<ModuleId, 'specifier' | 'version'>>, runtimeEnvironment: R, runtimeParams?: RuntimeParams, signature?: S): S extends string ? string : Promise<string>;
+    resolveModuleUri(moduleId: Required<Pick<ModuleId, 'specifier' | 'version'>>, runtimeEnvironment: RuntimeEnvironment, runtimeParams?: RuntimeParams, signature?: string): Promise<string>;
     getPublicApi(): PublicModuleBundler;
 }
 export {};

package/build/es/index.js

@@ -9,9 +9,10 @@ export class LwrModuleBundler {
         // Subsequent requests for the same bundle will await the original promise.
         // Cache entries will be removed once the bundle is resolved.
         this.inflightBundleDefinitions = new InflightTasks();
-        this.config = globalConfig;
         this.moduleRegistry = config.moduleRegistry;
         this.appObserver = config.appObserver;
+        // Freeze the bundle config to make sure it is not modified
+        this.bundleConfig = Object.freeze(globalConfig.bundleConfig);
         this.appObserver?.onModuleDefinitionChange(() => {
             // TODO: This is a very naive approach however
             // this would only happen in non-prod environments
@@ -69,10 +70,29 @@ export class LwrModuleBundler {
      * @param signature - The signature of the bundle instance being referenced
      * @returns the URI
      */
-    resolveModuleUri(moduleId, runtimeEnvironment, runtimeParams, signature) {
-        // TODO: Integrate resolving from a site caches.
-        // Fallback to resolving the URI from the registry.
-        return this.moduleRegistry.resolveModuleUri(moduleId, runtimeEnvironment, runtimeParams, signature);
+    async resolveModuleUri(moduleId, runtimeEnvironment, runtimeParams, signature) {
+        // First get the bundle definition to see if a src attribute is set.
+        const bundleDefinition = await this.getModuleBundle(moduleId, runtimeEnvironment, runtimeParams);
+        if (!bundleDefinition) {
+            throw createSingleDiagnosticError({
+                description: descriptions.UNRESOLVABLE.BUNDLE(moduleId.specifier),
+            }, LwrUnresolvableError);
+        }
+        let uri;
+        if (bundleDefinition.src) {
+            // If source is provided on the bundle definition use that
+            uri = bundleDefinition.src;
+        }
+        else {
+            let resolvedVersion = moduleId.version || bundleDefinition.version;
+            // If we do not know the verison, 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));
+        }
+        return uri;
     }
     getPublicApi() {
         return {

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

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

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

@@ -3,6 +3,7 @@ import { rollup } from 'rollup';
 import replace from '@rollup/plugin-replace';
 import { terser } from 'rollup-plugin-terser';
 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 plugins = [bundleDefinitions({ moduleGraphs })];
@@ -19,8 +20,9 @@ async function bundle(id, moduleGraphs, minify = false) {
     });
     return output[0].code;
 }
-export async function amdBundler(moduleId, moduleRegistry, minify = false, runtimeEnvironment, runtimeParams = {}, { bundleConfig, amdLoader }, bundleConfigOverride) {
-    const { exclude, external } = bundleConfigOverride ?? bundleConfig;
+export async function amdBundler(moduleId, moduleRegistry, minify = false, runtimeEnvironment, runtimeParams = {}, { bundleConfig, amdLoader }, bundleConfigOverrides) {
+    const { exclude, external = {} } = overrideBundleConfig(bundleConfig, bundleConfigOverrides);
+    const externalsArray = Object.keys(external);
     const requiredImports = new Map();
     const dynamicImports = new Map();
     const includedModules = [];
@@ -30,9 +32,16 @@ export async function amdBundler(moduleId, moduleRegistry, minify = false, runti
             static: GraphDepth.ALL,
             dynamic: 0,
             includeId: (moduleRef) => {
-                // loader should be auto bundled with shim already
-                if (exclude?.includes(moduleRef.specifier) || moduleRef.specifier === amdLoader) {
-                    requiredImports.set(`${moduleId.specifier}_${moduleId.version}`, moduleRef);
+                // Do not bundle externals, including the loader module, which is auto bundled
+                // with the shim + loader combo
+                if (externalsArray.includes(moduleRef.specifier) || moduleRef.specifier === amdLoader) {
+                    // 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;

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

@@ -0,0 +1,3 @@
+import type { BundleConfig, BundleConfigOverrides } from '@lwrjs/types';
+export declare function overrideBundleConfig(bundleConfig: BundleConfig, bundleConfigOverrides?: BundleConfigOverrides): BundleConfig;
+//# sourceMappingURL=bundle-common.d.ts.map

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

@@ -0,0 +1,39 @@
+export function overrideBundleConfig(bundleConfig, bundleConfigOverrides) {
+    if (!bundleConfigOverrides) {
+        return bundleConfig;
+    }
+    // Replace properties that are overridden
+    const newBundleConfig = {
+        UNSAFE_lwrDefaultExclude: [
+            ...(bundleConfigOverrides.UNSAFE_lwrDefaultExclude || [
+                ...(bundleConfig.UNSAFE_lwrDefaultExclude || []),
+            ]),
+        ],
+        external: { ...(bundleConfigOverrides.external || { ...(bundleConfig.external || {}) }) },
+        alias: { ...(bundleConfigOverrides.alias || { ...(bundleConfig.alias || {}) }) },
+    };
+    // Append Excludes
+    if (bundleConfigOverrides.appendExcludes) {
+        newBundleConfig.exclude = appendAndDedupArrays(bundleConfig.exclude, bundleConfigOverrides.exclude);
+        // or Replace Excludes
+    }
+    else {
+        newBundleConfig.exclude = [...(bundleConfigOverrides.exclude || [...(bundleConfig.exclude || [])])];
+    }
+    return newBundleConfig;
+}
+function appendAndDedupArrays(a1, a2) {
+    let ret;
+    if (!a1 && a2) {
+        return a2.filter((item, pos) => a2.indexOf(item) === pos);
+    }
+    else if (!a2 && a1) {
+        return a1.filter((item, pos) => a1.indexOf(item) === pos);
+    }
+    else if (a1 && a2) {
+        const c = a1?.concat(a2);
+        return c.filter((item, pos) => c.indexOf(item) === pos);
+    }
+    return ret;
+}
+//# sourceMappingURL=bundle-common.js.map

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

@@ -1,6 +1,14 @@
+interface ParseOptions {
+    envMode: string;
+}
 /**
  * Minification via esbuild.
  * When importing this module make sure the optional library 'esbuild' is installed.
  */
 export declare function minifyJavascript(source: string): Promise<string>;
+/**
+ * Parse source to remove process.env.NODE_ENV without minify
+ */
+export declare function parseJavascript(source: string, options: ParseOptions): Promise<string>;
+export {};
 //# sourceMappingURL=esbuild-utils.d.ts.map

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

@@ -2,7 +2,7 @@ import { logger } from '@lwrjs/shared-utils';
 import esbuildEsm from 'esbuild';
 // https://github.com/evanw/esbuild/issues/706
 // Fixed in 0.11.0 but upgrading past 0.9.7 has caused breaking changes for consumers...
-// https://github.com/salesforce-experience-platform/lwr/issues/1014
+// https://github.com/salesforce-experience-platform-emu/lwr/issues/1014
 let esbuild = esbuildEsm;
 if (!esbuildEsm) {
     try {
@@ -31,4 +31,22 @@ export async function minifyJavascript(source) {
         throw error;
     }
 }
+/**
+ * Parse source to remove process.env.NODE_ENV without minify
+ */
+export async function parseJavascript(source, options) {
+    try {
+        const { code } = await esbuild.transform(source, {
+            loader: 'js',
+            minify: false,
+            // Remove assertions by tree shaking the computed expression
+            define: { 'process.env.NODE_ENV': JSON.stringify(options.envMode) },
+        });
+        return code;
+    }
+    catch (error) {
+        logger.debug(error);
+        throw error;
+    }
+}
 //# sourceMappingURL=esbuild-utils.js.map

package/package.json

@@ -4,15 +4,15 @@
     "publishConfig": {
         "access": "public"
     },
-    "version": "0.9.0-alpha.15",
+    "version": "0.9.0-alpha.17",
     "homepage": "https://developer.salesforce.com/docs/platform/lwr/overview",
     "repository": {
         "type": "git",
-        "url": "https://github.com/salesforce/lwr.git",
+        "url": "https://github.com/salesforce-experience-platform-emu/lwr.git",
         "directory": "packages/@lwrjs/module-registry"
     },
     "bugs": {
-        "url": "https://github.com/salesforce/lwr/issues"
+        "url": "https://github.com/salesforce-experience-platform-emu/lwr/issues"
     },
     "type": "module",
     "types": "build/es/index.d.ts",
@@ -36,19 +36,22 @@
             "require": "./build/cjs/esm-bundle-provider.cjs"
         }
     },
+    "scripts": {
+        "build": "tsc -b"
+    },
     "files": [
         "build/**/*.js",
         "build/**/*.cjs",
         "build/**/*.d.ts"
     ],
     "dependencies": {
-        "@lwrjs/shared-utils": "0.9.0-alpha.15",
+        "@lwrjs/shared-utils": "0.9.0-alpha.17",
         "@rollup/plugin-replace": "^2.4.2",
         "rollup": "~2.45.2",
         "rollup-plugin-terser": "^7.0.2"
     },
     "devDependencies": {
-        "@lwrjs/types": "0.9.0-alpha.15"
+        "@lwrjs/types": "0.9.0-alpha.17"
     },
     "optionalDependencies": {
         "esbuild": "^0.9.7"
@@ -56,5 +59,9 @@
     "engines": {
         "node": ">=14.15.4 <19"
     },
-    "gitHead": "f32f103d2d5e516daccce1be69f68acd7b4b86fb"
+    "volta": {
+        "node": "14.19.1",
+        "yarn": "1.22.19"
+    },
+    "gitHead": "447417ff091802927b25cfc1bcb01da02264f41b"
 }