ddan-js 1.2.2 → 1.2.4

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const rule_1 = require("../rule");
+const util_1 = require("../util");
+const floatFn = (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);
+            rule_1.default.range(rule, value, source, errors, options);
+        }
+    }
+    callback(errors);
+};
+exports.default = floatFn;

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const string_1 = require("./string");
+const method_1 = require("./method");
+const number_1 = require("./number");
+const boolean_1 = require("./boolean");
+const regexp_1 = require("./regexp");
+const integer_1 = require("./integer");
+const float_1 = require("./float");
+const array_1 = require("./array");
+const object_1 = require("./object");
+const enum_1 = require("./enum");
+const pattern_1 = require("./pattern");
+const date_1 = require("./date");
+const required_1 = require("./required");
+const type_1 = require("./type");
+const any_1 = require("./any");
+exports.default = {
+    string: string_1.default,
+    method: method_1.default,
+    number: number_1.default,
+    boolean: boolean_1.default,
+    regexp: regexp_1.default,
+    integer: integer_1.default,
+    float: float_1.default,
+    array: array_1.default,
+    object: object_1.default,
+    enum: enum_1.default,
+    pattern: pattern_1.default,
+    date: date_1.default,
+    url: type_1.default,
+    hex: type_1.default,
+    email: type_1.default,
+    required: required_1.default,
+    any: any_1.default,
+};

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const rule_1 = require("../rule");
+const util_1 = require("../util");
+const integer = (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);
+            rule_1.default.range(rule, value, source, errors, options);
+        }
+    }
+    callback(errors);
+};
+exports.default = integer;

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const rule_1 = require("../rule");
+const util_1 = require("../util");
+const method = (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 = method;

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const rule_1 = require("../rule");
+const util_1 = require("../util");
+const number = (rule, value, callback, source, options) => {
+    const errors = [];
+    const validate = rule.required || (!rule.required && source.hasOwnProperty(rule.field));
+    if (validate) {
+        if (value === '') {
+            value = undefined;
+        }
+        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);
+            rule_1.default.range(rule, value, source, errors, options);
+        }
+    }
+    callback(errors);
+};
+exports.default = number;

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const rule_1 = require("../rule");
+const util_1 = require("../util");
+const object = (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 = object;

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const rule_1 = require("../rule");
+const util_1 = require("../util");
+const pattern = (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, 'string') && !rule.required) {
+            return callback();
+        }
+        rule_1.default.required(rule, value, source, errors, options);
+        if (!(0, util_1.isEmptyValue)(value, 'string')) {
+            rule_1.default.pattern(rule, value, source, errors, options);
+        }
+    }
+    callback(errors);
+};
+exports.default = pattern;

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const rule_1 = require("../rule");
+const util_1 = require("../util");
+const regexp = (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 (!(0, util_1.isEmptyValue)(value)) {
+            rule_1.default.type(rule, value, source, errors, options);
+        }
+    }
+    callback(errors);
+};
+exports.default = regexp;

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

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const rule_1 = require("../rule");
+const required = (rule, value, callback, source, options) => {
+    const errors = [];
+    const type = Array.isArray(value) ? 'array' : typeof value;
+    rule_1.default.required(rule, value, source, errors, options, type);
+    callback(errors);
+};
+exports.default = required;

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const rule_1 = require("../rule");
+const util_1 = require("../util");
+const string = (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, 'string') && !rule.required) {
+            return callback();
+        }
+        rule_1.default.required(rule, value, source, errors, options, 'string');
+        if (!(0, util_1.isEmptyValue)(value, 'string')) {
+            rule_1.default.type(rule, value, source, errors, options);
+            rule_1.default.range(rule, value, source, errors, options);
+            rule_1.default.pattern(rule, value, source, errors, options);
+            if (rule.whitespace === true) {
+                rule_1.default.whitespace(rule, value, source, errors, options);
+            }
+        }
+    }
+    callback(errors);
+};
+exports.default = string;

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

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

