dom-render 1.0.54 → 1.0.58

package/dist/validators/PassValidator.d.ts

@@ -0,0 +1,5 @@
+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;
+}

package/dist/validators/RegExpTestValidator.d.ts

@@ -0,0 +1,6 @@
+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;
+}

package/dist/validators/RequiredValidator.d.ts

@@ -0,0 +1,5 @@
+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;
+}

package/dist/validators/UnCheckedValidator.d.ts

@@ -0,0 +1,5 @@
+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;
+}

package/dist/validators/ValidMultipleValidator.d.ts

@@ -0,0 +1,9 @@
+import { Validator } from './Validator';
+import { MultipleValidator } from './MultipleValidator';
+export declare 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;
+}

package/dist/validators/ValidValidator.d.ts

@@ -0,0 +1,6 @@
+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;
+}

package/dist/validators/ValidValidatorArray.d.ts

@@ -0,0 +1,7 @@
+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;
+}

package/dist/validators/Validator.d.ts

@@ -0,0 +1,31 @@
+export declare type Valid<T = any, E = Element> = (value?: T, target?: E, event?: Event) => boolean;
+export declare abstract class Validator<T = any, E = Element> {
+    protected _value?: T | undefined;
+    private _target?;
+    private _event?;
+    private _autoValid;
+    constructor(_value?: T | undefined, target?: E, event?: Event, autoValid?: boolean);
+    getAutoValid(): boolean;
+    setAutoValid(autoValid: boolean): this;
+    getEvent(): Event | undefined;
+    setEvent(event: Event | undefined): this;
+    getTarget(): E | undefined;
+    setTarget(target: E | undefined): this;
+    get value(): T | undefined;
+    set value(value: T | undefined);
+    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 | null;
+    querySelectorALL(selector: string): NodeListOf<Element>;
+    abstract valid(): boolean;
+    inValid(): boolean;
+    allValid(): boolean;
+    allInValid(): boolean;
+    childValids(): boolean;
+    childInValids(): boolean;
+    get length(): any;
+}

package/dist/validators/ValidatorArray.d.ts

@@ -0,0 +1,17 @@
+import { Validator } from './Validator';
+export declare type MakeValidator<T = any, E = Element> = (value: T, target: E, event?: Event) => Validator<T, E>;
+export declare abstract class ValidatorArray<T = any, E = Element> extends Validator<Validator<T, E>[], E> {
+    private _makeValidatorFactory;
+    constructor(value?: Validator<T, E>[], target?: E, event?: Event, autoValid?: boolean);
+    getMakeValidatorFactory(): MakeValidator<T, E>;
+    setMakeValidatorFactory(value: MakeValidator<T, E>): this;
+    setArrayValue(target: E, value: T, event?: Event): void;
+    addValidator(value: T, target: E, event?: Event): void;
+    allChecked(checked: boolean): void;
+    getValidators(): Validator<T, E>[] | undefined;
+    getValidator(e: E): Validator<T, E> | undefined;
+    getValidatorByValue(value: T): Validator<T, E>;
+    getValidatorByValues(value: T): Validator<T, E>[];
+    removeElement(e: E): void;
+    makeValidator(value: T, target: E, event?: Event): Validator<T, E>;
+}

package/dist/validators/ValueEqualsValidator.d.ts

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

package/dist/validators/ValueNotEqualsValidator.d.ts

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

package/events/EventManager.js

