ph-utils 0.17.2 → 0.19.0

package/lib/src/file.js

@@ -0,0 +1,54 @@
+/** nodejs 文件操作工具类 */
+import path from "node:path";
+import fs from "node:fs/promises";
+/**
+ * 读取文件内容
+ * @example <caption>1. 读取JSON文件, 内容为字符串列表</caption>
+ * read<string[]>('a.json', []);
+ * @example <caption>2. 读取JSON文件, 内容为对象</caption>
+ * read<{ name: string }>('b.json', {});
+ * @param filepath     文件路径
+ * @param defaultValue 文件不存在时默认值, 不传则抛异常, 如果传递的是对象形式则会将结果转换为 JSON
+ * @returns 文件内容
+ */
+export async function read(filepath, defaultValue) {
+    let content;
+    try {
+        content = await fs.readFile(filepath, "utf8");
+        if (defaultValue != null && typeof defaultValue === "object") {
+            return JSON.parse(content);
+        }
+        return content;
+    }
+    catch (error) {
+        if (defaultValue === undefined) {
+            throw error;
+        }
+        return defaultValue;
+    }
+}
+/**
+ * 写入 JSON 格式的数据到文件
+ * @param file 待写入的文件
+ * @param data 待写入的数据
+ * @param opts 写入配置
+ * @property opts.json 是否写入 JSON 格式的数据，写入数据时对数据进行 JSON 格式化，默认为：true
+ * @property opts.format 是否在写入 json 数据时，将 JSON 数据格式化2个空格写入, 默认为 true
+ */
+export async function write(file, data, opts) {
+    let writeData = data.toString();
+    opts = { json: true, format: true, ...opts };
+    if (opts.json === true && typeof data === "object") {
+        writeData = JSON.stringify(data, null, opts.format === true ? 2 : 0);
+    }
+    await fs.writeFile(path.resolve(file), writeData);
+}
+/**
+ * 根据文件的 stat 获取文件的 etag
+ * @param filePath 文件地址
+ * @returns file stat etag
+ */
+export async function statTag(filePath) {
+    let stat = await fs.stat(filePath);
+    return `${stat.size.toString(16)}-${stat.mtimeMs.toString(16)}`;
+}

package/lib/src/id.d.ts

@@ -0,0 +1,68 @@
+type SnowflakeIDInfo = {
+    value: string;
+    timeOffset: bigint;
+    timestamp: number;
+    machineId: bigint;
+    sequence: bigint;
+    epoch: number;
+    version: string | undefined;
+};
+/** 雪花ID, 推荐在全局构造一个对象用于生成id */
+export declare class SnowflakeID {
+    /** 机器码, 默认为: 1 */
+    machineId: bigint;
+    /** 起始时间戳, 默认为：1288834974657 */
+    epoch: bigint;
+    _lastTimestamp: bigint;
+    /** 版本号, 默认为: 0 */
+    version: number;
+    private _sequence;
+    /**
+     * 构造函数
+     *
+     * @param machineId 机器标识，默认为1
+     * @param epoch 时间戳起始值，默认为1288834974657
+     */
+    constructor(machineId?: number, epoch?: number);
+    private _getTimestamp;
+    private _waitNextMillis;
+    /**
+     * 生成雪花ID
+     *
+     * @returns 返回生成的唯一ID字符串
+     * @throws 如果时钟回退，抛出错误
+     */
+    generate(): string;
+    parse(snowflakeID: string, epoch?: number, includeVersion?: boolean): SnowflakeIDInfo;
+}
+/** 将uuid转换为更简单的唯一标记id */
+export declare class ShortUUID {
+    private alphabet;
+    /**
+     * 构造函数，用于初始化字母表
+     * @param {string} [alphabet] - 可选参数，用于指定自定义字母表
+     * 如果提供了alphabet参数，则将其设置为实例的字母表属性
+     * 如果未提供alphabet参数，则使用默认值
+     */
+    constructor(alphabet?: string);
+    /**
+     * 将UUID字符串进行编码处理
+     * @param uuid - 需要编码的UUID字符串
+     * @returns 编码后的字符串
+     */
+    encode(uuid: string, alphabet?: string): string;
+    /**
+     * 解码短UUID字符串，将其转换为UUID整数和十六进制格式
+     * @param shortUUID - 需要解码的短UUID字符串
+     * @returns 返回包含UUID整数和十六进制格式的对象
+     */
+    decode(shortUUID: string, alphabet?: string): {
+        uuidInt: bigint;
+        uuid: string;
+    };
+    private _stringToInt;
+    private _intToString;
+    private _uuidHexToInt;
+    private _uuidIntToHex;
+}
+export {};

