@lwrjs/loader 0.13.0-alpha.2 → 0.13.0-alpha.21

package/build/modules/lwr/loaderLegacy/utils/url.js

@@ -0,0 +1,128 @@
+import { hasDocument } from './dom.js';
+export function getBaseUrl() {
+    let baseUrl = undefined;
+    if (hasDocument) {
+        // eslint-disable-next-line lwr/no-unguarded-apis, no-undef
+        const baseEl = document.querySelector('base[href]');
+        baseUrl = baseEl && baseEl.href;
+    }
+    // eslint-disable-next-line lwr/no-unguarded-apis
+    if (!baseUrl && typeof location !== 'undefined') {
+        // eslint-disable-next-line lwr/no-unguarded-apis, no-undef
+        baseUrl = location.href.split('#')[0].split('?')[0];
+        const lastSepIndex = baseUrl.lastIndexOf('/');
+        if (lastSepIndex !== -1) {
+            baseUrl = baseUrl.slice(0, lastSepIndex + 1);
+        }
+    }
+    return baseUrl;
+}
+/**
+ * Check if a string is a URL based on Common Internet Scheme Syntax
+ * https://www.ietf.org/rfc/rfc1738.txt
+ *
+ * URL Format:
+ *  <scheme>:<scheme-specific-part>
+ * Common Internet Scheme Syntax:
+ *  The scheme specific part starts with a double slash('//')
+ *
+ * A valid URL has a colon that is followed by a double slash.
+ *
+ * @param url - the url that is being checked
+ * @returns boolean
+ *
+ * @example Valid URLs
+ * 'https://salesforce.com'
+ * 'http://localhost:3000'
+ *
+ * @example Invalid URLs
+ * 'salesforce.com'
+ * 'localhost:3000'
+ * '@salesforce/label/type:namespace:name'
+ */
+export function isUrl(url) {
+    return url.indexOf('://') !== -1;
+}
+// Borrowed and adapted from https://github.com/systemjs/systemjs/blob/master/src/common.js
+// Resolves the first path segment relative to the second/parent URL
+// eg: resolveIfNotPlainOrUrl('../test', 'http://www.site.com/one/two') => 'http://www.site.com/test'
+// eg: resolveIfNotPlainOrUrl('./x/y/z', 'https://my.com/segment')).toBe('https://my.com/x/y/z')
+export function resolveIfNotPlainOrUrl(relUrl, parentUrl) {
+    const backslashRegEx = /\\/g;
+    if (relUrl.indexOf('\\') !== -1)
+        relUrl = relUrl.replace(backslashRegEx, '/');
+    // protocol-relative
+    if (relUrl[0] === '/' && relUrl[1] === '/') {
+        return parentUrl.slice(0, parentUrl.indexOf(':') + 1) + relUrl;
+    }
+    // relative-url
+    else if ((relUrl[0] === '.' &&
+        (relUrl[1] === '/' ||
+            (relUrl[1] === '.' && (relUrl[2] === '/' || (relUrl.length === 2 && (relUrl += '/')))) ||
+            (relUrl.length === 1 && (relUrl += '/')))) ||
+        relUrl[0] === '/') {
+        const parentProtocol = parentUrl.slice(0, parentUrl.indexOf(':') + 1);
+        let pathname;
+        if (parentUrl[parentProtocol.length + 1] === '/') {
+            // resolving to a :// so we need to read out the auth and host
+            if (parentProtocol !== 'file:') {
+                pathname = parentUrl.slice(parentProtocol.length + 2);
+                pathname = pathname.slice(pathname.indexOf('/') + 1);
+            }
+            else {
+                pathname = parentUrl.slice(8);
+            }
+        }
+        else {
+            // resolving to :/ so pathname is the /... part
+            pathname = parentUrl.slice(parentProtocol.length + (parentUrl[parentProtocol.length] === '/' ? 1 : 0));
+        }
+        if (relUrl[0] === '/')
+            return parentUrl.slice(0, parentUrl.length - pathname.length - 1) + relUrl;
+        // join together and split for removal of .. and . segments
+        // looping the string instead of anything fancy for perf reasons
+        // '../../../../../z' resolved to 'x/y' is just 'z'
+        const segmented = pathname.slice(0, pathname.lastIndexOf('/') + 1) + relUrl;
+        const output = [];
+        let segmentIndex = -1;
+        for (let i = 0; i < segmented.length; i++) {
+            // busy reading a segment - only terminate on '/'
+            if (segmentIndex !== -1) {
+                if (segmented[i] === '/') {
+                    output.push(segmented.slice(segmentIndex, i + 1));
+                    segmentIndex = -1;
+                }
+            }
+            // new segment - check if it is relative
+            else if (segmented[i] === '.') {
+                // ../ segment
+                if (segmented[i + 1] === '.' && (segmented[i + 2] === '/' || i + 2 === segmented.length)) {
+                    output.pop();
+                    i += 2;
+                }
+                // ./ segment
+                else if (segmented[i + 1] === '/' || i + 1 === segmented.length) {
+                    i += 1;
+                }
+                else {
+                    // the start of a new segment as below
+                    segmentIndex = i;
+                }
+            }
+            // it is the start of a new segment
+            else {
+                segmentIndex = i;
+            }
+        }
+        // finish reading out the last segment
+        if (segmentIndex !== -1)
+            output.push(segmented.slice(segmentIndex));
+        return parentUrl.slice(0, parentUrl.length - pathname.length) + output.join('');
+    }
+}
+export function resolveUrl(relUrl, parentUrl) {
+    const resolvedUrl = resolveIfNotPlainOrUrl(relUrl, parentUrl) ||
+        (isUrl(relUrl) ? relUrl : resolveIfNotPlainOrUrl('./' + relUrl, parentUrl));
+    return resolvedUrl;
+}
+//# sourceMappingURL=url.js.map

