@lwrjs/static 0.10.0-alpha.13

package/LICENSE

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

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

@@ -0,0 +1,96 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __markAsModule = (target) => __defProp(target, "__esModule", {value: true});
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {get: all[name], enumerable: true});
+};
+var __exportStar = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, {get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable});
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __exportStar(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? {get: () => module2.default, enumerable: true} : {value: module2, enumerable: true})), module2);
+};
+
+// packages/@lwrjs/static/src/providers/static-asset-provider.ts
+__markAsModule(exports);
+__export(exports, {
+  default: () => static_asset_provider_default
+});
+var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
+var import_path = __toModule(require("path"));
+var import_fs_extra = __toModule(require("fs-extra"));
+var StaticAssetProvider = class {
+  constructor(_config, context) {
+    this.name = "static-asset-provider";
+    if (!context.siteMetadata) {
+      throw new Error(`[${this.name}] Site metadata was not found`);
+    }
+    const {assets, rootDir, layoutsDir, contentDir} = context.config;
+    this.siteAssets = context.siteMetadata.getSiteAssets();
+    this.siteRootDir = context.siteMetadata.getSiteRootDir();
+    this.basePath = context.runtimeEnvironment.basePath;
+    this.assetsOnLambda = !!context.runtimeEnvironment.featureFlags?.ASSETS_ON_LAMBDA;
+    const ssgAssets = Array.from(assets, (asset) => {
+      if (asset.dir) {
+        return {
+          ...asset,
+          dir: asset.urlPath
+        };
+      }
+      return asset;
+    });
+    this.resourcePaths = {assets: ssgAssets, rootDir, layoutsDir, contentDir};
+  }
+  async getAsset(assetIdentifier) {
+    const fileAssetPath = this.normalizeSpecifier(assetIdentifier, this.resourcePaths);
+    const metadata = this.siteAssets.assets[fileAssetPath];
+    if (!metadata) {
+      import_shared_utils.logger.warn(`[${this.name}] Did not find requested specifier ${fileAssetPath}`);
+      return void 0;
+    }
+    const siteAssetPath = import_path.default.join(this.siteRootDir, metadata.path);
+    const mime = metadata.mimeType || (0, import_shared_utils.mimeLookup)(siteAssetPath);
+    const ext = import_path.default.extname(`x.${siteAssetPath}`).toLowerCase().substring(1);
+    const type = this.assetsOnLambda ? "asset" : "external";
+    const content = this.assetsOnLambda ? function(encoding) {
+      return import_fs_extra.default.readFileSync(siteAssetPath, encoding);
+    } : () => {
+      throw Error(`[${this.name}] Asset is not on lambda ${siteAssetPath}`);
+    };
+    const uri = this.assetsOnLambda ? fileAssetPath : import_path.default.join(this.siteRootDir, fileAssetPath);
+    import_shared_utils.logger.debug(`[${this.name}] uri ${assetIdentifier.specifier} -> ${uri}`);
+    return {
+      entry: siteAssetPath,
+      ext,
+      mime,
+      ownHash: (0, import_shared_utils.hashContent)(metadata.path),
+      content,
+      uri,
+      type,
+      noTransform: true
+    };
+  }
+  normalizeSpecifier(assetId, resourcePaths) {
+    const {specifier} = assetId;
+    let normalizedSpecifier = specifier;
+    if (normalizedSpecifier.includes("?")) {
+      import_shared_utils.logger.debug(`[${this.name}] Removed query param from asset specifier: ${specifier}`);
+      normalizedSpecifier = normalizedSpecifier.split("?")[0];
+    }
+    if (normalizedSpecifier[0] === "$") {
+      return (0, import_shared_utils.normalizeResourcePath)(normalizedSpecifier, resourcePaths);
+    }
+    return normalizedSpecifier;
+  }
+};
+var static_asset_provider_default = StaticAssetProvider;

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

