@lwrjs/shared-utils 0.9.0-alpha.2 → 0.9.0-alpha.21

package/build/es/compiler.js

@@ -0,0 +1,65 @@
+import { explodeSpecifier } from './identity.js';
+import { Compiler as Locker } from '@locker/compiler';
+import { rollup } from 'rollup';
+/**
+ * When importing these modules make sure the optional dependencies are installed:
+ * - 'rollup' for convertToAmd()
+ * - '@locker/compiler' for lockerize()
+ */
+export const AMD_DEFINE = 'LWR.define';
+const AMD_ROLLUP_PLUGIN = function (rootId, source) {
+    return {
+        name: 'lwr-amd-inline',
+        resolveId(id) {
+            return rootId === id ? id : undefined;
+        },
+        load(id) {
+            return rootId === id ? source : undefined;
+        },
+    };
+};
+export async function convertToAmd(source, { id }, forceNamedExports = true) {
+    const bundler = await rollup({
+        input: id,
+        plugins: [AMD_ROLLUP_PLUGIN(id, source)],
+        onwarn(warning, warn) {
+            // do not print out these: 'a' is imported by b, but could not be resolved – treating it as an external dependency
+            if (warning.code === 'UNRESOLVED_IMPORT')
+                return;
+            warn(warning);
+        },
+    });
+    const { output } = await bundler.generate({
+        amd: { id, define: AMD_DEFINE },
+        exports: forceNamedExports ? 'named' : 'auto',
+        format: 'amd',
+    });
+    const { code } = output[0];
+    return { code, map: null };
+}
+/** Locker
+ * Trusted Components can contain namespaces with wildcard or single component
+ */
+export function lockerize({ compiledSource: source, specifier, moduleEntry: { entry: filename } }, { trustedComponents }, sourcemap = false) {
+    const { namespace, name: rawName } = explodeSpecifier(specifier);
+    const [name] = rawName.split('#');
+    const bareSpecifier = namespace ? `${namespace}/${name}` : name;
+    const isJS = filename.endsWith('.js') || filename.endsWith('.mjs') || filename.endsWith('.ts');
+    // lockerize if component is JS and is not explicitly trusted or in a trusted namespace
+    if (isJS &&
+        trustedComponents &&
+        !trustedComponents.includes(`${namespace}/*`) &&
+        !trustedComponents.includes(bareSpecifier)) {
+        const { code } = Locker.compile(source, {
+            componentName: name,
+            filename,
+            // put non-namespaced modules in a single sandbox - this should only be non-lwc npm modules
+            sandboxKey: namespace || 'sandbox',
+            sourcemap,
+            remapDynamicImport: true, // support for dynamic imports
+        });
+        return { code, map: null };
+    }
+    return { code: source, map: null };
+}
+//# sourceMappingURL=compiler.js.map

package/build/es/env.d.ts

@@ -1,3 +1,3 @@
-import { FeatureFlags } from '@lwrjs/types';
+import type { FeatureFlags } from '@lwrjs/types';
 export declare function getFeatureFlags(): FeatureFlags;
 //# sourceMappingURL=env.d.ts.map

package/build/es/env.js

@@ -1,17 +1,20 @@
 export function getFeatureFlags() {
-    let legacyLoader = process.env.LEGACY_LOADER !== undefined && process.env.LEGACY_LOADER === 'true' ? true : false;
-    try {
-        // Use the Shim for MRT since we don't have access to managing environment variables
-        if (LWR) {
-            legacyLoader = LWR.LEGACY_LOADER;
-        }
-    }
-    catch (e) {
-        // No shim, ignore error
-    }
+    // Add any new feature flags here to parse from environment variables
     return {
         // DEFAULT LEGACY_LOADER = false;
-        LEGACY_LOADER: legacyLoader,
+        LEGACY_LOADER: process.env.LEGACY_LOADER !== undefined && process.env.LEGACY_LOADER.toLowerCase() === 'true'
+            ? true
+            : false,
+        // SSR should concatenate bundles, default = false
+        SSR_STATIC_BUNDLES: process.env.SSR_STATIC_BUNDLES !== undefined &&
+            process.env.SSR_STATIC_BUNDLES.toLowerCase() === 'true'
+            ? true
+            : false,
+        // Should we use a js worker for SSR, sandboxing = false (use locker for ssr sandboxing)
+        SSR_SANDBOX_WORKER: process.env.SSR_SANDBOX_WORKER !== undefined &&
+            process.env.SSR_SANDBOX_WORKER.toLowerCase() === 'true'
+            ? true
+            : false,
     };
 }
 //# sourceMappingURL=env.js.map

