@lwrjs/shared-utils 0.9.0-alpha.3 → 0.9.0-alpha.30

package/build/es/compiler.d.ts

@@ -0,0 +1,15 @@
+import type { CompilerResult, LwrLockerConfig, ModuleCompiled } from '@lwrjs/types';
+/**
+ * When importing these modules make sure the optional dependencies are installed:
+ * - 'rollup' for convertToAmd()
+ * - '@locker/compiler' for lockerize()
+ */
+export declare const AMD_DEFINE = "LWR.define";
+export declare function convertToAmd(source: string, { id }: {
+    id: string;
+}, forceNamedExports?: boolean): Promise<CompilerResult>;
+/** Locker
+ * Trusted Components can contain namespaces with wildcard or single component
+ */
+export declare function lockerize({ compiledSource: source, specifier, moduleEntry: { entry: filename } }: ModuleCompiled, { trustedComponents }: LwrLockerConfig, sourcemap?: boolean): CompilerResult;
+//# sourceMappingURL=compiler.d.ts.map

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,25 @@
 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, sand-boxing = false (use locker for ssr sand-boxing)
+        SSR_SANDBOX_WORKER: process.env.SSR_SANDBOX_WORKER !== undefined &&
+            process.env.SSR_SANDBOX_WORKER.toLowerCase() === 'true'
+            ? true
+            : false,
+        // Should we load load the assets from the lambda on MRT
+        ASSETS_ON_LAMBDA: process.env.ASSETS_ON_LAMBDA !== undefined &&
+            process.env.ASSETS_ON_LAMBDA.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 { AssetIdentifier, 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
  *
@@ -41,4 +32,8 @@ export declare function getViewSourceFromFile(source: string): ViewSource;
 export declare function normalizeDirectory(dir: string, rootDir: string): string;
 export declare function normalizeResourcePath(rawPath: string, { rootDir, assets, contentDir, layoutsDir }: ResourcePaths, allowUnresolvedAlias?: boolean): string;
 export { lookup as mimeLookup };
+/**
+ * Tries to convert any URL or $aliased path into a canonical fs path
+ */
+export declare function normalizeAssetSpecifier(assetId: AssetIdentifier, assetPathMap: Map<string, string>, resourcePaths: ResourcePaths, basePath: string): string;
 //# sourceMappingURL=fs.d.ts.map

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';
@@ -38,10 +36,10 @@ export function resolveFileExtension(filePath) {
     // No extension, if it exist, it can be a dir or a file
     if (fs.existsSync(filePath)) {
         if (fs.statSync(filePath).isFile()) {
-            return filePath; // extensionless file, which is odd but...
+            return filePath; // extension-less file, which is odd but...
         }
         else {
-            filePath = pathLib.join(filePath, 'index'); // if is a dir we will be tesing the extensions
+            filePath = pathLib.join(filePath, 'index'); // if is a dir we will be testing the extensions
         }
     }
     // At this point we have a file with no extension so we try for the default (js,ts) or fail
@@ -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
  *
@@ -153,4 +132,35 @@ function logMetrics(filePath) {
         }
     }
 }
