@lwrjs/static 0.13.0-alpha.2 → 0.13.0-alpha.21

package/build/cjs/utils/decision-tree.cjs

@@ -0,0 +1,201 @@
+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/utils/decision-tree.ts
+__markAsModule(exports);
+__export(exports, {
+  createFallbackMap: () => createFallbackMap,
+  default: () => decision_tree_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 CHOICE_WILDCARD = "*";
+var CHOICE_EMPTY = "";
+var CHOICE_PROD = "prod";
+var CHOICE_DEBUG = "debug";
+var DecisionTreeImpl = class {
+  constructor() {
+    this.root = new TreeNode();
+  }
+  insert(siteArtifactId, artifact, debug, localeFallbacks) {
+    const decisionPath = this.createPossibleArtifactChoices({
+      id: siteArtifactId,
+      localeFallbacks,
+      debug
+    });
+    const choices = decisionPath[0];
+    const isLeaf = decisionPath.length == 1;
+    for (const [index, key] of choices.entries()) {
+      const rank = [index];
+      if (!this.root.getChild(key, false)) {
+        this.root.addChild(key, new TreeNode(key, ""));
+      }
+      const nextNode = this.root.getChild(key, false);
+      if (isLeaf) {
+        nextNode.setArtifact(artifact, rank);
+      } else {
+        this.deepInsert(1, decisionPath, key, nextNode, artifact, rank);
+      }
+    }
+  }
+  deepInsert(level, decisionPath, currentPath, currentNode, artifact, rank) {
+    if (level >= decisionPath.length)
+      return;
+    const choices = decisionPath[level];
+    const isLeaf = level === decisionPath.length - 1;
+    for (const [index, key] of choices.entries()) {
+      const nextRank = [...rank, index];
+      if (!currentNode.getChild(key, false)) {
+        currentNode.addChild(key, new TreeNode(key, currentPath));
+      }
+      const nextNode = currentNode.getChild(key, false);
+      if (isLeaf) {
+        nextNode.setArtifact(artifact, nextRank);
+      } else {
+        this.deepInsert(level + 1, decisionPath, `${currentPath}/${key}`, nextNode, artifact, nextRank);
+      }
+    }
+  }
+  find(siteArtifactId, debug, localeId) {
+    const parsedArtifactId = (0, import_site_metadata.parseSiteId)(siteArtifactId);
+    const decisionPath = this.createArtifactChoices({
+      specifier: parsedArtifactId.specifier,
+      version: parsedArtifactId.variants[import_shared_utils.VERSION_SIGIL],
+      localeId: localeId ?? parsedArtifactId.variants[import_shared_utils.LOCALE_SIGIL],
+      debug
+    });
+    let currentNode = this.root;
+    for (const key of decisionPath) {
+      const lastPath = currentNode.getPath();
+      currentNode = currentNode.getChild(key);
+      if (!currentNode) {
+        import_diagnostics.logger.debug(`Module ${key} not found at ${lastPath}`);
+        return void 0;
+      }
+    }
+    if (!currentNode.artifact) {
+      import_diagnostics.logger.debug(`Artifact not found at ${currentNode.getPath()}`);
+    }
+    return currentNode.artifact;
+  }
+  createArtifactChoices({specifier, version, localeId, debug}) {
+    const envChoice = debug ? CHOICE_DEBUG : CHOICE_PROD;
+    const versionChoice = getVersionChoice(version);
+    const uriVersion = (0, import_shared_utils.normalizeVersionToUri)(versionChoice);
+    return [specifier, envChoice, uriVersion, localeId || CHOICE_WILDCARD];
+  }
+  createPossibleArtifactChoices({
+    id,
+    localeFallbacks,
+    debug
+  }) {
+    const match = (0, import_site_metadata.parseSiteId)(id);
+    const specifier = match.specifier;
+    if (!specifier) {
+      throw new Error(`Unable to parse${debug ? " debug" : ""} static bundle specifier: ${id}`);
+    }
+    const versionChoice = getVersionChoice(match.variants[import_shared_utils.VERSION_SIGIL]);
+    const versions = versionChoice === CHOICE_EMPTY ? [...new Set([CHOICE_EMPTY, CHOICE_WILDCARD])] : [...new Set([versionChoice, CHOICE_EMPTY])];
+    const envChoice = debug ? [CHOICE_DEBUG] : [CHOICE_PROD];
+    const localeChoice = match.variants[import_shared_utils.LOCALE_SIGIL];
+    const localeId = localeChoice && localeFallbacks ? localeFallbacks[localeChoice] : [CHOICE_WILDCARD];
+    return [[specifier], envChoice, versions, localeId];
+  }
+};
+var decision_tree_default = DecisionTreeImpl;
+var TreeNode = class {
+  constructor(value = "", parentPath = "") {
+    this.children = new Map();
+    this.artifact = void 0;
+    this.decisionValue = value;
+    this.parentPath = parentPath;
+  }
+  addChild(value, node) {
+    this.children.set(value, node);
+  }
+  setArtifact(artifact, rank) {
+    if (this.artifact && isLowerOrEqualRank(rank, this.rank)) {
+      import_diagnostics.logger.debug({
+        label: "DecisionTree",
+        message: `Ignored Artifact ${this.getPath()} ${this.rank} <= ${rank}`
+      });
+      return;
+    }
+    import_diagnostics.logger.debug({
+      label: "DecisionTree",
+      message: `Added artifact at ${this.getPath()}`
+    });
+    this.rank = rank;
+    this.artifact = artifact;
+  }
+  getChild(key, allowWildcard = true) {
+    return allowWildcard ? this.children.get(key) || this.children.get(CHOICE_WILDCARD) : this.children.get(key);
+  }
+  getPath() {
+    return this.parentPath ? this.parentPath + "|" + this.decisionValue : this.decisionValue;
+  }
+};
+function isLowerOrEqualRank(contender, existing) {
+  if (!existing) {
+    return true;
+  }
+  if (existing.length !== contender.length) {
+    throw new Error(`Paths must be of the same length ${existing} not found at ${contender}`);
+  }
+  for (let i = 0; i < existing.length; i++) {
+    if (contender[i] > existing[i]) {
+      return true;
+    } else if (contender[i] < existing[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+function getVersionChoice(version) {
+  if (!version || version === import_shared_utils.VERSION_NOT_PROVIDED) {
+    return CHOICE_EMPTY;
+  }
+  return (0, import_shared_utils.normalizeVersionToUri)(version);
+}
+function createFallbackMap(config) {
+  const map = {};
+  function findFallbacks(localeId, visited = new Set()) {
+    if (visited.has(localeId) || localeId === config.defaultLocale) {
+      return [];
+    }
+    visited.add(localeId);
+    const locale = config.locales.find((l) => l.id === localeId);
+    if (!locale || !locale.fallback) {
+      return [localeId];
+    }
+    return [localeId, ...findFallbacks(locale.fallback, visited)];
+  }
+  config.locales.forEach((locale) => {
+    if (locale.id !== config.defaultLocale) {
+      map[locale.id] = [...new Set([...findFallbacks(locale.id)])];
+    }
+  });
+  map[CHOICE_WILDCARD] = [CHOICE_WILDCARD];
+  return map;
+}

package/build/es/index.d.ts

@@ -0,0 +1,2 @@
+export * from './tools/dedupe-bundles.js';
+//# sourceMappingURL=index.d.ts.map

package/build/es/index.js

@@ -0,0 +1,2 @@
+export * from './tools/dedupe-bundles.js';
+//# sourceMappingURL=index.js.map

package/build/es/providers/static-bundle-provider.d.ts

@@ -1,13 +1,17 @@
-import type { AbstractModuleId, BundleDefinition, BundleProvider, ProviderContext, RuntimeEnvironment, RuntimeParams } from '@lwrjs/types';
+import type { AbstractModuleId, BundleDefinition, BundleProvider, ProviderContext, RuntimeEnvironment, RuntimeParams, SiteMetadata } from '@lwrjs/types';
 export default class StaticBundleProvider implements BundleProvider {
     name: string;
-    siteBundles: import("@lwrjs/types").SiteBundles;
-    debugSiteBundles?: import("@lwrjs/types").SiteBundles | undefined;
     siteRootDir: string;
     bundleConfig: import("@lwrjs/types").BundleConfig;
     i18n: import("@lwrjs/types").I18NConfig;
+    siteMetadata: SiteMetadata;
     constructor(_config: {}, context: ProviderContext);
     bundle<BundleIdentifier extends AbstractModuleId, RE extends RuntimeEnvironment>(moduleId: BundleIdentifier, runtimeEnvironment: RE, runtimeParams: RuntimeParams): Promise<BundleDefinition | undefined>;
+    private getBundleMetadata;
+    /**
+     * Takes a key from the site bundle metadata and creates an appropriate runtime BaseModuleReference to use in the LWR runtime.
+     */
+    private getModuleReference;
     /**
      * Get the source code for the a static bundle
      * If we are running in a lambda and the mode is debug we will return the prod source code instead of the debug source code
@@ -17,6 +21,6 @@ export default class StaticBundleProvider implements BundleProvider {
      * @param specifier Root specifier for the requested bundle
      * @param localeId Locale id (e.g. en-US) for the current request
      */
-    getCode(bundlePath: string, debug: boolean, specifier: string, localeId: string): Promise<string>;
+    getCode(bundlePath: string, debug: boolean, specifier: string, version: string | undefined, localeId: string): Promise<string>;
 }
 //# sourceMappingURL=static-bundle-provider.d.ts.map

package/build/es/providers/static-bundle-provider.js

@@ -1,16 +1,15 @@
 import { logger } from '@lwrjs/diagnostics';
-import { explodeSpecifier, getSpecifier } from '@lwrjs/shared-utils';
+import { VERSION_SIGIL, createIntegrityHash, explodeSpecifier, getSpecifier, isLambdaEnv, } from '@lwrjs/shared-utils';
 import path from 'path';
 import fs from 'fs-extra';
-import { getLocalizedBundle, resolveStaticBundleVersion } from '../utils/static-utils.js';
+import { getSiteBundleId, parseSiteId, resolveStaticBundleVersion } from '../site-metadata.js';
 export default class StaticBundleProvider {
     constructor(_config, context) {
         this.name = 'static-bundle-provider';
         if (!context.siteMetadata) {
             throw new Error(`[${this.name}] Site metadata was not found`);
         }
-        this.siteBundles = context.siteMetadata.getSiteBundles();
-        this.debugSiteBundles = context.siteMetadata.getDebugSiteBundles();
+        this.siteMetadata = context.siteMetadata;
         this.siteRootDir = context.siteMetadata.getSiteRootDir();
         this.bundleConfig = context.config.bundleConfig;
         this.i18n = context.config.i18n;
@@ -19,37 +18,26 @@ export default class StaticBundleProvider {
         const { specifier, name, namespace, version } = moduleId;
         const { debug, i18n: { defaultLocale }, } = runtimeEnvironment;
         const localeId = (runtimeParams?.locale || defaultLocale);
-        const siteBundles = debug && this.debugSiteBundles ? this.debugSiteBundles : this.siteBundles;
-        const metadata = await getLocalizedBundle(specifier, siteBundles, localeId, this.i18n);
+        const metadata = this.getBundleMetadata(moduleId, localeId, debug);
         if (!metadata) {
             return undefined;
         }
         // Default bundle source path
         const bundlePath = path.join(this.siteRootDir, metadata.path);
         // Get the associated bundle source code
-        const code = await this.getCode(bundlePath, debug, specifier, localeId);
-        const imports = metadata.imports.map((specifier) => {
-            const importModule = explodeSpecifier(specifier);
-            if (!importModule.version) {
-                // Get version from metadata for un-versioned imports
-                importModule.version = resolveStaticBundleVersion(this.siteBundles.bundles[specifier]?.version);
-            }
-            return importModule;
-        });
-        const dynamicImports = metadata.dynamicImports?.map((specifier) => {
-            const dynamicImportModule = explodeSpecifier(specifier);
-            if (!dynamicImportModule.version) {
-                // Get version from metadata for un-versioned imports
-                dynamicImportModule.version = resolveStaticBundleVersion(this.siteBundles.bundles[specifier]?.version);
-            }
-            return dynamicImportModule;
-        });
+        const code = await this.getCode(bundlePath, debug, specifier, version, localeId);
+        const imports = metadata.imports.map((importSpecifier) => this.getModuleReference(importSpecifier, localeId, debug));
+        const dynamicImports = metadata.dynamicImports?.map((importSpecifier) => this.getModuleReference(importSpecifier, localeId, debug));
         const id = getSpecifier(moduleId);
         const exploded = explodeSpecifier(id);
         // Seem unlikely name was not in the moduleId but just incase set it form the exploded id
-        const resolvedName = name || exploded.name;
-        const resolvedNamespace = namespace || exploded.namespace;
+        const resolvedName = name ?? exploded.name;
+        const resolvedNamespace = namespace ?? exploded.namespace;
         const resolvedVersion = resolveStaticBundleVersion(metadata.version, version);
+        const includedModules = metadata.includedModules?.map((includedId) => {
+            const includedModule = this.getModuleReference(includedId, localeId, debug);
+            return getSpecifier(includedModule);
+        }) || [];
         return {
             code,
             id: getSpecifier({
@@ -63,15 +51,37 @@ export default class StaticBundleProvider {
             version: resolvedVersion,
             specifier: specifier,
             config: this.bundleConfig,
+            integrity: metadata.integrity ?? createIntegrityHash(code),
             bundleRecord: {
                 // TODO we need to solve include modules for fingerprints support
-                includedModules: metadata.includedModules || [],
+                includedModules,
                 imports,
                 dynamicImports,
             },
             src: bundlePath,
         };
     }
+    getBundleMetadata(moduleId, localeId, debug) {
+        const siteBundleId = getSiteBundleId(moduleId, localeId, this.i18n);
+        return this.siteMetadata.getSiteBundlesDecisionTree().find(siteBundleId, debug);
+    }
+    /**
+     * Takes a key from the site bundle metadata and creates an appropriate runtime BaseModuleReference to use in the LWR runtime.
+     */
+    getModuleReference(siteBundleIdStr, localeId, debug) {
+        const siteBundleId = parseSiteId(siteBundleIdStr);
+        const includedModule = explodeSpecifier(siteBundleId.specifier);
+        if (!siteBundleId.variants[VERSION_SIGIL]) {
+            const importBundleMetadata = this.siteMetadata
+                .getSiteBundlesDecisionTree()
+                .find(siteBundleIdStr, debug, localeId);
+            includedModule.version = resolveStaticBundleVersion(importBundleMetadata?.version);
+        }
+        else {
+            includedModule.version = siteBundleId.variants[VERSION_SIGIL];
+        }
+        return includedModule;
+    }
     /**
      * Get the source code for the a static bundle
      * If we are running in a lambda and the mode is debug we will return the prod source code instead of the debug source code
@@ -81,17 +91,16 @@ export default class StaticBundleProvider {
      * @param specifier Root specifier for the requested bundle
      * @param localeId Locale id (e.g. en-US) for the current request
      */
-    async getCode(bundlePath, debug, specifier, localeId) {
+    async getCode(bundlePath, debug, specifier, version, localeId) {
         // Flag is used to indicate that we are running on a lambda
-        const isLambda = process.env.AWS_LAMBDA_FUNCTION_NAME !== undefined;
+        const isLambda = isLambdaEnv();
         // Default source code path determined from metadata based on debug mode
         let bundleSourcePath = bundlePath;
         try {
             // This is the special case where the request is in debug mode and we are on the lambda
             // So we will look up the prod source code instead of the debug source code
             if (debug && isLambda) {
-                const siteBundles = this.siteBundles;
-                const metadata = await getLocalizedBundle(specifier, siteBundles, localeId, this.i18n);
+                const metadata = this.getBundleMetadata({ specifier, version }, localeId, false);
                 if (!metadata) {
                     // We did not find the bundle prod bundle even though we did find it in the debug metadata before
                     logger.warn({
@@ -105,7 +114,7 @@ export default class StaticBundleProvider {
                 bundleSourcePath = path.join(this.siteRootDir, metadata.path);
             }
             // Read the bundle source code.
-            return (await fs.readFile(bundleSourcePath)).toString('utf-8');
+            return await fs.readFile(bundleSourcePath, 'utf-8');
         }
         catch (err) {
             // Ran it an un-expected error reading the bundle source code

package/build/es/providers/static-module-provider.d.ts

@@ -1,13 +1,15 @@
-import type { AbstractModuleId, I18NConfig, ModuleCompiled, ModuleEntry, ModuleProvider, ProviderContext, RuntimeParams } from '@lwrjs/types';
+import type { AbstractModuleId, I18NConfig, ModuleCompiled, ModuleEntry, ModuleProvider, ProviderContext, RuntimeParams, SiteMetadata } from '@lwrjs/types';
 export default class StaticModuleProvider implements ModuleProvider {
     name: string;
-    siteBundles: import("@lwrjs/types").SiteBundles;
     siteRootDir: string;
     externals: string[];
     fingerprintIndex: Record<string, ModuleEntry>;
     i18n: I18NConfig;
+    siteMetadata: SiteMetadata;
     constructor(_config: {}, context: ProviderContext);
     getModule<T extends AbstractModuleId>(moduleId: T, runtimeParams: RuntimeParams): Promise<ModuleCompiled | undefined>;
     getModuleEntry<T extends AbstractModuleId>(moduleId: T, runtimeParams: RuntimeParams): Promise<ModuleEntry | undefined>;
+    private getEntryFromFingerprintIndex;
+    private getBundleMetadata;
 }
 //# sourceMappingURL=static-module-provider.d.ts.map

package/build/es/providers/static-module-provider.js

@@ -1,7 +1,7 @@
 import { logger } from '@lwrjs/diagnostics';
-import { explodeSpecifier, getSpecifier } from '@lwrjs/shared-utils';
+import { VERSION_SIGIL, explodeSpecifier, getSpecifier } from '@lwrjs/shared-utils';
 import path from 'path';
-import { getLocalizedBundle, resolveStaticBundleVersion } from '../utils/static-utils.js';
+import { getSiteBundleId, parseSiteId, resolveStaticBundleVersion } from '../site-metadata.js';
 export default class StaticModuleProvider {
     constructor(_config, context) {
         this.name = 'static-module-provider';
@@ -9,16 +9,15 @@ export default class StaticModuleProvider {
             throw new Error(`[${this.name}] Site metadata was not found`);
         }
         this.externals = Object.keys(context.config.bundleConfig.external || {});
-        this.siteBundles = context.siteMetadata.getSiteBundles();
         this.siteRootDir = context.siteMetadata.getSiteRootDir();
         this.i18n = context.config.i18n;
+        this.siteMetadata = context.siteMetadata;
         // If we are using fingerprints collect all the specifiers in the bundles and add them to an index for creating the mapping identities
         this.fingerprintIndex = buildFingerprintsIndex(context);
     }
     async getModule(moduleId, runtimeParams) {
-        const { specifier } = moduleId;
         const localeId = (runtimeParams?.locale || this.i18n.defaultLocale);
-        const metadata = await getLocalizedBundle(specifier, this.siteBundles, localeId, this.i18n);
+        const metadata = this.getBundleMetadata(moduleId, localeId, false);
         if (metadata) {
             logger.warn({
                 label: `${this.name}`,
@@ -34,7 +33,7 @@ export default class StaticModuleProvider {
         // TODO shouldn't we be passing the runtime environment here to test?
         const { specifier, version } = moduleId;
         const localeId = (runtimeParams?.locale || this.i18n.defaultLocale);
-        const metadata = await getLocalizedBundle(specifier, this.siteBundles, localeId, this.i18n);
+        const metadata = this.getBundleMetadata(moduleId, localeId, false);
         if (metadata) {
             logger.debug({
                 label: `${this.name}`,
@@ -61,11 +60,16 @@ export default class StaticModuleProvider {
                 entry: 'entry-not-provided',
             };
         }
-        else if (this.fingerprintIndex[specifier]) {
-            return this.fingerprintIndex[specifier];
-        }
-        // proceed to next provider
-        return undefined;
+        // checks the fingerprint index or proceeds to next provider
+        return this.getEntryFromFingerprintIndex(moduleId);
+    }
+    getEntryFromFingerprintIndex(moduleId) {
+        const versionedSpecifier = getSpecifier(moduleId);
+        return this.fingerprintIndex[versionedSpecifier] || this.fingerprintIndex[moduleId.specifier];
+    }
+    getBundleMetadata(moduleId, localeId, debug) {
+        const siteBundleId = getSiteBundleId(moduleId, localeId, this.i18n);
+        return this.siteMetadata.getSiteBundlesDecisionTree().find(siteBundleId, debug);
     }
 }
 /**
@@ -80,10 +84,21 @@ function buildFingerprintsIndex(context) {
             const bundlePath = path.join(String(context.siteMetadata?.getSiteRootDir()), bundle.path);
             const includedModules = bundle.includedModules || [];
             for (const includedModule of includedModules) {
-                const moduleId = explodeSpecifier(includedModule);
+                const versionedSpecifier = convertSiteIdToVersionedSpecifier(includedModule);
+                const moduleId = explodeSpecifier(versionedSpecifier);
+                if (!fingerprintIndex[versionedSpecifier]) {
+                    fingerprintIndex[versionedSpecifier] = {
+                        id: versionedSpecifier,
+                        version: resolveStaticBundleVersion(moduleId.version),
+                        specifier: moduleId.specifier,
+                        entry: 'entry-not-provided',
+                        src: bundlePath,
+                    };
+                }
+                // Add an un-versioned match for the first hit
                 if (!fingerprintIndex[moduleId.specifier]) {
                     fingerprintIndex[moduleId.specifier] = {
-                        id: getSpecifier(moduleId),
+                        id: moduleId.specifier,
                         version: resolveStaticBundleVersion(moduleId.version),
                         specifier: moduleId.specifier,
                         entry: 'entry-not-provided',
@@ -95,4 +110,8 @@ function buildFingerprintsIndex(context) {
     }
     return fingerprintIndex;
 }
+function convertSiteIdToVersionedSpecifier(siteId) {
+    const parsedSiteId = parseSiteId(siteId);
+    return getSpecifier({ specifier: parsedSiteId.specifier, version: parsedSiteId.variants[VERSION_SIGIL] });
+}
 //# sourceMappingURL=static-module-provider.js.map

package/build/es/providers/static-resource-provider.d.ts

@@ -1,11 +1,10 @@
-import type { BootstrapRuntimeEnvironment, ProviderContext, ResourceDefinition, ResourceIdentifier, ResourceProvider } from '@lwrjs/types';
+import type { BootstrapRuntimeEnvironment, ProviderContext, ResourceDefinition, ResourceIdentifier, ResourceProvider, RuntimeParams } from '@lwrjs/types';
 export default class StaticResourceProvider implements ResourceProvider {
     name: string;
-    siteResources: import("@lwrjs/types").SiteResources;
-    debugSiteResources: import("@lwrjs/types").SiteResources;
     siteRootDir: string;
+    siteMetadata: import("@lwrjs/types").SiteMetadata;
     resourceRegistry: import("@lwrjs/types").PublicResourceRegistry;
     constructor(_config: {}, context: ProviderContext);
-    getResource<Identifier extends ResourceIdentifier, RuntimeEnvironment extends BootstrapRuntimeEnvironment>(resourceIdentity: Identifier, runtimeEnvironment: RuntimeEnvironment): Promise<ResourceDefinition | undefined>;
+    getResource<Identifier extends ResourceIdentifier, RuntimeEnvironment extends BootstrapRuntimeEnvironment>(resourceIdentity: Identifier, runtimeEnvironment: RuntimeEnvironment, runtimeParams: RuntimeParams): Promise<ResourceDefinition | undefined>;
 }
 //# sourceMappingURL=static-resource-provider.d.ts.map

package/build/es/providers/static-resource-provider.js

@@ -2,6 +2,7 @@ import { logger } from '@lwrjs/diagnostics';
 import { mimeLookup } from '@lwrjs/shared-utils';
 import path from 'path';
 import fs from 'fs-extra';
+import { getSiteResourceId } from '../site-metadata.js';
 export default class StaticResourceProvider {
     constructor(_config, context) {
         this.name = 'static-resource-provider';
@@ -9,50 +10,43 @@ export default class StaticResourceProvider {
             throw new Error(`[${this.name}] Site metadata was not found`);
         }
         this.resourceRegistry = context.resourceRegistry;
-        this.siteResources = context.siteMetadata.getSiteResources();
-        this.debugSiteResources = context.siteMetadata.getDebugSiteResources();
         this.siteRootDir = context.siteMetadata.getSiteRootDir();
+        this.siteMetadata = context.siteMetadata;
     }
-    async getResource(resourceIdentity, runtimeEnvironment) {
+    async getResource(resourceIdentity, runtimeEnvironment, runtimeParams) {
         const { debug } = runtimeEnvironment;
-        const metadata = this.siteResources.resources[resourceIdentity.specifier];
-        const debugMetadata = this.debugSiteResources
-            ? this.debugSiteResources.resources[resourceIdentity.specifier]
-            : undefined;
-        if (!metadata && !debugMetadata) {
+        // HACK: this code is tricky because resource IDs are different between prod vs debug ("lwr-loader-shim.bundle.min.js" vs "lwr-loader-shim.bundle.js").
+        // 1. In debug mode on Lambda (during SSR), we need to ignore runtimeEnvironment.debug because we will always ask for the prod version (lwr-loader-shim.bundle.min.js)
+        // 2. But when we generate the view, we can't ignore runtimeEnvironment.debug because we need the debug version of the loader shim (lwr-loader-shim.bundle.js)
+        const { ignoreDebug } = runtimeParams;
+        const resourceMetadata = this.siteMetadata
+            .getSiteResourcesDecisionTree()
+            .find(getSiteResourceId(resourceIdentity), debug && !ignoreDebug);
+        if (!resourceMetadata) {
             logger.warn({
                 label: `${this.name}`,
                 message: `Did not find requested specifier ${resourceIdentity.specifier}`,
             });
             return undefined;
         }
-        const resourcePath = path.join(this.siteRootDir, metadata.path);
-        const debugResourcePath = debugMetadata ? path.join(this.siteRootDir, debugMetadata.path) : undefined;
-        const isLambda = process.env.AWS_LAMBDA_FUNCTION_NAME !== undefined;
-        const useDebug = debug && !isLambda && debugResourcePath;
+        const resourcePath = path.join(this.siteRootDir, resourceMetadata.path);
         // Figure out mime type
-        const type = metadata.mimeType || mimeLookup(resourcePath) || 'application/javascript';
+        const type = resourceMetadata.mimeType ||
+            mimeLookup(resourcePath) ||
+            'application/javascript';
         return {
             type,
-            // Have to make the loader shim code available for SSR
             stream: () => {
                 logger.debug({
                     label: `${this.name}`,
                     message: `Resource read from lambda ${resourceIdentity.specifier}`,
                 });
-                if (useDebug) {
-                    // use the debug resource if:
-                    // - debug mode is ON
-                    // - isLambda is false
-                    // - the debug version of the resource exists
-                    return fs.createReadStream(debugResourcePath);
-                }
-                else {
-                    return fs.createReadStream(resourcePath);
-                }
+                return fs.createReadStream(resourcePath);
             },
-            src: useDebug ? debugResourcePath : resourcePath,
-            inline: metadata.inline,
+            src: resourcePath,
+            inline: resourceMetadata.inline,
+            integrity: resourceMetadata.integrity,
+            entry: path.resolve(resourcePath),
         };
     }
 }

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

@@ -1,7 +1,17 @@
-import type { SiteAssets, SiteBundles, SiteMetadata, SiteResources } from '@lwrjs/types';
+import type { AbstractModuleId, I18NConfig, ResourceIdentifier, SiteAssets, SiteBundle, SiteBundles, SiteMetadata, SiteResource, SiteResources } from '@lwrjs/types';
+import DecisionTree from './utils/decision-tree.js';
+import { LOCALE_SIGIL, VERSION_SIGIL } from '@lwrjs/shared-utils';
 type Options = {
     rootDir: string;
+    i18n: I18NConfig;
 };
+export declare const SITE_VERSION_PREFIX: string;
+export declare const SITE_LOCALE_PREFIX: string;
+type SIGIL = typeof VERSION_SIGIL | typeof LOCALE_SIGIL;
+interface SiteArtifactId {
+    specifier: string;
+    variants: Record<SIGIL, string>;
+}
 export declare class SiteMetadataImpl implements SiteMetadata {
     private options;
     private siteBundles;
@@ -9,6 +19,8 @@ export declare class SiteMetadataImpl implements SiteMetadata {
     private siteResources;
     private debugSiteResources;
     private siteAssets;
+    private bundleDecisionTree?;
+    private resourceDecisionTree?;
     constructor(options: Options);
     getSiteRootDir(): string;
     getSiteBundles(): SiteBundles;
@@ -16,6 +28,16 @@ export declare class SiteMetadataImpl implements SiteMetadata {
     getSiteResources(): SiteResources;
     getDebugSiteResources(): SiteResources;
     getSiteAssets(): SiteAssets;
+    /**
+     * Returns a decision tree for site bundles in the form [debug, specifier, version, locale].
+     * It is assumed this is static after creation subsequent calls will return the same instance.
+     */
+    getSiteBundlesDecisionTree(): DecisionTree<SiteBundle>;
+    /**
+     * Returns a decision tree for site resources.
+     * It is assumed this is static after creation subsequent calls will return the same instance.
+     */
+    getSiteResourcesDecisionTree(): DecisionTree<SiteResource>;
     persistSiteMetadata(): Promise<void>;
     private readStaticBundleMetadata;
     /**
@@ -27,5 +49,30 @@ export declare class SiteMetadataImpl implements SiteMetadata {
      */
     private readStaticAssetsMetadata;
 }
+/**
+ * Return the version for a static module bundle.
+ *
+ * Version defined in the metadata > Requested Version > 'version-not-provided'
+ */
+export declare function resolveStaticBundleVersion(metadataVersion?: string, requestedVersion?: string): string;
+/**
+ * Parse a site artifact ids string in the form specifier(|sigil(/value)?)*
+ */
+export declare function parseSiteId(input: string): SiteArtifactId;
+/**
+ * Get a  Site Bundle Identifier from a Root Module
+ *
+ * @param moduleId - Root Module Id
+ * @param locale - Current locale
+ * @returns Site Bundle Identifier
+ */
+export declare function getSiteBundleId({ specifier, namespace, name, version }: Partial<AbstractModuleId>, locale?: string, i18n?: I18NConfig): string;
+/**
+ * Get a  Site Resource Identifier from a Resource Identifier
+ *
+ * @param resourceID -Resource Identifier
+ * @returns Site Bundle Identifier
+ */
+export declare function getSiteResourceId({ specifier, version }: Partial<ResourceIdentifier>): string;
 export {};
 //# sourceMappingURL=site-metadata.d.ts.map