@wzyjs/utils 0.0.7 → 0.0.11

package/dist/cjs/common/index.d.ts

@@ -0,0 +1,5 @@
+import { cloneDeep, debounce, isBoolean, isEqual, isFunction, isNumber, isObject, isString, merge, omit, pick, uniq, uniqBy, uniqWith, isEmpty, isError } from 'lodash';
+export { cloneDeep, debounce, isBoolean, isEqual, isFunction, isNumber, isObject, isString, merge, omit, pick, uniq, uniqBy, uniqWith, isEmpty, isError, };
+export * as consola from 'consola';
+export * from './tools';
+export * from './types';

package/dist/cjs/common/tools/other.d.ts

@@ -0,0 +1,14 @@
+import { KeyValue, OrderParams, Pagination, SortParams } from '../types';
+export declare const handleParams: (params?: Pagination & KeyValue, sort?: SortParams) => {
+    page: Pagination;
+    where: KeyValue<string, string | number | boolean | RegExp>;
+    order?: OrderParams;
+};
+export declare const handleRes2List: <D>(reqPromise: any) => Promise<{
+    label: string;
+    value: string;
+}[]>;
+export declare const executePromise: (promise: Promise<any>) => Promise<{
+    result: any;
+    time: number;
+}>;

package/dist/cjs/common/tools/other.js

@@ -0,0 +1,50 @@
+'use strict';
+
+// 处理 ProComponents 中 ProTable 参数中的 page 和 where 和 sort
+const handleParams = (params, sort) => {
+    if (!params) {
+        return {
+            page: {},
+            where: {},
+        };
+    }
+    const { current, pageSize, ...other } = params;
+    return {
+        page: {
+            current: current || 1,
+            pageSize: pageSize || 10,
+        },
+        where: Object.entries(other).reduce((acc, [key, value]) => {
+            if (key && value) {
+                acc[key] = typeof value === 'string' ? new RegExp(value) : value;
+            }
+            return acc;
+        }, {}),
+        order: sort && {
+            field: Object.keys(sort)[0],
+            type: Object.values(sort)[0] === 'ascend' ? 'asc' : 'desc',
+        },
+    };
+};
+// 将 list 的数据处理为 { label: string, value: string }[]
+const handleRes2List = async (reqPromise) => {
+    const { data } = await reqPromise();
+    return (data?.list || []).map((item) => ({
+        label: item.name,
+        value: item.key,
+    }));
+};
+// 计算执行 promise 花费的时间
+const executePromise = async (promise) => {
+    const start = Date.now();
+    const result = await promise;
+    const time = Date.now() - start;
+    return {
+        result,
+        time,
+    };
+};
+
+exports.executePromise = executePromise;
+exports.handleParams = handleParams;
+exports.handleRes2List = handleRes2List;

package/dist/cjs/{types → common/types}/index.d.ts

@@ -3,7 +3,7 @@ export interface RequestRes<D = any> {
     message?: string;
     data?: D;
 }
-export type KeyValue<D extends object | string = string, V = string | number | boolean> = Record<D extends string ? string : keyof D, V>;
+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;

package/dist/cjs/fe/index.d.ts

@@ -0,0 +1,15 @@
+import md5 from 'md5';
+import dayjs from 'dayjs';
+import classnames from 'classnames';
+import copy from 'copy-to-clipboard';
+export { copy, classnames, dayjs, md5 };
+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>;
+};

package/dist/cjs/index.d.ts

@@ -1,22 +1,2 @@
-import dayjs from 'dayjs';
-import copy from 'copy-to-clipboard';
-import classnames from 'classnames';
-import consola from 'consola';
-import md5 from 'md5';
-export { copy, consola, classnames, dayjs, md5 };
-export * from 'ahooks';
-import { omit, pick, cloneDeep, isEqual, merge, isObject, isBoolean, isString, isNumber } from 'lodash';
-export { omit, pick, cloneDeep, isEqual, merge, isObject, isBoolean, isString, isNumber };
-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 './tools';
-export * from './hooks';
-export * from './types';
+export * from './common';
+export * from './fe';

package/dist/cjs/index_c.d.ts

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

package/dist/cjs/index_c.js

