cvitool 1.0.6

package/README.md

@@ -0,0 +1,9 @@
+# cvitool
+
+just.
+
+## 安装
+
+```js
+npm i cvitool
+```

package/build/src/cutil.d.ts

@@ -0,0 +1,9 @@
+interface randomStringOptions {
+    special?: boolean;
+    lowercase?: boolean;
+    upperCase?: boolean;
+    number?: boolean;
+    specials?: string;
+}
+declare function randomString(length: number, options?: randomStringOptions): string;
+export { randomStringOptions, randomString };

package/build/src/cutil.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.randomString = void 0;
+const crypto_1 = require("crypto");
+function randomString(length, options) {
+    let { special = false, lowercase = true, upperCase = true, number = true, specials } = options || {};
+    if (specials) {
+        special = true;
+    }
+    if (!special && !lowercase && !upperCase && !number) {
+        throw new Error('randomString|must choose one of (special|lowercase|upperCase|number)');
+    }
+    const numbers = '0123456789';
+    const lowercaseLetters = 'abcdefghijklmnopqrstuvwxyz';
+    const upperCaseLetters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+    specials = specials || '~!@#$%^*()_+-=[]{}|;:,./<>?';
+    let targetStr = '';
+    if (special) {
+        targetStr += specials;
+    }
+    if (lowercase) {
+        targetStr += lowercaseLetters;
+    }
+    if (upperCase) {
+        targetStr += upperCaseLetters;
+    }
+    if (number) {
+        targetStr += numbers;
+    }
+    let result = '';
+    while (length > 0) {
+        result += targetStr.charAt((0, crypto_1.randomInt)(targetStr.length));
+        length--;
+    }
+    return result;
+}
+exports.randomString = randomString;

package/build/src/hgo.d.ts

@@ -0,0 +1,48 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import * as https from 'https';
+import * as http from 'http';
+import { ReadStream } from 'fs';
+type Method = 'get' | 'put' | 'post' | 'delete' | 'patch' | 'head';
+type ResType = 'json' | 'buffer' | 'stream' | 'text';
+interface CustomObject {
+    [key: string]: any;
+}
+interface baseReqOptions {
+    timeout?: number;
+    method?: Method;
+    agent?: http.Agent | https.Agent;
+    headers?: {
+        [key: string]: string;
+    };
+    resType?: ResType;
+}
+interface reqOptions extends baseReqOptions {
+    query?: {
+        [key: string]: string;
+    };
+    body?: {
+        [key: string]: any;
+    };
+}
+interface reqSendBufferOptions extends baseReqOptions {
+    buffer: Buffer;
+}
+interface reqSendStreamOptions extends baseReqOptions {
+    stream: ReadStream;
+}
+interface reqSendMultiPartOptions extends baseReqOptions {
+    form: any;
+}
+interface ResData {
+    reqUrl: string;
+    resHeaders: CustomObject;
+    resBody: http.IncomingMessage | CustomObject | string | Buffer | null;
+}
+declare function request(url: string, options?: reqOptions): Promise<ResData>;
+declare function reqSendBuffer(url: string, options: reqSendBufferOptions): Promise<ResData>;
+declare function reqSendStream(url: string, options: reqSendStreamOptions): Promise<ResData>;
+declare function reqSendMultiPart(url: string, options: reqSendMultiPartOptions): Promise<ResData>;
+export { reqOptions, reqSendBufferOptions, reqSendStreamOptions, reqSendMultiPartOptions, ResData, request, reqSendBuffer, reqSendStream, reqSendMultiPart, };

package/build/src/hgo.js