package/build/es/fs-watch.d.ts

@@ -0,0 +1,17 @@
+import type { Watcher, WatcherFactory, WatchOptions } from '@lwrjs/types';
+/**
+ * Factory comptable with the LWR Runtime to create a file watch library for LWR dev server.
+ * When importing this module make sure the optional library 'chokidar' is installed.
+ */
+export declare class WatcherFactoryImpl implements WatcherFactory {
+    /**
+     * Set up a watcher with the given options
+     * @param options
+     */
+    createFileWatcher(options?: WatchOptions): Watcher;
+    /**
+     * Set up file watcher
+     */
+    setupWatcher(onModuleChange: Function): Watcher;
+}
+//# sourceMappingURL=fs-watch.d.ts.map

package/build/es/fs-watch.js

@@ -0,0 +1,27 @@
+import chokidar from 'chokidar';
+import { debounce } from './object.js';
+import { logger } from './logger.js';
+/**
+ * Factory comptable with the LWR Runtime to create a file watch library for LWR dev server.
+ * When importing this module make sure the optional library 'chokidar' is installed.
+ */
+export class WatcherFactoryImpl {
+    /**
+     * Set up a watcher with the given options
+     * @param options
+     */
+    createFileWatcher(options = { persistent: true, ignored: '**/node_modules/**' }) {
+        return chokidar.watch([], options);
+    }
+    /**
+     * Set up file watcher
+     */
+    setupWatcher(onModuleChange) {
+        const fileWatcher = this.createFileWatcher();
+        fileWatcher.on('change', debounce((file) => onModuleChange(file), 500));
+        fileWatcher.on('unlink', debounce((file) => onModuleChange(file), 500));
+        fileWatcher.on('add', (file) => logger.info(`Watching: ${file}`));
+        return fileWatcher;
+    }
+}
+//# sourceMappingURL=fs-watch.js.map

package/build/es/fs.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { ResourcePaths, Watcher, ViewSource } from '@lwrjs/types';
+import type { ResourcePaths, ViewSource } from '@lwrjs/types';
 import { lookup } from 'mime-types';
 /**
  * Create a hash string for a source
@@ -16,15 +16,6 @@ export declare function readFile(filePath: string): string;
  * @param filePath
  */
 export declare function resolveFileExtension(filePath: string): string;
