@e-mc/request 0.0.1

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@e-mc/request",
+  "version": "0.0.1",
+  "description": "Request constructor for e-mc.",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/anpham6/e-mc.git",
+    "directory": "src/request"
+  },
+  "keywords": [
+    "squared",
+    "squared-functions"
+  ],
+  "author": "An Pham <anpham6@gmail.com>",
+  "license": "BSD 3-Clause",
+  "homepage": "https://github.com/anpham6/e-mc#readme",
+  "dependencies": {
+    "@e-mc/module": "0.0.1",
+    "@e-mc/types": "0.0.1",
+    "combined-stream": "^1.0.8",
+    "js-yaml": "^4.1.0",
+    "which": "^2.0.2"
+  }
+}

package/util.d.ts

@@ -0,0 +1,17 @@
+import type { IncomingHttpHeaders, OutgoingHttpHeaders } from 'http';
+
+declare namespace util {
+    function parseHeader<T = unknown>(headers: IncomingHttpHeaders, name: string): T | undefined;
+    function normalizeHeaders(headers: OutgoingHttpHeaders): OutgoingHttpHeaders;
+    function getBasicAuth(auth: AuthValue): string;
+    function getBasicAuth(username: unknown, password?: unknown): string;
+    function hasBasicAuth(value: string): boolean;
+    function checkRetryable(err: unknown): boolean;
+    function isRetryable(value: number, timeout?: boolean): boolean;
+    function trimPath(value: string): string;
+    function asInt(value: unknown): number;
+    function asFloat(value: unknown): number;
+    function fromSeconds(value: unknown): number;
+}
+
+export = util;

package/util.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromSeconds = exports.asFloat = exports.asInt = exports.trimPath = exports.isRetryable = exports.checkRetryable = exports.hasBasicAuth = exports.getBasicAuth = exports.normalizeHeaders = exports.parseHeader = void 0;
+const module_1 = require("../module");
+const types_1 = require("../types");
+const safeInt = (value) => value >= 0 ? Math.min(value, Number.MAX_SAFE_INTEGER) : NaN;
+function parseHeader(headers, name) {
+    const value = headers[name];
+    if (value) {
+        switch (name.toLowerCase()) {
+            case 'content-disposition': {
+                const pattern = /\bfilename(?:\*\s*=\s*UTF-8''([^\s;]+)|\s*=\s*(?:"([^"]+)"|([^\s;]+)))/gi;
+                let result, match;
+                while (match = pattern.exec(value)) {
+                    if (match[1]) {
+                        return decodeURIComponent(match[1]).trim();
+                    }
+                    result = (match[2] || match[3]).trim();
+                }
+                return result;
+            }
+        }
+    }
+}
+exports.parseHeader = parseHeader;
+function normalizeHeaders(headers) {
+    const result = Object.create(null);
+    for (const name in headers) {
+        let value = headers[name];
+        switch (typeof value) {
+            case 'number':
+                value = value.toString();
+                break;
+            case 'string':
+                value = value.trim();
+                break;
+            default:
+                if (Array.isArray(value)) {
+                    value = value.map(out => module_1.default.asString(out).trim());
+                    break;
+                }
+                continue;
+        }
+        if (value) {
+            result[trimPath(name.trim().toLowerCase())] = value;
+        }
+    }
+    return result;
+}
+exports.normalizeHeaders = normalizeHeaders;
+function getBasicAuth(username, password) {
+    if ((0, types_1.isObject)(username)) {
+        ({ username, password } = username);
+    }
+    return (0, types_1.isString)(username) ? encodeURIComponent(username) + ((0, types_1.isString)(password) ? ':' + encodeURIComponent(password) : '') + '@' : '';
+}
+exports.getBasicAuth = getBasicAuth;
+function hasBasicAuth(value) {
+    try {
+        return (0, types_1.isString)(new URL(value).username);
+    }
+    catch {
+    }
+    return false;
+}
+exports.hasBasicAuth = hasBasicAuth;
+function checkRetryable(err) {
+    if (err instanceof Error) {
+        const { code, errno } = err;
+        switch (code) {
+            case 'ETIMEDOUT':
+            case 'ECONNRESET':
+            case 'EADDRINUSE':
+            case 'ECONNREFUSED':
+            case 'EPIPE':
+            case 'ENOTFOUND':
+            case 'ENETUNREACH':
+            case 'EAI_AGAIN':
+            case 'EPROTO':
+                return true;
+            default:
+                return typeof errno === 'number' && isRetryable(Math.abs(errno));
+        }
+    }
+    return false;
+}
+exports.checkRetryable = checkRetryable;
+function isRetryable(value, timeout) {
+    switch (value) {
+        case 408 /* HTTP_STATUS.REQUEST_TIMEOUT */:
+        case 504 /* HTTP_STATUS.GATEWAY_TIMEOUT */:
+        case 522 /* HTTP_STATUS.CONNECTION_TIMED_OUT */:
+        case 524 /* HTTP_STATUS.A_TIMEOUT_OCCURRED */:
+            if (timeout) {
+                return true;
+            }
+        case 429 /* HTTP_STATUS.TOO_MANY_REQUESTS */:
+        case 499 /* HTTP_STATUS.CLIENT_CLOSED_REQUEST */:
+        case 500 /* HTTP_STATUS.INTERNAL_SERVER_ERROR */:
+        case 502 /* HTTP_STATUS.BAD_GATEWAY */:
+        case 503 /* HTTP_STATUS.SERVICE_UNAVAILABLE */:
+        case 521 /* HTTP_STATUS.WEB_SERVER_IS_DOWN */:
+            if (!timeout) {
+                return true;
+            }
+        default:
+            return false;
+    }
+}
+exports.isRetryable = isRetryable;
+function trimPath(value) {
+    const length = value.length - 1;
+    return value[length] === '/' ? value.substring(0, length) : value;
+}
+exports.trimPath = trimPath;
+function asInt(value) {
+    switch (typeof value) {
+        case 'string':
+            return safeInt(parseInt(value));
+        case 'number':
+            return safeInt(Math.floor(value));
+        default:
+            return NaN;
+    }
+}
+exports.asInt = asInt;
+function asFloat(value) {
+    switch (typeof value) {
+        case 'string':
+            return safeInt(parseFloat(value));
+        case 'number':
+            return safeInt(value);
+        default:
+            return NaN;
+    }
+}
+exports.asFloat = asFloat;
+function fromSeconds(value) {
+    switch (typeof value) {
+        case 'string':
+            return safeInt(Math.ceil(parseFloat(value)) * 1000 /* TIME.S */);
+        case 'number':
+            return safeInt(value * 1000 /* TIME.S */);
+        default:
+            return NaN;
+    }
+}
+exports.fromSeconds = fromSeconds;