@wzyjs/utils 0.0.26 → 0.0.28

package/dist/node/esm/node/database/Collection.js

@@ -0,0 +1,200 @@
+import { merge, cloneDeep, isObject } from 'lodash';
+import { appendTime, defaultConditions } from './utils.js';
+import { Method, Command } from './types.js';
+
+class Collection {
+    db;
+    collection;
+    constructor(db, name) {
+        this.db = db;
+        this.collection = db.collection(name);
+    }
+    joinConditions(conditions) {
+        let record = this.collection;
+        if (!conditions) {
+            return record;
+        }
+        // 如果是根据 _id 查询
+        if ('_id' in conditions) {
+            record = record.doc(conditions._id);
+            // 如果是根据 条件 查询
+        }
+        else {
+            const { page, order, where, options } = conditions;
+            if (options) {
+                record = record.options(options);
+            }
+            if (where) {
+                record = record.where(where);
+            }
+            if (order) {
+                record = record.orderBy(order.field, order.type || 'desc');
+            }
+            if (page?.current && page?.size) {
+                record = record.skip((page.current - 1) * page.size);
+            }
+            if (page?.size) {
+                record = record.limit(page.size);
+            }
+        }
+        if (Array.isArray(conditions.field)) {
+            record = record.field(conditions.field.reduce((o, i) => ({ ...o, [i]: true }), {}));
+        }
+        else if (conditions.field) {
+            record = record.field(conditions.field);
+        }
+        return record;
+    }
+    request(params) {
+        switch (params.method) {
+            case Method.Add:
+                return this.joinConditions().add(params.data);
+            case Method.Find:
+            case Method.FindList:
+                return this.joinConditions(params.conditions).get();
+            case Method.Delete:
+                return this.joinConditions(params.conditions).remove();
+            case Method.Update:
+                if (params.isSet && '_id' in params.conditions) {
+                    return this.joinConditions(params.conditions).set(params.data);
+                }
+                return this.joinConditions(params.conditions).update(params.data);
+            case Method.Count:
+                return this.joinConditions(params.conditions).count();
+            default:
+                throw new Error('method is not exist');
+        }
+    }
+    // 处理出参
+    async handleRes(params, res) {
+        if (res) {
+            delete res.requestId;
+        }
+        let data = res;
+        switch (params.method) {
+            case Method.Add:
+                const addRes = res;
+                if (addRes.id && params.isReturn) {
+                    data = await this.find({ _id: addRes.id, field: params.conditions?.field });
+                }
+                break;
+            case Method.Update:
+                const updateRes = res;
+                if (updateRes.updated && params.isReturn && '_id' in params.conditions) {
+                    data = await this.find({ _id: params.conditions._id, field: params.conditions?.field });
+                }
+                break;
+            case Method.Find:
+                const getRes = res;
+                data = getRes?.data[0] || null;
+                break;
+            case Method.FindList:
+                const getListRes = res;
+                const countRes = await this.request({
+                    method: Method.Count,
+                    conditions: params.conditions,
+                });
+                data = {
+                    list: getListRes.data,
+                    total: countRes.total,
+                };
+                break;
+        }
+        return data;
+    }
+    // 处理数据
+    async handleData(params) {
+        switch (params.method) {
+            case Method.Add:
+                params.data = appendTime(params.data, 'create');
+                params.data = appendTime(params.data, 'update');
+                break;
+            case Method.Update:
+                if ('_id' in params.data) {
+                    delete params.data._id;
+                }
+                break;
+        }
+        return params;
+    }
+    // 处理条件
+    handleConditions(params) {
+        if (params.method !== Method.Add) {
+            params.conditions = merge(cloneDeep(defaultConditions), params.conditions);
+        }
+        // 处理 where 条件
+        if (params.conditions && 'where' in params.conditions) {
+            const { command: _ } = this.db;
+            for (const key in params.conditions.where) {
+                const whereValue = params.conditions.where[key];
+                if (isObject(whereValue)) {
+                    const { type, value } = whereValue;
+                    switch (type) {
+                        case Command.In:
+                            params.conditions.where[key] = _.in(value);
+                            break;
+                        case Command.Nin:
+                            params.conditions.where[key] = _.nin(value);
+                            break;
+                        case Command.Gt:
+                            params.conditions.where[key] = _.gt(value);
+                            break;
+                        case Command.Gte:
+                            params.conditions.where[key] = _.gte(value);
+                            break;
+                        case Command.Lt:
+                            params.conditions.where[key] = _.lt(value);
+                            break;
+                        case Command.Lte:
+                            params.conditions.where[key] = _.lte(value);
+                            break;
+                        case Command.Eq:
+                            params.conditions.where[key] = _.eq(value);
+                            break;
+                        case Command.Neq:
+                            params.conditions.where[key] = _.neq(value);
+                            break;
+                        case Command.Gtlt:
+                            params.conditions.where[key] = _.and(_.gt(value[0]), _.lt(value[1]));
+                            break;
+                        default:
+                            const check = type;
+                            console.error(666, '处理 where 条件 出现未定义的情况', check);
+                            break;
+                    }
+                }
+            }
+        }
+        return params;
+    }
+    async exec(params) {
+        params = await this.handleData(params);
+        params = await this.handleConditions(params);
+        const res = await this.request(params);
+        return this.handleRes(params, res);
+    }
+    add(data, isReturn, conditions) {
+        return this.exec({ method: Method.Add, conditions, data, isReturn });
+    }
+    // 删
+    delete(conditions) {
+        return this.exec({ method: Method.Delete, conditions });
+    }
+    update(conditions, data, isReturn, isSet) {
+        return this.exec({ method: Method.Update, conditions, data, isReturn, isSet });
+    }
+    // 查
+    find(conditions) {
+        return this.exec({ method: Method.Find, conditions });
+    }
+    // 查列表
+    findList(conditions) {
+        return this.exec({ method: Method.FindList, conditions });
+    }
+    // 查
+    count(conditions) {
+        return this.exec({ method: Method.Count, conditions });
+    }
+}
+
+export { Collection };

