@ohos-ports/lwrjs-static 0.24.0-beta.1

package/LICENSE

@@ -0,0 +1,10 @@
+MIT LICENSE
+
+Copyright (c) 2020, Salesforce.com, Inc.
+All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/build/cjs/index.cjs

@@ -0,0 +1,22 @@
+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 __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/static/src/index.ts
+__markAsModule(exports);
+__exportStar(exports, __toModule(require("./tools/dedupe-bundles.cjs")));

package/build/cjs/providers/static-asset-provider.cjs

@@ -0,0 +1,103 @@
+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/static/src/providers/static-asset-provider.ts
+__markAsModule(exports);
+__export(exports, {
+  default: () => static_asset_provider_default
+});
+var import_diagnostics = __toModule(require("@lwrjs/diagnostics"));
+var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
+var import_path = __toModule(require("path"));
+var import_fs_extra = __toModule(require("fs-extra"));
+var StaticAssetProvider = class {
+  constructor(_config, context) {
+    this.name = "static-asset-provider";
+    if (!context.siteMetadata) {
+      throw new Error(`[${this.name}] Site metadata was not found`);
+    }
+    const {assets, rootDir, layoutsDir, contentDir} = context.config;
+    this.siteAssets = context.siteMetadata.getSiteAssets();
+    this.siteRootDir = context.siteMetadata.getSiteRootDir();
+    this.basePath = context.runtimeEnvironment.basePath;
+    this.assetsOnLambda = !!context.runtimeEnvironment.featureFlags?.ASSETS_ON_LAMBDA;
+    const ssgAssets = Array.from(assets, (asset) => {
+      if (asset.dir) {
+        return {
+          ...asset,
+          dir: asset.urlPath
+        };
+      }
+      return asset;
+    });
+    this.resourcePaths = {assets: ssgAssets, rootDir, layoutsDir, contentDir};
+  }
+  async getAsset(assetIdentifier) {
+    const fileAssetPath = this.normalizeSpecifier(assetIdentifier, this.resourcePaths);
+    const metadata = this.siteAssets.assets[fileAssetPath];
+    if (!metadata) {
+      if (import_path.default.dirname(fileAssetPath) !== (this.basePath ? this.basePath : "/")) {
+        import_diagnostics.logger.warn({
+          label: `${this.name}`,
+          message: `Did not find requested specifier ${fileAssetPath}`
+        });
+      }
+      return void 0;
+    }
+    const siteAssetPath = (0, import_shared_utils.joinUrlPath)(this.siteRootDir, metadata.path);
+    const mime = metadata.mimeType || (0, import_shared_utils.mimeLookup)(siteAssetPath);
+    const ext = import_path.default.extname(`x.${siteAssetPath}`).toLowerCase().substring(1);
+    const type = this.assetsOnLambda ? "asset" : "external";
+    const content = function(encoding) {
+      return import_fs_extra.default.readFileSync(siteAssetPath, encoding);
+    };
+    const uri = this.assetsOnLambda ? fileAssetPath : (0, import_shared_utils.joinUrlPath)(this.siteRootDir, fileAssetPath);
+    import_diagnostics.logger.debug({label: `${this.name}`, message: `uri ${assetIdentifier.specifier} -> ${uri}`});
+    return {
+      entry: siteAssetPath,
+      ext,
+      mime,
+      ownHash: (0, import_shared_utils.hashContent)(metadata.path),
+      content,
+      uri,
+      type,
+      noTransform: true
+    };
+  }
+  normalizeSpecifier(assetId, resourcePaths) {
+    const {specifier} = assetId;
+    let normalizedSpecifier = specifier;
+    if (normalizedSpecifier.includes("?")) {
+      import_diagnostics.logger.debug({
+        label: `${this.name}`,
+        message: `Removed query param from asset specifier: ${specifier}`
+      });
+      normalizedSpecifier = normalizedSpecifier.split("?")[0];
+    }
+    if (normalizedSpecifier[0] === "$") {
+      return (0, import_shared_utils.normalizeResourcePath)(normalizedSpecifier, resourcePaths);
+    }
+    return normalizedSpecifier;
+  }
+};
+var static_asset_provider_default = StaticAssetProvider;

package/build/cjs/providers/static-bundle-provider.cjs