-/**
- * Set up a watcher with the given options
- * @param options
- */
-export declare function createFileWatcher(options?: any): Watcher;
-/**
- * Set up file watcher
- */
-export declare function setupWatcher(onModuleChange: Function): Watcher;
 /**
  * Returns if view of specific type can be resolved
  *

package/build/es/fs.js

@@ -2,8 +2,6 @@ import fs from 'fs';
 import pathLib from 'path';
 import crypto from 'crypto';
 import { slugify } from './identity.js';
-import { debounce } from './object.js';
-import chokidar from 'chokidar';
 import { LwrUnresolvableError, createSingleDiagnosticError, descriptions } from '@lwrjs/diagnostics';
 import { lookup } from 'mime-types';
 import { DEBUG, logger, VERBOSE } from './logger.js';
@@ -55,25 +53,6 @@ export function resolveFileExtension(filePath) {
         throw new Error(`Unable to find file "${filePath}"`);
     }
 }
-/**
- * Set up a watcher with the given options
- * @param options
- */
-export function createFileWatcher(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-options = { persistent: true, ignored: '**/node_modules/**' }) {
-    return chokidar.watch([], options);
-}
-/**
- * Set up file watcher
- */
-export function setupWatcher(onModuleChange) {
-    const fileWatcher = createFileWatcher();
-    fileWatcher.on('change', debounce((file) => onModuleChange(file), 500));
-    fileWatcher.on('unlink', debounce((file) => onModuleChange(file), 500));
-    fileWatcher.on('add', (file) => logger.info(`Watching: ${file}`));
-    return fileWatcher;
-}
 /**
  * Returns if view of specific type can be resolved
  *

package/build/es/graph.d.ts

@@ -1,9 +1,10 @@
-import { ModuleRegistry, RuntimeEnvironment, RuntimeParams, FlattenedModuleGraphs, GraphNode, GraphOptions, ModuleBundler } from '@lwrjs/types';
+import type { ModuleRegistry, RuntimeEnvironment, RuntimeParams, FlattenedModuleGraphs, GraphNode, GraphOptions, ModuleBundler, PublicModuleRegistry, PublicModuleBundler } from '@lwrjs/types';
 export declare enum GraphDepth {
     ALL = "all",
     DIRECT = "direct",
     NONE = "none"
 }
+export declare function isBundler(registry: PublicModuleRegistry | PublicModuleBundler): registry is PublicModuleBundler;
 export declare function getModuleGraphs(specifier: string, // version | un-versioned specifiers
 options: GraphOptions, moduleRegistry: ModuleRegistry, defRegistry: ModuleRegistry | ModuleBundler, runtimeEnvironment: RuntimeEnvironment, runtimeParams?: RuntimeParams, visited?: Map<string, GraphNode>): Promise<FlattenedModuleGraphs>;
 //# sourceMappingURL=graph.d.ts.map

package/build/es/graph.js

@@ -8,7 +8,7 @@ export var GraphDepth;
     GraphDepth["NONE"] = "none";
 })(GraphDepth || (GraphDepth = {}));
 // type guard for ViewDef responses
-function isBundler(registry) {
+export function isBundler(registry) {
     return registry.getModuleBundle !== undefined;
 }
 async function traverse(module, depth, flattened, 
@@ -129,7 +129,7 @@ options, moduleRegistry, defRegistry, runtimeEnvironment, runtimeParams, visited
             // eslint-disable-next-line no-await-in-loop
             const moduleId = await getVersionedModuleId(visitedSpecifier, moduleRegistry);
             // eslint-disable-next-line no-await-in-loop
-            const uri = await moduleRegistry.resolveModuleUri(moduleId, runtimeEnvironment, runtimeParams);
+            const uri = await defRegistry.resolveModuleUri(moduleId, runtimeEnvironment, runtimeParams);
             uriMap[visitedSpecifier] = uri;
         }
     }

package/build/es/identity.d.ts

@@ -1,5 +1,5 @@
 import getCacheKeyFromJson from 'fast-json-stable-stringify';
-import { AbstractModuleId, AssetIdentity, BundleDefinition, MappingIdentity, MiddlewareRequest, ModuleDefinition, ModuleId, ModuleIdentity, PublicModuleRegistry, ResourceIdentity, RuntimeEnvironment, RuntimeParams } from '@lwrjs/types';
+import { AbstractModuleId, BundleDefinition, ModuleDefinition, NormalizedLwrAppBootstrapConfig, PublicModuleRegistry, RuntimeEnvironment, RuntimeParams } from '@lwrjs/types';
 export declare const VERSION_SIGIL = "/v/";
 export declare const LOCALE_SIGIL = "l";
 export declare const ENVIRONMENT_SIGIL = "e";
@@ -13,14 +13,7 @@ export declare const DEFAULT_LWR_LOCKER_CONFIG: {
     enabled: boolean;
     trustedComponents: string[];
 };
-export declare const DEFAULT_LWR_BOOTSTRAP_CONFIG: {
-    autoBoot: boolean;
-    syntheticShadow: boolean;
-    workers: {};
-    services: never[];
-    configAsSrc: boolean;
-    ssr: boolean;
-};
+export declare const DEFAULT_LWR_BOOTSTRAP_CONFIG: NormalizedLwrAppBootstrapConfig;
 declare type ModuleIdentifierPartial = Partial<AbstractModuleId>;
 /**
  * Turn the dots in a version into underscores
@@ -64,29 +57,9 @@ export declare function explodeSpecifiers(rawSpecifiers: string): PartialModuleI
  * @example - { namespace: '@salesforce', name: 'label/my.label', version: '1' } => '@salesforce/label/my.label/v/1'
  */
 export declare function getSpecifier({ specifier, namespace, name, version }: ModuleIdentifierPartial): string;
