@dooboostore/dom-render 1.0.112 → 1.0.113

package/src/validators/CountGreaterThanUnCheckedValidatorArray.ts

@@ -1,12 +0,0 @@
-import {Validator} from './Validator';
-import {ValidatorArray} from './ValidatorArray';
-
-export class CountGreaterThanUnCheckedValidatorArray<T = any, E = Element> extends ValidatorArray<T, E> {
-    constructor(public count: number, value?: Validator<T, E>[], target?: E, event?: Event, autoValid = true) {
-        super(value, target, event, autoValid);
-    }
-
-    valid(): boolean {
-        return (this.value ?? []).filter(it => !it.checked).length > this.count;
-    }
-}

package/src/validators/CountLessThanCheckedValidatorArray.ts

@@ -1,12 +0,0 @@
-import {Validator} from './Validator';
-import {ValidatorArray} from './ValidatorArray';
-
-export class CountLessThanCheckedValidatorArray<T = any, E = Element> extends ValidatorArray<T, E> {
-    constructor(public count: number, value?: Validator<T, E>[], target?: E, event?: Event, autoValid = true) {
-        super(value, target, event, autoValid);
-    }
-
-    valid(): boolean {
-        return (this.value ?? []).filter(it => it.checked).length < this.count;
-    }
-}

package/src/validators/CountLessThanEqualsCheckedValidatorArray.ts

@@ -1,12 +0,0 @@
-import {Validator} from './Validator';
-import {ValidatorArray} from './ValidatorArray';
-
-export class CountLessThanEqualsCheckedValidatorArray<T = any, E = Element> extends ValidatorArray<T, E> {
-    constructor(public count: number, value?: Validator<T, E>[], target?: E, event?: Event, autoValid = true) {
-        super(value, target, event, autoValid);
-    }
-
-    valid(): boolean {
-        return (this.value ?? []).filter(it => it.checked).length <= this.count;
-    }
-}

package/src/validators/CountLessThanEqualsUnCheckedValidatorArray.ts

@@ -1,12 +0,0 @@
-import {Validator} from './Validator';
-import {ValidatorArray} from './ValidatorArray';
-
-export class CountLessThanEqualsUnCheckedValidatorArray<T = any, E = Element> extends ValidatorArray<T, E> {
-    constructor(public count: number, value?: Validator<T, E>[], target?: E, event?: Event, autoValid = true) {
-        super(value, target, event, autoValid);
-    }
-
-    valid(): boolean {
-        return (this.value ?? []).filter(it => !it.checked).length <= this.count;
-    }
-}

package/src/validators/CountLessThanUnCheckedValidatorArray.ts

@@ -1,12 +0,0 @@
-import {Validator} from './Validator';
-import {ValidatorArray} from './ValidatorArray';
-
-export class CountLessThanUnCheckedValidatorArray<T = any, E = Element> extends ValidatorArray<T, E> {
-    constructor(public count: number, value?: Validator<T, E>[], target?: E, event?: Event, autoValid = true) {
-        super(value, target, event, autoValid);
-    }
-
-    valid(): boolean {
-        return (this.value ?? []).filter(it => !it.checked).length < this.count;
-    }
-}

package/src/validators/CountUnCheckedValidatorArray.ts

@@ -1,12 +0,0 @@
-import {Validator} from './Validator';
-import {ValidatorArray} from './ValidatorArray';
-
-export class CountUnCheckedValidatorArray<T = any, E = Element> extends ValidatorArray<T, E> {
-    constructor(public count: number, value?: Validator<T, E>[], target?: E, event?: Event, autoValid = true) {
-        super(value, target, event, autoValid);
-    }
-
-    valid(): boolean {
-        return (this.value ?? []).filter(it => !it.checked).length >= this.count;
-    }
-}

package/src/validators/EmptyValidator.ts