@@ -0,0 +1,246 @@
+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/static/src/providers/static-bundle-provider.ts
+__markAsModule(exports);
+__export(exports, {
+  default: () => static_bundle_provider_default
+});
+var import_diagnostics = __toModule(require("@lwrjs/diagnostics"));
+var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
+var import_path = __toModule(require("path"));
+var import_fs_extra = __toModule(require("fs-extra"));
+var import_lru_cache = __toModule(require("lru-cache"));
+var import_site_metadata = __toModule(require("../site-metadata.cjs"));
+var import_instrumentation = __toModule(require("@lwrjs/instrumentation"));
+var import_instrumentation2 = __toModule(require("@lwrjs/instrumentation"));
+var BUNDLE_SOURCE_NOT_FOUND = "Bundle Source Path Not Found";
+var StaticBundleProvider = class {
+  constructor(config, context) {
+    this.name = "static-bundle-provider";
+    if (!context.siteMetadata) {
+      throw new Error(`[${this.name}] Site metadata was not found`);
+    }
+    this.siteMetadata = context.siteMetadata;
+    this.siteRootDir = context.siteMetadata.getSiteRootDir();
+    this.bundleConfig = context.config.bundleConfig;
+    this.i18n = context.config.i18n;
+    this.bundleCacheSize = config.bundleCacheSize ?? parseInt(process.env.BUNDLE_CODE_CACHE_SIZE ?? "500", 10);
+    if (this.bundleCacheSize > 0) {
+      this.codeCache = new import_lru_cache.LRUCache({
+        max: this.bundleCacheSize,
+        dispose: (_value, key) => {
+          if ((0, import_shared_utils.isLambdaEnv)()) {
+            import_diagnostics.logger.warn(`Bundle Code evicted from cache ${key}`);
+          } else {
+            import_diagnostics.logger.verbose(`Bundle Code evicted from cache ${key}`);
+          }
+        }
+      });
+    }
+  }
+  async bundle(moduleId, runtimeEnvironment, runtimeParams) {
+    const {specifier, version} = moduleId;
+    const {
+      debug,
+      i18n: {defaultLocale}
+    } = runtimeEnvironment;
+    const localeId = runtimeParams?.locale || defaultLocale;
+    const ssr = runtimeParams?.ssr;
+    let metadata = this.getBundleMetadata({moduleId, localeId, debug, ssr});
+    if (!metadata && debug) {
+      metadata = this.getBundleMetadata({moduleId, localeId, debug: false, ssr});
+    }
+    if (!metadata && (0, import_shared_utils.isExternalSpecifier)(moduleId.specifier, this.bundleConfig)) {
+      const {specifier: unversionedSepcifier} = (0, import_shared_utils.explodeSpecifier)(moduleId.specifier);
+      metadata = {
+        path: this.bundleConfig?.external?.[unversionedSepcifier],
+        imports: [],
+        dynamicImports: [],
+        version: moduleId.version
+      };
+      return this.createBundleDefinition(moduleId, metadata, localeId, debug, ssr, async () => "", (0, import_shared_utils.normalizeFromFileURL)(metadata.path, this.siteRootDir) ?? metadata.path);
+    }
+    if (!metadata) {
+      this.logBundleError(moduleId, localeId, debug, ssr);
+      return void 0;
+    }
+    const bundlePath = (0, import_shared_utils.joinUrlPath)(this.siteRootDir, metadata.path);
+    const resolvedBundlePath = this.getCodePath(bundlePath, debug, specifier, version, localeId, ssr);
+    const codePromiser = this.getCodePromiser(resolvedBundlePath, {
+      specifier,
+      version,
+      locale: localeId,
+      ssr,
+      debug
+    });
+    return this.createBundleDefinition(moduleId, metadata, localeId, debug, ssr, codePromiser, bundlePath);
+  }
+  async createBundleDefinition(moduleId, metadata, localeId, debug, ssr, codePromiser, bundlePath) {
+    const {specifier, name, namespace, version} = moduleId;
+    const imports = metadata.imports.map((importSpecifier) => this.getModuleReference(importSpecifier, localeId, debug, false));
+    const dynamicImports = metadata.dynamicImports?.map((importSpecifier) => this.getModuleReference(importSpecifier, localeId, debug, false));
+    const id = (0, import_shared_utils.getSpecifier)(moduleId);
+    const exploded = (0, import_shared_utils.explodeSpecifier)(id);
+    const resolvedName = name ?? exploded.name;
+    const resolvedNamespace = namespace ?? exploded.namespace;
+    const resolvedVersion = (0, import_site_metadata.resolveStaticBundleVersion)(metadata.version, version);
+    const includedModules = metadata.includedModules?.map((includedId) => {
+      const includedModule = this.getModuleReference(includedId, localeId, debug, ssr);
+      return (0, import_shared_utils.getSpecifier)(includedModule);
+    }) || [];
+    return {
+      getCode: codePromiser,
+      id: (0, import_shared_utils.getSpecifier)({
+        specifier,
+        version: resolvedVersion,
+        name: resolvedName,
+        namespace: resolvedNamespace
+      }),
+      name: resolvedName,
+      namespace: resolvedNamespace,
+      version: resolvedVersion,
+      specifier,
+      config: this.bundleConfig,
+      integrity: metadata.integrity,
+      bundleRecord: {
+        includedModules,
+        imports,
+        dynamicImports
+      },
+      src: bundlePath
+    };
+  }
+  getBundleMetadata({
+    moduleId,
+    localeId,
+    debug,
+    ssr
+  }) {
+    const siteBundleId = (0, import_site_metadata.getSiteBundleId)(moduleId, localeId, ssr, this.i18n);
+    return this.siteMetadata.getSiteBundlesDecisionTree().find(siteBundleId, debug);
+  }
+  getModuleReference(siteBundleIdStr, localeId, debug, ssr) {
+    const siteBundleId = (0, import_site_metadata.parseSiteId)(siteBundleIdStr);
+    const includedModule = (0, import_shared_utils.explodeSpecifier)(siteBundleId.specifier);
+    if (!siteBundleId.variants[import_shared_utils.VERSION_SIGIL]) {
+      const importBundleMetadata = this.siteMetadata.getSiteBundlesDecisionTree().find(siteBundleIdStr, debug, ssr, localeId);
+      includedModule.version = (0, import_site_metadata.resolveStaticBundleVersion)(importBundleMetadata?.version);
+    } else {
+      includedModule.version = siteBundleId.variants[import_shared_utils.VERSION_SIGIL];
+    }
+    return includedModule;
+  }
+  getCodePromiser(bundleSourcePath, {
+    specifier,
+    version,
+    locale,
+    ssr,
+    debug
+  }) {
+    const cache = this.codeCache;
+    return async () => {
+      let code = cache?.get(bundleSourcePath);
+      if (!code) {
+        try {
+          if (bundleSourcePath === BUNDLE_SOURCE_NOT_FOUND) {
+            throw new Error(BUNDLE_SOURCE_NOT_FOUND);
+          }
+          import_instrumentation.cacheCountStore.incrementCacheKey("missedReads");
+          await (0, import_instrumentation2.getTracer)().trace({
+            name: import_instrumentation2.BundleSpan.ReadBundle,
+            attributes: {
+              specifier,
+              version: version ?? "",
+              locale,
+              ssr: ssr ? "TRUE" : "FALSE",
+              debug: debug ? "TRUE" : "FALSE",
+              bundleSourcePath
+            }
+          }, async () => {
+            code = await import_fs_extra.default.readFile(import_path.default.join(bundleSourcePath), "utf-8");
+            if (cache) {
+              cache.set(bundleSourcePath, code);
+            }
+          });
+        } catch (err) {
+          import_diagnostics.logger.warn({
+            label: "static-bundle-provider",
+            message: `Unexpected code reference: ${specifier} ${bundleSourcePath}`
+          }, err);
+          code = `throw new Error('Unexpected code reference: ${specifier} ${bundleSourcePath}');`;
+          if (cache) {
+            cache.set(bundleSourcePath, code);
+          }
+        }
+      }
+      return code;
+    };
+  }
+  logBundleError(moduleId, localeId, debug, ssr) {
+    const moduleSpecifier = moduleId.namespace ? `${moduleId.namespace}/${moduleId.name}` : moduleId.name;
+    const siteBundleId = (0, import_site_metadata.getSiteBundleId)(moduleId, localeId, ssr, this.i18n);
+    const siteBundles = this.siteMetadata.getSiteBundles()?.bundles || {};
+    const siteDebugBundles = this.siteMetadata.getDebugSiteBundles()?.bundles || {};
+    const runtimeBundles = Object.keys(siteBundles).filter((key) => key.startsWith(moduleSpecifier));
+    const debugBundles = Object.keys(siteDebugBundles).filter((key) => key.startsWith(moduleSpecifier));
+    import_diagnostics.logger.error({
+      message: JSON.stringify({
+        message: "Failed to find static bundle",
+        moduleId,
+        localeId,
+        debug,
+        ssr,
+        moduleSpecifier,
+        siteBundleId,
+        debugBundles,
+        runtimeBundles,
+        totalBundlesCount: Object.keys(siteBundles).length,
+        totalDebugBundlesCount: Object.keys(siteDebugBundles).length
+      }),
+      label: "static-bundle-provider"
+    });
+  }
+  getCodePath(bundlePath, debug, specifier, version, localeId, ssr) {
+    const isLambda = (0, import_shared_utils.isLambdaEnv)() || process.env.FORCE_DEBUG_FALLBACK === "true";
+    let bundleSourcePath = bundlePath;
+    if (debug && isLambda) {
+      const metadata = this.getBundleMetadata({
+        moduleId: {specifier, version},
+        localeId,
+        debug: false,
+        ssr
+      });
+      if (!metadata) {
+        import_diagnostics.logger.error({
+          label: "static-bundle-provider",
+          message: `debug-to-prod fallback missing metadata for specifier: ${specifier}`
+        });
+        return BUNDLE_SOURCE_NOT_FOUND;
+      }
+      bundleSourcePath = (0, import_shared_utils.joinUrlPath)(this.siteRootDir, metadata.path);
+    }
+    return bundleSourcePath;
+  }
+};
+var static_bundle_provider_default = StaticBundleProvider;

