wrangler 0.0.0-e29a241 → 0.0.0-e2a6fa40

package/vendor/@cloudflare/kv-asset-handler/dist/index.js

@@ -1,354 +0,0 @@
-"use strict";
-var __awaiter =
-  (this && this.__awaiter) ||
-  function (thisArg, _arguments, P, generator) {
-    function adopt(value) {
-      return value instanceof P
-        ? value
-        : new P(function (resolve) {
-            resolve(value);
-          });
-    }
-    return new (P || (P = Promise))(function (resolve, reject) {
-      function fulfilled(value) {
-        try {
-          step(generator.next(value));
-        } catch (e) {
-          reject(e);
-        }
-      }
-      function rejected(value) {
-        try {
-          step(generator["throw"](value));
-        } catch (e) {
-          reject(e);
-        }
-      }
-      function step(result) {
-        result.done
-          ? resolve(result.value)
-          : adopt(result.value).then(fulfilled, rejected);
-      }
-      step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-  };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.InternalError =
-  exports.NotFoundError =
-  exports.MethodNotAllowedError =
-  exports.serveSinglePageApp =
-  exports.mapRequestToAsset =
-  exports.getAssetFromKV =
-    void 0;
-const mime = require("wrangler-mime");
-const types_1 = require("./types");
-Object.defineProperty(exports, "MethodNotAllowedError", {
-  enumerable: true,
-  get: function () {
-    return types_1.MethodNotAllowedError;
-  },
-});
-Object.defineProperty(exports, "NotFoundError", {
-  enumerable: true,
-  get: function () {
-    return types_1.NotFoundError;
-  },
-});
-Object.defineProperty(exports, "InternalError", {
-  enumerable: true,
-  get: function () {
-    return types_1.InternalError;
-  },
-});
-const defaultCacheControl = {
-  browserTTL: null,
-  edgeTTL: 2 * 60 * 60 * 24,
-  bypassCache: false, // do not bypass Cloudflare's cache
-};
-function assignOptions(options) {
-  // Assign any missing options passed in to the default
-  // options.mapRequestToAsset is handled manually later
-  return Object.assign(
-    {
-      ASSET_NAMESPACE: __STATIC_CONTENT,
-      ASSET_MANIFEST: __STATIC_CONTENT_MANIFEST,
-      cacheControl: defaultCacheControl,
-      defaultMimeType: "text/plain",
-      defaultDocument: "index.html",
-    },
-    options
-  );
-}
-/**
- * maps the path of incoming request to the request pathKey to look up
- * in bucket and in cache
- * e.g.  for a path '/' returns '/index.html' which serves
- * the content of bucket/index.html
- * @param {Request} request incoming request
- */
-const mapRequestToAsset = (request, options) => {
-  options = assignOptions(options);
-  const parsedUrl = new URL(request.url);
-  let pathname = parsedUrl.pathname;
-  if (pathname.endsWith("/")) {
-    // If path looks like a directory append options.defaultDocument
-    // e.g. If path is /about/ -> /about/index.html
-    pathname = pathname.concat(options.defaultDocument);
-  } else if (!mime.getType(pathname)) {
-    // If path doesn't look like valid content
-    //  e.g. /about.me ->  /about.me/index.html
-    pathname = pathname.concat("/" + options.defaultDocument);
-  }
-  parsedUrl.pathname = pathname;
-  return new Request(parsedUrl.toString(), request);
-};
-exports.mapRequestToAsset = mapRequestToAsset;
-/**
- * maps the path of incoming request to /index.html if it evaluates to
- * any HTML file.
- * @param {Request} request incoming request
- */
-function serveSinglePageApp(request, options) {
-  options = assignOptions(options);
-  // First apply the default handler, which already has logic to detect
-  // paths that should map to HTML files.
-  request = mapRequestToAsset(request, options);
-  const parsedUrl = new URL(request.url);
-  // Detect if the default handler decided to map to
-  // a HTML file in some specific directory.
-  if (parsedUrl.pathname.endsWith(".html")) {
-    // If expected HTML file was missing, just return the root index.html (or options.defaultDocument)
-    return new Request(
-      `${parsedUrl.origin}/${options.defaultDocument}`,
-      request
-    );
-  } else {
-    // The default handler decided this is not an HTML page. It's probably
-    // an image, CSS, or JS file. Leave it as-is.
-    return request;
-  }
-}
-exports.serveSinglePageApp = serveSinglePageApp;
-/**
- * takes the path of the incoming request, gathers the appropriate content from KV, and returns
- * the response
- *
- * @param {FetchEvent} event the fetch event of the triggered request
- * @param {{mapRequestToAsset: (string: Request) => Request, cacheControl: {bypassCache:boolean, edgeTTL: number, browserTTL:number}, ASSET_NAMESPACE: any, ASSET_MANIFEST:any}} [options] configurable options
- * @param {CacheControl} [options.cacheControl] determine how to cache on Cloudflare and the browser
- * @param {typeof(options.mapRequestToAsset)} [options.mapRequestToAsset]  maps the path of incoming request to the request pathKey to look up
- * @param {Object | string} [options.ASSET_NAMESPACE] the binding to the namespace that script references
- * @param {any} [options.ASSET_MANIFEST] the map of the key to cache and store in KV
- * */
-const getAssetFromKV = (event, options) =>
-  __awaiter(void 0, void 0, void 0, function* () {
-    options = assignOptions(options);
-    const request = event.request;
-    const ASSET_NAMESPACE = options.ASSET_NAMESPACE;
-    const ASSET_MANIFEST =
-      typeof options.ASSET_MANIFEST === "string"
-        ? JSON.parse(options.ASSET_MANIFEST)
-        : options.ASSET_MANIFEST;
-    if (typeof ASSET_NAMESPACE === "undefined") {
-      throw new types_1.InternalError(
-        `there is no KV namespace bound to the script`
-      );
-    }
-    const rawPathKey = new URL(request.url).pathname.replace(/^\/+/, ""); // strip any preceding /'s
-    let pathIsEncoded = false;
-    let requestKey;
-    // if options.mapRequestToAsset is explicitly passed in, always use it and assume user has own intentions
-    // otherwise handle request as normal, with default mapRequestToAsset below
-    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 {
-        // use default mapRequestToAsset
-        requestKey = mapRequestToAsset(request, options);
-      }
-    }
-    const SUPPORTED_METHODS = ["GET", "HEAD"];
-    if (!SUPPORTED_METHODS.includes(requestKey.method)) {
-      throw new types_1.MethodNotAllowedError(
-        `${requestKey.method} is not a valid request method`
-      );
-    }
-    const parsedUrl = new URL(requestKey.url);
-    const pathname = pathIsEncoded
-      ? decodeURIComponent(parsedUrl.pathname)
-      : parsedUrl.pathname; // decode percentage encoded path only when necessary
-    // pathKey is the file path to look up in the manifest
-    let pathKey = pathname.replace(/^\/+/, ""); // remove prepended /
-    // @ts-ignore
-    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; // false if storing in KV by raw file path i.e. no hash
-    // check manifest for map from file path to hash
-    if (typeof ASSET_MANIFEST !== "undefined") {
-      if (ASSET_MANIFEST[pathKey]) {
-        pathKey = ASSET_MANIFEST[pathKey];
-        // if path key is in asset manifest, we can assume it contains a content hash and can be cached
-        shouldEdgeCache = true;
-      }
-    }
-    // TODO this excludes search params from cache, investigate ideal behavior
-    let cacheKey = new Request(`${parsedUrl.origin}/${pathKey}`, request);
-    // if argument passed in for cacheControl is a function then
-    // evaluate that function. otherwise return the Object passed in
-    // or default Object
-    const evalCacheOpts = (() => {
-      switch (typeof options.cacheControl) {
-        case "function":
-          return options.cacheControl(request);
-        case "object":
-          return options.cacheControl;
-        default:
-          return defaultCacheControl;
-      }
-    })();
-    // formats the etag depending on the response context. if the entityId
-    // is invalid, returns an empty string (instead of null) to prevent the
-    // the potentially disastrous scenario where the value of the Etag resp
-    // header is "null". Could be modified in future to base64 encode etc
-    const formatETag = (entityId = pathKey, validatorType = "strong") => {
-      if (!entityId) {
-        return "";
-      }
-      switch (validatorType) {
-        case "weak":
-          if (!entityId.startsWith("W/")) {
-            return `W/${entityId}`;
-          }
-          return entityId;
-        case "strong":
-          if (entityId.startsWith(`W/"`)) {
-            entityId = entityId.replace("W/", "");
-          }
-          if (!entityId.endsWith(`"`)) {
-            entityId = `"${entityId}"`;
-          }
-          return entityId;
-        default:
-          return "";
-      }
-    };
-    options.cacheControl = Object.assign(
-      {},
-      defaultCacheControl,
-      evalCacheOpts
-    );
-    // override shouldEdgeCache if options say to bypassCache
-    if (
-      options.cacheControl.bypassCache ||
-      options.cacheControl.edgeTTL === null ||
-      request.method == "HEAD"
-    ) {
-      shouldEdgeCache = false;
-    }
-    // only set max-age if explicitly passed in a number as an arg
-    const shouldSetBrowserCache =
-      typeof options.cacheControl.browserTTL === "number";
-    let response = null;
-    if (shouldEdgeCache) {
-      response = yield cache.match(cacheKey);
-    }
-    if (response) {
-      if (response.status > 300 && response.status < 400) {
-        if (response.body && "cancel" in Object.getPrototypeOf(response.body)) {
-          response.body.cancel();
-          console.log(
-            "Body exists and environment supports readable streams. Body cancelled"
-          );
-        } else {
-          console.log("Environment doesnt support readable streams");
-        }
-        response = new Response(null, response);
-      } else {
-        // fixes #165
-        let 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 = yield ASSET_NAMESPACE.get(pathKey, "arrayBuffer");
-      if (body === null) {
-        throw new types_1.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", body.length);
-        // set etag before cache insertion
-        if (!response.headers.has("etag")) {
-          response.headers.set("etag", formatETag(pathKey, "strong"));
-        }
-        // determine Cloudflare cache behavior
-        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) {
-      let etag = formatETag(response.headers.get("etag"), "strong");
-      let ifNoneMatch = cacheKey.headers.get("if-none-match");
-      let 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;
-  });
-exports.getAssetFromKV = getAssetFromKV;

package/vendor/@cloudflare/kv-asset-handler/dist/mocks.d.ts

@@ -1,13 +0,0 @@
-export declare const getEvent: (request: Request) => any;
-export declare const mockKV: (store: any) => {
-    get: (path: string) => any;
-};
-export declare const mockManifest: () => string;
-export declare const mockCaches: () => {
-    default: {
-        match(key: any): Promise<any>;
-        put(key: any, val: Response): Promise<void>;
-    };
-};
-export declare function mockGlobal(): void;
-export declare const sleep: (milliseconds: number) => Promise<unknown>;

package/vendor/@cloudflare/kv-asset-handler/dist/mocks.js

@@ -1,148 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sleep = exports.mockGlobal = exports.mockCaches = exports.mockManifest = exports.mockKV = exports.getEvent = void 0;
-const makeServiceWorkerEnv = require('service-worker-mock');
-const HASH = '123HASHBROWN';
-const getEvent = (request) => {
-    const waitUntil = (callback) => __awaiter(void 0, void 0, void 0, function* () {
-        yield callback;
-    });
-    return {
-        request,
-        waitUntil,
-    };
-};
-exports.getEvent = getEvent;
-const store = {
-    'key1.123HASHBROWN.txt': 'val1',
-    'key1.123HASHBROWN.png': 'val1',
-    'index.123HASHBROWN.html': 'index.html',
-    'cache.123HASHBROWN.html': 'cache me if you can',
-    '测试.123HASHBROWN.html': 'My filename is non-ascii',
-    '%not-really-percent-encoded.123HASHBROWN.html': 'browser percent encoded',
-    '%2F.123HASHBROWN.html': 'user percent encoded',
-    '你好.123HASHBROWN.html': 'I shouldnt be served',
-    '%E4%BD%A0%E5%A5%BD.123HASHBROWN.html': 'Im important',
-    'nohash.txt': 'no hash but still got some result',
-    'sub/blah.123HASHBROWN.png': 'picturedis',
-    'sub/index.123HASHBROWN.html': 'picturedis',
-    'client.123HASHBROWN': 'important file',
-    'client.123HASHBROWN/index.html': 'Im here but serve my big bro above',
-    '你好/index.123HASHBROWN.html': 'My path is non-ascii',
-};
-const mockKV = (store) => {
-    return {
-        get: (path) => store[path] || null,
-    };
-};
-exports.mockKV = mockKV;
-const mockManifest = () => {
-    return JSON.stringify({
-        'key1.txt': `key1.${HASH}.txt`,
-        'key1.png': `key1.${HASH}.png`,
-        'cache.html': `cache.${HASH}.html`,
-        '测试.html': `测试.${HASH}.html`,
-        '你好.html': `你好.${HASH}.html`,
-        '%not-really-percent-encoded.html': `%not-really-percent-encoded.${HASH}.html`,
-        '%2F.html': `%2F.${HASH}.html`,
-        '%E4%BD%A0%E5%A5%BD.html': `%E4%BD%A0%E5%A5%BD.${HASH}.html`,
-        'index.html': `index.${HASH}.html`,
-        'sub/blah.png': `sub/blah.${HASH}.png`,
-        'sub/index.html': `sub/index.${HASH}.html`,
-        client: `client.${HASH}`,
-        'client/index.html': `client.${HASH}`,
-        '你好/index.html': `你好/index.${HASH}.html`,
-    });
-};
-exports.mockManifest = mockManifest;
-let cacheStore = new Map();
-const mockCaches = () => {
-    return {
-        default: {
-            match(key) {
-                return __awaiter(this, void 0, void 0, function* () {
-                    let cacheKey = {
-                        url: key.url,
-                        headers: {},
-                    };
-                    let response;
-                    if (key.headers.has('if-none-match')) {
-                        let makeStrongEtag = key.headers.get('if-none-match').replace('W/', '');
-                        Reflect.set(cacheKey.headers, 'etag', makeStrongEtag);
-                        response = cacheStore.get(JSON.stringify(cacheKey));
-                    }
-                    else {
-                        // if client doesn't send if-none-match, we need to iterate through these keys
-                        // and just test the URL
-                        const activeCacheKeys = Array.from(cacheStore.keys());
-                        for (const cacheStoreKey of activeCacheKeys) {
-                            if (JSON.parse(cacheStoreKey).url === key.url) {
-                                response = cacheStore.get(cacheStoreKey);
-                            }
-                        }
-                    }
-                    // TODO: write test to accomodate for rare scenarios with where range requests accomodate etags
-                    if (response && !key.headers.has('if-none-match')) {
-                        // this appears overly verbose, but is necessary to document edge cache behavior
-                        // The Range request header triggers the response header Content-Range ...
-                        const range = key.headers.get('range');
-                        if (range) {
-                            response.headers.set('content-range', `bytes ${range.split('=').pop()}/${response.headers.get('content-length')}`);
-                        }
-                        // ... which we are using in this repository to set status 206
-                        if (response.headers.has('content-range')) {
-                            response.status = 206;
-                        }
-                        else {
-                            response.status = 200;
-                        }
-                        let etag = response.headers.get('etag');
-                        if (etag && !etag.includes('W/')) {
-                            response.headers.set('etag', `W/${etag}`);
-                        }
-                    }
-                    return response;
-                });
-            },
-            put(key, val) {
-                return __awaiter(this, void 0, void 0, function* () {
-                    let headers = new Headers(val.headers);
-                    let url = new URL(key.url);
-                    let resWithBody = new Response(val.body, { headers, status: 200 });
-                    let resNoBody = new Response(null, { headers, status: 304 });
-                    let cacheKey = {
-                        url: key.url,
-                        headers: {
-                            etag: `"${url.pathname.replace('/', '')}"`,
-                        },
-                    };
-                    cacheStore.set(JSON.stringify(cacheKey), resNoBody);
-                    cacheKey.headers = {};
-                    cacheStore.set(JSON.stringify(cacheKey), resWithBody);
-                    return;
-                });
-            },
-        },
-    };
-};
-exports.mockCaches = mockCaches;
-function mockGlobal() {
-    Object.assign(global, makeServiceWorkerEnv());
-    Object.assign(global, { __STATIC_CONTENT_MANIFEST: exports.mockManifest() });
-    Object.assign(global, { __STATIC_CONTENT: exports.mockKV(store) });
-    Object.assign(global, { caches: exports.mockCaches() });
-}
-exports.mockGlobal = mockGlobal;
-const sleep = (milliseconds) => {
-    return new Promise((resolve) => setTimeout(resolve, milliseconds));
-};
-exports.sleep = sleep;

package/vendor/@cloudflare/kv-asset-handler/dist/test/getAssetFromKV.d.ts

@@ -1 +0,0 @@
-export {};