ddan-js 1.2.2 → 1.2.4

package/bin/lib/modules/rule/async-validator/rule/enum.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("../util");
+const ENUM = 'enum';
+const enumerable = (rule, value, source, errors, options) => {
+    rule[ENUM] = Array.isArray(rule[ENUM]) ? rule[ENUM] : [];
+    if (rule[ENUM].indexOf(value) === -1) {
+        errors.push(
+        //@ts-ignore
+        (0, util_1.format)(options.messages[ENUM], rule.fullField, rule[ENUM].join(', ')));
+    }
+};
+exports.default = enumerable;

package/bin/lib/modules/rule/async-validator/rule/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const required_1 = require("./required");
+const whitespace_1 = require("./whitespace");
+const type_1 = require("./type");
+const range_1 = require("./range");
+const enum_1 = require("./enum");
+const pattern_1 = require("./pattern");
+exports.default = {
+    required: required_1.default,
+    whitespace: whitespace_1.default,
+    type: type_1.default,
+    range: range_1.default,
+    enum: enum_1.default,
+    pattern: pattern_1.default,
+};

package/bin/lib/modules/rule/async-validator/rule/pattern.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("../util");
+const pattern = (rule, value, source, errors, options) => {
+    if (rule.pattern) {
+        if (rule.pattern instanceof RegExp) {
+            // if a RegExp instance is passed, reset `lastIndex` in case its `global`
+            // flag is accidentally set to `true`, which in a validation scenario
+            // is not necessary and the result might be misleading
+            rule.pattern.lastIndex = 0;
+            if (!rule.pattern.test(value)) {
+                errors.push((0, util_1.format)(
+                //@ts-ignore
+                options.messages.pattern.mismatch, rule.fullField, value, rule.pattern));
+            }
+        }
+        else if (typeof rule.pattern === 'string') {
+            const _pattern = new RegExp(rule.pattern);
+            if (!_pattern.test(value)) {
+                errors.push((0, util_1.format)(
+                //@ts-ignore
+                options.messages.pattern.mismatch, rule.fullField, value, rule.pattern));
+            }
+        }
+    }
+};
+exports.default = pattern;

package/bin/lib/modules/rule/async-validator/rule/range.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("../util");
+const range = (rule, value, source, errors, options) => {
+    const len = typeof rule.len === 'number';
+    const min = typeof rule.min === 'number';
+    const max = typeof rule.max === 'number';
+    // 正则匹配码点范围从U+010000一直到U+10FFFF的文字（补充平面Supplementary Plane）
+    const spRegexp = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
+    let val = value;
+    let key = "";
+    const num = typeof value === 'number';
+    const str = typeof value === 'string';
+    const arr = Array.isArray(value);
+    if (num) {
+        key = 'number';
+    }
+    else if (str) {
+        key = 'string';
+    }
+    else if (arr) {
+        key = 'array';
+    }
+    // if the value is not of a supported type for range validation
+    // the validation rule rule should use the
+    // type property to also test for a particular type
+    if (!key) {
+        return false;
+    }
+    if (arr) {
+        val = value.length;
+    }
+    if (str) {
+        // 处理码点大于U+010000的文字length属性不准确的bug，如"𠮷𠮷𠮷".length !== 3
+        val = value.replace(spRegexp, '_').length;
+    }
+    if (len) {
+        if (val !== rule.len) {
+            //@ts-ignore
+            errors.push((0, util_1.format)(options.messages[key].len, rule.fullField, rule.len));
+        }
+        //@ts-ignore
+    }
+    else if (min && !max && val < rule.min) {
+        errors.push((0, util_1.format)(options.messages[key].min, rule.fullField, rule.min));
+    }
+    else if (max && !min && val > rule.max) {
+        errors.push((0, util_1.format)(options.messages[key].max, rule.fullField, rule.max));
+    }
+    else if (min && max && (val < rule.min || val > rule.max)) {
+        errors.push((0, util_1.format)(options.messages[key].range, rule.fullField, rule.min, rule.max));
+    }
+};
+exports.default = range;