@@ -0,0 +1,265 @@
+"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.reqSendMultiPart = exports.reqSendStream = exports.reqSendBuffer = exports.request = void 0;
+const querystring = require("querystring");
+const https = require("https");
+const http = require("http");
+function getTimeOutMessage(timeout) {
+    return `request timeout of ${timeout} ms`;
+}
+function getProtocol(url) {
+    return url.startsWith('https') ? https : http;
+}
+function request(url, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { query = {}, body = {}, headers = {}, timeout = 5000, method = 'get', agent, resType = 'json' } = options || {};
+        if (Object.keys(query).length !== 0) {
+            if (url.indexOf('?') > -1) {
+                url = url + '&' + querystring.stringify(query);
+            }
+            else {
+                url = url + '?' + querystring.stringify(query);
+            }
+        }
+        const data = JSON.stringify(body);
+        const protocol = getProtocol(url);
+        const isbodyEmpty = Object.keys(body).length === 0;
+        const baseHeaders = {
+            'Content-Type': 'application/json;charset=utf-8',
+            'Content-length': isbodyEmpty ? 0 : Buffer.byteLength(data)
+        };
+        return new Promise((resolve, reject) => {
+            const req = protocol.request(url, {
+                timeout,
+                headers: Object.assign(headers, baseHeaders),
+                method,
+                agent
+            }, res => {
+                resHandld(res, resolve, reject, resType, method);
+            });
+            req.on('timeout', () => {
+                req.destroy();
+                reject(new Error(getTimeOutMessage(timeout)));
+            });
+            req.on('error', e => {
+                req.destroy();
+                reject(e);
+            });
+            if (isbodyEmpty) {
+                req.end();
+            }
+            else {
+                req.write(data, (e) => {
+                    req.end();
+                    if (e) {
+                        req.destroy();
+                        reject(e);
+                    }
+                });
+            }
+        });
+    });
+}
+exports.request = request;
+function reqSendBuffer(url, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { timeout = 60000, headers = {}, buffer, method = 'post', agent, resType = 'json' } = options;
+        const protocol = getProtocol(url);
+        return new Promise((resolve, reject) => {
+            const req = protocol.request(url, {
+                timeout,
+                headers: Object.assign(headers, { 'Content-Length': buffer.byteLength }),
+                method,
+                agent
+            }, res => {
+                resHandld(res, resolve, reject, resType, method);
+            });
+            req.on('timeout', () => {
+                req.destroy();
+                reject(new Error(getTimeOutMessage(timeout)));
+            });
+            req.on('error', e => {
+                req.destroy();
+                reject(e);
+            });
+            req.write(buffer, (e) => {
+                req.end();
+                if (e) {
+                    req.destroy();
+                    reject(e);
+                }
+            });
+        });
+    });
+}
+exports.reqSendBuffer = reqSendBuffer;
+function reqSendStream(url, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { timeout = 60000, method = 'post', stream, headers = {}, agent, resType = 'json' } = options;
+        const protocol = getProtocol(url);
+        return new Promise((resolve, reject) => {
+            const baseHeaders = {
+                'Content-Type': 'application/octet-stream',
+                'Transfer-Encoding': 'chunked',
+                Connection: 'keep-alive'
+            };
+            const req = protocol.request(url, {
+                timeout,
+                headers: Object.assign(headers, baseHeaders),
+                method,
+                agent
+            }, res => {
+                resHandld(res, resolve, reject, resType, method);
+            });
+            req.on('timeout', () => {
+                req.destroy();
+                reject(new Error(getTimeOutMessage(timeout)));
+            });
+            req.on('error', e => {
+                req.destroy();
+                reject(e);
+            });
+            stream.on('data', chunk => {
+                req.write(chunk, e => {
+                    if (e) {
+                        req.destroy();
+                        reject(e);
+                    }
+                });
+            });
+            stream.on('end', () => {
+                req.end();
+                stream.close();
+            });
+            stream.on('error', e => {
+                req.destroy();
+                stream.close();
+                reject(e);
+            });
+        });
+    });
+}
+exports.reqSendStream = reqSendStream;
+function reqSendMultiPart(url, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { timeout = 60000, headers = {}, form, agent, resType = 'json' } = options;
+        const protocol = getProtocol(url);
+        return new Promise((resolve, reject) => {
+            const req = protocol.request(url, {
+                timeout,
+                headers: Object.assign(headers, Object.assign({}, form.getHeaders())),
+                method: 'post',
+                agent
+            }, res => {
+                resHandld(res, resolve, reject, resType, 'post');
+            });
+            req.on('timeout', () => {
+                req.destroy();
+                reject(new Error(getTimeOutMessage(timeout)));
+            });
+            req.on('error', e => {
+                req.destroy();
+                reject(e);
+            });
+            form.pipe(req);
+            form.on('end', () => {
+                req.end();
+            });
+            form.on('error', e => {
+                req.destroy();
+                form.destroy();
+                reject(e);
+            });
+        });
+    });
+}
+exports.reqSendMultiPart = reqSendMultiPart;
+function resHandld(res, resolve, reject, resType, method) {
+    const reqUrl = `${res.req.protocol}//${res.req.host}${res.req.path}`;
+    const resHeaders = {};
+    for (let i = 0; i < res.rawHeaders.length; i += 2) {
+        resHeaders[res.rawHeaders[i]] = res.rawHeaders[i + 1];
+        if (i === res.rawHeaders.length - 2) {
+            break;
+        }
+    }
+    if (res.statusCode !== 200) {
+        errHandle(reject, res, reqUrl, resHeaders);
+        return;
+    }
+    const resData = {
+        reqUrl,
+        resHeaders,
+        resBody: null
+    };
+    if (method === 'head') {
+        resolve(resData);
+        return;
+    }
+    if (resType === 'stream') {
+        resData.resBody = res;
+        resolve(resData);
+        return;
+    }
+    let resBody;
+    const chunks = [];
+    res.on('data', chunk => {
+        chunks.push(chunk);
+    });
+    res.on('end', () => {
+        const buffer = Buffer.concat(chunks);
+        if (resType === 'buffer') {
+            resBody = buffer;
+        }
+        else {
+            const responseStr = buffer.toString();
+            if (resType === 'text') {
+                resBody = responseStr;
+            }
+            else {
+                try {
+                    resBody = JSON.parse(responseStr);
+                }
+                catch (e) {
+                    resBody = resData;
+                }
+            }
+        }
+        resData.resBody = resBody;
+        resolve(resData);
+    });
+}
+function errHandle(reject, res, reqUrl, resHeaders) {
+    const chunks = [];
+    res.on('data', chunk => {
+        chunks.push(chunk);
+    });
+    res.on('end', () => {
+        const buffer = Buffer.concat(chunks);
+        const resData = buffer.toString();
+        let resBody;
+        try {
+            resBody = JSON.parse(resData);
+        }
+        catch (e) {
+            resBody = resData;
+        }
+        const err = new Error();
+        err.code = res.statusCode;
+        err.name = 'statusCodeError';
+        err.message = `${res.statusCode}|${res.statusMessage}`;
+        err.resBody = resBody;
+        err.reqUrl = reqUrl;
+        err.resHeaders = resHeaders;
+        reject(err);
+    });
+}

