@zwa73/utils 1.0.202 → 1.0.203

package/src/UtilClass.ts

@@ -1,259 +0,0 @@
-import { matchProc } from "./QuickExport";
-import { Keyable, Literal, MPromise } from "./UtilInterfaces";
-import Handlebars from 'handlebars';
-import { SLogger } from "./UtilLogger";
-
-/**函数管道器 */
-export class Piper<Arg, Result = Arg> {
-    /**管道函数列表 */
-    private funcs: Function[] = [];
-    private constructor(){};
-    /**添加单个参数与返回值不同的函数 */
-    public static pipe<Arg, Result>(func: (arg: Arg) => Result): Piper<Arg, Result>;
-    /**添加多个参数与返回值相同的函数 */
-    public static pipe<Arg>(func:((arg: Arg) => Arg), ...funcs: ((arg: Arg) => Arg)[]): Piper<Arg>;
-    public static pipe(...funcs: Function[]){
-        const newPiper = new Piper<any>();
-        newPiper.funcs = [...funcs];
-        return newPiper;
-    }
-
-    /**添加单个参数与返回值不同的函数 */
-    public pipe<T>(func: (arg: Result) => T): Piper<Arg, T>;
-    /**添加多个参数与返回值相同的函数 */
-    public pipe(func:((arg: Result) => Result), ...funcs: ((arg: Result) => Result)[]): Piper<Arg, Result>;
-    public pipe(...funcs: Function[]): Piper<Arg, any> {
-        const newPiper = new Piper<Arg>();
-        newPiper.funcs = [...this.funcs, ...funcs];
-        return newPiper;
-    }
-    /**管道函数 */
-    public pipeline():(arg:Arg)=>Result {
-        return (arg:Arg) => this.funcs.reduce((value, func) => func(value), arg) as any as Result;
-    }
-    /**直接调用 */
-    public invoke(arg:Arg):Result {
-        return this.funcs.reduce((value, func) => func(value), arg) as any as Result;
-    }
-}
-
-
-//#region 并行流
-type StreamOperation<T, U> = (item: T)=>MPromise<U>;
-/**并行流 */
-export class Stream<T> implements Iterable<T>{
-    /**并发数*/
-    private _concurrent: number;
-    private _list: T[];
-    /**加工函数列表*/
-    private _operation: Array<StreamOperation<T, T>> = [];
-    private constructor(base?: Array<T>|number, concurrent: number = 1) {
-        if(base==undefined) this._list = new Array();
-        else if(typeof base === 'number') this._list = new Array(base);
-        else this._list = new Array(...base);
-        this._concurrent = concurrent;
-    }
-    /**从arraylike创建流
-     * @param args - arraylike
-     * @param concurrent - 并发数 默认 1
-     */
-    static from<T>(args:ArrayLike<T>,concurrent:number=1){
-        return new Stream(Array.from(args),concurrent);
-    }
-    /**从数组创建流 */
-    static of<T>(...args:T[]){
-        return new Stream(args);
-    }
-    /**设置并发数 */
-    concurrent(count: number): Stream<T> {
-        this._concurrent = count;
-        return this;
-    }
-    /**平分数组
-     * @param count - 份数
-     * @param mode  - 模式 average:轮询平均分 chunk:切块均分
-     * @returns 新数组
-     */
-    private divide(count: number, mode: "average" | "chunk" = "average"): T[][] {
-        if (count <= 0) return [];
-        if (count == 1) return [[...this]];
-        const size = this.length;
-        const result:T[][] = [];
-
-        matchProc(mode,{
-            //轮询平均分
-            'average':()=>{
-                for (let i = 0; i < count; i++) {
-                    const clist:T[] = [];
-                    for (let j = i; j < size; j += count)
-                        clist.push(this._list[j]);
-                    result.push(clist);
-                }
-            },
-            //切块均分
-            'chunk':()=>{
-                const chunkSize = Math.ceil(size / count);
-                for (let i = 0; i < count; i++) {
-                    const start = i * chunkSize;
-                    let end = (i + 1) * chunkSize;
-                    if (end > size) end = size;
-                    result.push(this._list.slice(start, end));
-                }
-            },
-        })
-        return result;
-    }
-    /**转换流  
-     * @param  operation - 加工函数
-     * @returns 新流
-     */
-    private trans<U>(operation:StreamOperation<T, U>): Stream<U>{
-        const ns = new Stream(this._list,this._concurrent);
-        ns._operation.push(...this._operation);
-        ns._operation.push(operation as any);
-        return ns as any;
-    }
-
-    /**流式的 映射加工
-     * @param  operation - 加工函数
-     * @returns 新流
-     */
-    map<U>(operation: StreamOperation<T, U>): Stream<U> {
-        return this.trans(operation);
-    }
-    /**流式的 遍历
-     * 返回自身
-     * @param  operation - 遍历函数
-     * @returns 自身
-     */
-    each(operation: StreamOperation<T, void>): Stream<T> {
-        const opera = async (item: T) => {
-            await operation(item);
-            return item;
-        };
-        return this.trans(opera);;
-    }
-
-    //终结操作
-    /**应用加工
-     * @returns 自身
-     */
-    async append(): Promise<Stream<T>> {
-        if (this._operation.length == 0) return this;
-
-        //均分处理
-        const pList = this.divide(this._concurrent)
-            .map(async (subList)=>{
-                    const result:T[] = [];
-                    for (let item of subList) {
-                        for (const operation of this._operation)
-                            item = await operation(item);
-                        result.push(item);
-                    }
-                    return (result);
-                });
-        const rlist = await Promise.all(pList);
-
-        //拼接结果 轮询均分
-        const result = new Array(this.length).fill(undefined);
-        rlist.forEach((subList,i)=>{
-            if (!subList) return;
-            const subSize = subList.length;
-            for (let j = 0; j < subSize; j++)
-                result[i + j * this._concurrent] = subList[j];
-        });
-
-        this._list = result;
-        this._operation = [];
-        return this;
-    }
-    /**应用加工 并转换为数组
-     * @returns 数组
-     */
-    async toArray(): Promise<Array<T>> {
-        await this.append();
-        return [...this];
-    }
-    /**应用加工 并排除某个字面量
-     * @param value - 排除的值
-     * @returns 自身
-     */
-    async exclude<E>(value:Literal<E>): Promise<Stream<Exclude<T,E>>>{
-        await this.append();
-        return new Stream(this._list.filter((v)=>v!==value as any) as Exclude<T,E>[]);
-    }
-    /**应用加工 并过滤
-     * @param func - 过滤函数
-     * @returns 自身
-     */
-    async filter(func:(value: T, index: number, array: T[])=>boolean): Promise<Stream<T>>{
-        await this.append();
-        return new Stream(this._list.filter(func));
-    }
-    //迭代器
-    [Symbol.iterator](): Iterator<T> {
-        let index = 0;
-        const data  = this._list;
-
-        return {
-            next: () => ({
-                value: data[index++],
-                done: index > data.length
-            })
-        };
-    }
-
-    // 创建 length 属性的 getter 和 setter
-    get length(): number {
-        return this._list.length;
-    }
-}
-//#endregion
-
-
-/**文本模板渲染器
- * @template T - 上下文对象的类型，默认为记录类型
- */
-export class Hbs<T extends Record<Keyable,any> = Record<Keyable,any>>{
-    hbs = Handlebars.create();
-    context:T;
-
-    /**创建一个新的 Hbs 实例
-    * @param context - 上下文对象，用于在渲染模板时提供数据
-    */
-    constructor(context:T={} as T) {
-        this.context = context;
-
-        this.hbs.registerHelper('def', (name, options)=> {
-            const value = options.fn(this.context).trim();
-            (this.context as any)[name] = value;
-            return '';
-        });
-
-        this.hbs.registerHelper('defli', (name,options)=> {
-            const rawvalue = options.fn(this.context) as string;
-
-            const values = rawvalue
-                .split('[[br]]')
-                .map(value => value.trim());
-            (this.context as any)[name] = values;
-            return '';
-        });
-    }
-
-    /**渲染模板
-     * @param template - 要渲染的 Handlebars 模板字符串
-     * @returns 渲染后的字符串
-     */
-    render(template:string):string{
-        try{
-            return this.hbs.compile(template)(this.context);
-        } catch(e){
-            SLogger.error(e);
-            return '';
-        }
-    }
-}
-
-
-

