@lwrjs/shared-utils 0.9.0-alpha.13 → 0.9.0-alpha.14

package/build/cjs/compiler.cjs

@@ -0,0 +1,80 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __markAsModule = (target) => __defProp(target, "__esModule", {value: true});
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {get: all[name], enumerable: true});
+};
+var __exportStar = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, {get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable});
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __exportStar(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? {get: () => module2.default, enumerable: true} : {value: module2, enumerable: true})), module2);
+};
+
+// packages/@lwrjs/shared-utils/src/compiler.ts
+__markAsModule(exports);
+__export(exports, {
+  AMD_DEFINE: () => AMD_DEFINE,
+  convertToAmd: () => convertToAmd,
+  lockerize: () => lockerize
+});
+var import_identity = __toModule(require("./identity.cjs"));
+var import_compiler = __toModule(require("@locker/compiler"));
+var import_rollup = __toModule(require("rollup"));
+var AMD_DEFINE = "LWR.define";
+var AMD_ROLLUP_PLUGIN = function(rootId, source) {
+  return {
+    name: "lwr-amd-inline",
+    resolveId(id) {
+      return rootId === id ? id : void 0;
+    },
+    load(id) {
+      return rootId === id ? source : void 0;
+    }
+  };
+};
+async function convertToAmd(source, {id}, forceNamedExports = true) {
+  const bundler = await (0, import_rollup.rollup)({
+    input: id,
+    plugins: [AMD_ROLLUP_PLUGIN(id, source)],
+    onwarn(warning, warn) {
+      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};
+}
+function lockerize({compiledSource: source, specifier, moduleEntry: {entry: filename}}, {trustedComponents}, sourcemap = false) {
+  const {namespace, name: rawName} = (0, import_identity.explodeSpecifier)(specifier);
+  const [name] = rawName.split("#");
+  const bareSpecifier = namespace ? `${namespace}/${name}` : name;
+  const isJS = filename.endsWith(".js") || filename.endsWith(".mjs") || filename.endsWith(".ts");
+  if (isJS && trustedComponents && !trustedComponents.includes(`${namespace}/*`) && !trustedComponents.includes(bareSpecifier)) {
+    const {code} = import_compiler.Compiler.compile(source, {
+      componentName: name,
+      filename,
+      sandboxKey: namespace || "sandbox",
+      sourcemap,
+      remapDynamicImport: true
+    });
+    return {code, map: null};
+  }
+  return {code: source, map: null};
+}

package/build/cjs/env.cjs

@@ -11,15 +11,9 @@ __export(exports, {
   getFeatureFlags: () => getFeatureFlags
 });
 function getFeatureFlags() {
-  let legacyLoader = process.env.LEGACY_LOADER !== void 0 && process.env.LEGACY_LOADER === "true" ? true : false;
-  try {
-    if (LWR) {
-      legacyLoader = LWR.LEGACY_LOADER;
-    }
-  } catch (e) {
-  }
   return {
-    LEGACY_LOADER: legacyLoader,
-    SSR_STATIC_BUNDLES: process.env.SSR_STATIC_BUNDLES !== void 0 && process.env.SSR_STATIC_BUNDLES === "true" ? true : false
+    LEGACY_LOADER: process.env.LEGACY_LOADER !== void 0 && process.env.LEGACY_LOADER.toLowerCase() === "true" ? true : false,
+    SSR_STATIC_BUNDLES: process.env.SSR_STATIC_BUNDLES !== void 0 && process.env.SSR_STATIC_BUNDLES.toLowerCase() === "true" ? true : false,
+    SSR_SANDBOX_WORKER: process.env.SSR_SANDBOX_WORKER !== void 0 && process.env.SSR_SANDBOX_WORKER.toLowerCase() === "true" ? true : false
   };
 }

package/build/cjs/graph.cjs

@@ -121,7 +121,7 @@ async function getModuleGraphs(specifier, options, moduleRegistry, defRegistry,
   if (options.includeUris) {
     for (const visitedSpecifier of acc.keys()) {
       const moduleId = await (0, import_identity.getVersionedModuleId)(visitedSpecifier, moduleRegistry);
-      const uri = await moduleRegistry.resolveModuleUri(moduleId, runtimeEnvironment, runtimeParams);
+      const uri = await defRegistry.resolveModuleUri(moduleId, runtimeEnvironment, runtimeParams);
       uriMap[visitedSpecifier] = uri;
     }
   }

package/build/cjs/identity.cjs

@@ -43,7 +43,6 @@ __export(exports, {
   getPropFromAttrName: () => getPropFromAttrName,
   getSpecifier: () => getSpecifier,
   getVersionedModuleId: () => getVersionedModuleId,
-  getVersionedSpecifier: () => getVersionedSpecifier,
   isBundleDefinition: () => isBundleDefinition,
   isExternalUrl: () => isExternalUrl,
   kebabCaseToModuleSpecifer: () => kebabCaseToModuleSpecifer,
@@ -119,14 +118,6 @@ function getSpecifier({specifier, namespace, name = "", version}) {
   const bareSpecifier = namespace ? `${namespace}/${name}` : name;
   return version ? `${bareSpecifier}${VERSION_SIGIL}${normalizeVersionToUri(version)}` : bareSpecifier;
 }
-async function getVersionedSpecifier(rawSpecifier, moduleRegistry) {
-  const {specifier, namespace, name, version} = explodeSpecifier(rawSpecifier);
-  if (version) {
-    return normalizeVersionToUri(rawSpecifier);
-  }
-  const moduleEntry = await moduleRegistry.getModuleEntry({specifier});
-  return getSpecifier({namespace, name, version: normalizeVersionToUri(moduleEntry.version)});
-}
 async function getVersionedModuleId(rawSpecifier, moduleRegistry) {
   const moduleId = explodeSpecifier(rawSpecifier);
   if (moduleId.version) {

package/build/cjs/index.cjs

@@ -27,7 +27,6 @@ __exportStar(exports, __toModule(require("./link.cjs")));
 __exportStar(exports, __toModule(require("./object.cjs")));
 __exportStar(exports, __toModule(require("./serialize.cjs")));
 __exportStar(exports, __toModule(require("./tasks.cjs")));
-__exportStar(exports, __toModule(require("./typescript.cjs")));
 __exportStar(exports, __toModule(require("./import-metadata.cjs")));
 __exportStar(exports, __toModule(require("./graph.cjs")));
 __exportStar(exports, __toModule(require("./mappings.cjs")));
@@ -35,3 +34,4 @@ __exportStar(exports, __toModule(require("./urls.cjs")));
 __exportStar(exports, __toModule(require("./env.cjs")));
 __exportStar(exports, __toModule(require("./logger.cjs")));
 __exportStar(exports, __toModule(require("./lwr-app-observer.cjs")));
+__exportStar(exports, __toModule(require("./site-metadata.cjs")));

package/build/cjs/logger.cjs

@@ -74,19 +74,21 @@ function log(level, message, additionalInfo) {
     }
   }
   if (shouldLog) {
-    let logMethod;
-    if (level == ERROR) {
-      logMethod = console.error;
-    } else if (level == WARN) {
-      logMethod = console.warn;
+    let logMessage;
+    if (additionalInfo) {
+      logMessage = `[${level}]${gap(message)}${message} 
+Additional Info: ${JSON.stringify(additionalInfo)}`;
     } else {
-      logMethod = console.log;
+      logMessage = `[${level}]${gap(message)}${message}`;
     }
-    if (additionalInfo) {
-      logMethod(`[${level}] ${message} 
-Additional Info: ${JSON.stringify(additionalInfo)}`);
+    if (level == ERROR) {
+      console.error("%s", logMessage);
+    } else if (level == WARN) {
+      console.warn("%s", logMessage);
+    } else if (level == DEBUG || level == VERBOSE) {
+      console.log("%s", logMessage);
     } else {
-      logMethod(`[${level}] ${message}`);
+      console.log(logMessage);
     }
   }
 }
@@ -110,12 +112,24 @@ var stringifyError = (error) => {
     return JSON.stringify(retObj);
   }
 };
+function gap(message) {
+  return String(message)?.indexOf("[") === 0 ? "" : " ";
+}
+function logError(err, additionalInfo) {
+  if (err instanceof import_diagnostics.DiagnosticsError || !err || !err.message) {
+    log(ERROR, stringifyError(err), additionalInfo);
+  }
+  if (err && err.message) {
+    err.message = `[${ERROR}]${gap(err.message)}${err.message}`;
+    console.error("%s", err);
+  }
+}
 var 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/cjs/mappings.cjs

@@ -57,7 +57,7 @@ async function getImportMetadataMappings(moduleIds, runtimeEnvironment, runtimeP
   }
   return importMetadata;
 }
-async function toImportMetadata(moduleGraph, existingImportMetadata = {imports: {}, index: {}}, moduleRegistry, runtimeEnvironment, runtimeParams = {}) {
+async function toImportMetadata(moduleGraph, existingImportMetadata = {imports: {}, index: {}}, defRegistry, runtimeEnvironment, runtimeParams = {}) {
   const specifier = moduleGraph.graphs[0].specifier;
   const uri = moduleGraph.uriMap[specifier];
   const definition = moduleGraph.linkedDefinitions[specifier];
@@ -67,7 +67,7 @@ async function toImportMetadata(moduleGraph, existingImportMetadata = {imports:
   if (!definition) {
     throw new Error("Linked module definition was not included in the graph: " + specifier);
   }
-  const rootMetadata = await normalizeImportMetadata(specifier, uri, definition, moduleRegistry, runtimeEnvironment, runtimeParams);
+  const rootMetadata = await normalizeImportMetadata(specifier, uri, definition, defRegistry, 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) {
@@ -85,7 +85,7 @@ 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);
+      const depMetadata = await normalizeImportMetadata((0, import_identity.getSpecifier)(depDef), depUri, depDef, defRegistry, runtimeEnvironment, runtimeParams);
       importMetadata = mergeImportMetadata(importMetadata, depMetadata);
     }
   }
@@ -103,11 +103,11 @@ function mergeImportMetadata(existing, newMetadata) {
     }
   };
 }
-async function normalizeImportMetadata(specifier, uri, definition, moduleRegistry, moduleRuntimeEnvironment, runtimeParams) {
+async function normalizeImportMetadata(specifier, uri, definition, defRegistry, moduleRuntimeEnvironment, runtimeParams) {
   const specifiers = normalizedIncludedModules(definition);
   const imports = {};
   imports[uri] = specifiers;
-  const index = await createIndex(specifiers, moduleRegistry, moduleRuntimeEnvironment, runtimeParams);
+  const index = await createIndex(specifiers, defRegistry, moduleRuntimeEnvironment, runtimeParams);
   if (!(specifier in index)) {
     index[specifier] = uri;
   }
@@ -119,7 +119,7 @@ async function normalizeImportMetadata(specifier, uri, definition, moduleRegistr
 function normalizedIncludedModules(definition) {
   return (0, import_identity.isBundleDefinition)(definition) ? [(0, import_identity.getSpecifier)(definition), ...definition.bundleRecord.includedModules] : [(0, import_identity.getSpecifier)(definition)];
 }
-async function createIndex(specifiers, moduleRegistry, runtimeEnvironment, runtimeParams) {
+async function createIndex(specifiers, defRegistry, runtimeEnvironment, runtimeParams) {
   const index = {};
   const moduleRuntimeEnvironment = {...runtimeEnvironment, bundle: false};
   async function getUri(specifier) {
@@ -127,7 +127,7 @@ async function createIndex(specifiers, moduleRegistry, runtimeEnvironment, runti
     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 defRegistry.resolveModuleUri({...moduleId, version: moduleId.version}, moduleRuntimeEnvironment, runtimeParams);
   }
   const promises = [];
   for (const specifier of specifiers) {

package/build/cjs/site-metadata.cjs

@@ -0,0 +1,137 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __markAsModule = (target) => __defProp(target, "__esModule", {value: true});
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {get: all[name], enumerable: true});
+};
+var __exportStar = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, {get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable});
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __exportStar(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? {get: () => module2.default, enumerable: true} : {value: module2, enumerable: true})), module2);
+};
+
+// packages/@lwrjs/shared-utils/src/site-metadata.ts
+__markAsModule(exports);
+__export(exports, {
+  SiteMetadataImpl: () => SiteMetadataImpl
+});
+var import_path = __toModule(require("path"));
+var import_fs_extra = __toModule(require("fs-extra"));
+var import_logger = __toModule(require("./logger.cjs"));
+var SITE_METADATA_PATH = "site-metadata";
+var STATIC_BUNDLE_METADATA_PATH = import_path.default.join(SITE_METADATA_PATH, "/bundle-metadata.json");
+var STATIC_RESOURCE_METADATA_PATH = import_path.default.join(SITE_METADATA_PATH, "/resource-metadata.json");
+var STATIC_ASSET_METADATA_PATH = import_path.default.join(SITE_METADATA_PATH, "/asset-metadata.json");
+var SiteMetadataImpl = class {
+  constructor(options) {
+    this.options = options;
+    this.siteBundles = this.readStaticBundleMetadata(options.rootDir);
+    this.siteResources = this.readStaticResourceMetadata(options.rootDir);
+    this.siteAssets = this.readStaticAssetsMetadata(options.rootDir);
+  }
+  getSiteBundles() {
+    return this.siteBundles;
+  }
+  getSiteResources() {
+    return this.siteResources;
+  }
+  getSiteAssets() {
+    return this.siteAssets;
+  }
+  async persistSiteMetadata() {
+    const siteMetadataPath = import_path.default.join(this.options.rootDir, SITE_METADATA_PATH);
+    if (!await import_fs_extra.default.pathExists(siteMetadataPath)) {
+      await import_fs_extra.default.mkdir(siteMetadataPath, {recursive: true});
+    }
+    const bundleMetadataPath = import_path.default.join(this.options.rootDir, STATIC_BUNDLE_METADATA_PATH);
+    await import_fs_extra.default.writeJSON(bundleMetadataPath, this.siteBundles, {spaces: 2});
+    const resourceMetadataPath = import_path.default.join(this.options.rootDir, STATIC_RESOURCE_METADATA_PATH);
+    await import_fs_extra.default.writeJSON(resourceMetadataPath, this.siteResources, {spaces: 2});
+    const assetMetadataPath = import_path.default.join(this.options.rootDir, STATIC_ASSET_METADATA_PATH);
+    return import_fs_extra.default.writeJSON(assetMetadataPath, this.siteAssets, {spaces: 2});
+  }
+  readStaticBundleMetadata(staticRoot) {
+    let bundleMetadataPath;
+    let siteBundles = {
+      bundles: {},
+      environment: {
+        format: this.options.runtimeEnvironment.format,
+        ...this.options.runtimeEnvironment.featureFlags?.LEGACY_LOADER && {
+          featureFlags: {LEGACY_LOADER: true}
+        }
+      }
+    };
+    try {
+      bundleMetadataPath = import_path.default.join(staticRoot, STATIC_BUNDLE_METADATA_PATH);
+      const savedMetadata = import_fs_extra.default.readJSONSync(bundleMetadataPath);
+      if (this.options.runtimeEnvironment.format !== savedMetadata.environment?.format || this.options.runtimeEnvironment.featureFlags?.LEGACY_LOADER != savedMetadata.environment?.featureFlags?.LEGACY_LOADER) {
+        import_logger.logger.warn("[SiteMetadata] Saved bundles do not match the current runtime.  They will not be used.", {expected: savedMetadata.environment, actual: this.options.runtimeEnvironment});
+      } else {
+        siteBundles = savedMetadata;
+      }
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        import_logger.logger.debug(`[SiteMetadata] Failed to load Static Bundle Metadata: ${bundleMetadataPath}`);
+      } else {
+        throw error;
+      }
+    }
+    return siteBundles;
+  }
+  readStaticResourceMetadata(staticRoot) {
+    let resourceMetadataPath;
+    let siteResources = {
+      resources: {},
+      environment: {
+        format: this.options.runtimeEnvironment.format,
+        ...this.options.runtimeEnvironment.featureFlags?.LEGACY_LOADER && {
+          featureFlags: {LEGACY_LOADER: true}
+        }
+      }
+    };
+    try {
+      resourceMetadataPath = import_path.default.join(staticRoot, STATIC_RESOURCE_METADATA_PATH);
+      const savedMetadata = import_fs_extra.default.readJSONSync(resourceMetadataPath);
+      if (this.options.runtimeEnvironment.format !== savedMetadata.environment?.format || this.options.runtimeEnvironment.featureFlags?.LEGACY_LOADER != savedMetadata.environment?.featureFlags?.LEGACY_LOADER) {
+        import_logger.logger.warn("[SiteMetadata] Saved resources do not match the current runtime.  They will not be used.", {expected: savedMetadata.environment, actual: this.options.runtimeEnvironment});
+      } else {
+        siteResources = savedMetadata;
+      }
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        import_logger.logger.debug(`[SiteMetadata] Failed to load Static Resource Metadata: ${resourceMetadataPath}`);
+      } else {
+        throw error;
+      }
+    }
+    return siteResources;
+  }
+  readStaticAssetsMetadata(staticRoot) {
+    let assetMetadataPath;
+    let siteAssets = {
+      assets: {}
+    };
+    try {
+      assetMetadataPath = import_path.default.join(staticRoot, STATIC_ASSET_METADATA_PATH);
+      siteAssets = import_fs_extra.default.readJSONSync(assetMetadataPath);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        import_logger.logger.debug(`[SiteMetadata] Failed to load Static Resource Metadata: ${assetMetadataPath}`);
+      } else {
+        throw error;
+      }
+    }
+    return siteAssets;
+  }
+};

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,19 +1,18 @@
 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 === 'true'
+        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,
     };

package/build/es/graph.js

@@ -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

@@ -57,29 +57,6 @@ 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;
 }

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`

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/logger.js

@@ -43,21 +43,24 @@ function log(level, message, additionalInfo) {
         }
     }
     if (shouldLog) {
-        let logMethod;
+        let logMessage;
+        if (additionalInfo) {
+            logMessage = `[${level}]${gap(message)}${message} \nAdditional Info: ${JSON.stringify(additionalInfo)}`;
+        }
+        else {
+            logMessage = `[${level}]${gap(message)}${message}`;
+        }
         if (level == ERROR) {
-            logMethod = console.error;
+            console.error('\x1b[31m%s\x1b[0m', logMessage); // red
         }
         else if (level == WARN) {
-            logMethod = console.warn;
+            console.warn('\x1b[33m%s\x1b[0m', logMessage); // 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
         }
         else {
-            logMethod(`[${level}] ${message}`);
+            console.log(logMessage);
         }
     }
 }
@@ -83,12 +86,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.d.ts

@@ -15,5 +15,5 @@ export declare function getImportMetadataMappings(moduleIds: AbstractModuleId[],
  * @param existingImportMetadata Optional existing ImportMetadata.  If provided the results will be a merge the two sets of URI mappings.
  * @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 toImportMetadata(moduleGraph: FlattenedModuleGraphs, existingImportMetadata: ImportMetadata | undefined, defRegistry: ModuleRegistry | ModuleBundler, runtimeEnvironment: RuntimeEnvironment, runtimeParams?: RuntimeParams): Promise<ImportMetadata>;
 //# sourceMappingURL=mappings.d.ts.map

package/build/es/mappings.js

@@ -53,7 +53,7 @@ export async function getImportMetadataMappings(moduleIds, runtimeEnvironment, r
  * @param existingImportMetadata Optional existing ImportMetadata.  If provided the results will be a merge the two sets of URI mappings.
  * @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 async function toImportMetadata(moduleGraph, existingImportMetadata = { imports: {}, index: {} }, moduleRegistry, runtimeEnvironment, runtimeParams = {}) {
+export async function toImportMetadata(moduleGraph, existingImportMetadata = { imports: {}, index: {} }, defRegistry, runtimeEnvironment, runtimeParams = {}) {
     // root module specifier
     const specifier = moduleGraph.graphs[0].specifier;
     const uri = moduleGraph.uriMap[specifier];
@@ -65,7 +65,7 @@ export async function toImportMetadata(moduleGraph, existingImportMetadata = { i
         throw new Error('Linked module definition was not included in the graph: ' + specifier);
     }
     // Merge in the existing metadata with imports for the root specifier
-    const rootMetadata = await normalizeImportMetadata(specifier, uri, definition, moduleRegistry, runtimeEnvironment, runtimeParams);
+    const rootMetadata = await normalizeImportMetadata(specifier, uri, definition, defRegistry, runtimeEnvironment, runtimeParams);
     let importMetadata = mergeImportMetadata(existingImportMetadata, rootMetadata);
     // root module dependencies:
     //  - static for AMD; dynamic dependencies require a new mapping request
@@ -91,7 +91,7 @@ export async function toImportMetadata(moduleGraph, existingImportMetadata = { i
         }
         if (!importMetadata.imports[depUri]) {
             // eslint-disable-next-line no-await-in-loop
-            const depMetadata = await normalizeImportMetadata(getSpecifier(depDef), depUri, depDef, moduleRegistry, runtimeEnvironment, runtimeParams);
+            const depMetadata = await normalizeImportMetadata(getSpecifier(depDef), depUri, depDef, defRegistry, runtimeEnvironment, runtimeParams);
             importMetadata = mergeImportMetadata(importMetadata, depMetadata);
         }
     }
@@ -110,12 +110,12 @@ function mergeImportMetadata(existing, newMetadata) {
         },
     };
 }
-async function normalizeImportMetadata(specifier, uri, definition, moduleRegistry, moduleRuntimeEnvironment, runtimeParams) {
+async function normalizeImportMetadata(specifier, uri, definition, defRegistry, moduleRuntimeEnvironment, runtimeParams) {
     const specifiers = normalizedIncludedModules(definition);
     const imports = {};
     imports[uri] = specifiers;
     // The index info for the modules included in a bundle
-    const index = await createIndex(specifiers, moduleRegistry, moduleRuntimeEnvironment, runtimeParams);
+    const index = await createIndex(specifiers, defRegistry, moduleRuntimeEnvironment, runtimeParams);
     // If root specifier was not included in createIndex add an entry where the uri is the index
     if (!(specifier in index)) {
         index[specifier] = uri;
@@ -132,7 +132,7 @@ function normalizedIncludedModules(definition) {
         ? [getSpecifier(definition), ...definition.bundleRecord.includedModules]
         : [getSpecifier(definition)];
 }
-async function createIndex(specifiers, moduleRegistry, runtimeEnvironment, runtimeParams) {
+async function createIndex(specifiers, defRegistry, runtimeEnvironment, runtimeParams) {
     const index = {};
     // We need a runtime environment for modules when building the index for a bundle
     const moduleRuntimeEnvironment = { ...runtimeEnvironment, bundle: false };
@@ -141,7 +141,7 @@ async function createIndex(specifiers, moduleRegistry, runtimeEnvironment, runti
         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 defRegistry.resolveModuleUri({ ...moduleId, version: moduleId.version }, moduleRuntimeEnvironment, runtimeParams);
     }
     // Queue up uri requests
     const promises = [];

package/build/es/site-metadata.d.ts

@@ -0,0 +1,27 @@
+import type { RuntimeEnvironment, SiteAssets, SiteBundles, SiteMetadata, SiteResources } from '@lwrjs/types';
+declare type Options = {
+    rootDir: string;
+    runtimeEnvironment: RuntimeEnvironment;
+};
+export declare class SiteMetadataImpl implements SiteMetadata {
+    private options;
+    private siteBundles;
+    private siteResources;
+    private siteAssets;
+    constructor(options: Options);
+    getSiteBundles(): SiteBundles;
+    getSiteResources(): SiteResources;
+    getSiteAssets(): SiteAssets;
+    persistSiteMetadata(): Promise<void>;
+    private readStaticBundleMetadata;
+    /**
+     * Read the metadata about the pre-built resources of the current site.
+     */
+    private readStaticResourceMetadata;
+    /**
+     * Read the metadata about the pre-built assets of the current site.
+     */
+    private readStaticAssetsMetadata;
+}
+export {};
+//# sourceMappingURL=site-metadata.d.ts.map

package/build/es/site-metadata.js

@@ -0,0 +1,136 @@
+import path from 'path';
+import fs from 'fs-extra';
+import { logger } from './logger.js';
+const SITE_METADATA_PATH = 'site-metadata';
+const STATIC_BUNDLE_METADATA_PATH = path.join(SITE_METADATA_PATH, '/bundle-metadata.json');
+const STATIC_RESOURCE_METADATA_PATH = path.join(SITE_METADATA_PATH, '/resource-metadata.json');
+const STATIC_ASSET_METADATA_PATH = path.join(SITE_METADATA_PATH, '/asset-metadata.json');
+export class SiteMetadataImpl {
+    constructor(options) {
+        this.options = options;
+        this.siteBundles = this.readStaticBundleMetadata(options.rootDir);
+        this.siteResources = this.readStaticResourceMetadata(options.rootDir);
+        this.siteAssets = this.readStaticAssetsMetadata(options.rootDir);
+    }
+    getSiteBundles() {
+        return this.siteBundles;
+    }
+    getSiteResources() {
+        return this.siteResources;
+    }
+    getSiteAssets() {
+        return this.siteAssets;
+    }
+    async persistSiteMetadata() {
+        // Create the metadata directory if if does not exist
+        const siteMetadataPath = path.join(this.options.rootDir, SITE_METADATA_PATH);
+        if (!(await fs.pathExists(siteMetadataPath))) {
+            await fs.mkdir(siteMetadataPath, { recursive: true });
+        }
+        // Save Bundle Metadata
+        const bundleMetadataPath = path.join(this.options.rootDir, STATIC_BUNDLE_METADATA_PATH);
+        await fs.writeJSON(bundleMetadataPath, this.siteBundles, { spaces: 2 });
+        // Save Resource Metadata
+        const resourceMetadataPath = path.join(this.options.rootDir, STATIC_RESOURCE_METADATA_PATH);
+        await fs.writeJSON(resourceMetadataPath, this.siteResources, { spaces: 2 });
+        // Save Resource Metadata
+        const assetMetadataPath = path.join(this.options.rootDir, STATIC_ASSET_METADATA_PATH);
+        return fs.writeJSON(assetMetadataPath, this.siteAssets, { spaces: 2 });
+    }
+    readStaticBundleMetadata(staticRoot) {
+        let bundleMetadataPath;
+        // Default metadata based on the current runtime environment
+        let siteBundles = {
+            bundles: {},
+            environment: {
+                format: this.options.runtimeEnvironment.format,
+                ...(this.options.runtimeEnvironment.featureFlags?.LEGACY_LOADER && {
+                    featureFlags: { LEGACY_LOADER: true },
+                }),
+            },
+        };
+        try {
+            bundleMetadataPath = path.join(staticRoot, STATIC_BUNDLE_METADATA_PATH);
+            const savedMetadata = fs.readJSONSync(bundleMetadataPath);
+            // Make sure the saved metadata runtime environment match the current runtime environment
+            if (this.options.runtimeEnvironment.format !== savedMetadata.environment?.format ||
+                this.options.runtimeEnvironment.featureFlags?.LEGACY_LOADER !=
+                    savedMetadata.environment?.featureFlags?.LEGACY_LOADER) {
+                logger.warn('[SiteMetadata] Saved bundles do not match the current runtime.  They will not be used.', { expected: savedMetadata.environment, actual: this.options.runtimeEnvironment });
+            }
+            else {
+                siteBundles = savedMetadata;
+            }
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                logger.debug(`[SiteMetadata] Failed to load Static Bundle Metadata: ${bundleMetadataPath}`);
+            }
+            else {
+                throw error;
+            }
+        }
+        return siteBundles;
+    }
+    /**
+     * Read the metadata about the pre-built resources of the current site.
+     */
+    readStaticResourceMetadata(staticRoot) {
+        let resourceMetadataPath;
+        // Default metadata based on the current runtime environment
+        let siteResources = {
+            resources: {},
+            environment: {
+                format: this.options.runtimeEnvironment.format,
+                ...(this.options.runtimeEnvironment.featureFlags?.LEGACY_LOADER && {
+                    featureFlags: { LEGACY_LOADER: true },
+                }),
+            },
+        };
+        try {
+            resourceMetadataPath = path.join(staticRoot, STATIC_RESOURCE_METADATA_PATH);
+            const savedMetadata = fs.readJSONSync(resourceMetadataPath);
+            // Make sure the savedMetaadta runtime environment match the current runtime environment
+            if (this.options.runtimeEnvironment.format !== savedMetadata.environment?.format ||
+                this.options.runtimeEnvironment.featureFlags?.LEGACY_LOADER !=
+                    savedMetadata.environment?.featureFlags?.LEGACY_LOADER) {
+                logger.warn('[SiteMetadata] Saved resources do not match the current runtime.  They will not be used.', { expected: savedMetadata.environment, actual: this.options.runtimeEnvironment });
+            }
+            else {
+                siteResources = savedMetadata;
+            }
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                logger.debug(`[SiteMetadata] Failed to load Static Resource Metadata: ${resourceMetadataPath}`);
+            }
+            else {
+                throw error;
+            }
+        }
+        return siteResources;
+    }
+    /**
+     * Read the metadata about the pre-built assets of the current site.
+     */
+    readStaticAssetsMetadata(staticRoot) {
+        let assetMetadataPath;
+        let siteAssets = {
+            assets: {},
+        };
+        try {
+            assetMetadataPath = path.join(staticRoot, STATIC_ASSET_METADATA_PATH);
+            siteAssets = fs.readJSONSync(assetMetadataPath);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                logger.debug(`[SiteMetadata] Failed to load Static Resource Metadata: ${assetMetadataPath}`);
+            }
+            else {
+                throw error;
+            }
+        }
+        return siteAssets;
+    }
+}
+//# sourceMappingURL=site-metadata.js.map

package/build/es/typescript.js

@@ -1,8 +1,9 @@
 import fs from 'fs';
 import { join, dirname, extname } from 'path';
 import esbuildEsm from 'esbuild';
-// Workaround until this is fixed:
 // https://github.com/evanw/esbuild/issues/706
+// Fixed in 0.11.0 but upgrading past 0.9.7 has caused breaking changes for consumers...
+// https://github.com/salesforce-experience-platform/lwr/issues/1014
 let esbuild = esbuildEsm;
 if (!esbuildEsm) {
     try {

package/package.json

@@ -4,7 +4,7 @@
     "publishConfig": {
         "access": "public"
     },
-    "version": "0.9.0-alpha.13",
+    "version": "0.9.0-alpha.14",
     "homepage": "https://developer.salesforce.com/docs/platform/lwr/overview",
     "repository": {
         "type": "git",
@@ -29,6 +29,14 @@
         "./fs-watch": {
             "import": "./build/es/fs-watch.js",
             "require": "./build/cjs/fs-watch.cjs"
+        },
+        "./typescript": {
+            "import": "./build/es/typescript.js",
+            "require": "./build/cjs/typescript.cjs"
+        },
+        "./compiler": {
+            "import": "./build/es/compiler.js",
+            "require": "./build/cjs/compiler.cjs"
         }
     },
     "files": [
@@ -38,7 +46,6 @@
     ],
     "dependencies": {
         "es-module-lexer": "^0.3.18",
-        "esbuild": "^0.9.7",
         "fast-json-stable-stringify": "^2.1.0",
         "magic-string": "^0.25.7",
         "mime-types": "^2.1.33",
@@ -48,16 +55,19 @@
         "slugify": "^1.4.5"
     },
     "optionalDependencies": {
-        "chokidar": "^3.5.3"
+        "@locker/compiler": "0.18.2",
+        "chokidar": "^3.5.3",
+        "esbuild": "^0.9.7",
+        "rollup": "~2.45.2"
     },
     "devDependencies": {
-        "@lwrjs/diagnostics": "0.9.0-alpha.13",
-        "@lwrjs/types": "0.9.0-alpha.13",
+        "@lwrjs/diagnostics": "0.9.0-alpha.14",
+        "@lwrjs/types": "0.9.0-alpha.14",
         "@types/mime-types": "2.1.1",
         "@types/path-to-regexp": "^1.7.0"
     },
     "engines": {
         "node": ">=14.15.4 <19"
     },
-    "gitHead": "fa30915a685f6e8c5c2895d0c053d59145780123"
+    "gitHead": "64e0ba617151429da6e09f1a9686628f64183d25"
 }