package/build/src/streamhelper.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+import { ReadStream, WriteStream } from 'fs';
+interface pipeOptions {
+    timeout?: number;
+    readBytesPreSec?: number;
+}
+declare function pipe(source: ReadStream, target: WriteStream, options?: pipeOptions): Promise<void>;
+declare function limitStreamFlowingRate(stream: ReadStream, readBytesPreSec: number): void;
+export { pipeOptions, pipe, limitStreamFlowingRate };

package/build/src/streamhelper.js

@@ -0,0 +1,61 @@
+"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.limitStreamFlowingRate = exports.pipe = void 0;
+function pipe(source, target, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { timeout, readBytesPreSec } = options || {};
+        return new Promise((resolve, reject) => {
+            if (readBytesPreSec) {
+                limitStreamFlowingRate(source, readBytesPreSec);
+            }
+            source.pipe(target);
+            target.on('finish', () => {
+                resolve();
+            });
+            source.on('error', e => {
+                reject(e);
+            });
+            if (timeout) {
+                setTimeout(() => {
+                    if (!target.closed) {
+                        target.destroy();
+                        source.destroy();
+                        const downloadErr = new Error(`文件下载超时|${(timeout / 1000).toFixed(3)}s`);
+                        reject(downloadErr);
+                    }
+                }, timeout);
+            }
+        });
+    });
+}
+exports.pipe = pipe;
+function limitStreamFlowingRate(stream, readBytesPreSec) {
+    let start = 0;
+    let calReadBytesTotal = 0;
+    stream.on('data', (chunk) => {
+        if (!start) {
+            start = Date.now();
+        }
+        calReadBytesTotal += chunk.length;
+        const fromStartSecs = Math.ceil((Date.now() - start) / 1000);
+        if (calReadBytesTotal > fromStartSecs * readBytesPreSec && fromStartSecs > 0) {
+            const stopTime = Math.ceil((fromStartSecs - ((Date.now() - start) / 1000)) * 1000);
+            if (stopTime > 0) {
+                stream.pause();
+                setTimeout(() => {
+                    stream.resume();
+                }, stopTime);
+            }
+        }
+    });
+}
+exports.limitStreamFlowingRate = limitStreamFlowingRate;

