@e-mc/request 0.11.8 → 0.12.1

package/README.md

@@ -1,7 +1,7 @@
 # @e-mc/request
 
-* NodeJS 16 LTS
-* ES2021
+* NodeJS 18
+* ES2022
 
 ## General Usage
 
@@ -9,12 +9,12 @@
 
 ## Interface
 
-* [View Source](https://www.unpkg.com/@e-mc/types@0.11.8/lib/index.d.ts)
+* [View Source](https://www.unpkg.com/@e-mc/types@0.12.1/lib/index.d.ts)
 
 ```typescript
 import type { IModule, ModuleConstructor } from "./index";
 import type { HttpAgentSettings, HttpProtocolVersion, HttpRequestClient, InternetProtocolVersion } from "./http";
-import type { ApplyOptions, Aria2Options, FormDataPart, HeadersOnCallback, HostConfig, IHttpAdapter, OpenOptions, PostOptions, ProxySettings, PutOptions, ReadExpectType, RequestInit, StatusOnCallback } from "./request";
+import type { ApplyOptions, Aria2Options, FormDataPart, HeadersOnCallback, HostConfig, IHttpAdapter, OpenOptions, PostOptions, ProxySettings, PutOptions, RcloneOptions, ReadExpectType, RequestInit, StatusOnCallback } from "./request";
 import type { DnsLookupSettings, RequestModule, RequestSettings } from "./settings";
 
 import type { ClientRequest, OutgoingHttpHeaders } from "node:http";
@@ -42,6 +42,8 @@ interface IRequest extends IModule {
     headersOf(uri: string): OutgoingHttpHeaders | undefined;
     aria2c(uri: string | URL, pathname: string): Promise<string[]>;
     aria2c(uri: string | URL, options?: Aria2Options): Promise<string[]>;
+    rclone(uri: string, pathname: string): Promise<string[]>;
+    rclone(uri: string, options?: RcloneOptions): Promise<string[]>;
     json(uri: string | URL, options?: OpenOptions): Promise<object | null>;
     pipe(uri: string | URL, to: Writable, options?: OpenOptions): Promise<null>;
     opts(url: string | URL, options?: OpenOptions): HostConfig;
@@ -72,9 +74,9 @@ interface RequestConstructor extends ModuleConstructor {
     readTLSKey(value: string, cache?: boolean): string;
     readTLSCert(value: string, cache?: boolean): string;
     isCert(value: string): boolean;
-    /** @deprecated */
+    /** @deprecated @e-mc/request/util */
     fromURL(url: URL, value: string): string;
-    /** @deprecated */
+    /** @deprecated @e-mc/request/util */
     fromStatusCode(value: number | string): string;
     defineHttpAgent(options: HttpAgentSettings): void;
     defineDnsLookup(options: DnsLookupSettings, clear?: boolean): void;
@@ -168,6 +170,48 @@ interface DownloadModule {
         file_allocation?: "none" | "prealloc" | "trunc" | "falloc";
         conf_path?: string;
     };
+    rclone?: {
+        bin?: string | false;
+        exec?: {
+            uid?: number;
+            gid?: number;
+        };
+        /* Copy */
+        check_first?: boolean;
+        checksum?: boolean;
+        cutoff_mode?: "HARD" | "SOFT" | "CAUTIOUS";
+        ignore_case_sync?: boolean;
+        ignore_checksum?: boolean;
+        ignore_existing?: boolean;
+        ignore_size?: boolean;
+        ignore_times?: boolean;
+        immutable?: boolean;
+        inplace?: boolean;
+        max_backlog?: number;
+        max_duration?: string;
+        max_transfer?: string;
+        metadata?: boolean;
+        modify_window?: string;
+        multi_thread_chunk_size?: string;
+        multi_thread_cutoff?: string;
+        multi_thread_streams?: number;
+        multi_thread_write_buffer_size?: string;
+        no_check_dest?: boolean;
+        no_traverse?: boolean;
+        no_update_dir_modtime?: boolean;
+        refresh_times?: boolean;
+        size_only?: boolean;
+        update?: boolean;
+        /* Listing */
+        fast_list?: boolean;
+        /* Networking */
+        bind?: string;
+        contimeout?: string;
+        disable_http2?: boolean;
+        timeout?: string;
+        /* Config */
+        config?: string;
+    };
 }
 ```
 
@@ -209,9 +253,9 @@ instance.get("http://hostname/path/config.yml", options).then(data => {
 
 ## References
 
-- https://www.unpkg.com/@e-mc/types@0.11.8/lib/http.d.ts
-- https://www.unpkg.com/@e-mc/types@0.11.8/lib/request.d.ts
-- https://www.unpkg.com/@e-mc/types@0.11.8/lib/settings.d.ts
+- https://www.unpkg.com/@e-mc/types@0.12.1/lib/http.d.ts
+- https://www.unpkg.com/@e-mc/types@0.12.1/lib/request.d.ts
+- https://www.unpkg.com/@e-mc/types@0.12.1/lib/settings.d.ts
 
 * https://www.npmjs.com/package/@types/node
 

package/http/adapter/index.js

@@ -1,15 +1,15 @@
 "use strict";
-var _a;
 const fs = require("node:fs");
 const http2 = require("node:http2");
 const yaml = require("js-yaml");
 const types_1 = require("@e-mc/types");
 const module_1 = require("@e-mc/module");
 const util_1 = require("@e-mc/request/util");
-const kOutStream = Symbol('outStream');
-const kOptions = Symbol('options');
 let LOG_TIMEFORMAT = 'readable';
 class HttpAdapter {
+    instance;
+    state;
+    uri;
     static isUnsupported(value) {
         return value === 421 || value === 505;
     }
@@ -38,20 +38,26 @@ class HttpAdapter {
                 break;
         }
     }
+    contentLength = 0;
+    retries = 0;
+    redirects = 0;
+    closed = false;
+    aborted = false;
+    timeout = null;
+    dataTime = null;
+    delayTime = undefined;
+    opts;
+    client;
+    resolve;
+    reject;
+    startTime;
+    #outStream = null;
+    #options;
     constructor(instance, state, uri, options) {
         this.instance = instance;
         this.state = state;
         this.uri = uri;
-        this.contentLength = 0;
-        this.retries = 0;
-        this.redirects = 0;
-        this.closed = false;
-        this.aborted = false;
-        this.timeout = null;
-        this.dataTime = null;
-        this.delayTime = undefined;
-        this[_a] = null;
-        this[kOptions] = options;
+        this.#options = options;
         this.startTime = state.log ? process.hrtime.bigint() : BigInt(0);
         this.setOpts();
     }
@@ -91,14 +97,14 @@ class HttpAdapter {
                     this.retryResponse(statusCode, headers['retry-after']);
                 }
                 else if (HttpAdapter.isUnsupported(statusCode)) {
-                    this.retryDownload(true, this.formatNgFlags(http2.constants.NGHTTP2_PROTOCOL_ERROR, statusCode));
+                    this.retryDownload(true, this.#formatNgFlags(http2.constants.NGHTTP2_PROTOCOL_ERROR, statusCode));
                 }
                 else {
                     switch (flags) {
                         case http2.constants.NGHTTP2_PROTOCOL_ERROR:
                         case http2.constants.NGHTTP2_INADEQUATE_SECURITY:
                         case http2.constants.NGHTTP2_HTTP_1_1_REQUIRED:
-                            this.retryDownload(true, this.formatNgFlags(flags, statusCode, headers.location));
+                            this.retryDownload(true, this.#formatNgFlags(flags, statusCode, headers.location));
                             break;
                         default:
                             this.retryDownload(false, this.formatStatus(statusCode));
@@ -186,7 +192,7 @@ class HttpAdapter {
         if (uri) {
             this.uri = uri;
         }
-        this.opts = this.instance.opts(this.uri, this[kOptions]);
+        this.opts = this.instance.opts(this.uri, this.#options);
     }
     setWriteStream() {
         const pipeTo = this.pipeTo;
@@ -454,7 +460,7 @@ class HttpAdapter {
                 return;
             }
         }
-        this.sendWarning(this.formatRetry((0, util_1.fromStatusCode)(statusCode)));
+        this.sendWarning(this.#formatRetry((0, util_1.fromStatusCode)(statusCode)));
         if ((0, util_1.isRetryable)(statusCode, true)) {
             setImmediate(this.init.bind(this));
         }
@@ -468,7 +474,7 @@ class HttpAdapter {
         return (0, util_1.isRetryable)(value) && ++this.retries <= this.retryLimit;
     }
     retryTimeout() {
-        this.sendWarning(this.formatRetry("HTTP connection timeout"));
+        this.sendWarning(this.#formatRetry("HTTP connection timeout"));
         this.init();
     }
     terminate(err) {
@@ -506,10 +512,10 @@ class HttpAdapter {
             this.outStream = null;
         }
     }
-    formatNgFlags(value, statusCode, location) {
+    #formatNgFlags(value, statusCode, location) {
         return location ? `Using HTTP 1.1 for URL redirect (${location})` : this.formatStatus(statusCode, value ? 'NGHTTP2 Error ' + value : '');
     }
-    formatRetry(message) {
+    #formatRetry(message) {
         return `${message} (${this.retries} / ${this.retryLimit})`;
     }
     set abortController(value) {
@@ -519,13 +525,13 @@ class HttpAdapter {
         return this.opts.outAbort || null;
     }
     set outStream(value) {
-        this[kOutStream] = value;
+        this.#outStream = value;
         if (value) {
             this.opts.outStream = value;
         }
     }
     get outStream() {
-        return this[kOutStream];
+        return this.#outStream;
     }
     get destroyed() {
         return this.client.destroyed || this.httpVersion === 2 && this.client.aborted;
@@ -555,5 +561,4 @@ class HttpAdapter {
         return this.state.config.redirectLimit;
     }
 }
-_a = kOutStream;
 module.exports = HttpAdapter;

package/http/host/index.js

@@ -1,18 +1,6 @@
 "use strict";
-var _a, _b, _c, _d;
 const tls = require("node:tls");
 const types_1 = require("@e-mc/types");
-const kProtocol = Symbol('protocol');
-const kSecure = Symbol('secure');
-const kHostname = Symbol('hostname');
-const kPort = Symbol('port');
-const kOrigin = Symbol('origin');
-const kStreamSize = Symbol('streamSize');
-const kVersion = Symbol('version');
-const kVersionData = Symbol('versionData');
-const kAltSvc = Symbol('altSvc');
-const kAltSvcQueue = Symbol('altSvcQueue');
-const kAltSvcError = Symbol('altSvcError');
 const HOST_LOCAL = new Set(['localhost']);
 const HOST_STREAM = new Map();
 const HOST_HTTP_1_1 = [];
@@ -73,44 +61,52 @@ class HttpHost {
             this.defineProtocolNegotiation(protocol);
         }
     }
+    localhost;
+    _tlsConnect = null;
+    #version;
+    #altSvc = [];
+    #altSvcQueue = [];
+    #altSvcError = [];
+    #protocol;
+    #secure;
+    #hostname;
+    #port;
+    #origin;
+    #streamSize;
+    #versionData = [
+        [0, 0, 0, 1, -1],
+        [0, 0, 0, -1, -1]
+    ];
     constructor(url, httpVersion = 1) {
-        this[_a] = [
-            [0, 0, 0, 1, -1],
-            [0, 0, 0, -1, -1]
-        ];
-        this[_b] = [];
-        this[_c] = [];
-        this[_d] = [];
-        this._tlsConnect = null;
         const { protocol, hostname } = url;
         const secure = protocol === 'https:';
         const port = url.port || (secure ? '443' : '80');
         let address = hostname + ':' + port;
-        this[kProtocol] = protocol;
-        this[kSecure] = secure;
-        this[kHostname] = hostname;
-        this[kPort] = port;
-        this[kOrigin] = url.origin;
+        this.#protocol = protocol;
+        this.#secure = secure;
+        this.#hostname = hostname;
+        this.#port = port;
+        this.#origin = url.origin;
         this.localhost = HOST_LOCAL.has(hostname);
-        this[kStreamSize] = HOST_STREAM.get(address) || (this.localhost ? 65536 : 4096);
+        this.#streamSize = HOST_STREAM.get(address) || (this.localhost ? 65536 : 4096);
         if (protocol !== 'file:' && !HOST_HTTP_1_1.includes(address = protocol + '//' + address)) {
             if (secure) {
-                this[kVersion] = HOST_ALPN_H2.includes(address) ? 2 : httpVersion;
+                this.#version = HOST_ALPN_H2.includes(address) ? 2 : httpVersion;
                 return;
             }
             if (HOST_ALPN_H2C.includes(address)) {
-                this[kVersion] = 2;
+                this.#version = 2;
                 return;
             }
         }
-        this[kVersion] = 1;
-        for (const version of this[kVersionData]) {
+        this.#version = 1;
+        for (const version of this.#versionData) {
             version[4] = 0;
         }
     }
     async hasProtocol(version) {
         if (version > 1) {
-            const data = this[kVersionData][version - 1];
+            const data = this.#versionData[version - 1];
             if (!data || !this.secure) {
                 return 0;
             }
@@ -153,11 +149,11 @@ class HttpHost {
         return 1;
     }
     success(version, status) {
-        const data = this[kVersionData][version - 1];
+        const data = this.#versionData[version - 1];
         return status ? data[0] : ++data[0];
     }
     failed(version, status) {
-        const data = this[kVersionData][version - 1];
+        const data = this.#versionData[version - 1];
         if (status) {
             return data[1];
         }
@@ -165,7 +161,7 @@ class HttpHost {
         return ++data[1];
     }
     error(version, status) {
-        const data = this[kVersionData][version - 1];
+        const data = this.#versionData[version - 1];
         if (status) {
             return data[2];
         }
@@ -180,7 +176,7 @@ class HttpHost {
                 this.clearAltSvc();
                 return;
             }
-            const data = this[kVersionData];
+            const data = this.#versionData;
             for (let i = data.length - 1; i >= version; --i) {
                 const host = data[i];
                 if (host[4] === 0) {
@@ -188,16 +184,16 @@ class HttpHost {
                 }
                 const increment = (flag) => {
                     host[4] = flag;
-                    if (this[kVersion] < i + 1) {
-                        this[kVersion] = i + 1;
+                    if (this.#version < i + 1) {
+                        this.#version = i + 1;
                         return true;
                     }
                     return false;
                 };
                 const addresses = [];
                 const time = Date.now();
-                const hostname = this[kHostname];
-                const excluded = this[kAltSvcError];
+                const hostname = this.#hostname;
+                const excluded = this.#altSvcError;
                 for (const match of altSvc.matchAll(new RegExp(`h${i + 1}(?:-\\d+)?="([^:]*):(\\d+)"([^,]*)`, 'g'))) {
                     const port = match[2];
                     if (!match[1] && port === this.port) {
@@ -219,7 +215,7 @@ class HttpHost {
                 }
                 if (addresses.length > 0) {
                     this.closeAltSvc();
-                    this[kAltSvcQueue] = addresses.sort((a, b) => {
+                    this.#altSvcQueue = addresses.sort((a, b) => {
                         if (a[0] === hostname) {
                             return -1;
                         }
@@ -248,10 +244,10 @@ class HttpHost {
         }
     }
     didAltSvc(version) {
-        return this[kVersionData][version][4] !== -1;
+        return this.#versionData[version][4] !== -1;
     }
     nextAltSvc() {
-        const queue = this[kAltSvcQueue].shift();
+        const queue = this.#altSvcQueue.shift();
         if (queue) {
             const [hostname, port, expires, version] = queue;
             const timeout = expires - Date.now();
@@ -266,20 +262,20 @@ class HttpHost {
                     }
                 }, timeout);
             }
-            this[kAltSvc] = [hostname, port, timer, version, this.protocol + '//' + hostname + ':' + port];
+            this.#altSvc = [hostname, port, timer, version, this.protocol + '//' + hostname + ':' + port];
             return true;
         }
         return false;
     }
     closeAltSvc(error) {
-        const [hostname, port, timeout, version] = this[kAltSvc];
+        const [hostname, port, timeout, version] = this.#altSvc;
         if (hostname) {
-            this[kAltSvc] = [];
+            this.#altSvc = [];
             if (timeout) {
                 clearTimeout(timeout);
             }
             if (error) {
-                this[kAltSvcError].push(`h${version}:${hostname}:${port}`);
+                this.#altSvcError.push(`h${version}:${hostname}:${port}`);
                 return this.nextAltSvc();
             }
         }
@@ -287,7 +283,7 @@ class HttpHost {
     }
     clearAltSvc(version) {
         if (version) {
-            if (this[kAltSvcQueue].length === 0) {
+            if (this.#altSvcQueue.length === 0) {
                 this.flagAltSvc(version, 0);
             }
             else if (!this.closeAltSvc(true)) {
@@ -296,9 +292,9 @@ class HttpHost {
         }
         else {
             this.closeAltSvc();
-            this[kAltSvcQueue] = [];
-            this[kAltSvcError] = [];
-            for (const item of this[kVersionData]) {
+            this.#altSvcQueue = [];
+            this.#altSvcError = [];
+            for (const item of this.#versionData) {
                 if (item[3]) {
                     item[4] = -1;
                 }
@@ -306,11 +302,11 @@ class HttpHost {
         }
     }
     flagAltSvc(version, value) {
-        this[kVersionData][version - 1][4] = value;
+        this.#versionData[version - 1][4] = value;
     }
     reset() {
         this.clearAltSvc();
-        this[kVersionData].forEach((item, index) => {
+        this.#versionData.forEach((item, index) => {
             item[0] = 0;
             item[1] = 0;
             item[2] = 0;
@@ -320,37 +316,36 @@ class HttpHost {
         });
     }
     v2() {
-        return this[kVersion] === 2;
+        return this.#version === 2;
     }
     set version(value) {
         switch (value) {
             case 1:
             case 2:
-                this.flagAltSvc(this[kVersion] = value, -1);
+                this.flagAltSvc(this.#version = value, -1);
                 break;
         }
     }
     get version() {
-        return this[kVersion];
+        return this.#version;
     }
     get protocol() {
-        return this[kProtocol];
+        return this.#protocol;
     }
     get secure() {
-        return this[kSecure];
+        return this.#secure;
     }
     get hostname() {
-        return this[kAltSvc][0] || this[kHostname];
+        return this.#altSvc[0] || this.#hostname;
     }
     get port() {
-        return this[kAltSvc][1] || this[kPort];
+        return this.#altSvc[1] || this.#port;
     }
     get origin() {
-        return this[kAltSvc][4] || this[kOrigin];
+        return this.#altSvc[4] || this.#origin;
     }
     get streamSize() {
-        return this[kStreamSize];
+        return this.#streamSize;
     }
 }
-_a = kVersionData, _b = kAltSvc, _c = kAltSvcQueue, _d = kAltSvcError;
 module.exports = HttpHost;