package/bin/lib/modules/rule/async-validator/rule/required.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("../util");
+const required = (rule, value, source, errors, options, type) => {
+    if (rule.required &&
+        (!source.hasOwnProperty(rule.field || "") ||
+            (0, util_1.isEmptyValue)(value, type || rule.type))) {
+        //@ts-ignore
+        errors.push((0, util_1.format)(options.messages.required, rule.fullField));
+    }
+};
+exports.default = required;

package/bin/lib/modules/rule/async-validator/rule/type.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("../util");
+const required_1 = require("./required");
+const url_1 = require("./url");
+/* eslint max-len:0 */
+const pattern = {
+    // http://emailregex.com/
+    email: /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+\.)+[a-zA-Z\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]{2,}))$/,
+    // url: new RegExp(
+    //   '^(?!mailto:)(?:(?:http|https|ftp)://|//)(?:\\S+(?::\\S*)?@)?(?:(?:(?:[1-9]\\d?|1\\d\\d|2[01]\\d|22[0-3])(?:\\.(?:1?\\d{1,2}|2[0-4]\\d|25[0-5])){2}(?:\\.(?:[0-9]\\d?|1\\d\\d|2[0-4]\\d|25[0-4]))|(?:(?:[a-z\\u00a1-\\uffff0-9]+-*)*[a-z\\u00a1-\\uffff0-9]+)(?:\\.(?:[a-z\\u00a1-\\uffff0-9]+-*)*[a-z\\u00a1-\\uffff0-9]+)*(?:\\.(?:[a-z\\u00a1-\\uffff]{2,})))|localhost)(?::\\d{2,5})?(?:(/|\\?|#)[^\\s]*)?$',
+    //   'i',
+    // ),
+    hex: /^#?([a-f0-9]{6}|[a-f0-9]{3})$/i,
+};
+const types = {
+    integer(value) {
+        return types.number(value) && parseInt(value, 10) === value;
+    },
+    float(value) {
+        return types.number(value) && !types.integer(value);
+    },
+    array(value) {
+        return Array.isArray(value);
+    },
+    regexp(value) {
+        if (value instanceof RegExp) {
+            return true;
+        }
+        try {
+            return !!new RegExp(value);
+        }
+        catch (e) {
+            return false;
+        }
+    },
+    date(value) {
+        return (typeof value.getTime === 'function' &&
+            typeof value.getMonth === 'function' &&
+            typeof value.getYear === 'function' &&
+            !isNaN(value.getTime()));
+    },
+    number(value) {
+        if (isNaN(value)) {
+            return false;
+        }
+        return typeof value === 'number';
+    },
+    object(value) {
+        return typeof value === 'object' && !types.array(value);
+    },
+    method(value) {
+        return typeof value === 'function';
+    },
+    email(value) {
+        return (typeof value === 'string' &&
+            value.length <= 320 &&
+            !!value.match(pattern.email));
+    },
+    url(value) {
+        return (typeof value === 'string' &&
+            value.length <= 2048 &&
+            !!value.match((0, url_1.default)()));
+    },
+    hex(value) {
+        return typeof value === 'string' && !!value.match(pattern.hex);
+    },
+};
+const type = (rule, value, source, errors, options) => {
+    if (rule.required && value === undefined) {
+        (0, required_1.default)(rule, value, source, errors, options);
+        return;
+    }
+    const custom = [
+        'integer',
+        'float',
+        'array',
+        'regexp',
+        'object',
+        'method',
+        'email',
+        'number',
+        'date',
+        'url',
+        'hex',
+    ];
+    const ruleType = rule.type;
+    if (custom.indexOf(ruleType) > -1) {
+        if (!types[ruleType](value)) {
+            errors.push((0, util_1.format)(options.messages.types[ruleType], rule.fullField, rule.type));
+        }
+        // straight typeof check
+    }
+    else if (ruleType && typeof value !== rule.type) {
+        errors.push((0, util_1.format)(options.messages.types[ruleType], rule.fullField, rule.type));
+    }
+};
+exports.default = type;