package/dist/node/esm/node/database/Database.js

@@ -0,0 +1,23 @@
+import { init } from '@cloudbase/node-sdk';
+import { Collection } from './Collection.js';
+
+class Database {
+    db;
+    instance = {};
+    constructor(config) {
+        this.db = init(config).database();
+    }
+    // 封装了较多功能的 collection
+    collection(name) {
+        if (!this.instance[name]) {
+            this.instance[name] = new Collection(this.db, name);
+        }
+        return this.instance[name];
+    }
+    // 创建 collection
+    createCollection(name) {
+        return this.db.createCollection(name);
+    }
+}
+
+export { Database };

package/dist/node/esm/node/database/types.js

@@ -0,0 +1,25 @@
+// 查询数据库的条件 - 比较的特殊条件
+var Command;
+(function (Command) {
+    Command["Eq"] = "eq";
+    Command["Neq"] = "neq";
+    Command["Lt"] = "lt";
+    Command["Lte"] = "lte";
+    Command["Gt"] = "gt";
+    Command["Gte"] = "gte";
+    Command["In"] = "in";
+    Command["Nin"] = "nin";
+    Command["Gtlt"] = "gtlt";
+})(Command || (Command = {}));
+// 查询的方法
+var Method;
+(function (Method) {
+    Method["Add"] = "add";
+    Method["Find"] = "find";
+    Method["FindList"] = "findList";
+    Method["Delete"] = "delete";
+    Method["Update"] = "update";
+    Method["Count"] = "count";
+})(Method || (Method = {}));
+
+export { Command, Method };

package/dist/node/esm/node/database/utils.js

@@ -0,0 +1,27 @@
+// 给记录添加时间
+const appendTime = (data, type) => {
+    if (!data) {
+        return {};
+    }
+    return {
+        ...data,
+        [type + 'At']: Date.now(),
+    };
+};
+// 默认条件
+const defaultConditions = {
+    order: {
+        field: 'createAt',
+        type: 'desc',
+    },
+    options: {
+        timeout: 10000,
+        multiple: true,
+    },
+    page: {
+        current: 1,
+        size: 10,
+    },
+};
+
+export { appendTime, defaultConditions };

package/dist/node/esm/node/jsonFile/index.js

