@dooboostore/dom-render 1.0.98

package/validators/CountGreaterThanEqualsCheckedValidatorArray.js

@@ -0,0 +1,12 @@
+import { ValidatorArray } from './ValidatorArray';
+export class CountGreaterThanEqualsCheckedValidatorArray extends ValidatorArray {
+    constructor(count, value, target, event, autoValid = true) {
+        super(value, target, event, autoValid);
+        this.count = count;
+    }
+    valid() {
+        var _a;
+        return ((_a = this.value) !== null && _a !== void 0 ? _a : []).filter(it => it.checked).length >= this.count;
+    }
+}
+//# sourceMappingURL=CountGreaterThanEqualsCheckedValidatorArray.js.map

package/validators/CountGreaterThanEqualsUnCheckedValidatorArray.d.ts

@@ -0,0 +1,8 @@
+import { Validator } from './Validator';
+import { ValidatorArray } from './ValidatorArray';
+export declare class CountGreaterThanEqualsUnCheckedValidatorArray<T = any, E = Element> extends ValidatorArray<T, E> {
+    count: number;
+    constructor(count: number, value?: Validator<T, E>[], target?: E, event?: Event, autoValid?: boolean);
+    valid(): boolean;
+}
+//# sourceMappingURL=CountGreaterThanEqualsUnCheckedValidatorArray.d.ts.map

package/validators/CountGreaterThanEqualsUnCheckedValidatorArray.js

@@ -0,0 +1,12 @@
+import { ValidatorArray } from './ValidatorArray';
+export class CountGreaterThanEqualsUnCheckedValidatorArray extends ValidatorArray {
+    constructor(count, value, target, event, autoValid = true) {
+        super(value, target, event, autoValid);
+        this.count = count;
+    }
+    valid() {
+        var _a;
+        return ((_a = this.value) !== null && _a !== void 0 ? _a : []).filter(it => !it.checked).length >= this.count;
+    }
+}
+//# sourceMappingURL=CountGreaterThanEqualsUnCheckedValidatorArray.js.map

package/validators/CountGreaterThanUnCheckedValidatorArray.d.ts

@@ -0,0 +1,8 @@
+import { Validator } from './Validator';
+import { ValidatorArray } from './ValidatorArray';
+export declare class CountGreaterThanUnCheckedValidatorArray<T = any, E = Element> extends ValidatorArray<T, E> {
+    count: number;
+    constructor(count: number, value?: Validator<T, E>[], target?: E, event?: Event, autoValid?: boolean);
+    valid(): boolean;
+}
+//# sourceMappingURL=CountGreaterThanUnCheckedValidatorArray.d.ts.map

package/validators/CountGreaterThanUnCheckedValidatorArray.js

@@ -0,0 +1,12 @@
+import { ValidatorArray } from './ValidatorArray';
+export class CountGreaterThanUnCheckedValidatorArray extends ValidatorArray {
+    constructor(count, value, target, event, autoValid = true) {
+        super(value, target, event, autoValid);
+        this.count = count;
+    }
+    valid() {
+        var _a;
+        return ((_a = this.value) !== null && _a !== void 0 ? _a : []).filter(it => !it.checked).length > this.count;
+    }
+}
+//# sourceMappingURL=CountGreaterThanUnCheckedValidatorArray.js.map

package/validators/CountLessThanCheckedValidatorArray.d.ts

@@ -0,0 +1,8 @@
+import { Validator } from './Validator';
+import { ValidatorArray } from './ValidatorArray';
+export declare class CountLessThanCheckedValidatorArray<T = any, E = Element> extends ValidatorArray<T, E> {
+    count: number;
+    constructor(count: number, value?: Validator<T, E>[], target?: E, event?: Event, autoValid?: boolean);
+    valid(): boolean;
+}
+//# sourceMappingURL=CountLessThanCheckedValidatorArray.d.ts.map

package/validators/CountLessThanCheckedValidatorArray.js

