baja-lite 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 void-soul
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1 @@
+

package/cjs/constant.d.ts

@@ -0,0 +1,13 @@
+/** 执行方式 */
+export declare enum SqlSyncMode {
+    /** 同步执行 */
+    Sync = 0,
+    /** 异步执行 */
+    Async = 1
+}
+export declare enum ExcuteSplitMode {
+    SyncTrust = 0,
+    SyncNoTrust = 1,
+    AsyncTrust = 2,
+    AsyncNoTrust = 3
+}

package/cjs/constant.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExcuteSplitMode = exports.SqlSyncMode = void 0;
+/** 执行方式 */
+var SqlSyncMode;
+(function (SqlSyncMode) {
+    /** 同步执行 */
+    SqlSyncMode[SqlSyncMode["Sync"] = 0] = "Sync";
+    /** 异步执行 */
+    SqlSyncMode[SqlSyncMode["Async"] = 1] = "Async";
+})(SqlSyncMode || (exports.SqlSyncMode = SqlSyncMode = {}));
+;
+var ExcuteSplitMode;
+(function (ExcuteSplitMode) {
+    ExcuteSplitMode[ExcuteSplitMode["SyncTrust"] = 0] = "SyncTrust";
+    ExcuteSplitMode[ExcuteSplitMode["SyncNoTrust"] = 1] = "SyncNoTrust";
+    ExcuteSplitMode[ExcuteSplitMode["AsyncTrust"] = 2] = "AsyncTrust";
+    ExcuteSplitMode[ExcuteSplitMode["AsyncNoTrust"] = 3] = "AsyncNoTrust";
+})(ExcuteSplitMode || (exports.ExcuteSplitMode = ExcuteSplitMode = {}));

package/cjs/error.d.ts

@@ -0,0 +1,5 @@
+export declare const Throw: {
+    if(test: boolean, message: string | Error | any): void;
+    ifNot(test: boolean, message: string | Error | any): void;
+    now(message: string | Error | any): never;
+};

package/cjs/error.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Throw = void 0;
+exports.Throw = {
+    if(test, message) {
+        if (test === true)
+            this.now(message);
+    },
+    ifNot(test, message) {
+        if (test !== true)
+            this.now(message);
+    },
+    now(message) {
+        throw typeof message === 'string' ? new Error(message) : message;
+    },
+};

package/cjs/fn.d.ts