package/bin/lib/modules/rule/async-validator/rule/url.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// https://github.com/kevva/url-regex/blob/master/index.js
+let urlReg;
+exports.default = () => {
+    if (urlReg) {
+        return urlReg;
+    }
+    const word = '[a-fA-F\\d:]';
+    const b = options => options && options.includeBoundaries
+        ? `(?:(?<=\\s|^)(?=${word})|(?<=${word})(?=\\s|$))`
+        : '';
+    const v4 = '(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)){3}';
+    const v6seg = '[a-fA-F\\d]{1,4}';
+    const v6 = `
+(?:
+(?:${v6seg}:){7}(?:${v6seg}|:)|                                    // 1:2:3:4:5:6:7::  1:2:3:4:5:6:7:8
+(?:${v6seg}:){6}(?:${v4}|:${v6seg}|:)|                             // 1:2:3:4:5:6::    1:2:3:4:5:6::8   1:2:3:4:5:6::8  1:2:3:4:5:6::1.2.3.4
+(?:${v6seg}:){5}(?::${v4}|(?::${v6seg}){1,2}|:)|                   // 1:2:3:4:5::      1:2:3:4:5::7:8   1:2:3:4:5::8    1:2:3:4:5::7:1.2.3.4
+(?:${v6seg}:){4}(?:(?::${v6seg}){0,1}:${v4}|(?::${v6seg}){1,3}|:)| // 1:2:3:4::        1:2:3:4::6:7:8   1:2:3:4::8      1:2:3:4::6:7:1.2.3.4
+(?:${v6seg}:){3}(?:(?::${v6seg}){0,2}:${v4}|(?::${v6seg}){1,4}|:)| // 1:2:3::          1:2:3::5:6:7:8   1:2:3::8        1:2:3::5:6:7:1.2.3.4
+(?:${v6seg}:){2}(?:(?::${v6seg}){0,3}:${v4}|(?::${v6seg}){1,5}|:)| // 1:2::            1:2::4:5:6:7:8   1:2::8          1:2::4:5:6:7:1.2.3.4
+(?:${v6seg}:){1}(?:(?::${v6seg}){0,4}:${v4}|(?::${v6seg}){1,6}|:)| // 1::              1::3:4:5:6:7:8   1::8            1::3:4:5:6:7:1.2.3.4
+(?::(?:(?::${v6seg}){0,5}:${v4}|(?::${v6seg}){1,7}|:))             // ::2:3:4:5:6:7:8  ::2:3:4:5:6:7:8  ::8             ::1.2.3.4
+)(?:%[0-9a-zA-Z]{1,})?                                             // %eth0            %1
+`
+        .replace(/\s*\/\/.*$/gm, '')
+        .replace(/\n/g, '')
+        .trim();
+    // Pre-compile only the exact regexes because adding a global flag make regexes stateful
+    const v46Exact = new RegExp(`(?:^${v4}$)|(?:^${v6}$)`);
+    const v4exact = new RegExp(`^${v4}$`);
+    const v6exact = new RegExp(`^${v6}$`);
+    const ip = options => options && options.exact
+        ? v46Exact
+        : new RegExp(`(?:${b(options)}${v4}${b(options)})|(?:${b(options)}${v6}${b(options)})`, 'g');
+    ip.v4 = (options) => options && options.exact
+        ? v4exact
+        : new RegExp(`${b(options)}${v4}${b(options)}`, 'g');
+    ip.v6 = (options) => options && options.exact
+        ? v6exact
+        : new RegExp(`${b(options)}${v6}${b(options)}`, 'g');
+    const protocol = `(?:(?:[a-z]+:)?//)`;
+    const auth = '(?:\\S+(?::\\S*)?@)?';
+    const ipv4 = ip.v4().source;
+    const ipv6 = ip.v6().source;
+    const host = '(?:(?:[a-z\\u00a1-\\uffff0-9][-_]*)*[a-z\\u00a1-\\uffff0-9]+)';
+    const domain = '(?:\\.(?:[a-z\\u00a1-\\uffff0-9]-*)*[a-z\\u00a1-\\uffff0-9]+)*';
+    const tld = `(?:\\.(?:[a-z\\u00a1-\\uffff]{2,}))`;
+    const port = '(?::\\d{2,5})?';
+    const path = '(?:[/?#][^\\s"]*)?';
+    const regex = `(?:${protocol}|www\\.)${auth}(?:localhost|${ipv4}|${ipv6}|${host}${domain}${tld})${port}${path}`;
+    urlReg = new RegExp(`(?:^${regex}$)`, 'i');
+    return urlReg;
+};