@@ -0,0 +1,12 @@
+import { ValidatorArray } from './ValidatorArray';
+export class CountLessThanCheckedValidatorArray extends ValidatorArray {
+    constructor(count, value, target, event, autoValid = true) {
+        super(value, target, event, autoValid);
+        this.count = count;
+    }
+    valid() {
+        var _a;
+        return ((_a = this.value) !== null && _a !== void 0 ? _a : []).filter(it => it.checked).length < this.count;
+    }
+}
+//# sourceMappingURL=CountLessThanCheckedValidatorArray.js.map

package/validators/CountLessThanEqualsCheckedValidatorArray.d.ts

@@ -0,0 +1,8 @@
+import { Validator } from './Validator';
+import { ValidatorArray } from './ValidatorArray';
+export declare class CountLessThanEqualsCheckedValidatorArray<T = any, E = Element> extends ValidatorArray<T, E> {
+    count: number;
+    constructor(count: number, value?: Validator<T, E>[], target?: E, event?: Event, autoValid?: boolean);
+    valid(): boolean;
+}
+//# sourceMappingURL=CountLessThanEqualsCheckedValidatorArray.d.ts.map

package/validators/CountLessThanEqualsCheckedValidatorArray.js

@@ -0,0 +1,12 @@
+import { ValidatorArray } from './ValidatorArray';
+export class CountLessThanEqualsCheckedValidatorArray extends ValidatorArray {
+    constructor(count, value, target, event, autoValid = true) {
+        super(value, target, event, autoValid);
+        this.count = count;
+    }
+    valid() {
+        var _a;
+        return ((_a = this.value) !== null && _a !== void 0 ? _a : []).filter(it => it.checked).length <= this.count;
+    }
+}
+//# sourceMappingURL=CountLessThanEqualsCheckedValidatorArray.js.map

package/validators/CountLessThanEqualsUnCheckedValidatorArray.d.ts

@@ -0,0 +1,8 @@
+import { Validator } from './Validator';
+import { ValidatorArray } from './ValidatorArray';
+export declare class CountLessThanEqualsUnCheckedValidatorArray<T = any, E = Element> extends ValidatorArray<T, E> {
+    count: number;
+    constructor(count: number, value?: Validator<T, E>[], target?: E, event?: Event, autoValid?: boolean);
+    valid(): boolean;
+}
+//# sourceMappingURL=CountLessThanEqualsUnCheckedValidatorArray.d.ts.map

package/validators/CountLessThanEqualsUnCheckedValidatorArray.js

@@ -0,0 +1,12 @@
+import { ValidatorArray } from './ValidatorArray';
+export class CountLessThanEqualsUnCheckedValidatorArray extends ValidatorArray {
+    constructor(count, value, target, event, autoValid = true) {
+        super(value, target, event, autoValid);
+        this.count = count;
+    }
+    valid() {
+        var _a;
+        return ((_a = this.value) !== null && _a !== void 0 ? _a : []).filter(it => !it.checked).length <= this.count;
+    }
+}
+//# sourceMappingURL=CountLessThanEqualsUnCheckedValidatorArray.js.map

package/validators/CountLessThanUnCheckedValidatorArray.d.ts

@@ -0,0 +1,8 @@
+import { Validator } from './Validator';
+import { ValidatorArray } from './ValidatorArray';
+export declare class CountLessThanUnCheckedValidatorArray<T = any, E = Element> extends ValidatorArray<T, E> {
+    count: number;
+    constructor(count: number, value?: Validator<T, E>[], target?: E, event?: Event, autoValid?: boolean);
+    valid(): boolean;
+}
+//# sourceMappingURL=CountLessThanUnCheckedValidatorArray.d.ts.map

package/validators/CountLessThanUnCheckedValidatorArray.js

@@ -0,0 +1,12 @@
+import { ValidatorArray } from './ValidatorArray';
+export class CountLessThanUnCheckedValidatorArray extends ValidatorArray {
+    constructor(count, value, target, event, autoValid = true) {
+        super(value, target, event, autoValid);
+        this.count = count;
+    }
+    valid() {
+        var _a;
+        return ((_a = this.value) !== null && _a !== void 0 ? _a : []).filter(it => !it.checked).length < this.count;
+    }
+}
+//# sourceMappingURL=CountLessThanUnCheckedValidatorArray.js.map

package/validators/CountUnCheckedValidatorArray.d.ts