@@ -0,0 +1,105 @@
+'use strict';
+
+var lodash = require('lodash');
+var consola = require('consola');
+var string = require('./common/tools/string.js');
+var object = require('./common/tools/object.js');
+var other = require('./common/tools/other.js');
+var Database = require('./rd/database/Database.js');
+
+function _interopNamespaceDefault(e) {
+	var n = Object.create(null);
+	if (e) {
+		Object.keys(e).forEach(function (k) {
+			if (k !== 'default') {
+				var d = Object.getOwnPropertyDescriptor(e, k);
+				Object.defineProperty(n, k, d.get ? d : {
+					enumerable: true,
+					get: function () { return e[k]; }
+				});
+			}
+		});
+	}
+	n.default = e;
+	return Object.freeze(n);
+}
+
+var consola__namespace = /*#__PURE__*/_interopNamespaceDefault(consola);
+
+
+
+Object.defineProperty(exports, 'cloneDeep', {
+	enumerable: true,
+	get: function () { return lodash.cloneDeep; }
+});
+Object.defineProperty(exports, 'debounce', {
+	enumerable: true,
+	get: function () { return lodash.debounce; }
+});
+Object.defineProperty(exports, 'isBoolean', {
+	enumerable: true,
+	get: function () { return lodash.isBoolean; }
+});
+Object.defineProperty(exports, 'isEmpty', {
+	enumerable: true,
+	get: function () { return lodash.isEmpty; }
+});
+Object.defineProperty(exports, 'isEqual', {
+	enumerable: true,
+	get: function () { return lodash.isEqual; }
+});
+Object.defineProperty(exports, 'isError', {
+	enumerable: true,
+	get: function () { return lodash.isError; }
+});
+Object.defineProperty(exports, 'isFunction', {
+	enumerable: true,
+	get: function () { return lodash.isFunction; }
+});
+Object.defineProperty(exports, 'isNumber', {
+	enumerable: true,
+	get: function () { return lodash.isNumber; }
+});
+Object.defineProperty(exports, 'isObject', {
+	enumerable: true,
+	get: function () { return lodash.isObject; }
+});
+Object.defineProperty(exports, 'isString', {
+	enumerable: true,
+	get: function () { return lodash.isString; }
+});
+Object.defineProperty(exports, 'merge', {
+	enumerable: true,
+	get: function () { return lodash.merge; }
+});
+Object.defineProperty(exports, 'omit', {
+	enumerable: true,
+	get: function () { return lodash.omit; }
+});
+Object.defineProperty(exports, 'pick', {
+	enumerable: true,
+	get: function () { return lodash.pick; }
+});
+Object.defineProperty(exports, 'uniq', {
+	enumerable: true,
+	get: function () { return lodash.uniq; }
+});
+Object.defineProperty(exports, 'uniqBy', {
+	enumerable: true,
+	get: function () { return lodash.uniqBy; }
+});
+Object.defineProperty(exports, 'uniqWith', {
+	enumerable: true,
+	get: function () { return lodash.uniqWith; }
+});
+exports.consola = consola__namespace;
+exports.getChineseByStr = string.getChineseByStr;
+exports.getStrLength = string.getStrLength;
+exports.jsonParse = string.jsonParse;
+exports.replaceAll = string.replaceAll;
+exports.replaceByRules = string.replaceByRules;
+exports.checkAttr = object.checkAttr;
+exports.executePromise = other.executePromise;
+exports.handleParams = other.handleParams;
+exports.handleRes2List = other.handleRes2List;
+exports.Database = Database.Database;

package/dist/cjs/rd/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/cjs/rd/database/Collection.js