@@ -0,0 +1,128 @@
+/**
+ * 回调函数promise化
+ * 调用示例
+ * soap.excute(arg1, arg2, function(error, data){});
+ * 可使用为:
+ * const soap_excute = promise({
+ *  fn: soap.excute,
+ *  target: soap
+ * });
+ * const data = await soap_excute(arg1, arg2);
+ * @param this
+ * @param param1
+ */
+export declare const promise: <T>(this: any, { fn, target, last }: {
+    fn: (...args: any[]) => any;
+    target?: any;
+    last?: boolean;
+}) => (...args: any[]) => Promise<T>;
+export declare const sleep: (time?: number) => Promise<unknown>;
+/**
+ * 执行器
+ * @param fn
+ * @param {
+    ifFinish?: (result?: T) => boolean; // 是否结束,默认是建议判断 !!result
+    maxTryTimes?: number; //最多尝试几次,默认是20
+    onFail?: () => Promise<boolean | undefined> | boolean | undefined; // 失败时的回调，返回false表示停止执行
+    name?: string;  // 执行器名称，用于打印日志
+    exitIfFail?: boolean; // 失败时是否退出，默认是false. 这里设置true后，onFail返回true,也会停止执行
+    defVal?: T; // 失败时的默认值
+    sleepAppend?: number; // 等待延迟MS，默认是1000内随机+200
+ * }
+ * @returns
+ */
+export declare function dieTrying<T = any>(fn: (...args: any[]) => Promise<T | undefined> | T | undefined, { ifFinish, maxTryTimes, onFail, name, exitIfFail, defVal, sleepAppend }?: {
+    ifFinish?: (result?: T) => boolean;
+    maxTryTimes?: number;
+    onFail?: () => Promise<boolean | undefined> | boolean | undefined;
+    name?: string;
+    exitIfFail?: boolean;
+    defVal?: T;
+    sleepAppend?: number;
+}): Promise<T | undefined>;
+export declare enum ExcuteSplitMode {
+    SyncTrust = 0,
+    SyncNoTrust = 1,
+    AsyncTrust = 2,
+    AsyncNoTrust = 3
+}
+/**
+ * 数组分割执行
+ * @param datas 数组
+ * @param fn 执行的函数, 参数1：分割数组；参数2：第几个分割数组；参数3：分割数组的数量；参数4：从第几个下标（相对于总数组）元素开始；参数5：到第几个下标（相对于总数组）元素结束
+ * @param config 配置（三选一）：everyLength=每组个数(最后一组可能不足次数), groupCount=拆分几组, extendParams=依附拆分数组；
+ * @param 额外选项 settled=是否并行?
+ * T: datas类型
+ * E: extendParams类型
+ * R: 返回值类型
+ */
+/**
+ * 数组分割执行
+ *
+ * # 参数说明
+ * @param sync 同步异步开关
+ * @param datas 数组
+ * @param fn 执行的函数
+  ```
+  ** `args`:   分割后的小数组
+  ** `index`:  第几个小数组
+  ** `length`: 总共多少个小数组
+  ** `extendParam`?: `参见下面Option中的extendParams`
+  ** `startIndex`?: 本次小数组的第一个元素是从总数组的第几个元素
+  ** `endIndex`?: 本次小数组的最后一个元素是从总数组的第几个元素
+  fn: (args: T[], index: number, length: number, extendParam?: E, startIndex?: number, endIndex?: number):R => {
+
+  }
+  ```
+  * @param option 选项
+
+  ## 分割数组方式:2种，选择一种即可
+  1. everyLength=每组个数(最后一组可能不足次数)
+  2. groupCount=拆分几组
+  ## settled 异步执行是否并行执行? 默认false
+  ## `extendParams`：扩展参数
+  ** 数组
+  ** 结合分组方式：groupCount使用。例如:
+  ```
+  `groupCount`=5，那么可以传入5个`extendParams`,在执行分组时，会为每个数组传入对应下标的`extendParam`
+  ```
+  ## `trust` 是否信任方法体，默认false
+  * true时，执行时捕获不异常, 返回值变为 R[]
+  * false时,执行时捕获异常，并返回 { result: R[]; error: string[]; };
+  # 泛型说明:全部可选
+  1. T = 数组类型
+  2. R = 返回结果类型
+  3. E = 扩展参数类型
+
+ * @returns
+ */
+export declare function excuteSplit<T = any, R = any, E = any>(sync: ExcuteSplitMode.SyncTrust, datas: T[], fn: (args: T[], index: number, length: number, extendParam?: E, startIndex?: number, endIndex?: number) => R, option: {
+    everyLength?: number;
+    groupCount?: number;
+    settled?: boolean;
+    extendParams?: E[];
+}): R[];
+export declare function excuteSplit<T = any, R = any, E = any>(sync: ExcuteSplitMode.SyncNoTrust, datas: T[], fn: (args: T[], index: number, length: number, extendParam?: E, startIndex?: number, endIndex?: number) => R, option: {
+    everyLength?: number;
+    groupCount?: number;
+    settled?: boolean;
+    extendParams?: E[];
+}): {
+    result: R[];
+    error: string[];
+};
+export declare function excuteSplit<T = any, R = any, E = any>(sync: ExcuteSplitMode.AsyncTrust, datas: T[], fn: (args: T[], index: number, length: number, extendParam?: E, startIndex?: number, endIndex?: number) => Promise<R>, option: {
+    everyLength?: number;
+    groupCount?: number;
+    settled?: boolean;
+    extendParams?: E[];
+}): Promise<R[]>;
+export declare function excuteSplit<T = any, R = any, E = any>(sync: ExcuteSplitMode.AsyncNoTrust, datas: T[], fn: (args: T[], index: number, length: number, extendParam?: E, startIndex?: number, endIndex?: number) => Promise<R>, option: {
+    everyLength?: number;
+    groupCount?: number;
+    settled?: boolean;
+    extendParams?: E[];
+}): Promise<{
+    result: R[];
+    error: string[];
+}>;

