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

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, explodeSpecifier, getSpecifier } 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({
@@ -65,13 +53,34 @@ export default class StaticBundleProvider {
             config: this.bundleConfig,
             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,7 +90,7 @@ 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;
         // Default source code path determined from metadata based on debug mode
@@ -90,8 +99,7 @@ export default class StaticBundleProvider {
             // 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({

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,9 +1,8 @@
 import type { BootstrapRuntimeEnvironment, ProviderContext, ResourceDefinition, ResourceIdentifier, ResourceProvider } 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>;

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,17 +10,18 @@ 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) {
         const { debug } = runtimeEnvironment;
-        const metadata = this.siteResources.resources[resourceIdentity.specifier];
-        const debugMetadata = this.debugSiteResources
-            ? this.debugSiteResources.resources[resourceIdentity.specifier]
-            : undefined;
-        if (!metadata && !debugMetadata) {
+        const metadata = this.siteMetadata
+            .getSiteResourcesDecisionTree()
+            .find(getSiteResourceId(resourceIdentity));
+        const debugMetadata = this.siteMetadata
+            .getSiteResourcesDecisionTree()
+            .find(getSiteResourceId(resourceIdentity), true);
+        if (!metadata) {
             logger.warn({
                 label: `${this.name}`,
                 message: `Did not find requested specifier ${resourceIdentity.specifier}`,

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

package/build/es/site-metadata.js

@@ -1,12 +1,16 @@
 import path from 'path';
 import fs from 'fs-extra';
 import { logger } from '@lwrjs/diagnostics';
+import DecisionTree, { createFallbackMap } from './utils/decision-tree.js';
+import { LOCALE_SIGIL, VERSION_NOT_PROVIDED, VERSION_SIGIL, normalizeVersionToUri, } from '@lwrjs/shared-utils';
 const SITE_METADATA_PATH = '.metadata';
 const STATIC_BUNDLE_METADATA_PATH = path.join(SITE_METADATA_PATH, '/bundle-metadata.json');
 const DEBUG_STATIC_BUNDLE_METADATA_PATH = path.join(SITE_METADATA_PATH, '/bundle-metadata-debug.json');
 const STATIC_RESOURCE_METADATA_PATH = path.join(SITE_METADATA_PATH, '/resource-metadata.json');
 const DEBUG_STATIC_RESOURCE_METADATA_PATH = path.join(SITE_METADATA_PATH, '/resource-metadata-debug.json');
 const STATIC_ASSET_METADATA_PATH = path.join(SITE_METADATA_PATH, '/asset-metadata.json');
+export const SITE_VERSION_PREFIX = `|${VERSION_SIGIL}/`;
+export const SITE_LOCALE_PREFIX = `|${LOCALE_SIGIL}/`;
 export class SiteMetadataImpl {
     constructor(options) {
         this.options = options;
@@ -34,6 +38,44 @@ export class SiteMetadataImpl {
     getSiteAssets() {
         return this.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() {
+        if (!this.bundleDecisionTree) {
+            this.bundleDecisionTree = new DecisionTree();
+            // Normalize i18NConfig fallback paths
+            const localeFallbacks = createFallbackMap(this.options.i18n);
+            // Add All the Bundles path keys [specifier][prod][version? (version || '') : ('' || '*')][localeId || fallbacks]
+            for (const [key, bundle] of Object.entries(this.siteBundles.bundles)) {
+                this.bundleDecisionTree.insert(key, bundle, false, localeFallbacks);
+            }
+            // Add All the Bundles path keys [specifier][debug][[version? (version || '') : ('' || '*')][localeId || fallbacks]
+            for (const [key, bundle] of Object.entries(this.debugSiteBundles.bundles)) {
+                this.bundleDecisionTree.insert(key, bundle, true, localeFallbacks);
+            }
+        }
+        return this.bundleDecisionTree;
+    }
+    /**
+     * Returns a decision tree for site resources.
+     * It is assumed this is static after creation subsequent calls will return the same instance.
+     */
+    getSiteResourcesDecisionTree() {
+        if (!this.resourceDecisionTree) {
+            this.resourceDecisionTree = new DecisionTree();
+            // Add All the prod resources path keys [specifier][prod][version? (version || '') : ('' || '*')][*]
+            for (const [key, resource] of Object.entries(this.siteResources.resources)) {
+                this.resourceDecisionTree.insert(key, resource, false);
+            }
+            // Add All the debug resources path keys [specifier][debug][version? (version || '') : ('' || '*')][*]
+            for (const [key, resource] of Object.entries(this.debugSiteResources.resources)) {
+                this.resourceDecisionTree.insert(key, resource, true);
+            }
+        }
+        return this.resourceDecisionTree;
+    }
     async persistSiteMetadata() {
         // Create the metadata directory if if does not exist
         const siteMetadataPath = path.join(this.options.rootDir, SITE_METADATA_PATH);
@@ -135,4 +177,63 @@ export class SiteMetadataImpl {
         return siteAssets;
     }
 }
+/**
+ * Return the version for a static module bundle.
+ *
+ * Version defined in the metadata > Requested Version > 'version-not-provided'
+ */
+export function resolveStaticBundleVersion(metadataVersion, requestedVersion) {
+    return metadataVersion || requestedVersion || VERSION_NOT_PROVIDED;
+}
+/**
+ * Parse a site artifact ids string in the form specifier(|sigil(/value)?)*
+ */
+export function parseSiteId(input) {
+    const parts = input.split('|');
+    const specifier = parts[0];
+    const variants = {};
+    // Process each variant part after the first element
+    for (let i = 1; i < parts.length; i++) {
+        const [sigil, value] = parts[i].split('/');
+        if (sigil && value) {
+            variants[sigil] = value;
+        }
+    }
+    return {
+        specifier: specifier,
+        variants: variants,
+    };
+}
+/**
+ * Get a  Site Bundle Identifier from a Root Module
+ *
+ * @param moduleId - Root Module Id
+ * @param locale - Current locale
+ * @returns Site Bundle Identifier
+ */
+export function getSiteBundleId({ specifier, namespace, name = '', version }, locale, i18n) {
+    if (!specifier) {
+        specifier = namespace ? `${namespace}/${name}` : name;
+    }
+    // If a module has an explicit 'version-not-provided' version this will not be reflected in the specifier
+    const versionedSpecifier = version && version !== VERSION_NOT_PROVIDED
+        ? `${specifier}${SITE_VERSION_PREFIX}${normalizeVersionToUri(version)}`
+        : specifier;
+    return i18n?.defaultLocale === locale
+        ? versionedSpecifier
+        : `${versionedSpecifier}${SITE_LOCALE_PREFIX}${locale}`;
+}
+/**
+ * Get a  Site Resource Identifier from a Resource Identifier
+ *
+ * @param resourceID -Resource Identifier
+ * @returns Site Bundle Identifier
+ */
+export function getSiteResourceId({ specifier, version }) {
+    // If a module has an explicit 'version-not-provided' version this will not be reflected in the specifier
+    const versionedSpecifier = version && version !== VERSION_NOT_PROVIDED
+        ? `${specifier}${SITE_VERSION_PREFIX}${normalizeVersionToUri(version)}`
+        : specifier;
+    return versionedSpecifier;
+}
 //# sourceMappingURL=site-metadata.js.map

package/build/es/tools/dedupe-bundles.d.ts

@@ -0,0 +1,3 @@
+import type { I18NConfig } from '@lwrjs/types';
+export declare function dedupeBundles(rootDir: string, i18n: I18NConfig): Promise<void>;
+//# sourceMappingURL=dedupe-bundles.d.ts.map

package/build/es/tools/dedupe-bundles.js

@@ -0,0 +1,89 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { logger } from '@lwrjs/diagnostics';
+import { SiteMetadataImpl, parseSiteId } from '../site-metadata.js';
+import { LOCALE_SIGIL, hashContent } from '@lwrjs/shared-utils';
+export async function dedupeBundles(rootDir, i18n) {
+    const siteMetadata = new SiteMetadataImpl({
+        rootDir,
+        i18n,
+    });
+    const siteBundles = siteMetadata.getSiteBundles();
+    const decisionTree = siteMetadata.getSiteBundlesDecisionTree();
+    logger.info({
+        label: `dedupeBundles`,
+        message: `Deduplicating ${Object.keys(siteBundles.bundles).length} bundles`,
+    });
+    for (const [siteIdStr, metadata] of Object.entries(siteBundles.bundles)) {
+        const siteId = parseSiteId(siteIdStr);
+        const localeId = siteId.variants[LOCALE_SIGIL];
+        // If this is already the default locale has no fall backs skip
+        if (!localeId || localeId === i18n.defaultLocale) {
+            continue;
+        }
+        // Read the content from the current metadata
+        const currentPath = path.join(rootDir, metadata.path);
+        const currentSrc = fs.readFileSync(currentPath);
+        logger.debug({
+            label: `dedupeBundles`,
+            message: `${siteIdStr} -> ${hashContent(currentSrc)}`,
+        });
+        // Find the current locale
+        const locale = i18n.locales.find((l) => l.id === localeId);
+        const fallBackLocale = locale?.fallback ?? i18n.defaultLocale;
+        const fallbackMetadata = decisionTree.find(siteIdStr, false, fallBackLocale);
+        if (fallbackMetadata) {
+            // Read the content of the fallback metadata
+            const fallbackSrc = fs.readFileSync(path.join(rootDir, fallbackMetadata.path));
+            logger.debug({
+                label: `dedupeBundles`,
+                message: `fallback ${siteIdStr},${fallBackLocale} -> ${hashContent(fallbackSrc)}`,
+            });
+            if (currentSrc.equals(fallbackSrc)) {
+                logger.debug({
+                    label: `dedupeBundles`,
+                    message: `Remove duplicate variant ${siteIdStr}`,
+                });
+                delete siteBundles.bundles[siteIdStr];
+                // Do not remove the file if it is the same path as the fallback
+                if (metadata.path != fallbackMetadata.path) {
+                    fs.removeSync(currentPath);
+                }
+            }
+        }
+    }
+    logger.info({
+        label: `dedupeBundles`,
+        message: `Deduplicated down to ${Object.keys(siteBundles.bundles).length} bundles`,
+    });
+    // Save the updated bundle metadata
+    await siteMetadata.persistSiteMetadata();
+    // Clean up empty folders
+    deleteEmptyFolders(rootDir);
+}
+function deleteEmptyFolders(directory) {
+    if (!fs.existsSync(directory)) {
+        logger.warn({ label: `dedupeBundles`, message: `Directory does not exist: ${directory}` });
+        return;
+    }
+    const files = fs.readdirSync(directory);
+    if (files.length === 0) {
+        fs.rmdirSync(directory);
+        logger.debug({ label: `dedupeBundles`, message: `Deleted empty folder: ${directory}` });
+        return;
+    }
+    files.forEach((file) => {
+        const filePath = path.join(directory, file);
+        const isDirectory = fs.statSync(filePath).isDirectory();
+        if (isDirectory) {
+            deleteEmptyFolders(filePath);
+        }
+    });
+    // Check if the directory is empty after deleting its subdirectories
+    const updatedFiles = fs.readdirSync(directory);
+    if (updatedFiles.length === 0) {
+        fs.rmdirSync(directory);
+        logger.debug({ label: `dedupeBundles`, message: `Deleted empty folder: ${directory}` });
+    }
+}
+//# sourceMappingURL=dedupe-bundles.js.map

package/build/es/utils/decision-tree.d.ts

@@ -0,0 +1,29 @@
+import type { DecisionTree, I18NConfig, SiteArtifact } from '@lwrjs/types';
+export interface ArtifactVariantId {
+    specifier: string;
+    version?: string;
+    localeId?: string;
+    debug?: boolean;
+}
+export default class DecisionTreeImpl<Artifact extends SiteArtifact> implements DecisionTree<Artifact> {
+    private root;
+    insert(siteArtifactId: string, artifact: Artifact, debug?: boolean, localeFallbacks?: Record<string, string[]>): void;
+    /**
+     * A method to handle deeper insertions, preserving the unique paths.
+     * This will be called for each node in the decision path.
+     */
+    private deepInsert;
+    find(siteArtifactId: string, debug?: boolean, localeId?: string): Artifact | undefined;
+    /**
+     * Create a decision tree patch to look up the most appropriate bundle
+     *
+     * @param specifier Bundle specifier
+     * @param version known version or will add the choice ''
+     * @param localeId preferred bundle locale or will add '' for default locale
+     * @param debug flag if debug bundle is preferred
+     */
+    private createArtifactChoices;
+    private createPossibleArtifactChoices;
+}
+export declare function createFallbackMap(config: I18NConfig): Record<string, string[]>;
+//# sourceMappingURL=decision-tree.d.ts.map