package/bin/lib/modules/rule/async-validator/rule/whitespace.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("../util");
+/**
+ *  Rule for validating whitespace.
+ *
+ *  @param rule The validation rule.
+ *  @param value The value of the field on the source object.
+ *  @param source The source object being validated.
+ *  @param errors An array of errors that this rule may add
+ *  validation errors to.
+ *  @param options The validation options.
+ *  @param options.messages The validation messages.
+ */
+const whitespace = (rule, value, source, errors, options) => {
+    if (/^\s+$/.test(value) || value === '') {
+        errors.push((0, util_1.format)(options.messages.whitespace, rule.fullField));
+    }
+};
+exports.default = whitespace;

package/bin/lib/modules/rule/async-validator/util.js

@@ -0,0 +1,250 @@
+"use strict";
+/* eslint no-console:0 */
+//@ts-nocheck
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deepMerge = exports.complementError = exports.asyncMap = exports.AsyncValidationError = exports.isEmptyObject = exports.isEmptyValue = exports.format = exports.convertFieldsError = exports.warning = void 0;
+const formatRegExp = /%[sdj%]/g;
+let warning = () => { };
+exports.warning = warning;
+// don't print warning message when in production env or node runtime
+if (typeof process !== 'undefined' &&
+    process.env &&
+    process.env.NODE_ENV !== 'production' &&
+    typeof window !== 'undefined' &&
+    typeof document !== 'undefined') {
+    exports.warning = (type, errors) => {
+        if (typeof console !== 'undefined' &&
+            console.warn &&
+            typeof ASYNC_VALIDATOR_NO_WARNING === 'undefined') {
+            if (errors.every(e => typeof e === 'string')) {
+                console.warn(type, errors);
+            }
+        }
+    };
+}
+function convertFieldsError(errors) {
+    if (!errors || !errors.length)
+        return null;
+    const fields = {};
+    errors.forEach(error => {
+        const field = error.field;
+        fields[field] = fields[field] || [];
+        fields[field].push(error);
+    });
+    return fields;
+}
+exports.convertFieldsError = convertFieldsError;
+function format(template, ...args) {
+    let i = 0;
+    const len = args.length;
+    if (typeof template === 'function') {
+        return template.apply(null, args);
+    }
+    if (typeof template === 'string') {
+        let str = template.replace(formatRegExp, x => {
+            if (x === '%%') {
+                return '%';
+            }
+            if (i >= len) {
+                return x;
+            }
+            switch (x) {
+                case '%s':
+                    return String(args[i++]);
+                case '%d':
+                    return Number(args[i++]);
+                case '%j':
+                    try {
+                        return JSON.stringify(args[i++]);
+                    }
+                    catch (_) {
+                        return '[Circular]';
+                    }
+                    break;
+                default:
+                    return x;
+            }
+        });
+        return str;
+    }
+    return template;
+}
+exports.format = format;
+function isNativeStringType(type) {
+    return (type === 'string' ||
+        type === 'url' ||
+        type === 'hex' ||
+        type === 'email' ||
+        type === 'date' ||
+        type === 'pattern');
+}
+function isEmptyValue(value, type) {
+    if (value === undefined || value === null) {
+        return true;
+    }
+    if (type === 'array' && Array.isArray(value) && !value.length) {
+        return true;
+    }
+    if (isNativeStringType(type) && typeof value === 'string' && !value) {
+        return true;
+    }
+    return false;
+}
+exports.isEmptyValue = isEmptyValue;
+function isEmptyObject(obj) {
+    return Object.keys(obj).length === 0;
+}
+exports.isEmptyObject = isEmptyObject;
+function asyncParallelArray(arr, func, callback) {
+    const results = [];
+    let total = 0;
+    const arrLength = arr.length;
+    function count(errors) {
+        results.push(...(errors || []));
+        total++;
+        if (total === arrLength) {
+            callback(results);
+        }
+    }
+    arr.forEach(a => {
+        func(a, count);
+    });
+}
+function asyncSerialArray(arr, func, callback) {
+    let index = 0;
+    const arrLength = arr.length;
+    function next(errors) {
+        if (errors && errors.length) {
+            callback(errors);
+            return;
+        }
+        const original = index;
+        index = index + 1;
+        if (original < arrLength) {
+            func(arr[original], next);
+        }
+        else {
+            callback([]);
+        }
+    }
+    next([]);
+}
+function flattenObjArr(objArr) {
+    const ret = [];
+    Object.keys(objArr).forEach(k => {
+        ret.push(...(objArr[k] || []));
+    });
+    return ret;
+}
+class AsyncValidationError extends Error {
+    constructor(errors, fields) {
+        super('Async Validation Error');
+        this.errors = errors;
+        this.fields = fields;
+    }
+}
+exports.AsyncValidationError = AsyncValidationError;
+function asyncMap(objArr, option, func, callback, source) {
+    if (option.first) {
+        const pending = new Promise((resolve, reject) => {
+            const next = (errors) => {
+                callback(errors);
+                return errors.length
+                    ? reject(new AsyncValidationError(errors, convertFieldsError(errors)))
+                    : resolve(source);
+            };
+            const flattenArr = flattenObjArr(objArr);
+            asyncSerialArray(flattenArr, func, next);
+        });
+        pending.catch(e => e);
+        return pending;
+    }
+    const firstFields = option.firstFields === true
+        ? Object.keys(objArr)
+        : option.firstFields || [];
+    const objArrKeys = Object.keys(objArr);
+    const objArrLength = objArrKeys.length;
+    let total = 0;
+    const results = [];
+    const pending = new Promise((resolve, reject) => {
+        const next = (errors) => {
+            results.push.apply(results, errors);
+            total++;
+            if (total === objArrLength) {
+                callback(results);
+                return results.length
+                    ? reject(new AsyncValidationError(results, convertFieldsError(results)))
+                    : resolve(source);
+            }
+        };
+        if (!objArrKeys.length) {
+            callback(results);
+            resolve(source);
+        }
+        objArrKeys.forEach(key => {
+            const arr = objArr[key];
+            if (firstFields.indexOf(key) !== -1) {
+                asyncSerialArray(arr, func, next);
+            }
+            else {
+                asyncParallelArray(arr, func, next);
+            }
+        });
+    });
+    pending.catch(e => e);
+    return pending;
+}
+exports.asyncMap = asyncMap;
+function isErrorObj(obj) {
+    return !!(obj && obj.message !== undefined);
+}
+function getValue(value, path) {
+    let v = value;
+    for (let i = 0; i < path.length; i++) {
+        if (v == undefined) {
+            return v;
+        }
+        v = v[path[i]];
+    }
+    return v;
+}
+function complementError(rule, source) {
+    return (oe) => {
+        let fieldValue;
+        if (rule.fullFields) {
+            fieldValue = getValue(source, rule.fullFields);
+        }
+        else {
+            fieldValue = source[oe.field || rule.fullField];
+        }
+        if (isErrorObj(oe)) {
+            oe.field = oe.field || rule.fullField;
+            oe.fieldValue = fieldValue;
+            return oe;
+        }
+        return {
+            message: typeof oe === 'function' ? oe() : oe,
+            fieldValue,
+            field: oe.field || rule.fullField,
+        };
+    };
+}
+exports.complementError = complementError;
+function deepMerge(target, source) {
+    if (source) {
+        for (const s in source) {
+            if (source.hasOwnProperty(s)) {
+                const value = source[s];
+                if (typeof value === 'object' && typeof target[s] === 'object') {
+                    target[s] = Object.assign(Object.assign({}, target[s]), value);
+                }
+                else {
+                    //@ts-ignore
+                    target[s] = value;
+                }
+            }
+        }
+    }
+    return target;
+}
+exports.deepMerge = deepMerge;