package/cjs/fn.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.excuteSplit = exports.ExcuteSplitMode = exports.dieTrying = exports.sleep = exports.promise = void 0;
+const object_1 = require("./object");
+const error_1 = require("./error");
+/**
+ * 回调函数promise化
+ * 调用示例
+ * soap.excute(arg1, arg2, function(error, data){});
+ * 可使用为:
+ * const soap_excute = promise({
+ *  fn: soap.excute,
+ *  target: soap
+ * });
+ * const data = await soap_excute(arg1, arg2);
+ * @param this
+ * @param param1
+ */
+const promise = function ({ fn, target, last = true }) {
+    return (...args) => {
+        return new Promise((resolve, reject) => {
+            args[last === true ? 'push' : 'unshift']((err, data) => {
+                if (err === null || err === undefined) {
+                    return resolve.call(this, data);
+                }
+                return reject(err);
+            });
+            if (target) {
+                fn.apply(target, args);
+            }
+            else {
+                fn.apply({}, args);
+            }
+        });
+    };
+};
+exports.promise = promise;
+const sleep = (time = parseInt(`${Math.random()}`) + 200) => new Promise((resolve) => setTimeout(resolve, time));
+exports.sleep = sleep;
+/**
+ * 执行器
+ * @param fn
+ * @param {
+    ifFinish?: (result?: T) => boolean; // 是否结束,默认是建议判断 !!result
+    maxTryTimes?: number; //最多尝试几次,默认是20
+    onFail?: () => Promise<boolean | undefined> | boolean | undefined; // 失败时的回调，返回false表示停止执行
+    name?: string;  // 执行器名称，用于打印日志
+    exitIfFail?: boolean; // 失败时是否退出，默认是false. 这里设置true后，onFail返回true,也会停止执行
+    defVal?: T; // 失败时的默认值
+    sleepAppend?: number; // 等待延迟MS，默认是1000内随机+200
+ * }
+ * @returns
+ */
+async function dieTrying(fn, { ifFinish = (result) => !!result, maxTryTimes = 20, onFail, name = 'dieTrying', exitIfFail = true, defVal, sleepAppend = 0 } = {}) {
+    let count = 0;
+    let result = defVal;
+    while (result = await fn(), !ifFinish(result)) {
+        await (0, exports.sleep)(parseInt(`${Math.random() * 1000}`) + sleepAppend);
+        count++;
+        console.debug(`${name} try ${count} times`);
+        if (count > maxTryTimes) {
+            if (onFail) {
+                const remuseExcute = await onFail();
+                console.error(`${name} timeout`);
+                count = 0;
+                if (remuseExcute === false) {
+                    break;
+                }
+            }
+            if (exitIfFail) {
+                break;
+            }
+        }
+    }
+    return result;
+}
+exports.dieTrying = dieTrying;
+var ExcuteSplitMode;
+(function (ExcuteSplitMode) {
+    ExcuteSplitMode[ExcuteSplitMode["SyncTrust"] = 0] = "SyncTrust";
+    ExcuteSplitMode[ExcuteSplitMode["SyncNoTrust"] = 1] = "SyncNoTrust";
+    ExcuteSplitMode[ExcuteSplitMode["AsyncTrust"] = 2] = "AsyncTrust";
+    ExcuteSplitMode[ExcuteSplitMode["AsyncNoTrust"] = 3] = "AsyncNoTrust";
+})(ExcuteSplitMode || (exports.ExcuteSplitMode = ExcuteSplitMode = {}));
+function excuteSplit(sync, datas, fn, { everyLength = 0, groupCount = 0, settled = false, extendParams = new Array() }) {
+    if (extendParams.length > 0) {
+        groupCount = extendParams.length;
+    }
+    error_1.Throw.if(everyLength === 0 && groupCount === 0, '参数错误!');
+    const ps = { everyLength, groupCount };
+    const list = (0, object_1.arraySplit)(datas, ps);
+    if (sync === ExcuteSplitMode.AsyncTrust) {
+        return new Promise(async (resolve, reject) => {
+            const reasons = [];
+            if (settled) {
+                const result = await Promise.allSettled(list.map((list, i) => fn(list, i, list.length, extendParams[i])));
+                for (const item of result) {
+                    if (item.status === 'rejected') {
+                        reject(item.reason);
+                    }
+                    else {
+                        reasons.push(item.value);
+                    }
+                }
+            }
+            else {
+                for (let i = 0; i < list.length; i++) {
+                    const startIndex = (i - 1) * ps.everyLength;
+                    const endIndex = startIndex + list[i].length - 1;
+                    reasons.push(await fn(list[i], i, list.length, extendParams[i], startIndex, endIndex));
+                }
+            }
+            resolve(reasons);
+        });
+    }
+    else if (sync === ExcuteSplitMode.AsyncNoTrust) {
+        return new Promise(async (resolve, reject) => {
+            const reasons = { result: [], error: [] };
+            if (settled) {
+                const result = await Promise.allSettled(list.map((list, i) => fn(list, i, list.length, extendParams[i])));
+                for (const item of result) {
+                    if (item.status === 'rejected') {
+                        reasons.error.push(item.reason);
+                    }
+                    else {
+                        reasons.result.push(item.value);
+                    }
+                }
+            }
+            else {
+                for (let i = 0; i < list.length; i++) {
+                    const startIndex = (i - 1) * ps.everyLength;
+                    const endIndex = startIndex + list[i].length - 1;
+                    try {
+                        reasons.result.push(await fn(list[i], i, list.length, extendParams[i], startIndex, endIndex));
+                    }
+                    catch (error) {
+                        reasons.error.push(error);
+                    }
+                }
+            }
+            resolve(reasons);
+        });
+    }
+    else if (sync === ExcuteSplitMode.SyncTrust) {
+        const reasons = [];
+        for (let i = 0; i < list.length; i++) {
+            const startIndex = (i - 1) * ps.everyLength;
+            const endIndex = startIndex + list[i].length - 1;
+            reasons.push(fn(list[i], i, list.length, extendParams[i], startIndex, endIndex));
+        }
+        return reasons;
+    }
+    else {
+        const reasons = { result: [], error: [] };
+        for (let i = 0; i < list.length; i++) {
+            try {
+                const startIndex = (i - 1) * ps.everyLength;
+                const endIndex = startIndex + list[i].length - 1;
+                reasons.result.push(fn(list[i], i, list.length, extendParams[i], startIndex, endIndex));
+            }
+            catch (error) {
+                reasons.error.push(error);
+            }
+        }
+        return reasons;
+    }
+}
+exports.excuteSplit = excuteSplit;