@@ -104,7 +104,6 @@ export var eventManager = new (function () {
         });
         this.procAttr(childNodes, this.attrPrefix + 'value-link', function (it, varName) {
             if (varName) {
-                console.log('--value-link-->', _this.getValue(obj, varName), 'value->', it.value);
                 var value = _this.getValue(obj, varName);
                 if (typeof value === 'function' && value) {
                     value(it.value);
@@ -118,7 +117,6 @@ export var eventManager = new (function () {
                     }
                 }
                 it.addEventListener('input', function (eit) {
-                    console.log('input change--->link', eit.target.value);
                     if (typeof _this.getValue(obj, varName) === 'function') {
                         _this.getValue(obj, varName)(it.value, eit);
                     }

package/iterators/Range.d.ts

@@ -19,4 +19,5 @@ export declare class Range implements Iterable<number> {
     constructor(first: number, last: number, step?: number);
     [Symbol.iterator](): Iterator<number>;
     static range(first: number | string, last?: number, step?: number): Range;
+    toArray(): number[];
 }

package/iterators/Range.js

@@ -14,6 +14,15 @@ var __read = (this && this.__read) || function (o, n) {
     }
     return ar;
 };
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 var RangeResult = (function () {
     function RangeResult(value, done) {
         this.done = done;
@@ -71,6 +80,9 @@ var Range = (function () {
             return new Range(first, last !== null && last !== void 0 ? last : 0, step);
         }
     };
+    Range.prototype.toArray = function () {
+        return __spreadArray([], __read(this), false);
+    };
     return Range;
 }());
 export { Range };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dom-render",
-  "version": "1.0.54",
+  "version": "1.0.58",
   "main": "DomRender.js",
   "license": "MIT",
   "description": "dom-render",

package/validators/AllCheckedValidatorArray.d.ts

@@ -0,0 +1,6 @@
+import { Validator } from './Validator';
+import { ValidatorArray } from './ValidatorArray';
+export declare class AllCheckedValidatorArray<T = any, E = Element> extends ValidatorArray<T, E> {
+    constructor(value?: Validator<T, E>[], target?: E, event?: Event, autoValid?: boolean);
+    valid(): boolean;
+}

package/validators/AllCheckedValidatorArray.js

@@ -0,0 +1,29 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import { ValidatorArray } from './ValidatorArray';
+var AllCheckedValidatorArray = (function (_super) {
+    __extends(AllCheckedValidatorArray, _super);
+    function AllCheckedValidatorArray(value, target, event, autoValid) {
+        if (autoValid === void 0) { autoValid = true; }
+        return _super.call(this, value, target, event, autoValid) || this;
+    }
+    AllCheckedValidatorArray.prototype.valid = function () {
+        var _a;
+        return !(((_a = this.value) !== null && _a !== void 0 ? _a : []).filter(function (it) { return !it.checked; }).length > 0);
+    };
+    return AllCheckedValidatorArray;
+}(ValidatorArray));
+export { AllCheckedValidatorArray };

package/validators/AllUnCheckedValidatorArray.d.ts

@@ -0,0 +1,6 @@
+import { Validator } from './Validator';
+import { ValidatorArray } from './ValidatorArray';
+export declare class AllUnCheckedValidatorArray<T = any, E = Element> extends ValidatorArray<T, E> {
+    constructor(value?: Validator<T, E>[], target?: E, event?: Event, autoValid?: boolean);
+    valid(): boolean;
+}

package/validators/AllUnCheckedValidatorArray.js

@@ -0,0 +1,29 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import { ValidatorArray } from './ValidatorArray';
+var AllUnCheckedValidatorArray = (function (_super) {
+    __extends(AllUnCheckedValidatorArray, _super);
+    function AllUnCheckedValidatorArray(value, target, event, autoValid) {
+        if (autoValid === void 0) { autoValid = true; }
+        return _super.call(this, value, target, event, autoValid) || this;
+    }
+    AllUnCheckedValidatorArray.prototype.valid = function () {
+        var _a;
+        return !(((_a = this.value) !== null && _a !== void 0 ? _a : []).filter(function (it) { return it.checked; }).length > 0);
+    };
+    return AllUnCheckedValidatorArray;
+}(ValidatorArray));
+export { AllUnCheckedValidatorArray };

package/validators/CheckedValidator.d.ts

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

package/validators/CheckedValidator.js

@@ -0,0 +1,29 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import { Validator } from './Validator';
+var CheckedValidator = (function (_super) {
+    __extends(CheckedValidator, _super);
+    function CheckedValidator(value, target, event, autoValid) {
+        if (autoValid === void 0) { autoValid = true; }
+        return _super.call(this, value, target, event, autoValid) || this;
+    }
+    CheckedValidator.prototype.valid = function () {
+        var _a, _b;
+        return (_b = (_a = this.getTarget()) === null || _a === void 0 ? void 0 : _a.checked) !== null && _b !== void 0 ? _b : false;
+    };
+    return CheckedValidator;
+}(Validator));
+export { CheckedValidator };

package/validators/CountEqualsCheckedValidatorArray.d.ts

@@ -0,0 +1,7 @@
+import { Validator } from './Validator';
+import { ValidatorArray } from './ValidatorArray';
+export declare class CountEqualsCheckedValidatorArray<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;
+}

package/validators/CountEqualsCheckedValidatorArray.js

@@ -0,0 +1,31 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import { ValidatorArray } from './ValidatorArray';
+var CountEqualsCheckedValidatorArray = (function (_super) {
+    __extends(CountEqualsCheckedValidatorArray, _super);
+    function CountEqualsCheckedValidatorArray(count, value, target, event, autoValid) {
+        if (autoValid === void 0) { autoValid = true; }
+        var _this = _super.call(this, value, target, event, autoValid) || this;
+        _this.count = count;
+        return _this;
+    }
+    CountEqualsCheckedValidatorArray.prototype.valid = function () {
+        var _a;
+        return ((_a = this.value) !== null && _a !== void 0 ? _a : []).filter(function (it) { return it.checked; }).length === this.count;
+    };
+    return CountEqualsCheckedValidatorArray;
+}(ValidatorArray));
+export { CountEqualsCheckedValidatorArray };

package/validators/CountEqualsUnCheckedValidatorArray.d.ts

@@ -0,0 +1,7 @@
+import { Validator } from './Validator';
+import { ValidatorArray } from './ValidatorArray';
+export declare class CountEqualsUnCheckedValidatorArray<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;
+}

package/validators/CountEqualsUnCheckedValidatorArray.js

@@ -0,0 +1,31 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import { ValidatorArray } from './ValidatorArray';
+var CountEqualsUnCheckedValidatorArray = (function (_super) {
+    __extends(CountEqualsUnCheckedValidatorArray, _super);
+    function CountEqualsUnCheckedValidatorArray(count, value, target, event, autoValid) {
+        if (autoValid === void 0) { autoValid = true; }
+        var _this = _super.call(this, value, target, event, autoValid) || this;
+        _this.count = count;
+        return _this;
+    }
+    CountEqualsUnCheckedValidatorArray.prototype.valid = function () {
+        var _a;
+        return ((_a = this.value) !== null && _a !== void 0 ? _a : []).filter(function (it) { return !it.checked; }).length === this.count;
+    };
+    return CountEqualsUnCheckedValidatorArray;
+}(ValidatorArray));
+export { CountEqualsUnCheckedValidatorArray };

package/validators/CountGreaterThanCheckedValidatorArray.d.ts

@@ -0,0 +1,7 @@
+import { Validator } from './Validator';
+import { ValidatorArray } from './ValidatorArray';
+export declare class CountGreaterThanCheckedValidatorArray<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;
+}

package/validators/CountGreaterThanCheckedValidatorArray.js

@@ -0,0 +1,31 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import { ValidatorArray } from './ValidatorArray';
+var CountGreaterThanCheckedValidatorArray = (function (_super) {
+    __extends(CountGreaterThanCheckedValidatorArray, _super);
+    function CountGreaterThanCheckedValidatorArray(count, value, target, event, autoValid) {
+        if (autoValid === void 0) { autoValid = true; }
+        var _this = _super.call(this, value, target, event, autoValid) || this;
+        _this.count = count;
+        return _this;
+    }
+    CountGreaterThanCheckedValidatorArray.prototype.valid = function () {
+        var _a;
+        return ((_a = this.value) !== null && _a !== void 0 ? _a : []).filter(function (it) { return it.checked; }).length > this.count;
+    };
+    return CountGreaterThanCheckedValidatorArray;
+}(ValidatorArray));
+export { CountGreaterThanCheckedValidatorArray };

package/validators/CountGreaterThanEqualsCheckedValidatorArray.d.ts

@@ -0,0 +1,7 @@
+import { Validator } from './Validator';
+import { ValidatorArray } from './ValidatorArray';
+export declare class CountGreaterThanEqualsCheckedValidatorArray<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;
+}

package/validators/CountGreaterThanEqualsCheckedValidatorArray.js

@@ -0,0 +1,31 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import { ValidatorArray } from './ValidatorArray';
+var CountGreaterThanEqualsCheckedValidatorArray = (function (_super) {
+    __extends(CountGreaterThanEqualsCheckedValidatorArray, _super);
+    function CountGreaterThanEqualsCheckedValidatorArray(count, value, target, event, autoValid) {
+        if (autoValid === void 0) { autoValid = true; }
+        var _this = _super.call(this, value, target, event, autoValid) || this;
+        _this.count = count;
+        return _this;
+    }
+    CountGreaterThanEqualsCheckedValidatorArray.prototype.valid = function () {
+        var _a;
+        return ((_a = this.value) !== null && _a !== void 0 ? _a : []).filter(function (it) { return it.checked; }).length >= this.count;
+    };
+    return CountGreaterThanEqualsCheckedValidatorArray;
+}(ValidatorArray));
+export { CountGreaterThanEqualsCheckedValidatorArray };

package/validators/CountGreaterThanEqualsUnCheckedValidatorArray.d.ts

@@ -0,0 +1,7 @@
+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;
+}

package/validators/CountGreaterThanEqualsUnCheckedValidatorArray.js

@@ -0,0 +1,31 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import { ValidatorArray } from './ValidatorArray';
+var CountGreaterThanEqualsUnCheckedValidatorArray = (function (_super) {
+    __extends(CountGreaterThanEqualsUnCheckedValidatorArray, _super);
+    function CountGreaterThanEqualsUnCheckedValidatorArray(count, value, target, event, autoValid) {
+        if (autoValid === void 0) { autoValid = true; }
+        var _this = _super.call(this, value, target, event, autoValid) || this;
+        _this.count = count;
+        return _this;
+    }
+    CountGreaterThanEqualsUnCheckedValidatorArray.prototype.valid = function () {
+        var _a;
+        return ((_a = this.value) !== null && _a !== void 0 ? _a : []).filter(function (it) { return !it.checked; }).length >= this.count;
+    };
+    return CountGreaterThanEqualsUnCheckedValidatorArray;
+}(ValidatorArray));
+export { CountGreaterThanEqualsUnCheckedValidatorArray };

package/validators/CountGreaterThanUnCheckedValidatorArray.d.ts

@@ -0,0 +1,7 @@
+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;
+}