-/**
- * Create a versioned specifier based on the module registry
- *
- * @remarks
- * If the incoming specifier is already versioned, it will be returned as is.
- *
- * The returned specifier's version conforms to the format expected to be used
- * external to the framework (e.g. via the identity in the URL, mapping metadata,
- * AMD define module name). This format conforms to the `normalizeVersionToUri`
- * implementation (e.g. version semver format -- major_minor_patch).
- *
- * This method is analogous to `getSpecifier` but supports non-versioned `rawSpecifiers`
- * The inverse of this method is `explodeSpecifier`
-
- * @param specifier - the module specifier
- * @param moduleRegistry - the public module registry
- *
- * @returns the specifier for the latest version
- *
- * @example - 'c/form' => 'c/form/v/0_0_1'
- * @example - 'c/form/v/0.0.2' => 'c/form/v/0_0_2'
- */
-export declare function getVersionedSpecifier(rawSpecifier: string, moduleRegistry: PublicModuleRegistry): Promise<string>;
+interface VersionedAbstractModuleId extends AbstractModuleId {
+    version: string;
+}
 /**
  * Create a AbstractModuleId using the module registry to resolve the version
  * if a version is not provided in the `rawSpecifier`
@@ -107,7 +80,7 @@ export declare function getVersionedSpecifier(rawSpecifier: string, moduleRegist
  * @example - 'c/form/v/0.0.2' => {specifier: "c/form", version: "0.0.2"}
  * @example - 'c/form/v/0_0_2' => {specifier: "c/form", version: "0.0.2"}
  */