@@ -0,0 +1,8 @@
+import { Validator } from './Validator';
+import { ValidatorArray } from './ValidatorArray';
+export declare class CountUnCheckedValidatorArray<T = any, E = Element> extends ValidatorArray<T, E> {
+    count: number;
+    constructor(count: number, value?: Validator<T, E>[], target?: E, event?: Event, autoValid?: boolean);
+    valid(): boolean;
+}
+//# sourceMappingURL=CountUnCheckedValidatorArray.d.ts.map

package/validators/CountUnCheckedValidatorArray.js

@@ -0,0 +1,12 @@
+import { ValidatorArray } from './ValidatorArray';
+export class CountUnCheckedValidatorArray extends ValidatorArray {
+    constructor(count, value, target, event, autoValid = true) {
+        super(value, target, event, autoValid);
+        this.count = count;
+    }
+    valid() {
+        var _a;
+        return ((_a = this.value) !== null && _a !== void 0 ? _a : []).filter(it => !it.checked).length >= this.count;
+    }
+}
+//# sourceMappingURL=CountUnCheckedValidatorArray.js.map

package/validators/EmptyValidator.d.ts

@@ -0,0 +1,6 @@
+import { Validator } from './Validator';
+export declare class EmptyValidator<T = any, E = Element> extends Validator<T, E> {
+    constructor(value?: T, target?: E, event?: Event, autoValid?: boolean);
+    valid(): boolean;
+}
+//# sourceMappingURL=EmptyValidator.d.ts.map

package/validators/EmptyValidator.js

@@ -0,0 +1,12 @@
+import { Validator } from './Validator';
+export class EmptyValidator extends Validator {
+    constructor(value, target, event, autoValid = true) {
+        super(value, target, event, autoValid);
+    }
+    valid() {
+        var _a;
+        const value = this.value;
+        return value === undefined || value === null || ((_a = value === null || value === void 0 ? void 0 : value.length) !== null && _a !== void 0 ? _a : 0) <= 0;
+    }
+}
+//# sourceMappingURL=EmptyValidator.js.map

package/validators/ExcludeCheckedValidatorArray.d.ts

@@ -0,0 +1,9 @@
+import { Validator } from './Validator';
+import { ValidatorArray } from './ValidatorArray';
+export declare class ExcludeCheckedValidatorArray<T = any, E = Element> extends ValidatorArray<T, E> {
+    include: any[];
+    allRequired: boolean;
+    constructor(include: any[], allRequired?: boolean, value?: Validator<T, E>[], target?: E, event?: Event, autoValid?: boolean);
+    valid(): boolean;
+}
+//# sourceMappingURL=ExcludeCheckedValidatorArray.d.ts.map

package/validators/ExcludeCheckedValidatorArray.js

@@ -0,0 +1,17 @@
+import { ValidatorArray } from './ValidatorArray';
+export class ExcludeCheckedValidatorArray extends ValidatorArray {
+    constructor(include, allRequired = false, value, target, event, autoValid = true) {
+        super(value, target, event, autoValid);
+        this.include = include;
+        this.allRequired = allRequired;
+    }
+    valid() {
+        var _a;
+        const valus = (_a = this.value) !== null && _a !== void 0 ? _a : [];
+        const unCheckedValue = valus.filter(it => !it.checked).map(it => it.value);
+        return unCheckedValue.length > 0 &&
+            (!(unCheckedValue.filter(it => !this.include.includes(it)).length > 0)) &&
+            (this.allRequired ? unCheckedValue.filter(it => this.include.includes(it)).length === this.include.length : true);
+    }
+}
+//# sourceMappingURL=ExcludeCheckedValidatorArray.js.map

package/validators/FormValidator.d.ts

@@ -0,0 +1,8 @@
+import { Validator } from './Validator';
+export declare class FormValidator<E = HTMLFormElement> extends Validator<void, E> {
+    constructor(target?: E, event?: Event, autoValid?: boolean);
+    validAction(): boolean;
+    valid(): boolean;
+    reset(): void;
+}
+//# sourceMappingURL=FormValidator.d.ts.map

package/validators/FormValidator.js