package/validators/CountGreaterThanUnCheckedValidatorArray.js

@@ -0,0 +1,31 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import { ValidatorArray } from './ValidatorArray';
+var CountGreaterThanUnCheckedValidatorArray = (function (_super) {
+    __extends(CountGreaterThanUnCheckedValidatorArray, _super);
+    function CountGreaterThanUnCheckedValidatorArray(count, value, target, event, autoValid) {
+        if (autoValid === void 0) { autoValid = true; }
+        var _this = _super.call(this, value, target, event, autoValid) || this;
+        _this.count = count;
+        return _this;
+    }
+    CountGreaterThanUnCheckedValidatorArray.prototype.valid = function () {
+        var _a;
+        return ((_a = this.value) !== null && _a !== void 0 ? _a : []).filter(function (it) { return !it.checked; }).length > this.count;
+    };
+    return CountGreaterThanUnCheckedValidatorArray;
+}(ValidatorArray));
+export { CountGreaterThanUnCheckedValidatorArray };

package/validators/CountLessThanCheckedValidatorArray.d.ts

@@ -0,0 +1,7 @@
+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;
+}

package/validators/CountLessThanCheckedValidatorArray.js

@@ -0,0 +1,31 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import { ValidatorArray } from './ValidatorArray';
+var CountLessThanCheckedValidatorArray = (function (_super) {
+    __extends(CountLessThanCheckedValidatorArray, _super);
+    function CountLessThanCheckedValidatorArray(count, value, target, event, autoValid) {
+        if (autoValid === void 0) { autoValid = true; }
+        var _this = _super.call(this, value, target, event, autoValid) || this;
+        _this.count = count;
+        return _this;
+    }
+    CountLessThanCheckedValidatorArray.prototype.valid = function () {
+        var _a;
+        return ((_a = this.value) !== null && _a !== void 0 ? _a : []).filter(function (it) { return it.checked; }).length < this.count;
+    };
+    return CountLessThanCheckedValidatorArray;
+}(ValidatorArray));
+export { CountLessThanCheckedValidatorArray };

package/validators/CountLessThanEqualsCheckedValidatorArray.d.ts

@@ -0,0 +1,7 @@
+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;
+}

package/validators/CountLessThanEqualsCheckedValidatorArray.js

@@ -0,0 +1,31 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import { ValidatorArray } from './ValidatorArray';
+var CountLessThanEqualsCheckedValidatorArray = (function (_super) {
+    __extends(CountLessThanEqualsCheckedValidatorArray, _super);
+    function CountLessThanEqualsCheckedValidatorArray(count, value, target, event, autoValid) {
+        if (autoValid === void 0) { autoValid = true; }
+        var _this = _super.call(this, value, target, event, autoValid) || this;
+        _this.count = count;
+        return _this;
+    }
+    CountLessThanEqualsCheckedValidatorArray.prototype.valid = function () {
+        var _a;
+        return ((_a = this.value) !== null && _a !== void 0 ? _a : []).filter(function (it) { return it.checked; }).length <= this.count;
+    };
+    return CountLessThanEqualsCheckedValidatorArray;
+}(ValidatorArray));
+export { CountLessThanEqualsCheckedValidatorArray };

package/validators/CountLessThanEqualsUnCheckedValidatorArray.d.ts

@@ -0,0 +1,7 @@
+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;
+}