@@ -0,0 +1,85 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __markAsModule = (target) => __defProp(target, "__esModule", {value: true});
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {get: all[name], enumerable: true});
+};
+var __exportStar = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, {get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable});
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __exportStar(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? {get: () => module2.default, enumerable: true} : {value: module2, enumerable: true})), module2);
+};
+
+// packages/@lwrjs/static/src/providers/static-bundle-provider.ts
+__markAsModule(exports);
+__export(exports, {
+  default: () => static_bundle_provider_default
+});
+var import_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"));
+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.siteRootDir = context.siteMetadata.getSiteRootDir();
+    this.bundleConfig = context.config.bundleConfig;
+  }
+  async bundle(moduleId, runtimeEnvironment) {
+    const {specifier, name, namespace, version} = moduleId;
+    const metadata = this.siteBundles.bundles[specifier];
+    if (!metadata) {
+      import_shared_utils.logger.warn(`[${this.name}] did not find requested specifier ${specifier}`);
+      return void 0;
+    }
+    const bundlePath = import_path.default.join(this.siteRootDir, metadata.path);
+    const code = (await import_fs_extra.default.readFile(bundlePath)).toString("utf-8");
+    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 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);
+    return {
+      code,
+      id: (0, import_shared_utils.getSpecifier)({
+        specifier,
+        version: resolvedVersion,
+        name: resolvedName,
+        namespace: resolvedNamespace
+      }),
+      name: resolvedName,
+      namespace: resolvedNamespace,
+      version: resolvedVersion,
+      specifier,
+      config: this.bundleConfig,
+      bundleRecord: {
+        includedModules: metadata.includedModules || [],
+        imports
+      },
+      src: bundlePath
+    };
+  }
+};
+var static_bundle_provider_default = StaticBundleProvider;

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