@@ -0,0 +1,16 @@
+import { Validator } from './Validator';
+export class FormValidator extends Validator {
+    constructor(target, event, autoValid = true) {
+        super(undefined, target, event, autoValid);
+    }
+    validAction() {
+        return super.childValidAction();
+    }
+    valid() {
+        return this.childValid();
+    }
+    reset() {
+        this.targetReset();
+    }
+}
+//# sourceMappingURL=FormValidator.js.map

package/validators/IncludeCheckedValidatorArray.d.ts

@@ -0,0 +1,9 @@
+import { Validator } from './Validator';
+import { ValidatorArray } from './ValidatorArray';
+export declare class IncludeCheckedValidatorArray<T = any, E = Element> extends ValidatorArray<T, E> {
+    include: any[];
+    allRequired: boolean;
+    constructor(include: any[], allRequired?: boolean, value?: Validator<T, E>[], target?: E, event?: Event, autoValid?: boolean);
+    valid(): boolean;
+}
+//# sourceMappingURL=IncludeCheckedValidatorArray.d.ts.map

package/validators/IncludeCheckedValidatorArray.js

@@ -0,0 +1,17 @@
+import { ValidatorArray } from './ValidatorArray';
+export class IncludeCheckedValidatorArray extends ValidatorArray {
+    constructor(include, allRequired = false, value, target, event, autoValid = true) {
+        super(value, target, event, autoValid);
+        this.include = include;
+        this.allRequired = allRequired;
+    }
+    valid() {
+        var _a;
+        const valus = (_a = this.value) !== null && _a !== void 0 ? _a : [];
+        const checkedValue = valus.filter(it => it.checked).map(it => it.value);
+        return checkedValue.length > 0 &&
+            (!(checkedValue.filter(it => !this.include.includes(it)).length > 0)) &&
+            (this.allRequired ? checkedValue.filter(it => this.include.includes(it)).length === this.include.length : true);
+    }
+}
+//# sourceMappingURL=IncludeCheckedValidatorArray.js.map

package/validators/MultipleValidator.d.ts

@@ -0,0 +1,9 @@
+import { Validator } from './Validator';
+export declare class MultipleValidator<T = any, E = Element> extends Validator<T, E> {
+    validators: Validator<T, E>[];
+    constructor(validators: Validator<T, E>[], value?: T, target?: E, event?: Event, autoValid?: boolean);
+    changeValue(value: T | undefined): void;
+    validAction(): boolean;
+    valid(): boolean;
+}
+//# sourceMappingURL=MultipleValidator.d.ts.map

package/validators/MultipleValidator.js

@@ -0,0 +1,25 @@
+import { Validator } from './Validator';
+export class MultipleValidator extends Validator {
+    constructor(validators, value, target, event, autoValid = true) {
+        super(value, target, event, autoValid);
+        this.validators = validators.map(it => {
+            it.setAutoValid(false);
+            it.setAutoValidAction(false);
+            return it;
+        });
+        this.validators.forEach(it => {
+            it.set(this.value, this.getTarget(), this.getEvent());
+        });
+    }
+    changeValue(value) {
+        this.validators.forEach(it => it.set(this.value, this.getTarget(), this.getEvent()));
+    }
+    validAction() {
+        return !(this.validators.filter(it => !it.validAction()).length > 0);
+    }
+    valid() {
+        // console.log('mm', this.validators)
+        return !(this.validators.filter(it => !it.valid()).length > 0);
+    }
+}
+//# sourceMappingURL=MultipleValidator.js.map

package/validators/NonPassValidator.d.ts

@@ -0,0 +1,6 @@
+import { Validator } from './Validator';
+export declare class NonPassValidator<T = any, E = Element> extends Validator<T, E> {
+    constructor(value?: T, target?: E, event?: Event, autoValid?: boolean);
+    valid(): boolean;
+}
+//# sourceMappingURL=NonPassValidator.d.ts.map

package/validators/NonPassValidator.js

@@ -0,0 +1,10 @@
+import { Validator } from './Validator';
+export class NonPassValidator extends Validator {
+    constructor(value, target, event, autoValid = true) {
+        super(value, target, event, autoValid);
+    }
+    valid() {
+        return false;
+    }
+}
+//# sourceMappingURL=NonPassValidator.js.map