package/index.d.ts

@@ -0,0 +1,78 @@
+import { ReadStream, WriteStream } from 'fs';
+
+import {
+    reqOptions,
+    reqSendBufferOptions,
+    reqSendStreamOptions,
+    reqSendMultiPartOptions,
+    ResData
+} from './src/hgo';
+
+import {
+    pipeOptions,
+} from './src/streamhelper';
+
+import {
+    randomStringOptions
+} from './src/cutil';
+
+interface Hgo {
+    /**
+     * 发出普通请求
+     * @param url 
+     * @param options 
+     */
+    request(url: string, options?: reqOptions): Promise<ResData>,
+    /**
+     * 发出传送buffer请求
+     * @param url 
+     * @param options 
+     */
+    reqSendBuffer(url: string, options: reqSendBufferOptions): Promise<ResData>,
+    /**
+     * 发出传送stream请求
+     * @param url 
+     * @param options 
+     */
+    reqSendStream(url: string, options: reqSendStreamOptions): Promise<ResData>,
+    /**
+     * 发出传送表单formData请求
+     * @param url 
+     * @param options 
+     */
+    reqSendMultiPart(url: string, options: reqSendMultiPartOptions): Promise<ResData>,
+}
+
+interface StreamHelper {
+    /**
+     * 实现一个promise流传输
+     * @param source 
+     * @param target 
+     * @param options 
+     */
+    pipe(source: ReadStream, target: WriteStream, options?: pipeOptions): Promise<void>,
+    /**
+     * stream传输限流
+     * @param stream 
+     * @param readBytesPreSec 
+     */
+    limitStreamFlowingRate(stream: ReadStream, readBytesPreSec: number): void
+}
+
+interface Cutil {
+    /**
+     * 获取一个随机字符串
+     * @param length 
+     * @param options 
+     */
+    randomString(length: number, options?: randomStringOptions): string
+}
+
+declare const hgo: Hgo;
+declare const streamhelper: StreamHelper;
+declare const cutil: Cutil;
+export {
+    hgo,
+    streamhelper,
+    cutil
+}

package/index.js

@@ -0,0 +1,9 @@
+const hgo = require('./build/src/hgo');
+const streamhelper = require('./build/src/streamhelper');
+const cutil = require('./build/src/cutil');
+
+module.exports = {
+    hgo,
+    streamhelper,
+    cutil
+};

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "cvitool",
+  "version": "1.0.6",
+  "description": "cvitool",
+  "main": "index.js",
+  "scripts": {
+    "test": "npm run build && node ./build/test/index.test.js",
+    "build": "rm -rf build && tsc"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@typescript-eslint/eslint-plugin": "5.54.0",
+    "@typescript-eslint/parser": "5.54.0",
+    "eslint": "7.32.0",
+    "eslint-config-standard": "16.0.3",
+    "@types/node": "20.10.4"
+  },
+  "files": [
+    "build/src",
+    "src",
+    "index.js",
+    "index.d.ts",
+    "package.json"
+  ],
+  "keywords": [],
+  "repository": {
+    "type": "git",
+    "url": ""
+  },
+  "author": "",
+  "license": "ISC"
+}

