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

package/build/cjs/site-metadata.cjs

@@ -0,0 +1,215 @@
+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/site-metadata.ts
+__markAsModule(exports);
+__export(exports, {
+  SITE_LOCALE_PREFIX: () => SITE_LOCALE_PREFIX,
+  SITE_SSR_PREFIX: () => SITE_SSR_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 SITE_SSR_PREFIX = `|${import_shared_utils.SSR_SIGIL}`;
+var SiteMetadataImpl = class {
+  constructor(options) {
+    this.options = options;
+    this.siteBundles = this.readStaticBundleMetadata(options.rootDir, STATIC_BUNDLE_METADATA_PATH);
+    this.debugSiteBundles = this.readStaticBundleMetadata(options.rootDir, DEBUG_STATIC_BUNDLE_METADATA_PATH);
+    this.siteResources = this.readStaticResourceMetadata(options.rootDir, STATIC_RESOURCE_METADATA_PATH);
+    this.debugSiteResources = this.readStaticResourceMetadata(options.rootDir, DEBUG_STATIC_RESOURCE_METADATA_PATH);
+    this.siteAssets = this.readStaticAssetsMetadata(options.rootDir, STATIC_ASSET_METADATA_PATH);
+  }
+  getSiteRootDir() {
+    return this.options.rootDir;
+  }
+  getSiteBundles() {
+    return this.siteBundles;
+  }
+  getDebugSiteBundles() {
+    return this.debugSiteBundles;
+  }
+  getSiteResources() {
+    return this.siteResources;
+  }
+  getDebugSiteResources() {
+    return this.debugSiteResources;
+  }
+  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)
+      return;
+    try {
+      if (!import_fs_extra.default.existsSync(siteMetadataPath)) {
+        await import_fs_extra.default.mkdir(siteMetadataPath, {recursive: true});
+      }
+      const bundleMetadataPath = import_path.default.join(this.options.rootDir, STATIC_BUNDLE_METADATA_PATH);
+      await import_fs_extra.default.writeJSON(bundleMetadataPath, this.siteBundles, {spaces: 2});
+      const debugBundleMetadataPath = import_path.default.join(this.options.rootDir, DEBUG_STATIC_BUNDLE_METADATA_PATH);
+      await import_fs_extra.default.writeJSON(debugBundleMetadataPath, this.debugSiteBundles, {spaces: 2});
+      const resourceMetadataPath = import_path.default.join(this.options.rootDir, STATIC_RESOURCE_METADATA_PATH);
+      await import_fs_extra.default.writeJSON(resourceMetadataPath, this.siteResources, {spaces: 2});
+      const debugResourceMetadataPath = import_path.default.join(this.options.rootDir, DEBUG_STATIC_RESOURCE_METADATA_PATH);
+      await import_fs_extra.default.writeJSON(debugResourceMetadataPath, this.debugSiteResources, {spaces: 2});
+      const assetMetadataPath = import_path.default.join(this.options.rootDir, STATIC_ASSET_METADATA_PATH);
+      return import_fs_extra.default.writeJSON(assetMetadataPath, this.siteAssets, {spaces: 2});
+    } catch (err) {
+      import_diagnostics.logger.error(`[SiteMetadata] Failed to save site metadata ${siteMetadataPath}`);
+      import_diagnostics.logger.error(err);
+    }
+  }
+  readStaticBundleMetadata(staticRoot, metadataPath) {
+    let bundleMetadataPath;
+    let siteBundles = {bundles: {}};
+    try {
+      bundleMetadataPath = import_path.default.join(staticRoot, metadataPath);
+      const savedMetadata = import_fs_extra.default.readJSONSync(bundleMetadataPath);
+      siteBundles = savedMetadata;
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        import_diagnostics.logger.debug({
+          label: `SiteMetadata`,
+          message: `Failed to load Static Bundle Metadata: ${bundleMetadataPath}`
+        });
+      } else {
+        throw error;
+      }
+    }
+    return siteBundles;
+  }
+  readStaticResourceMetadata(staticRoot, metadataPath) {
+    let resourceMetadataPath;
+    let siteResources = {resources: {}};
+    try {
+      resourceMetadataPath = import_path.default.join(staticRoot, metadataPath);
+      const savedMetadata = import_fs_extra.default.readJSONSync(resourceMetadataPath);
+      siteResources = savedMetadata;
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        import_diagnostics.logger.debug({
+          label: `SiteMetadata`,
+          message: `Failed to load Static Resource Metadata: ${resourceMetadataPath}`
+        });
+      } else {
+        throw error;
+      }
+    }
+    return siteResources;
+  }
+  readStaticAssetsMetadata(staticRoot, metadataPath) {
+    let assetMetadataPath;
+    let siteAssets = {
+      assets: {}
+    };
+    try {
+      assetMetadataPath = import_path.default.join(staticRoot, metadataPath);
+      siteAssets = import_fs_extra.default.readJSONSync(assetMetadataPath);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        import_diagnostics.logger.debug({
+          label: `SiteMetadata`,
+          message: `Failed to load Static Resource Metadata: ${assetMetadataPath}`
+        });
+      } else {
+        throw error;
+      }
+    }
+    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;
+    } else if (sigil) {
+      variants[sigil] = "true";
+    }
+  }
+  return {
+    specifier,
+    variants
+  };
+}
+function getSiteBundleId({specifier, namespace, name = "", version}, locale, ssr, 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;
+  const ssrSpecifier = ssr ? `${versionedSpecifier}${SITE_SSR_PREFIX}` : versionedSpecifier;
+  return i18n?.defaultLocale === locale ? ssrSpecifier : `${ssrSpecifier}${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 = (0, import_shared_utils.joinUrlPath)(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, false, fallBackLocale);
+    if (fallbackMetadata) {
+      const fallbackSrc = import_fs_extra.default.readFileSync((0, import_shared_utils.joinUrlPath)(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/transformers/mrt-static-uri-transformer.cjs

@@ -0,0 +1,62 @@
+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/transformers/mrt-static-uri-transformer.ts
+__markAsModule(exports);
+__export(exports, {
+  default: () => mrtStaticUriTransformer
+});
+var import_diagnostics = __toModule(require("@lwrjs/diagnostics"));
+var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
+function mrtStaticUriTransformer() {
+  return {
+    name: "mrt-static-uri-transformer",
+    async transformUri(uriDef, _def, runtimeEnvironment) {
+      if (uriDef.artifactType === "asset" && runtimeEnvironment?.featureFlags?.ASSETS_ON_LAMBDA) {
+        import_diagnostics.logger.debug({
+          label: `${this.name}`,
+          message: `uri not transformed ${uriDef.entry} -> ${uriDef.uri}`
+        });
+        return {
+          ...uriDef,
+          external: false
+        };
+      }
+      let basePathlessUri = uriDef.uri;
+      if (runtimeEnvironment?.basePath && uriDef.uri.startsWith(runtimeEnvironment?.basePath)) {
+        basePathlessUri = uriDef.uri.replace(runtimeEnvironment?.basePath, "");
+      }
+      const uri = (0, import_shared_utils.getMrtArtifactUrl)(runtimeEnvironment?.basePath || "", basePathlessUri);
+      import_diagnostics.logger.debug({
+        label: `${this.name}`,
+        message: `normalized ${uriDef.artifactType} url ${uriDef.entry} -> ${uri}`
+      });
+      return {
+        ...uriDef,
+        uri,
+        immutable: true,
+        external: true
+      };
+    }
+  };
+}

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

@@ -0,0 +1,209 @@
+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_TRUE = "true";
+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, ssr, localeId) {
+    const parsedArtifactId = (0, import_site_metadata.parseSiteId)(siteArtifactId);
+    const decisionPath = this.createArtifactChoices({
+      specifier: parsedArtifactId.specifier,
+      version: parsedArtifactId.variants[import_shared_utils.VERSION_SIGIL],
+      ssr: ssr ?? import_shared_utils.SSR_SIGIL in parsedArtifactId.variants,
+      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, ssr}) {
+    const envChoice = debug ? CHOICE_DEBUG : CHOICE_PROD;
+    const versionChoice = getVersionChoice(version);
+    const uriVersion = (0, import_shared_utils.normalizeVersionToUri)(versionChoice);
+    const ssrChoice = ssr ? CHOICE_TRUE : CHOICE_EMPTY;
+    return this.getOrderedChoices(specifier, envChoice, ssrChoice, uriVersion, localeId);
+  }
+  getOrderedChoices(specifier, envChoice, ssrChoice, uriVersion, localeId) {
+    return [specifier, envChoice, ssrChoice, 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 ssrChoice = match.variants[import_shared_utils.SSR_SIGIL] || CHOICE_EMPTY;
+    const ssr = (0, import_shared_utils.getFeatureFlags)().SSR_COMPILER_ENABLED ? [ssrChoice] : match.variants[import_shared_utils.SSR_SIGIL] ? [CHOICE_TRUE, CHOICE_EMPTY] : [CHOICE_EMPTY, CHOICE_TRUE];
+    const localeChoice = match.variants[import_shared_utils.LOCALE_SIGIL];
+    const localeId = localeFallbacks?.[localeChoice] ?? [CHOICE_WILDCARD];
+    return this.getOrderedChoices([specifier], envChoice, ssr, 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-asset-provider.d.ts

@@ -0,0 +1,16 @@
+import type { AssetIdentifier, AssetProvider, AssetSource, ProviderContext, ResourcePaths } from '@lwrjs/types';
+export default class StaticAssetProvider implements AssetProvider {
+    name: string;
+    siteAssets: import("@lwrjs/types").SiteAssets;
+    resourcePaths: ResourcePaths;
+    siteRootDir: string;
+    basePath: string;
+    assetsOnLambda: boolean;
+    constructor(_config: {}, context: ProviderContext);
+    getAsset(assetIdentifier: AssetIdentifier): Promise<AssetSource | undefined>;
+    /**
+     * Replaces and aliased resource paths (i.e. $assetDir with a qualified specifier)
+     */
+    private normalizeSpecifier;
+}
+//# sourceMappingURL=static-asset-provider.d.ts.map