dom-render 1.0.54 → 1.0.58

package/validators/ValidMultipleValidator.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 { MultipleValidator } from './MultipleValidator';
+var ValidMultipleValidator = (function (_super) {
+    __extends(ValidMultipleValidator, _super);
+    function ValidMultipleValidator(validMultipleCallback, validators, value, target, event, autoValid) {
+        if (autoValid === void 0) { autoValid = true; }
+        var _this = _super.call(this, validators, value, target, event, autoValid) || this;
+        _this.validMultipleCallback = validMultipleCallback;
+        _this.validators = validators;
+        return _this;
+    }
+    ValidMultipleValidator.prototype.valid = function () {
+        return this.validMultipleCallback(this.validators, this.value, this.getTarget(), this.getEvent());
+    };
+    return ValidMultipleValidator;
+}(MultipleValidator));
+export { ValidMultipleValidator };

package/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/validators/ValidValidator.js

@@ -0,0 +1,30 @@
+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 ValidValidator = (function (_super) {
+    __extends(ValidValidator, _super);
+    function ValidValidator(validCallBack, value, target, event, autoValid) {
+        if (autoValid === void 0) { autoValid = true; }
+        var _this = _super.call(this, value, target, event, autoValid) || this;
+        _this.validCallBack = validCallBack;
+        return _this;
+    }
+    ValidValidator.prototype.valid = function (value, target, event) {
+        return this.validCallBack(value, target, event);
+    };
+    return ValidValidator;
+}(Validator));
+export { ValidValidator };

package/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/validators/ValidValidatorArray.js

@@ -0,0 +1,30 @@
+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 ValidValidatorArray = (function (_super) {
+    __extends(ValidValidatorArray, _super);
+    function ValidValidatorArray(validCallBack, value, target, event, autoValid) {
+        if (autoValid === void 0) { autoValid = true; }
+        var _this = _super.call(this, value, target, event, autoValid) || this;
+        _this.validCallBack = validCallBack;
+        return _this;
+    }
+    ValidValidatorArray.prototype.valid = function () {
+        return this.validCallBack(this.value, this.getTarget(), this.getEvent());
+    };
+    return ValidValidatorArray;
+}(ValidatorArray));
+export { ValidValidatorArray };

package/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/validators/Validator.js