package/src/cutil.ts

@@ -0,0 +1,47 @@
+import { randomInt } from 'crypto';
+
+interface randomStringOptions {
+    special?: boolean,
+    lowercase?: boolean,
+    upperCase?: boolean,
+    number?: boolean
+    specials?: string
+}
+
+function randomString(length: number, options?: randomStringOptions) {
+    let { special = false, lowercase = true, upperCase = true, number = true, specials } = options || {};
+    if (specials) {
+        special = true;
+    }
+    if (!special && !lowercase && !upperCase && !number) {
+        throw new Error('randomString|must choose one of (special|lowercase|upperCase|number)');
+    }
+    const numbers = '0123456789';
+    const lowercaseLetters = 'abcdefghijklmnopqrstuvwxyz';
+    const upperCaseLetters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+    specials = specials || '~!@#$%^*()_+-=[]{}|;:,./<>?';
+    let targetStr = '';
+    if (special) {
+        targetStr += specials;
+    }
+    if (lowercase) {
+        targetStr += lowercaseLetters;
+    }
+    if (upperCase) {
+        targetStr += upperCaseLetters;
+    }
+    if (number) {
+        targetStr += numbers;
+    }
+    let result = '';
+    while (length > 0) {
+        result += targetStr.charAt(randomInt(targetStr.length));
+        length--;
+    }
+    return result;
+}
+
+export {
+    randomStringOptions,
+    randomString
+};

package/src/hgo.ts