package/build/shim/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const REQUIRED_MODULES_TIMEOUT: number;
+//# sourceMappingURL=constants.d.ts.map

package/build/shim/constants.js

@@ -0,0 +1,2 @@
+export const REQUIRED_MODULES_TIMEOUT = 60 * 1000; // 2m
+//# sourceMappingURL=constants.js.map

package/build/shim/customInit.d.ts

@@ -0,0 +1,4 @@
+import type { ClientBootstrapConfig } from '@lwrjs/types';
+import type { InitializeApp, LoaderDefine, RegisterCustomErrorHandler } from '../types.js';
+export declare function customInit(config: ClientBootstrapConfig, initializeApp: InitializeApp, define: LoaderDefine, onBootstrapError: RegisterCustomErrorHandler): void;
+//# sourceMappingURL=customInit.d.ts.map

package/build/shim/customInit.js

@@ -0,0 +1,29 @@
+import { attachDispatcher } from 'lwr/profiler';
+// Check for errors with autoBoot and customInit
+function validatePreInit(autoBoot, customInit) {
+    // If autoBoot === false, there must be a customInit hook
+    if (!autoBoot && !customInit) {
+        throw new Error('The customInit hook is required when autoBoot is false');
+    }
+    // If autoBoot === true, there must NOT be a customInit hook
+    if (autoBoot && customInit) {
+        throw new Error('The customInit hook must not be defined when autoBoot is true');
+    }
+}
+// Process the customInit hook
+export function customInit(config, initializeApp, define, onBootstrapError) {
+    // Validate config
+    const { autoBoot, customInit } = config;
+    validatePreInit(autoBoot, customInit);
+    // Set up arguments and call the customInit hook, if available
+    if (customInit) {
+        const lwr = {
+            initializeApp,
+            define,
+            onBootstrapError,
+            attachDispatcher,
+        };
+        customInit(lwr, config);
+    }
+}
+//# sourceMappingURL=customInit.js.map

package/build/shim/index.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.d.ts.map

package/build/shim/index.js

@@ -0,0 +1,9 @@
+import LoaderShim from './shim.js';
+// The loader module is ALWAYS required
+const GLOBAL = globalThis;
+GLOBAL.LWR.requiredModules = GLOBAL.LWR.requiredModules || [];
+if (GLOBAL.LWR.requiredModules.indexOf('lwr/loader/v/__VERSION__') < 0) {
+    GLOBAL.LWR.requiredModules.push('lwr/loader/v/__VERSION__');
+}
+new LoaderShim(GLOBAL);
+//# sourceMappingURL=index.js.map

package/build/shim/loader.d.ts

@@ -0,0 +1,3 @@
+import type { DefineArguments, FingerprintsLoaderAPI as LoaderAPI, FingerprintsLoaderConfig as LoaderConfig } from '../types.js';
+export declare function createLoader(name: string, definition: DefineArguments, config: LoaderConfig, externalModules?: string[]): LoaderAPI;
+//# sourceMappingURL=loader.d.ts.map