@@ -1,12 +0,0 @@
-import {Validator} from './Validator';
-
-export class EmptyValidator<T = any, E = Element> extends Validator<T, E> {
-    constructor(value?: T, target?: E, event?: Event, autoValid = true) {
-        super(value, target, event, autoValid);
-    }
-
-    valid(): boolean {
-        const value = this.value;
-        return value === undefined || value === null || ((value as any)?.length ?? 0) <= 0;
-    }
-}

package/src/validators/ExcludeCheckedValidatorArray.ts

@@ -1,16 +0,0 @@
-import {Validator} from './Validator';
-import {ValidatorArray} from './ValidatorArray';
-
-export class ExcludeCheckedValidatorArray<T = any, E = Element> extends ValidatorArray<T, E> {
-    constructor(public include: any[], public allRequired: boolean = false, value?: Validator<T, E>[], target?: E, event?: Event, autoValid = true) {
-        super(value, target, event, autoValid);
-    }
-
-    valid(): boolean {
-        const valus = this.value ?? [];
-        const unCheckedValue = valus.filter(it => !it.checked).map(it => it.value);
-        return unCheckedValue.length > 0 &&
-            (!(unCheckedValue.filter(it => !this.include.includes(it)).length > 0)) &&
-            (this.allRequired ? unCheckedValue.filter(it => this.include.includes(it)).length === this.include.length : true)
-    }
-}

package/src/validators/FormValidator.ts

@@ -1,19 +0,0 @@
-import {Validator} from './Validator';
-
-export class FormValidator<E = HTMLFormElement> extends Validator<void, E> {
-    constructor(target?: E, event?: Event, autoValid = true) {
-        super(undefined, target, event, autoValid)
-    }
-
-    validAction(): boolean {
-        return super.childValidAction();
-    }
-
-    valid(): boolean {
-        return this.childValid()
-    }
-
-    reset() {
-        this.targetReset();
-    }
-}

package/src/validators/IncludeCheckedValidatorArray.ts

@@ -1,16 +0,0 @@
-import {Validator} from './Validator';
-import {ValidatorArray} from './ValidatorArray';
-
-export class IncludeCheckedValidatorArray<T = any, E = Element> extends ValidatorArray<T, E> {
-    constructor(public include: any[], public allRequired: boolean = false, value?: Validator<T, E>[], target?: E, event?: Event, autoValid = true) {
-        super(value, target, event, autoValid);
-    }
-
-    valid(): boolean {
-        const valus = this.value ?? [];
-        const checkedValue = valus.filter(it => it.checked).map(it => it.value);
-        return checkedValue.length > 0 &&
-            (!(checkedValue.filter(it => !this.include.includes(it)).length > 0)) &&
-            (this.allRequired ? checkedValue.filter(it => this.include.includes(it)).length === this.include.length : true)
-    }
-}

package/src/validators/MultipleValidator.ts

@@ -1,29 +0,0 @@
-import {Validator} from './Validator';
-
-export class MultipleValidator<T = any, E = Element> extends Validator<T, E> {
-    public validators: Validator<T, E>[];
-    constructor(validators: Validator<T, E>[], value?: T, target?: E, event?: Event, autoValid: boolean = true) {
-        super(value, target, event, autoValid);
-        this.validators = validators.map(it => {
-            it.setAutoValid(false);
-            it.setAutoValidAction(false);
-            return it;
-        })
-        this.validators.forEach(it => {
-            it.set(this.value, this.getTarget(), this.getEvent())
-        });
-    }
-
-    changeValue(value: T | undefined) {
-        this.validators.forEach(it => it.set(this.value, this.getTarget(), this.getEvent()));
-    }
-
-    validAction(): boolean {
-        return !(this.validators.filter(it => !it.validAction()).length > 0);
-    }
-
-    valid(): boolean {
-        // console.log('mm', this.validators)
-        return !(this.validators.filter(it => !it.valid()).length > 0);
-    }
-}

package/src/validators/NonPassValidator.ts

