@dooboostore/dom-render 1.0.98

package/rawsets/RawSetOperatorType.d.ts

@@ -0,0 +1,4 @@
+export declare enum RawSetOperatorType {
+    DR_THIS_PROPERTY = "this-property"
+}
+//# sourceMappingURL=RawSetOperatorType.d.ts.map

package/rawsets/RawSetOperatorType.js

@@ -0,0 +1,5 @@
+export var RawSetOperatorType;
+(function (RawSetOperatorType) {
+    RawSetOperatorType["DR_THIS_PROPERTY"] = "this-property";
+})(RawSetOperatorType || (RawSetOperatorType = {}));
+//# sourceMappingURL=RawSetOperatorType.js.map

package/rawsets/RawSetType.d.ts

@@ -0,0 +1,8 @@
+export declare enum RawSetType {
+    TEXT = "TEXT",
+    STYLE_TEXT = "STYLE_TEXT",
+    TARGET_ELEMENT = "TARGET_ELEMENT",
+    TARGET_ATTR = "TARGET_ATTR",
+    UNKOWN = "UNKOWN"
+}
+//# sourceMappingURL=RawSetType.d.ts.map

package/rawsets/RawSetType.js

@@ -0,0 +1,9 @@
+export var RawSetType;
+(function (RawSetType) {
+    RawSetType["TEXT"] = "TEXT";
+    RawSetType["STYLE_TEXT"] = "STYLE_TEXT";
+    RawSetType["TARGET_ELEMENT"] = "TARGET_ELEMENT";
+    RawSetType["TARGET_ATTR"] = "TARGET_ATTR";
+    RawSetType["UNKOWN"] = "UNKOWN";
+})(RawSetType || (RawSetType = {}));
+//# sourceMappingURL=RawSetType.js.map

package/rawsets/Render.d.ts

@@ -0,0 +1,27 @@
+import { CreatorMetaData } from './CreatorMetaData';
+import { Router } from '../routers/Router';
+import { RawSet } from './RawSet';
+export type Render = {
+    rawSet?: RawSet;
+    scripts?: {
+        [n: string]: any;
+    };
+    bindScript?: string;
+    renderScript?: string;
+    element?: any;
+    getElement?: <T extends Element>() => T;
+    attribute?: any;
+    creatorMetaData?: CreatorMetaData;
+    router?: Router;
+    range?: any;
+    value?: any;
+    currentThis?: any;
+    currentThisPath?: any;
+    nearThisPath?: string;
+    nearThis?: any;
+    parentThisPath?: string;
+    parentThis?: any;
+    rootObject?: any;
+    [n: string]: any;
+};
+//# sourceMappingURL=Render.d.ts.map

package/rawsets/Render.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Render.js.map

package/routers/HashRouter.d.ts

@@ -0,0 +1,24 @@
+import { RouteAction, Router, RouterConfig } from './Router';
+export declare class HashRouter extends Router {
+    constructor(config: RouterConfig);
+    getSearchParams(data?: {
+        delete?: string[];
+        append?: [[string, string]];
+    }): URLSearchParams;
+    push(path: RouteAction, data?: any, title?: string): void;
+    replace(path: RouteAction, data?: any, title?: string): void;
+    setDeleteHashSearchParam(name: string, data?: any, title?: string): void;
+    pushDeleteHashSearchParam(name: string | string[], data: any, title: string | undefined): void;
+    pushDeleteSearchParam(name: string | string[], data?: any, title?: string): void;
+    pushAddSearchParam(params: [[string, string]], data?: any, title?: string): void;
+    replaceDeleteHashSearchParam(name: string | string[], data: any, title: string | undefined): void;
+    replaceDeleteSearchParam(name: string | string[], data?: any, title?: string): void;
+    replaceAddSearchParam(params: [[string, string]], data?: any, title?: string): void;
+    getUrl(): string;
+    getPath(): string;
+    getHashSearchParams(data?: {
+        delete?: string[];
+        append?: [[string, string]];
+    }): URLSearchParams;
+}
+//# sourceMappingURL=HashRouter.d.ts.map

package/routers/HashRouter.js

