baja-lite 1.0.0

package/es/fn.js

@@ -0,0 +1,162 @@
+import { arraySplit } from './object';
+import { Throw } from './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
+ */
+export 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);
+            }
+        });
+    };
+};
+export const sleep = (time = parseInt(`${Math.random()}`) + 200) => new Promise((resolve) => setTimeout(resolve, time));
+/**
+ * 执行器
+ * @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 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 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;
+}
+export 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 || (ExcuteSplitMode = {}));
+export function excuteSplit(sync, datas, fn, { everyLength = 0, groupCount = 0, settled = false, extendParams = new Array() }) {
+    if (extendParams.length > 0) {
+        groupCount = extendParams.length;
+    }
+    Throw.if(everyLength === 0 && groupCount === 0, '参数错误!');
+    const ps = { everyLength, groupCount };
+    const list = 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;
+    }
+}

package/es/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/es/index.js

@@ -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/es/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;

package/es/math.js

@@ -0,0 +1,414 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+import Decimal from 'decimal.js';
+/** 金钱格式化可用样式 */
+export class MoneyOption {
+    constructor() {
+        this.style = 'currency';
+        this.currency = 'CNY';
+        this.prefix = 2;
+        this.def = 0;
+        this.currencyDisplay = 'symbol';
+        this.useGrouping = true;
+        this.local = 'zh';
+    }
+}
+// const ONE = new Decimal(1);
+const ZERO = new Decimal(0);
+function isNum(a) {
+    return a !== '' && a !== null && !isNaN(a);
+}
+export const num = (val, def = 0) => {
+    if (val instanceof Bus) {
+        return val.over();
+    }
+    else if (!isNum(val)) {
+        return def;
+    }
+    return +val;
+};
+function filterNumber(array) {
+    const res = [];
+    array.forEach((element) => {
+        if (element instanceof Bus) {
+            res.push(element.over());
+        }
+        else if (isNum(element)) {
+            res.push(+element);
+        }
+    });
+    return res;
+}
+function filterNumber2(array, def) {
+    const res = [];
+    array.forEach((element) => {
+        if (element instanceof Bus) {
+            res.push(new Decimal(element.over()));
+        }
+        else if (isNum(element)) {
+            res.push(new Decimal(element));
+        }
+        else if (def !== undefined) {
+            res.push(new Decimal(def));
+        }
+    });
+    return res;
+}
+export const max = (...args) => {
+    const arr = filterNumber(args);
+    return Math.max.apply(null, arr);
+};
+export const min = (...args) => {
+    const arr = filterNumber(args);
+    return Math.min.apply(null, arr);
+};
+export const div = (...args) => {
+    const arr = filterNumber2(args);
+    if (arr.length > 1) {
+        return arr.reduce((a, b) => a.div(b)).toNumber();
+    }
+    else if (arr.length > 0) {
+        return arr[0].toNumber();
+    }
+    else {
+        return 0;
+    }
+};
+export const divDef = (def, ...args) => {
+    const arr = filterNumber2(args);
+    if (arr.length > 1) {
+        const zeros = arr.slice(1).findIndex(i => i.equals(ZERO));
+        if (zeros > -1) {
+            return new Decimal(def).toNumber();
+        }
+        return arr.reduce((a, b) => a.div(b)).toNumber();
+    }
+    else if (arr.length > 0) {
+        return arr[0].toNumber();
+    }
+    else {
+        return 0;
+    }
+};
+export const add = (...args) => {
+    const arr = filterNumber2(args);
+    if (arr.length > 1) {
+        return arr.reduce((a, b) => a.add(b)).toNumber();
+    }
+    else if (arr.length > 0) {
+        return arr[0].toNumber();
+    }
+    else {
+        return 0;
+    }
+};
+export const mul = (...args) => {
+    const arr = filterNumber2(args);
+    if (arr.length > 1) {
+        return arr.reduce((a, b) => a.mul(b)).toNumber();
+    }
+    else if (arr.length > 0) {
+        return arr[0].toNumber();
+    }
+    else {
+        return 0;
+    }
+};
+export const sub = (...args) => {
+    const arr = filterNumber2(args, 0);
+    if (arr.length > 1) {
+        return arr.reduce((a, b) => a.sub(b)).toNumber();
+    }
+    else if (arr.length > 0) {
+        return arr[0].toNumber();
+    }
+    else {
+        return 0;
+    }
+};
+const roundMode = [Decimal.ROUND_HALF_UP, Decimal.ROUND_UP, Decimal.ROUND_DOWN];
+export const round = (number, numDigits, upOrDown = 0) => {
+    if (isNum(number)) {
+        const nu = new Decimal(number);
+        return nu.toDP(numDigits, roundMode[upOrDown]).toNumber();
+    }
+    else {
+        return 0;
+    }
+};
+/** =value.xx,其中xx=number,如number=99，表示修正数字为value.99 */
+export const merge = function (value, number) {
+    if (isNum(value) && isNum(number)) {
+        return new Decimal(value).floor().add(`0.${number}`).toNumber();
+    }
+    else if (isNum(value)) {
+        return value;
+    }
+    else {
+        return 0;
+    }
+};
+export const money = (value, option = {}) => {
+    // Intl.NumberFormat(option.local ?? 'zh', {
+    //   style: option.style ?? 'currency',
+    //   currency: option.currency ?? 'CNY',
+    //   minimumFractionDigits: option.prefix ?? 2,
+    //   currencyDisplay: option.currencyDisplay ?? 'symbol',
+    //   useGrouping: option.useGrouping ?? true
+    // }).format(isNum(value) ? value : option.def).replace(/CN|\s/g, '');
+    return (isNum(value) ? value : option.def).toLocaleString(option.local ?? 'zh', {
+        style: option.style ?? 'currency',
+        currency: option.currency ?? 'CNY',
+        minimumFractionDigits: option.prefix ?? 2,
+        currencyDisplay: option.currencyDisplay ?? 'symbol',
+        useGrouping: option.useGrouping ?? true
+    }).replace(/CN|\s/g, '');
+};
+const IF = function () {
+    return function (_target, _propertyKey, descriptor) {
+        const fn = descriptor.value;
+        descriptor.value = function () {
+            if (this['ifit'] === true) {
+                // eslint-disable-next-line prefer-rest-params
+                const args = Array.from(arguments);
+                fn.call(this, ...args);
+            }
+            this['ifit'] = true;
+            return this;
+        };
+    };
+};
+export class Bus {
+    constructor(result) {
+        this.ifit = true;
+        this.result = num(result);
+    }
+    add(...args) {
+        this.result = add(this.result, ...args);
+        return this;
+    }
+    sub(...args) {
+        this.result = sub(this.result, ...args);
+        return this;
+    }
+    div(...args) {
+        this.result = div(this.result, ...args);
+        return this;
+    }
+    divDef(def, ...args) {
+        this.result = divDef(def, this.result, ...args);
+        return this;
+    }
+    mul(...args) {
+        this.result = mul(this.result, ...args);
+        return this;
+    }
+    max(...args) {
+        this.result = max(this.result, ...args);
+        return this;
+    }
+    min(...args) {
+        this.result = min(this.result, ...args);
+        return this;
+    }
+    ac() {
+        this.result = sub(0, this.result);
+        return this;
+    }
+    abs() {
+        this.result = Math.abs(this.result);
+        return this;
+    }
+    round(numDigits, upOrDown) {
+        this.result = round(this.result, numDigits, upOrDown);
+        return this;
+    }
+    merge(number) {
+        this.result = merge(this.result, number);
+        return this;
+    }
+    if(condition) {
+        this.ifit = condition;
+        return this;
+    }
+    over() {
+        return this.result;
+    }
+    money(option) {
+        return money(this.result, option);
+    }
+    lt(data) {
+        const [d, r] = filterNumber2([data, this.result]);
+        return r.lessThan(d);
+    }
+    le(data) {
+        const [d, r] = filterNumber2([data, this.result]);
+        return r.lessThanOrEqualTo(d);
+    }
+    gt(data) {
+        const [d, r] = filterNumber2([data, this.result]);
+        return r.greaterThan(d);
+    }
+    ge(data) {
+        const [d, r] = filterNumber2([data, this.result]);
+        return r.greaterThanOrEqualTo(d);
+    }
+    nlt(data) {
+        const [d, r] = filterNumber2([data, this.result]);
+        return !r.lessThan(d);
+    }
+    nle(data) {
+        const [d, r] = filterNumber2([data, this.result]);
+        return !r.lessThanOrEqualTo(d);
+    }
+    ngt(data) {
+        const [d, r] = filterNumber2([data, this.result]);
+        return !r.greaterThan(d);
+    }
+    nge(data) {
+        const [d, r] = filterNumber2([data, this.result]);
+        return !r.greaterThanOrEqualTo(d);
+    }
+    eq(data) {
+        const [d, r] = filterNumber2([data, this.result]);
+        return r.equals(d);
+    }
+    ne(data) {
+        const [d, r] = filterNumber2([data, this.result]);
+        return !r.eq(d);
+    }
+    ifLt(data) {
+        const [d, r] = filterNumber2([data, this.result]);
+        this.ifit = r.lessThan(d);
+        return this;
+    }
+    ifLe(data) {
+        const [d, r] = filterNumber2([data, this.result]);
+        this.ifit = r.lessThanOrEqualTo(d);
+        return this;
+    }
+    ifGt(data) {
+        const [d, r] = filterNumber2([data, this.result]);
+        this.ifit = r.greaterThan(d);
+        return this;
+    }
+    ifGe(data) {
+        const [d, r] = filterNumber2([data, this.result]);
+        this.ifit = r.greaterThanOrEqualTo(d);
+        return this;
+    }
+    ifNlt(data) {
+        const [d, r] = filterNumber2([data, this.result]);
+        this.ifit = !r.lessThan(d);
+        return this;
+    }
+    ifNle(data) {
+        const [d, r] = filterNumber2([data, this.result]);
+        this.ifit = !r.lessThanOrEqualTo(d);
+        return this;
+    }
+    ifNgt(data) {
+        const [d, r] = filterNumber2([data, this.result]);
+        this.ifit = !r.greaterThan(d);
+        return this;
+    }
+    ifNge(data) {
+        const [d, r] = filterNumber2([data, this.result]);
+        this.ifit = !r.greaterThanOrEqualTo(d);
+        return this;
+    }
+    ifEq(data) {
+        const [d, r] = filterNumber2([data, this.result]);
+        this.ifit = r.equals(d);
+        return this;
+    }
+    ifNe(data) {
+        const [d, r] = filterNumber2([data, this.result]);
+        this.ifit = !r.eq(d);
+        return this;
+    }
+}
+__decorate([
+    IF(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Object)
+], Bus.prototype, "add", null);
+__decorate([
+    IF(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Object)
+], Bus.prototype, "sub", null);
+__decorate([
+    IF(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Object)
+], Bus.prototype, "div", null);
+__decorate([
+    IF(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Object)
+], Bus.prototype, "divDef", null);
+__decorate([
+    IF(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Object)
+], Bus.prototype, "mul", null);
+__decorate([
+    IF(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Object)
+], Bus.prototype, "max", null);
+__decorate([
+    IF(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Object)
+], Bus.prototype, "min", null);
+__decorate([
+    IF(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Object)
+], Bus.prototype, "ac", null);
+__decorate([
+    IF(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Object)
+], Bus.prototype, "abs", null);
+__decorate([
+    IF(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Number, Number]),
+    __metadata("design:returntype", Object)
+], Bus.prototype, "round", null);
+__decorate([
+    IF(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], Bus.prototype, "merge", null);
+export const calc = (result) => {
+    return new Bus(result);
+};
+export const getGeo = (p1, p2) => {
+    p1.lat = calc(p1.latitude).mul(Math.PI).div(180).over();
+    p1.long = calc(p1.longitude).mul(Math.PI).div(180).over();
+    p2.lat = calc(p2.latitude).mul(Math.PI).div(180).over();
+    p2.long = calc(p2.longitude).mul(Math.PI).div(180).over();
+    return calc(Math.round(mul(Math.asin(Math.sqrt(add(Math.pow(Math.sin(div(sub(p1.lat, p2.lat), 2)), 2), mul(Math.cos(p1.lat), Math.cos(p2.lat), Math.pow(Math.sin(div(sub(p1.long, p2.long), 2)), 2))))), 2, 6378.137, 10000))).div(10000).round(2).over();
+};

package/es/now.d.ts

@@ -0,0 +1,7 @@
+export declare const dateTime = "YYYY-MM-DD HH:mm:ss";
+export declare const dateXSDTime = "YYYY-MM-DDTHH:mm:ss";
+export declare const date = "YYYY-MM-DD";
+export declare const nowTime: () => string;
+export declare const nowDate: () => string;
+export declare const nowTimeXSD: () => string;
+export declare const dateFormat: (str: any, format?: string) => any;

package/es/now.js

@@ -0,0 +1,16 @@
+import day from 'dayjs';
+export const dateTime = 'YYYY-MM-DD HH:mm:ss';
+export const dateXSDTime = 'YYYY-MM-DDTHH:mm:ss';
+export const date = 'YYYY-MM-DD';
+export const nowTime = () => day().format(dateTime);
+export const nowDate = () => day().format(date);
+export const nowTimeXSD = () => day().format(dateXSDTime);
+export const dateFormat = (str, format) => {
+    if (str) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+        return day(str).format(format || dateTime);
+    }
+    else {
+        return str;
+    }
+};