@lwrjs/static 0.13.0-alpha.6 → 0.13.0-alpha.8

package/build/cjs/{utils/static-utils.cjs → index.cjs}

@@ -5,10 +5,6 @@ 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))
@@ -21,19 +17,6 @@ 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/static-utils.ts
+// packages/@lwrjs/static/src/index.ts
 __markAsModule(exports);
-__export(exports, {
-  getLocalizedBundle: () => getLocalizedBundle,
-  resolveStaticBundleVersion: () => resolveStaticBundleVersion
-});
-var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
-function resolveStaticBundleVersion(metadataVersion, requestedVersion) {
-  return metadataVersion || requestedVersion || import_shared_utils.VERSION_NOT_PROVIDED;
-}
-async function getLocalizedBundle(specifier, siteBundles, initialLocaleId, i18n) {
-  return (0, import_shared_utils.walkLocaleFallbacks)(initialLocaleId, i18n, async (localeId) => {
-    const localizedSpecifier = localeId === i18n.defaultLocale ? specifier : `${specifier}|l/${localeId}`;
-    return siteBundles.bundles[localizedSpecifier];
-  });
-}
+__exportStar(exports, __toModule(require("./tools/dedupe-bundles.cjs")));

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

@@ -30,15 +30,14 @@ 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_static_utils = __toModule(require("../utils/static-utils.cjs"));
+var import_site_metadata = __toModule(require("../site-metadata.cjs"));
 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.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;
@@ -50,32 +49,23 @@ var StaticBundleProvider = class {
       i18n: {defaultLocale}
     } = runtimeEnvironment;
     const localeId = runtimeParams?.locale || defaultLocale;
-    const siteBundles = debug && this.debugSiteBundles ? this.debugSiteBundles : this.siteBundles;
-    const metadata = await (0, import_static_utils.getLocalizedBundle)(specifier, siteBundles, localeId, this.i18n);
+    const metadata = this.getBundleMetadata(moduleId, localeId, debug);
     if (!metadata) {
       return void 0;
     }
     const bundlePath = import_path.default.join(this.siteRootDir, metadata.path);
