@zwa73/utils 1.0.57 → 1.0.61

package/src/UtilCodecs.ts

@@ -1,118 +1,118 @@
-import * as he from 'html-entities';
-import {get_encoding,Tiktoken} from 'tiktoken';
-
-
-
-/**编码/解码器 */
-export namespace UtilCodec{
-
-
-let encoderTurbo:Tiktoken|null = null;
-let encoderDavinci:Tiktoken|null = null;
-const textDecoder = new TextDecoder();
-
-// 定义一个对象，存储常见的HTML实体和对应的字符
-let htmlEntities:Record<string,string> = {
-    "&lt;": "<",
-    "&gt;": ">",
-    "&amp;": "&",
-    "&quot;": "\"",
-    "&#39;": "'",
-    "&#91;": "[",
-    "&#93;": "]"
-};
-
-/**HTML实体解码 将一个字符串中的HTML实体转换为对应的字符
- * @param {string} str - 要转换的字符串
- * @returns {string} 转换后的字符串
- */
-export function decodeHtmlEntities(str:string) {
-    //for(let code in htmlEntities){
-	//	let cha = htmlEntities[code]
-	//	str = str.replaceAll(code, cha);
-	//}
-	//return str
-    return he.decode(str);
-}
-
-/**HTML实体编码 将一个字符串中的 需编码字符转换为 HTML实体
- * @param {string} str - 要转换的字符串
- * @returns {string} 转换后的字符串
- */
-export function encodeHtmlEntities(str:string) {
-    //for(let code in htmlEntities){
-	//	let cha = htmlEntities[code]
-	//	str = str.replaceAll(cha, code);
-	//}
-	//return str
-    return he.encode(str);
-}
-
-
-//token长度计算器
-//cl100k_base	ChatGPT models, text-embedding-ada-002
-//p50k_base	Code models, text-davinci-002, text-davinci-003
-//r50k_base (or gpt2)	GPT-3 models like davinci
-
-
-//避免在nextjs调用时出错
-function initTikTokenEncoder (){
-	if(encoderTurbo!=null && encoderDavinci!=null)
-		return;
-
-	encoderTurbo = get_encoding("cl100k_base");
-	encoderDavinci = get_encoding("p50k_base");
-}
-
-/**token长度计算器 Turbo模型
- * @param {string} str = 所要计算的消息
- * @returns {number} 整数长度结果
- */
-export function tokenNumTurbo(str:string):number{
-	initTikTokenEncoder();
-	//return encoder.encode(str).length
-	return encoderTurbo?.encode(str).length as any as number;
-}
-/**token长度计算器 Davinci模型
- * @param {string} str = 所要计算的消息
- * @returns {number} 整数长度结果
- */
-export function tokenNumDavinci(str:string):number{
-	initTikTokenEncoder();
-	return encoderDavinci?.encode(str).length as any as number;
-}
-
-/**token编码 Turbo模型
- * @param {string} str = 所要计算的消息
- * @returns {Array<number>} Token数组
- */
-export function encodeTokenTurbo(str:string):Uint32Array{
-	initTikTokenEncoder();
-	return encoderTurbo?.encode(str) as any as Uint32Array
-}
-/**token编码 Davinci模型
- * @param {string} str = 所要计算的消息
- * @returns {Array<number>} Token数组
- */
-export function encodeTokenDavinci(str:string):Uint32Array{
-	initTikTokenEncoder();
-	return encoderDavinci?.encode(str) as any as Uint32Array;
-}
-/**token解码 Turbo模型
- * @param {Array<number>} arr = Token数组
- * @returns {string} 消息字符串
- */
-export function decodeTokenTurbo(arr:Uint32Array):string{
-	initTikTokenEncoder();
-	return textDecoder.decode(encoderTurbo?.decode(arr));
-}
-/**token解码 Davinci模型
- * @param {Array<number>} arr = Token数组
- * @returns {string} 消息字符串
- */
-export function decodeTokenDavinci(arr:Uint32Array):string{
-	initTikTokenEncoder();
-	return textDecoder.decode(encoderDavinci?.decode(arr));
-}
-
+import * as he from 'html-entities';
+import {get_encoding,Tiktoken} from 'tiktoken';
+
+
+
+/**编码/解码器 */
+export namespace UtilCodec{
+
+
+let encoderTurbo:Tiktoken|null = null;
+let encoderDavinci:Tiktoken|null = null;
+const textDecoder = new TextDecoder();
+
+// 定义一个对象，存储常见的HTML实体和对应的字符
+let htmlEntities:Record<string,string> = {
+    "&lt;": "<",
+    "&gt;": ">",
+    "&amp;": "&",
+    "&quot;": "\"",
+    "&#39;": "'",
+    "&#91;": "[",
+    "&#93;": "]"
+};
+
+/**HTML实体解码 将一个字符串中的HTML实体转换为对应的字符
+ * @param str - 要转换的字符串
+ * @returns 转换后的字符串
+ */
+export function decodeHtmlEntities(str:string) {
+    //for(let code in htmlEntities){
+	//	let cha = htmlEntities[code]
+	//	str = str.replaceAll(code, cha);
+	//}
+	//return str
+    return he.decode(str);
+}
+
+/**HTML实体编码 将一个字符串中的 需编码字符转换为 HTML实体
+ * @param str - 要转换的字符串
+ * @returns 转换后的字符串
+ */
+export function encodeHtmlEntities(str:string) {
+    //for(let code in htmlEntities){
+	//	let cha = htmlEntities[code]
+	//	str = str.replaceAll(cha, code);
+	//}
+	//return str
+    return he.encode(str);
+}
+
+
+//token长度计算器
+//cl100k_base	ChatGPT models, text-embedding-ada-002
+//p50k_base	Code models, text-davinci-002, text-davinci-003
+//r50k_base (or gpt2)	GPT-3 models like davinci
+
+
+//避免在nextjs调用时出错
+function initTikTokenEncoder (){
+	if(encoderTurbo!=null && encoderDavinci!=null)
+		return;
+
+	encoderTurbo = get_encoding("cl100k_base");
+	encoderDavinci = get_encoding("p50k_base");
+}
+
+/**token长度计算器 Turbo模型
+ * @param str = 所要计算的消息
+ * @returns 整数长度结果
+ */
+export function tokenNumTurbo(str:string):number{
+	initTikTokenEncoder();
+	//return encoder.encode(str).length
+	return encoderTurbo?.encode(str).length as any as number;
+}
+/**token长度计算器 Davinci模型
+ * @param str = 所要计算的消息
+ * @returns 整数长度结果
+ */
+export function tokenNumDavinci(str:string):number{
+	initTikTokenEncoder();
+	return encoderDavinci?.encode(str).length as any as number;
+}
+
+/**token编码 Turbo模型
+ * @param str = 所要计算的消息
+ * @returns Token数组
+ */
+export function encodeTokenTurbo(str:string):Uint32Array{
+	initTikTokenEncoder();
+	return encoderTurbo?.encode(str) as any as Uint32Array
+}
+/**token编码 Davinci模型
+ * @param str = 所要计算的消息
+ * @returns Token数组
+ */
+export function encodeTokenDavinci(str:string):Uint32Array{
+	initTikTokenEncoder();
+	return encoderDavinci?.encode(str) as any as Uint32Array;
+}
+/**token解码 Turbo模型
+ * @param arr = Token数组
+ * @returns 消息字符串
+ */
+export function decodeTokenTurbo(arr:Uint32Array):string{
+	initTikTokenEncoder();
+	return textDecoder.decode(encoderTurbo?.decode(arr));
+}
+/**token解码 Davinci模型
+ * @param arr = Token数组
+ * @returns 消息字符串
+ */
+export function decodeTokenDavinci(arr:Uint32Array):string{
+	initTikTokenEncoder();
+	return textDecoder.decode(encoderDavinci?.decode(arr));
+}
+
 }

package/src/UtilCom.ts

@@ -1,175 +1,172 @@
-import { JObject, PromiseVerifyFn, stringifyJToken } from "./UtilInterfaces";
-import * as https from 'https';
-import * as http from 'http';
-import { SLogger } from "./UtilLogger";
-import { UtilFunc } from "./UtilFunctions";
-
-
-/**网络工具 */
-export namespace UtilCom{
-
-/**通用post处理  
- * @param {"http"|"https"} posttype - post类型
- * @param {JObject} json 	        - 数据对象
- * @param {Object} options          - 参数对象
- * @param {number} [timeLimit]      - 超时时间/秒  最小为10秒
- * @returns {Promise<JObject|null>} 结果 null 为未能成功接收
- */
-function sPost(posttype:"http"|"https",json:JObject,options:Object,timeLimit:number=-1):Promise<JObject|null>{
-    //转换为毫秒
-    const hasTimeLimit = (timeLimit>=10);
-    if(hasTimeLimit)
-        timeLimit*=1000
-
-    const jsonStr = stringifyJToken(json);
-    const funcName = `s${posttype}Psot`;
-
-    return new Promise((resolve, rejecte)=>{
-        const resFunc = (res:http.IncomingMessage)=>{
-            try{
-                //请求超时
-                if(hasTimeLimit){
-                    res.setTimeout(timeLimit, ()=>{
-                        //res.abort();
-                        SLogger.warn(`${funcName} 接收反馈超时: ${timeLimit} ms`);
-                        resolve(null);
-                        return;
-                    });
-                }
-
-                let resdata = "";
-                res.setEncoding('utf8');
-                res.on('data',(chunk)=>resdata+=chunk);
-
-                res.on('error',(e)=>{
-                    SLogger.warn(`${funcName} 接收反馈错误:${e}`);
-                    resolve(null);
-                    return;
-                });
-
-                res.on('end',()=>{
-                    if(resdata==""){
-                        SLogger.warn(funcName+" 接收反馈错误: resdata 为空");
-                        resolve(null);
-                        return;
-                    }
-                    try{
-                        let obj = JSON.parse(resdata);
-                        SLogger.http(funcName+" 接受信息:",stringifyJToken(obj));
-                        resolve(obj);
-                        return;
-                    }
-                    catch(e){
-                        SLogger.warn(`${funcName} 接收反馈错误:${e}\n原始字符串:${resdata}`);
-                        resolve(null);
-                        return;
-                    }
-                });
-            }catch(err){
-                SLogger.warn(funcName+" 未知错误:"+err);
-                resolve(null);
-                return;
-            }
-        };
-        //路由 http/https
-        let req:http.ClientRequest=null as any as http.ClientRequest;
-        if(posttype === "https")
-            req = https.request(options, resFunc);
-        else if(posttype === "http")
-            req = http.request(options, resFunc);
-
-        //请求超时
-        if(hasTimeLimit){
-            req.setTimeout(timeLimit, ()=>{
-                SLogger.warn(`${funcName} 发送请求超时: ${timeLimit} ms`);
-                req.destroy();
-            });
-        }
-
-        req.on('error', (e)=>{
-            SLogger.warn(`${funcName} 发送请求错误:${e}`);
-            resolve(null);
-        });
-
-        req.write(jsonStr);
-        req.end();
-    });
-}
-
-/**发送一个 https POST请求并接受数据  
- * Object ()  
- * @async
- * @param {JObject} json 	   - 数据对象
- * @param {Object} options     - 参数对象
- * @param {number} [timeLimit] - 超时时间/秒  最小为10秒
- * @returns {Promise<JObject|null>} 结果 null 为未能成功接收
- */
-export function shttpsPost(json:JObject,options:Object,timeLimit:number=-1):Promise<JObject|null>{
-    return sPost("https",json,options,timeLimit);
-}
-
-/**发送一个 http POST请求并接受数据  
- * Object ()  
- * @async
- * @param {JObject} json 	   - 数据对象
- * @param {Object} options     - 参数对象
- * @param {number} [timeLimit] - 超时时间/秒  最小为10秒
- * @returns {Promise<JObject|null>} 结果 null 为未能成功接收
- */
-export function shttpPost(json:JObject,options:Object,timeLimit:number=-1):Promise<JObject|null>{
-    return sPost("http",json,options,timeLimit);
-}
-
-
-
-/**通用重复post处理  
- * @async
- * @param {"http"|"https"} posttype - post类型
- * @param {JObject} json 	        - 数据对象
- * @param {Object} options          - 参数对象
- * @param {number} [timeLimit]      - 超时时间/秒  最小为10秒
- * @param {number} [repeatCount]    - 重试次数
- * @param {number} [repeatTime]     - 超时时间/秒  最小为10秒
- * @param {PromiseVerifyFn<JObject|null>} [verifyFn]     - 判断有效性函数
- * @returns {Promise<JObject|null>}  - 结果 null 为未能成功接收
- */
-async function sRepeatPost(posttype:"http"|"https",json:JObject,options:Object,timeLimit:number=-1,
-    repeatCount:number=3,repeatTime:number=180,verifyFn?:PromiseVerifyFn<JObject|null>):Promise<JObject|null>{
-    const procFn = ()=>sPost(posttype,json,options,timeLimit);
-    return UtilFunc.repeatPromise(procFn,verifyFn,repeatCount,repeatTime);
-}
-
-
-/**重复一个 https POST请求并接受数据  
- * Object ()  
- * @async
- * @param {JObject} json 	        - 数据对象
- * @param {Object} options          - 参数对象
- * @param {number} [timeLimit]      - 超时时间/秒  最小为10秒
- * @param {number} [repeatCount]    - 重试次数
- * @param {number} [repeatTime]     - 超时时间/秒  最小为10秒
- * @param {PromiseVerifyFn<JObject|null>} [verifyFn]     - 判断有效性函数
- * @returns {Promise<JObject|null>}  - 结果 null 为未能成功接收
- */
-export function shttpsRepeatPost(json:JObject,options:Object,timeLimit:number=-1,
-    repeatCount:number=3,repeatTime:number=180,verifyFn?:PromiseVerifyFn<JObject|null>):Promise<JObject|null>{
-    return sRepeatPost("https",json,options,timeLimit,repeatCount,repeatTime,verifyFn);
-}
-
-/**重复一个 http POST请求并接受数据  
- * Object ()  
- * @async
- * @param {JObject} json 	        - 数据对象
- * @param {Object} options          - 参数对象
- * @param {number} [timeLimit]      - 超时时间/秒  最小为10秒
- * @param {number} [repeatCount]    - 重试次数
- * @param {number} [repeatTime]     - 超时时间/秒  最小为10秒
- * @param {PromiseVerifyFn<JObject|null>} [verifyFn]     - 判断有效性函数
- * @returns {Promise<JObject|null>}  - 结果 null 为未能成功接收
- */
-export function shttpRepeatPost(json:JObject,options:Object,timeLimit:number=-1,
-    repeatCount:number=3,repeatTime:number=180,verifyFn?:PromiseVerifyFn<JObject|null>):Promise<JObject|null>{
-    return sRepeatPost("http",json,options,timeLimit,repeatCount,repeatTime,verifyFn);
-}
-
+import { JObject, PromiseVerifyFn, stringifyJToken } from "@src/UtilInterfaces";
+import * as https from 'https';
+import * as http from 'http';
+import { SLogger } from "@src/UtilLogger";
+import { UtilFunc } from "@src/UtilFunctions";
+
+
+/**网络工具 */
+export namespace UtilCom{
+
+/**通用post处理  
+ * @param posttype  - post类型
+ * @param json 	    - 数据对象
+ * @param options   - 参数对象
+ * @param timeLimit - 超时时间/秒  最小为10秒
+ * @returns 结果 null 为未能成功接收
+ */
+function sPost(posttype:"http"|"https",json:JObject,options:Object,timeLimit:number=-1):Promise<JObject|null>{
+    //转换为毫秒
+    const hasTimeLimit = (timeLimit>=10);
+    if(hasTimeLimit)
+        timeLimit*=1000
+
+    const jsonStr = stringifyJToken(json);
+    const funcName = `s${posttype}Psot`;
+
+    return new Promise((resolve, rejecte)=>{
+        const resFunc = (res:http.IncomingMessage)=>{
+            try{
+                //请求超时
+                if(hasTimeLimit){
+                    res.setTimeout(timeLimit, ()=>{
+                        //res.abort();
+                        SLogger.warn(`${funcName} 接收反馈超时: ${timeLimit} ms`);
+                        resolve(null);
+                        return;
+                    });
+                }
+
+                let resdata = "";
+                res.setEncoding('utf8');
+                res.on('data',(chunk)=>resdata+=chunk);
+
+                res.on('error',(e)=>{
+                    SLogger.warn(`${funcName} 接收反馈错误:${e}`);
+                    resolve(null);
+                    return;
+                });
+
+                res.on('end',()=>{
+                    if(resdata==""){
+                        SLogger.warn(funcName+" 接收反馈错误: resdata 为空");
+                        resolve(null);
+                        return;
+                    }
+                    try{
+                        let obj = JSON.parse(resdata);
+                        SLogger.http(funcName+" 接受信息:",stringifyJToken(obj));
+                        resolve(obj);
+                        return;
+                    }
+                    catch(e){
+                        SLogger.warn(`${funcName} 接收反馈错误:${e}\n原始字符串:${resdata}`);
+                        resolve(null);
+                        return;
+                    }
+                });
+            }catch(err){
+                SLogger.warn(funcName+" 未知错误:"+err);
+                resolve(null);
+                return;
+            }
+        };
+        //路由 http/https
+        let req:http.ClientRequest=null as any as http.ClientRequest;
+        if(posttype === "https")
+            req = https.request(options, resFunc);
+        else if(posttype === "http")
+            req = http.request(options, resFunc);
+
+        //请求超时
+        if(hasTimeLimit){
+            req.setTimeout(timeLimit, ()=>{
+                SLogger.warn(`${funcName} 发送请求超时: ${timeLimit} ms`);
+                req.destroy();
+            });
+        }
+
+        req.on('error', (e)=>{
+            SLogger.warn(`${funcName} 发送请求错误:${e}`);
+            resolve(null);
+        });
+
+        req.write(jsonStr);
+        req.end();
+    });
+}
+
+/**发送一个 https POST请求并接受数据  
+ * @async
+ * @param json 	    - 数据对象
+ * @param options   - 参数对象
+ * @param timeLimit - 超时时间/秒  最小为10秒
+ * @returns 结果 null 为未能成功接收
+ */
+export function shttpsPost(json:JObject,options:Object,timeLimit:number=-1):Promise<JObject|null>{
+    return sPost("https",json,options,timeLimit);
+}
+
+/**发送一个 http POST请求并接受数据  
+ * @async
+ * @param json 	    - 数据对象
+ * @param options   - 参数对象
+ * @param timeLimit - 超时时间/秒  最小为10秒
+ * @returns 结果 null 为未能成功接收
+ */
+export function shttpPost(json:JObject,options:Object,timeLimit:number=-1):Promise<JObject|null>{
+    return sPost("http",json,options,timeLimit);
+}
+
+
+
+/**通用重复post处理  
+ * @async
+ * @param posttype    - post类型
+ * @param json 	      - 数据对象
+ * @param options     - 参数对象
+ * @param timeLimit   - 超时时间/秒  最小为10秒
+ * @param repeatCount - 重试次数
+ * @param repeatTime  - 超时时间/秒  最小为10秒
+ * @param verifyFn    - 判断有效性函数
+ * @returns 结果 null 为未能成功接收
+ */
+async function sRepeatPost(posttype:"http"|"https",json:JObject,options:Object,timeLimit:number=-1,
+    repeatCount:number=3,repeatTime:number=180,verifyFn?:PromiseVerifyFn<JObject|null>):Promise<JObject|null>{
+    const procFn = ()=>sPost(posttype,json,options,timeLimit);
+    return UtilFunc.repeatPromise(procFn,verifyFn,repeatCount,repeatTime);
+}
+
+
+/**重复一个 https POST请求并接受数据  
+ * @async
+ * @param json 	      - 数据对象
+ * @param options     - 参数对象
+ * @param timeLimit   - 超时时间/秒  最小为10秒
+ * @param repeatCount - 重试次数
+ * @param repeatTime  - 超时时间/秒  最小为10秒
+ * @param verifyFn    - 判断有效性函数
+ * @returns 结果 null 为未能成功接收
+ */
+export function shttpsRepeatPost(json:JObject,options:Object,timeLimit:number=-1,
+    repeatCount:number=3,repeatTime:number=180,verifyFn?:PromiseVerifyFn<JObject|null>):Promise<JObject|null>{
+    return sRepeatPost("https",json,options,timeLimit,repeatCount,repeatTime,verifyFn);
+}
+
+/**重复一个 http POST请求并接受数据  
+ * Object ()  
+ * @async
+ * @param json 	      - 数据对象
+ * @param options     - 参数对象
+ * @param timeLimit   - 超时时间/秒  最小为10秒
+ * @param repeatCount - 重试次数
+ * @param repeatTime  - 超时时间/秒  最小为10秒
+ * @param verifyFn    - 判断有效性函数
+ * @returns 结果 null 为未能成功接收
+ */
+export function shttpRepeatPost(json:JObject,options:Object,timeLimit:number=-1,
+    repeatCount:number=3,repeatTime:number=180,verifyFn?:PromiseVerifyFn<JObject|null>):Promise<JObject|null>{
+    return sRepeatPost("http",json,options,timeLimit,repeatCount,repeatTime,verifyFn);
+}
+
 }