@@ -0,0 +1,86 @@
+import { Router } from './Router';
+import { LocationUtils } from '@dooboostore/core-web/location/LocationUtils';
+export class HashRouter extends Router {
+    constructor(config) {
+        super(config);
+    }
+    getSearchParams(data) {
+        var _a, _b;
+        const hashSearch = LocationUtils.hashSearch(this.config.window);
+        const searchParams = hashSearch ? new URLSearchParams(hashSearch) : (new URL(this.config.window.document.location.href)).searchParams;
+        (_a = data === null || data === void 0 ? void 0 : data.delete) === null || _a === void 0 ? void 0 : _a.forEach(it => {
+            searchParams.delete(it);
+        });
+        (_b = data === null || data === void 0 ? void 0 : data.append) === null || _b === void 0 ? void 0 : _b.forEach(it => {
+            searchParams.append(it[0], it[1]);
+        });
+        return searchParams;
+    }
+    push(path, data, title = '') {
+        if (path === '/') {
+            super.pushState(data, title, '/');
+        }
+        else {
+            super.pushState(data, title, `#${this.toUrl(path)}`);
+        }
+    }
+    replace(path, data, title) {
+        if (path === '/') {
+            super.replaceState(data, title, '/');
+        }
+        else {
+            super.replaceState(data, title, `#${this.toUrl(path)}`);
+        }
+    }
+    setDeleteHashSearchParam(name, data, title) {
+    }
+    pushDeleteHashSearchParam(name, data, title) {
+        const s = this.getHashSearchParams({ delete: Array.isArray(name) ? name : [name] });
+        const size = Array.from(s.entries()).length;
+        const href = `${this.config.window.location.pathname}${this.config.window.location.search}${size > 0 ? '#' + s.toString() : ''}`;
+        super.pushState(data, title, href);
+    }
+    pushDeleteSearchParam(name, data, title) {
+        const s = this.getSearchParams({ delete: Array.isArray(name) ? name : [name] });
+        this.push({ searchParams: s }, data, title);
+    }
+    pushAddSearchParam(params, data, title) {
+        const s = this.getSearchParams({ append: params });
+        this.push({ searchParams: s }, data, title);
+    }
+    replaceDeleteHashSearchParam(name, data, title) {
+        const s = this.getHashSearchParams({ delete: Array.isArray(name) ? name : [name] });
+        const size = Array.from(s.entries()).length;
+        const href = `${this.config.window.location.pathname}${this.config.window.location.search}${size > 0 ? '#' + s.toString() : ''}`;
+        super.pushState(data, title, href);
+    }
+    replaceDeleteSearchParam(name, data, title) {
+        const s = this.getSearchParams({ delete: Array.isArray(name) ? name : [name] });
+        this.push({ searchParams: s }, data, title);
+    }
+    replaceAddSearchParam(params, data, title) {
+        const s = this.getSearchParams({ append: params });
+        this.push({ searchParams: s }, data, title);
+    }
+    getUrl() {
+        return LocationUtils.hash(this.config.window) || '/';
+    }
+    getPath() {
+        return LocationUtils.hashPath(this.config.window) || '/';
+    }
+    getHashSearchParams(data) {
+        var _a, _b;
+        const hash = this.config.window.location.hash;
+        const queryIndex = hash.indexOf('?');
+        const searchParams = (queryIndex !== -1) ? new URLSearchParams(hash.slice(queryIndex + 1)) : new URLSearchParams();
+        ;
+        (_a = data === null || data === void 0 ? void 0 : data.delete) === null || _a === void 0 ? void 0 : _a.forEach(it => {
+            searchParams.delete(it);
+        });
+        (_b = data === null || data === void 0 ? void 0 : data.append) === null || _b === void 0 ? void 0 : _b.forEach(it => {
+            searchParams.append(it[0], it[1]);
+        });
+        return searchParams;
+    }
+}
+//# sourceMappingURL=HashRouter.js.map

package/routers/PathRouter.d.ts

@@ -0,0 +1,23 @@
+import { RouteAction, Router, RouterConfig } from './Router';
+export declare class PathRouter extends Router {
+    constructor(config: RouterConfig);
+    getSearchParams(data?: {
+        delete?: string[];
+        append?: [[string, string]];
+    }): URLSearchParams;
+    push(path: RouteAction, data?: any, title?: string): void;
+    replace(path: RouteAction, data?: any, title?: string): void;
+    pushDeleteSearchParam(name: string, data?: any, title?: string): void;
+    pushDeleteHashSearchParam(name: string, data?: any, title?: string): void;
+    pushAddSearchParam(params: [[string, string]], data?: any, title?: string): void;
+    replaceDeleteSearchParam(name: string | string[], data?: any, title?: string): void;
+    replaceDeleteHashSearchParam(name: string | string[], data?: any, title?: string): void;
+    replaceAddSearchParam(params: [[string, string]], data?: any, title?: string): void;
+    getUrl(): string;
+    getPath(): string;
+    getHashSearchParams(data?: {
+        delete?: string[];
+        append?: [[string, string]];
+    }): URLSearchParams;
+}
+//# sourceMappingURL=PathRouter.d.ts.map