package/validators/NotEmptyValidator.d.ts

@@ -0,0 +1,6 @@
+import { Validator } from './Validator';
+export declare class NotEmptyValidator<T = any, E = Element> extends Validator<T, E> {
+    constructor(value?: T, target?: E, event?: Event, autoValid?: boolean);
+    valid(): boolean;
+}
+//# sourceMappingURL=NotEmptyValidator.d.ts.map

package/validators/NotEmptyValidator.js

@@ -0,0 +1,13 @@
+import { Validator } from './Validator';
+export class NotEmptyValidator extends Validator {
+    constructor(value, target, event, autoValid = true) {
+        super(value, target, event, autoValid);
+    }
+    valid() {
+        var _a;
+        const value = this.value;
+        // console.log('NotEmptyValidator', value, value !== undefined && value !== null && ((value as any)?.length ?? 0) > 0)
+        return value !== undefined && value !== null && ((_a = value === null || value === void 0 ? void 0 : value.length) !== null && _a !== void 0 ? _a : 0) > 0;
+    }
+}
+//# sourceMappingURL=NotEmptyValidator.js.map

package/validators/NotRegExpTestValidator.d.ts

@@ -0,0 +1,7 @@
+import { Validator } from './Validator';
+export declare class NotRegExpTestValidator<T = any, E = Element> extends Validator<T, E> {
+    regexp: RegExp;
+    constructor(regexp: RegExp, value?: T, target?: E, event?: Event, autoValid?: boolean);
+    valid(): boolean;
+}
+//# sourceMappingURL=NotRegExpTestValidator.d.ts.map

package/validators/NotRegExpTestValidator.js

@@ -0,0 +1,20 @@
+import { Validator } from './Validator';
+import { DomRenderProxy } from '../DomRenderProxy';
+export class NotRegExpTestValidator extends Validator {
+    constructor(regexp, value, target, event, autoValid = true) {
+        super(value, target, event, autoValid);
+        this.regexp = DomRenderProxy.final(regexp);
+    }
+    valid() {
+        var _a;
+        const value = this.value;
+        const regExp = (_a = this.regexp._DomRender_origin) !== null && _a !== void 0 ? _a : this.regexp;
+        if (value) {
+            return !regExp.test(value);
+        }
+        else {
+            return true;
+        }
+    }
+}
+//# sourceMappingURL=NotRegExpTestValidator.js.map

package/validators/PassValidator.d.ts

@@ -0,0 +1,6 @@
+import { Validator } from './Validator';
+export declare class PassValidator<T = any, E = Element> extends Validator<T, E> {
+    constructor(value?: T, target?: E, event?: Event, autoValid?: boolean);
+    valid(): boolean;
+}
+//# sourceMappingURL=PassValidator.d.ts.map

package/validators/PassValidator.js

@@ -0,0 +1,10 @@
+import { Validator } from './Validator';
+export class PassValidator extends Validator {
+    constructor(value, target, event, autoValid = true) {
+        super(value, target, event, autoValid);
+    }
+    valid() {
+        return true;
+    }
+}
+//# sourceMappingURL=PassValidator.js.map

package/validators/RegExpTestValidator.d.ts

@@ -0,0 +1,7 @@
+import { Validator } from './Validator';
+export declare class RegExpTestValidator<T = any, E = Element> extends Validator<T, E> {
+    regexp: RegExp;
+    constructor(regexp: RegExp, value?: T, target?: E, event?: Event, autoValid?: boolean);
+    valid(): boolean;
+}
+//# sourceMappingURL=RegExpTestValidator.d.ts.map

package/validators/RegExpTestValidator.js

@@ -0,0 +1,21 @@
+import { Validator } from './Validator';
+import { DomRenderProxy } from '../DomRenderProxy';
+export class RegExpTestValidator extends Validator {
+    constructor(regexp, value, target, event, autoValid = true) {
+        super(value, target, event, autoValid);
+        this.regexp = DomRenderProxy.final(regexp);
+    }
+    valid() {
+        var _a;
+        const value = this.value;
+        const regExp = (_a = this.regexp._DomRender_origin) !== null && _a !== void 0 ? _a : this.regexp;
+        // console.log('regexp-->', value, this.regexp, regExp.test(value))
+        if (value) {
+            return regExp.test(value);
+        }
+        else {
+            return false;
+        }
+    }
+}
+//# sourceMappingURL=RegExpTestValidator.js.map