package/build/shim/loader.js

@@ -0,0 +1,27 @@
+export function createLoader(name, definition, config, externalModules) {
+    if (!definition || typeof definition[2] !== 'function') {
+        throw new Error(`Expected loader with specifier "${name}" to be a module`);
+    }
+    // Create a Loader instance
+    const exports = {};
+    definition[2].call(null, exports);
+    const { Loader } = exports;
+    if (!Loader) {
+        throw new Error('Expected Loader class to be defined');
+    }
+    const loader = new Loader(config);
+    if (externalModules && externalModules.length) {
+        loader.registerExternalModules(externalModules);
+    }
+    // Define the loader module with public API: { define, load, services }
+    const exporter = (exports) => {
+        Object.assign(exports, {
+            define: loader.define.bind(loader),
+            load: loader.load.bind(loader),
+            services: loader.services,
+        });
+    };
+    loader.define(name, ['exports'], exporter);
+    return loader;
+}
+//# sourceMappingURL=loader.js.map

package/build/shim/shim.d.ts

@@ -0,0 +1,31 @@
+import type { GlobalThis } from '../types.js';
+export default class LoaderShim {
+    private global;
+    private config;
+    private bootReady;
+    private loaderSpecifier;
+    private defineCache;
+    private orderedDefs;
+    private errorHandler?;
+    private watchdogTimerId?;
+    constructor(global: GlobalThis);
+    private canInit;
+    /**
+     * Create a temporary LWR.define() function which captures all
+     * calls that occur BEFORE the full loader module is available
+     *
+     * Each call to LWR.define() is stored in 2 ways:
+     *      - in a map as [moduleName, arguments] pairs
+     *      - each moduleName is pushed onto an array, to preserve
+     *          the order in which the modules were defined
+     */
+    private tempDefine;
+    private postCustomInit;
+    private initApp;
+    private waitForDOMContentLoaded;
+    private createProfilerModule;
+    private mountApp;
+    private enterErrorState;
+    private startWatchdogTimer;
+}
+//# sourceMappingURL=shim.d.ts.map

package/build/shim/shim.js

