@lwrjs/loader 0.22.9 → 0.22.11

package/build/shim-legacy/shimLegacy.d.ts

@@ -6,6 +6,7 @@ export default class LoaderShim {
     private loaderModule;
     private defineCache;
     private orderedDefs;
+    private importMapUpdatesCache;
     private errorHandler?;
     private watchdogTimerId?;
     constructor(global: GlobalThis);
@@ -20,6 +21,19 @@ export default class LoaderShim {
      *          the order in which the modules were defined
      */
     private tempDefine;
+    /**
+     * Create a temporary LWR.importMap() function which captures all
+     * import map updates that occur BEFORE the full loader module is available
+     *
+     * Each import map update is validated, converted to moduleName -> URL mapping,
+     * and merged into the importMapUpdatesCache with write-once protection
+     */
+    private tempImportMap;
+    /**
+     * Apply all cached import map updates and merge with bootstrap import map
+     * Returns merged import map
+     */
+    private getImportMappingsWithUpdates;
     private postCustomInit;
     private initApp;
     private waitForBody;

package/build/shim-legacy/shimLegacy.js

@@ -4,6 +4,8 @@ import { logOperationStart, logOperationEnd } from 'lwr/profiler';
 import { createLoader } from './loaderLegacy.js';
 import { REQUIRED_MODULES_TIMEOUT } from '../shim/constants.js';
 import { customInit } from '../shim/customInit.js';
+import { validateAndConvertImportMapUpdate } from '../modules/lwr/loaderLegacy/utils/validation.js';
+import { mergeImportMapEntry } from '../modules/lwr/loaderLegacy/importMap/utils.js';
 /* eslint-disable lwr/no-unguarded-apis */
 const hasSetTimeout = typeof setTimeout === 'function';
 const hasConsole = typeof console !== 'undefined';
@@ -13,6 +15,7 @@ export default class LoaderShim {
     constructor(global) {
         this.defineCache = {};
         this.orderedDefs = [];
+        this.importMapUpdatesCache = {};
         // Start watchdog timer
         if (hasSetTimeout) {
             this.watchdogTimerId = this.startWatchdogTimer();
@@ -23,9 +26,11 @@ export default class LoaderShim {
         this.loaderModule = 'lwr/loaderLegacy/v/__VERSION__';
         // Set up error handler
         this.errorHandler = this.config.onError;
-        // Set up the temporary LWR.define function and customInit hook
+        // Set up the temporary LWR.define and LWR.importMap functions
         const tempDefine = this.tempDefine.bind(this);
         global.LWR.define = tempDefine;
+        const tempImportMapMethod = this.tempImportMap.bind(this);
+        global.LWR.importMap = tempImportMapMethod;
         this.bootReady = this.config.autoBoot;
         try {
             this.createProfilerModule(global.LWR.define);
@@ -73,6 +78,48 @@ export default class LoaderShim {
             this.initApp();
         }
     }
+    /**
+     * Create a temporary LWR.importMap() function which captures all
+     * import map updates that occur BEFORE the full loader module is available
+     *
+     * Each import map update is validated, converted to moduleName -> URL mapping,
+     * and merged into the importMapUpdatesCache with write-once protection
+     */
+    tempImportMap(importMapUpdate) {
+        try {
+            // Validate and convert the import map update to { imports: { moduleName: moduleScriptURL } }
+            const importMap = validateAndConvertImportMapUpdate(importMapUpdate);
+            // Early return if update was empty
+            if (!importMap) {
+                return;
+            }
+            // Merge into cache with write-once protection
+            for (const [moduleName, moduleScriptURL] of Object.entries(importMap.imports)) {
+                mergeImportMapEntry(moduleName, moduleScriptURL, this.importMapUpdatesCache);
+            }
+        }
+        catch (e) {
+            this.enterErrorState(e);
+        }
+    }
+    /**
+     * Apply all cached import map updates and merge with bootstrap import map
+     * Returns merged import map
+     */
+    getImportMappingsWithUpdates() {
+        // Start with bootstrap import map
+        // Cast importMappings from object to ImportMap to access properties
+        const bootstrapMappings = this.config.importMappings;
+        // Merge with write-once protection: bootstrap mappings take precedence
+        const mergedImports = { ...(bootstrapMappings?.imports || {}) };
+        for (const [specifier, uri] of Object.entries(this.importMapUpdatesCache)) {
+            mergeImportMapEntry(specifier, uri, mergedImports);
+        }
+        return {
+            ...(bootstrapMappings || {}),
+            imports: mergedImports,
+        };
+    }
     // Called by the customInit hook via lwr.initializeApp()
     postCustomInit() {
         this.bootReady = true;
@@ -99,7 +146,7 @@ export default class LoaderShim {
                     rootComponents: this.config.rootComponents,
                 },
             };
-            const loader = createLoader(this.loaderModule, this.defineCache[this.loaderModule], loaderConfig, this.config.preloadModules);
+            const loader = createLoader(this.loaderModule, this.defineCache[this.loaderModule], loaderConfig, this.config.preloadModules, this.defineCache);
             this.mountApp(loader);
             if (loader &&
                 typeof loader.getModuleWarnings === 'function' &&
@@ -155,10 +202,12 @@ export default class LoaderShim {
     }
     // Set up the application globals, import map, root custom element...
     mountApp(loader) {
-        const { bootstrapModule, rootComponent, importMappings, rootComponents, serverData, endpoints } = this.config;
+        const { bootstrapModule, rootComponent, rootComponents, serverData, endpoints } = this.config;
+        const importMappings = this.getImportMappingsWithUpdates();
         // Set global LWR.define to loader.define
         this.global.LWR = Object.freeze({
             define: loader.define.bind(loader),
+            importMap: loader.importMap.bind(loader),
             rootComponent,
             rootComponents,
             serverData: serverData || {},
@@ -180,7 +229,7 @@ export default class LoaderShim {
             .registerImportMappings(importMappings)
             .then(() => {
             // eslint-disable-next-line lwr/no-unguarded-apis
-            if (typeof window === 'undefined' || typeof document === undefined) {
+            if (typeof window === 'undefined' || typeof document === 'undefined') {
                 return Promise.resolve();
             }
             if (initDeferDOM) {

package/build/types.d.ts

@@ -4,14 +4,35 @@ import type { ProfilerAPI, LogDispatcher } from 'lwr/profiler';
 export type GlobalThis = {
     LWR: Partial<ClientBootstrapConfig> & {
         define: LoaderDefine;
+        importMap?: LwrImportMapUpdateMethod;
     };
     [key: string]: unknown;
 };
 export type LoaderDefine = (id: string, deps: string[], exporter: Function, hash?: object) => void;
+/** define(id, deps, factory, hash?) - full form. Same shape as LoaderDefine args. (from main) */
 export type DefineArguments = [string, string[], Function, object?];
+/** Raw args from define() - at least [id, depsOrFactory]; may include factory, hash. Used for parsing. */
+export type DefineArgsInput = readonly [id: string, depsOrFactory: unknown, factory?: unknown, hash?: object];
+export interface ParseDefineResult {
+    deps: string[];
+    /** Same as DefineArguments[2] / LoaderDefine exporter */
+    factory: Function;
+}
+/** Normalized loader factory: receives (exports, ...resolvedDeps). Used after resolveLoaderDepsFromDefineCache. */
+export type LoaderFactory = (exports: object, ...deps: unknown[]) => void;
+/** Args passed to the loader factory: [exports, ...resolvedDeps]. First element is always the exports bag. */
+export type LoaderFactoryArgs = [exports: object, ...deps: unknown[]];
+/** Result of resolveLoaderDepsFromDefineCache. Typed for createLoader consumption. */
+export interface ResolvedLoader {
+    factory: LoaderFactory;
+    args: LoaderFactoryArgs;
+    exportsObj: object;
+}
 export type LoaderClass = {
     new (config?: LoaderConfig): LoaderAPI;
 };
+export type ImportMapUpdate = Record<string, string[]>;
+export type LwrImportMapUpdateMethod = (update: ImportMapUpdate) => void;
 export interface BaseLoaderAPI {
     define: LoaderDefine;
     load(id: string): Promise<unknown>;
@@ -22,6 +43,7 @@ export interface BaseLoaderAPI {
 }
 export interface LoaderAPI extends BaseLoaderAPI {
     registerImportMappings(mappings?: ImportMap): Promise<void>;
+    importMap: LwrImportMapUpdateMethod;
 }
 export type LoaderConfig = {
     baseUrl?: string;

package/package.json

@@ -5,7 +5,7 @@
     "publishConfig": {
         "access": "public"
     },
-    "version": "0.22.9",
+    "version": "0.22.11",
     "homepage": "https://developer.salesforce.com/docs/platform/lwr/overview",
     "repository": {
         "type": "git",
@@ -61,16 +61,16 @@
     },
     "devDependencies": {
         "@locker/trusted-types": "0.26.4",
-        "@lwrjs/diagnostics": "0.22.9",
-        "@lwrjs/types": "0.22.9",
+        "@lwrjs/diagnostics": "0.22.11",
+        "@lwrjs/types": "0.22.11",
         "@rollup/plugin-node-resolve": "^15.2.3",
         "@rollup/plugin-sucrase": "^5.0.2",
         "@rollup/plugin-terser": "^0.4.4",
         "rollup": "^2.80.0"
     },
     "dependencies": {
-        "@lwrjs/client-modules": "0.22.9",
-        "@lwrjs/shared-utils": "0.22.9"
+        "@lwrjs/client-modules": "0.22.11",
+        "@lwrjs/shared-utils": "0.22.11"
     },
     "lwc": {
         "modules": [
@@ -90,5 +90,5 @@
     "volta": {
         "extends": "../../../package.json"
     },
-    "gitHead": "d0c112cd7b6eb940d6e554d0bbd93fb535465fdc"
+    "gitHead": "85710371aa359747e08a064d4b4a2b3dfed1d30a"
 }