package/validators/RequiredValidator.d.ts

@@ -0,0 +1,6 @@
+import { Validator } from './Validator';
+export declare class RequiredValidator<T = any, E = Element> extends Validator<T, E> {
+    constructor(value?: T, target?: E, event?: Event, autoValid?: boolean);
+    valid(): boolean;
+}
+//# sourceMappingURL=RequiredValidator.d.ts.map

package/validators/RequiredValidator.js

@@ -0,0 +1,12 @@
+import { Validator } from './Validator';
+export class RequiredValidator extends Validator {
+    constructor(value, target, event, autoValid = true) {
+        super(value, target, event, autoValid);
+    }
+    valid() {
+        const value = this.value;
+        // console.log('required', value, value !== undefined && value !== null)
+        return value !== undefined && value !== null;
+    }
+}
+//# sourceMappingURL=RequiredValidator.js.map

package/validators/UnCheckedValidator.d.ts

@@ -0,0 +1,6 @@
+import { Validator } from './Validator';
+export declare class UnCheckedValidator<T = any, E = HTMLElement> extends Validator<T, E> {
+    constructor(value?: T, target?: E, event?: Event, autoValid?: boolean);
+    valid(): boolean;
+}
+//# sourceMappingURL=UnCheckedValidator.d.ts.map

package/validators/UnCheckedValidator.js

@@ -0,0 +1,11 @@
+import { Validator } from './Validator';
+export class UnCheckedValidator extends Validator {
+    constructor(value, target, event, autoValid = true) {
+        super(value, target, event, autoValid);
+    }
+    valid() {
+        var _a, _b;
+        return !((_b = (_a = this.getTarget()) === null || _a === void 0 ? void 0 : _a.checked) !== null && _b !== void 0 ? _b : false);
+    }
+}
+//# sourceMappingURL=UnCheckedValidator.js.map

package/validators/ValidMultipleValidator.d.ts

@@ -0,0 +1,10 @@
+import { Validator } from './Validator';
+import { MultipleValidator } from './MultipleValidator';
+export type ValidMulltiple<T = any, E = Element> = (validators: Validator<T, E>[], value?: T, target?: E, event?: Event) => boolean;
+export declare class ValidMultipleValidator<T = any, E = Element> extends MultipleValidator<T, E> {
+    validMultipleCallback: ValidMulltiple<T, E>;
+    validators: Validator<T, E>[];
+    constructor(validMultipleCallback: ValidMulltiple<T, E>, validators: Validator<T, E>[], value?: T, target?: E, event?: Event, autoValid?: boolean);
+    valid(): boolean;
+}
+//# sourceMappingURL=ValidMultipleValidator.d.ts.map

package/validators/ValidMultipleValidator.js

@@ -0,0 +1,12 @@
+import { MultipleValidator } from './MultipleValidator';
+export class ValidMultipleValidator extends MultipleValidator {
+    constructor(validMultipleCallback, validators, value, target, event, autoValid = true) {
+        super(validators, value, target, event, autoValid);
+        this.validMultipleCallback = validMultipleCallback;
+        this.validators = validators;
+    }
+    valid() {
+        return this.validMultipleCallback(this.validators, this.value, this.getTarget(), this.getEvent());
+    }
+}
+//# sourceMappingURL=ValidMultipleValidator.js.map

package/validators/ValidValidator.d.ts

@@ -0,0 +1,7 @@
+import { Valid, Validator } from './Validator';
+export declare class ValidValidator<T = any, E = Element> extends Validator<T, E> {
+    validCallBack: Valid<T, E>;
+    constructor(validCallBack: Valid<T, E>, value?: T, target?: E, event?: Event, autoValid?: boolean);
+    valid(value?: T, target?: E, event?: Event): boolean;
+}
+//# sourceMappingURL=ValidValidator.d.ts.map