@@ -0,0 +1,300 @@
+import * as querystring from 'querystring';
+import * as https from 'https';
+import * as http from 'http';
+import { ReadStream } from 'fs';
+
+type Method = 'get' | 'put' | 'post' | 'delete' | 'patch' | 'head';
+type ResType = 'json' | 'buffer' | 'stream' | 'text';
+
+interface CustomObject {
+    [key: string]: any
+}
+
+interface baseReqOptions {
+    timeout?: number,
+    method?: Method,
+    agent?: http.Agent | https.Agent,
+    headers?: {
+        [key: string]: string
+    },
+    resType?: ResType
+}
+
+interface reqOptions extends baseReqOptions {
+    query?: {
+        [key: string]: string
+    },
+    body?: {
+        [key: string]: any
+    }
+}
+
+interface reqSendBufferOptions extends baseReqOptions {
+    buffer: Buffer
+}
+
+interface reqSendStreamOptions extends baseReqOptions {
+    stream: ReadStream
+}
+
+interface reqSendMultiPartOptions extends baseReqOptions {
+    form: any
+}
+
+interface ResData {
+    reqUrl: string,
+    resHeaders: CustomObject,
+    resBody: http.IncomingMessage | CustomObject | string | Buffer | null
+}
+
+function getTimeOutMessage(timeout: number): string {
+    return `request timeout of ${timeout} ms`;
+}
+
+function getProtocol(url: string) {
+    return url.startsWith('https') ? https : http;
+}
+
+async function request(url: string, options?: reqOptions): Promise<ResData> {
+    const { query = {}, body = {}, headers = {}, timeout = 5000, method = 'get', agent, resType = 'json' } = options || {};
+    if (Object.keys(query).length !== 0) {
+        if (url.indexOf('?') > -1) {
+            url = url + '&' + querystring.stringify(query);
+        } else {
+            url = url + '?' + querystring.stringify(query);
+        }
+    }
+    const data = JSON.stringify(body);
+    const protocol = getProtocol(url);
+    const isbodyEmpty = Object.keys(body).length === 0;
+    const baseHeaders = {
+        'Content-Type': 'application/json;charset=utf-8',
+        'Content-length': isbodyEmpty ? 0 : Buffer.byteLength(data)
+    };
+    return new Promise((resolve, reject) => {
+        const req = protocol.request(url, {
+            timeout,
+            headers: Object.assign(headers, baseHeaders),
+            method,
+            agent
+        }, res => {
+            resHandld(res, resolve, reject, resType, method);
+        });
+        req.on('timeout', () => {
+            req.destroy();
+            reject(new Error(getTimeOutMessage(timeout)));
+        });
+        req.on('error', e => {
+            req.destroy();
+            reject(e);
+        });
+        if (isbodyEmpty) {
+            req.end();
+        } else {
+            req.write(data, (e) => {
+                req.end();
+                if (e) {
+                    req.destroy();
+                    reject(e);
+                }
+            });
+        }
+    });
+}
+
+async function reqSendBuffer(url: string, options: reqSendBufferOptions): Promise<ResData> {
+    const { timeout = 60000, headers = {}, buffer, method = 'post', agent, resType = 'json' } = options;
+    const protocol = getProtocol(url);
+    return new Promise((resolve, reject) => {
+        const req = protocol.request(url, {
+            timeout,
+            headers: Object.assign(headers, { 'Content-Length': buffer.byteLength }),
+            method,
+            agent
+        }, res => {
+            resHandld(res, resolve, reject, resType, method);
+        });
+        req.on('timeout', () => {
+            req.destroy();
+            reject(new Error(getTimeOutMessage(timeout)));
+        });
+        req.on('error', e => {
+            req.destroy();
+            reject(e);
+        });
+        req.write(buffer, (e) => {
+            req.end();
+            if (e) {
+                req.destroy();
+                reject(e);
+            }
+        });
+    });
+}
+
+async function reqSendStream(url: string, options: reqSendStreamOptions): Promise<ResData> {
+    const { timeout = 60000, method = 'post', stream, headers = {}, agent, resType = 'json' } = options;
+    const protocol = getProtocol(url);
+    return new Promise((resolve, reject) => {
+        const baseHeaders = {
+            'Content-Type': 'application/octet-stream',
+            'Transfer-Encoding': 'chunked',
+            Connection: 'keep-alive'
+        };
+        const req = protocol.request(url, {
+            timeout,
+            headers: Object.assign(headers, baseHeaders),
+            method,
+            agent
+        }, res => {
+            resHandld(res, resolve, reject, resType, method);
+        });
+        req.on('timeout', () => {
+            req.destroy();
+            reject(new Error(getTimeOutMessage(timeout)));
+        });
+        req.on('error', e => {
+            req.destroy();
+            reject(e);
+        });
+        stream.on('data', chunk => {
+            req.write(chunk, e => {
+                if (e) {
+                    req.destroy();
+                    reject(e);
+                }
+            });
+        });
+        stream.on('end', () => {
+            req.end();
+            stream.close();
+        });
+        stream.on('error', e => {
+            req.destroy();
+            stream.close();
+            reject(e);
+        });
+    });
+}
+
+async function reqSendMultiPart(url: string, options: reqSendMultiPartOptions): Promise<ResData> {
+    const { timeout = 60000, headers = {}, form, agent, resType = 'json' } = options;
+    const protocol = getProtocol(url);
+    return new Promise((resolve, reject) => {
+        const req = protocol.request(url, {
+            timeout,
+            headers: Object.assign(headers, { ...form.getHeaders() }),
+            method: 'post',
+            agent
+        }, res => {
+            resHandld(res, resolve, reject, resType, 'post');
+        });
+        req.on('timeout', () => {
+            req.destroy();
+            reject(new Error(getTimeOutMessage(timeout)));
+        });
+        req.on('error', e => {
+            req.destroy();
+            reject(e);
+        });
+        form.pipe(req);
+        form.on('end', () => {
+            req.end();
+        });
+        form.on('error', e => {
+            req.destroy();
+            form.destroy();
+            reject(e);
+        });
+    });
+}
+
+function resHandld(res: http.IncomingMessage, resolve: any, reject: any, resType: ResType, method: Method) {
+    const reqUrl = `${(res as any).req.protocol}//${(res as any).req.host}${(res as any).req.path}`;
+    const resHeaders: CustomObject = {};
+    for (let i = 0; i < res.rawHeaders.length; i += 2) {
+        resHeaders[res.rawHeaders[i]] = res.rawHeaders[i + 1];
+        if (i === res.rawHeaders.length - 2) {
+            break;
+        }
+    }
+    if (res.statusCode !== 200) {
+        errHandle(reject, res, reqUrl, resHeaders);
+        return;
+    }
+    const resData = {
+        reqUrl,
+        resHeaders,
+        resBody: null
+    };
+    if (method === 'head') {
+        resolve(resData);
+        return;
+    }
+    if (resType === 'stream') {
+        resData.resBody = res;
+        resolve(resData);
+        return;
+    }
+    let resBody: Buffer | object | string;
+    const chunks = [];
+    res.on('data', chunk => {
+        chunks.push(chunk);
+    });
+    res.on('end', () => {
+        const buffer = Buffer.concat(chunks);
+        if (resType === 'buffer') {
+            resBody = buffer;
+        } else {
+            const responseStr = buffer.toString();
+            if (resType === 'text') {
+                resBody = responseStr;
+            } else {
+                try {
+                    resBody = JSON.parse(responseStr);
+                } catch (e) {
+                    resBody = resData;
+                }
+            }
+        }
+        resData.resBody = resBody;
+        resolve(resData);
+    });
+}
+
+function errHandle(reject: any, res: http.IncomingMessage, reqUrl: string, resHeaders: CustomObject) {
+    const chunks = [];
+    res.on('data', chunk => {
+        chunks.push(chunk);
+    });
+    res.on('end', () => {
+        const buffer = Buffer.concat(chunks);
+        const resData = buffer.toString();
+        let resBody: object | string;
+        try {
+            resBody = JSON.parse(resData);
+        } catch (e) {
+            resBody = resData;
+        }
+        const err: any = new Error();
+        err.code = res.statusCode;
+        err.name = 'statusCodeError';
+        err.message = `${res.statusCode}|${res.statusMessage}`;
+        err.resBody = resBody;
+        err.reqUrl = reqUrl;
+        err.resHeaders = resHeaders;
+        reject(err);
+    });
+}
+
+export {
+    reqOptions,
+    reqSendBufferOptions,
+    reqSendStreamOptions,
+    reqSendMultiPartOptions,
+    ResData,
+    request,
+    reqSendBuffer,
+    reqSendStream,
+    reqSendMultiPart,
+};