package/bin/lib/modules/rule/index.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const hook_1 = require("../hook");
+const async_validator_1 = require("./async-validator");
+function validateId(content) {
+    if (!content)
+        return false;
+    if (content.length < 6)
+        return false;
+    const reg = /^[A-Za-z0-9_-]+$/;
+    if (!reg.test(content)) {
+        return false;
+    }
+    return true;
+}
+function validatePhone(content) {
+    if (!content)
+        return false;
+    const reg = /^(13[0-9]|14[01456879]|15[0-35-9]|16[2567]|17[0-8]|18[0-9]|19[0-35-9])\d{8}$/;
+    if (!reg.test(content)) {
+        return false;
+    }
+    return true;
+}
+function validator(rules) {
+    return new async_validator_1.default(rules);
+}
+function validate(rules, source_, o = {}, oc = () => { }) {
+    return hook_1.default.run(validator(rules).validate(source_, o, oc));
+}
+exports.default = { validateId, validatePhone, validator, validate };

package/bin/lib/modules/url/index.js

@@ -2,4 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const decode_1 = require("./decode");
 const encode_1 = require("./encode");
-exports.default = { parse: decode_1.default, decode: decode_1.default, stringify: encode_1.default, encode: encode_1.default };
+function useHttps(url) {
+    if (!url)
+        return url;
+    const tUrl = url.trim();
+    if (typeof url !== "string")
+        return url;
+    if (tUrl.indexOf("https") < 0) {
+        return tUrl.replace("http", "https");
+    }
+    return tUrl;
+}
+exports.default = { parse: decode_1.default, decode: decode_1.default, stringify: encode_1.default, encode: encode_1.default, useHttps };

package/bin/lib/util/index.js

@@ -3,4 +3,33 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const is_1 = require("./is");
 const _object_1 = require("../common/_object");
 const includes_1 = require("./includes");
-exports.default = Object.assign(Object.assign(Object.assign({}, is_1.default), _object_1.default), { includes: includes_1.default });
+function compareArray(arr1, arr2) {
+    if (!Array.isArray(arr1) || !Array.isArray(arr2))
+        return false;
+    if (arr1.length !== arr2.length)
+        return false;
+    for (let i = 0, len = arr1.length; i < len; i++) {
+        if (arr1[i] !== arr2[i])
+            return false;
+    }
+    return true;
+}
+function merge(target, source) {
+    if (!source)
+        return target;
+    if (!target)
+        return source;
+    Object.keys(source).forEach((key) => {
+        if (Array.isArray(target[key]) && Array.isArray(source[key])) {
+            target[key] = target[key].concat(source[key]);
+        }
+        else if (typeof target[key] === "object" && typeof source[key] === "object") {
+            target[key] = Object.assign(target[key], source[key]);
+        }
+        else {
+            target[key] = source[key];
+        }
+    });
+    return target;
+}
+exports.default = Object.assign(Object.assign(Object.assign({}, is_1.default), _object_1.default), { includes: includes_1.default, merge, compareArray });

package/bin/types/index.d.ts