@@ -0,0 +1,27 @@
+const fs = require('fs');
+const path = require('path');
+// 实现一个文件系统读写数据库
+class JsonFile {
+    filePath;
+    constructor(filePath) {
+        this.filePath = path.resolve(__dirname, filePath);
+    }
+    get(key) {
+        return new Promise((resolve) => {
+            fs.readFile(this.filePath, (err, data) => {
+                const json = data ? JSON.parse(data) : {};
+                resolve(json[key]);
+            });
+        });
+    }
+    set(key, value) {
+        fs.readFile(this.filePath, { encoding: 'utf-8' }, (err, data) => {
+            const json = data ? JSON.parse(data || '{}') : {};
+            json[key] = value;
+            fs.writeFile(this.filePath, JSON.stringify(json), () => {
+            });
+        });
+    }
+}
+
+export { JsonFile };

package/dist/node/esm/node/mail/index.js

@@ -0,0 +1,29 @@
+import nodemailer from 'nodemailer';
+
+const fromEmail = '15835196981@163.com';
+const fromPass = 'KPTVCFBMRXJVTCGW';
+const transporter = nodemailer.createTransport({
+    host: 'smtp.163.com',
+    port: 465,
+    secure: true,
+    auth: {
+        user: fromEmail,
+        pass: fromPass
+    }
+});
+const sendMail = async (toEmail, title, content) => {
+    try {
+        await transporter.sendMail({
+            from: fromEmail,
+            to: toEmail,
+            subject: title,
+            text: content // 邮件正文
+        });
+        return title + ' 邮件通知成功';
+    }
+    catch (error) {
+        return title + '邮件通知失败' + JSON.stringify(error);
+    }
+};
+
+export { sendMail };

package/dist/node/esm/node.js

@@ -0,0 +1,14 @@
+export { default as _, cloneDeep, debounce, find, groupBy, isBoolean, isEmpty, isEqual, isError, isFunction, isNumber, isObject, isString, merge, noop, omit, pick, uniq, uniqBy, uniqWith } from 'lodash';
+import * as consola from 'consola';
+export { consola };
+import './common/dayjs.js';
+export * from 'zod';
+export { amount, getChinese, getChineseByStr, getCookie, getLength, getProxyUrl, getRandomColor, getRandomString, getSliceStr, getStrLength, getType, isJson, jsonParse, replaceAll, replaceByRules, toString } from './common/string.js';
+export { filterParams, findItem, watch } from './common/object.js';
+export { delay, executePromise, handleParams, handleRes2List, locationFn } from './common/other.js';
+export { getFileSize, getRandomNum, limitDecimals } from './common/number.js';
+export { CustomError } from './common/classs.js';
+export { Database } from './node/database/Database.js';
+export { JsonFile } from './node/jsonFile/index.js';
+export { sendMail } from './node/mail/index.js';
+export { Dayjs, default as dayjs } from 'dayjs';

package/dist/node/esm/types/index.d.ts

@@ -0,0 +1,27 @@
+export interface RequestRes<D = any> {
+    success: boolean;
+    message: string;
+    data: D;
+}
+export type KeyValue<D extends object | string = string, V = any> = Partial<Record<D extends string ? string : keyof D, V>>;
+export interface Pagination {
+    current?: number;
+    pageSize?: number;
+}
+export type SortParams<D extends object | string = string> = Record<D extends string ? string : keyof D, 'ascend' | 'descend'>;
+export type OrderParams<D extends object | string = string> = {
+    field: D extends string ? string : keyof D;
+    type: 'asc' | 'desc';
+};
+export interface Option<V extends string | number = string> {
+    label: string;
+    value: V;
+    children?: Option<V>[];
+}
+export type OrderBy = {
+    [key: string]: 'asc' | 'desc';
+} | {
+    [key: string]: 'asc' | 'desc';
+}[];
+export type Optional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+export type Set<T, OmitK extends keyof T = never, OptionalK extends Exclude<keyof T, OmitK> = never> = Optional<Omit<T, OmitK>, OptionalK>;

package/dist/node/esm/utils/src/browser/element.d.ts