package/validators/ValidValidator.js

@@ -0,0 +1,11 @@
+import { Validator } from './Validator';
+export class ValidValidator extends Validator {
+    constructor(validCallBack, value, target, event, autoValid = true) {
+        super(value, target, event, autoValid);
+        this.validCallBack = validCallBack;
+    }
+    valid(value, target, event) {
+        return this.validCallBack(value, target, event);
+    }
+}
+//# sourceMappingURL=ValidValidator.js.map

package/validators/ValidValidatorArray.d.ts

@@ -0,0 +1,8 @@
+import { Valid, Validator } from './Validator';
+import { ValidatorArray } from './ValidatorArray';
+export declare class ValidValidatorArray<T = any, E = Element> extends ValidatorArray<T, E> {
+    validCallBack: Valid<Validator<T, E>[], E>;
+    constructor(validCallBack: Valid<Validator<T, E>[], E>, value?: Validator<T, E>[], target?: E, event?: Event, autoValid?: boolean);
+    valid(): boolean;
+}
+//# sourceMappingURL=ValidValidatorArray.d.ts.map

package/validators/ValidValidatorArray.js

@@ -0,0 +1,11 @@
+import { ValidatorArray } from './ValidatorArray';
+export class ValidValidatorArray extends ValidatorArray {
+    constructor(validCallBack, value, target, event, autoValid = true) {
+        super(value, target, event, autoValid);
+        this.validCallBack = validCallBack;
+    }
+    valid() {
+        return this.validCallBack(this.value, this.getTarget(), this.getEvent());
+    }
+}
+//# sourceMappingURL=ValidValidatorArray.js.map

package/validators/Validator.d.ts

@@ -0,0 +1,58 @@
+export type Valid<T = any, E = Element> = (value?: T, target?: E, event?: Event) => boolean;
+export type ValidAction<T = any, E = Element> = (valid: boolean, value?: T, target?: E, event?: Event) => void;
+export declare abstract class Validator<T = any, E = Element> {
+    protected _value?: T;
+    private _target?;
+    private _event?;
+    private _autoValid;
+    private _autoValidAction;
+    private _validAction?;
+    constructor(_value?: T, target?: E, event?: Event, autoValid?: boolean, autoValidAction?: boolean);
+    getValidAction(): ValidAction<T, E> | undefined;
+    setValidAction(value: ValidAction<T, E>): this;
+    getAutoValid(): boolean;
+    setAutoValid(autoValid: boolean): this;
+    getAutoValidAction(): boolean;
+    setAutoValidAction(autoValid: boolean): this;
+    getEvent(): Event;
+    setEvent(event: Event | undefined): this;
+    getTarget(): E;
+    targetFocus(): void;
+    targetReset(): void;
+    targetDispatchEvent(event: Event): any;
+    setTarget(target: E | undefined): this;
+    private domRenderFinal;
+    get value(): T | undefined;
+    set value(value: T | undefined);
+    protected tickValue(value: T | undefined): void;
+    set(value?: T, target?: E, event?: Event): void;
+    changeValue(value: T | undefined): void;
+    get checked(): boolean;
+    set checked(checked: boolean);
+    get selectedIndex(): number;
+    set selectedIndex(selectedIndex: number);
+    querySelector(selector: string): Element;
+    querySelectorALL(selector: string): NodeListOf<Element>;
+    validAction(): boolean;
+    abstract valid(): boolean;
+    inValid(): boolean;
+    allValid(): boolean;
+    allValidAction(): boolean;
+    allInValid(): boolean;
+    allInValidAction(): boolean;
+    childValid(): boolean;
+    childValue(): {
+        [key: string]: any;
+    };
+    childValidAction(): boolean;
+    childInValid(): boolean;
+    childInValidValidator(): [string, Validator<any, Element>][];
+    childInValidAction(): boolean;
+    childValidator(name: string): Validator | undefined;
+    childValidators(): [string, Validator][];
+    childValidValidator(): [string, Validator][];
+    syncValue(): void;
+    allSyncValue(): void;
+    get length(): any;
+}
+//# sourceMappingURL=Validator.d.ts.map