package/routers/PathRouter.js

@@ -0,0 +1,73 @@
+import { Router } from './Router';
+export class PathRouter extends Router {
+    constructor(config) {
+        super(config);
+    }
+    getSearchParams(data) {
+        var _a, _b;
+        const searchParams = (new URL(this.config.window.document.location.href)).searchParams;
+        (_a = data === null || data === void 0 ? void 0 : data.delete) === null || _a === void 0 ? void 0 : _a.forEach(it => {
+            searchParams.delete(it);
+        });
+        (_b = data === null || data === void 0 ? void 0 : data.append) === null || _b === void 0 ? void 0 : _b.forEach(it => {
+            searchParams.append(it[0], it[1]);
+        });
+        return searchParams;
+    }
+    push(path, data, title = '') {
+        // console.log('pppppp?')
+        super.pushState(data, title, this.toUrl(path));
+    }
+    replace(path, data, title = '') {
+        super.replaceState(data, title, this.toUrl(path));
+    }
+    pushDeleteSearchParam(name, data, title) {
+        const s = this.getSearchParams({ delete: [name] });
+        this.push({ searchParams: s }, data, title);
+    }
+    pushDeleteHashSearchParam(name, data, title) {
+        const s = this.getHashSearchParams({ delete: [name] });
+        const size = Array.from(s.entries()).length;
+        const href = `${this.config.window.location.pathname}${this.config.window.location.search}${size > 0 ? '#' + s.toString() : ''}`;
+        super.pushState(data, title, href);
+    }
+    pushAddSearchParam(params, data, title) {
+        const s = this.getSearchParams({ append: params });
+        this.push({ searchParams: s }, data, title);
+    }
+    replaceDeleteSearchParam(name, data, title) {
+        const s = this.getSearchParams({ delete: Array.isArray(name) ? name : [name] });
+        this.replace({ searchParams: s }, data, title);
+    }
+    replaceDeleteHashSearchParam(name, data, title) {
+        const s = this.getHashSearchParams({ delete: Array.isArray(name) ? name : [name] });
+        const size = Array.from(s.entries()).length;
+        const href = `${this.config.window.location.pathname}${this.config.window.location.search}${size > 0 ? '#' + s.toString() : ''}`;
+        super.replaceState(data, title, href);
+    }
+    replaceAddSearchParam(params, data, title) {
+        const s = this.getSearchParams({ append: params });
+        this.replace({ searchParams: s }, data, title);
+    }
+    getUrl() {
+        const url = new URL(this.config.window.document.location.href);
+        return url.pathname + url.search;
+    }
+    getPath() {
+        return this.config.window.location.pathname;
+    }
+    getHashSearchParams(data) {
+        var _a, _b;
+        // http://local.com/#wow=222&wow=bb&z=2
+        const searchParams = new URLSearchParams(this.config.window.location.hash.slice(1));
+        (_a = data === null || data === void 0 ? void 0 : data.delete) === null || _a === void 0 ? void 0 : _a.forEach(it => {
+            searchParams.delete(it);
+        });
+        (_b = data === null || data === void 0 ? void 0 : data.append) === null || _b === void 0 ? void 0 : _b.forEach(it => {
+            searchParams.append(it[0], it[1]);
+        });
+        return searchParams;
+        // return undefined;
+    }
+}
+//# sourceMappingURL=PathRouter.js.map

package/routers/Router.d.ts