package/lib/src/id.js

@@ -0,0 +1,170 @@
+/** 雪花ID, 推荐在全局构造一个对象用于生成id */
+export class SnowflakeID {
+    /**
+     * 构造函数
+     *
+     * @param machineId 机器标识，默认为1
+     * @param epoch 时间戳起始值，默认为1288834974657
+     */
+    constructor(machineId = 1, epoch = 1288834974657) {
+        /** 版本号, 默认为: 0 */
+        this.version = 0;
+        this.machineId = BigInt(machineId);
+        this.epoch = BigInt(epoch);
+        this._lastTimestamp = BigInt(0);
+        this._sequence = BigInt(0);
+    }
+    _getTimestamp() {
+        return BigInt(Date.now());
+    }
+    _waitNextMillis(cTimestamp) {
+        let timestamp = cTimestamp;
+        while (timestamp <= this._lastTimestamp) {
+            timestamp = BigInt(Date.now());
+        }
+        return timestamp;
+    }
+    /**
+     * 生成雪花ID
+     *
+     * @returns 返回生成的唯一ID字符串
+     * @throws 如果时钟回退，抛出错误
+     */
+    generate() {
+        let cTimestamp = this._getTimestamp();
+        if (cTimestamp < this._lastTimestamp) {
+            throw new Error("Clock moved backwards");
+        }
+        if (cTimestamp === this._lastTimestamp) {
+            // TODO: increment sequence
+            // 雪花id，末尾: 12位序列号(二进制12个1等于16进制4095)，最多4096个(从0到4095)
+            this._sequence = (this._sequence + 1n) & BigInt("0xFFF");
+            if (this._sequence === 0n) {
+                // 同一时间戳，序列号溢出，等待下一毫秒
+                cTimestamp = this._waitNextMillis(cTimestamp);
+            }
+        }
+        else {
+            this._sequence = BigInt(0);
+        }
+        this._lastTimestamp = cTimestamp;
+        const timeDiff = cTimestamp - this.epoch;
+        let id = (timeDiff << BigInt(22)) |
+            (this.machineId << BigInt(12)) |
+            this._sequence;
+        let idstr = id.toString().padStart(19, "0");
+        return `${this.version}${idstr}`;
+    }
+    parse(snowflakeID, epoch, includeVersion = true) {
+        let version = undefined;
+        if (includeVersion) {
+            snowflakeID = snowflakeID.substring(1);
+            version = snowflakeID.substring(0, 1);
+        }
+        let epochTime = epoch || Number(this.epoch);
+        const id = BigInt(snowflakeID);
+        // 1FFFFFFFFFF 就是二进制的41个1, 雪花id前面41为为时间戳，间隔部分
+        let timeDiff = (id >> BigInt(22)) & BigInt("0x1FFFFFFFFFF");
+        const flowTime = Number(timeDiff) + epochTime;
+        // 雪花id中间10位为机器标识, 0x3FF(二进制10个1) 进行位运算
+        const machineId = (id >> BigInt(12)) & BigInt("0x3FF");
+        const sequence = id & BigInt("0xFFF");
+        return {
+            value: snowflakeID,
+            timeOffset: timeDiff,
+            timestamp: flowTime,
+            machineId: machineId,
+            sequence: sequence,
+            epoch: epochTime,
+            version: version,
+        };
+    }
+}
+/** 将uuid转换为更简单的唯一标记id */
+export class ShortUUID {
+    /**
+     * 构造函数，用于初始化字母表
+     * @param {string} [alphabet] - 可选参数，用于指定自定义字母表
+     * 如果提供了alphabet参数，则将其设置为实例的字母表属性
+     * 如果未提供alphabet参数，则使用默认值
+     */
+    constructor(alphabet) {
+        this.alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+        if (alphabet) {
+            this.alphabet = alphabet;
+        }
+    }
+    /**
+     * 将UUID字符串进行编码处理
+     * @param uuid - 需要编码的UUID字符串
+     * @returns 编码后的字符串
+     */
+    encode(uuid, alphabet) {
+        // 将UUID字符串转换为整数
+        const uuidInt = this._uuidHexToInt(uuid);
+        // 将整数转换为特定格式的字符串
+        return this._intToString(uuidInt, alphabet);
+    }
+    /**
+     * 解码短UUID字符串，将其转换为UUID整数和十六进制格式
+     * @param shortUUID - 需要解码的短UUID字符串
+     * @returns 返回包含UUID整数和十六进制格式的对象
+     */
+    decode(shortUUID, alphabet) {
+        const uuidInt = this._stringToInt(shortUUID, alphabet);
+        return {
+            uuidInt: uuidInt,
+            uuid: this._uuidIntToHex(uuidInt),
+        };
+    }
+    _stringToInt(str, alphabet) {
+        if (!alphabet)
+            alphabet = this.alphabet;
+        const alphabetlen = BigInt(alphabet.length);
+        let result = BigInt(0);
+        let multiplier = BigInt(1);
+        const strlen = str.length;
+        for (let i = strlen - 1; i >= 0; i--) {
+            const char = str[i];
+            const index = alphabet.indexOf(char);
+            if (index === -1) {
+                throw new Error(`Character "${char}" not found in alphabet`);
+            }
+            result += BigInt(index) * multiplier;
+            multiplier *= alphabetlen;
+        }
+        return result;
+    }
+    _intToString(uuidInt, alphabet) {
+        if (!alphabet)
+            alphabet = this.alphabet;
+        const alphabetlen = BigInt(alphabet.length);
+        let num = uuidInt;
+        const result = [];
+        // uuidInt = d₀ × 1(base的0次方) + d₁ × base + d₂ × base²...
+        while (num) {
+            const index = Number(num % alphabetlen);
+            num = num / alphabetlen;
+            result.push(alphabet.charAt(index));
+        }
+        // 倒序，保证高位在前
+        return result.reverse().join("");
+    }
+    _uuidHexToInt(uuid) {
+        const uuidHex = uuid.replaceAll("-", "");
+        return BigInt(`0x${uuidHex}`);
+    }
+    _uuidIntToHex(uuidInt) {
+        const uuidHexStr = uuidInt.toString(16);
+        if (!/^[0-9a-fA-F]{32}$/.test(uuidHexStr)) {
+            throw new Error("Invalid UUID string (must be 32 hex characters)");
+        }
+        return [
+            uuidHexStr.slice(0, 8),
+            uuidHexStr.slice(8, 12),
+            uuidHexStr.slice(12, 16),
+            uuidHexStr.slice(16, 20),
+            uuidHexStr.slice(20),
+        ].join("-");
+    }
+}

