@zwa73/utils 1.0.169 → 1.0.171

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (10) hide show
  1. package/dist/UtilCom.d.ts +82 -40
  2. package/dist/UtilCom.js +158 -97
  3. package/dist/UtilFunctions.d.ts +5 -4
  4. package/dist/UtilFunctions.js +6 -6
  5. package/dist/UtilLogger.d.ts +1 -1
  6. package/dist/UtilLogger.js +1 -1
  7. package/package.json +2 -1
  8. package/src/UtilCom.ts +176 -88
  9. package/src/UtilFunctions.ts +9 -8
  10. package/src/UtilLogger.ts +2 -2
package/dist/UtilCom.d.ts CHANGED
@@ -1,12 +1,17 @@
1
1
  import { AnyString, JObject, ReqVerifyFn } from "./UtilInterfaces";
2
+ import http from 'http';
2
3
  import { RepeatPromiseOpt, RepeatPromiseResult } from "./UtilFunctions";
3
- export type ComPostOption = {
4
+ export type ComRequestOption = {
5
+ /**超时时间/秒 最小为10秒 */
6
+ timeLimit?: number;
7
+ /**请求协议 */
8
+ protocol: 'http' | 'https';
4
9
  /**请求域名 */
5
10
  hostname: string;
6
11
  /**请求路径 */
7
12
  path: string;
8
- /**方式 post为 POST */
9
- method: 'POST';
13
+ /**请求方式 post 为 */
14
+ method: 'POST' | 'GET';
10
15
  /**端口 */
11
16
  port?: number;
12
17
  /**请求头 */
@@ -17,54 +22,91 @@ export type ComPostOption = {
17
22
  'Content-Length'?: number;
18
23
  };
19
24
  };
20
- type RepeatPostOpt = Partial<{
21
- /**httppost 超时中断时间限制 */
22
- postTimeLimit?: number;
23
- }> & RepeatPromiseOpt;
25
+ type HttpResp = {
26
+ /**响应头 */
27
+ headers: http.IncomingHttpHeaders;
28
+ /**响应状态码 */
29
+ statusCode?: number;
30
+ /**响应数据 */
31
+ data: string;
32
+ };
24
33
  /**网络工具 */
25
34
  export declare namespace UtilCom {
26
- /**发送一个 https POST请求并接受数据
35
+ /**发送一个 https POST 请求并接受数据
36
+ * @async
37
+ * @param json - 数据对象
38
+ * @param comReqOpt - 请求参数
39
+ * @returns 结果 undefined 为未能成功接收
40
+ */
41
+ function httpsPost(json: JObject, comReqOpt: Omit<ComRequestOption, 'protocol' | 'method'>): Promise<HttpResp | undefined>;
42
+ /**发送一个 http POST 请求并接受数据
43
+ * @async
44
+ * @param json - 数据对象
45
+ * @param comReqOpt - 请求参数
46
+ * @returns 结果 undefined 为未能成功接收
47
+ */
48
+ function httpPost(json: JObject, comReqOpt: Omit<ComRequestOption, 'protocol' | 'method'>): Promise<HttpResp | undefined>;
49
+ /**发送一个 https GET 请求并接受数据
27
50
  * @async
28
- * @param json - 数据对象
29
- * @param options - 参数对象
30
- * @param timeLimit - 超时时间/秒 最小为10秒
31
- * @returns 结果 null 为未能成功接收
51
+ * @param json - 数据对象
52
+ * @param comReqOpt - 请求参数
53
+ * @returns 结果 undefined 为未能成功接收
32
54
  */
33
- function httpsPost(json: JObject, options: ComPostOption, timeLimit?: number): Promise<JObject | null>;
34
- /**发送一个 http POST请求并接受数据
55
+ function httpsGet(json: JObject, comReqOpt: Omit<ComRequestOption, 'protocol' | 'method'>): Promise<HttpResp | undefined>;
56
+ /**发送一个 http GET 请求并接受数据
35
57
  * @async
36
- * @param json - 数据对象
37
- * @param options - 参数对象
38
- * @param timeLimit - 超时时间/秒 最小为10秒
39
- * @returns 结果 null 为未能成功接收
58
+ * @param json - 数据对象
59
+ * @param comReqOpt - 请求参数
60
+ * @returns 结果 undefined 为未能成功接收
40
61
  */
41
- function httpPost(json: JObject, options: ComPostOption, timeLimit?: number): Promise<JObject | null>;
62
+ function httpGet(json: JObject, comReqOpt: Omit<ComRequestOption, 'protocol' | 'method'>): Promise<HttpResp | undefined>;
42
63
  /**重复一个 https POST请求并接受数据
43
64
  * @async
44
- * @param json - 数据对象
45
- * @param options - 参数对象
46
- * @param verifyFn - 判断有效性函数
47
- * @param opt - 可选参数
48
- * @param opt.post_timelimit - 超时时间/秒 最小为10秒 默认无限
49
- * @param opt.count - 重试次数 默认3
50
- * @param opt.try_interval - 重试超时时间/秒 最小为5秒 默认180
51
- * @param opt.try_delay - 重试间隔 秒 默认0
52
- * @returns 结果 null 为未能成功接收
65
+ * @param json - 数据对象
66
+ * @param comReqOpt - 请求参数
67
+ * @param verifyFn - 判断有效性函数
68
+ * @param repeatOpt - 可选参数
69
+ * @param opt.count - 重试次数 默认3
70
+ * @param opt.tryInterval - 超时时间/秒 默认180 最小为5秒
71
+ * @param opt.tryDelay - 重试间隔时间/秒 默认 1
72
+ * @returns 结果 undefined 为未能成功接收
53
73
  */
54
- function httpsRepeatPost(json: JObject, options: ComPostOption, verifyFn?: ReqVerifyFn<JObject | null>, opt?: RepeatPostOpt): Promise<RepeatPromiseResult<JObject | null> | null>;
74
+ function httpsRepeatPost(json: JObject, comReqOpt: Omit<ComRequestOption, 'protocol' | 'method'>, verifyFn?: ReqVerifyFn<JObject | undefined>, repeatOpt?: RepeatPromiseOpt): Promise<RepeatPromiseResult<HttpResp | undefined> | undefined>;
55
75
  /**重复一个 http POST请求并接受数据
56
- * Object ()
57
76
  * @async
58
- * @param json - 数据对象
59
- * @param options - 参数对象
60
- * @param verifyFn - 判断有效性函数
61
- * @param opt - 可选参数
62
- * @param opt.post_timelimit - 超时时间/秒 最小为10秒 默认无限
63
- * @param opt.count - 重试次数 默认3
64
- * @param opt.try_interval - 重试超时时间/秒 最小为5秒 默认180
65
- * @param opt.try_delay - 重试间隔 秒 默认0
66
- * @returns 结果 null 为未能成功接收
77
+ * @param json - 数据对象
78
+ * @param comReqOpt - 请求参数
79
+ * @param verifyFn - 判断有效性函数
80
+ * @param repeatOpt - 可选参数
81
+ * @param opt.count - 重试次数 默认3
82
+ * @param opt.tryInterval - 超时时间/秒 默认180 最小为5秒
83
+ * @param opt.tryDelay - 重试间隔时间/秒 默认 1
84
+ * @returns 结果 undefined 为未能成功接收
85
+ */
86
+ function httpRepeatPost(json: JObject, comReqOpt: Omit<ComRequestOption, 'protocol' | 'method'>, verifyFn?: ReqVerifyFn<JObject | undefined>, repeatOpt?: RepeatPromiseOpt): Promise<RepeatPromiseResult<HttpResp | undefined> | undefined>;
87
+ /**重复一个 https GET 请求并接受数据
88
+ * @async
89
+ * @param json - 数据对象
90
+ * @param comReqOpt - 请求参数
91
+ * @param verifyFn - 判断有效性函数
92
+ * @param repeatOpt - 可选参数
93
+ * @param opt.count - 重试次数 默认3
94
+ * @param opt.tryInterval - 超时时间/秒 默认180 最小为5秒
95
+ * @param opt.tryDelay - 重试间隔时间/秒 默认 1
96
+ * @returns 结果 undefined 为未能成功接收
97
+ */
98
+ function httpsRepeatGet(json: JObject, comReqOpt: Omit<ComRequestOption, 'protocol' | 'method'>, verifyFn?: ReqVerifyFn<JObject | undefined>, repeatOpt?: RepeatPromiseOpt): Promise<RepeatPromiseResult<HttpResp | undefined> | undefined>;
99
+ /**重复一个 http GET 请求并接受数据
100
+ * @async
101
+ * @param json - 数据对象
102
+ * @param comReqOpt - 请求参数
103
+ * @param verifyFn - 判断有效性函数
104
+ * @param repeatOpt - 可选参数
105
+ * @param opt.count - 重试次数 默认3
106
+ * @param opt.tryInterval - 超时时间/秒 默认180 最小为5秒
107
+ * @param opt.tryDelay - 重试间隔时间/秒 默认 1
108
+ * @returns 结果 undefined 为未能成功接收
67
109
  */
68
- function httpRepeatPost(json: JObject, options: ComPostOption, verifyFn?: ReqVerifyFn<JObject | null>, opt?: RepeatPostOpt): Promise<RepeatPromiseResult<JObject | null> | null>;
110
+ function httpRepeatGet(json: JObject, comReqOpt: Omit<ComRequestOption, 'protocol' | 'method'>, verifyFn?: ReqVerifyFn<JObject | undefined>, repeatOpt?: RepeatPromiseOpt): Promise<RepeatPromiseResult<HttpResp | undefined> | undefined>;
69
111
  }
70
112
  export {};
package/dist/UtilCom.js CHANGED
@@ -1,51 +1,36 @@
1
1
  "use strict";
2
- var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
3
- if (k2 === undefined) k2 = k;
4
- var desc = Object.getOwnPropertyDescriptor(m, k);
5
- if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
6
- desc = { enumerable: true, get: function() { return m[k]; } };
7
- }
8
- Object.defineProperty(o, k2, desc);
9
- }) : (function(o, m, k, k2) {
10
- if (k2 === undefined) k2 = k;
11
- o[k2] = m[k];
12
- }));
13
- var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
14
- Object.defineProperty(o, "default", { enumerable: true, value: v });
15
- }) : function(o, v) {
16
- o["default"] = v;
17
- });
18
- var __importStar = (this && this.__importStar) || function (mod) {
19
- if (mod && mod.__esModule) return mod;
20
- var result = {};
21
- if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
22
- __setModuleDefault(result, mod);
23
- return result;
2
+ var __importDefault = (this && this.__importDefault) || function (mod) {
3
+ return (mod && mod.__esModule) ? mod : { "default": mod };
24
4
  };
25
5
  Object.defineProperty(exports, "__esModule", { value: true });
26
6
  exports.UtilCom = void 0;
27
- const https = __importStar(require("https"));
28
- const http = __importStar(require("http"));
7
+ const https_1 = __importDefault(require("https"));
8
+ const http_1 = __importDefault(require("http"));
29
9
  const UtilLogger_1 = require("./UtilLogger");
30
10
  const UtilFunctions_1 = require("./UtilFunctions");
11
+ const querystring_1 = __importDefault(require("querystring"));
31
12
  /**网络工具 */
32
13
  var UtilCom;
33
14
  (function (UtilCom) {
34
15
  /**通用post处理
35
- * @param posttype - post类型
36
16
  * @param json - 数据对象
37
- * @param options - 参数对象
17
+ * @param comReqOpt - 请求参数
38
18
  * @param timeLimit - 超时时间/秒 最小为10秒
39
- * @returns 结果 null 为未能成功接收
19
+ * @returns 结果 undefined 为未能成功接收
40
20
  */
41
- function post(posttype, json, options, timeLimit) {
21
+ function comReq(json, comReqOpt) {
22
+ let { protocol, timeLimit, ...baseOpt } = comReqOpt;
42
23
  //转换为毫秒
43
24
  const hasTimeLimit = (timeLimit ? timeLimit >= 10 : false);
44
25
  if (hasTimeLimit && timeLimit != undefined)
45
26
  timeLimit *= 1000;
46
27
  const fixlimit = timeLimit;
47
- const jsonStr = UtilFunctions_1.UtilFunc.stringifyJToken(json);
48
- const funcName = `s${posttype}Psot`;
28
+ const isPost = baseOpt.method == "POST";
29
+ const isHttps = protocol == "https";
30
+ const jsonStr = isPost ? UtilFunctions_1.UtilFunc.stringifyJToken(json) : '';
31
+ const funcName = `${protocol}${baseOpt.method}`;
32
+ if (!isPost)
33
+ baseOpt.path += `?${querystring_1.default.stringify(json)}`;
49
34
  return new Promise((resolve, rejecte) => {
50
35
  const resFunc = (res) => {
51
36
  try {
@@ -54,7 +39,7 @@ var UtilCom;
54
39
  res.setTimeout(fixlimit, () => {
55
40
  //res.abort();
56
41
  UtilLogger_1.SLogger.warn(`${funcName} 接收反馈超时: ${timeLimit} ms`);
57
- resolve(null);
42
+ resolve(undefined);
58
43
  return;
59
44
  });
60
45
  }
@@ -63,40 +48,42 @@ var UtilCom;
63
48
  res.on('data', (chunk) => resdata += chunk);
64
49
  res.on('error', (e) => {
65
50
  UtilLogger_1.SLogger.warn(`${funcName} 接收反馈错误:${e}`);
66
- resolve(null);
51
+ resolve(undefined);
67
52
  return;
68
53
  });
69
54
  res.on('end', () => {
70
55
  if (resdata == "") {
71
56
  UtilLogger_1.SLogger.warn(funcName + " 接收反馈错误: resdata 为空");
72
- resolve(null);
57
+ resolve(undefined);
73
58
  return;
74
59
  }
75
60
  try {
76
61
  const obj = JSON.parse(resdata);
77
- UtilLogger_1.SLogger.http(funcName + " 接受信息:", UtilFunctions_1.UtilFunc.stringifyJToken(obj));
78
- resolve(obj);
62
+ UtilLogger_1.SLogger.http(`${funcName} 接受信息:`, UtilFunctions_1.UtilFunc.stringifyJToken(obj));
63
+ resolve({
64
+ headers: res.headers,
65
+ statusCode: res.statusCode,
66
+ data: obj,
67
+ });
79
68
  return;
80
69
  }
81
70
  catch (e) {
82
71
  UtilLogger_1.SLogger.warn(`${funcName} 接收反馈错误:${e}\n原始字符串:${resdata}`);
83
- resolve(null);
72
+ resolve(undefined);
84
73
  return;
85
74
  }
86
75
  });
87
76
  }
88
77
  catch (err) {
89
78
  UtilLogger_1.SLogger.warn(`${funcName} 未知错误:${err}`);
90
- resolve(null);
79
+ resolve(undefined);
91
80
  return;
92
81
  }
93
82
  };
94
83
  //路由 http/https
95
- let req = null;
96
- if (posttype === "https")
97
- req = https.request(options, resFunc);
98
- else if (posttype === "http")
99
- req = http.request(options, resFunc);
84
+ const req = isHttps
85
+ ? https_1.default.request(baseOpt, resFunc)
86
+ : http_1.default.request(baseOpt, resFunc);
100
87
  //请求超时
101
88
  if (hasTimeLimit) {
102
89
  req.setTimeout(fixlimit, () => {
@@ -106,85 +93,159 @@ var UtilCom;
106
93
  }
107
94
  req.on('error', (e) => {
108
95
  UtilLogger_1.SLogger.warn(`${funcName} 发送请求错误:${e}`);
109
- resolve(null);
96
+ resolve(undefined);
110
97
  });
111
- req.write(jsonStr);
98
+ if (isHttps)
99
+ req.write(jsonStr);
112
100
  req.end();
113
101
  });
114
102
  }
115
- /**发送一个 https POST请求并接受数据
103
+ /**通用重复post处理
116
104
  * @async
117
105
  * @param json - 数据对象
118
- * @param options - 参数对象
119
- * @param timeLimit - 超时时间/秒 最小为10秒
120
- * @returns 结果 null 为未能成功接收
106
+ * @param comReqOpt - 请求参数
107
+ * @param verifyFn - 判断有效性函数
108
+ * @param repeatOpt - 可选参数
109
+ * @param opt.count - 重试次数 默认3
110
+ * @param opt.tryInterval - 超时时间/秒 默认180 最小为5秒
111
+ * @param opt.tryDelay - 重试间隔时间/秒 默认 1
112
+ * @returns 结果 undefined 为未能成功接收
121
113
  */
122
- function httpsPost(json, options, timeLimit) {
123
- return post("https", json, options, timeLimit);
114
+ async function repeatComReq(json, comReqOpt, verifyFn, repeatOpt = {}) {
115
+ repeatOpt.tryDelay = repeatOpt.tryDelay ?? 1;
116
+ const procFn = () => comReq(json, comReqOpt);
117
+ return UtilFunctions_1.UtilFunc.repeatPromise(procFn, verifyFn, repeatOpt);
118
+ }
119
+ /**发送一个 https POST 请求并接受数据
120
+ * @async
121
+ * @param json - 数据对象
122
+ * @param comReqOpt - 请求参数
123
+ * @returns 结果 undefined 为未能成功接收
124
+ */
125
+ function httpsPost(json, comReqOpt) {
126
+ return comReq(json, {
127
+ ...comReqOpt,
128
+ method: "POST",
129
+ protocol: "https",
130
+ });
124
131
  }
125
132
  UtilCom.httpsPost = httpsPost;
126
- /**发送一个 http POST请求并接受数据
133
+ /**发送一个 http POST 请求并接受数据
127
134
  * @async
128
- * @param json - 数据对象
129
- * @param options - 参数对象
130
- * @param timeLimit - 超时时间/秒 最小为10秒
131
- * @returns 结果 null 为未能成功接收
135
+ * @param json - 数据对象
136
+ * @param comReqOpt - 请求参数
137
+ * @returns 结果 undefined 为未能成功接收
132
138
  */
133
- function httpPost(json, options, timeLimit) {
134
- return post("http", json, options, timeLimit);
139
+ function httpPost(json, comReqOpt) {
140
+ return comReq(json, {
141
+ ...comReqOpt,
142
+ method: "POST",
143
+ protocol: "http",
144
+ });
135
145
  }
136
146
  UtilCom.httpPost = httpPost;
137
- /**通用重复post处理
147
+ /**发送一个 https GET 请求并接受数据
138
148
  * @async
139
- * @param posttype - post类型
140
- * @param json - 数据对象
141
- * @param options - 参数对象
142
- * @param verifyFn - 判断有效性函数
143
- * @param opt - 可选参数
144
- * @param opt.post_timelimit - 超时时间/秒 最小为10秒 默认无限
145
- * @param opt.count - 重试次数 默认3
146
- * @param opt.try_interval - 重试超时时间/秒 最小为5秒 默认180
147
- * @param opt.try_delay - 重试间隔 秒 默认0
148
- * @returns 结果 null 为未能成功接收
149
+ * @param json - 数据对象
150
+ * @param comReqOpt - 请求参数
151
+ * @returns 结果 undefined 为未能成功接收
149
152
  */
150
- async function repeatPost(posttype, json, options, verifyFn, opt = {}) {
151
- opt.count = opt.count ?? 3;
152
- opt.tryInterval = opt.tryInterval ?? 180;
153
- opt.tryDelay = opt.tryDelay ?? 1;
154
- const procFn = () => post(posttype, json, options, opt.postTimeLimit);
155
- return UtilFunctions_1.UtilFunc.repeatPromise(procFn, verifyFn, opt);
153
+ function httpsGet(json, comReqOpt) {
154
+ return comReq(json, {
155
+ ...comReqOpt,
156
+ method: "GET",
157
+ protocol: "https",
158
+ });
159
+ }
160
+ UtilCom.httpsGet = httpsGet;
161
+ /**发送一个 http GET 请求并接受数据
162
+ * @async
163
+ * @param json - 数据对象
164
+ * @param comReqOpt - 请求参数
165
+ * @returns 结果 undefined 为未能成功接收
166
+ */
167
+ function httpGet(json, comReqOpt) {
168
+ return comReq(json, {
169
+ ...comReqOpt,
170
+ method: "GET",
171
+ protocol: "http",
172
+ });
156
173
  }
174
+ UtilCom.httpGet = httpGet;
157
175
  /**重复一个 https POST请求并接受数据
158
176
  * @async
159
- * @param json - 数据对象
160
- * @param options - 参数对象
161
- * @param verifyFn - 判断有效性函数
162
- * @param opt - 可选参数
163
- * @param opt.post_timelimit - 超时时间/秒 最小为10秒 默认无限
164
- * @param opt.count - 重试次数 默认3
165
- * @param opt.try_interval - 重试超时时间/秒 最小为5秒 默认180
166
- * @param opt.try_delay - 重试间隔 秒 默认0
167
- * @returns 结果 null 为未能成功接收
177
+ * @param json - 数据对象
178
+ * @param comReqOpt - 请求参数
179
+ * @param verifyFn - 判断有效性函数
180
+ * @param repeatOpt - 可选参数
181
+ * @param opt.count - 重试次数 默认3
182
+ * @param opt.tryInterval - 超时时间/秒 默认180 最小为5秒
183
+ * @param opt.tryDelay - 重试间隔时间/秒 默认 1
184
+ * @returns 结果 undefined 为未能成功接收
168
185
  */
169
- function httpsRepeatPost(json, options, verifyFn, opt) {
170
- return repeatPost("https", json, options, verifyFn, opt);
186
+ function httpsRepeatPost(json, comReqOpt, verifyFn, repeatOpt) {
187
+ return repeatComReq(json, {
188
+ ...comReqOpt,
189
+ method: "POST",
190
+ protocol: "https",
191
+ }, verifyFn, repeatOpt);
171
192
  }
172
193
  UtilCom.httpsRepeatPost = httpsRepeatPost;
173
194
  /**重复一个 http POST请求并接受数据
174
- * Object ()
175
195
  * @async
176
- * @param json - 数据对象
177
- * @param options - 参数对象
178
- * @param verifyFn - 判断有效性函数
179
- * @param opt - 可选参数
180
- * @param opt.post_timelimit - 超时时间/秒 最小为10秒 默认无限
181
- * @param opt.count - 重试次数 默认3
182
- * @param opt.try_interval - 重试超时时间/秒 最小为5秒 默认180
183
- * @param opt.try_delay - 重试间隔 秒 默认0
184
- * @returns 结果 null 为未能成功接收
196
+ * @param json - 数据对象
197
+ * @param comReqOpt - 请求参数
198
+ * @param verifyFn - 判断有效性函数
199
+ * @param repeatOpt - 可选参数
200
+ * @param opt.count - 重试次数 默认3
201
+ * @param opt.tryInterval - 超时时间/秒 默认180 最小为5秒
202
+ * @param opt.tryDelay - 重试间隔时间/秒 默认 1
203
+ * @returns 结果 undefined 为未能成功接收
185
204
  */
186
- function httpRepeatPost(json, options, verifyFn, opt) {
187
- return repeatPost("http", json, options, verifyFn, opt);
205
+ function httpRepeatPost(json, comReqOpt, verifyFn, repeatOpt) {
206
+ return repeatComReq(json, {
207
+ ...comReqOpt,
208
+ method: "POST",
209
+ protocol: "http",
210
+ }, verifyFn, repeatOpt);
188
211
  }
189
212
  UtilCom.httpRepeatPost = httpRepeatPost;
213
+ /**重复一个 https GET 请求并接受数据
214
+ * @async
215
+ * @param json - 数据对象
216
+ * @param comReqOpt - 请求参数
217
+ * @param verifyFn - 判断有效性函数
218
+ * @param repeatOpt - 可选参数
219
+ * @param opt.count - 重试次数 默认3
220
+ * @param opt.tryInterval - 超时时间/秒 默认180 最小为5秒
221
+ * @param opt.tryDelay - 重试间隔时间/秒 默认 1
222
+ * @returns 结果 undefined 为未能成功接收
223
+ */
224
+ function httpsRepeatGet(json, comReqOpt, verifyFn, repeatOpt) {
225
+ return repeatComReq(json, {
226
+ ...comReqOpt,
227
+ method: "GET",
228
+ protocol: "https",
229
+ }, verifyFn, repeatOpt);
230
+ }
231
+ UtilCom.httpsRepeatGet = httpsRepeatGet;
232
+ /**重复一个 http GET 请求并接受数据
233
+ * @async
234
+ * @param json - 数据对象
235
+ * @param comReqOpt - 请求参数
236
+ * @param verifyFn - 判断有效性函数
237
+ * @param repeatOpt - 可选参数
238
+ * @param opt.count - 重试次数 默认3
239
+ * @param opt.tryInterval - 超时时间/秒 默认180 最小为5秒
240
+ * @param opt.tryDelay - 重试间隔时间/秒 默认 1
241
+ * @returns 结果 undefined 为未能成功接收
242
+ */
243
+ function httpRepeatGet(json, comReqOpt, verifyFn, repeatOpt) {
244
+ return repeatComReq(json, {
245
+ ...comReqOpt,
246
+ method: "GET",
247
+ protocol: "http",
248
+ }, verifyFn, repeatOpt);
249
+ }
250
+ UtilCom.httpRepeatGet = httpRepeatGet;
190
251
  })(UtilCom || (exports.UtilCom = UtilCom = {}));
package/dist/UtilFunctions.d.ts CHANGED
@@ -35,7 +35,8 @@ type TimeoutOut<T> = Outcome<Timeout, Promise<T>>;
35
35
  /**完成的重试请求 */
36
36
  export type RepeatPromiseResult<T> = {
37
37
  completed: T;
38
- pending: Promise<T | None>[];
38
+ /**还未完成的其他Promise 若是验证失败则会返回undefined */
39
+ pending: Promise<T | undefined>[];
39
40
  };
40
41
  /**遍历对象的回调函数
41
42
  * @param key - 字段名
@@ -112,10 +113,10 @@ export declare class UtilFunc {
112
113
  * @param opt - 可选参数
113
114
  * @param opt.count - 重试次数 默认3
114
115
  * @param opt.tryInterval - 超时时间/秒 默认180 最小为5秒
115
- * @param opt.tryDelay - 重试间隔时间 默认0
116
- * @returns 结果 null 为全部失败/超时
116
+ * @param opt.tryDelay - 重试间隔时间/秒 默认 0
117
+ * @returns 结果 undefined 为全部失败/超时
117
118
  */
118
- static repeatPromise<T>(procFn: () => Promise<T>, verifyFn?: ReqVerifyFn<T>, opt?: RepeatPromiseOpt): Promise<RepeatPromiseResult<T> | null>;
119
+ static repeatPromise<T>(procFn: () => Promise<T>, verifyFn?: ReqVerifyFn<T>, opt?: RepeatPromiseOpt): Promise<RepeatPromiseResult<T> | undefined>;
119
120
  /**创建一个限时的Promise
120
121
  * @param func - 处理函数
121
122
  * @param timeLimit - 毫秒限时
package/dist/UtilFunctions.js CHANGED
@@ -172,8 +172,8 @@ class UtilFunc {
172
172
  * @param opt - 可选参数
173
173
  * @param opt.count - 重试次数 默认3
174
174
  * @param opt.tryInterval - 超时时间/秒 默认180 最小为5秒
175
- * @param opt.tryDelay - 重试间隔时间 默认0
176
- * @returns 结果 null 为全部失败/超时
175
+ * @param opt.tryDelay - 重试间隔时间/秒 默认 0
176
+ * @returns 结果 undefined 为全部失败/超时
177
177
  */
178
178
  static async repeatPromise(procFn, verifyFn, opt = {}) {
179
179
  opt.count = opt.count ?? 3;
@@ -264,17 +264,17 @@ class UtilFunc {
264
264
  if (outres.stat == UtilSymbol_1.Success)
265
265
  return outres.result;
266
266
  }
267
- return UtilSymbol_1.None;
267
+ return undefined;
268
268
  }),
269
269
  };
270
270
  }
271
- //全部失败或超时则返回null
271
+ //全部失败或超时则返回 undefined
272
272
  UtilLogger_1.SLogger.warn(`${count} 次 repeatPromise 尝试均失败`);
273
- return null;
273
+ return undefined;
274
274
  }
275
275
  catch (err) {
276
276
  UtilLogger_1.SLogger.warn(`repeatPromise 发生错误`, err);
277
- return null;
277
+ return undefined;
278
278
  }
279
279
  }
280
280
  /**创建一个限时的Promise
package/dist/UtilLogger.d.ts CHANGED
@@ -83,7 +83,7 @@ export declare class SLogger {
83
83
  * @param level - log等级 === null时不产生log
84
84
  * @returns 格式化的时间字符串
85
85
  */
86
- timeEnd(flag: string, level?: LogLevel | null): string | null;
86
+ timeEnd(flag: string, level?: LogLevel | null): string | undefined;
87
87
  /**名称为default的slogger实例 */
88
88
  private static get defaultInstance();
89
89
  /**让名称为default的logger 产生一条对应等级的log 返回自身
package/dist/UtilLogger.js CHANGED
@@ -242,7 +242,7 @@ class SLogger {
242
242
  const start = SLogger.timeTable[flag];
243
243
  if (start == null) {
244
244
  this.warn("SLogger.timeEnd 错误 flag:" + flag + " 不存在");
245
- return null;
245
+ return;
246
246
  }
247
247
  const timelen = process.hrtime(start);
248
248
  const totalMicroseconds = (timelen[0] * 1e9 + timelen[1]) / 1000;
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@zwa73/utils",
3
- "version": "1.0.169",
3
+ "version": "1.0.171",
4
4
  "description": "my utils",
5
5
  "main": "index.js",
6
6
  "scripts": {
@@ -26,6 +26,7 @@
26
26
  "json5": "^2.2.3",
27
27
  "pathe": "^1.1.2",
28
28
  "public-ip": "^6.0.2",
29
+ "querystring": "^0.2.1",
29
30
  "tiktoken": "^1.0.7",
30
31
  "winston": "^3.10.0",
31
32
  "winston-daily-rotate-file": "^4.7.1"
package/src/UtilCom.ts CHANGED
@@ -1,16 +1,21 @@
1
1
  import { AnyString, JObject, ReqVerifyFn } from "@src/UtilInterfaces";
2
- import * as https from 'https';
3
- import * as http from 'http';
2
+ import https from 'https';
3
+ import http from 'http';
4
4
  import { SLogger } from "@src/UtilLogger";
5
5
  import { RepeatPromiseOpt, RepeatPromiseResult, UtilFunc } from "@src/UtilFunctions";
6
+ import qs from "querystring";
6
7
 
7
- export type ComPostOption = {
8
+ export type ComRequestOption = {
9
+ /**超时时间/秒 最小为10秒 */
10
+ timeLimit?:number
11
+ /**请求协议 */
12
+ protocol: 'http'|'https';
8
13
  /**请求域名 */
9
14
  hostname: string;
10
15
  /**请求路径 */
11
16
  path: string;
12
- /**方式 post为 POST */
13
- method: 'POST';
17
+ /**请求方式 post 为 */
18
+ method: 'POST'|'GET';
14
19
  /**端口 */
15
20
  port?:number;
16
21
  /**请求头 */
@@ -22,29 +27,39 @@ export type ComPostOption = {
22
27
  }
23
28
  }
24
29
 
25
- type RepeatPostOpt = Partial<{
26
- /**httppost 超时中断时间限制 */
27
- postTimeLimit? : number;
28
- }> & RepeatPromiseOpt;
30
+ type HttpResp = {
31
+ /**响应头 */
32
+ headers: http.IncomingHttpHeaders;
33
+ /**响应状态码 */
34
+ statusCode?: number;
35
+ /**响应数据 */
36
+ data: string;
37
+ }
29
38
 
30
39
  /**网络工具 */
31
40
  export namespace UtilCom{
32
41
 
33
42
  /**通用post处理
34
- * @param posttype - post类型
35
43
  * @param json - 数据对象
36
- * @param options - 参数对象
44
+ * @param comReqOpt - 请求参数
37
45
  * @param timeLimit - 超时时间/秒 最小为10秒
38
- * @returns 结果 null 为未能成功接收
46
+ * @returns 结果 undefined 为未能成功接收
39
47
  */
40
- function post(posttype:"http"|"https",json:JObject,options:ComPostOption,timeLimit?:number):Promise<JObject|null>{
48
+ function comReq(json:JObject,comReqOpt:ComRequestOption):Promise<HttpResp|undefined>{
49
+ let {protocol,timeLimit,...baseOpt} = comReqOpt;
50
+
41
51
  //转换为毫秒
42
52
  const hasTimeLimit = (timeLimit ? timeLimit>=10 : false );
43
53
  if(hasTimeLimit && timeLimit!=undefined) timeLimit*=1000;
44
54
  const fixlimit = timeLimit as number;
45
55
 
46
- const jsonStr = UtilFunc.stringifyJToken(json);
47
- const funcName = `s${posttype}Psot`;
56
+ const isPost = baseOpt.method=="POST";
57
+ const isHttps = protocol=="https";
58
+
59
+ const jsonStr = isPost ? UtilFunc.stringifyJToken(json) : '';
60
+ const funcName = `${protocol}${baseOpt.method}`;
61
+
62
+ if(!isPost) baseOpt.path += `?${qs.stringify(json as any)}`;
48
63
 
49
64
  return new Promise((resolve, rejecte)=>{
50
65
  const resFunc = (res:http.IncomingMessage)=>{
@@ -54,7 +69,7 @@ function post(posttype:"http"|"https",json:JObject,options:ComPostOption,timeLim
54
69
  res.setTimeout(fixlimit, ()=>{
55
70
  //res.abort();
56
71
  SLogger.warn(`${funcName} 接收反馈超时: ${timeLimit} ms`);
57
- resolve(null);
72
+ resolve(undefined);
58
73
  return;
59
74
  });
60
75
  }
@@ -65,40 +80,42 @@ function post(posttype:"http"|"https",json:JObject,options:ComPostOption,timeLim
65
80
 
66
81
  res.on('error',(e)=>{
67
82
  SLogger.warn(`${funcName} 接收反馈错误:${e}`);
68
- resolve(null);
83
+ resolve(undefined);
69
84
  return;
70
85
  });
71
86
 
72
87
  res.on('end',()=>{
73
88
  if(resdata==""){
74
89
  SLogger.warn(funcName+" 接收反馈错误: resdata 为空");
75
- resolve(null);
90
+ resolve(undefined);
76
91
  return;
77
92
  }
78
93
  try{
79
94
  const obj = JSON.parse(resdata);
80
- SLogger.http(funcName+" 接受信息:",UtilFunc.stringifyJToken(obj));
81
- resolve(obj);
95
+ SLogger.http(`${funcName} 接受信息:`,UtilFunc.stringifyJToken(obj));
96
+ resolve({
97
+ headers: res.headers,
98
+ statusCode: res.statusCode,
99
+ data: obj,
100
+ });
82
101
  return;
83
102
  }
84
103
  catch(e){
85
104
  SLogger.warn(`${funcName} 接收反馈错误:${e}\n原始字符串:${resdata}`);
86
- resolve(null);
105
+ resolve(undefined);
87
106
  return;
88
107
  }
89
108
  });
90
109
  }catch(err){
91
110
  SLogger.warn(`${funcName} 未知错误:${err}`);
92
- resolve(null);
111
+ resolve(undefined);
93
112
  return;
94
113
  }
95
114
  };
96
115
  //路由 http/https
97
- let req:http.ClientRequest=null as any as http.ClientRequest;
98
- if(posttype === "https")
99
- req = https.request(options, resFunc);
100
- else if(posttype === "http")
101
- req = http.request(options, resFunc);
116
+ const req:http.ClientRequest= isHttps
117
+ ? https.request(baseOpt, resFunc)
118
+ : http.request(baseOpt, resFunc);
102
119
 
103
120
  //请求超时
104
121
  if(hasTimeLimit){
@@ -110,95 +127,166 @@ function post(posttype:"http"|"https",json:JObject,options:ComPostOption,timeLim
110
127
 
111
128
  req.on('error', (e)=>{
112
129
  SLogger.warn(`${funcName} 发送请求错误:${e}`);
113
- resolve(null);
130
+ resolve(undefined);
114
131
  });
115
-
116
- req.write(jsonStr);
132
+ if(isHttps) req.write(jsonStr);
117
133
  req.end();
118
134
  });
119
135
  }
120
136
 
121
- /**发送一个 https POST请求并接受数据
137
+ /**通用重复post处理
122
138
  * @async
123
139
  * @param json - 数据对象
124
- * @param options - 参数对象
125
- * @param timeLimit - 超时时间/秒 最小为10秒
126
- * @returns 结果 null 为未能成功接收
140
+ * @param comReqOpt - 请求参数
141
+ * @param verifyFn - 判断有效性函数
142
+ * @param repeatOpt - 可选参数
143
+ * @param opt.count - 重试次数 默认3
144
+ * @param opt.tryInterval - 超时时间/秒 默认180 最小为5秒
145
+ * @param opt.tryDelay - 重试间隔时间/秒 默认 1
146
+ * @returns 结果 undefined 为未能成功接收
127
147
  */
128
- export function httpsPost(json:JObject,options:ComPostOption,timeLimit?:number):Promise<JObject|null>{
129
- return post("https",json,options,timeLimit);
148
+ async function repeatComReq(json:JObject,comReqOpt:ComRequestOption,verifyFn?:ReqVerifyFn<JObject|undefined>,repeatOpt:RepeatPromiseOpt={}):
149
+ Promise<RepeatPromiseResult<HttpResp|undefined>|undefined>{
150
+ repeatOpt.tryDelay = repeatOpt.tryDelay??1;
151
+
152
+ const procFn = ()=>comReq(json,comReqOpt);
153
+ return UtilFunc.repeatPromise(procFn,verifyFn,repeatOpt);
130
154
  }
131
155
 
132
- /**发送一个 http POST请求并接受数据
156
+ /**发送一个 https POST 请求并接受数据
133
157
  * @async
134
- * @param json - 数据对象
135
- * @param options - 参数对象
136
- * @param timeLimit - 超时时间/秒 最小为10秒
137
- * @returns 结果 null 为未能成功接收
158
+ * @param json - 数据对象
159
+ * @param comReqOpt - 请求参数
160
+ * @returns 结果 undefined 为未能成功接收
138
161
  */
139
- export function httpPost(json:JObject,options:ComPostOption,timeLimit?:number):Promise<JObject|null>{
140
- return post("http",json,options,timeLimit);
162
+ export function httpsPost(json:JObject,comReqOpt:Omit<ComRequestOption,'protocol'|'method'>):Promise<HttpResp|undefined>{
163
+ return comReq(json,{
164
+ ...comReqOpt,
165
+ method:"POST",
166
+ protocol:"https",
167
+ });
141
168
  }
142
169
 
170
+ /**发送一个 http POST 请求并接受数据
171
+ * @async
172
+ * @param json - 数据对象
173
+ * @param comReqOpt - 请求参数
174
+ * @returns 结果 undefined 为未能成功接收
175
+ */
176
+ export function httpPost(json:JObject,comReqOpt:Omit<ComRequestOption,'protocol'|'method'>):Promise<HttpResp|undefined>{
177
+ return comReq(json,{
178
+ ...comReqOpt,
179
+ method:"POST",
180
+ protocol:"http",
181
+ });
182
+ }
183
+ /**发送一个 https GET 请求并接受数据
184
+ * @async
185
+ * @param json - 数据对象
186
+ * @param comReqOpt - 请求参数
187
+ * @returns 结果 undefined 为未能成功接收
188
+ */
189
+ export function httpsGet(json:JObject,comReqOpt:Omit<ComRequestOption,'protocol'|'method'>):Promise<HttpResp|undefined>{
190
+ return comReq(json,{
191
+ ...comReqOpt,
192
+ method:"GET",
193
+ protocol:"https",
194
+ });
195
+ }
143
196
 
144
-
145
- /**通用重复post处理
197
+ /**发送一个 http GET 请求并接受数据
146
198
  * @async
147
- * @param posttype - post类型
148
- * @param json - 数据对象
149
- * @param options - 参数对象
150
- * @param verifyFn - 判断有效性函数
151
- * @param opt - 可选参数
152
- * @param opt.post_timelimit - 超时时间/秒 最小为10秒 默认无限
153
- * @param opt.count - 重试次数 默认3
154
- * @param opt.try_interval - 重试超时时间/秒 最小为5秒 默认180
155
- * @param opt.try_delay - 重试间隔 秒 默认0
156
- * @returns 结果 null 为未能成功接收
199
+ * @param json - 数据对象
200
+ * @param comReqOpt - 请求参数
201
+ * @returns 结果 undefined 为未能成功接收
157
202
  */
158
- async function repeatPost(posttype:"http"|"https",json:JObject,options:ComPostOption,verifyFn?:ReqVerifyFn<JObject|null>,opt:RepeatPostOpt={}):
159
- Promise<RepeatPromiseResult<JObject|null>|null>{
160
- opt.count = opt.count??3;
161
- opt.tryInterval = opt.tryInterval??180;
162
- opt.tryDelay = opt.tryDelay??1;
163
-
164
- const procFn = ()=>post(posttype,json,options,opt.postTimeLimit);
165
- return UtilFunc.repeatPromise(procFn,verifyFn,opt);
203
+ export function httpGet(json:JObject,comReqOpt:Omit<ComRequestOption,'protocol'|'method'>):Promise<HttpResp|undefined>{
204
+ return comReq(json,{
205
+ ...comReqOpt,
206
+ method:"GET",
207
+ protocol:"http",
208
+ });
166
209
  }
167
210
 
168
211
 
169
212
  /**重复一个 https POST请求并接受数据
170
213
  * @async
171
- * @param json - 数据对象
172
- * @param options - 参数对象
173
- * @param verifyFn - 判断有效性函数
174
- * @param opt - 可选参数
175
- * @param opt.post_timelimit - 超时时间/秒 最小为10秒 默认无限
176
- * @param opt.count - 重试次数 默认3
177
- * @param opt.try_interval - 重试超时时间/秒 最小为5秒 默认180
178
- * @param opt.try_delay - 重试间隔 秒 默认0
179
- * @returns 结果 null 为未能成功接收
214
+ * @param json - 数据对象
215
+ * @param comReqOpt - 请求参数
216
+ * @param verifyFn - 判断有效性函数
217
+ * @param repeatOpt - 可选参数
218
+ * @param opt.count - 重试次数 默认3
219
+ * @param opt.tryInterval - 超时时间/秒 默认180 最小为5秒
220
+ * @param opt.tryDelay - 重试间隔时间/秒 默认 1
221
+ * @returns 结果 undefined 为未能成功接收
180
222
  */
181
- export function httpsRepeatPost(json:JObject,options:ComPostOption,verifyFn?:ReqVerifyFn<JObject|null>,opt?:RepeatPostOpt):
182
- Promise<RepeatPromiseResult<JObject|null>|null>{
183
- return repeatPost("https",json,options,verifyFn,opt);
223
+ export function httpsRepeatPost(json:JObject,comReqOpt:Omit<ComRequestOption,'protocol'|'method'>,verifyFn?:ReqVerifyFn<JObject|undefined>,repeatOpt?:RepeatPromiseOpt):
224
+ Promise<RepeatPromiseResult<HttpResp|undefined>|undefined>{
225
+ return repeatComReq(json,{
226
+ ...comReqOpt,
227
+ method:"POST",
228
+ protocol:"https",
229
+ },verifyFn,repeatOpt);
184
230
  }
185
231
 
186
232
  /**重复一个 http POST请求并接受数据
187
- * Object ()
188
233
  * @async
189
- * @param json - 数据对象
190
- * @param options - 参数对象
191
- * @param verifyFn - 判断有效性函数
192
- * @param opt - 可选参数
193
- * @param opt.post_timelimit - 超时时间/秒 最小为10秒 默认无限
194
- * @param opt.count - 重试次数 默认3
195
- * @param opt.try_interval - 重试超时时间/秒 最小为5秒 默认180
196
- * @param opt.try_delay - 重试间隔 秒 默认0
197
- * @returns 结果 null 为未能成功接收
234
+ * @param json - 数据对象
235
+ * @param comReqOpt - 请求参数
236
+ * @param verifyFn - 判断有效性函数
237
+ * @param repeatOpt - 可选参数
238
+ * @param opt.count - 重试次数 默认3
239
+ * @param opt.tryInterval - 超时时间/秒 默认180 最小为5秒
240
+ * @param opt.tryDelay - 重试间隔时间/秒 默认 1
241
+ * @returns 结果 undefined 为未能成功接收
242
+ */
243
+ export function httpRepeatPost(json:JObject,comReqOpt:Omit<ComRequestOption,'protocol'|'method'>,verifyFn?:ReqVerifyFn<JObject|undefined>,repeatOpt?:RepeatPromiseOpt):
244
+ Promise<RepeatPromiseResult<HttpResp|undefined>|undefined>{
245
+ return repeatComReq(json,{
246
+ ...comReqOpt,
247
+ method:"POST",
248
+ protocol:"http",
249
+ },verifyFn,repeatOpt);
250
+ }
251
+
252
+ /**重复一个 https GET 请求并接受数据
253
+ * @async
254
+ * @param json - 数据对象
255
+ * @param comReqOpt - 请求参数
256
+ * @param verifyFn - 判断有效性函数
257
+ * @param repeatOpt - 可选参数
258
+ * @param opt.count - 重试次数 默认3
259
+ * @param opt.tryInterval - 超时时间/秒 默认180 最小为5秒
260
+ * @param opt.tryDelay - 重试间隔时间/秒 默认 1
261
+ * @returns 结果 undefined 为未能成功接收
262
+ */
263
+ export function httpsRepeatGet(json:JObject,comReqOpt:Omit<ComRequestOption,'protocol'|'method'>,verifyFn?:ReqVerifyFn<JObject|undefined>,repeatOpt?:RepeatPromiseOpt):
264
+ Promise<RepeatPromiseResult<HttpResp|undefined>|undefined>{
265
+ return repeatComReq(json,{
266
+ ...comReqOpt,
267
+ method:"GET",
268
+ protocol:"https",
269
+ },verifyFn,repeatOpt);
270
+ }
271
+
272
+ /**重复一个 http GET 请求并接受数据
273
+ * @async
274
+ * @param json - 数据对象
275
+ * @param comReqOpt - 请求参数
276
+ * @param verifyFn - 判断有效性函数
277
+ * @param repeatOpt - 可选参数
278
+ * @param opt.count - 重试次数 默认3
279
+ * @param opt.tryInterval - 超时时间/秒 默认180 最小为5秒
280
+ * @param opt.tryDelay - 重试间隔时间/秒 默认 1
281
+ * @returns 结果 undefined 为未能成功接收
198
282
  */
199
- export function httpRepeatPost(json:JObject,options:ComPostOption,verifyFn?:ReqVerifyFn<JObject|null>,opt?:RepeatPostOpt):
200
- Promise<RepeatPromiseResult<JObject|null>|null>{
201
- return repeatPost("http",json,options,verifyFn,opt);
283
+ export function httpRepeatGet(json:JObject,comReqOpt:Omit<ComRequestOption,'protocol'|'method'>,verifyFn?:ReqVerifyFn<JObject|undefined>,repeatOpt?:RepeatPromiseOpt):
284
+ Promise<RepeatPromiseResult<HttpResp|undefined>|undefined>{
285
+ return repeatComReq(json,{
286
+ ...comReqOpt,
287
+ method:"GET",
288
+ protocol:"http",
289
+ },verifyFn,repeatOpt);
202
290
  }
203
291
 
204
292
  }
package/src/UtilFunctions.ts CHANGED
@@ -59,7 +59,8 @@ type PromiseResult<T> = {
59
59
  /**完成的重试请求 */
60
60
  export type RepeatPromiseResult<T> = {
61
61
  completed:T;
62
- pending:Promise<T|None>[];
62
+ /**还未完成的其他Promise 若是验证失败则会返回undefined */
63
+ pending:Promise<T|undefined>[];
63
64
  }
64
65
 
65
66
 
@@ -225,12 +226,12 @@ static getNeverResolvedPromise<T>():Promise<T>{
225
226
  * @param opt - 可选参数
226
227
  * @param opt.count - 重试次数 默认3
227
228
  * @param opt.tryInterval - 超时时间/秒 默认180 最小为5秒
228
- * @param opt.tryDelay - 重试间隔时间 默认0
229
- * @returns 结果 null 为全部失败/超时
229
+ * @param opt.tryDelay - 重试间隔时间/秒 默认 0
230
+ * @returns 结果 undefined 为全部失败/超时
230
231
  */
231
232
  @LogTimeAsync("repeatPromise ",true)
232
233
  static async repeatPromise<T>(procFn:()=>Promise<T>,verifyFn?:ReqVerifyFn<T>,opt:RepeatPromiseOpt = {}):
233
- Promise<RepeatPromiseResult<T>|null>{
234
+ Promise<RepeatPromiseResult<T>|undefined>{
234
235
  opt.count = opt.count??3;
235
236
  opt.tryInterval = opt.tryInterval??180;
236
237
  let {count,tryInterval} = opt;
@@ -323,16 +324,16 @@ Promise<RepeatPromiseResult<T>|null>{
323
324
  const outres = await curObj.result;
324
325
  if(outres.stat==Success) return outres.result;
325
326
  }
326
- return None;
327
+ return undefined;
327
328
  }),
328
329
  };
329
330
  }
330
- //全部失败或超时则返回null
331
+ //全部失败或超时则返回 undefined
331
332
  SLogger.warn(`${count} 次 repeatPromise 尝试均失败`);
332
- return null;
333
+ return undefined;
333
334
  }catch(err){
334
335
  SLogger.warn(`repeatPromise 发生错误`,err);
335
- return null;
336
+ return undefined;
336
337
  }
337
338
  }
338
339
 
package/src/UtilLogger.ts CHANGED
@@ -230,11 +230,11 @@ export class SLogger{
230
230
  * @param level - log等级 === null时不产生log
231
231
  * @returns 格式化的时间字符串
232
232
  */
233
- timeEnd(flag:string,level:LogLevel|null="info"):string|null{
233
+ timeEnd(flag:string,level:LogLevel|null="info"):string|undefined{
234
234
  const start = SLogger.timeTable[flag];
235
235
  if(start==null){
236
236
  this.warn("SLogger.timeEnd 错误 flag:"+flag+" 不存在");
237
- return null;
237
+ return;
238
238
  }
239
239
  const timelen = process.hrtime(start as any as [number,number]);
240
240