package/src/streamhelper.ts

@@ -0,0 +1,59 @@
+import { ReadStream, WriteStream } from 'fs';
+
+interface pipeOptions {
+    timeout?: number,
+    readBytesPreSec?: number
+}
+
+async function pipe(source: ReadStream, target: WriteStream, options?: pipeOptions): Promise<void> {
+    const { timeout, readBytesPreSec } = options || {};
+    return new Promise((resolve, reject) => {
+        if (readBytesPreSec) {
+            limitStreamFlowingRate(source, readBytesPreSec);
+        }
+        source.pipe(target);
+        target.on('finish', () => {
+            resolve();
+        });
+        source.on('error', e => {
+            reject(e);
+        });
+        if (timeout) {
+            setTimeout(() => {
+                if (!target.closed) {
+                    target.destroy();
+                    source.destroy();
+                    const downloadErr = new Error(`文件下载超时|${(timeout / 1000).toFixed(3)}s`);
+                    reject(downloadErr);
+                }
+            }, timeout);
+        }
+    });
+}
+
+function limitStreamFlowingRate(stream: ReadStream, readBytesPreSec: number) {
+    let start = 0;
+    let calReadBytesTotal = 0;
+    stream.on('data', (chunk) => {
+        if (!start) {
+            start = Date.now();
+        }
+        calReadBytesTotal += chunk.length;
+        const fromStartSecs = Math.ceil((Date.now() - start) / 1000);
+        if (calReadBytesTotal > fromStartSecs * readBytesPreSec && fromStartSecs > 0) {
+            const stopTime = Math.ceil((fromStartSecs - ((Date.now() - start) / 1000)) * 1000);
+            if (stopTime > 0) {
+                stream.pause();
+                setTimeout(() => {
+                    stream.resume();
+                }, stopTime);
+            }
+        }
+    });
+}
+
+export {
+    pipeOptions,
+    pipe,
+    limitStreamFlowingRate
+};