typea/main/types.js

JS 数据结构验证、转换器

import { Type, Struct, TypeBind } from './createType.js';
export const string = Type("string", {
    // 验证 string 类型
    type(data) {
        if (typeof data === 'string') {
            return { data };
        }
        else {
            return { error: "值必须为 string 类型" };
        }
    },
    // 限制最小长度
    min(data, min) {
        if (data.length < min) {
            return { error: `值长度不能小于 "${min}" 个字符` };
        }
        else {
            return { data };
        }
    },
    // 限制最大长度
    max(data, max) {
        if (data.length > max) {
            return { error: `值长度不能大于 "${max}" 个字符` };
        }
        else {
            return { data };
        }
    },
    // 正则
    reg(data, reg) {
        if (data.search(reg) === -1) {
            return { error: '正则表达式格式错误' };
        }
        else {
            return { data };
        }
    },
    // 包含
    in(data, array) {
        const result = array.indexOf(data);
        if (result === -1) {
            return { error: `值必须为 [${array}] 选项其中之一` };
        }
        else {
            return { data };
        }
    }
});
TypeBind(String, string);
export const number = Type("number", {
    type(data) {
        if (typeof data === 'number') {
            return { data };
        }
        else {
            return { error: '值必须为 number 类型' };
        }
    },
    min(data, min) {
        if (data < min) {
            return { error: `值不能小于 "${min}"` };
        }
        else {
            return { data };
        }
    },
    max(data, max) {
        if (data > max) {
            return { error: `值不能大于 "${max}"` };
        }
        else {
            return { data };
        }
    },
    // 匹配多个可选值中的一个
    in(data, array) {
        const result = array.indexOf(data);
        if (result === -1) {
            return { error: `值必须为 "${array}" 中的一个` };
        }
        else {
            return { data };
        }
    }
});
TypeBind(Number, number);
export const boolean = Type("boolean", {
    type(data) {
        if (typeof data === 'boolean') {
            return { data };
        }
        else {
            return { error: '值必须为 boolean 类型' };
        }
    }
});
TypeBind(Boolean, boolean);
export const symbol = Type("symbol", {
    type(data) {
        if (typeof data === 'symbol') {
            return { data };
        }
        else {
            return { error: '值必须为 symbol 类型' };
        }
    }
});
TypeBind(Symbol, symbol);
export const func = Type("func", {
    type(data) {
        if (typeof data === 'function') {
            return { data };
        }
        else {
            return { error: '值必须为 function 类型' };
        }
    }
});
TypeBind(Function, func);
export const any = Type("any", {
    type(data) { return { data }; }
});
// 结构体数组
export const array = Struct("array", {
    type(data) {
        if (Array.isArray(data)) {
            return { data };
        }
        else {
            return { error: '值必须为 array 类型' };
        }
    },
    min(data, min) {
        if (data.length < min) {
            return { error: `值长度不能小于 "${min}" 个字符` };
        }
        else {
            return { data };
        }
    },
    max(data, max) {
        if (data.length > max) {
            return { error: `值长度不能大于 "${max} "个字符` };
        }
        else {
            return { data };
        }
    }
});
TypeBind(Array, array);
export const { toString } = Object.prototype;
// 结构体对象
export const object = Struct("object", {
    type(data) {
        if (toString.call(data) === '[object Object]') {
            return { data };
        }
        else {
            return { error: "值必须为 object 类型" };
        }
    }
});
TypeBind(Object, object);
const types = {
    string,
    number,
    boolean,
    symbol,
    func,
    any,
    array,
    object
};
export default types;