@@ -0,0 +1,68 @@
+import { ConvertUtils } from '@dooboostore/core/convert/ConvertUtils';
+import ToURLSearchParamsParams = ConvertUtils.ToURLSearchParamsParams;
+export type RouteData = {
+    path: string;
+    url: string;
+    data?: any;
+    searchParams: URLSearchParams;
+    pathData?: any;
+    router: Router;
+};
+export type RouterConfig<T = any> = {
+    rootObject?: T;
+    window: Window;
+    disableAttach?: boolean;
+};
+export type RouteAction = string | {
+    path?: string;
+    searchParams?: ToURLSearchParamsParams;
+};
+export declare abstract class Router<T = any> {
+    private changeCallbacks;
+    private _config;
+    get searchParamObject(): {
+        [key: string]: string | string[];
+    };
+    get config(): RouterConfig<T>;
+    constructor(config: RouterConfig<any>);
+    getSearchFirstParamsObject<T = any>(defaultValue?: T): T & import("@dooboostore/core/types").FieldType<T, string>;
+    getHashSearchFirstParamsObject<T = any>(): import("@dooboostore/core/types").FieldType<T, string>;
+    addChangeCallback(callback: (routeData: RouteData) => void): void;
+    attach(): Promise<void>;
+    testRegexp(regexp: string): boolean;
+    test(urlExpression: string): boolean;
+    getRouteData(urlExpression?: string): RouteData;
+    pushState(data: any, title: string, path: string): void;
+    replaceState(data: any, title: string, path: string): void;
+    dispatchPopStateEvent(): void;
+    reload(): void;
+    getData(): any;
+    getPathData(urlExpression: string, currentUrl?: string): any;
+    go(config: {
+        path: RouteAction;
+        data?: any;
+        replace?: boolean;
+        title?: string;
+        disabledPopEvent?: boolean;
+    } | string): Promise<void>;
+    toUrl(data: RouteAction): string;
+    abstract push(path: RouteAction, data?: any, title?: string): void;
+    abstract replace(path: RouteAction, data?: any, title?: string): void;
+    abstract pushDeleteSearchParam(name: string | string[], data?: any, title?: string): void;
+    abstract pushDeleteHashSearchParam(name: string | string[], data?: any, title?: string): void;
+    abstract pushAddSearchParam(params: [[string, string]], data?: any, title?: string): void;
+    abstract replaceDeleteSearchParam(name: string | string[], data?: any, title?: string): void;
+    abstract replaceDeleteHashSearchParam(name: string | string[], data?: any, title?: string): void;
+    abstract replaceAddSearchParam(params: [[string, string]], data?: any, title?: string): void;
+    abstract getSearchParams(data?: {
+        delete?: string[];
+        append?: [[string, string]];
+    }): URLSearchParams;
+    abstract getHashSearchParams(data?: {
+        delete?: string[];
+        append?: [[string, string]];
+    }): URLSearchParams;
+    abstract getUrl(): string;
+    abstract getPath(): string;
+}
+//# sourceMappingURL=Router.d.ts.map

package/routers/Router.js

@@ -0,0 +1,132 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { EventManager } from '../events/EventManager';
+import { ConvertUtils } from '@dooboostore/core/convert/ConvertUtils';
+import { Expression } from '@dooboostore/core/expression/Expression';
+export class Router {
+    get searchParamObject() {
+        return ConvertUtils.toObject(this.getSearchParams());
+    }
+    get config() {
+        return this._config;
+    }
+    constructor(config) {
+        this.changeCallbacks = new Set();
+        this._config = config;
+        this._config.window.addEventListener('popstate', () => {
+            this.changeCallbacks.forEach(it => {
+                it(this.getRouteData());
+            });
+        });
+        // this.go({path:this.getUrl()});
+    }
+    getSearchFirstParamsObject(defaultValue) {
+        const a = ConvertUtils.toObject(this.getSearchParams(), { firstValue: true });
+        return Object.assign({}, defaultValue, a);
+    }
+    getHashSearchFirstParamsObject() {
+        return ConvertUtils.toObject(this.getHashSearchParams(), { firstValue: true });
+    }
+    addChangeCallback(callback) {
+        this.changeCallbacks.add(callback);
+    }
+    attach() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const proxy = this.config.rootObject._DomRender_proxy;
+            if (proxy) {
+                const key = `___${EventManager.ROUTER_VARNAME}`;
+                yield proxy.render(key);
+            }
+        });
+    }
+    testRegexp(regexp) {
+        const b = RegExp(regexp).test(this.getPath());
+        return b;
+    }
+    test(urlExpression) {
+        if (this.getPathData(urlExpression)) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    getRouteData(urlExpression) {
+        const newVar = {
+            path: this.getPath(),
+            url: this.getUrl(),
+            searchParams: this.getSearchParams()
+        };
+        const data = this.getData();
+        if (data) {
+            newVar.data = data;
+        }
+        if (urlExpression) {
+            const data = this.getPathData(urlExpression);
+            if (data) {
+                newVar.pathData = data;
+            }
+        }
+        newVar.router = this;
+        return Object.freeze(newVar);
+    }
+    pushState(data, title, path) {
+        this.config.window.history.pushState(data, title, path);
+    }
+    replaceState(data, title, path) {
+        this.config.window.history.replaceState(data, title, path);
+    }
+    dispatchPopStateEvent() {
+        this.config.window.dispatchEvent(new Event('popstate'));
+    }
+    reload() {
+        this.config.window.dispatchEvent(new Event('popstate'));
+    }
+    getData() {
+        return this.config.window.history.state;
+    }
+    getPathData(urlExpression, currentUrl = this.getPath()) {
+        return Expression.Path.pathNameData(currentUrl, urlExpression);
+    }
+    go(config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (typeof config === 'string') {
+                config = { path: config };
+            }
+            if (config === null || config === void 0 ? void 0 : config.replace) {
+                this.replace(config.path, config.data, config.title);
+            }
+            else {
+                this.push(config.path, config.data, config.title);
+            }
+            if (!this.config.disableAttach) {
+                yield this.attach();
+            }
+            if (!config.disabledPopEvent) {
+                this.dispatchPopStateEvent();
+            }
+        });
+    }
+    toUrl(data) {
+        var _a;
+        let targetPath;
+        if (typeof data === 'string') {
+            targetPath = data;
+        }
+        else {
+            const tpath = (_a = data.path) !== null && _a !== void 0 ? _a : this.getPath();
+            const s = data.searchParams ? ConvertUtils.toURLSearchParams(data.searchParams).toString() : '';
+            // data.searchParams
+            targetPath = `${tpath}${s.length > 0 ? '?' : ''}${s}`;
+        }
+        return targetPath;
+    }
+}
+//# sourceMappingURL=Router.js.map

