@dooboostore/dom-render 1.0.106 → 1.0.108

package/src/validators/CountLessThanEqualsCheckedValidatorArray.ts

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/src/validators/ValueNotEqualsValidator.ts

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

package/{dist/esm/validators/index.d.ts → src/validators/index.ts}

@@ -29,4 +29,3 @@ export * from './ValidValidator';
 export * from './ValidValidatorArray';
 export * from './Validator';
 export * from './ValidatorArray';
-//# sourceMappingURL=index.d.ts.map