package/lib/src/index.d.ts

@@ -0,0 +1,154 @@
+/**
+ * 验证参数是否为空
+ * @param str               待验证的参数
+ * @param ignoreWhitespace  如果是字符串是否忽略空格(包括空白字符串以及[\r\t\n]之类的制表符)，默认为true
+ */
+export declare function isBlank(str?: any, ignoreWhitespace?: boolean): boolean;
+/**
+ * 屏蔽手机号，中间部分用 * 展示
+ * @param mobile 待屏蔽的手机号
+ * @returns 屏蔽后的手机号，例如：123 **** 1234
+ */
+export declare function shieldMobile(mobile: string): string;
+/**
+ * 验证参数是否是数字
+ * @param str 待验证的字符串
+ * @param numericParam 通过参数标记是否包含小数、正数
+ * @param numericParam.isPositive 是否是正数, 默认: false
+ * @param numericParam.isFloat 是否是小数, 默认: true
+ * @returns true 是数字, false 不是数字
+ */
+export declare function isNumeric(str: string, numericParam?: {
+    isPositive?: boolean;
+    isFloat?: boolean;
+}): boolean;
+/**
+ * 验证参数是否是Boolean 类型
+ * @param str 待验证的字符串
+ * @returns
+ */
+export declare function isBoolean(str: string): boolean;
+/** 生成随机数的选项 */
+interface RandomStringOption {
+    /** 生成指定长度的随机字符串 */
+    length: number;
+    /** 是否包含英文字母, 默认为: true */
+    hasLetter?: boolean;
+    /** 生成纯数字的随机数时, 首位是否允许为 0, 默认为: true */
+    firstIsZero?: boolean;
+}
+interface RangeRandomOption {
+    /** 配合 max 生成 [min~max] 之间的随机数 */
+    min: number;
+    /** 配合 min 生成 [min~max] 之间的随机数 */
+    max: number;
+    /** 生成的随机数，是否包含 max, 默认: false */
+    hasEnd?: boolean;
+    /** 生成的随机数是否是整数, 默认: true */
+    isInteger?: boolean;
+}
+/**
+ * 生成指定长度的随机数
+ *
+ * @param len - 生成的随机数长度
+ *
+ * @example <caption>1. 生成指定长度的随机字符串</caption>
+ * random(1); // 长度为 1 的随机字符串
+ */
+export declare function random(len: number): string;
+/**
+ * 生成介于 [min, max] 之间的随机数
+ *
+ * @param option 配置项
+ * @param option.min 生成介于 [min, max] 之间的随机数
+ * @param option.max 生成介于 [min, max] 之间的随机数
+ * @param option.hasEnd 生成的随机数，是否包含 max, 默认: false
+ * @param option.isInteger 生成的随机数是否是整数, 默认: true
+ */
+export declare function random(option: RangeRandomOption): number;
+/**
+ * 生成指定长度随机数
+ *
+ * @param option 配置项
+ * @param option.length 生成的随机数长度
+ * @param option.hasLetter 是否包含英文字母, 默认为: true
+ * @param option.firstIsZero 生成纯数字的随机数时, 首位是否允许为 0, 默认为: true
+ *
+ * @example <caption>2. 生成纯数字且首位不能为0长度为1的随机字符</caption>
+ * random({ length: 1, hasLetter: false, firstIsZero: false })
+ */
+export declare function random(option: RandomStringOption): string;
+/**
+ * 带有错误名称标记的错误类型
+ */
+export declare class BaseError extends Error {
+    /**
+     * 错误名称，类似于 Java 中的不同的 Exception[NullPointerException]；
+     * 增加 name 字段，表明不同的错误，当需要根据不同的错误执行不同的处理的时候，会很有用
+     */
+    name: string;
+    /**
+     * 构造一个 name = BaseError 的错误信息
+     * @param message 错误描述
+     */
+    constructor(message: string);
+    /**
+     *
+     * @param name 错误名称
+     * @param message 错误描述
+     */
+    constructor(name: string, message: string);
+}
+/**
+ * 将金额数字格式化为金额格式显示并且会保留两位小数[去除多余的位数，不是四舍五入，而是直接舍去]  1234523432.23 => 123,123,123.23
+ * @param {number} number 待转换的金额数字
+ * @return string
+ */
+export declare function formatMoney(number: number): string;
+/**
+ * 将风格由大写风格转换为下划线风格: HelloWorld -> hello-world
+ * @param name 命名, 例如: HelloWorld
+ * @param connector 连接符, 默认为: _
+ */
+export declare function snakeCaseStyle(name: string, connector?: string): string;
+/**
+ * 对数字进行四舍五入处理
+ * @param num 需要进行四舍五入的数字
+ * @param precision 精度，默认为2，即保留小数点后两位
+ * @param roundType 舍入类型，默认为0，提供三种取值:
+ *        0: 标准四舍五入
+ *        1: 向上取整
+ *        2: 向下取整
+ * @returns 返回经过指定方式舍入后的数字
+ */
+export declare function round(num: number, precision?: number, roundType?: 0 | 1 | 2): number;
+/**
+ * 反转字符串
+ */
+export declare function reverseStr(str: string): string;
+/** 数据格式化配置 */
+interface FormDataConfig<T> {
+    /** 配置需要转换为数字的字段 */
+    numberFields?: (keyof T)[];
+    /** 配置需要转换为字符串的字段 */
+    stringFields?: (keyof T)[];
+    /** 自定义的格式化 */
+    formatter?: {
+        [K in keyof T]?: "number" | "string" | ((value: any) => number | string);
+    };
+}
+/**
+ * 嵌套的 json 指定 key 数据
+ * @param data JSON格式数据
+ * @param keys 待获取的数据 key, 可以通过 [.] 获取嵌套数据, 例如: a.b.c
+ * @returns
+ */
+export declare function getJSONValue(data: Record<string, any>, keystr: string): Record<string, any> | null;
+/**
+ * 数据格式化主要用于数据类型转换
+ * @param data 待转换数据类型的数据
+ * @param config 转换配置
+ * @returns
+ */
+export declare function formatData<T extends Record<string, any>>(data: T, config?: FormDataConfig<T>): T;
+export {};

