@lwrjs/shared-utils 0.12.0-alpha.9 → 0.12.1

package/build/cjs/bundle.cjs

@@ -28,6 +28,9 @@ function isGroupie(rawSpecifier, groupsConfig) {
   return false;
 }
 function createAmdAlias(aliasSpecifier, originalSpecifier) {
+  if (aliasSpecifier === originalSpecifier) {
+    return "";
+  }
   const builder = [];
   builder.push(`LWR.define('${aliasSpecifier}',['exports','${originalSpecifier}'],function(e,m){`);
   builder.push(`e.default=m&&'object'==typeof m&&'default'in m?m.default:m;`);

package/build/cjs/env.cjs

@@ -8,14 +8,16 @@ var __export = (target, all) => {
 // packages/@lwrjs/shared-utils/src/env.ts
 __markAsModule(exports);
 __export(exports, {
+  REQUEST_DEPTH_HEADER: () => REQUEST_DEPTH_HEADER,
+  REQUEST_DEPTH_KEY: () => REQUEST_DEPTH_KEY,
   buildEnvironmentContext: () => buildEnvironmentContext,
-  getFeatureFlags: () => getFeatureFlags
+  getFeatureFlags: () => getFeatureFlags,
+  parseRequestDepthHeader: () => parseRequestDepthHeader
 });
 function getFeatureFlags() {
   return {
     ASSETS_ON_LAMBDA: process.env.ASSETS_ON_LAMBDA !== void 0 && process.env.ASSETS_ON_LAMBDA.toLowerCase() === "true" ? true : false,
     LEGACY_LOADER: process.env.LEGACY_LOADER !== void 0 && process.env.LEGACY_LOADER.toLowerCase() === "true" ? true : false,
-    SSR_SANDBOX_VM: process.env.SSR_SANDBOX_VM !== void 0 && process.env.SSR_SANDBOX_VM.toLowerCase() === "true" ? true : false,
     SSR_STATIC_BUNDLES: process.env.SSR_STATIC_BUNDLES !== void 0 && process.env.SSR_STATIC_BUNDLES.toLowerCase() === "true" ? true : false,
     SSR_WITH_CSR_FALLBACK: process.env.SSR_WITH_CSR_FALLBACK !== void 0 && process.env.SSR_WITH_CSR_FALLBACK.toLowerCase() === "true" ? true : false,
     EXPERIMENTAL_UNVERSIONED_ALIASES: process.env.EXPERIMENTAL_UNVERSIONED_ALIASES !== void 0 && process.env.EXPERIMENTAL_UNVERSIONED_ALIASES.toLowerCase() === "true" ? true : false,
@@ -34,3 +36,27 @@ function buildEnvironmentContext(runtimeParams) {
     uiBasePath
   };
 }
+var REQUEST_DEPTH_HEADER = "X-SFDC-Request-Depth";
+var REQUEST_DEPTH_KEY = REQUEST_DEPTH_HEADER.toLowerCase();
+function parseRequestDepthHeader(headers = {}) {
+  let maxDepth = 0;
+  const value = headers && headers[REQUEST_DEPTH_KEY];
+  if (value) {
+    if (Array.isArray(value)) {
+      for (const depth of value) {
+        if (typeof depth === "string") {
+          const depthValue = parseInt(depth, 10);
+          if (!isNaN(depthValue) && depthValue > maxDepth) {
+            maxDepth = depthValue;
+          }
+        }
+      }
+    } else if (typeof value === "string") {
+      const depth = parseInt(value, 10);
+      if (!isNaN(depth) && depth > maxDepth) {
+        maxDepth = depth;
+      }
+    }
+  }
+  return maxDepth;
+}

package/build/cjs/fs.cjs

@@ -24,20 +24,28 @@ var __toModule = (module2) => {
 // packages/@lwrjs/shared-utils/src/fs.ts
 __markAsModule(exports);
 __export(exports, {
+  PROTOCOL_FILE: () => PROTOCOL_FILE,
+  PROTOCOL_HTTP: () => PROTOCOL_HTTP,
+  PROTOCOL_HTTPS: () => PROTOCOL_HTTPS,
   canResolveView: () => canResolveView,
+  filterProtocolEntries: () => filterProtocolEntries,
   getViewSourceFromFile: () => getViewSourceFromFile,
   hashContent: () => hashContent,
+  isLocalPath: () => isLocalPath,
   mimeLookup: () => import_mime_types.lookup,
   normalizeAssetSpecifier: () => normalizeAssetSpecifier,
   normalizeDirectory: () => normalizeDirectory,
+  normalizeFromFileURL: () => normalizeFromFileURL,
   normalizeResourcePath: () => normalizeResourcePath,
+  normalizeToFileUrl: () => normalizeToFileUrl,
   readFile: () => readFile,
   resolveFileExtension: () => resolveFileExtension,
   streamToString: () => streamToString,
   stringToStream: () => stringToStream
 });
-var import_fs = __toModule(require("fs"));
+var import_fs_extra = __toModule(require("fs-extra"));
 var import_path = __toModule(require("path"));
+var import_url = __toModule(require("url"));
 var import_crypto = __toModule(require("crypto"));
 var import_identity = __toModule(require("./identity.cjs"));
 var import_diagnostics = __toModule(require("@lwrjs/diagnostics"));
@@ -46,12 +54,15 @@ var import_stream = __toModule(require("stream"));
 var import_diagnostics2 = __toModule(require("@lwrjs/diagnostics"));
 var fileCount = 0;
 var files = new Map();
+var PROTOCOL_HTTP = "http://";
+var PROTOCOL_HTTPS = "https://";
+var PROTOCOL_FILE = "file://";
 function hashContent(source) {
   return import_crypto.default.createHash("md5").update(source).digest("hex");
 }
 function readFile(filePath) {
   logMetrics(filePath);
-  return import_fs.default.readFileSync(filePath, "utf8");
+  return import_fs_extra.default.readFileSync(filePath, "utf8");
 }
 function resolveFileExtension(filePath) {
   const fileName = import_path.default.basename(filePath);
@@ -59,16 +70,16 @@ function resolveFileExtension(filePath) {
   if (hasExt) {
     return filePath;
   }
-  if (import_fs.default.existsSync(filePath)) {
-    if (import_fs.default.statSync(filePath).isFile()) {
+  if (import_fs_extra.default.existsSync(filePath)) {
+    if (import_fs_extra.default.statSync(filePath).isFile()) {
       return filePath;
     } else {
       filePath = import_path.default.join(filePath, "index");
     }
   }
-  if (import_fs.default.existsSync(filePath + ".js")) {
+  if (import_fs_extra.default.existsSync(filePath + ".js")) {
     return filePath + ".js";
-  } else if (import_fs.default.existsSync(filePath + ".ts")) {
+  } else if (import_fs_extra.default.existsSync(filePath + ".ts")) {
     return filePath + ".ts";
   } else {
     throw new Error(`Unable to find file "${filePath}"`);
@@ -81,7 +92,7 @@ function canResolveView(source, type) {
   if (!source.endsWith(`.${type}`)) {
     return false;
   }
-  if (!import_fs.default.existsSync(import_path.default.resolve(source))) {
+  if (!import_fs_extra.default.existsSync(import_path.default.resolve(source))) {
     throw new Error(`View template cannot be found: "${source}"`);
   }
   return true;
@@ -103,6 +114,44 @@ var ROOT_DIR_REGEX = /\$rootDir/g;
 function normalizeDirectory(dir, rootDir) {
   return dir.replace(ROOT_DIR_REGEX, rootDir);
 }
+function normalizeToFileUrl(filePath, rootDir) {
+  if (filePath.startsWith(PROTOCOL_FILE)) {
+    return filePath;
+  }
+  const replacedPath = filePath.replace(ROOT_DIR_REGEX, rootDir);
+  const fullPath = import_path.default.resolve(rootDir, replacedPath);
+  return import_url.default.pathToFileURL(fullPath).href;
+}
+function normalizeFromFileURL(fileURL, basePath) {
+  if (typeof fileURL !== "string" || !fileURL.startsWith("file://")) {
+    return null;
+  }
+  const filePath = import_url.default.fileURLToPath(fileURL);
+  const normalizedBasePath = import_path.default.resolve(import_path.default.normalize(basePath));
+  const compatibleFilePath = filePath.split(import_path.default.sep).join("/");
+  const compatibleBasePath = normalizedBasePath.split(import_path.default.sep).join("/");
+  if (compatibleFilePath.startsWith(compatibleBasePath)) {
+    const relativePath = "/" + import_path.default.relative(normalizedBasePath, filePath).split(import_path.default.sep).join("/");
+    return relativePath;
+  } else {
+    return compatibleFilePath.startsWith("/") ? compatibleFilePath : "/" + compatibleFilePath;
+  }
+}
+function isLocalPath(filePath) {
+  if (!filePath) {
+    return false;
+  }
+  if (filePath.startsWith("//")) {
+    return false;
+  }
+  if (filePath.startsWith("$rootDir") || filePath.startsWith(PROTOCOL_FILE) || filePath.startsWith("/")) {
+    return true;
+  }
+  if (/^[a-zA-Z]:\\/.test(filePath)) {
+    return true;
+  }
+  return false;
+}
 var RESOURCE_DIR_REGEX = /\$(\w+)|^\$(\w+)/g;
 function normalizeResourcePath(rawPath, {rootDir, assets, contentDir, layoutsDir}, allowUnresolvedAlias) {
   const assetsMap = assets.reduce((map, asset) => {
@@ -188,3 +237,7 @@ function stringToStream(str) {
   });
   return readable;
 }
+function filterProtocolEntries(record, protocol) {
+  const filteredEntries = Object.entries(record).filter(([_key, value]) => !value || !value.startsWith(protocol));
+  return Object.fromEntries(filteredEntries);
+}

package/build/cjs/identity.cjs

@@ -122,10 +122,10 @@ function getSpecifier({specifier, namespace, name = "", version}) {
   if (specifier) {
     const versionMatch = specifier.match(/(.+)\/v\/[a-zA-Z0-9-_.]+$/);
     specifier = versionMatch ? versionMatch[1] : specifier;
-    return version ? `${specifier}${VERSION_SIGIL}${normalizeVersionToUri(version)}` : specifier;
+    return version && version !== VERSION_NOT_PROVIDED ? `${specifier}${VERSION_SIGIL}${normalizeVersionToUri(version)}` : specifier;
   }
   const bareSpecifier = namespace ? `${namespace}/${name}` : name;
-  return version ? `${bareSpecifier}${VERSION_SIGIL}${normalizeVersionToUri(version)}` : bareSpecifier;
+  return version && version !== VERSION_NOT_PROVIDED ? `${bareSpecifier}${VERSION_SIGIL}${normalizeVersionToUri(version)}` : bareSpecifier;
 }
 async function getVersionedModuleId(rawSpecifier, moduleRegistry, runtimeParams) {
   const moduleId = explodeSpecifier(rawSpecifier);

package/build/cjs/mappings.cjs

@@ -25,10 +25,13 @@ var __toModule = (module2) => {
 __markAsModule(exports);
 __export(exports, {
   getImportMetadataMappings: () => getImportMetadataMappings,
+  isExternalFileSpecifier: () => isExternalFileSpecifier,
+  isExternalSpecifier: () => isExternalSpecifier,
   toImportMetadata: () => toImportMetadata
 });
 var import_graph = __toModule(require("./graph.cjs"));
 var import_identity = __toModule(require("./identity.cjs"));
+var import_fs = __toModule(require("./fs.cjs"));
 async function getImportMetadataMappings(moduleIds, runtimeEnvironment, runtimeParams, moduleRegistry, moduleBundler) {
   const visitedCache = new Map();
   let importMetadata = {
@@ -46,7 +49,7 @@ async function getImportMetadataMappings(moduleIds, runtimeEnvironment, runtimeP
       const moduleGraph = await (0, import_graph.getModuleGraphs)(specifier, {includeUris: true, includeLinkedDefinitions: true, depth}, moduleRegistry, runtimeEnvironment.bundle ? moduleBundler : moduleRegistry, runtimeEnvironment, runtimeParams, visitedCache);
       importMetadata = await toImportMetadata(moduleGraph, importMetadata, moduleRegistry, runtimeEnvironment, runtimeParams);
     }
-    if (requestedSpecifier !== specifier) {
+    if (moduleId.importer && requestedSpecifier !== specifier) {
       const requestedSpecifierPlusImporter = `${requestedSpecifier}?importer=${moduleId.importer}`;
       const specifiersArray = Object.values(importMetadata.imports).find((a) => a.includes(specifier));
       if (!specifiersArray) {
@@ -67,10 +70,19 @@ async function toImportMetadata(moduleGraph, existingImportMetadata = {imports:
   if (!definition) {
     throw new Error("Linked module definition was not included in the graph: " + specifier);
   }
+  if (isExternalSpecifier(specifier, moduleRegistry.getConfig().bundleConfig)) {
+    const externalMapping = {imports: {}, index: {}};
+    externalMapping.imports[uri] = [specifier];
+    externalMapping.index[specifier] = uri;
+    return externalMapping;
+  }
   const rootMetadata = await normalizeImportMetadata(specifier, uri, definition, moduleRegistry, runtimeEnvironment, runtimeParams);
   let importMetadata = mergeImportMetadata(existingImportMetadata, rootMetadata);
   const depSpecifiers = runtimeEnvironment.format === "esm" ? moduleGraph.graphs[0].dynamicRefs : moduleGraph.graphs[0].static;
   for (const depSpecifier of depSpecifiers) {
+    if (isExternalSpecifier(depSpecifier, moduleRegistry.getConfig().bundleConfig)) {
+      continue;
+    }
     const depUri = moduleGraph.uriMap[depSpecifier];
     const depDef = moduleGraph.linkedDefinitions[depSpecifier];
     const depMissing = !depUri || !depDef;
@@ -85,8 +97,11 @@ async function toImportMetadata(moduleGraph, existingImportMetadata = {imports:
       continue;
     }
     if (!importMetadata.imports[depUri]) {
-      const depMetadata = await normalizeImportMetadata((0, import_identity.getSpecifier)(depDef), depUri, depDef, moduleRegistry, runtimeEnvironment, runtimeParams);
-      importMetadata = mergeImportMetadata(importMetadata, depMetadata);
+      const depDefSpecifier = (0, import_identity.getSpecifier)(depDef);
+      if (!isExternalSpecifier(depDefSpecifier, moduleRegistry.getConfig().bundleConfig)) {
+        const depMetadata = await normalizeImportMetadata(depDefSpecifier, depUri, depDef, moduleRegistry, runtimeEnvironment, runtimeParams);
+        importMetadata = mergeImportMetadata(importMetadata, depMetadata);
+      }
     }
   }
   return importMetadata;
@@ -124,20 +139,19 @@ async function createIndex(specifiers, moduleRegistry, runtimeEnvironment, runti
   const moduleRuntimeEnvironment = {...runtimeEnvironment, bundle: false};
   async function getUri(specifier) {
     const moduleId = (0, import_identity.explodeSpecifier)(specifier);
-    if (!moduleId.version) {
-      throw new Error("Module specifier must include a version: " + specifier);
-    }
-    index[specifier] = await moduleRegistry.resolveModuleUri({...moduleId, version: moduleId.version}, moduleRuntimeEnvironment, runtimeParams);
+    index[specifier] = await moduleRegistry.resolveModuleUri({...moduleId, version: moduleId.version || import_identity.VERSION_NOT_PROVIDED}, moduleRuntimeEnvironment, runtimeParams);
   }
   const promises = [];
   for (const specifier of specifiers) {
-    promises.push(getUri(specifier));
+    if (!isExternalSpecifier(specifier, moduleRegistry.getConfig().bundleConfig)) {
+      promises.push(getUri(specifier));
+    }
   }
   await Promise.all(promises);
   return index;
 }
 async function getVersionedSpecifier(moduleId, moduleRegistry, runtimeParams) {
-  if (!moduleId.importer || moduleId.version) {
+  if (moduleId.version) {
     return (0, import_identity.getSpecifier)(moduleId);
   }
   const versionedModuleEntry = await moduleRegistry.getModuleEntry({
@@ -145,3 +159,11 @@ async function getVersionedSpecifier(moduleId, moduleRegistry, runtimeParams) {
   }, runtimeParams);
   return (0, import_identity.getSpecifier)(versionedModuleEntry);
 }
+function isExternalSpecifier(id, bundleConfig) {
+  const {specifier} = (0, import_identity.explodeSpecifier)(id);
+  return !!(bundleConfig?.external && Object.prototype.hasOwnProperty.call(bundleConfig.external, specifier));
+}
+function isExternalFileSpecifier(id, bundleConfig) {
+  const {specifier} = (0, import_identity.explodeSpecifier)(id);
+  return !!(bundleConfig?.external && bundleConfig.external[specifier] && bundleConfig.external[specifier].startsWith(import_fs.PROTOCOL_FILE));
+}

package/build/es/bundle.js

@@ -25,6 +25,10 @@ export function isGroupie(rawSpecifier, groupsConfig) {
  *
  */
 export function createAmdAlias(aliasSpecifier, originalSpecifier) {
+    // If the aliasSpecifier === the originalSpecifier specifier do not bother creating an alias
+    if (aliasSpecifier === originalSpecifier) {
+        return '';
+    }
     const builder = [];
     // Define statement
     builder.push(`LWR.define('${aliasSpecifier}',['exports','${originalSpecifier}'],function(e,m){`);

package/build/es/env.d.ts

@@ -1,7 +1,10 @@
-import type { EnvironmentContext, FeatureFlags, RuntimeParams } from '@lwrjs/types';
+import type { EnvironmentContext, FeatureFlags, Headers, RuntimeParams } from '@lwrjs/types';
 export declare function getFeatureFlags(): FeatureFlags;
 /**
  * Create a serializable context for the lwr/environment variable
  */
 export declare function buildEnvironmentContext(runtimeParams: RuntimeParams): EnvironmentContext;
+export declare const REQUEST_DEPTH_HEADER = "X-SFDC-Request-Depth";
+export declare const REQUEST_DEPTH_KEY: string;
+export declare function parseRequestDepthHeader(headers?: Headers): number;
 //# sourceMappingURL=env.d.ts.map

package/build/es/env.js

@@ -10,10 +10,6 @@ export function getFeatureFlags() {
         LEGACY_LOADER: process.env.LEGACY_LOADER !== undefined && process.env.LEGACY_LOADER.toLowerCase() === 'true'
             ? true
             : false,
-        // Set true to use NODE:VM for SSR sandboxes
-        SSR_SANDBOX_VM: process.env.SSR_SANDBOX_VM !== undefined && process.env.SSR_SANDBOX_VM.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'
@@ -53,4 +49,29 @@ export function buildEnvironmentContext(runtimeParams) {
         uiBasePath,
     };
 }
+export const REQUEST_DEPTH_HEADER = 'X-SFDC-Request-Depth';
+export const REQUEST_DEPTH_KEY = REQUEST_DEPTH_HEADER.toLowerCase();
+export function parseRequestDepthHeader(headers = {}) {
+    let maxDepth = 0;
+    const value = headers && headers[REQUEST_DEPTH_KEY];
+    if (value) {
+        if (Array.isArray(value)) {
+            for (const depth of value) {
+                if (typeof depth === 'string') {
+                    const depthValue = parseInt(depth, 10);
+                    if (!isNaN(depthValue) && depthValue > maxDepth) {
+                        maxDepth = depthValue;
+                    }
+                }
+            }
+        }
+        else if (typeof value === 'string') {
+            const depth = parseInt(value, 10);
+            if (!isNaN(depth) && depth > maxDepth) {
+                maxDepth = depth;
+            }
+        }
+    }
+    return maxDepth;
+}
 //# sourceMappingURL=env.js.map

package/build/es/fs.d.ts

@@ -3,6 +3,9 @@
 import type { AssetIdentifier, ResourcePaths, ViewSource } from '@lwrjs/types';
 import { lookup } from 'mime-types';
 import { Readable } from 'stream';
+export declare const PROTOCOL_HTTP = "http://";
+export declare const PROTOCOL_HTTPS = "https://";
+export declare const PROTOCOL_FILE = "file://";
 /**
  * Create a hash string for a source
  * @param source
@@ -32,6 +35,15 @@ export declare function canResolveView(source: unknown, type: string): boolean;
  */
 export declare function getViewSourceFromFile(source: string): ViewSource;
 export declare function normalizeDirectory(dir: string, rootDir: string): string;
+/**
+ * Replace all instances of `$rootDir` with `rootDir`.
+ * Convert path to file:// url
+ * @param file
+ * @param rootDir
+ */
+export declare function normalizeToFileUrl(filePath: string, rootDir: string): string;
+export declare function normalizeFromFileURL(fileURL: string | undefined, basePath: string): string | null;
+export declare function isLocalPath(filePath: string): boolean;
 export declare function normalizeResourcePath(rawPath: string, { rootDir, assets, contentDir, layoutsDir }: ResourcePaths, allowUnresolvedAlias?: boolean): string;
 export { lookup as mimeLookup };
 /**
@@ -40,4 +52,5 @@ export { lookup as mimeLookup };
 export declare function normalizeAssetSpecifier(assetId: AssetIdentifier, assetPathMap: Map<string, string>, resourcePaths: ResourcePaths, basePath: string): string;
 export declare function streamToString(stream: Readable, encoding?: BufferEncoding): Promise<string>;
 export declare function stringToStream(str: string | Buffer): Readable;
+export declare function filterProtocolEntries(record: Record<string, string>, protocol: string): Record<string, string>;
 //# sourceMappingURL=fs.d.ts.map

package/build/es/fs.js

@@ -1,5 +1,6 @@
-import fs from 'fs';
+import fs from 'fs-extra';
 import pathLib from 'path';
+import url from 'url';
 import crypto from 'crypto';
 import { slugify } from './identity.js';
 import { LwrUnresolvableError, createSingleDiagnosticError, descriptions } from '@lwrjs/diagnostics';
@@ -8,6 +9,10 @@ import { Readable } from 'stream';
 import { logger } from '@lwrjs/diagnostics';
 let fileCount = 0;
 const files = new Map();
+// LWR Internal URL protocol
+export const PROTOCOL_HTTP = 'http://';
+export const PROTOCOL_HTTPS = 'https://';
+export const PROTOCOL_FILE = 'file://';
 /**
  * Create a hash string for a source
  * @param source
@@ -99,6 +104,63 @@ const ROOT_DIR_REGEX = /\$rootDir/g;
 export function normalizeDirectory(dir, rootDir) {
     return dir.replace(ROOT_DIR_REGEX, rootDir);
 }
+/**
+ * Replace all instances of `$rootDir` with `rootDir`.
+ * Convert path to file:// url
+ * @param file
+ * @param rootDir
+ */
+export function normalizeToFileUrl(filePath, rootDir) {
+    // Check if filePath already starts with 'file://'
+    if (filePath.startsWith(PROTOCOL_FILE)) {
+        return filePath;
+    }
+    const replacedPath = filePath.replace(ROOT_DIR_REGEX, rootDir);
+    const fullPath = pathLib.resolve(rootDir, replacedPath);
+    return url.pathToFileURL(fullPath).href;
+}
+export function normalizeFromFileURL(fileURL, basePath) {
+    if (typeof fileURL !== 'string' || !fileURL.startsWith('file://')) {
+        return null;
+    }
+    // Convert fileURL to a system-specific path
+    const filePath = url.fileURLToPath(fileURL);
+    // Resolve and normalize base path to ensure it's in the correct format and system-specific
+    const normalizedBasePath = pathLib.resolve(pathLib.normalize(basePath));
+    // Ensure compatibility across different OS by replacing path separators accordingly
+    const compatibleFilePath = filePath.split(pathLib.sep).join('/');
+    const compatibleBasePath = normalizedBasePath.split(pathLib.sep).join('/');
+    // Check if filePath starts with the basePath
+    if (compatibleFilePath.startsWith(compatibleBasePath)) {
+        // Return the relative path from basePath, ensuring it starts with a '/'
+        const relativePath = '/' + pathLib.relative(normalizedBasePath, filePath).split(pathLib.sep).join('/');
+        return relativePath;
+    }
+    else {
+        // Return the full path if outside of basePath, ensuring it starts with a '/'
+        return compatibleFilePath.startsWith('/') ? compatibleFilePath : '/' + compatibleFilePath;
+    }
+}
+export function isLocalPath(filePath) {
+    // handle null or undefined
+    if (!filePath) {
+        return false;
+    }
+    // Check for protocol-relative URLs or network paths
+    if (filePath.startsWith('//')) {
+        return false;
+    }
+    // Check for file protocol or absolute file paths on Unix/Linux
+    if (filePath.startsWith('$rootDir') || filePath.startsWith(PROTOCOL_FILE) || filePath.startsWith('/')) {
+        return true;
+    }
+    // Check for Windows absolute paths (e.g., C:\path\to\file)
+    if (/^[a-zA-Z]:\\/.test(filePath)) {
+        return true;
+    }
+    // Consider anything not identified as a file protocol or an absolute path as non-local
+    return false;
+}
 /**
  * Replace all instances of `$*Dir` with `resourcePaths.*Dir`
  * @param rawPath
@@ -203,4 +265,12 @@ export function stringToStream(str) {
     });
     return readable;
 }
+// Function to filter out entries where the value starts with given protocol
+export function filterProtocolEntries(record, protocol) {
+    // Use Object.entries to get an array of [key, value] pairs,
+    // then filter out the pairs where value starts with {protocol}
+    const filteredEntries = Object.entries(record).filter(([_key, value]) => !value || !value.startsWith(protocol));
+    // Use Object.fromEntries to convert the filtered entries back into an object
+    return Object.fromEntries(filteredEntries);
+}
 //# sourceMappingURL=fs.js.map

package/build/es/identity.d.ts

@@ -56,6 +56,7 @@ export declare function explodeSpecifiers(rawSpecifiers: string): PartialModuleI
  * @example - { name: 'lwc', version: '1.7' } => 'lwc/v/1.7'
  * @example - { namespace: 'c', name: 'navMenu', version: '2.0' } => 'c/navMenu/v/2.0'
  * @example - { namespace: '@salesforce', name: 'label/my.label', version: '1' } => '@salesforce/label/my.label/v/1'
+ * @example - { namespace: '@salesforce', name: 'label/my.label', version: 'version-not-provided' } => '@salesforce/label/my.label'
  */
 export declare function getSpecifier({ specifier, namespace, name, version }: ModuleIdentifierPartial): string;
 interface VersionedAbstractModuleId extends AbstractModuleId {

package/build/es/identity.js

@@ -90,16 +90,23 @@ export function explodeSpecifiers(rawSpecifiers) {
  * @example - { name: 'lwc', version: '1.7' } => 'lwc/v/1.7'
  * @example - { namespace: 'c', name: 'navMenu', version: '2.0' } => 'c/navMenu/v/2.0'
  * @example - { namespace: '@salesforce', name: 'label/my.label', version: '1' } => '@salesforce/label/my.label/v/1'
+ * @example - { namespace: '@salesforce', name: 'label/my.label', version: 'version-not-provided' } => '@salesforce/label/my.label'
  */
 export function getSpecifier({ specifier, namespace, name = '', version }) {
     if (specifier) {
         // Remove any versioning from the specifier
         const versionMatch = specifier.match(/(.+)\/v\/[a-zA-Z0-9-_.]+$/);
         specifier = versionMatch ? versionMatch[1] : specifier;
-        return version ? `${specifier}${VERSION_SIGIL}${normalizeVersionToUri(version)}` : specifier;
+        // If a module has an explicit 'version-not-provided' version this will not be reflected in the specifier
+        return version && version !== VERSION_NOT_PROVIDED
+            ? `${specifier}${VERSION_SIGIL}${normalizeVersionToUri(version)}`
+            : specifier;
     }
     const bareSpecifier = namespace ? `${namespace}/${name}` : name;
-    return version ? `${bareSpecifier}${VERSION_SIGIL}${normalizeVersionToUri(version)}` : bareSpecifier;
+    // If a module has an explicit 'version-not-provided' version this will not be reflected in the specifier
+    return version && version !== VERSION_NOT_PROVIDED
+        ? `${bareSpecifier}${VERSION_SIGIL}${normalizeVersionToUri(version)}`
+        : bareSpecifier;
 }
 /**
  * Create a AbstractModuleId using the module registry to resolve the version

package/build/es/mappings.d.ts

@@ -1,4 +1,4 @@
-import type { AbstractModuleId, FlattenedModuleGraphs, ImportMetadata, ModuleBundler, ModuleRegistry, RuntimeEnvironment, RuntimeParams } from '@lwrjs/types';
+import type { AbstractModuleId, BundleConfig, FlattenedModuleGraphs, ImportMetadata, ModuleBundler, ModuleRegistry, RuntimeEnvironment, RuntimeParams } from '@lwrjs/types';
 /**
  * Get the Import Metadata for the LWR Mapping Api (https://rfcs.lwc.dev/rfcs/lwr/0000-mapping-api)
  */
@@ -16,4 +16,6 @@ export declare function getImportMetadataMappings(moduleIds: AbstractModuleId[],
  * @returns Returns ImportMetadata from a module graph in the format here -> https://rfcs.lwc.dev/rfcs/lwr/0000-mapping-api#uri-mapping-resource-specification
  */
 export declare function toImportMetadata(moduleGraph: FlattenedModuleGraphs, existingImportMetadata: ImportMetadata | undefined, moduleRegistry: ModuleRegistry, runtimeEnvironment: RuntimeEnvironment, runtimeParams?: RuntimeParams): Promise<ImportMetadata>;
+export declare function isExternalSpecifier(id: string, bundleConfig: BundleConfig): boolean;
+export declare function isExternalFileSpecifier(id: string, bundleConfig: BundleConfig): boolean;
 //# sourceMappingURL=mappings.d.ts.map

package/build/es/mappings.js

@@ -1,5 +1,6 @@
 import { getModuleGraphs, GraphDepth } from './graph.js';
-import { explodeSpecifier, getSpecifier, isBundleDefinition } from './identity.js';
+import { explodeSpecifier, getSpecifier, isBundleDefinition, VERSION_NOT_PROVIDED } from './identity.js';
+import { PROTOCOL_FILE } from './fs.js';
 /**
  * Get the Import Metadata for the LWR Mapping Api (https://rfcs.lwc.dev/rfcs/lwr/0000-mapping-api)
  */
@@ -30,7 +31,7 @@ export async function getImportMetadataMappings(moduleIds, runtimeEnvironment, r
             importMetadata = await toImportMetadata(moduleGraph, importMetadata, moduleRegistry, runtimeEnvironment, runtimeParams);
         }
         // If the requested specifier is not the same as the versioned specifier, include the requested specifier's importer.
-        if (requestedSpecifier !== specifier) {
+        if (moduleId.importer && requestedSpecifier !== specifier) {
             const requestedSpecifierPlusImporter = `${requestedSpecifier}?importer=${moduleId.importer}`;
             const specifiersArray = Object.values(importMetadata.imports).find((a) => a.includes(specifier));
             if (!specifiersArray) {
@@ -64,6 +65,13 @@ export async function toImportMetadata(moduleGraph, existingImportMetadata = { i
     if (!definition) {
         throw new Error('Linked module definition was not included in the graph: ' + specifier);
     }
+    // Add a single entry for an external
+    if (isExternalSpecifier(specifier, moduleRegistry.getConfig().bundleConfig)) {
+        const externalMapping = { imports: {}, index: {} };
+        externalMapping.imports[uri] = [specifier];
+        externalMapping.index[specifier] = uri;
+        return externalMapping;
+    }
     // Merge in the existing metadata with imports for the root specifier
     const rootMetadata = await normalizeImportMetadata(specifier, uri, definition, moduleRegistry, runtimeEnvironment, runtimeParams);
     let importMetadata = mergeImportMetadata(existingImportMetadata, rootMetadata);
@@ -74,6 +82,10 @@ export async function toImportMetadata(moduleGraph, existingImportMetadata = { i
         ? moduleGraph.graphs[0].dynamicRefs
         : moduleGraph.graphs[0].static;
     for (const depSpecifier of depSpecifiers) {
+        if (isExternalSpecifier(depSpecifier, moduleRegistry.getConfig().bundleConfig)) {
+            // Ignore Externals
+            continue;
+        }
         const depUri = moduleGraph.uriMap[depSpecifier];
         const depDef = moduleGraph.linkedDefinitions[depSpecifier];
         const depMissing = !depUri || !depDef;
@@ -90,9 +102,12 @@ export async function toImportMetadata(moduleGraph, existingImportMetadata = { i
             continue;
         }
         if (!importMetadata.imports[depUri]) {
-            // eslint-disable-next-line no-await-in-loop
-            const depMetadata = await normalizeImportMetadata(getSpecifier(depDef), depUri, depDef, moduleRegistry, runtimeEnvironment, runtimeParams);
-            importMetadata = mergeImportMetadata(importMetadata, depMetadata);
+            const depDefSpecifier = getSpecifier(depDef);
+            if (!isExternalSpecifier(depDefSpecifier, moduleRegistry.getConfig().bundleConfig)) {
+                // eslint-disable-next-line no-await-in-loop
+                const depMetadata = await normalizeImportMetadata(depDefSpecifier, depUri, depDef, moduleRegistry, runtimeEnvironment, runtimeParams);
+                importMetadata = mergeImportMetadata(importMetadata, depMetadata);
+            }
         }
     }
     return importMetadata;
@@ -138,24 +153,23 @@ async function createIndex(specifiers, moduleRegistry, runtimeEnvironment, runti
     const moduleRuntimeEnvironment = { ...runtimeEnvironment, bundle: false };
     async function getUri(specifier) {
         const moduleId = explodeSpecifier(specifier);
-        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
+        // Do not use replace with the moduleBundler.  Otherwise we will create a bundle from every
         // root just to get the URL.
-        index[specifier] = await moduleRegistry.resolveModuleUri({ ...moduleId, version: moduleId.version }, moduleRuntimeEnvironment, runtimeParams);
+        index[specifier] = await moduleRegistry.resolveModuleUri({ ...moduleId, version: moduleId.version || VERSION_NOT_PROVIDED }, moduleRuntimeEnvironment, runtimeParams);
     }
     // Queue up uri requests
     const promises = [];
     for (const specifier of specifiers) {
-        promises.push(getUri(specifier));
+        if (!isExternalSpecifier(specifier, moduleRegistry.getConfig().bundleConfig)) {
+            promises.push(getUri(specifier));
+        }
     }
     // Wait for them to finish
     await Promise.all(promises);
     return index;
 }
 async function getVersionedSpecifier(moduleId, moduleRegistry, runtimeParams) {
-    if (!moduleId.importer || moduleId.version) {
+    if (moduleId.version) {
         return getSpecifier(moduleId);
     }
     const versionedModuleEntry = await moduleRegistry.getModuleEntry({
@@ -163,4 +177,14 @@ async function getVersionedSpecifier(moduleId, moduleRegistry, runtimeParams) {
     }, runtimeParams);
     return getSpecifier(versionedModuleEntry);
 }
+export function isExternalSpecifier(id, bundleConfig) {
+    const { specifier } = explodeSpecifier(id);
+    return !!(bundleConfig?.external && Object.prototype.hasOwnProperty.call(bundleConfig.external, specifier));
+}
+export function isExternalFileSpecifier(id, bundleConfig) {
+    const { specifier } = explodeSpecifier(id);
+    return !!(bundleConfig?.external &&
+        bundleConfig.external[specifier] &&
+        bundleConfig.external[specifier].startsWith(PROTOCOL_FILE));
+}
 //# sourceMappingURL=mappings.js.map

package/package.json

@@ -4,7 +4,7 @@
     "publishConfig": {
         "access": "public"
     },
-    "version": "0.12.0-alpha.9",
+    "version": "0.12.1",
     "homepage": "https://developer.salesforce.com/docs/platform/lwr/overview",
     "repository": {
         "type": "git",
@@ -37,10 +37,10 @@
         "build/**/*.d.ts"
     ],
     "dependencies": {
-        "@lwrjs/diagnostics": "0.12.0-alpha.9",
+        "@lwrjs/diagnostics": "0.12.1",
         "es-module-lexer": "^1.3.0",
         "fast-json-stable-stringify": "^2.1.0",
-        "magic-string": "^0.30.0",
+        "magic-string": "^0.30.8",
         "mime-types": "^2.1.33",
         "ms": "^2.1.3",
         "parse5-sax-parser": "^6.0.1",
@@ -50,12 +50,12 @@
         "slugify": "^1.4.5"
     },
     "devDependencies": {
-        "@lwrjs/types": "0.12.0-alpha.9",
-        "@types/mime-types": "2.1.1",
+        "@lwrjs/types": "0.12.1",
+        "@types/mime-types": "2.1.4",
         "@types/path-to-regexp": "^1.7.0"
     },
     "engines": {
         "node": ">=18.0.0"
     },
-    "gitHead": "58b28fbc6300b704ac17f8878423120de0e376d7"
+    "gitHead": "4f8b2759b540af7443f07528980ddb0e7d4d5e3a"
 }