package/bin/lib/modules/rule/async-validator/validator/any.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const rule_1 = require("../rule");
+const util_1 = require("../util");
+const any = (rule, value, callback, source, options) => {
+    const errors = [];
+    const validate = rule.required || (!rule.required && source.hasOwnProperty(rule.field));
+    if (validate) {
+        if ((0, util_1.isEmptyValue)(value) && !rule.required) {
+            return callback();
+        }
+        rule_1.default.required(rule, value, source, errors, options);
+    }
+    callback(errors);
+};
+exports.default = any;

package/bin/lib/modules/rule/async-validator/validator/array.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../rule/index");
+const array = (rule, value, callback, source, options) => {
+    const errors = [];
+    const validate = rule.required || (!rule.required && source.hasOwnProperty(rule.field));
+    if (validate) {
+        if ((value === undefined || value === null) && !rule.required) {
+            return callback();
+        }
+        index_1.default.required(rule, value, source, errors, options, 'array');
+        if (value !== undefined && value !== null) {
+            index_1.default.type(rule, value, source, errors, options);
+            index_1.default.range(rule, value, source, errors, options);
+        }
+    }
+    callback(errors);
+};
+exports.default = array;

package/bin/lib/modules/rule/async-validator/validator/boolean.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//@ts-nocheck
+const util_1 = require("../util");
+const rule_1 = require("../rule");
+const boolean = (rule, value, callback, source, options) => {
+    const errors = [];
+    const validate = rule.required || (!rule.required && source.hasOwnProperty(rule.field));
+    if (validate) {
+        if ((0, util_1.isEmptyValue)(value) && !rule.required) {
+            return callback();
+        }
+        rule_1.default.required(rule, value, source, errors, options);
+        if (value !== undefined) {
+            rule_1.default.type(rule, value, source, errors, options);
+        }
+    }
+    callback(errors);
+};
+exports.default = boolean;