package/cjs/index.d.ts

@@ -0,0 +1,8 @@
+export * from './error';
+export * from './fn';
+export * from './math';
+export * from './now';
+export * from './object';
+export * from './set-ex';
+export * from './sql';
+export * from './string';

package/cjs/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./error"), exports);
+__exportStar(require("./fn"), exports);
+__exportStar(require("./math"), exports);
+__exportStar(require("./now"), exports);
+__exportStar(require("./object"), exports);
+__exportStar(require("./set-ex"), exports);
+__exportStar(require("./sql"), exports);
+__exportStar(require("./string"), exports);

package/cjs/math.d.ts

@@ -0,0 +1,69 @@
+/** 金钱格式化可用样式 */
+export declare class MoneyOption {
+    style?: 'currency' | 'decimal' | 'percent';
+    currency?: string;
+    prefix?: number;
+    def?: number;
+    currencyDisplay?: 'symbol' | 'name' | 'code';
+    useGrouping?: boolean;
+    local?: string;
+}
+export interface Point {
+    latitude: string;
+    longitude: string;
+    lat: number;
+    long: number;
+}
+export declare const num: (val: any, def?: number) => number;
+export declare const max: (...args: any[]) => number;
+export declare const min: (...args: any[]) => number;
+export declare const div: (...args: any[]) => number;
+export declare const divDef: (def: any, ...args: any[]) => number;
+export declare const add: (...args: any[]) => number;
+export declare const mul: (...args: any[]) => number;
+export declare const sub: (...args: any[]) => number;
+export declare const round: (number: any, numDigits: number, upOrDown?: number) => number;
+/** =value.xx,其中xx=number,如number=99，表示修正数字为value.99 */
+export declare const merge: (value: any, number: any) => any;
+export declare const money: (value: any, option?: MoneyOption) => string;
+export declare class Bus {
+    private result;
+    private ifit;
+    constructor(result: any);
+    add(...args: any[]): this;
+    sub(...args: any[]): this;
+    div(...args: any[]): this;
+    divDef(def: any, ...args: any[]): this;
+    mul(...args: any[]): this;
+    max(...args: any[]): this;
+    min(...args: any[]): this;
+    ac(): this;
+    abs(): this;
+    round(numDigits: number, upOrDown?: number): this;
+    merge(number: any): this;
+    if(condition: boolean): this;
+    over(): number;
+    money(option?: MoneyOption): string;
+    lt(data: any): boolean;
+    le(data: any): boolean;
+    gt(data: any): boolean;
+    ge(data: any): boolean;
+    nlt(data: any): boolean;
+    nle(data: any): boolean;
+    ngt(data: any): boolean;
+    nge(data: any): boolean;
+    eq(data: any): boolean;
+    ne(data: any): boolean;
+    ifLt(data: any): this;
+    ifLe(data: any): this;
+    ifGt(data: any): this;
+    ifGe(data: any): this;
+    ifNlt(data: any): this;
+    ifNle(data: any): this;
+    ifNgt(data: any): this;
+    ifNge(data: any): this;
+    ifEq(data: any): this;
+    ifNe(data: any): this;
+}
+export declare const calc: (result: any) => Bus;
+export declare const getGeo: (p1: Point, p2: Point) => number;