+/**
+ * Tries to convert any URL or $aliased path into a canonical fs path
+ */
+export function normalizeAssetSpecifier(assetId, assetPathMap, resourcePaths, basePath) {
+    const { specifier, importer, type } = assetId;
+    if (specifier.startsWith('./') || specifier.startsWith('../')) {
+        if (!importer) {
+            throw Error(`Unable to resolve relative import "${specifier}" without an importer.`);
+        }
+        return pathLib.join(pathLib.dirname(importer), specifier);
+    }
+    if (type === 'content-asset') {
+        const originSpecifier = !basePath ? specifier : specifier.split(basePath)[1];
+        return pathLib.join(resourcePaths.contentDir, originSpecifier);
+    }
+    if (specifier[0] === '$') {
+        // This is a fs path containing an asset alias
+        return normalizeResourcePath(specifier, resourcePaths);
+    }
+    // This is an absolute path to the server
+    // Match in 2 ways:
+    //      - Directories: the prefix of the asset specifier/path matches a configured assets[i].urlPath
+    //      - Individual files: the asset specifier is equal to a configured assets[i].urlPath
+    for (const [urlPath, fsPath] of assetPathMap.entries()) {
+        const slashPath = urlPath.endsWith('/') ? urlPath : `${urlPath}/`;
+        if (specifier.startsWith(slashPath) || specifier === urlPath) {
+            return specifier.replace(urlPath, fsPath);
+        }
+    }
+    return specifier;
+}
 //# sourceMappingURL=fs.js.map

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, 
@@ -94,7 +94,7 @@ defRegistry, runtimeEnvironment, runtimeParams) {
 }
 async function flatten(versionedSpecifier, flattened, idx, visited) {
     const node = visited.get(versionedSpecifier);
-    if (node) {
+    if (flattened[idx]?.static && node?.static) {
         node.static.forEach(async (imp) => {
             if (!flattened[idx].static.includes(imp)) {
                 flattened[idx].static.push(imp);
@@ -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, AssetSource, 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;
@@ -131,9 +104,9 @@ export declare function parsePackageSpecifier(specifier: string): PackageIdentit
  * @param name A string in kebab case
  * @example - 'name-of-something' => 'name/ofSomething'
  */
-export declare function kebabCaseToModuleSpecifer(name: string): string;
+export declare function kebabCaseToModuleSpecifier(name: string): string;
 /**
- * Clone of lwr/init, reverse of kebabCaseToModuleSpecifer, strips off versions
+ * Clone of lwr/init, reverse of kebabCaseToModuleSpecifier, strips off versions
  * @param specifier
  * @example - 'name/ofSomething/v/1.0.0' => 'name-of-something'
  */
@@ -164,9 +137,6 @@ export declare function getModuleUriPrefix({ apiVersion, bundle, format, compat,
 export declare function getMappingUriPrefix({ apiVersion, bundle, format, compat, basePath }: RuntimeEnvironment, { locale, environment }?: RuntimeParams): string;
 export { getCacheKeyFromJson };
 export declare function isExternalUrl(url: string): boolean;
+export declare function isAssetSourceExternal(assetSource: AssetSource): 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

@@ -21,6 +21,8 @@ export const DEFAULT_LWR_BOOTSTRAP_CONFIG = {
     services: [],
     configAsSrc: false,
     ssr: false,
+    module: undefined,
+    preloadModules: [],
 };
 /**
  * Turn the dots in a version into underscores
@@ -96,37 +98,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 +119,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]+))?/;
@@ -194,7 +165,7 @@ export function parsePackageSpecifier(specifier) {
  * @param name A string in kebab case
  * @example - 'name-of-something' => 'name/ofSomething'
  */
-export function kebabCaseToModuleSpecifer(name) {
+export function kebabCaseToModuleSpecifier(name) {
     const newName = [];
     let nsFound = false;
     let upper = false;
@@ -216,7 +187,7 @@ export function kebabCaseToModuleSpecifer(name) {
     return newName.join('');
 }
 /**
- * Clone of lwr/init, reverse of kebabCaseToModuleSpecifer, strips off versions
+ * Clone of lwr/init, reverse of kebabCaseToModuleSpecifier, strips off versions
  * @param specifier
  * @example - 'name/ofSomething/v/1.0.0' => 'name-of-something'
  */
@@ -275,57 +246,11 @@ const REGEX_URL_SCHEMA_PREFIX = /^(https?|\/\/)/;
 export function isExternalUrl(url) {
     return REGEX_URL_SCHEMA_PREFIX.test(url);
 }
+export function isAssetSourceExternal(assetSource) {
+    return assetSource.type === 'external' || (!!assetSource.uri && isExternalUrl(assetSource.uri));
+}
 // type guard for ViewDef responses
 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