@@ -0,0 +1,9 @@
+export declare const scrollIntoView: (el: Element, option?: ScrollIntoViewOptions) => void;
+export declare const getElement: (el: string | Element) => {
+    element: null;
+    originalStyle: {};
+} | {
+    element: Element;
+    originalStyle: CSSStyleDeclaration;
+};
+export declare const isElementInViewport: (el: string | Element) => boolean | undefined;

package/dist/node/esm/utils/src/browser/index.d.ts

@@ -0,0 +1,18 @@
+import md5 from 'md5';
+import classnames from 'classnames';
+import copy from 'copy-to-clipboard';
+import anime from 'animejs';
+export { copy, classnames, md5, anime };
+export declare const localforage: {
+    config: {
+        (options: LocalForageOptions): boolean;
+        (options: string): any;
+        (): LocalForageOptions;
+    };
+    setItem: <T>(key: string, value: T, callback?: ((err: any, value: T) => void) | undefined) => Promise<T>;
+    getItem: <T_1>(key: string, callback?: ((err: any, value: T_1 | null) => void) | undefined) => Promise<T_1 | null>;
+    removeItem: (key: string, callback?: ((err: any) => void) | undefined) => Promise<void>;
+};
+export * from './style';
+export * from './element';
+export * from './other';

package/dist/node/esm/utils/src/browser/other.d.ts

@@ -0,0 +1 @@
+export declare const readClipboard: () => Promise<string>;

package/dist/node/esm/utils/src/browser/style.d.ts

@@ -0,0 +1,10 @@
+export declare const hexToRgba: (hexColor: string, a?: number) => {
+    nums: {
+        red: number;
+        green: number;
+        blue: number;
+    };
+    text: string;
+};
+export declare const flashBackground: (el: string | Element, color: string, a?: number) => void;
+export declare const flashBorder: (el: string | Element, color: string, a?: number) => void;

package/dist/node/esm/utils/src/browser.d.ts

@@ -0,0 +1,2 @@
+export * from './common';
+export * from './browser/index';

package/dist/node/esm/utils/src/common/classs.d.ts

@@ -0,0 +1,5 @@
+export declare class CustomError extends Error {
+    code?: number;
+    data?: any;
+    constructor(message: string, code?: number, data?: any);
+}

package/dist/node/esm/utils/src/common/dayjs.d.ts

@@ -0,0 +1,4 @@
+import dayjs from 'dayjs';
+import 'dayjs/locale/zh-cn';
+export { Dayjs } from 'dayjs';
+export default dayjs;

package/dist/node/esm/utils/src/common/index.d.ts

@@ -0,0 +1,11 @@
+import { cloneDeep, debounce, isBoolean, isEqual, isFunction, isNumber, isObject, isString, merge, omit, pick, uniq, uniqBy, uniqWith, isEmpty, isError, find, groupBy, noop } from 'lodash';
+export { cloneDeep, debounce, isBoolean, isEqual, isFunction, isNumber, isObject, isString, merge, omit, pick, uniq, uniqBy, uniqWith, isEmpty, isError, find, groupBy, noop, };
+export * as consola from 'consola';
+export { default as dayjs, Dayjs } from './dayjs';
+export * from 'zod';
+export * from './string';
+export * from './object';
+export * from './other';
+export * from './number';
+export * from './classs';
+export { default as _ } from 'lodash';

package/dist/node/esm/utils/src/common/number.d.ts

@@ -0,0 +1,3 @@
+export declare const getRandomNum: (min: number, max: number) => number;
+export declare const limitDecimals: (v: string, num: number | undefined, isForce: boolean) => string;
+export declare const getFileSize: (size: number) => string;

package/dist/node/esm/utils/src/common/object.d.ts

@@ -0,0 +1,10 @@
+export declare const findItem: <I>(list: I[], attr: keyof I, value?: I[keyof I] | undefined) => I | undefined;
+export declare const filterParams: (params: {
+    [key: string]: any;
+}) => {};
+export declare const watch: {
+    observe(obj: {
+        [key: string]: any;
+    }, key: string, watchFun: (value: any, val: any) => undefined): void;
+    setWatcher(data?: {}, watch?: {}): void;
+};

package/dist/node/esm/utils/src/common/other.d.ts