package/types/Types.d.ts

@@ -0,0 +1,12 @@
+export declare class Shield {
+    [name: string]: any;
+}
+export declare class DomRenderFinalProxy<T extends object> implements ProxyHandler<T> {
+    set(target: T, p: string | symbol, value: any, receiver: any): boolean;
+    get(target: T, p: string | symbol, receiver: any): any;
+    static final<T = any>(obj: T): T;
+    static isFinal<T = any>(obj: T): boolean;
+    static unFinal<T = any>(obj: T): T;
+    has(target: T, p: string | symbol): boolean;
+}
+//# sourceMappingURL=Types.d.ts.map

package/types/Types.js

@@ -0,0 +1,26 @@
+export class Shield {
+}
+export class DomRenderFinalProxy {
+    set(target, p, value, receiver) {
+        target[p] = value;
+        return true;
+    }
+    get(target, p, receiver) {
+        return target[p];
+    }
+    static final(obj) {
+        obj._DomRender_isFinal = true;
+        return obj;
+    }
+    static isFinal(obj) {
+        return '_DomRender_isFinal' in obj;
+    }
+    static unFinal(obj) {
+        delete obj._DomRender_isFinal;
+        return obj;
+    }
+    has(target, p) {
+        return p === '_DomRender_isFinal' || p in target;
+    }
+}
+//# sourceMappingURL=Types.js.map

package/validators/AllCheckedValidatorArray.d.ts

@@ -0,0 +1,7 @@
+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;
+}
+//# sourceMappingURL=AllCheckedValidatorArray.d.ts.map

package/validators/AllCheckedValidatorArray.js

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

package/validators/AllUnCheckedValidatorArray.d.ts

@@ -0,0 +1,7 @@
+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;
+}
+//# sourceMappingURL=AllUnCheckedValidatorArray.d.ts.map

package/validators/AllUnCheckedValidatorArray.js

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

package/validators/CheckedValidator.d.ts

@@ -0,0 +1,6 @@
+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;
+}
+//# sourceMappingURL=CheckedValidator.d.ts.map

package/validators/CheckedValidator.js

@@ -0,0 +1,11 @@
+import { Validator } from './Validator';
+export class CheckedValidator 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=CheckedValidator.js.map

package/validators/CountEqualsCheckedValidatorArray.d.ts

@@ -0,0 +1,8 @@
+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;
+}
+//# sourceMappingURL=CountEqualsCheckedValidatorArray.d.ts.map

package/validators/CountEqualsCheckedValidatorArray.js

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

package/validators/CountEqualsUnCheckedValidatorArray.d.ts

@@ -0,0 +1,8 @@
+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;
+}
+//# sourceMappingURL=CountEqualsUnCheckedValidatorArray.d.ts.map

package/validators/CountEqualsUnCheckedValidatorArray.js

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

package/validators/CountGreaterThanCheckedValidatorArray.d.ts

@@ -0,0 +1,8 @@
+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;
+}
+//# sourceMappingURL=CountGreaterThanCheckedValidatorArray.d.ts.map

package/validators/CountGreaterThanCheckedValidatorArray.js

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

package/validators/CountGreaterThanEqualsCheckedValidatorArray.d.ts

@@ -0,0 +1,8 @@
+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;
+}
+//# sourceMappingURL=CountGreaterThanEqualsCheckedValidatorArray.d.ts.map