package/src/UtilCodecs.ts

@@ -1,102 +0,0 @@
-import * as he from 'html-entities';
-import {get_encoding,Tiktoken} from 'tiktoken';
-
-
-
-/**编码/解码器 */
-export namespace UtilCodec{
-
-/**gpt-4, gpt-3.5-turbo, text-embedding-ada-002, text-embedding-3-small, text-embedding-3-large
- */
-let encoderCl100kBase:Tiktoken|null = null;
-/**Codex models, text-davinci-002, text-davinci-003
- */
-let encoderP50kBase:Tiktoken|null = null;
-const textDecoder = new TextDecoder();
-
-/**HTML实体解码 将一个字符串中的HTML实体转换为对应的字符
- * @param str - 要转换的字符串
- * @returns 转换后的字符串
- */
-export function decodeHtmlEntities(str:string) {
-    return he.decode(str);
-}
-
-/**HTML实体编码 将一个字符串中的 需编码字符转换为 HTML实体
- * @param str - 要转换的字符串
- * @returns 转换后的字符串
- */
-export function encodeHtmlEntities(str:string) {
-    return he.encode(str);
-}
-
-//#region LAM
-//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(encoderCl100kBase!=null && encoderP50kBase!=null)
-		return;
-
-	encoderCl100kBase = get_encoding("cl100k_base");
-	encoderP50kBase = get_encoding("p50k_base");
-}
-
-/**token长度计算器 Turbo模型
- * @param str = 所要计算的消息
- * @returns 整数长度结果
- */
-export function tokenNumTurbo(str:string):number{
-	initTikTokenEncoder();
-	//return encoder.encode(str).length
-	return encoderCl100kBase?.encode(str).length as any as number;
-}
-/**token长度计算器 Davinci模型
- * @param str = 所要计算的消息
- * @returns 整数长度结果
- */
-export function tokenNumDavinci(str:string):number{
-	initTikTokenEncoder();
-	return encoderP50kBase?.encode(str).length as any as number;
-}
-
-/**token编码 Turbo模型
- * @param str = 所要计算的消息
- * @returns Token数组
- */
-export function encodeTokenTurbo(str:string):Uint32Array{
-	initTikTokenEncoder();
-	return encoderCl100kBase?.encode(str) as any as Uint32Array
-}
-/**token编码 Davinci模型
- * @param str = 所要计算的消息
- * @returns Token数组
- */
-export function encodeTokenDavinci(str:string):Uint32Array{
-	initTikTokenEncoder();
-	return encoderP50kBase?.encode(str) as any as Uint32Array;
-}
-/**token解码 Turbo模型
- * @param arr = Token数组
- * @returns 消息字符串
- */
-export function decodeTokenTurbo(arr:Uint32Array|number[]):string{
-	initTikTokenEncoder();
-	if(Array.isArray(arr)) arr = new Uint32Array(arr);
-	return textDecoder.decode(encoderCl100kBase?.decode(arr));
-}
-/**token解码 Davinci模型
- * @param arr = Token数组
- * @returns 消息字符串
- */
-export function decodeTokenDavinci(arr:Uint32Array|number[]):string{
-	initTikTokenEncoder();
-	if(Array.isArray(arr)) arr = new Uint32Array(arr);
-	return textDecoder.decode(encoderP50kBase?.decode(arr));
-}
-//#endregion
-}

package/src/UtilCom.macro.ts

@@ -1,28 +0,0 @@
-import { regionMacro } from "@zwa73/dev-utils";
-import { dedent } from "./QuickExport";
-
-const sep1 = ["http","https"];
-const sep2 = ["get","post"];
-const AcceptTypeList = ["json","raw"]as const;
-const SendTypeList = ["json","query","formData","none","raw"] as const;
-const sep3 = SendTypeList;
-const up = (str:string)=>{
-    if (str.length === 0) return str; // 处理空字符串
-    return str.charAt(0).toUpperCase() + str.slice(1);
-}
-if(false)
-regionMacro("UtilCom宏定义",()=>{
-    const result:string[] = [];
-    sep1.forEach(s1=>{
-        sep2.forEach(s2=>{
-            sep3.filter(s=>s!='raw').forEach(s3=>{
-                result.push(dedent`
-                    /** 宏 UtilCom.${s1}().${s2}().send('${s3}').acceptJson() */
-                    static ${s1}${up(s2)}${up(s3)}(){
-                        return UtilCom.${s1}().${s2}().send('${s3}' as const).acceptJson();
-                    }`.trim());
-            })
-        })
-    })
-    return result.reverse().join('\n');
-});