@@ -0,0 +1,26 @@
+import { KeyValue, OrderParams, Pagination, SortParams } from '@wzyjs/types';
+export declare const handleParams: (params?: Pagination & KeyValue, sort?: SortParams) => {
+    page: {
+        size?: number | undefined;
+        current?: number | undefined;
+    };
+    where: KeyValue<string, string | number | boolean | RegExp>;
+    order?: OrderParams<string> | undefined;
+};
+export declare const handleRes2List: <D>(reqPromise: any) => Promise<{
+    label: string;
+    value: string;
+}[]>;
+export declare const executePromise: (promise: Promise<any>) => Promise<{
+    result: any;
+    time: number;
+}>;
+export declare const locationFn: {
+    url2Params: (url?: string) => {};
+    params2Url: (params: {
+        [key: string]: any;
+    }) => string;
+    setUrlParams: (key: string, value: any, keepName: string) => void;
+    urlGetPath: (url?: string) => string;
+};
+export declare const delay: (time?: number) => Promise<unknown>;

package/dist/node/esm/utils/src/common/string.d.ts

@@ -0,0 +1,16 @@
+export declare const getChineseByStr: (str: string) => string;
+export declare const getStrLength: (value: string) => number;
+export declare const replaceAll: (str: string, searchValue: string, replaceValue: string) => string;
+export declare const replaceByRules: (str: string, rules: [string, string][]) => string;
+export declare const getType: (value: any) => string;
+export declare const amount: (str: string) => string;
+export declare const jsonParse: (value: string | object) => object;
+export declare const isJson: (str: string) => boolean;
+export declare const toString: (value: any) => string;
+export declare const getRandomColor: () => string;
+export declare const getRandomString: (length?: number) => string;
+export declare const getChinese: (str: string) => string;
+export declare const getSliceStr: (str: string, before: string, after: string) => string;
+export declare const getProxyUrl: (url: string) => string;
+export declare const getLength: (value: string) => number;
+export declare const getCookie: (name: string) => string | null;

package/dist/node/esm/utils/src/node/database/Collection.d.ts

@@ -0,0 +1,22 @@
+import { Database, IKeyValue } from '@cloudbase/node-sdk';
+import { Add, Conditions, Count, Delete, Find, FindList, IdConditions, MethodParams, Update, WhereConditions } from './types';
+export declare class Collection<D extends IKeyValue> {
+    private readonly db;
+    private readonly collection;
+    constructor(db: Database.Db, name: string);
+    private joinConditions;
+    private request;
+    private handleRes;
+    private handleData;
+    handleConditions(params: MethodParams<D>): MethodParams<D>;
+    private exec;
+    add(data: Add.Params<D>['data']): Promise<Add.Res>;
+    add(data: Add.Params<D>['data'], isReturn: true, conditions?: Pick<IdConditions, 'field'>): Promise<Find.Res<D>>;
+    delete(conditions: Conditions): Promise<Delete.Res>;
+    update(conditions: Conditions, data: Update.Params<D>['data'], isSet?: true): Promise<Update.Res<D>>;
+    update(conditions: IdConditions, data: Update.Params<D>['data'], isSet?: true): Promise<Update.Res<D>>;
+    update(conditions: IdConditions, data: Update.Params<D>['data'], isReturn: true, isSet?: true): Promise<Find.Res<D>>;
+    find(conditions?: Conditions): Promise<Find.Res<D>>;
+    findList(conditions?: WhereConditions): Promise<FindList.Res<D>>;
+    count(conditions: Conditions): Promise<Count.Res>;
+}

package/dist/node/esm/utils/src/node/database/Database.d.ts

@@ -0,0 +1,10 @@
+import tcb, { IKeyValue } from '@cloudbase/node-sdk';
+import { Config } from './types';
+import { Collection } from './Collection';
+export declare class Database {
+    private readonly db;
+    private readonly instance;
+    constructor(config: Config);
+    collection<D extends IKeyValue>(name: string): Collection<D>;
+    createCollection(name: string): tcb.IBaseRes;
+}

package/dist/node/esm/utils/src/node/database/index.d.ts

@@ -0,0 +1,2 @@
+export { Database } from './Database';
+export { Conditions, IdConditions, WhereConditions, Record } from './types';