add hw2

node_modules/get-uri/dist/http.js

@@ -0,0 +1,191 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.http = void 0;
+const http_1 = __importDefault(require("http"));
+const https_1 = __importDefault(require("https"));
+const events_1 = require("events");
+const debug_1 = __importDefault(require("debug"));
+const http_error_1 = __importDefault(require("./http-error"));
+const notfound_1 = __importDefault(require("./notfound"));
+const notmodified_1 = __importDefault(require("./notmodified"));
+const debug = (0, debug_1.default)('get-uri:http');
+/**
+ * Returns a Readable stream from an "http:" URI.
+ */
+const http = async (url, opts = {}) => {
+    debug('GET %o', url.href);
+    const cache = getCache(url, opts.cache);
+    // first check the previous Expires and/or Cache-Control headers
+    // of a previous response if a `cache` was provided
+    if (cache && isFresh(cache) && typeof cache.statusCode === 'number') {
+        // check for a 3xx "redirect" status code on the previous cache
+        const type = (cache.statusCode / 100) | 0;
+        if (type === 3 && cache.headers.location) {
+            debug('cached redirect');
+            throw new Error('TODO: implement cached redirects!');
+        }
+        // otherwise we assume that it's the destination endpoint,
+        // since there's nowhere else to redirect to
+        throw new notmodified_1.default();
+    }
+    // 5 redirects allowed by default
+    const maxRedirects = typeof opts.maxRedirects === 'number' ? opts.maxRedirects : 5;
+    debug('allowing %o max redirects', maxRedirects);
+    let mod;
+    if (opts.http) {
+        // the `https` module passed in from the "http.js" file
+        mod = opts.http;
+        debug('using secure `https` core module');
+    }
+    else {
+        mod = http_1.default;
+        debug('using `http` core module');
+    }
+    const options = { ...opts };
+    // add "cache validation" headers if a `cache` was provided
+    if (cache) {
+        if (!options.headers) {
+            options.headers = {};
+        }
+        const lastModified = cache.headers['last-modified'];
+        if (lastModified) {
+            options.headers['If-Modified-Since'] = lastModified;
+            debug('added "If-Modified-Since" request header: %o', lastModified);
+        }
+        const etag = cache.headers.etag;
+        if (etag) {
+            options.headers['If-None-Match'] = etag;
+            debug('added "If-None-Match" request header: %o', etag);
+        }
+    }
+    const req = mod.get(url, options);
+    const [res] = await (0, events_1.once)(req, 'response');
+    const code = res.statusCode || 0;
+    // assign a Date to this response for the "Cache-Control" delta calculation
+    res.date = Date.now();
+    res.parsed = url;
+    debug('got %o response status code', code);
+    // any 2xx response is a "success" code
+    const type = (code / 100) | 0;
+    // check for a 3xx "redirect" status code
+    const location = res.headers.location;
+    if (type === 3 && location) {
+        if (!opts.redirects)
+            opts.redirects = [];
+        const redirects = opts.redirects;
+        if (redirects.length < maxRedirects) {
+            debug('got a "redirect" status code with Location: %o', location);
+            // flush this response - we're not going to use it
+            res.resume();
+            // hang on to this Response object for the "redirects" Array
+            redirects.push(res);
+            const newUri = new URL(location, url.href);
+            debug('resolved redirect URL: %o', newUri.href);
+            const left = maxRedirects - redirects.length;
+            debug('%o more redirects allowed after this one', left);
+            // check if redirecting to a different protocol
+            if (newUri.protocol !== url.protocol) {
+                opts.http = newUri.protocol === 'https:' ? https_1.default : undefined;
+            }
+            return (0, exports.http)(newUri, opts);
+        }
+    }
+    // if we didn't get a 2xx "success" status code, then create an Error object
+    if (type !== 2) {
+        res.resume();
+        if (code === 304) {
+            throw new notmodified_1.default();
+        }
+        else if (code === 404) {
+            throw new notfound_1.default();
+        }
+        // other HTTP-level error
+        throw new http_error_1.default(code);
+    }
+    if (opts.redirects) {
+        // store a reference to the "redirects" Array on the Response object so that
+        // they can be inspected during a subsequent call to GET the same URI
+        res.redirects = opts.redirects;
+    }
+    return res;
+};
+exports.http = http;
+/**
+ * Returns `true` if the provided cache's "freshness" is valid. That is, either
+ * the Cache-Control header or Expires header values are still within the allowed
+ * time period.
+ *
+ * @return {Boolean}
+ * @api private
+ */
+function isFresh(cache) {
+    let fresh = false;
+    let expires = parseInt(cache.headers.expires || '', 10);
+    const cacheControl = cache.headers['cache-control'];
+    if (cacheControl) {
+        // for Cache-Control rules, see: http://www.mnot.net/cache_docs/#CACHE-CONTROL
+        debug('Cache-Control: %o', cacheControl);
+        const parts = cacheControl.split(/,\s*?\b/);
+        for (let i = 0; i < parts.length; i++) {
+            const part = parts[i];
+            const subparts = part.split('=');
+            const name = subparts[0];
+            switch (name) {
+                case 'max-age':
+                    expires =
+                        (cache.date || 0) + parseInt(subparts[1], 10) * 1000;
+                    fresh = Date.now() < expires;
+                    if (fresh) {
+                        debug('cache is "fresh" due to previous %o Cache-Control param', part);
+                    }
+                    return fresh;
+                case 'must-revalidate':
+                    // XXX: what we supposed to do here?
+                    break;
+                case 'no-cache':
+                case 'no-store':
+                    debug('cache is "stale" due to explicit %o Cache-Control param', name);
+                    return false;
+                default:
+                    // ignore unknown cache value
+                    break;
+            }
+        }
+    }
+    else if (expires) {
+        // for Expires rules, see: http://www.mnot.net/cache_docs/#EXPIRES
+        debug('Expires: %o', expires);
+        fresh = Date.now() < expires;
+        if (fresh) {
+            debug('cache is "fresh" due to previous Expires response header');
+        }
+        return fresh;
+    }
+    return false;
+}
+/**
+ * Attempts to return a previous Response object from a previous GET call to the
+ * same URI.
+ *
+ * @api private
+ */
+function getCache(url, cache) {
+    if (cache) {
+        if (cache.parsed && cache.parsed.href === url.href) {
+            return cache;
+        }
+        if (cache.redirects) {
+            for (let i = 0; i < cache.redirects.length; i++) {
+                const c = getCache(url, cache.redirects[i]);
+                if (c) {
+                    return c;
+                }
+            }
+        }
+    }
+    return null;
+}
+//# sourceMappingURL=http.js.map