-export declare function getVersionedModuleId(rawSpecifier: string, moduleRegistry: PublicModuleRegistry): Promise<Required<Pick<ModuleId, 'specifier' | 'version'>>>;
+export declare function getVersionedModuleId(rawSpecifier: string, moduleRegistry: PublicModuleRegistry): Promise<VersionedAbstractModuleId>;
 interface PackageIdentity {
     scope?: string;
     packageName: string;
@@ -165,8 +138,4 @@ export declare function getMappingUriPrefix({ apiVersion, bundle, format, compat
 export { getCacheKeyFromJson };
 export declare function isExternalUrl(url: string): boolean;
 export declare function isBundleDefinition(definition: ModuleDefinition | BundleDefinition): definition is BundleDefinition;
-export declare function getModuleIdentity(req: MiddlewareRequest): ModuleIdentity;
-export declare function getMappingIdentity(req: MiddlewareRequest): MappingIdentity;
-export declare function getResourceIdentity(req: MiddlewareRequest): ResourceIdentity;
-export declare function getAssetIdentity(req: MiddlewareRequest): AssetIdentity;
 //# sourceMappingURL=identity.d.ts.map

package/build/es/identity.js

@@ -96,37 +96,6 @@ export function getSpecifier({ specifier, namespace, name = '', version }) {
     const bareSpecifier = namespace ? `${namespace}/${name}` : name;
     return version ? `${bareSpecifier}${VERSION_SIGIL}${normalizeVersionToUri(version)}` : bareSpecifier;
 }
-/**
- * Create a versioned specifier based on the module registry
- *
- * @remarks
- * If the incoming specifier is already versioned, it will be returned as is.
- *
- * The returned specifier's version conforms to the format expected to be used
- * external to the framework (e.g. via the identity in the URL, mapping metadata,
- * AMD define module name). This format conforms to the `normalizeVersionToUri`
- * implementation (e.g. version semver format -- major_minor_patch).
- *
- * This method is analogous to `getSpecifier` but supports non-versioned `rawSpecifiers`
- * The inverse of this method is `explodeSpecifier`
-
- * @param specifier - the module specifier
- * @param moduleRegistry - the public module registry
- *
- * @returns the specifier for the latest version
- *
- * @example - 'c/form' => 'c/form/v/0_0_1'
- * @example - 'c/form/v/0.0.2' => 'c/form/v/0_0_2'
- */
-export async function getVersionedSpecifier(rawSpecifier, moduleRegistry) {
-    const { specifier, namespace, name, version } = explodeSpecifier(rawSpecifier);
-    if (version) {
-        return normalizeVersionToUri(rawSpecifier);
-    }
-    // Get version from Module Registry
-    const moduleEntry = await moduleRegistry.getModuleEntry({ specifier });
-    return getSpecifier({ namespace, name, version: normalizeVersionToUri(moduleEntry.version) });
-}
 /**
  * Create a AbstractModuleId using the module registry to resolve the version
  * if a version is not provided in the `rawSpecifier`
@@ -148,13 +117,13 @@ export async function getVersionedSpecifier(rawSpecifier, moduleRegistry) {
  * @example - 'c/form/v/0_0_2' => {specifier: "c/form", version: "0.0.2"}
  */
 export async function getVersionedModuleId(rawSpecifier, moduleRegistry) {
-    const { specifier, version } = explodeSpecifier(rawSpecifier);
-    if (version) {
-        return { specifier, version: normalizeVersionFromUri(version) };
+    const moduleId = explodeSpecifier(rawSpecifier);
+    if (moduleId.version) {
+        return { ...moduleId, version: normalizeVersionFromUri(moduleId.version) };
     }
     // Get version from Module Registry
-    const moduleEntry = await moduleRegistry.getModuleEntry({ specifier });
-    return { specifier, version: moduleEntry.version };
+    const moduleEntry = await moduleRegistry.getModuleEntry(moduleId);
+    return { ...moduleId, version: moduleEntry.version };
 }
 const RE_SCOPED = /^(@[^/]+\/[^/@]+)(?:\/([^@]+))?(?:@([\s\S]+))?/;
 const RE_NORMAL = /^([^/@]+)(?:\/([^@]+))?(?:@([\s\S]+))?/;
@@ -279,53 +248,4 @@ export function isExternalUrl(url) {
 export function isBundleDefinition(definition) {
     return definition.bundleRecord !== undefined;
 }
-function validateSpecifier(specifer) {
-    return specifer.indexOf('../') < 0;
-}
-export function getModuleIdentity(req) {
-    const { specifier, signature = LATEST_SIGNATURE } = req.params;
-    if (validateSpecifier(specifier) === false) {
-        throw new Error('dot-dot-slash is not allowed for module specifier');
-    }
-    const moduleId = explodeSpecifier(specifier);
-    return {
-        moduleId,
-        signature,
-    };
-}
-export function getMappingIdentity(req) {
-    const { specifiers } = req.params;
-    const moduleIds = explodeSpecifiers(specifiers).map((obj) => ({
-        ...obj,
-        importer: req.query.importer,
-    }));
-    return {
-        moduleIds,
-    };
-}
-export function getResourceIdentity(req) {
-    const { specifier, signature = LATEST_SIGNATURE } = req.params;
-    if (validateSpecifier(specifier) === false) {
-        throw new Error('dot-dot-slash is not allowed for resource specifier');
-    }
-    const resourceId = explodeSpecifier(specifier);
-    return {
-        resourceId,
-        signature,
-    };
-}
-export function getAssetIdentity(req) {
-    const { signature = LATEST_SIGNATURE, assetType: type } = req.params;
-    const [specifier] = req.originalUrl.split('?');
-    if (validateSpecifier(specifier) === false) {
-        throw new Error('dot-dot-slash is not allowed for asset specifier');
-    }
-    return {
-        assetId: {
-            specifier,
-            type,
-        },
-        signature,
-    };
-}
 //# sourceMappingURL=identity.js.map

package/build/es/index.d.ts

@@ -6,7 +6,6 @@ export * from './link.js';
 export * from './object.js';
 export * from './serialize.js';
 export * from './tasks.js';
-export * from './typescript.js';
 export * from './import-metadata.js';
 export * from './graph.js';
 export * from './mappings.js';
@@ -14,4 +13,5 @@ export * from './urls.js';
 export * from './env.js';
 export * from './logger.js';
 export * from './lwr-app-observer.js';
+export * from './site-metadata.js';
 //# sourceMappingURL=index.d.ts.map

package/build/es/index.js

@@ -6,7 +6,6 @@ export * from './link.js';
 export * from './object.js';
 export * from './serialize.js';
 export * from './tasks.js';
-export * from './typescript.js';
 export * from './import-metadata.js';
 export * from './graph.js';
 export * from './mappings.js';
@@ -14,4 +13,5 @@ export * from './urls.js';
 export * from './env.js';
 export * from './logger.js';
 export * from './lwr-app-observer.js';
+export * from './site-metadata.js';
 //# sourceMappingURL=index.js.map

package/build/es/interchangeable-modules.d.ts

@@ -11,7 +11,7 @@ import { InterchangeableModuleRecord, LwcConfig, ResolverModuleRecord, Interchan
  * @returns {map} a map of all possible interchangeable modules
  *
  */
-export declare function discoverInterchangeableModules(modules: ResolverModuleRecord[], interchangeableModules?: InterchangeableModuleMap): InterchangeableModuleMap;
+export declare function discoverInterchangeableModules(modules: ResolverModuleRecord[], interchangeableModules?: InterchangeableModuleMap, visitedModules?: Set<string>): InterchangeableModuleMap;
 /**
  * Locate the LWC config for the package and resolve custom properties
  *

package/build/es/interchangeable-modules.js

@@ -24,10 +24,13 @@ function isNpmModuleRecord(module) {
  * @returns {map} a map of all possible interchangeable modules
  *
  */
-export function discoverInterchangeableModules(modules, interchangeableModules) {
+export function discoverInterchangeableModules(modules, interchangeableModules, visitedModules) {
     if (!interchangeableModules) {
         interchangeableModules = new Map();
     }
+    if (!visitedModules) {
+        visitedModules = new Set();
+    }
     if (modules.length === 0) {
         return interchangeableModules;
     }
@@ -37,6 +40,10 @@ export function discoverInterchangeableModules(modules, interchangeableModules)
         if (!isNpmModuleRecord(module)) {
             continue;
         }
+        if (visitedModules?.has(module.npm)) {
+            continue;
+        }
+        visitedModules.add(module.npm);
         // resolve module path and package.json
         const packageJsonPath = resolve.sync(`${module.npm}/package.json`);
         const packageJson = JSON.parse(readFile(packageJsonPath));
@@ -55,7 +62,7 @@ export function discoverInterchangeableModules(modules, interchangeableModules)
             interchangeableModules = normalizeInterchangeableModuleConfig(lwcConfig.interchangeableModules, interchangeableModules);
         }
     }
-    return discoverInterchangeableModules(nestedModules, interchangeableModules);
+    return discoverInterchangeableModules(nestedModules, interchangeableModules, visitedModules);
 }
 /**
  * Locate the LWC config for the package and resolve custom properties

package/build/es/logger.js

@@ -43,21 +43,33 @@ function log(level, message, additionalInfo) {
         }
     }
     if (shouldLog) {
-        let logMethod;
+        const logMessage = `[${level}]${gap(message)}${message}`;
+        const additionalMessage = additionalInfo
+            ? `Additional Info: ${JSON.stringify(additionalInfo)}`
+            : undefined;
         if (level == ERROR) {
-            logMethod = console.error;
+            console.error('\x1b[31m%s\x1b[0m', logMessage); // red
+            if (additionalInfo) {
+                console.error('\n\x1b[31m%s\x1b[0m', additionalMessage); // red
+            }
         }
         else if (level == WARN) {
-            logMethod = console.warn;
+            console.warn('\x1b[33m%s\x1b[0m', logMessage); // yellow
+            if (additionalInfo) {
+                console.warn('\n\x1b[33m%s\x1b[0m', additionalMessage); // yellow
+            }
         }
-        else {
-            logMethod = console.log;
-        }
-        if (additionalInfo) {
-            logMethod(`[${level}] ${message} \nAdditional Info: ${JSON.stringify(additionalInfo)}`);
+        else if (level == DEBUG || level == VERBOSE) {
+            console.log('\x1b[2m%s\x1b[0m', logMessage); // dim
+            if (additionalInfo) {
+                console.log('\n\x1b[2m%s\x1b[0m', additionalMessage); // dim
+            }
         }
         else {
-            logMethod(`[${level}] ${message}`);
+            console.log(logMessage);
+            if (additionalInfo) {
+                console.log(`\n${additionalMessage}`);
+            }
         }
     }
 }
@@ -83,12 +95,26 @@ export const stringifyError = (error) => {
         return JSON.stringify(retObj);
     }
 };
+// Return a space if there should be a space between the message and the level
+function gap(message) {
+    return String(message)?.indexOf('[') === 0 ? '' : ' ';
+}
+function logError(err, additionalInfo) {
+    if (err instanceof DiagnosticsError || !err || !err.message) {
+        log(ERROR, stringifyError(err), additionalInfo);
+    }
+    // If this is an error with a message update the message header and log as is...
+    if (err && err.message) {
+        err.message = `[${ERROR}]${gap(err.message)}${err.message}`;
+        console.error('\x1b[31m%s\x1b[0m', err);
+    }
+}
 export const logger = {
     verbose: (message, additionalInfo) => log(VERBOSE, message, additionalInfo),
     debug: (message, additionalInfo) => log(DEBUG, message, additionalInfo),
     info: (message, additionalInfo) => log(INFO, message, additionalInfo),
     warn: (message, additionalInfo) => log(WARN, message, additionalInfo),
-    error: (error, additionalInfo) => log(ERROR, stringifyError(error), additionalInfo),
+    error: (error, additionalInfo) => logError(error, additionalInfo),
     log,
     setOptions: (opts) => {
         options = opts;

package/build/es/mappings.js

@@ -141,6 +141,8 @@ async function createIndex(specifiers, moduleRegistry, runtimeEnvironment, runti
         if (!moduleId.version) {
             throw new Error('Module specifier must include a version: ' + specifier);
         }
+        // Do not use replace with the moduleBundler.  Otherwize we will create a bundle from every
+        // root just to get the URL.
         index[specifier] = await moduleRegistry.resolveModuleUri({ ...moduleId, version: moduleId.version }, moduleRuntimeEnvironment, runtimeParams);
     }
     // Queue up uri requests

package/build/es/object.js

@@ -18,7 +18,8 @@ function _deepFreeze(obj, maxDepth, depth) {
  */
 // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
 export function deepFreeze(obj, maxDepth = 5) {
-    return _deepFreeze(obj, maxDepth, 0);
+    const objClone = JSON.parse(JSON.stringify(obj));
+    return _deepFreeze(objClone, maxDepth, 0);
 }
 /**
  * Returns a function which debounces when the input function is called with the same first argument

package/build/es/serialize.d.ts

@@ -1,4 +1,4 @@
-import { LinkedModuleDefinition, ModuleJsonDefinition, ModuleRegistry, RuntimeParams } from '@lwrjs/types';
+import type { LinkedModuleDefinition, ModuleJsonDefinition, ModuleRegistry, RuntimeParams } from '@lwrjs/types';
 /**
  * Take a Module Definition and return its JSON serialization
  *
@@ -19,4 +19,11 @@ export declare function replaceStringFromLocation(src: string, { startOffset, en
     startOffset: number;
     endOffset: number;
 }, replaceValue: string): string;
+/**
+ * Given two TTLs, return the shortest one
+ * @param newTtl - time-to-live: time string or number of seconds
+ * @param oldTtl - the current shortest TTL (if it exists)
+ * @returns - the shorter of the two TTLs IN SECONDS, undefined if both TTLs are missing
+ */
+export declare function shortestTtl(newTtl?: string | number, oldTtl?: string | number): number | undefined;
 //# sourceMappingURL=serialize.d.ts.map

package/build/es/serialize.js

@@ -1,3 +1,4 @@
+import ms from 'ms';
 // Given a Module Identifier, return a JSON entry
 async function createJsonModule(moduleId, moduleRegistry, runtimeEnvironment, runtimeParams) {
     const { ownHash, moduleEntry: { version }, } = await moduleRegistry.getModule(moduleId, runtimeParams);
@@ -42,4 +43,21 @@ export async function serializeModuleToJson(code = '', { specifier, version, own
 export function replaceStringFromLocation(src, { startOffset, endOffset }, replaceValue) {
     return src.substr(0, startOffset) + replaceValue + src.substr(endOffset, src.length);
 }
+/**
+ * Given two TTLs, return the shortest one
+ * @param newTtl - time-to-live: time string or number of seconds
+ * @param oldTtl - the current shortest TTL (if it exists)
+ * @returns - the shorter of the two TTLs IN SECONDS, undefined if both TTLs are missing
+ */
+export function shortestTtl(newTtl, oldTtl) {
+    if (!newTtl && !oldTtl)
+        return undefined;
+    const newSeconds = typeof newTtl === 'string' ? ms(newTtl) / 1000 : newTtl;
+    const oldSeconds = typeof oldTtl === 'string' ? ms(oldTtl) / 1000 : oldTtl;
+    if (!newSeconds)
+        return oldSeconds;
+    if (!oldSeconds)
+        return newSeconds;
+    return newSeconds < oldSeconds ? newSeconds : oldSeconds;
+}
 //# sourceMappingURL=serialize.js.map