package/lib/src/index.js

@@ -0,0 +1,239 @@
+/**
+ * node 和 web 通用的工具类
+ */
+/** 包含字母+数字的随机数字符 */
+const RANDOM_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+/** 只包含字母的随机数字符 */
+const NUMBER_RANDOM_CHARTS = "0123456789";
+/**
+ * 验证参数是否为空
+ * @param str               待验证的参数
+ * @param ignoreWhitespace  如果是字符串是否忽略空格(包括空白字符串以及[\r\t\n]之类的制表符)，默认为true
+ */
+export function isBlank(str, ignoreWhitespace = true) {
+    if (str == null) {
+        return true;
+    }
+    return ((ignoreWhitespace && typeof str === "string"
+        ? str.trim().length
+        : str.length) === 0);
+}
+/**
+ * 屏蔽手机号，中间部分用 * 展示
+ * @param mobile 待屏蔽的手机号
+ * @returns 屏蔽后的手机号，例如：123 **** 1234
+ */
+export function shieldMobile(mobile) {
+    const x1 = Math.floor(mobile.length / 2);
+    const x2 = Math.ceil(x1 / 2);
+    const shields = [" "];
+    for (let i = 0; i < x1 - 1; i++) {
+        shields.push("*");
+    }
+    shields.push(" ");
+    return (mobile.substring(0, x2) + shields.join("") + mobile.substring(x2 + x1 - 1));
+}
+/**
+ * 验证参数是否是数字
+ * @param str 待验证的字符串
+ * @param numericParam 通过参数标记是否包含小数、正数
+ * @param numericParam.isPositive 是否是正数, 默认: false
+ * @param numericParam.isFloat 是否是小数, 默认: true
+ * @returns true 是数字, false 不是数字
+ */
+export function isNumeric(str, numericParam) {
+    numericParam = { isPositive: false, isFloat: true, ...numericParam };
+    const symbol = numericParam.isPositive ? "[+]?" : "[+-]?";
+    const main = numericParam.isFloat ? "([0-9]*[.])?[0-9]+" : "[0-9]+";
+    return new RegExp("^" + symbol + main + "$").test(str);
+}
+/**
+ * 验证参数是否是Boolean 类型
+ * @param str 待验证的字符串
+ * @returns
+ */
+export function isBoolean(str) {
+    return ["true", "false"].indexOf(str) >= 0;
+}
+export function random(opts) {
+    if (typeof opts === "object" && opts.min != null && opts.max != null) {
+        const randomNum = Math.random();
+        /* 生成两个数字之间的随机数(number) */
+        const end = opts.hasEnd ? 1 : 0;
+        const resRandom = randomNum * (opts.max - opts.min + end) + opts.min;
+        return opts.isInteger !== false ? Math.floor(resRandom) : resRandom;
+    }
+    else {
+        if (typeof opts === "object" && opts.length == null) {
+            throw new Error("random_length_cannot_null");
+        }
+        let len = typeof opts === "object" ? opts.length : opts;
+        /* 生成指定长度的随机数 */
+        let chars = RANDOM_CHARS;
+        if (typeof opts === "object" && opts.hasLetter === false) {
+            chars = NUMBER_RANDOM_CHARTS;
+        }
+        const resRandom = Array.from({ length: len }, () => chars.charAt(random({ min: 0, max: chars.length - 1, hasEnd: true }))).join("");
+        if (typeof opts === "object" &&
+            opts.firstIsZero === false &&
+            resRandom.indexOf("0") === 0) {
+            return random(opts);
+        }
+        else {
+            return resRandom;
+        }
+    }
+}
+/**
+ * 带有错误名称标记的错误类型
+ */
+export class BaseError extends Error {
+    constructor() {
+        if (arguments.length === 1) {
+            super(arguments[0]);
+            this.name = "BaseError";
+        }
+        else {
+            super(arguments[1]);
+            this.name = arguments[0];
+        }
+    }
+}
+/**
+ * 将金额数字格式化为金额格式显示并且会保留两位小数[去除多余的位数，不是四舍五入，而是直接舍去]  1234523432.23 => 123,123,123.23
+ * @param {number} number 待转换的金额数字
+ * @return string
+ */
+export function formatMoney(number) {
+    if (typeof Intl.NumberFormat !== "undefined") {
+        const formatter = new Intl.NumberFormat("zh-CN", {
+            style: "decimal",
+            maximumFractionDigits: 2,
+        });
+        return formatter.format(number);
+    }
+    else {
+        number = number || 0;
+        const negative = "";
+        const base = String(parseInt(number, 10)); // 获取数字整数部分
+        const mod = base.length > 3 ? base.length % 3 : 0;
+        /*
+         * 利用 正则前瞻 (?=) 将3位数字后面还紧跟一位数字的三位数字替换为 数字, 的形式
+         */
+        const numberStr = String(number);
+        const usePrecision = numberStr.indexOf(".");
+        let dotStr = usePrecision > 0 ? numberStr.slice(usePrecision + 1) : "00";
+        dotStr = dotStr.length > 2 ? dotStr.slice(0, 2) : dotStr;
+        return (negative +
+            (mod ? base.slice(0, mod) + "," : "") +
+            base.slice(mod).replace(/(\d{3})(?=\d)/g, "$1,") +
+            "." +
+            dotStr);
+    }
+}
+/**
+ * 将风格由大写风格转换为下划线风格: HelloWorld -> hello-world
+ * @param name 命名, 例如: HelloWorld
+ * @param connector 连接符, 默认为: _
+ */
+export function snakeCaseStyle(name, connector = "-") {
+    return name.replace(/([A-Z])/g, (match, p1, offset) => (offset > 0 ? connector : "") + match.toLowerCase());
+}
+/**
+ * 对数字进行四舍五入处理
+ * @param num 需要进行四舍五入的数字
+ * @param precision 精度，默认为2，即保留小数点后两位
+ * @param roundType 舍入类型，默认为0，提供三种取值:
+ *        0: 标准四舍五入
+ *        1: 向上取整
+ *        2: 向下取整
+ * @returns 返回经过指定方式舍入后的数字
+ */
+export function round(num, precision = 2, roundType = 0) {
+    // 计算精度因子，用于后续四舍五入计算
+    const factor = Math.pow(10, precision);
+    switch (roundType) {
+        case 0:
+            // 标准四舍五入
+            return Math.round(num * factor) / factor;
+        case 1:
+            // 向上取整
+            return Math.ceil(num * factor) / factor;
+        case 2:
+            // 向下取整
+            return Math.floor(num * factor) / factor;
+        default:
+            // 如果传入的roundType不是预期的值，则直接返回原始数字
+            return num;
+    }
+}
+/**
+ * 反转字符串
+ */
+export function reverseStr(str) {
+    return str.split("").reverse().join("");
+}
+function getObjKeyValue(data, key) {
+    if (data == null)
+        return null;
+    return data[key];
+}
+/**
+ * 嵌套的 json 指定 key 数据
+ * @param data JSON格式数据
+ * @param keys 待获取的数据 key, 可以通过 [.] 获取嵌套数据, 例如: a.b.c
+ * @returns
+ */
+export function getJSONValue(data, keystr) {
+    if (data == null)
+        return null;
+    const keys = keystr.split(".");
+    let res = data;
+    for (const key of keys) {
+        res = getObjKeyValue(res, key);
+        if (res == null)
+            break;
+    }
+    return res;
+}
+/**
+ * 数据格式化主要用于数据类型转换
+ * @param data 待转换数据类型的数据
+ * @param config 转换配置
+ * @returns
+ */
+export function formatData(data, config) {
+    const cfg = {
+        numberFields: [],
+        stringFields: [],
+        formatter: {},
+        ...config,
+    };
+    const res = {};
+    for (const key in data) {
+        let value = getJSONValue(data, key);
+        let formater;
+        if (key in cfg.formatter) {
+            formater = cfg.formatter[key];
+        }
+        if (cfg.numberFields.includes(key)) {
+            formater = "number";
+        }
+        if (cfg.stringFields.includes(key)) {
+            formater = "string";
+        }
+        if (formater != null) {
+            if (typeof formater == "function") {
+                value = formater(value);
+            }
+            else if (formater == "number") {
+                value = Number(value);
+            }
+            else if (formater == "string") {
+                value = String(value);
+            }
+        }
+        res[key] = value;
+    }
+    return res;
+}