-    const code = await this.getCode(bundlePath, debug, specifier, localeId);
-    const imports = metadata.imports.map((specifier2) => {
-      const importModule = (0, import_shared_utils.explodeSpecifier)(specifier2);
-      if (!importModule.version) {
-        importModule.version = (0, import_static_utils.resolveStaticBundleVersion)(this.siteBundles.bundles[specifier2]?.version);
-      }
-      return importModule;
-    });
-    const dynamicImports = metadata.dynamicImports?.map((specifier2) => {
-      const dynamicImportModule = (0, import_shared_utils.explodeSpecifier)(specifier2);
-      if (!dynamicImportModule.version) {
-        dynamicImportModule.version = (0, import_static_utils.resolveStaticBundleVersion)(this.siteBundles.bundles[specifier2]?.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 = (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_static_utils.resolveStaticBundleVersion)(metadata.version, version);
+    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);
+      return (0, import_shared_utils.getSpecifier)(includedModule);
+    }) || [];
     return {
       code,
       id: (0, import_shared_utils.getSpecifier)({
@@ -90,20 +80,34 @@ var StaticBundleProvider = class {
       specifier,
       config: this.bundleConfig,
       bundleRecord: {
-        includedModules: metadata.includedModules || [],
+        includedModules,
         imports,
         dynamicImports
       },
       src: bundlePath
     };
   }
-  async getCode(bundlePath, debug, specifier, localeId) {
+  getBundleMetadata(moduleId, localeId, debug) {
+    const siteBundleId = (0, import_site_metadata.getSiteBundleId)(moduleId, localeId, this.i18n);
+    return this.siteMetadata.getSiteBundlesDecisionTree().find(siteBundleId, debug);
+  }
+  getModuleReference(siteBundleIdStr, localeId, debug) {
+    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, localeId);
+      includedModule.version = (0, import_site_metadata.resolveStaticBundleVersion)(importBundleMetadata?.version);
+    } else {
+      includedModule.version = siteBundleId.variants[import_shared_utils.VERSION_SIGIL];
+    }
+    return includedModule;
+  }
+  async getCode(bundlePath, debug, specifier, version, localeId) {
     const isLambda = process.env.AWS_LAMBDA_FUNCTION_NAME !== void 0;
     let bundleSourcePath = bundlePath;
     try {
       if (debug && isLambda) {
-        const siteBundles = this.siteBundles;
-        const metadata = await (0, import_static_utils.getLocalizedBundle)(specifier, siteBundles, localeId, this.i18n);
+        const metadata = this.getBundleMetadata({specifier, version}, localeId, false);
         if (!metadata) {
           import_diagnostics.logger.warn({
             label: "static-bundle-provider",

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

@@ -29,7 +29,7 @@ __export(exports, {
 var import_diagnostics = __toModule(require("@lwrjs/diagnostics"));
 var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
 var import_path = __toModule(require("path"));
-var import_static_utils = __toModule(require("../utils/static-utils.cjs"));
+var import_site_metadata = __toModule(require("../site-metadata.cjs"));
 var StaticModuleProvider = class {
   constructor(_config, context) {
     this.name = "static-module-provider";
@@ -37,15 +37,14 @@ var StaticModuleProvider = class {
       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;
     this.fingerprintIndex = buildFingerprintsIndex(context);
   }
   async getModule(moduleId, runtimeParams) {
-    const {specifier} = moduleId;
     const localeId = runtimeParams?.locale || this.i18n.defaultLocale;
-    const metadata = await (0, import_static_utils.getLocalizedBundle)(specifier, this.siteBundles, localeId, this.i18n);
+    const metadata = this.getBundleMetadata(moduleId, localeId, false);
     if (metadata) {
       import_diagnostics.logger.warn({
         label: `${this.name}`,
@@ -58,14 +57,14 @@ var StaticModuleProvider = class {
   async getModuleEntry(moduleId, runtimeParams) {
     const {specifier, version} = moduleId;
     const localeId = runtimeParams?.locale || this.i18n.defaultLocale;
-    const metadata = await (0, import_static_utils.getLocalizedBundle)(specifier, this.siteBundles, localeId, this.i18n);
+    const metadata = this.getBundleMetadata(moduleId, localeId, false);
     if (metadata) {
       import_diagnostics.logger.debug({
         label: `${this.name}`,
         message: `Module Entry request for static bundle ${specifier}`
       });
       const bundlePath = import_path.default.join(this.siteRootDir, metadata.path);
-      const resolvedVersion = (0, import_static_utils.resolveStaticBundleVersion)(metadata.version, version);
+      const resolvedVersion = (0, import_site_metadata.resolveStaticBundleVersion)(metadata.version, version);
       return {
         id: (0, import_shared_utils.getSpecifier)({...moduleId, version: resolvedVersion}),
         version: resolvedVersion,
@@ -74,17 +73,23 @@ var StaticModuleProvider = class {
         src: bundlePath
       };
     } else if (this.externals.includes(specifier)) {
-      const resolvedVersion = (0, import_static_utils.resolveStaticBundleVersion)(void 0, version);
+      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"
       };
-    } else if (this.fingerprintIndex[specifier]) {
-      return this.fingerprintIndex[specifier];
     }
-    return void 0;
+    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) {
+    const siteBundleId = (0, import_site_metadata.getSiteBundleId)(moduleId, localeId, this.i18n);
+    return this.siteMetadata.getSiteBundlesDecisionTree().find(siteBundleId, debug);
   }
 };
 var static_module_provider_default = StaticModuleProvider;
@@ -96,11 +101,21 @@ function buildFingerprintsIndex(context) {
       const bundlePath = import_path.default.join(String(context.siteMetadata?.getSiteRootDir()), bundle.path);
       const includedModules = bundle.includedModules || [];
       for (const includedModule of includedModules) {
-        const moduleId = (0, import_shared_utils.explodeSpecifier)(includedModule);
+        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: (0, import_shared_utils.getSpecifier)(moduleId),
-            version: (0, import_static_utils.resolveStaticBundleVersion)(moduleId.version),
+            id: moduleId.specifier,
+            version: (0, import_site_metadata.resolveStaticBundleVersion)(moduleId.version),
             specifier: moduleId.specifier,
             entry: "entry-not-provided",
             src: bundlePath
@@ -111,3 +126,7 @@ function buildFingerprintsIndex(context) {
   }
   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

@@ -30,6 +30,7 @@ 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";
@@ -37,15 +38,14 @@ var StaticResourceProvider = class {
       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) {
     const {debug} = runtimeEnvironment;
-    const metadata = this.siteResources.resources[resourceIdentity.specifier];
-    const debugMetadata = this.debugSiteResources ? this.debugSiteResources.resources[resourceIdentity.specifier] : void 0;
-    if (!metadata && !debugMetadata) {
+    const metadata = this.siteMetadata.getSiteResourcesDecisionTree().find((0, import_site_metadata.getSiteResourceId)(resourceIdentity));
+    const debugMetadata = this.siteMetadata.getSiteResourcesDecisionTree().find((0, import_site_metadata.getSiteResourceId)(resourceIdentity), true);
+    if (!metadata) {
       import_diagnostics.logger.warn({
         label: `${this.name}`,
         message: `Did not find requested specifier ${resourceIdentity.specifier}`

package/build/cjs/site-metadata.cjs

@@ -24,17 +24,27 @@ var __toModule = (module2) => {
 // packages/@lwrjs/static/src/site-metadata.ts
 __markAsModule(exports);
 __export(exports, {
-  SiteMetadataImpl: () => SiteMetadataImpl
+  SITE_LOCALE_PREFIX: () => SITE_LOCALE_PREFIX,
+  SITE_VERSION_PREFIX: () => SITE_VERSION_PREFIX,
+  SiteMetadataImpl: () => SiteMetadataImpl,
+  getSiteBundleId: () => getSiteBundleId,
+  getSiteResourceId: () => getSiteResourceId,
+  parseSiteId: () => parseSiteId,
+  resolveStaticBundleVersion: () => resolveStaticBundleVersion
 });
 var import_path = __toModule(require("path"));
 var import_fs_extra = __toModule(require("fs-extra"));
 var import_diagnostics = __toModule(require("@lwrjs/diagnostics"));
+var import_decision_tree = __toModule(require("./utils/decision-tree.cjs"));
+var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
 var SITE_METADATA_PATH = ".metadata";
 var STATIC_BUNDLE_METADATA_PATH = import_path.default.join(SITE_METADATA_PATH, "/bundle-metadata.json");
 var DEBUG_STATIC_BUNDLE_METADATA_PATH = import_path.default.join(SITE_METADATA_PATH, "/bundle-metadata-debug.json");
 var STATIC_RESOURCE_METADATA_PATH = import_path.default.join(SITE_METADATA_PATH, "/resource-metadata.json");
 var DEBUG_STATIC_RESOURCE_METADATA_PATH = import_path.default.join(SITE_METADATA_PATH, "/resource-metadata-debug.json");
 var STATIC_ASSET_METADATA_PATH = import_path.default.join(SITE_METADATA_PATH, "/asset-metadata.json");
+var SITE_VERSION_PREFIX = `|${import_shared_utils.VERSION_SIGIL}/`;
+var SITE_LOCALE_PREFIX = `|${import_shared_utils.LOCALE_SIGIL}/`;
 var SiteMetadataImpl = class {
   constructor(options) {
     this.options = options;
@@ -62,6 +72,31 @@ var SiteMetadataImpl = class {
   getSiteAssets() {
     return this.siteAssets;
   }
+  getSiteBundlesDecisionTree() {
+    if (!this.bundleDecisionTree) {
+      this.bundleDecisionTree = new import_decision_tree.default();
+      const localeFallbacks = (0, import_decision_tree.createFallbackMap)(this.options.i18n);
+      for (const [key, bundle] of Object.entries(this.siteBundles.bundles)) {
+        this.bundleDecisionTree.insert(key, bundle, false, localeFallbacks);
+      }
+      for (const [key, bundle] of Object.entries(this.debugSiteBundles.bundles)) {
+        this.bundleDecisionTree.insert(key, bundle, true, localeFallbacks);
+      }
+    }
+    return this.bundleDecisionTree;
+  }
+  getSiteResourcesDecisionTree() {
+    if (!this.resourceDecisionTree) {
+      this.resourceDecisionTree = new import_decision_tree.default();
+      for (const [key, resource] of Object.entries(this.siteResources.resources)) {
+        this.resourceDecisionTree.insert(key, resource, false);
+      }
+      for (const [key, resource] of Object.entries(this.debugSiteResources.resources)) {
+        this.resourceDecisionTree.insert(key, resource, true);
+      }
+    }
+    return this.resourceDecisionTree;
+  }
   async persistSiteMetadata() {
     const siteMetadataPath = import_path.default.join(this.options.rootDir, SITE_METADATA_PATH);
     if (siteMetadataPath.indexOf("__skip_directory_creation__") !== -1)
@@ -144,3 +179,32 @@ var SiteMetadataImpl = class {
     return siteAssets;
   }
 };
+function resolveStaticBundleVersion(metadataVersion, requestedVersion) {
+  return metadataVersion || requestedVersion || import_shared_utils.VERSION_NOT_PROVIDED;
+}
+function parseSiteId(input) {
+  const parts = input.split("|");
+  const specifier = parts[0];
+  const variants = {};
+  for (let i = 1; i < parts.length; i++) {
+    const [sigil, value] = parts[i].split("/");
+    if (sigil && value) {
+      variants[sigil] = value;
+    }
+  }
+  return {
+    specifier,
+    variants
+  };
+}
+function getSiteBundleId({specifier, namespace, name = "", version}, locale, i18n) {
+  if (!specifier) {
+    specifier = namespace ? `${namespace}/${name}` : name;
+  }
+  const versionedSpecifier = version && version !== import_shared_utils.VERSION_NOT_PROVIDED ? `${specifier}${SITE_VERSION_PREFIX}${(0, import_shared_utils.normalizeVersionToUri)(version)}` : specifier;
+  return i18n?.defaultLocale === locale ? versionedSpecifier : `${versionedSpecifier}${SITE_LOCALE_PREFIX}${locale}`;
+}
+function getSiteResourceId({specifier, version}) {
+  const versionedSpecifier = version && version !== import_shared_utils.VERSION_NOT_PROVIDED ? `${specifier}${SITE_VERSION_PREFIX}${(0, import_shared_utils.normalizeVersionToUri)(version)}` : specifier;
+  return versionedSpecifier;
+}

package/build/cjs/tools/dedupe-bundles.cjs

@@ -0,0 +1,108 @@
+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/tools/dedupe-bundles.ts
+__markAsModule(exports);
+__export(exports, {
+  dedupeBundles: () => dedupeBundles
+});
+var import_fs_extra = __toModule(require("fs-extra"));
+var import_path = __toModule(require("path"));
+var import_diagnostics = __toModule(require("@lwrjs/diagnostics"));
+var import_site_metadata = __toModule(require("../site-metadata.cjs"));
+var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
+async function dedupeBundles(rootDir, i18n) {
+  const siteMetadata = new import_site_metadata.SiteMetadataImpl({
+    rootDir,
+    i18n
+  });
+  const siteBundles = siteMetadata.getSiteBundles();
+  const decisionTree = siteMetadata.getSiteBundlesDecisionTree();
+  import_diagnostics.logger.info({
+    label: `dedupeBundles`,
+    message: `Deduplicating ${Object.keys(siteBundles.bundles).length} bundles`
+  });
+  for (const [siteIdStr, metadata] of Object.entries(siteBundles.bundles)) {
+    const siteId = (0, import_site_metadata.parseSiteId)(siteIdStr);
+    const localeId = siteId.variants[import_shared_utils.LOCALE_SIGIL];
+    if (!localeId || localeId === i18n.defaultLocale) {
+      continue;
+    }
+    const currentPath = import_path.default.join(rootDir, metadata.path);
+    const currentSrc = import_fs_extra.default.readFileSync(currentPath);
+    import_diagnostics.logger.debug({
+      label: `dedupeBundles`,
+      message: `${siteIdStr} -> ${(0, import_shared_utils.hashContent)(currentSrc)}`
+    });
+    const locale = i18n.locales.find((l) => l.id === localeId);
+    const fallBackLocale = locale?.fallback ?? i18n.defaultLocale;
+    const fallbackMetadata = decisionTree.find(siteIdStr, false, fallBackLocale);
+    if (fallbackMetadata) {
+      const fallbackSrc = import_fs_extra.default.readFileSync(import_path.default.join(rootDir, fallbackMetadata.path));
+      import_diagnostics.logger.debug({
+        label: `dedupeBundles`,
+        message: `fallback ${siteIdStr},${fallBackLocale} -> ${(0, import_shared_utils.hashContent)(fallbackSrc)}`
+      });
+      if (currentSrc.equals(fallbackSrc)) {
+        import_diagnostics.logger.debug({
+          label: `dedupeBundles`,
+          message: `Remove duplicate variant ${siteIdStr}`
+        });
+        delete siteBundles.bundles[siteIdStr];
+        if (metadata.path != fallbackMetadata.path) {
+          import_fs_extra.default.removeSync(currentPath);
+        }
+      }
+    }
+  }
+  import_diagnostics.logger.info({
+    label: `dedupeBundles`,
+    message: `Deduplicated down to ${Object.keys(siteBundles.bundles).length} bundles`
+  });
+  await siteMetadata.persistSiteMetadata();
+  deleteEmptyFolders(rootDir);
+}
+function deleteEmptyFolders(directory) {
+  if (!import_fs_extra.default.existsSync(directory)) {
+    import_diagnostics.logger.warn({label: `dedupeBundles`, message: `Directory does not exist: ${directory}`});
+    return;
+  }
+  const files = import_fs_extra.default.readdirSync(directory);
+  if (files.length === 0) {
+    import_fs_extra.default.rmdirSync(directory);
+    import_diagnostics.logger.debug({label: `dedupeBundles`, message: `Deleted empty folder: ${directory}`});
+    return;
+  }
+  files.forEach((file) => {
+    const filePath = import_path.default.join(directory, file);
+    const isDirectory = import_fs_extra.default.statSync(filePath).isDirectory();
+    if (isDirectory) {
+      deleteEmptyFolders(filePath);
+    }
+  });
+  const updatedFiles = import_fs_extra.default.readdirSync(directory);
+  if (updatedFiles.length === 0) {
+    import_fs_extra.default.rmdirSync(directory);
+    import_diagnostics.logger.debug({label: `dedupeBundles`, message: `Deleted empty folder: ${directory}`});
+  }
+}

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