elearning/Frontend-Learner/node_modules/@cloudflare/kv-asset-handler/dist/index.js

import * as mime from 'mime';

var __defProp = Object.defineProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });

// src/types.ts
var KVError = class _KVError extends Error {
  static {
    __name(this, "KVError");
  }
  constructor(message, status = 500) {
    super(message);
    Object.setPrototypeOf(this, new.target.prototype);
    this.name = _KVError.name;
    this.status = status;
  }
  status;
};
var MethodNotAllowedError = class extends KVError {
  static {
    __name(this, "MethodNotAllowedError");
  }
  constructor(message = `Not a valid request method`, status = 405) {
    super(message, status);
  }
};
var NotFoundError = class extends KVError {
  static {
    __name(this, "NotFoundError");
  }
  constructor(message = `Not Found`, status = 404) {
    super(message, status);
  }
};
var InternalError = class extends KVError {
  static {
    __name(this, "InternalError");
  }
  constructor(message = `Internal Error in KV Asset Handler`, status = 500) {
    super(message, status);
  }
};

// src/index.ts
var defaultCacheControl = {
  browserTTL: null,
  edgeTTL: 2 * 60 * 60 * 24,
  // 2 days
  bypassCache: false
  // do not bypass Cloudflare's cache
};
var parseStringAsObject = /* @__PURE__ */ __name((maybeString) => typeof maybeString === "string" ? JSON.parse(maybeString) : maybeString, "parseStringAsObject");
function getAssetFromKVDefaultOptions() {
  return {
    ASSET_NAMESPACE: typeof __STATIC_CONTENT !== "undefined" ? __STATIC_CONTENT : void 0,
    ASSET_MANIFEST: typeof __STATIC_CONTENT_MANIFEST !== "undefined" ? parseStringAsObject(__STATIC_CONTENT_MANIFEST) : {},
    cacheControl: defaultCacheControl,
    defaultMimeType: "text/plain",
    defaultDocument: "index.html",
    pathIsEncoded: false,
    defaultETag: "strong"
  };
}
__name(getAssetFromKVDefaultOptions, "getAssetFromKVDefaultOptions");
function assignOptions(options) {
  return Object.assign({}, getAssetFromKVDefaultOptions(), options);
}
__name(assignOptions, "assignOptions");
var mapRequestToAsset = /* @__PURE__ */ __name((request, options) => {
  options = assignOptions(options);
  const parsedUrl = new URL(request.url);
  let pathname = parsedUrl.pathname;
  if (pathname.endsWith("/")) {
    pathname = pathname.concat(options.defaultDocument);
  } else if (!mime.getType(pathname)) {
    pathname = pathname.concat("/" + options.defaultDocument);
  }
  parsedUrl.pathname = pathname;
  return new Request(parsedUrl.toString(), request);
}, "mapRequestToAsset");
function serveSinglePageApp(request, options) {
  options = assignOptions(options);
  request = mapRequestToAsset(request, options);
  const parsedUrl = new URL(request.url);
  if (parsedUrl.pathname.endsWith(".html")) {
    return new Request(
      `${parsedUrl.origin}/${options.defaultDocument}`,
      request
    );
  } else {
    return request;
  }
}
__name(serveSinglePageApp, "serveSinglePageApp");
var getAssetFromKV = /* @__PURE__ */ __name(async (event, options) => {
  options = assignOptions(options);
  const request = event.request;
  const ASSET_NAMESPACE = options.ASSET_NAMESPACE;
  const ASSET_MANIFEST = parseStringAsObject(
    options.ASSET_MANIFEST
  );
  if (typeof ASSET_NAMESPACE === "undefined") {
    throw new InternalError(`there is no KV namespace bound to the script`);
  }
  const rawPathKey = new URL(request.url).pathname.replace(/^\/+/, "");
  let pathIsEncoded = options.pathIsEncoded;
  let requestKey;
  if (options.mapRequestToAsset) {
    requestKey = options.mapRequestToAsset(request);
  } else if (ASSET_MANIFEST[rawPathKey]) {
    requestKey = request;
  } else if (ASSET_MANIFEST[decodeURIComponent(rawPathKey)]) {
    pathIsEncoded = true;
    requestKey = request;
  } else {
    const mappedRequest = mapRequestToAsset(request);
    const mappedRawPathKey = new URL(mappedRequest.url).pathname.replace(
      /^\/+/,
      ""
    );
    if (ASSET_MANIFEST[decodeURIComponent(mappedRawPathKey)]) {
      pathIsEncoded = true;
      requestKey = mappedRequest;
    } else {
      requestKey = mapRequestToAsset(request, options);
    }
  }
  const SUPPORTED_METHODS = ["GET", "HEAD"];
  if (!SUPPORTED_METHODS.includes(requestKey.method)) {
    throw new MethodNotAllowedError(
      `${requestKey.method} is not a valid request method`
    );
  }
  const parsedUrl = new URL(requestKey.url);
  const pathname = pathIsEncoded ? decodeURIComponent(parsedUrl.pathname) : parsedUrl.pathname;
  let pathKey = pathname.replace(/^\/+/, "");
  const cache = caches.default;
  let mimeType = mime.getType(pathKey) || options.defaultMimeType;
  if (mimeType.startsWith("text") || mimeType === "application/javascript") {
    mimeType += "; charset=utf-8";
  }
  let shouldEdgeCache = false;
  if (typeof ASSET_MANIFEST !== "undefined") {
    if (ASSET_MANIFEST[pathKey]) {
      pathKey = ASSET_MANIFEST[pathKey];
      shouldEdgeCache = true;
    }
  }
  const cacheKey = new Request(`${parsedUrl.origin}/${pathKey}`, request);
  const evalCacheOpts = (() => {
    switch (typeof options.cacheControl) {
      case "function":
        return options.cacheControl(request);
      case "object":
        return options.cacheControl;
      default:
        return defaultCacheControl;
    }
  })();
  const formatETag = /* @__PURE__ */ __name((entityId = pathKey, validatorType = options.defaultETag) => {
    if (!entityId) {
      return "";
    }
    switch (validatorType) {
      case "weak":
        if (!entityId.startsWith("W/")) {
          if (entityId.startsWith(`"`) && entityId.endsWith(`"`)) {
            return `W/${entityId}`;
          }
          return `W/"${entityId}"`;
        }
        return entityId;
      case "strong":
        if (entityId.startsWith(`W/"`)) {
          entityId = entityId.replace("W/", "");
        }
        if (!entityId.endsWith(`"`)) {
          entityId = `"${entityId}"`;
        }
        return entityId;
      default:
        return "";
    }
  }, "formatETag");
  options.cacheControl = Object.assign({}, defaultCacheControl, evalCacheOpts);
  if (options.cacheControl.bypassCache || options.cacheControl.edgeTTL === null || request.method == "HEAD") {
    shouldEdgeCache = false;
  }
  const shouldSetBrowserCache = typeof options.cacheControl.browserTTL === "number";
  let response = null;
  if (shouldEdgeCache) {
    response = await cache.match(cacheKey);
  }
  if (response) {
    if (response.status > 300 && response.status < 400) {
      if (response.body && "cancel" in Object.getPrototypeOf(response.body)) {
        response.body.cancel();
      }
      response = new Response(null, response);
    } else {
      const opts = {
        headers: new Headers(response.headers),
        status: 0,
        statusText: ""
      };
      opts.headers.set("cf-cache-status", "HIT");
      if (response.status) {
        opts.status = response.status;
        opts.statusText = response.statusText;
      } else if (opts.headers.has("Content-Range")) {
        opts.status = 206;
        opts.statusText = "Partial Content";
      } else {
        opts.status = 200;
        opts.statusText = "OK";
      }
      response = new Response(response.body, opts);
    }
  } else {
    const body = await ASSET_NAMESPACE.get(pathKey, "arrayBuffer");
    if (body === null) {
      throw new NotFoundError(
        `could not find ${pathKey} in your content namespace`
      );
    }
    response = new Response(body);
    if (shouldEdgeCache) {
      response.headers.set("Accept-Ranges", "bytes");
      response.headers.set("Content-Length", String(body.byteLength));
      if (!response.headers.has("etag")) {
        response.headers.set("etag", formatETag(pathKey));
      }
      response.headers.set(
        "Cache-Control",
        `max-age=${options.cacheControl.edgeTTL}`
      );
      event.waitUntil(cache.put(cacheKey, response.clone()));
      response.headers.set("CF-Cache-Status", "MISS");
    }
  }
  response.headers.set("Content-Type", mimeType);
  if (response.status === 304) {
    const etag = formatETag(response.headers.get("etag"));
    const ifNoneMatch = cacheKey.headers.get("if-none-match");
    const proxyCacheStatus = response.headers.get("CF-Cache-Status");
    if (etag) {
      if (ifNoneMatch && ifNoneMatch === etag && proxyCacheStatus === "MISS") {
        response.headers.set("CF-Cache-Status", "EXPIRED");
      } else {
        response.headers.set("CF-Cache-Status", "REVALIDATED");
      }
      response.headers.set("etag", formatETag(etag, "weak"));
    }
  }
  if (shouldSetBrowserCache) {
    response.headers.set(
      "Cache-Control",
      `max-age=${options.cacheControl.browserTTL}`
    );
  } else {
    response.headers.delete("Cache-Control");
  }
  return response;
}, "getAssetFromKV");

export { InternalError, MethodNotAllowedError, NotFoundError, getAssetFromKV, mapRequestToAsset, serveSinglePageApp };
//# sourceMappingURL=index.js.map
//# sourceMappingURL=index.js.map