@dooboostore/dom-render 1.0.98

package/validators/Validator.js

@@ -0,0 +1,203 @@
+// export interface Valid<T = any, E = Element> {
+//     valid(value?: T, target?: E, event?: Event): boolean;
+// }
+export class Validator {
+    constructor(_value, target, event, autoValid = true, autoValidAction = true) {
+        this._value = _value;
+        this.setTarget(target);
+        this.setEvent(event);
+        this.setAutoValid(autoValid);
+        this.setAutoValidAction(autoValidAction);
+    }
+    getValidAction() {
+        return this._validAction;
+    }
+    setValidAction(value) {
+        this._validAction = value;
+        return this;
+    }
+    getAutoValid() {
+        return this._autoValid;
+    }
+    setAutoValid(autoValid) {
+        this._autoValid = autoValid;
+        return this;
+    }
+    getAutoValidAction() {
+        return this._autoValidAction;
+    }
+    setAutoValidAction(autoValid) {
+        this._autoValidAction = autoValid;
+        return this;
+    }
+    getEvent() {
+        return this._event;
+    }
+    setEvent(event) {
+        if (event) {
+            this._event = this.domRenderFinal(event);
+        }
+        return this;
+    }
+    getTarget() {
+        return this._target;
+    }
+    targetFocus() {
+        var _a, _b;
+        (_b = (_a = this._target) === null || _a === void 0 ? void 0 : _a.focus) === null || _b === void 0 ? void 0 : _b.call(_a);
+    }
+    targetReset() {
+        var _a, _b;
+        (_b = (_a = this._target) === null || _a === void 0 ? void 0 : _a.reset) === null || _b === void 0 ? void 0 : _b.call(_a);
+    }
+    targetDispatchEvent(event) {
+        var _a;
+        return (_a = this._target) === null || _a === void 0 ? void 0 : _a.dispatchEvent(event);
+    }
+    setTarget(target) {
+        if (target) {
+            this._target = this.domRenderFinal(target);
+        }
+        return this;
+    }
+    domRenderFinal(obj) {
+        obj._DomRender_isFinal = true;
+        return obj;
+    }
+    get value() {
+        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 value(value) {
+        // console.log('---?set?', value, this)
+        this._value = value;
+        this.tickValue(value);
+    }
+    tickValue(value) {
+        this.changeValue(value);
+        const 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) {
+            try {
+                target.value = this._value;
+            }
+            catch (e) {
+                console.error('set value function is blocked ');
+            }
+        }
+        if (this.getAutoValidAction()) {
+            this.validAction();
+        }
+        else if (this.getAutoValid()) {
+            this.valid();
+        }
+    }
+    set(value, target, event) {
+        this.setTarget(target);
+        this.setEvent(event);
+        this.value = value;
+    }
+    changeValue(value) {
+    }
+    get checked() {
+        var _a, _b;
+        return (_b = (_a = this.getTarget()) === null || _a === void 0 ? void 0 : _a.checked) !== null && _b !== void 0 ? _b : false;
+    }
+    set checked(checked) {
+        const target = this.getTarget();
+        if (target) {
+            target.checked = checked;
+        }
+    }
+    get selectedIndex() {
+        var _a, _b;
+        return (_b = (_a = this.getTarget()) === null || _a === void 0 ? void 0 : _a.selectedIndex) !== null && _b !== void 0 ? _b : -1;
+    }
+    set selectedIndex(selectedIndex) {
+        const target = this.getTarget();
+        if (target) {
+            target.selectedIndex = selectedIndex;
+        }
+    }
+    querySelector(selector) {
+        var _a;
+        return (_a = this.getTarget()) === null || _a === void 0 ? void 0 : _a.querySelector(selector);
+    }
+    querySelectorALL(selector) {
+        var _a;
+        return (_a = this.getTarget()) === null || _a === void 0 ? void 0 : _a.querySelectorAll(selector);
+    }
+    validAction() {
+        var _a;
+        const valid = this.valid();
+        (_a = this.getValidAction()) === null || _a === void 0 ? void 0 : _a(valid, this.value, this.getTarget(), this.getEvent());
+        return valid;
+    }
+    inValid() {
+        return !this.valid();
+    }
+    ;
+    allValid() {
+        return this.valid() && this.childInValid();
+    }
+    allValidAction() {
+        return this.validAction() && this.childInValidAction();
+    }
+    allInValid() {
+        return !this.allValid();
+    }
+    allInValidAction() {
+        return !this.allValidAction();
+    }
+    childValid() {
+        return !this.childInValid();
+    }
+    childValue() {
+        const data = {};
+        this.childValidators().filter(([k, v]) => {
+            data[k] = v.value;
+        });
+        return data;
+    }
+    childValidAction() {
+        return !this.childInValidAction();
+    }
+    childInValid() {
+        const inValid = this.childValidators().filter(([k, v]) => !v.valid());
+        return inValid.length > 0;
+    }
+    childInValidValidator() {
+        const inValid = this.childValidators().filter(([k, v]) => !v.valid());
+        return inValid;
+    }
+    childInValidAction() {
+        const inValid = this.childValidators().filter(([k, v]) => !v.validAction());
+        return inValid.length > 0;
+    }
+    childValidator(name) {
+        var _a;
+        return (_a = Object.entries(this).find(([k, v]) => (k === name && (v instanceof Validator)))) === null || _a === void 0 ? void 0 : _a[1];
+    }
+    childValidators() {
+        return Object.entries(this).filter(([k, v]) => (v instanceof Validator));
+    }
+    childValidValidator() {
+        return this.childValidators().filter(it => it[1].valid());
+    }
+    syncValue() {
+        var _a;
+        this.value = (_a = this.getTarget()) === null || _a === void 0 ? void 0 : _a.value;
+    }
+    allSyncValue() {
+        this.childValidators().forEach(([k, e]) => {
+            e.syncValue();
+        });
+    }
+    get length() {
+        var _a, _b;
+        return (_b = (_a = this.value) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0;
+    }
+}
+//# sourceMappingURL=Validator.js.map

package/validators/ValidatorArray.d.ts

@@ -0,0 +1,18 @@
+import { Validator } from './Validator';
+export 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>[];
+    getValidator(e: E): Validator<T, E>;
+    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>;
+}
+//# sourceMappingURL=ValidatorArray.d.ts.map