package/build/cjs/providers/static-module-provider.cjs

@@ -0,0 +1,138 @@
+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/static/src/providers/static-module-provider.ts
+__markAsModule(exports);
+__export(exports, {
+  default: () => static_module_provider_default
+});
+var import_diagnostics = __toModule(require("@lwrjs/diagnostics"));
+var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
+var import_site_metadata = __toModule(require("../site-metadata.cjs"));
+var StaticModuleProvider = class {
+  constructor(_config, context) {
+    this.name = "static-module-provider";
+    if (!context.siteMetadata) {
+      throw new Error(`[${this.name}] Site metadata was not found`);
+    }
+    this.externals = Object.keys(context.config.bundleConfig.external || {});
+    this.siteRootDir = context.siteMetadata.getSiteRootDir();
+    this.i18n = context.config.i18n;
+    this.siteMetadata = context.siteMetadata;
+    this.fingerprintIndex = buildFingerprintsIndex(context);
+  }
+  async getModule(moduleId, runtimeParams) {
+    const localeId = runtimeParams?.locale || this.i18n.defaultLocale;
+    const ssr = runtimeParams?.ssr;
+    const metadata = this.getBundleMetadata({moduleId, localeId, debug: false, ssr});
+    if (metadata && (0, import_shared_utils.isLambdaEnv)()) {
+      import_diagnostics.logger.warn({
+        label: `${this.name}`,
+        message: `We should not be asking for module source we have in our site metadata: ${moduleId.specifier}`
+      });
+      return void 0;
+    }
+    return void 0;
+  }
+  async getModuleEntry(moduleId, runtimeParams) {
+    const {specifier, version} = moduleId;
+    const localeId = runtimeParams?.locale || this.i18n.defaultLocale;
+    const ssr = runtimeParams?.ssr;
+    const metadata = this.getBundleMetadata({moduleId, localeId, ssr, debug: false});
+    if (metadata) {
+      import_diagnostics.logger.debug({
+        label: `${this.name}`,
+        message: `Module Entry request for static bundle ${specifier}`
+      });
+      const bundlePath = (0, import_shared_utils.joinUrlPath)(this.siteRootDir, metadata.path);
+      const resolvedVersion = (0, import_site_metadata.resolveStaticBundleVersion)(metadata.version, version);
+      return {
+        id: (0, import_shared_utils.getSpecifier)({...moduleId, version: resolvedVersion}),
+        version: resolvedVersion,
+        specifier,
+        entry: "entry-not-provided",
+        src: bundlePath
+      };
+    } else if (this.externals.includes(specifier)) {
+      const resolvedVersion = (0, import_site_metadata.resolveStaticBundleVersion)(void 0, version);
+      return {
+        id: (0, import_shared_utils.getSpecifier)({...moduleId, version: resolvedVersion}),
+        version: resolvedVersion,
+        specifier,
+        entry: "entry-not-provided"
+      };
+    }
+    return this.getEntryFromFingerprintIndex(moduleId);
+  }
+  getEntryFromFingerprintIndex(moduleId) {
+    const versionedSpecifier = (0, import_shared_utils.getSpecifier)(moduleId);
+    return this.fingerprintIndex[versionedSpecifier] || this.fingerprintIndex[moduleId.specifier];
+  }
+  getBundleMetadata({
+    moduleId,
+    localeId,
+    debug,
+    ssr
+  }) {
+    const siteBundleId = (0, import_site_metadata.getSiteBundleId)(moduleId, localeId, ssr, this.i18n);
+    return this.siteMetadata.getSiteBundlesDecisionTree().find(siteBundleId, debug);
+  }
+};
+var static_module_provider_default = StaticModuleProvider;
+function buildFingerprintsIndex(context) {
+  const fingerprintIndex = {};
+  if (!context.runtimeEnvironment.featureFlags.LEGACY_LOADER) {
+    const bundles = context.siteMetadata?.getSiteBundles().bundles || {};
+    for (const bundle of Object.values(bundles)) {
+      const bundlePath = (0, import_shared_utils.joinUrlPath)(String(context.siteMetadata?.getSiteRootDir()), bundle.path);
+      const includedModules = bundle.includedModules || [];
+      for (const includedModule of includedModules) {
+        const versionedSpecifier = convertSiteIdToVersionedSpecifier(includedModule);
+        const moduleId = (0, import_shared_utils.explodeSpecifier)(versionedSpecifier);
+        if (!fingerprintIndex[versionedSpecifier]) {
+          fingerprintIndex[versionedSpecifier] = {
+            id: versionedSpecifier,
+            version: (0, import_site_metadata.resolveStaticBundleVersion)(moduleId.version),
+            specifier: moduleId.specifier,
+            entry: "entry-not-provided",
+            src: bundlePath
+          };
+        }
+        if (!fingerprintIndex[moduleId.specifier]) {
+          fingerprintIndex[moduleId.specifier] = {
+            id: moduleId.specifier,
+            version: (0, import_site_metadata.resolveStaticBundleVersion)(moduleId.version),
+            specifier: moduleId.specifier,
+            entry: "entry-not-provided",
+            src: bundlePath
+          };
+        }
+      }
+    }
+  }
+  return fingerprintIndex;
+}
+function convertSiteIdToVersionedSpecifier(siteId) {
+  const parsedSiteId = (0, import_site_metadata.parseSiteId)(siteId);
+  return (0, import_shared_utils.getSpecifier)({specifier: parsedSiteId.specifier, version: parsedSiteId.variants[import_shared_utils.VERSION_SIGIL]});
+}