@@ -0,0 +1,103 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __markAsModule = (target) => __defProp(target, "__esModule", {value: true});
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {get: all[name], enumerable: true});
+};
+var __exportStar = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, {get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable});
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __exportStar(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? {get: () => module2.default, enumerable: true} : {value: module2, enumerable: true})), module2);
+};
+
+// packages/@lwrjs/static/src/providers/static-module-provider.ts
+__markAsModule(exports);
+__export(exports, {
+  default: () => static_module_provider_default
+});
+var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
+var import_path = __toModule(require("path"));
+var import_static_utils = __toModule(require("../utils/static-utils"));
+var StaticModuleProvider = class {
+  constructor(_config, context) {
+    this.name = "static-module-provider";
+    if (!context.siteMetadata) {
+      throw new Error(`[${this.name}] Site metadata was not found`);
+    }
+    this.externals = Object.keys(context.config.bundleConfig.external || {});
+    this.siteBundles = context.siteMetadata.getSiteBundles();
+    this.siteRootDir = context.siteMetadata.getSiteRootDir();
+    this.fingerprintIndex = buildFingerprintsIndex(context);
+  }
+  async getModule(moduleId) {
+    const {specifier} = moduleId;
+    const metadata = this.siteBundles.bundles[specifier];
+    if (metadata) {
+      import_shared_utils.logger.warn(`[${this.name}] We should not be asking for module source we have in our site metadata ${moduleId.specifier}`);
+      return void 0;
+    }
+    return void 0;
+  }
+  async getModuleEntry(moduleId) {
+    const {specifier, version} = moduleId;
+    const metadata = this.siteBundles.bundles[specifier];
+    if (metadata) {
+      import_shared_utils.logger.info(`[${this.name}] 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);
+      return {
+        id: (0, import_shared_utils.getSpecifier)({...moduleId, version: resolvedVersion}),
+        version: resolvedVersion,
+        specifier,
+        entry: "entry-not-provided",
+        src: bundlePath
+      };
+    } else if (this.externals.includes(specifier)) {
+      const resolvedVersion = (0, import_static_utils.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;
+  }
+};
+var static_module_provider_default = StaticModuleProvider;
+function buildFingerprintsIndex(context) {
+  const fingerprintIndex = {};
+  if (!context.runtimeEnvironment.featureFlags.LEGACY_LOADER) {
+    const bundles = context.siteMetadata?.getSiteBundles().bundles || {};
+    for (const bundle of Object.values(bundles)) {
+      const bundlePath = 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);
+        if (!fingerprintIndex[moduleId.specifier]) {
+          fingerprintIndex[moduleId.specifier] = {
+            id: (0, import_shared_utils.getSpecifier)(moduleId),
+            version: (0, import_static_utils.resolveStaticBundleVersion)(moduleId.version),
+            specifier: moduleId.specifier,
+            entry: "entry-not-provided",
+            src: bundlePath
+          };
+        }
+      }
+    }
+  }
+  return fingerprintIndex;
+}

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

@@ -0,0 +1,60 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __markAsModule = (target) => __defProp(target, "__esModule", {value: true});
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {get: all[name], enumerable: true});
+};
+var __exportStar = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, {get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable});
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __exportStar(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? {get: () => module2.default, enumerable: true} : {value: module2, enumerable: true})), module2);
+};
+
+// packages/@lwrjs/static/src/providers/static-resource-provider.ts
+__markAsModule(exports);
+__export(exports, {
+  default: () => static_resource_provider_default
+});
+var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
+var import_path = __toModule(require("path"));
+var import_fs_extra = __toModule(require("fs-extra"));
+var StaticResourceProvider = class {
+  constructor(_config, context) {
+    this.name = "static-resource-provider";
+    if (!context.siteMetadata) {
+      throw new Error(`[${this.name}] Site metadata was not found`);
+    }
+    this.resourceRegistry = context.resourceRegistry;
+    this.siteResources = context.siteMetadata.getSiteResources();
+    this.siteRootDir = context.siteMetadata.getSiteRootDir();
+  }
+  async getResource(resourceIdentity, runtimeEnvironment) {
+    const metadata = this.siteResources.resources[resourceIdentity.specifier];
+    if (!metadata) {
+      import_shared_utils.logger.warn(`[${this.name}] Did not find requested specifier ${resourceIdentity.specifier}`);
+      return void 0;
+    }
+    const resourcePath = import_path.default.join(this.siteRootDir, metadata.path);
+    const type = metadata.mimeType || (0, import_shared_utils.mimeLookup)(resourcePath) || "application/javascript";
+    return {
+      type,
+      stream: () => {
+        import_shared_utils.logger.info(`[${this.name}] Resource read from lambda ${resourceIdentity.specifier}`);
+        return import_fs_extra.default.createReadStream(resourcePath);
+      },
+      src: resourcePath
+    };
+  }
+};
+var static_resource_provider_default = StaticResourceProvider;

package/build/cjs/site-metadata.cjs

@@ -0,0 +1,121 @@
+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, {
+  SiteMetadataImpl: () => SiteMetadataImpl
+});
+var import_path = __toModule(require("path"));
+var import_fs_extra = __toModule(require("fs-extra"));
+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 STATIC_RESOURCE_METADATA_PATH = import_path.default.join(SITE_METADATA_PATH, "/resource-metadata.json");
+var STATIC_ASSET_METADATA_PATH = import_path.default.join(SITE_METADATA_PATH, "/asset-metadata.json");
+var SiteMetadataImpl = class {
+  constructor(options) {
+    this.options = options;
+    this.siteBundles = this.readStaticBundleMetadata(options.rootDir);
+    this.siteResources = this.readStaticResourceMetadata(options.rootDir);
+    this.siteAssets = this.readStaticAssetsMetadata(options.rootDir);
+  }
+  getSiteRootDir() {
+    return this.options.rootDir;
+  }
+  getSiteBundles() {
+    return this.siteBundles;
+  }
+  getSiteResources() {
+    return this.siteResources;
+  }
+  getSiteAssets() {
+    return this.siteAssets;
+  }
+  async persistSiteMetadata() {
+    const siteMetadataPath = import_path.default.join(this.options.rootDir, SITE_METADATA_PATH);
+    try {
+      if (!await import_fs_extra.default.pathExists(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 resourceMetadataPath = import_path.default.join(this.options.rootDir, STATIC_RESOURCE_METADATA_PATH);
+      await import_fs_extra.default.writeJSON(resourceMetadataPath, this.siteResources, {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) {
+      console.error(`[SiteMetadata] Failed to save site metadata ${siteMetadataPath}`);
+      console.error(err);
+    }
+  }
+  readStaticBundleMetadata(staticRoot) {
+    let bundleMetadataPath;
+    let siteBundles = {bundles: {}};
+    try {
+      bundleMetadataPath = import_path.default.join(staticRoot, STATIC_BUNDLE_METADATA_PATH);
+      const savedMetadata = import_fs_extra.default.readJSONSync(bundleMetadataPath);
+      siteBundles = savedMetadata;
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        import_shared_utils.logger.debug(`[SiteMetadata] Failed to load Static Bundle Metadata: ${bundleMetadataPath}`);
+      } else {
+        throw error;
+      }
+    }
+    return siteBundles;
+  }
+  readStaticResourceMetadata(staticRoot) {
+    let resourceMetadataPath;
+    let siteResources = {resources: {}};
+    try {
+      resourceMetadataPath = import_path.default.join(staticRoot, STATIC_RESOURCE_METADATA_PATH);
+      const savedMetadata = import_fs_extra.default.readJSONSync(resourceMetadataPath);
+      siteResources = savedMetadata;
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        import_shared_utils.logger.debug(`[SiteMetadata] Failed to load Static Resource Metadata: ${resourceMetadataPath}`);
+      } else {
+        throw error;
+      }
+    }
+    return siteResources;
+  }
+  readStaticAssetsMetadata(staticRoot) {
+    let assetMetadataPath;
+    let siteAssets = {
+      assets: {}
+    };
+    try {
+      assetMetadataPath = import_path.default.join(staticRoot, STATIC_ASSET_METADATA_PATH);
+      siteAssets = import_fs_extra.default.readJSONSync(assetMetadataPath);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        import_shared_utils.logger.debug(`[SiteMetadata] Failed to load Static Resource Metadata: ${assetMetadataPath}`);
+      } else {
+        throw error;
+      }
+    }
+    return siteAssets;
+  }
+};

package/build/cjs/utils/static-utils.cjs

@@ -0,0 +1,32 @@
+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/static-utils.ts
+__markAsModule(exports);
+__export(exports, {
+  resolveStaticBundleVersion: () => resolveStaticBundleVersion
+});
+var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
+function resolveStaticBundleVersion(metadataVersion, requestedVersion) {
+  return metadataVersion || requestedVersion || import_shared_utils.VERSION_NOT_PROVIDED;
+}

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

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

@@ -0,0 +1,83 @@
+import { hashContent, logger, mimeLookup, normalizeResourcePath } from '@lwrjs/shared-utils';
+import path from 'path';
+import fs from 'fs-extra';
+export default class StaticAssetProvider {
+    constructor(_config, context) {
+        this.name = 'static-asset-provider';
+        if (!context.siteMetadata) {
+            throw new Error(`[${this.name}] Site metadata was not found`);
+        }
+        const { assets, rootDir, layoutsDir, contentDir } = context.config;
+        this.siteAssets = context.siteMetadata.getSiteAssets();
+        this.siteRootDir = context.siteMetadata.getSiteRootDir();
+        this.basePath = context.runtimeEnvironment.basePath;
+        this.assetsOnLambda = !!context.runtimeEnvironment.featureFlags?.ASSETS_ON_LAMBDA;
+        // Adjust the assets directories to be rooted in ssg folder.
+        const ssgAssets = Array.from(assets, (asset) => {
+            if (asset.dir) {
+                // Return the URI as the dir where it will be relative to the ssg root
+                return {
+                    ...asset,
+                    dir: asset.urlPath,
+                };
+            }
+            return asset;
+        });
+        this.resourcePaths = { assets: ssgAssets, rootDir, layoutsDir, contentDir };
+    }
+    async getAsset(assetIdentifier) {
+        // Set all the asset path to resolve to the ssg root
+        const fileAssetPath = this.normalizeSpecifier(assetIdentifier, this.resourcePaths);
+        const metadata = this.siteAssets.assets[fileAssetPath];
+        if (!metadata) {
+            logger.warn(`[${this.name}] Did not find requested specifier ${fileAssetPath}`);
+            return undefined;
+        }
+        // FS path including ssg root
+        const siteAssetPath = path.join(this.siteRootDir, metadata.path);
+        // Figure out mime type
+        const mime = metadata.mimeType || mimeLookup(siteAssetPath);
+        // Normalize extension
+        const ext = path.extname(`x.${siteAssetPath}`).toLowerCase().substring(1);
+        // Unless assets on lambda feature flag is set indicate the asset source is external
+        const type = this.assetsOnLambda ? 'asset' : 'external';
+        const content = this.assetsOnLambda
+            ? function (encoding) {
+                return fs.readFileSync(siteAssetPath, encoding);
+            }
+            : () => {
+                throw Error(`[${this.name}] Asset is not on lambda ${siteAssetPath}`);
+            };
+        const uri = this.assetsOnLambda ? fileAssetPath : path.join(this.siteRootDir, fileAssetPath);
+        logger.debug(`[${this.name}] uri ${assetIdentifier.specifier} -> ${uri}`);
+        return {
+            entry: siteAssetPath,
+            ext,
+            mime,
+            ownHash: hashContent(metadata.path),
+            content,
+            uri,
+            // Type: external triggers a 302 when requested form the asset middleware.
+            type,
+            noTransform: true,
+        };
+    }
+    /**
+     * Replaces and aliased resource paths (i.e. $assetDir with a qualified specifier)
+     */
+    normalizeSpecifier(assetId, resourcePaths) {
+        const { specifier } = assetId;
+        // Remove query params from specifiers (i.e. /assets/styles/styles.css?e368d71b59)
+        let normalizedSpecifier = specifier;
+        if (normalizedSpecifier.includes('?')) {
+            logger.debug(`[${this.name}] Removed query param from asset specifier: ${specifier}`);
+            normalizedSpecifier = normalizedSpecifier.split('?')[0];
+        }
+        if (normalizedSpecifier[0] === '$') {
+            // This is a fs path containing an asset alias
+            return normalizeResourcePath(normalizedSpecifier, resourcePaths);
+        }
+        return normalizedSpecifier;
+    }
+}
+//# sourceMappingURL=static-asset-provider.js.map

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

@@ -0,0 +1,10 @@
+import type { AbstractModuleId, BundleDefinition, BundleProvider, ProviderContext, RuntimeEnvironment } from '@lwrjs/types';
+export default class StaticBundleProvider implements BundleProvider {
+    name: string;
+    siteBundles: import("@lwrjs/types").SiteBundles;
+    siteRootDir: string;
+    bundleConfig: import("@lwrjs/types").BundleConfig;
+    constructor(_config: {}, context: ProviderContext);
+    bundle<BundleIdentifier extends AbstractModuleId, RE extends RuntimeEnvironment>(moduleId: BundleIdentifier, runtimeEnvironment: RE): Promise<BundleDefinition | undefined>;
+}
+//# sourceMappingURL=static-bundle-provider.d.ts.map

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

@@ -0,0 +1,61 @@
+import { explodeSpecifier, getSpecifier, logger } from '@lwrjs/shared-utils';
+import path from 'path';
+import fs from 'fs-extra';
+import { resolveStaticBundleVersion } from '../utils/static-utils';
+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.siteRootDir = context.siteMetadata.getSiteRootDir();
+        this.bundleConfig = context.config.bundleConfig;
+    }
+    async bundle(moduleId, runtimeEnvironment) {
+        const { specifier, name, namespace, version } = moduleId;
+        const metadata = this.siteBundles.bundles[specifier];
+        if (!metadata) {
+            logger.warn(`[${this.name}] did not find requested specifier ${specifier}`);
+            return undefined;
+        }
+        // Have to make the bundle code available for SSR
+        const bundlePath = path.join(this.siteRootDir, metadata.path);
+        const code = (await fs.readFile(bundlePath)).toString('utf-8');
+        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 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 resolvedVersion = resolveStaticBundleVersion(metadata.version, version);
+        return {
+            code,
+            id: getSpecifier({
+                specifier: specifier,
+                version: resolvedVersion,
+                name: resolvedName,
+                namespace: resolvedNamespace,
+            }),
+            name: resolvedName,
+            namespace: resolvedNamespace,
+            version: resolvedVersion,
+            specifier: specifier,
+            config: this.bundleConfig,
+            bundleRecord: {
+                // TODO we need to solve include modules for fingerprints support
+                includedModules: metadata.includedModules || [],
+                imports,
+            },
+            src: bundlePath,
+        };
+    }
+}
+//# sourceMappingURL=static-bundle-provider.js.map

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

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

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

@@ -0,0 +1,88 @@
+import { explodeSpecifier, getSpecifier, logger } from '@lwrjs/shared-utils';
+import path from 'path';
+import { resolveStaticBundleVersion } from '../utils/static-utils';
+export default class StaticModuleProvider {
+    constructor(_config, context) {
+        this.name = 'static-module-provider';
+        if (!context.siteMetadata) {
+            throw new Error(`[${this.name}] Site metadata was not found`);
+        }
+        this.externals = Object.keys(context.config.bundleConfig.external || {});
+        this.siteBundles = context.siteMetadata.getSiteBundles();
+        this.siteRootDir = context.siteMetadata.getSiteRootDir();
+        // 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) {
+        const { specifier } = moduleId;
+        const metadata = this.siteBundles.bundles[specifier];
+        if (metadata) {
+            logger.warn(`[${this.name}] We should not be asking for module source we have in our site metadata ${moduleId.specifier}`);
+            // proceed to next provider
+            return undefined;
+        }
+        // proceed to next provider
+        return undefined;
+    }
+    async getModuleEntry(moduleId) {
+        // TODO shouldn't we be passing the runtime environment here to test?
+        const { specifier, version } = moduleId;
+        const metadata = this.siteBundles.bundles[specifier];
+        if (metadata) {
+            logger.info(`[${this.name}] Module Entry request for static bundle ${specifier}`);
+            // Have to make the bundle code available for SSR
+            const bundlePath = path.join(this.siteRootDir, metadata.path);
+            const resolvedVersion = resolveStaticBundleVersion(metadata.version, version);
+            return {
+                id: getSpecifier({ ...moduleId, version: resolvedVersion }),
+                version: resolvedVersion,
+                specifier: specifier,
+                entry: 'entry-not-provided',
+                src: bundlePath,
+            };
+        }
+        else if (this.externals.includes(specifier)) {
+            // Externals are not SSG'ed so hard coding definition
+            const resolvedVersion = resolveStaticBundleVersion(undefined, version);
+            return {
+                id: getSpecifier({ ...moduleId, version: resolvedVersion }),
+                version: resolvedVersion,
+                specifier: specifier,
+                entry: 'entry-not-provided',
+            };
+        }
+        else if (this.fingerprintIndex[specifier]) {
+            return this.fingerprintIndex[specifier];
+        }
+        // proceed to next provider
+        return undefined;
+    }
+}
+/**
+ * Map each of the includedModules for a bundle to the bundle src
+ * This enables lookup of modules which are not top-level in the bundle metadata
+ */
+function buildFingerprintsIndex(context) {
+    const fingerprintIndex = {};
+    if (!context.runtimeEnvironment.featureFlags.LEGACY_LOADER) {
+        const bundles = context.siteMetadata?.getSiteBundles().bundles || {};
+        for (const bundle of Object.values(bundles)) {
+            const bundlePath = path.join(String(context.siteMetadata?.getSiteRootDir()), bundle.path);
+            const includedModules = bundle.includedModules || [];
+            for (const includedModule of includedModules) {
+                const moduleId = explodeSpecifier(includedModule);
+                if (!fingerprintIndex[moduleId.specifier]) {
+                    fingerprintIndex[moduleId.specifier] = {
+                        id: getSpecifier(moduleId),
+                        version: resolveStaticBundleVersion(moduleId.version),
+                        specifier: moduleId.specifier,
+                        entry: 'entry-not-provided',
+                        src: bundlePath,
+                    };
+                }
+            }
+        }
+    }
+    return fingerprintIndex;
+}
+//# sourceMappingURL=static-module-provider.js.map

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

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

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

@@ -0,0 +1,34 @@
+import { logger, mimeLookup } from '@lwrjs/shared-utils';
+import path from 'path';
+import fs from 'fs-extra';
+export default class StaticResourceProvider {
+    constructor(_config, context) {
+        this.name = 'static-resource-provider';
+        if (!context.siteMetadata) {
+            throw new Error(`[${this.name}] Site metadata was not found`);
+        }
+        this.resourceRegistry = context.resourceRegistry;
+        this.siteResources = context.siteMetadata.getSiteResources();
+        this.siteRootDir = context.siteMetadata.getSiteRootDir();
+    }
+    async getResource(resourceIdentity, runtimeEnvironment) {
+        const metadata = this.siteResources.resources[resourceIdentity.specifier];
+        if (!metadata) {
+            logger.warn(`[${this.name}] Did not find requested specifier ${resourceIdentity.specifier}`);
+            return undefined;
+        }
+        const resourcePath = path.join(this.siteRootDir, metadata.path);
+        // Figure out mime type
+        const type = metadata.mimeType || mimeLookup(resourcePath) || 'application/javascript';
+        return {
+            type,
+            // Have to make the loader shim code available for SSR
+            stream: () => {
+                logger.info(`[${this.name}] Resource read from lambda ${resourceIdentity.specifier}`);
+                return fs.createReadStream(resourcePath);
+            },
+            src: resourcePath,
+        };
+    }
+}
+//# sourceMappingURL=static-resource-provider.js.map

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

@@ -0,0 +1,27 @@
+import type { SiteAssets, SiteBundles, SiteMetadata, SiteResources } from '@lwrjs/types';
+declare type Options = {
+    rootDir: string;
+};
+export declare class SiteMetadataImpl implements SiteMetadata {
+    private options;
+    private siteBundles;
+    private siteResources;
+    private siteAssets;
+    constructor(options: Options);
+    getSiteRootDir(): string;
+    getSiteBundles(): SiteBundles;
+    getSiteResources(): SiteResources;
+    getSiteAssets(): SiteAssets;
+    persistSiteMetadata(): Promise<void>;
+    private readStaticBundleMetadata;
+    /**
+     * Read the metadata about the pre-built resources of the current site.
+     */
+    private readStaticResourceMetadata;
+    /**
+     * Read the metadata about the pre-built assets of the current site.
+     */
+    private readStaticAssetsMetadata;
+}
+export {};
+//# sourceMappingURL=site-metadata.d.ts.map

package/build/es/site-metadata.js

@@ -0,0 +1,111 @@
+import path from 'path';
+import fs from 'fs-extra';
+import { logger } from '@lwrjs/shared-utils';
+const SITE_METADATA_PATH = '.metadata';
+const STATIC_BUNDLE_METADATA_PATH = path.join(SITE_METADATA_PATH, '/bundle-metadata.json');
+const STATIC_RESOURCE_METADATA_PATH = path.join(SITE_METADATA_PATH, '/resource-metadata.json');
+const STATIC_ASSET_METADATA_PATH = path.join(SITE_METADATA_PATH, '/asset-metadata.json');
+export class SiteMetadataImpl {
+    constructor(options) {
+        this.options = options;
+        this.siteBundles = this.readStaticBundleMetadata(options.rootDir);
+        this.siteResources = this.readStaticResourceMetadata(options.rootDir);
+        this.siteAssets = this.readStaticAssetsMetadata(options.rootDir);
+    }
+    getSiteRootDir() {
+        return this.options.rootDir;
+    }
+    getSiteBundles() {
+        return this.siteBundles;
+    }
+    getSiteResources() {
+        return this.siteResources;
+    }
+    getSiteAssets() {
+        return this.siteAssets;
+    }
+    async persistSiteMetadata() {
+        // Create the metadata directory if if does not exist
+        const siteMetadataPath = path.join(this.options.rootDir, SITE_METADATA_PATH);
+        try {
+            if (!(await fs.pathExists(siteMetadataPath))) {
+                await fs.mkdir(siteMetadataPath, { recursive: true });
+            }
+            // Save Bundle Metadata
+            const bundleMetadataPath = path.join(this.options.rootDir, STATIC_BUNDLE_METADATA_PATH);
+            await fs.writeJSON(bundleMetadataPath, this.siteBundles, { spaces: 2 });
+            // Save Resource Metadata
+            const resourceMetadataPath = path.join(this.options.rootDir, STATIC_RESOURCE_METADATA_PATH);
+            await fs.writeJSON(resourceMetadataPath, this.siteResources, { spaces: 2 });
+            // Save Resource Metadata
+            const assetMetadataPath = path.join(this.options.rootDir, STATIC_ASSET_METADATA_PATH);
+            return fs.writeJSON(assetMetadataPath, this.siteAssets, { spaces: 2 });
+        }
+        catch (err) {
+            console.error(`[SiteMetadata] Failed to save site metadata ${siteMetadataPath}`);
+            console.error(err);
+        }
+    }
+    readStaticBundleMetadata(staticRoot) {
+        let bundleMetadataPath;
+        let siteBundles = { bundles: {} };
+        try {
+            bundleMetadataPath = path.join(staticRoot, STATIC_BUNDLE_METADATA_PATH);
+            const savedMetadata = fs.readJSONSync(bundleMetadataPath);
+            siteBundles = savedMetadata;
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                logger.debug(`[SiteMetadata] Failed to load Static Bundle Metadata: ${bundleMetadataPath}`);
+            }
+            else {
+                throw error;
+            }
+        }
+        return siteBundles;
+    }
+    /**
+     * Read the metadata about the pre-built resources of the current site.
+     */
+    readStaticResourceMetadata(staticRoot) {
+        let resourceMetadataPath;
+        let siteResources = { resources: {} };
+        try {
+            resourceMetadataPath = path.join(staticRoot, STATIC_RESOURCE_METADATA_PATH);
+            const savedMetadata = fs.readJSONSync(resourceMetadataPath);
+            siteResources = savedMetadata;
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                logger.debug(`[SiteMetadata] Failed to load Static Resource Metadata: ${resourceMetadataPath}`);
+            }
+            else {
+                throw error;
+            }
+        }
+        return siteResources;
+    }
+    /**
+     * Read the metadata about the pre-built assets of the current site.
+     */
+    readStaticAssetsMetadata(staticRoot) {
+        let assetMetadataPath;
+        let siteAssets = {
+            assets: {},
+        };
+        try {
+            assetMetadataPath = path.join(staticRoot, STATIC_ASSET_METADATA_PATH);
+            siteAssets = fs.readJSONSync(assetMetadataPath);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                logger.debug(`[SiteMetadata] Failed to load Static Resource Metadata: ${assetMetadataPath}`);
+            }
+            else {
+                throw error;
+            }
+        }
+        return siteAssets;
+    }
+}
+//# sourceMappingURL=site-metadata.js.map

package/build/es/utils/static-utils.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 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;
+//# sourceMappingURL=static-utils.d.ts.map

package/build/es/utils/static-utils.js

@@ -0,0 +1,14 @@
+/**
+ * Try to add any code that is mrt specific here so that we can isolate details that would have to be refactored to run lambdas
+ * on a different platform
+ */
+import { VERSION_NOT_PROVIDED } from '@lwrjs/shared-utils';
+/**
+ * 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;
+}
+//# sourceMappingURL=static-utils.js.map

package/package.json

@@ -0,0 +1,66 @@
+{
+    "name": "@lwrjs/static",
+    "license": "MIT",
+    "publishConfig": {
+        "access": "public"
+    },
+    "version": "0.10.0-alpha.13",
+    "homepage": "https://developer.salesforce.com/docs/platform/lwr/overview",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/salesforce-experience-platform-emu/lwr.git",
+        "directory": "packages/@lwrjs/static"
+    },
+    "bugs": {
+        "url": "https://github.com/salesforce-experience-platform-emu/lwr/issues"
+    },
+    "type": "module",
+    "exports": {
+        "./site-metadata": {
+            "import": "./build/es/site-metadata.js",
+            "require": "./build/cjs/site-metadata.cjs"
+        },
+        "./asset-provider": {
+            "import": "./build/es/providers/static-asset-provider.js",
+            "require": "./build/cjs/providers/static-asset-provider.cjs"
+        },
+        "./bundle-provider": {
+            "import": "./build/es/providers/static-bundle-provider.js",
+            "require": "./build/cjs/providers/static-bundle-provider.cjs"
+        },
+        "./module-provider": {
+            "import": "./build/es/providers/static-module-provider.js",
+            "require": "./build/cjs/providers/static-module-provider.cjs"
+        },
+        "./resource-provider": {
+            "import": "./build/es/providers/static-resource-provider.js",
+            "require": "./build/cjs/providers/static-resource-provider.cjs"
+        }
+    },
+    "scripts": {
+        "build": "tsc -b",
+        "clean": "rm -rf build node_modules",
+        "test": "jest"
+    },
+    "files": [
+        "build/**/*.js",
+        "build/**/*.cjs",
+        "build/**/*.d.ts"
+    ],
+    "dependencies": {
+        "@lwrjs/shared-utils": "0.10.0-alpha.13"
+    },
+    "devDependencies": {
+        "@lwrjs/types": "0.10.0-alpha.13",
+        "@types/express": "^4.17.17",
+        "jest-express": "^1.12.0",
+        "mock-res": "^0.6.0"
+    },
+    "engines": {
+        "node": ">=16.0.0 <20"
+    },
+    "volta": {
+        "extends": "../../../package.json"
+    },
+    "gitHead": "f6d142d5a027554cb1685389e0b173734149683d"
+}