@@ -0,0 +1,194 @@
+/* global document */
+import { BOOTSTRAP_ERROR } from 'lwr/metrics';
+import { logOperationStart, logOperationEnd } from 'lwr/profiler';
+import { createLoader } from './loader.js';
+import { REQUIRED_MODULES_TIMEOUT } from './constants.js';
+import { customInit } from './customInit.js';
+/* eslint-disable lwr/no-unguarded-apis */
+const hasSetTimeout = typeof setTimeout === 'function';
+const hasConsole = typeof console !== 'undefined';
+/* eslint-enable lwr/no-unguarded-apis */
+export default class LoaderShim {
+    constructor(global) {
+        this.defineCache = {};
+        this.orderedDefs = [];
+        // Start watchdog timer
+        if (hasSetTimeout) {
+            this.watchdogTimerId = this.startWatchdogTimer();
+        }
+        // Parse configuration
+        this.global = global;
+        this.config = global.LWR;
+        this.loaderSpecifier = 'lwr/loader/v/__VERSION__';
+        // Set up error handler
+        this.errorHandler = this.config.onError;
+        // Set up the temporary LWR.define function and customInit hook
+        const tempDefine = this.tempDefine.bind(this);
+        global.LWR.define = tempDefine;
+        this.bootReady = this.config.autoBoot;
+        try {
+            this.createProfilerModule(global.LWR.define);
+            customInit(Object.freeze(this.config), this.postCustomInit.bind(this), tempDefine, (e) => {
+                // customInit handlers can overwrite
+                // the error handler with onBootstrapError
+                this.errorHandler = e;
+            });
+        }
+        catch (e) {
+            this.enterErrorState(e);
+        }
+    }
+    // Return true if the app can be initialized
+    canInit() {
+        if (!this.config.requiredModules) {
+            throw new Error('Unexpected missing requiredModules');
+        }
+        // Initialize the app if:
+        //  - bootReady: autoBoot is on OR customInit has finished
+        //  - all required modules are defined
+        const allDefined = this.config.requiredModules.every((m) => this.orderedDefs.includes(m));
+        return this.bootReady && allDefined;
+    }
+    /**
+     * Create a temporary LWR.define() function which captures all
+     * calls that occur BEFORE the full loader module is available
+     *
+     * Each call to LWR.define() is stored in 2 ways:
+     *      - in a map as [moduleName, arguments] pairs
+     *      - each moduleName is pushed onto an array, to preserve
+     *          the order in which the modules were defined
+     */
+    tempDefine(...args) {
+        // Cache the incoming module
+        const moduleName = args[0];
+        this.defineCache[moduleName] = args;
+        this.orderedDefs.push(moduleName);
+        if (this.canInit()) {
+            if (hasSetTimeout) {
+                // requiredModules are defined, clear watchdog timer
+                // eslint-disable-next-line lwr/no-unguarded-apis, no-undef
+                clearTimeout(this.watchdogTimerId);
+            }
+            this.initApp();
+        }
+    }
+    // Called by the customInit hook via lwr.initializeApp()
+    postCustomInit() {
+        this.bootReady = true;
+        if (this.canInit()) {
+            if (hasSetTimeout) {
+                // requiredModules are defined, clear watchdog timer
+                // eslint-disable-next-line lwr/no-unguarded-apis, no-undef
+                clearTimeout(this.watchdogTimerId);
+            }
+            this.initApp();
+        }
+    }
+    // Create the loader and initialize the application
+    initApp() {
+        try {
+            const loaderConfig = {
+                endpoints: this.config.endpoints,
+                baseUrl: this.config.baseUrl,
+                profiler: { logOperationStart, logOperationEnd },
+                // TODO: can be removed following https://github.com/salesforce-experience-platform-emu/lwr/issues/1087
+                appMetadata: {
+                    appId: this.config.appId,
+                    bootstrapModule: this.config.bootstrapModule,
+                    rootComponent: this.config.rootComponent,
+                    rootComponents: this.config.rootComponents,
+                },
+            };
+            const loader = createLoader(this.loaderSpecifier, this.defineCache[this.loaderSpecifier], loaderConfig, this.config.preloadModules);
+            this.mountApp(loader);
+        }
+        catch (e) {
+            this.enterErrorState(e);
+        }
+    }
+    waitForDOMContentLoaded() {
+        // eslint-disable-next-line lwr/no-unguarded-apis
+        if (typeof document === undefined) {
+            return Promise.resolve();
+        }
+        // Resolve if document is already "ready" https://developer.mozilla.org/en-US/docs/Web/API/Document/readyState
+        // eslint-disable-next-line lwr/no-unguarded-apis
+        if (document.readyState === 'interactive' || document.readyState === 'complete') {
+            return Promise.resolve();
+        }
+        return new Promise((resolve) => {
+            // eslint-disable-next-line lwr/no-unguarded-apis
+            document.addEventListener('DOMContentLoaded', () => {
+                resolve();
+            });
+        });
+    }
+    // Create a module out of the profiler
+    // Note: The profiler is also available as a module through lwc module resolution (see package.json)
+    createProfilerModule(define) {
+        const exporter = (exports) => {
+            Object.assign(exports, { logOperationStart, logOperationEnd });
+        };
+        define('lwr/profiler/v/__VERSION__', ['exports'], exporter);
+    }
+    // Set up the application globals, import map, root custom element...
+    mountApp(loader) {
+        const { bootstrapModule, rootComponent, rootComponents, serverData, endpoints, imports, index } = this.config;
+        const importsObj = imports || {};
+        // Set global LWR.define to loader.define
+        this.global.LWR = Object.freeze({
+            define: loader.define.bind(loader),
+            rootComponent,
+            rootComponents,
+            serverData: serverData || {},
+            endpoints,
+            imports: importsObj,
+            index: index || {},
+            env: this.global.LWR.env,
+        });
+        // Redefine all modules in the temporary cache
+        this.orderedDefs.forEach((specifier) => {
+            if (specifier !== this.loaderSpecifier) {
+                loader.define(...this.defineCache[specifier]);
+            }
+        });
+        // by default, app initialization is gated on waiting for document to be parsed (via DOMContentLoaded)
+        const { disableInitDefer } = this.config;
+        // Load the import mappings and application bootstrap module
+        loader
+            .registerImportMappings({ imports: importsObj, index }, [
+            bootstrapModule,
+            rootComponent,
+        ])
+            .then(() => {
+            if (!disableInitDefer) {
+                return this.waitForDOMContentLoaded();
+            }
+        })
+            .then(() => loader.load(bootstrapModule))
+            .catch((reason) => {
+            this.enterErrorState(new Error(`Application ${rootComponent || bootstrapModule} could not be loaded: ${reason}`));
+        });
+    }
+    // Trigger bootstrap error state, and call error handler if registered
+    enterErrorState(error) {
+        logOperationStart({ id: BOOTSTRAP_ERROR });
+        if (this.errorHandler) {
+            this.errorHandler(error);
+        }
+        else {
+            if (hasConsole) {
+                // eslint-disable-next-line lwr/no-unguarded-apis, no-undef
+                console.error(`An error occurred during LWR bootstrap. ${error.message}`, error.stack);
+            }
+        }
+    }
+    // eslint-disable-next-line no-undef, lwr/no-unguarded-apis
+    startWatchdogTimer() {
+        // eslint-disable-next-line lwr/no-unguarded-apis, no-undef
+        return setTimeout(() => {
+            this.enterErrorState(new Error('Failed to load required modules - timed out'));
+        }, REQUIRED_MODULES_TIMEOUT);
+    }
+}
+//# sourceMappingURL=shim.js.map

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.d.ts.map