package/build/cjs/providers/static-resource-provider.cjs

@@ -0,0 +1,73 @@
+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/static/src/providers/static-resource-provider.ts
+__markAsModule(exports);
+__export(exports, {
+  default: () => static_resource_provider_default
+});
+var import_diagnostics = __toModule(require("@lwrjs/diagnostics"));
+var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
+var import_path = __toModule(require("path"));
+var import_fs_extra = __toModule(require("fs-extra"));
+var import_site_metadata = __toModule(require("../site-metadata.cjs"));
+var StaticResourceProvider = class {
+  constructor(_config, context) {
+    this.name = "static-resource-provider";
+    if (!context.siteMetadata) {
+      throw new Error(`[${this.name}] Site metadata was not found`);
+    }
+    this.resourceRegistry = context.resourceRegistry;
+    this.siteRootDir = context.siteMetadata.getSiteRootDir();
+    this.siteMetadata = context.siteMetadata;
+  }
+  async getResource(resourceIdentity, runtimeEnvironment, runtimeParams) {
+    const {debug} = runtimeEnvironment;
+    const {ignoreDebug} = runtimeParams;
+    const resourceMetadata = this.siteMetadata.getSiteResourcesDecisionTree().find((0, import_site_metadata.getSiteResourceId)(resourceIdentity), debug && !ignoreDebug);
+    if (!resourceMetadata) {
+      import_diagnostics.logger.warn({
+        label: `${this.name}`,
+        message: `Did not find requested specifier ${resourceIdentity.specifier}`
+      });
+      return void 0;
+    }
+    const resourcePath = (0, import_shared_utils.joinUrlPath)(this.siteRootDir, resourceMetadata.path);
+    const type = resourceMetadata.mimeType || (0, import_shared_utils.mimeLookup)(resourcePath) || "application/javascript";
+    return {
+      type,
+      stream: () => {
+        import_diagnostics.logger.debug({
+          label: `${this.name}`,
+          message: `Resource read from lambda ${resourceIdentity.specifier}`
+        });
+        return import_fs_extra.default.createReadStream(resourcePath);
+      },
+      src: resourcePath,
+      inline: resourceMetadata.inline,
+      integrity: resourceMetadata.integrity,
+      entry: import_path.default.resolve(resourcePath)
+    };
+  }
+};
+var static_resource_provider_default = StaticResourceProvider;