package/validators/ValidatorArray.js

@@ -0,0 +1,77 @@
+import { Validator } from './Validator';
+import { NonPassValidator } from './NonPassValidator';
+export class ValidatorArray extends Validator {
+    constructor(value, target, event, autoValid = true) {
+        super(value, target, event, autoValid);
+        this._makeValidatorFactory = (value, target, event) => {
+            return new NonPassValidator(value, target, event);
+        };
+    }
+    getMakeValidatorFactory() {
+        return this._makeValidatorFactory;
+    }
+    setMakeValidatorFactory(value) {
+        this._makeValidatorFactory = value;
+        return this;
+    }
+    setArrayValue(target, value, event) {
+        var _a;
+        (_a = this.value) === null || _a === void 0 ? void 0 : _a.filter(it => {
+            if (it.getTarget()) {
+                return it.getTarget() === target;
+            }
+            else {
+                return false;
+            }
+        }).forEach(it => {
+            it.set(value, target, event);
+        });
+        this.tickValue(this.value);
+    }
+    addValidator(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));
+        }
+        this.tickValue(this.value);
+    }
+    allChecked(checked) {
+        var _a;
+        this.checked = checked;
+        (_a = this.value) === null || _a === void 0 ? void 0 : _a.forEach(it => {
+            it.checked = checked;
+        });
+    }
+    getValidators() {
+        return this._value;
+    }
+    getValidator(e) {
+        var _a;
+        return (_a = this.value) === null || _a === void 0 ? void 0 : _a.filter(it => it.getTarget() === e)[0];
+    }
+    getValidatorByValue(value) {
+        const validatorByValue = this.getValidatorByValues(value)[0];
+        return validatorByValue;
+    }
+    getValidatorByValues(value) {
+        var _a, _b;
+        return (_b = (_a = this.value) === null || _a === void 0 ? void 0 : _a.filter(it => it.value === value)) !== null && _b !== void 0 ? _b : [];
+    }
+    removeElement(e) {
+        const value = this.value;
+        if (value) {
+            this.value = value.filter(it => it.getTarget() !== e);
+        }
+    }
+    makeValidator(value, target, event) {
+        return this._makeValidatorFactory(value, target, event);
+    }
+    ;
+}
+//# sourceMappingURL=ValidatorArray.js.map

package/validators/ValueEqualsValidator.d.ts

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

package/validators/ValueEqualsValidator.js

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

package/validators/ValueNotEqualsValidator.d.ts

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

package/validators/ValueNotEqualsValidator.js

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