@@ -0,0 +1,202 @@
+'use strict';
+
+var lodash = require('lodash');
+var utils = require('./utils.js');
+var types = require('./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 types.Method.Add:
+                return this.joinConditions().add(params.data);
+            case types.Method.Find:
+            case types.Method.FindList:
+                return this.joinConditions(params.conditions).get();
+            case types.Method.Delete:
+                return this.joinConditions(params.conditions).remove();
+            case types.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 types.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 types.Method.Add:
+                const addRes = res;
+                if (addRes.id && params.isReturn) {
+                    data = await this.find({ _id: addRes.id, field: params.conditions?.field });
+                }
+                break;
+            case types.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 types.Method.Find:
+                const getRes = res;
+                data = getRes?.data[0] || null;
+                break;
+            case types.Method.FindList:
+                const getListRes = res;
+                const countRes = await this.request({
+                    method: types.Method.Count,
+                    conditions: params.conditions,
+                });
+                data = {
+                    list: getListRes.data,
+                    total: countRes.total,
+                };
+                break;
+        }
+        return data;
+    }
+    // 处理数据
+    async handleData(params) {
+        switch (params.method) {
+            case types.Method.Add:
+                params.data = utils.appendTime(params.data, 'create');
+                params.data = utils.appendTime(params.data, 'update');
+                break;
+            case types.Method.Update:
+                if ('_id' in params.data) {
+                    delete params.data._id;
+                }
+                break;
+        }
+        return params;
+    }
+    // 处理条件
+    handleConditions(params) {
+        if (params.method !== types.Method.Add) {
+            params.conditions = lodash.merge(lodash.cloneDeep(utils.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 (lodash.isObject(whereValue)) {
+                    const { type, value } = whereValue;
+                    switch (type) {
+                        case types.Command.In:
+                            params.conditions.where[key] = _.in(value);
+                            break;
+                        case types.Command.Nin:
+                            params.conditions.where[key] = _.nin(value);
+                            break;
+                        case types.Command.Gt:
+                            params.conditions.where[key] = _.gt(value);
+                            break;
+                        case types.Command.Gte:
+                            params.conditions.where[key] = _.gte(value);
+                            break;
+                        case types.Command.Lt:
+                            params.conditions.where[key] = _.lt(value);
+                            break;
+                        case types.Command.Lte:
+                            params.conditions.where[key] = _.lte(value);
+                            break;
+                        case types.Command.Eq:
+                            params.conditions.where[key] = _.eq(value);
+                            break;
+                        case types.Command.Neq:
+                            params.conditions.where[key] = _.neq(value);
+                            break;
+                        case types.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: types.Method.Add, conditions, data, isReturn });
+    }
+    // 删
+    delete(conditions) {
+        return this.exec({ method: types.Method.Delete, conditions });
+    }
+    update(conditions, data, isReturn, isSet) {
+        return this.exec({ method: types.Method.Update, conditions, data, isReturn, isSet });
+    }
+    // 查
+    find(conditions) {
+        return this.exec({ method: types.Method.Find, conditions });
+    }
+    // 查列表
+    findList(conditions) {
+        return this.exec({ method: types.Method.FindList, conditions });
+    }
+    // 查
+    count(conditions) {
+        return this.exec({ method: types.Method.Count, conditions });
+    }
+}
+
+exports.Collection = Collection;

package/dist/cjs/rd/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/cjs/rd/database/Database.js

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

package/dist/cjs/rd/database/index.d.ts

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

package/dist/cjs/rd/database/types.d.ts

@@ -0,0 +1,151 @@
+import { Database, ICountRes } from '@cloudbase/node-sdk';
+export interface Config {
+    env: string;
+    secretId: string;
+    secretKey: string;
+}
+export type IdConditions = {
+    _id: string;
+    field?: string[] | {
+        [key: string]: false;
+    };
+    options?: {
+        timeout: number;
+        multiple?: false;
+    };
+};
+export declare enum Command {
+    Eq = "eq",
+    Neq = "neq",
+    Lt = "lt",
+    Lte = "lte",
+    Gt = "gt",
+    Gte = "gte",
+    In = "in",
+    Nin = "nin",
+    Gtlt = "gtlt"
+}
+export type CommandWhere = {
+    type: Command.Eq;
+    value: any;
+} | {
+    type: Command.Neq;
+    value: any;
+} | {
+    type: Command.Gt;
+    value: number;
+} | {
+    type: Command.Gte;
+    value: number;
+} | {
+    type: Command.Lt;
+    value: number;
+} | {
+    type: Command.Lte;
+    value: number;
+} | {
+    type: Command.Gtlt;
+    value: number[];
+} | {
+    type: Command.In;
+    value: any[];
+} | {
+    type: Command.Nin;
+    value: any[];
+};
+export type WhereConditions = {
+    where?: {
+        [key: string]: any | CommandWhere;
+    };
+    field?: string[] | {
+        [key: string]: false;
+    };
+    page?: {
+        size?: number;
+        current?: number;
+    };
+    order?: {
+        field: string;
+        type?: 'asc' | 'desc';
+    };
+    options?: {
+        timeout?: number;
+        multiple?: boolean;
+    };
+};
+export type Conditions = IdConditions | WhereConditions;
+export declare enum Method {
+    Add = "add",
+    Find = "find",
+    FindList = "findList",
+    Delete = "delete",
+    Update = "update",
+    Count = "count"
+}
+export declare namespace Add {
+    type Params<D> = {
+        method: Method.Add;
+        data: D;
+        conditions?: Pick<IdConditions, 'field'>;
+        isReturn?: true;
+    };
+    type Res = {
+        id: string;
+    };
+}
+export declare namespace Find {
+    type Params = {
+        method: Method.Find;
+        conditions?: Conditions;
+    };
+    type Res<D> = Record<D> | undefined;
+}
+export declare namespace FindList {
+    type Params = {
+        method: Method.FindList;
+        conditions?: WhereConditions;
+    };
+    type Res<D> = {
+        list?: Record<D>[];
+        total?: number;
+    };
+}
+export declare namespace Delete {
+    type Params = {
+        method: Method.Delete;
+        conditions: Conditions;
+    };
+    type Res = {
+        deleted: number | string;
+    };
+}
+export declare namespace Update {
+    type Params<D> = {
+        method: Method.Update;
+        conditions: Conditions;
+        data: Partial<Record<D>>;
+        isReturn?: true;
+        isSet?: true;
+    };
+    type Res<D> = {
+        updated?: number;
+        doc?: D;
+    };
+}
+export declare namespace Count {
+    type Params = {
+        method: Method.Count;
+        conditions?: WhereConditions;
+    };
+    type Res = {
+        total?: number;
+    };
+}
+export type MethodParams<D> = Add.Params<D> | Find.Params | FindList.Params | Delete.Params | Update.Params<D> | Count.Params;
+export type MethodRes<D> = Add.Res | Find.Res<D> | FindList.Res<D> | Delete.Res | Update.Res<D> | Count.Res;
+export type IRes = Database.IAddRes | Database.IGetRes | Database.IDeleteResult | Database.IUpdateResult | ICountRes;
+export type Record<D> = D & {
+    _id: string;
+    createAt: number;
+    updateAt: number;
+};