package/bin/lib/modules/rule/async-validator/validator/date.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const rule_1 = require("../rule");
+const util_1 = require("../util");
+const date = (rule, value, callback, source, options) => {
+    // console.log('integer rule called %j', rule);
+    const errors = [];
+    const validate = rule.required || (!rule.required && source.hasOwnProperty(rule.field));
+    // console.log('validate on %s value', value);
+    if (validate) {
+        if ((0, util_1.isEmptyValue)(value, 'date') && !rule.required) {
+            return callback();
+        }
+        rule_1.default.required(rule, value, source, errors, options);
+        if (!(0, util_1.isEmptyValue)(value, 'date')) {
+            let dateObject;
+            if (value instanceof Date) {
+                dateObject = value;
+            }
+            else {
+                dateObject = new Date(value);
+            }
+            rule_1.default.type(rule, dateObject, source, errors, options);
+            if (dateObject) {
+                rule_1.default.range(rule, dateObject.getTime(), source, errors, options);
+            }
+        }
+    }
+    callback(errors);
+};
+exports.default = date;

package/bin/lib/modules/rule/async-validator/validator/enum.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const rule_1 = require("../rule");
+const util_1 = require("../util");
+const ENUM = 'enum';
+const enumerable = (rule, value, callback, source, options) => {
+    const errors = [];
+    const validate = rule.required || (!rule.required && source.hasOwnProperty(rule.field));
+    if (validate) {
+        if ((0, util_1.isEmptyValue)(value) && !rule.required) {
+            return callback();
+        }
+        rule_1.default.required(rule, value, source, errors, options);
+        if (value !== undefined) {
+            rule_1.default[ENUM](rule, value, source, errors, options);
+        }
+    }
+    callback(errors);
+};
+exports.default = enumerable;