package/build/shim-legacy/index.js

@@ -0,0 +1,9 @@
+import LoaderShim from './shimLegacy.js';
+// The loader module is ALWAYS required
+const GLOBAL = globalThis;
+GLOBAL.LWR.requiredModules = GLOBAL.LWR.requiredModules || [];
+if (GLOBAL.LWR.requiredModules.indexOf('lwr/loaderLegacy/v/__VERSION__') < 0) {
+    GLOBAL.LWR.requiredModules.push('lwr/loaderLegacy/v/__VERSION__');
+}
+new LoaderShim(GLOBAL);
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,3 @@
+import type { LoaderConfig, DefineArguments, LoaderAPI } from '../types.js';
+export declare function createLoader(name: string, definition: DefineArguments, config: LoaderConfig, externalModules?: string[]): LoaderAPI;
+//# sourceMappingURL=loaderLegacy.d.ts.map

package/build/shim-legacy/loaderLegacy.js

@@ -0,0 +1,29 @@
+export function createLoader(name, definition, config, externalModules) {
+    if (!definition || typeof definition[2] !== 'function') {
+        throw new Error(`Expected loader with specifier "${name}" to be a module`);
+    }
+    // Create a Loader instance
+    const exports = {};
+    definition[2].call(null, exports);
+    const { Loader } = exports;
+    if (!Loader) {
+        throw new Error('Expected Loader class to be defined');
+    }
+    const loader = new Loader(config);
+    // register externally loaded modules
+    if (externalModules && externalModules.length) {
+        loader.registerExternalModules(externalModules);
+    }
+    // Define the loader module with public API: { define, load, services }
+    const exporter = (exports) => {
+        Object.assign(exports, {
+            define: loader.define.bind(loader),
+            load: loader.load.bind(loader),
+            services: loader.services,
+        });
+        return;
+    };
+    loader.define(name, ['exports'], exporter, definition[3]);
+    return loader;
+}
+//# sourceMappingURL=loaderLegacy.js.map

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

@@ -0,0 +1,31 @@
+import type { GlobalThis } from '../types.js';
+export default class LoaderShim {
+    private global;
+    private config;
+    private bootReady;
+    private loaderModule;
+    private defineCache;
+    private orderedDefs;
+    private errorHandler?;
+    private watchdogTimerId?;
+    constructor(global: GlobalThis);
+    private canInit;
+    /**
+     * Create a temporary LWR.define() function which captures all
+     * calls that occur BEFORE the full loader module is available
+     *
+     * Each call to LWR.define() is stored in 2 ways:
+     *      - in a map as [moduleName, arguments] pairs
+     *      - each moduleName is pushed onto an array, to preserve
+     *          the order in which the modules were defined
+     */
+    private tempDefine;
+    private postCustomInit;
+    private initApp;
+    private waitForDOMContentLoaded;
+    private createProfilerModule;
+    private mountApp;
+    private enterErrorState;
+    private startWatchdogTimer;
+}
+//# sourceMappingURL=shimLegacy.d.ts.map