@@ -33,9 +33,12 @@ declare const _default: {
         random: (max: number) => number;
         randomRange: (min: number, max: number) => number;
         lerp: (start: number, end: number, t: number) => number;
+        randomString: (len: any, prefix?: boolean) => string;
     };
     util: {
         includes: typeof import("./util/includes").default;
+        merge: (target: any, source: any) => any;
+        compareArray: (arr1: any, arr2: any) => boolean;
         getTag: (value: any) => string;
         getType: (value: any) => string;
         toString: () => string;
@@ -66,14 +69,42 @@ declare const _default: {
     };
     mini: {
         diff: typeof import("./modules/mini/diff").default;
-        promixify: (wxapi: any) => (options: any, ...params: any[]) => Promise<any[]>;
-        api: (miniapi: any, options: any, ...params: any[]) => Promise<any[]>;
+        promixify: (miniapi: any) => any;
+        run: (func: any, args?: {}) => Promise<any[]> | undefined;
+        formatList: (lists: any[], start: any, name: any) => any;
     };
     url: {
-        parse: (qs: any, sep: any, eq: any, options: any) => {};
-        decode: (qs: any, sep: any, eq: any, options: any) => {};
-        stringify: (obj: any, sep: any, eq: any, name: any) => string;
-        encode: (obj: any, sep: any, eq: any, name: any) => string;
+        parse: (qs: any, { sep, eq, max, multiple }?: {
+            sep?: string | undefined;
+            eq?: string | undefined;
+            max?: number | undefined;
+            multiple?: boolean | undefined;
+        }) => {};
+        decode: (qs: any, { sep, eq, max, multiple }?: {
+            sep?: string | undefined;
+            eq?: string | undefined;
+            max?: number | undefined;
+            multiple?: boolean | undefined;
+        }) => {};
+        stringify: (obj: any, { sep, eq, name, multiple }?: {
+            sep?: string | undefined;
+            eq?: string | undefined;
+            name?: null | undefined;
+            multiple?: boolean | undefined;
+        }) => string;
+        encode: (obj: any, { sep, eq, name, multiple }?: {
+            sep?: string | undefined;
+            eq?: string | undefined;
+            name?: null | undefined;
+            multiple?: boolean | undefined;
+        }) => string;
+        useHttps: (url: string) => string;
+    };
+    rule: {
+        validateId: (content: any) => boolean;
+        validatePhone: (content: any) => boolean;
+        validator: (rules: import("./modules/rule/async-validator").Rules) => import("./modules/rule/async-validator").default;
+        validate: (rules: import("./modules/rule/async-validator").Rules, source_: import("./modules/rule/async-validator").Values, o?: any, oc?: any) => Promise<import("./modules/rule/async-validator").Values>;
     };
     DEvent: typeof DEvent;
     store: typeof store;

package/bin/types/modules/math/index.d.ts

@@ -16,9 +16,11 @@ declare function randomRange(min: number, max: number): number;
  * @param t
  */
 declare function lerp(start: number, end: number, t: number): number;
+declare function randomString(len: any, prefix?: boolean): string;
 declare const _default: {
     random: typeof random;
     randomRange: typeof randomRange;
     lerp: typeof lerp;
+    randomString: typeof randomString;
 };
 export default _default;

package/bin/types/modules/mini/index.d.ts

@@ -1,7 +1,9 @@
 import diff from "./diff";
+declare function formatList(lists: any[], start: any, name: any): any;
 declare const _default: {
     diff: typeof diff;
-    promixify: (miniapi: any) => (options: any, ...params: any[]) => Promise<unknown>;
-    api: (miniapi: any, options?: null, ...params: any[]) => Promise<any[]>;
+    promixify: (miniapi: any) => any;
+    run: (func: any, args?: {}) => Promise<any[]> | undefined;
+    formatList: typeof formatList;
 };
 export default _default;

package/bin/types/modules/rule/async-validator/index.d.ts

@@ -0,0 +1,43 @@
+import { InternalRuleItem, InternalValidateMessages, RuleItem, Rules, ValidateCallback, ValidateMessages, ValidateOption, Values, SyncErrorType } from './interface';
+export * from './interface';
+/**
+ *  Encapsulates a validation schema.
+ *
+ *  @param descriptor An object declaring validation rules
+ *  for this schema.
+ */
+declare class Schema {
+    static register: (type: string, validator: any) => void;
+    static warning: (type: string, errors: SyncErrorType[]) => void;
+    static messages: InternalValidateMessages;
+    static validators: {
+        string: import("./interface").ExecuteValidator;
+        method: import("./interface").ExecuteValidator;
+        number: import("./interface").ExecuteValidator;
+        boolean: import("./interface").ExecuteValidator;
+        regexp: import("./interface").ExecuteValidator;
+        integer: import("./interface").ExecuteValidator;
+        float: import("./interface").ExecuteValidator;
+        array: import("./interface").ExecuteValidator;
+        object: import("./interface").ExecuteValidator;
+        enum: import("./interface").ExecuteValidator;
+        pattern: import("./interface").ExecuteValidator;
+        date: import("./interface").ExecuteValidator;
+        url: import("./interface").ExecuteValidator;
+        hex: import("./interface").ExecuteValidator;
+        email: import("./interface").ExecuteValidator;
+        required: import("./interface").ExecuteValidator;
+        any: import("./interface").ExecuteValidator;
+    };
+    rules: Record<string, RuleItem[]>;
+    _messages: InternalValidateMessages;
+    constructor(descriptor: Rules);
+    define(rules: Rules): void;
+    messages(messages?: ValidateMessages): InternalValidateMessages;
+    validate(source: Values, option?: ValidateOption, callback?: ValidateCallback): Promise<Values>;
+    validate(source: Values, callback: ValidateCallback): Promise<Values>;
+    validate(source: Values): Promise<Values>;
+    getType(rule: InternalRuleItem): import("./interface").RuleType;
+    getValidationMethod(rule: InternalRuleItem): import("./interface").ExecuteValidator | ((rule: InternalRuleItem, value: any, callback: (error?: string | Error | undefined) => void, source: Values, options: ValidateOption) => void | import("./interface").SyncValidateResult);
+}
+export default Schema;

package/bin/types/modules/rule/async-validator/interface.d.ts

@@ -0,0 +1,135 @@
+export type RuleType = 'string' | 'number' | 'boolean' | 'method' | 'regexp' | 'integer' | 'float' | 'array' | 'object' | 'enum' | 'date' | 'url' | 'hex' | 'email' | 'pattern' | 'any';
+export interface ValidateOption {
+    suppressWarning?: boolean;
+    suppressValidatorError?: boolean;
+    first?: boolean;
+    firstFields?: boolean | string[];
+    messages?: Partial<ValidateMessages>;
+    /** The name of rules need to be trigger. Will validate all rules if leave empty */
+    keys?: string[];
+    error?: (rule: InternalRuleItem, message: string) => ValidateError;
+}
+export type SyncErrorType = Error | string;
+export type SyncValidateResult = boolean | SyncErrorType | SyncErrorType[];
+export type ValidateResult = void | Promise<void> | SyncValidateResult;
+export interface RuleItem {
+    type?: RuleType;
+    required?: boolean;
+    pattern?: RegExp | string;
+    min?: number;
+    max?: number;
+    len?: number;
+    enum?: Array<string | number | boolean | null | undefined>;
+    whitespace?: boolean;
+    fields?: Record<string, Rule>;
+    options?: ValidateOption;
+    defaultField?: Rule;
+    transform?: (value: Value) => Value;
+    message?: string | ((a?: string) => string);
+    asyncValidator?: (rule: InternalRuleItem, value: Value, callback: (error?: string | Error) => void, source: Values, options: ValidateOption) => void | Promise<void>;
+    validator?: (rule: InternalRuleItem, value: Value, callback: (error?: string | Error) => void, source: Values, options: ValidateOption) => SyncValidateResult | void;
+}
+export type Rule = RuleItem | RuleItem[];
+export type Rules = Record<string, Rule>;
+/**
+ *  Rule for validating a value exists in an enumerable list.
+ *
+ *  @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.
+ *  @param type Rule type
+ */
+export type ExecuteRule = (rule: InternalRuleItem, value: Value, source: Values, errors: string[], options: ValidateOption, type?: string) => void;
+/**
+ *  Performs validation for any type.
+ *
+ *  @param rule The validation rule.
+ *  @param value The value of the field on the source object.
+ *  @param callback The callback function.
+ *  @param source The source object being validated.
+ *  @param options The validation options.
+ *  @param options.messages The validation messages.
+ */
+export type ExecuteValidator = (rule: InternalRuleItem, value: Value, callback: (error?: string[]) => void, source: Values, options: ValidateOption) => void;
+type ValidateMessage<T extends any[] = unknown[]> = string | ((...args: T) => string);
+type FullField = string | undefined;
+type EnumString = string | undefined;
+type Pattern = string | RegExp | undefined;
+type Range = number | undefined;
+type Type = string | undefined;
+export interface ValidateMessages {
+    default?: ValidateMessage;
+    required?: ValidateMessage<[FullField]>;
+    enum?: ValidateMessage<[FullField, EnumString]>;
+    whitespace?: ValidateMessage<[FullField]>;
+    date?: {
+        format?: ValidateMessage;
+        parse?: ValidateMessage;
+        invalid?: ValidateMessage;
+    };
+    types?: {
+        string?: ValidateMessage<[FullField, Type]>;
+        method?: ValidateMessage<[FullField, Type]>;
+        array?: ValidateMessage<[FullField, Type]>;
+        object?: ValidateMessage<[FullField, Type]>;
+        number?: ValidateMessage<[FullField, Type]>;
+        date?: ValidateMessage<[FullField, Type]>;
+        boolean?: ValidateMessage<[FullField, Type]>;
+        integer?: ValidateMessage<[FullField, Type]>;
+        float?: ValidateMessage<[FullField, Type]>;
+        regexp?: ValidateMessage<[FullField, Type]>;
+        email?: ValidateMessage<[FullField, Type]>;
+        url?: ValidateMessage<[FullField, Type]>;
+        hex?: ValidateMessage<[FullField, Type]>;
+    };
+    string?: {
+        len?: ValidateMessage<[FullField, Range]>;
+        min?: ValidateMessage<[FullField, Range]>;
+        max?: ValidateMessage<[FullField, Range]>;
+        range?: ValidateMessage<[FullField, Range, Range]>;
+    };
+    number?: {
+        len?: ValidateMessage<[FullField, Range]>;
+        min?: ValidateMessage<[FullField, Range]>;
+        max?: ValidateMessage<[FullField, Range]>;
+        range?: ValidateMessage<[FullField, Range, Range]>;
+    };
+    array?: {
+        len?: ValidateMessage<[FullField, Range]>;
+        min?: ValidateMessage<[FullField, Range]>;
+        max?: ValidateMessage<[FullField, Range]>;
+        range?: ValidateMessage<[FullField, Range, Range]>;
+    };
+    pattern?: {
+        mismatch?: ValidateMessage<[FullField, Value, Pattern]>;
+    };
+}
+export interface InternalValidateMessages extends ValidateMessages {
+    clone: () => InternalValidateMessages;
+}
+export type Value = any;
+export type Values = Record<string, Value>;
+export interface ValidateError {
+    message?: string;
+    fieldValue?: Value;
+    field?: string;
+}
+export type ValidateFieldsError = Record<string, ValidateError[]>;
+export type ValidateCallback = (errors: ValidateError[] | null, fields: ValidateFieldsError | Values) => void;
+export interface RuleValuePackage {
+    rule: InternalRuleItem;
+    value: Value;
+    source: Values;
+    field: string;
+}
+export interface InternalRuleItem extends Omit<RuleItem, 'validator'> {
+    field?: string;
+    fullField?: string;
+    fullFields?: string[];
+    validator?: RuleItem['validator'] | ExecuteValidator;
+}
+export {};

package/bin/types/modules/rule/async-validator/messages.d.ts

@@ -0,0 +1,3 @@
+import { InternalValidateMessages } from './interface';
+export declare function newMessages(): InternalValidateMessages;
+export declare const messages: InternalValidateMessages;

package/bin/types/modules/rule/async-validator/rule/enum.d.ts

@@ -0,0 +1,3 @@
+import { ExecuteRule } from '../interface';
+declare const enumerable: ExecuteRule;
+export default enumerable;

package/bin/types/modules/rule/async-validator/rule/index.d.ts

@@ -0,0 +1,9 @@
+declare const _default: {
+    required: import("..").ExecuteRule;
+    whitespace: import("..").ExecuteRule;
+    type: import("..").ExecuteRule;
+    range: import("..").ExecuteRule;
+    enum: import("..").ExecuteRule;
+    pattern: import("..").ExecuteRule;
+};
+export default _default;

package/bin/types/modules/rule/async-validator/rule/pattern.d.ts

@@ -0,0 +1,3 @@
+import { ExecuteRule } from '../interface';
+declare const pattern: ExecuteRule;
+export default pattern;

package/bin/types/modules/rule/async-validator/rule/range.d.ts

@@ -0,0 +1,3 @@
+import { ExecuteRule } from '../interface';
+declare const range: ExecuteRule;
+export default range;

package/bin/types/modules/rule/async-validator/rule/required.d.ts

@@ -0,0 +1,3 @@
+import { ExecuteRule } from '../interface';
+declare const required: ExecuteRule;
+export default required;

package/bin/types/modules/rule/async-validator/rule/type.d.ts

@@ -0,0 +1,3 @@
+import { ExecuteRule } from '../interface';
+declare const type: ExecuteRule;
+export default type;

package/bin/types/modules/rule/async-validator/rule/url.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => RegExp;
+export default _default;

package/bin/types/modules/rule/async-validator/rule/whitespace.d.ts

@@ -0,0 +1,14 @@
+import { ExecuteRule } from '../interface';
+/**
+ *  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.
+ */
+declare const whitespace: ExecuteRule;
+export default whitespace;