@@ -1,11 +0,0 @@
-import {Validator} from './Validator';
-
-export class NonPassValidator<T = any, E = Element> extends Validator<T, E> {
-    constructor(value?: T, target?: E, event?: Event, autoValid = true) {
-        super(value, target, event, autoValid);
-    }
-
-    valid(): boolean {
-        return false;
-    }
-}

package/src/validators/NotEmptyValidator.ts

@@ -1,13 +0,0 @@
-import {Validator} from './Validator';
-
-export class NotEmptyValidator<T = any, E = Element> extends Validator<T, E> {
-    constructor(value?: T, target?: E, event?: Event, autoValid = true) {
-        super(value, target, event, autoValid);
-    }
-
-    valid(): boolean {
-        const value = this.value;
-        // console.log('NotEmptyValidator', value, value !== undefined && value !== null && ((value as any)?.length ?? 0) > 0)
-        return value !== undefined && value !== null && ((value as any)?.length ?? 0) > 0;
-    }
-}

package/src/validators/NotRegExpTestValidator.ts

@@ -1,20 +0,0 @@
-import {Validator} from './Validator';
-import {DomRenderProxy} from '../DomRenderProxy';
-
-export class NotRegExpTestValidator<T = any, E = Element> extends Validator<T, E> {
-    public regexp: RegExp;
-    constructor(regexp: RegExp, value?: T, target?: E, event?: Event, autoValid = true) {
-        super(value, target, event, autoValid);
-        this.regexp = DomRenderProxy.final(regexp)
-    }
-
-    valid(): boolean {
-        const value = this.value as unknown as string;
-        const regExp = (this.regexp as any)._DomRender_origin ?? this.regexp;
-        if (value) {
-            return !regExp.test(value);
-        } else {
-            return true;
-        }
-    }
-}

package/src/validators/PassValidator.ts

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

package/src/validators/RegExpTestValidator.ts

@@ -1,21 +0,0 @@
-import {Validator} from './Validator';
-import {DomRenderProxy} from '../DomRenderProxy';
-
-export class RegExpTestValidator<T = any, E = Element> extends Validator<T, E> {
-    public regexp: RegExp;
-    constructor(regexp: RegExp, value?: T, target?: E, event?: Event, autoValid = true) {
-        super(value, target, event, autoValid);
-        this.regexp = DomRenderProxy.final(regexp)
-    }
-
-    valid(): boolean {
-        const value = this.value as unknown as string;
-        const regExp = (this.regexp as any)._DomRender_origin ?? this.regexp;
-        // console.log('regexp-->', value, this.regexp, regExp.test(value))
-        if (value) {
-            return regExp.test(value);
-        } else {
-            return false;
-        }
-    }
-}

package/src/validators/RequiredValidator.ts

@@ -1,13 +0,0 @@
-import {Validator} from './Validator';
-
-export class RequiredValidator<T = any, E = Element> extends Validator<T, E> {
-    constructor(value?: T, target?: E, event?: Event, autoValid = true) {
-        super(value, target, event, autoValid);
-    }
-
-    valid(): boolean {
-        const value = this.value;
-        // console.log('required', value, value !== undefined && value !== null)
-        return value !== undefined && value !== null;
-    }
-}

package/src/validators/UnCheckedValidator.ts

@@ -1,11 +0,0 @@
-import {Validator} from './Validator';
-
-export class UnCheckedValidator<T = any, E = HTMLElement> extends Validator<T, E> {
-    constructor(value?: T, target?: E, event?: Event, autoValid = true) {
-        super(value, target, event, autoValid);
-    }
-
-    valid(): boolean {
-        return !((this.getTarget() as any)?.checked ?? false);
-    }
-}

package/src/validators/ValidMultipleValidator.ts

