@e-mc/request 0.10.6 → 0.11.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@e-mc/request",
-  "version": "0.10.6",
+  "version": "0.11.1",
   "description": "Request constructor for E-mc.",
   "main": "index.js",
   "types": "index.d.ts",
@@ -20,11 +20,11 @@
   "license": "BSD-3-Clause",
   "homepage": "https://github.com/anpham6/e-mc#readme",
   "dependencies": {
-    "@e-mc/module": "0.10.6",
-    "@e-mc/types": "0.10.6",
+    "@e-mc/module": "0.11.1",
+    "@e-mc/types": "0.11.1",
     "combined-stream": "^1.0.8",
     "js-yaml": "^4.1.0",
     "picomatch": "^4.0.2",
-    "which": "^2.0.2"
+    "which": "^4.0.0"
   }
 }

package/util.d.ts

@@ -1,8 +1,8 @@
 import type { AuthValue } from '@e-mc/types/lib/http';
 import type { HttpProxySettings } from '@e-mc/types/lib/settings';
 
-import type { IncomingHttpHeaders, OutgoingHttpHeaders } from 'http';
-import type { Readable, Writable } from 'stream';
+import type { IncomingHttpHeaders, OutgoingHttpHeaders } from 'node:http';
+import type { Readable, Writable } from 'node:stream';
 
 declare namespace util {
     function parseHeader<T = unknown>(headers: IncomingHttpHeaders, name: string): T | undefined;
@@ -13,11 +13,13 @@ declare namespace util {
     function hasBasicAuth(value: string): boolean;
     function checkRetryable(err: unknown): boolean;
     function isRetryable(value: number, timeout?: boolean): boolean;
-    function parseHttpProxy(value?: string, ignoreEnv?: boolean): HttpProxySettings | undefined;
+    function parseHttpProxy(value?: string): HttpProxySettings | undefined;
     function trimPath(value: string): string;
     function asInt(value: unknown): number;
     function asFloat(value: unknown): number;
     function fromSeconds(value: unknown): number;
+    function fromURL(url: URL, value: string): string;
+    function fromStatusCode(value: number | string): string;
     function getTransferRate(length: number, timeMs: number, unitSeparator?: string): string;
     function hasSameStat(src: string, dest: string, keepEmpty?: boolean): boolean;
     function hasSize(value: string, keepEmpty?: boolean): boolean;

package/util.js

@@ -11,18 +11,20 @@ exports.trimPath = trimPath;
 exports.asInt = asInt;
 exports.asFloat = asFloat;
 exports.fromSeconds = fromSeconds;
+exports.fromURL = fromURL;
+exports.fromStatusCode = fromStatusCode;
 exports.getTransferRate = getTransferRate;
 exports.hasSize = hasSize;
 exports.getSize = getSize;
 exports.hasSameStat = hasSameStat;
 exports.byteLength = byteLength;
 exports.cleanupStream = cleanupStream;
-const path = require("path");
-const fs = require("fs");
-const util = require("util");
+const path = require("node:path");
+const fs = require("node:fs");
+const node_util_1 = require("node:util");
 const types_1 = require("@e-mc/types");
 const module_1 = require("@e-mc/module");
-const SUPPORTED_USVSTRING = (0, types_1.supported)(16, 8);
+const host_1 = require("@e-mc/request/http/host");
 const safeInt = (value) => value >= 0 ? Math.min(value, Number.MAX_SAFE_INTEGER) : NaN;
 function parseHeader(headers, name) {
     const value = headers[name];
@@ -86,7 +88,7 @@ function getBasicAuth(username, password) {
     if ((0, types_1.isObject)(username)) {
         ({ username, password } = username);
     }
-    return (0, types_1.isString)(username) ? encodeURIComponent(SUPPORTED_USVSTRING ? util.toUSVString(username) : username) + ((0, types_1.isString)(password) ? ':' + encodeURIComponent(SUPPORTED_USVSTRING ? util.toUSVString(password) : password) : '') + '@' : '';
+    return (0, types_1.isString)(username) ? encodeURIComponent((0, node_util_1.toUSVString)(username)) + ((0, types_1.isString)(password) ? ':' + encodeURIComponent((0, node_util_1.toUSVString)(password)) : '') + '@' : '';
 }
 function hasBasicAuth(value) {
     try {
@@ -212,6 +214,155 @@ function fromSeconds(value) {
             return NaN;
     }
 }
+function fromURL(url, value) {
+    if (module_1.isURL(value)) {
+        return value;
+    }
+    const auth = host_1.formatBasicAuth(url);
+    return url.protocol + '//' + (auth && (auth + '@')) + url.hostname + (url.port ? ':' + url.port : '') + (value.startsWith('/') ? '' : '/') + value;
+}
+function fromStatusCode(value) {
+    value = +value;
+    if (value < 200) {
+        switch (value) {
+            case 100:
+                return 'Continue';
+            case 101:
+                return 'Switching Protocol';
+            case 102:
+                return 'Processing';
+            case 103:
+                return 'Early Hints';
+        }
+    }
+    else if (value < 300) {
+        switch (value) {
+            case 200:
+                return 'OK';
+            case 201:
+                return 'Created';
+            case 202:
+                return 'Accepted';
+            case 203:
+                return 'Non-Authoritative Information';
+            case 204:
+                return 'No Content';
+            case 205:
+                return 'Reset Content';
+            case 206:
+                return 'Partial Content';
+        }
+    }
+    else if (value < 400) {
+        switch (value) {
+            case 300:
+                return 'Multiple Choice';
+            case 301:
+                return 'Moved Permanently';
+            case 302:
+                return 'Found';
+            case 303:
+                return 'See Other';
+            case 304:
+                return 'Not Modified';
+            case 305:
+                return 'Use Proxy';
+            case 307:
+                return 'Temporary Redirect';
+            case 308:
+                return 'Permanent Redirect';
+        }
+    }
+    else if (value < 500) {
+        switch (value) {
+            case 400:
+                return 'Bad Request';
+            case 401:
+                return 'Upgrade Required';
+            case 402:
+                return 'Payment Required';
+            case 403:
+                return 'Forbidden';
+            case 404:
+                return 'Not Found';
+            case 405:
+                return 'Method Not Allowed';
+            case 406:
+                return 'Not Acceptable';
+            case 407:
+                return 'Proxy Authentication Required';
+            case 408:
+                return 'Request Timeout';
+            case 409:
+                return 'Conflict';
+            case 410:
+                return 'Gone';
+            case 411:
+                return 'Length Required';
+            case 412:
+                return 'Precondition Failed';
+            case 413:
+                return 'Payload Too Large';
+            case 414:
+                return 'URI Too Long';
+            case 415:
+                return 'Unsupported Media Type';
+            case 416:
+                return 'Range Not Satisfiable';
+            case 417:
+                return 'Expectation Failed';
+            case 421:
+                return 'Misdirected Request';
+            case 422:
+                return 'Unprocessable Entity';
+            case 423:
+                return 'Locked';
+            case 424:
+                return 'Failed Dependency';
+            case 425:
+                return 'Too Early';
+            case 426:
+                return 'Upgrade Required';
+            case 428:
+                return 'Precondition Required';
+            case 429:
+                return 'Too Many Requests';
+            case 431:
+                return 'Request Header Fields Too Large';
+            case 451:
+                return 'Unavailable For Legal Reasons';
+        }
+    }
+    else {
+        switch (value) {
+            case 500:
+                return 'Internal Server Error';
+            case 501:
+                return 'Not Implemented';
+            case 502:
+                return 'Bad Gateway';
+            case 503:
+                return 'Service Unavailable';
+            case 504:
+                return 'Gateway Timeout';
+            case 505:
+                return 'HTTP Version Not Supported';
+            case 506:
+                return 'Variant Also Negotiates';
+            case 507:
+                return 'Insufficient Storage';
+            case 508:
+                return 'Loop Detected';
+            case 509:
+                return 'Bandwidth Limit Exceeded';
+            case 510:
+                return 'Not Extended';
+            case 511:
+                return 'Network Authentication Required';
+        }
+    }
+    return "Unknown";
+}
 function getTransferRate(length, timeMs, unitSeparator = '') {
     const unit = (length * 8) / timeMs;
     if (unit < 1) {
@@ -273,8 +424,9 @@ function cleanupStream(stream, uri) {
         }
     }
     catch (err) {
-        if (!module_1.isErrorCode(err, 'ENOENT')) {
-            module_1.writeFail(["Unable to delete file", path.basename(uri)], err, 32);
+        if (module_1.isErrorCode(err, 'ENOENT')) {
+            return;
         }
+        module_1.writeFail(["Unable to delete file", path.basename(uri)], err, 32);
     }
 }