@@ -0,0 +1,146 @@
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+import { DomRenderProxy } from '../DomRenderProxy';
+var Validator = (function () {
+    function Validator(_value, target, event, autoValid) {
+        if (autoValid === void 0) { autoValid = true; }
+        this._value = _value;
+        this.setTarget(target);
+        this.setEvent(event);
+        this.setAutoValid(autoValid);
+    }
+    Validator.prototype.getAutoValid = function () {
+        return this._autoValid;
+    };
+    Validator.prototype.setAutoValid = function (autoValid) {
+        this._autoValid = autoValid;
+        return this;
+    };
+    Validator.prototype.getEvent = function () {
+        return this._event;
+    };
+    Validator.prototype.setEvent = function (event) {
+        if (event) {
+            this._event = DomRenderProxy.final(event);
+        }
+        return this;
+    };
+    Validator.prototype.getTarget = function () {
+        return this._target;
+    };
+    Validator.prototype.setTarget = function (target) {
+        if (target) {
+            this._target = DomRenderProxy.final(target);
+        }
+        return this;
+    };
+    Object.defineProperty(Validator.prototype, "value", {
+        get: function () {
+            var _a;
+            if (this._value === undefined || this._value === null) {
+                this._value = (_a = this.getTarget()) === null || _a === void 0 ? void 0 : _a.value;
+            }
+            return this._value;
+        },
+        set: function (value) {
+            this._value = value;
+            this.changeValue(value);
+            var target = this.getTarget();
+            if (target && (target === null || target === void 0 ? void 0 : target.value) !== undefined && (target === null || target === void 0 ? void 0 : target.value) !== null) {
+                target.value = this._value;
+            }
+            if (this.getAutoValid()) {
+                this.valid();
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Validator.prototype.set = function (value, target, event) {
+        this.value = value;
+        this.setTarget(target);
+        this.setEvent(event);
+    };
+    Validator.prototype.changeValue = function (value) {
+    };
+    Object.defineProperty(Validator.prototype, "checked", {
+        get: function () {
+            var _a, _b;
+            return (_b = (_a = this.getTarget()) === null || _a === void 0 ? void 0 : _a.checked) !== null && _b !== void 0 ? _b : false;
+        },
+        set: function (checked) {
+            var target = this.getTarget();
+            if (target) {
+                target.checked = checked;
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Validator.prototype, "selectedIndex", {
+        get: function () {
+            var _a, _b;
+            return (_b = (_a = this.getTarget()) === null || _a === void 0 ? void 0 : _a.selectedIndex) !== null && _b !== void 0 ? _b : -1;
+        },
+        set: function (selectedIndex) {
+            var target = this.getTarget();
+            if (target) {
+                target.selectedIndex = selectedIndex;
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Validator.prototype.querySelector = function (selector) {
+        var _a;
+        return (_a = this.getTarget()) === null || _a === void 0 ? void 0 : _a.querySelector(selector);
+    };
+    Validator.prototype.querySelectorALL = function (selector) {
+        var _a;
+        return (_a = this.getTarget()) === null || _a === void 0 ? void 0 : _a.querySelectorAll(selector);
+    };
+    Validator.prototype.inValid = function () {
+        return !this.valid();
+    };
+    ;
+    Validator.prototype.allValid = function () {
+        return this.valid() && this.childInValids();
+    };
+    Validator.prototype.allInValid = function () {
+        return !this.allValid();
+    };
+    Validator.prototype.childValids = function () {
+        return !this.childInValids();
+    };
+    Validator.prototype.childInValids = function () {
+        var inValid = Object.entries(this).filter(function (_a) {
+            var _b = __read(_a, 2), k = _b[0], v = _b[1];
+            return (v instanceof Validator) && !v.valid();
+        });
+        return inValid.length > 0;
+    };
+    Object.defineProperty(Validator.prototype, "length", {
+        get: function () {
+            var _a, _b;
+            return (_b = (_a = this.value) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return Validator;
+}());
+export { Validator };

package/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/validators/ValidatorArray.js

@@ -0,0 +1,94 @@
+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';
+import { NonPassValidator } from './NonPassValidator';
+var ValidatorArray = (function (_super) {
+    __extends(ValidatorArray, _super);
+    function ValidatorArray(value, target, event, autoValid) {
+        if (autoValid === void 0) { autoValid = true; }
+        var _this = _super.call(this, value, target, event, autoValid) || this;
+        _this._makeValidatorFactory = function (value, target, event) {
+            return new NonPassValidator(value, target, event);
+        };
+        return _this;
+    }
+    ValidatorArray.prototype.getMakeValidatorFactory = function () {
+        return this._makeValidatorFactory;
+    };
+    ValidatorArray.prototype.setMakeValidatorFactory = function (value) {
+        this._makeValidatorFactory = value;
+        return this;
+    };
+    ValidatorArray.prototype.setArrayValue = function (target, value, event) {
+        var _a;
+        (_a = this.value) === null || _a === void 0 ? void 0 : _a.filter(function (it) {
+            if (it.getTarget()) {
+                return it.getTarget() === target;
+            }
+            else {
+                return false;
+            }
+        }).forEach(function (it) {
+            it.set(value, target, event);
+        });
+    };
+    ValidatorArray.prototype.addValidator = function (value, target, event) {
+        var _a, _b;
+        if (!this.value) {
+            this.value = [];
+        }
+        if (value instanceof Validator) {
+            (_a = this.value) === null || _a === void 0 ? void 0 : _a.push(value);
+        }
+        else {
+            (_b = this.value) === null || _b === void 0 ? void 0 : _b.push(this.makeValidator(value, target, event));
+        }
+    };
+    ValidatorArray.prototype.allChecked = function (checked) {
+        var _a;
+        this.checked = checked;
+        (_a = this.value) === null || _a === void 0 ? void 0 : _a.forEach(function (it) {
+            it.checked = checked;
+        });
+    };
+    ValidatorArray.prototype.getValidators = function () {
+        return this._value;
+    };
+    ValidatorArray.prototype.getValidator = function (e) {
+        var _a;
+        return (_a = this.value) === null || _a === void 0 ? void 0 : _a.filter(function (it) { return it.getTarget() === e; })[0];
+    };
+    ValidatorArray.prototype.getValidatorByValue = function (value) {
+        var validatorByValue = this.getValidatorByValues(value)[0];
+        return validatorByValue;
+    };
+    ValidatorArray.prototype.getValidatorByValues = function (value) {
+        var _a, _b;
+        return (_b = (_a = this.value) === null || _a === void 0 ? void 0 : _a.filter(function (it) { return it.value === value; })) !== null && _b !== void 0 ? _b : [];
+    };
+    ValidatorArray.prototype.removeElement = function (e) {
+        var value = this.value;
+        if (value) {
+            this.value = value.filter(function (it) { return it.getTarget() !== e; });
+        }
+    };
+    ValidatorArray.prototype.makeValidator = function (value, target, event) {
+        return this._makeValidatorFactory(value, target, event);
+    };
+    ;
+    return ValidatorArray;
+}(Validator));
+export { ValidatorArray };

package/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/validators/ValueEqualsValidator.js

@@ -0,0 +1,30 @@
+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 ValueEqualsValidator = (function (_super) {
+    __extends(ValueEqualsValidator, _super);
+    function ValueEqualsValidator(equalsValue, value, target, event, autoValid) {
+        if (autoValid === void 0) { autoValid = true; }
+        var _this = _super.call(this, value, target, event, autoValid) || this;
+        _this.equalsValue = equalsValue;
+        return _this;
+    }
+    ValueEqualsValidator.prototype.valid = function () {
+        return this.value === this.equalsValue;
+    };
+    return ValueEqualsValidator;
+}(Validator));
+export { ValueEqualsValidator };

package/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/validators/ValueNotEqualsValidator.js

@@ -0,0 +1,30 @@
+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 ValueNotEqualsValidator = (function (_super) {
+    __extends(ValueNotEqualsValidator, _super);
+    function ValueNotEqualsValidator(equalsValue, value, target, event, autoValid) {
+        if (autoValid === void 0) { autoValid = true; }
+        var _this = _super.call(this, value, target, event, autoValid) || this;
+        _this.equalsValue = equalsValue;
+        return _this;
+    }
+    ValueNotEqualsValidator.prototype.valid = function () {
+        return this.value !== this.equalsValue;
+    };
+    return ValueNotEqualsValidator;
+}(Validator));
+export { ValueNotEqualsValidator };

package/dist/validations/Validation.d.ts

@@ -1,13 +0,0 @@
-export declare abstract class Validation<T = any, E = Element> {
-    protected _value?: T | undefined;
-    target?: E | undefined;
-    event?: Event | undefined;
-    constructor(_value?: T | undefined, target?: E | undefined, event?: Event | undefined);
-    get value(): T | undefined;
-    set value(value: T);
-    abstract valid(): boolean;
-    valids(): boolean;
-    inValids(): boolean;
-    get length(): any;
-    [name: string]: Validation | string | undefined | Element | any;
-}

package/dist/validations/Validations.d.ts

@@ -1,9 +0,0 @@
-import { Validation } from './Validation';
-export declare abstract class Validations<T = any, E = Element> extends Validation<Validation<T, E>[]> {
-    constructor(value?: Validation<T, E>[]);
-    get values(): Validation<T, E>[] | undefined;
-    setValue(target: E, value: T, event?: Event): void;
-    addValue(value: T, target: E, event?: Event): void;
-    removeElement(e: E): void;
-    makeValidation(value: T, target: E, event?: Event): Validation<T, E>;
-}

package/dist/validations/validators/RequiredValidator.d.ts

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

package/validations/Validation.d.ts

@@ -1,13 +0,0 @@
-export declare abstract class Validation<T = any, E = Element> {
-    protected _value?: T | undefined;
-    target?: E | undefined;
-    event?: Event | undefined;
-    constructor(_value?: T | undefined, target?: E | undefined, event?: Event | undefined);
-    get value(): T | undefined;
-    set value(value: T);
-    abstract valid(): boolean;
-    valids(): boolean;
-    inValids(): boolean;
-    get length(): any;
-    [name: string]: Validation | string | undefined | Element | any;
-}

package/validations/Validation.js

@@ -1,53 +0,0 @@
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var Validation = (function () {
-    function Validation(_value, target, event) {
-        this._value = _value;
-        this.target = target;
-        this.event = event;
-    }
-    Object.defineProperty(Validation.prototype, "value", {
-        get: function () {
-            return this._value;
-        },
-        set: function (value) {
-            this._value = value;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Validation.prototype.valids = function () {
-        return !this.inValids();
-    };
-    Validation.prototype.inValids = function () {
-        var inValid = Object.entries(this).filter(function (_a) {
-            var _b = __read(_a, 2), k = _b[0], v = _b[1];
-            return (v instanceof Validation) && !v.valid();
-        });
-        return inValid.length > 0;
-    };
-    Object.defineProperty(Validation.prototype, "length", {
-        get: function () {
-            var _a, _b;
-            return (_b = (_a = this.value) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return Validation;
-}());
-export { Validation };

package/validations/Validations.d.ts

@@ -1,9 +0,0 @@
-import { Validation } from './Validation';
-export declare abstract class Validations<T = any, E = Element> extends Validation<Validation<T, E>[]> {
-    constructor(value?: Validation<T, E>[]);
-    get values(): Validation<T, E>[] | undefined;
-    setValue(target: E, value: T, event?: Event): void;
-    addValue(value: T, target: E, event?: Event): void;
-    removeElement(e: E): void;
-    makeValidation(value: T, target: E, event?: Event): Validation<T, E>;
-}

package/validations/Validations.js

@@ -1,63 +0,0 @@
-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 { Validation } from './Validation';
-import { RequiredValidator } from './validators/RequiredValidator';
-var Validations = (function (_super) {
-    __extends(Validations, _super);
-    function Validations(value) {
-        return _super.call(this, value) || this;
-    }
-    Object.defineProperty(Validations.prototype, "values", {
-        get: function () {
-            return this._value;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Validations.prototype.setValue = function (target, value, event) {
-        var _a;
-        (_a = this.value) === null || _a === void 0 ? void 0 : _a.filter(function (it) {
-            return it.target === target || it.target._DomRender_origin === target;
-        }).forEach(function (it) {
-            it.value = value;
-            it.event = event;
-        });
-    };
-    Validations.prototype.addValue = function (value, target, event) {
-        var _a, _b;
-        console.log('validations --> ', value, target, event);
-        if (!this.value) {
-            this.value = [];
-        }
-        if (value instanceof Validation) {
-            (_a = this.value) === null || _a === void 0 ? void 0 : _a.push(value);
-        }
-        else {
-            (_b = this.value) === null || _b === void 0 ? void 0 : _b.push(this.makeValidation(value, target, event));
-        }
-    };
-    Validations.prototype.removeElement = function (e) {
-        if (this.value) {
-            this.value = this.value.filter(function (it) { return it.target !== e; });
-        }
-    };
-    Validations.prototype.makeValidation = function (value, target, event) {
-        return new RequiredValidator(value, target, event);
-    };
-    ;
-    return Validations;
-}(Validation));
-export { Validations };

package/validations/validators/RequiredValidator.d.ts

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