@@ -1,14 +0,0 @@
-import {Validator} from './Validator';
-import {MultipleValidator} from './MultipleValidator';
-
-export type ValidMulltiple<T = any, E = Element> = (validators: Validator<T, E>[], value?: T, target?: E, event?: Event) => boolean;
-
-export class ValidMultipleValidator<T = any, E = Element> extends MultipleValidator<T, E> {
-    constructor(public validMultipleCallback: ValidMulltiple<T, E>, public validators: Validator<T, E>[], value?: T, target?: E, event?: Event, autoValid: boolean = true) {
-        super(validators, value, target, event, autoValid);
-    }
-
-    valid(): boolean {
-        return this.validMultipleCallback(this.validators, this.value, this.getTarget(), this.getEvent());
-    }
-}

package/src/validators/ValidValidator.ts

@@ -1,11 +0,0 @@
-import {Valid, Validator} from './Validator';
-
-export class ValidValidator<T = any, E = Element> extends Validator<T, E> {
-    constructor(public validCallBack: Valid<T, E>, value?: T, target?: E, event?: Event, autoValid = true) {
-        super(value, target, event, autoValid);
-    }
-
-    valid(value?:T, target?:E, event?:Event): boolean {
-        return this.validCallBack(value, target, event);
-    }
-}

package/src/validators/ValidValidatorArray.ts

@@ -1,12 +0,0 @@
-import {Valid, Validator} from './Validator';
-import {ValidatorArray} from './ValidatorArray';
-
-export class ValidValidatorArray<T = any, E = Element> extends ValidatorArray<T, E> {
-    constructor(public validCallBack: Valid<Validator<T, E>[], E>, value?: Validator<T, E>[], target?: E, event?: Event, autoValid = true) {
-        super(value, target, event, autoValid);
-    }
-
-    valid(): boolean {
-        return this.validCallBack(this.value, this.getTarget(), this.getEvent());
-    }
-}

package/src/validators/Validator.ts

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

package/src/validators/ValidatorArray.ts

@@ -1,83 +0,0 @@
-import {Validator} from './Validator';
-import {NonPassValidator} from './NonPassValidator';
-
-export type MakeValidator<T = any, E = Element> = (value: T, target: E, event?: Event) => Validator<T, E>;
-
-export abstract class ValidatorArray<T = any, E = Element> extends Validator<Validator<T, E>[], E> {
-    private _makeValidatorFactory: MakeValidator<T, E> = (value: T, target: E, event?: Event): Validator<T, E> => {
-        return new NonPassValidator(value, target, event);
-    }
-
-    constructor(value?: Validator<T, E>[], target?: E, event?: Event, autoValid = true) {
-        super(value, target, event, autoValid);
-    }
-
-    getMakeValidatorFactory(): MakeValidator<T, E> {
-        return this._makeValidatorFactory;
-    }
-
-    setMakeValidatorFactory(value: MakeValidator<T, E>) {
-        this._makeValidatorFactory = value;
-        return this;
-    }
-
-    setArrayValue(target: E, value: T, event?: Event) {
-        this.value?.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: T, target: E, event?: Event) {
-        if (!this.value) {
-            this.value = [];
-        }
-        if (value instanceof Validator) {
-            this.value?.push(value)
-        } else {
-            this.value?.push(this.makeValidator(value, target, event))
-        }
-        this.tickValue(this.value)
-    }
-
-    allChecked(checked: boolean) {
-        this.checked = checked;
-        this.value?.forEach(it => {
-            it.checked = checked;
-        })
-    }
-
-    getValidators() {
-        return this._value;
-    }
-
-    getValidator(e: E) {
-        return this.value?.filter(it => it.getTarget() === e)[0]
-    }
-
-    getValidatorByValue(value: T) {
-        const validatorByValue = this.getValidatorByValues(value)[0];
-        return validatorByValue;
-    }
-
-    getValidatorByValues(value: T) {
-        return this.value?.filter(it => it.value === value) ?? [];
-    }
-
-    removeElement(e: E) {
-        const value = this.value;
-        if (value) {
-            this.value = value.filter(it => it.getTarget() !== e);
-        }
-    }
-
-    makeValidator(value: T, target: E, event?: Event): Validator<T, E> {
-        return this._makeValidatorFactory(value, target, event);
-    };
-}

package/src/validators/ValueEqualsValidator.ts

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