@sbcore/ng-absolute-validator 14.0.0

package/esm2020/lib/rule/required_unless/required-unless.directive.mjs

@@ -0,0 +1,65 @@
+import { Directive, Input } from '@angular/core';
+import { NG_VALIDATORS } from '@angular/forms';
+import { Subject, takeUntil, debounceTime } from 'rxjs';
+import { toArray } from '../../common.utils';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/messages-builder.service";
+import * as i2 from "../../services/utils.service";
+export class RequiredUnlessDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.destroy$ = new Subject();
+        this.wired = false;
+        this.fieldName = 'field';
+        this.requiredUnless = [];
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'required_unless');
+        this.wireSiblingWatchers(control);
+        return this.isValid(control, this.requiredUnless);
+    }
+    isValid(control, args) {
+        if (!this.utl.requiredUnless(control, args)) {
+            return { 'required_unless': this.mb.call('required_unless', this.fieldName, ...toArray(args), this.vmessage) };
+        }
+        return null;
+    }
+    wireSiblingWatchers(control) {
+        if (this.wired)
+            return;
+        let [name, ...args] = toArray(this.requiredUnless);
+        let sibling = control.root.get(name);
+        if (!sibling)
+            return;
+        this.wired = true;
+        sibling.valueChanges.pipe(debounceTime(200), takeUntil(this.destroy$))
+            .subscribe(() => control.updateValueAndValidity({ onlySelf: true }));
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+    }
+}
+RequiredUnlessDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: RequiredUnlessDirective, deps: [{ token: i1.MessageBuilderService }, { token: i0.ElementRef }, { token: i2.UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+RequiredUnlessDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: RequiredUnlessDirective, selector: "[requiredUnless]", inputs: { requiredUnless: "requiredUnless", message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: RequiredUnlessDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: RequiredUnlessDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[requiredUnless]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: RequiredUnlessDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: i1.MessageBuilderService }, { type: i0.ElementRef }, { type: i2.UtilService }]; }, propDecorators: { requiredUnless: [{
+                type: Input,
+                args: ['requiredUnless']
+            }], message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/rule/required_with/required-with.directive.mjs

@@ -0,0 +1,67 @@
+import { Directive, Input } from '@angular/core';
+import { NG_VALIDATORS } from '@angular/forms';
+import { Subject, takeUntil, debounceTime } from 'rxjs';
+import { toArray } from '../../common.utils';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/messages-builder.service";
+import * as i2 from "../../services/utils.service";
+export class RequiredWithDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.destroy$ = new Subject();
+        this.wired = false;
+        this.fieldName = 'field';
+        this.requiredWith = [];
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'required_with');
+        this.wireSiblingWatchers(control);
+        return this.isValid(control, this.requiredWith);
+    }
+    isValid(control, args) {
+        if (!this.utl.requiredWith(control, args)) {
+            return { 'required_with': this.mb.call('required_with', this.fieldName, ...toArray(args), this.vmessage) };
+        }
+        return null;
+    }
+    wireSiblingWatchers(control) {
+        if (this.wired)
+            return;
+        let names = toArray(this.requiredWith);
+        let siblings = names.map(name => control.root.get(name));
+        if (siblings.filter(Boolean).length !== names.length)
+            return;
+        this.wired = true;
+        siblings.forEach(sibling => {
+            sibling.valueChanges.pipe(debounceTime(200), takeUntil(this.destroy$))
+                .subscribe(() => control.updateValueAndValidity({ onlySelf: true }));
+        });
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+    }
+}
+RequiredWithDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: RequiredWithDirective, deps: [{ token: i1.MessageBuilderService }, { token: i0.ElementRef }, { token: i2.UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+RequiredWithDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: RequiredWithDirective, selector: "[requiredWith]", inputs: { requiredWith: "requiredWith", message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: RequiredWithDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: RequiredWithDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[requiredWith]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: RequiredWithDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: i1.MessageBuilderService }, { type: i0.ElementRef }, { type: i2.UtilService }]; }, propDecorators: { requiredWith: [{
+                type: Input,
+                args: ['requiredWith']
+            }], message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/rule/required_with_all/required-with-all.directive.mjs

@@ -0,0 +1,67 @@
+import { Directive, Input } from '@angular/core';
+import { NG_VALIDATORS } from '@angular/forms';
+import { Subject, takeUntil, debounceTime } from 'rxjs';
+import { toArray } from '../../common.utils';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/messages-builder.service";
+import * as i2 from "../../services/utils.service";
+export class RequiredWithAllDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.destroy$ = new Subject();
+        this.wired = false;
+        this.fieldName = 'field';
+        this.requiredWithAll = [];
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'required_with_all');
+        this.wireSiblingWatchers(control);
+        return this.isValid(control, this.requiredWithAll);
+    }
+    isValid(control, args) {
+        if (!this.utl.requiredWithAll(control, args)) {
+            return { 'required_with_all': this.mb.call('required_with_all', this.fieldName, ...toArray(args), this.vmessage) };
+        }
+        return null;
+    }
+    wireSiblingWatchers(control) {
+        if (this.wired)
+            return;
+        let names = toArray(this.requiredWithAll);
+        let siblings = names.map(name => control.root.get(name));
+        if (siblings.filter(Boolean).length !== names.length)
+            return;
+        this.wired = true;
+        siblings.forEach(sibling => {
+            sibling.valueChanges.pipe(debounceTime(200), takeUntil(this.destroy$))
+                .subscribe(() => control.updateValueAndValidity({ onlySelf: true }));
+        });
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+    }
+}
+RequiredWithAllDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: RequiredWithAllDirective, deps: [{ token: i1.MessageBuilderService }, { token: i0.ElementRef }, { token: i2.UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+RequiredWithAllDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: RequiredWithAllDirective, selector: "[requiredWithAll]", inputs: { requiredWithAll: "requiredWithAll", message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: RequiredWithAllDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: RequiredWithAllDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[requiredWithAll]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: RequiredWithAllDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: i1.MessageBuilderService }, { type: i0.ElementRef }, { type: i2.UtilService }]; }, propDecorators: { requiredWithAll: [{
+                type: Input,
+                args: ['requiredWithAll']
+            }], message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/rule/required_without/required-without.directive.mjs

@@ -0,0 +1,67 @@
+import { Directive, Input } from '@angular/core';
+import { NG_VALIDATORS } from '@angular/forms';
+import { debounceTime, Subject, takeUntil } from 'rxjs';
+import { toArray } from '../../common.utils';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/messages-builder.service";
+import * as i2 from "../../services/utils.service";
+export class RequiredWithoutDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.destroy$ = new Subject();
+        this.wired = false;
+        this.fieldName = 'field';
+        this.requiredWithout = [];
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'required_without');
+        this.wireSiblingWatchers(control);
+        return this.isValid(control, this.requiredWithout);
+    }
+    isValid(control, args) {
+        if (!this.utl.requiredWithout(control, args)) {
+            return { 'required_without': this.mb.call('required_without', this.fieldName, ...toArray(args), this.vmessage) };
+        }
+        return null;
+    }
+    wireSiblingWatchers(control) {
+        if (this.wired)
+            return;
+        let names = toArray(this.requiredWithout);
+        let siblings = names.map(name => control.root.get(name));
+        if (siblings.filter(Boolean).length !== names.length)
+            return;
+        this.wired = true;
+        siblings.forEach(sibling => {
+            sibling.valueChanges.pipe(debounceTime(200), takeUntil(this.destroy$))
+                .subscribe(() => control.updateValueAndValidity({ onlySelf: true }));
+        });
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+    }
+}
+RequiredWithoutDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: RequiredWithoutDirective, deps: [{ token: i1.MessageBuilderService }, { token: i0.ElementRef }, { token: i2.UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+RequiredWithoutDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: RequiredWithoutDirective, selector: "[requiredWithout]", inputs: { requiredWithout: "requiredWithout", message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: RequiredWithoutDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: RequiredWithoutDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[requiredWithout]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: RequiredWithoutDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: i1.MessageBuilderService }, { type: i0.ElementRef }, { type: i2.UtilService }]; }, propDecorators: { requiredWithout: [{
+                type: Input,
+                args: ['requiredWithout']
+            }], message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVxdWlyZWQtd2l0aG91dC5kaXJlY3RpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZy1hYnNvbHV0ZS12YWxpZGF0b3Ivc3JjL2xpYi9ydWxlL3JlcXVpcmVkX3dpdGhvdXQvcmVxdWlyZWQtd2l0aG91dC5kaXJlY3RpdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBYyxLQUFLLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDN0QsT0FBTyxFQUFFLGFBQWEsRUFBNkQsTUFBTSxnQkFBZ0IsQ0FBQztBQUcxRyxPQUFPLEVBQUUsWUFBWSxFQUFFLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxNQUFNLENBQUM7QUFDeEQsT0FBTyxFQUFFLE9BQU8sRUFBRSxNQUFNLG9CQUFvQixDQUFDOzs7O0FBUTdDLE1BQU0sT0FBTyx3QkFBd0I7SUFhakMsWUFDWSxFQUF5QixFQUN6QixFQUFjLEVBQ2QsR0FBZ0I7UUFGaEIsT0FBRSxHQUFGLEVBQUUsQ0FBdUI7UUFDekIsT0FBRSxHQUFGLEVBQUUsQ0FBWTtRQUNkLFFBQUcsR0FBSCxHQUFHLENBQWE7UUFkcEIsYUFBUSxHQUF1QixFQUFFLENBQUE7UUFDakMsYUFBUSxHQUFxQixJQUFJLE9BQU8sRUFBUSxDQUFDO1FBQ2pELFVBQUssR0FBaUIsS0FBSyxDQUFDO1FBQzVCLGNBQVMsR0FBYSxPQUFPLENBQUM7UUFFWixvQkFBZSxHQUFzQixFQUFFLENBQUM7UUFVOUQsSUFBSSxDQUFDLFNBQVMsR0FBRyxJQUFJLENBQUMsRUFBRSxDQUFDLGFBQWEsQ0FBQyxJQUFJLENBQUE7SUFBQyxDQUFDO0lBVGpELElBQ0ksT0FBTyxDQUFDLElBQXFCO1FBQzdCLElBQUksQ0FBQyxRQUFRLEdBQUcsSUFBSSxDQUFBO0lBQ3hCLENBQUM7SUFRRCxRQUFRLENBQUMsT0FBd0I7UUFDN0IsSUFBSSxDQUFDLEdBQUcsQ0FBQyxrQkFBa0IsQ0FBQyxPQUFPLEVBQUUsa0JBQWtCLENBQUMsQ0FBQztRQUN6RCxJQUFJLENBQUMsbUJBQW1CLENBQUMsT0FBTyxDQUFDLENBQUE7UUFDakMsT0FBTyxJQUFJLENBQUMsT0FBTyxDQUFDLE9BQU8sRUFBRSxJQUFJLENBQUMsZUFBZSxDQUFDLENBQUE7SUFDdEQsQ0FBQztJQUVPLE9BQU8sQ0FBQyxPQUF3QixFQUFFLElBQXVCO1FBQzdELElBQUksQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLGVBQWUsQ0FBQyxPQUFPLEVBQUUsSUFBSSxDQUFDLEVBQUU7WUFDMUMsT0FBTyxFQUFFLGtCQUFrQixFQUFFLElBQUksQ0FBQyxFQUFFLENBQUMsSUFBSSxDQUFDLGtCQUFrQixFQUFFLElBQUksQ0FBQyxTQUFTLEVBQUUsR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLEVBQUUsSUFBSSxDQUFDLFFBQVEsQ0FBQyxFQUFFLENBQUE7U0FDbkg7UUFDRCxPQUFPLElBQUksQ0FBQztJQUNoQixDQUFDO0lBRU8sbUJBQW1CLENBQUMsT0FBd0I7UUFDaEQsSUFBSSxJQUFJLENBQUMsS0FBSztZQUFFLE9BQU87UUFDdkIsSUFBSSxLQUFLLEdBQU0sT0FBTyxDQUFDLElBQUksQ0FBQyxlQUFlLENBQUMsQ0FBQTtRQUM1QyxJQUFJLFFBQVEsR0FBRyxLQUFLLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFnQixDQUFDLENBQUE7UUFFdkUsSUFBSSxRQUFRLENBQUMsTUFBTSxDQUFDLE9BQU8sQ0FBQyxDQUFDLE1BQU0sS0FBSyxLQUFLLENBQUMsTUFBTTtZQUFFLE9BQU87UUFDN0QsSUFBSSxDQUFDLEtBQUssR0FBRyxJQUFJLENBQUM7UUFFbEIsUUFBUSxDQUFDLE9BQU8sQ0FBQyxPQUFPLENBQUMsRUFBRTtZQUN2QixPQUFPLENBQUMsWUFBWSxDQUFDLElBQUksQ0FBQyxZQUFZLENBQUMsR0FBRyxDQUFDLEVBQUMsU0FBUyxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsQ0FBQztpQkFDaEUsU0FBUyxDQUFDLEdBQUcsRUFBRSxDQUFDLE9BQU8sQ0FBQyxzQkFBc0IsQ0FBQyxFQUFFLFFBQVEsRUFBRSxJQUFJLEVBQUUsQ0FBQyxDQUFDLENBQUM7UUFDN0UsQ0FBQyxDQUFDLENBQUM7SUFDUCxDQUFDO0lBRUQsV0FBVztRQUNQLElBQUksQ0FBQyxRQUFRLENBQUMsSUFBSSxFQUFFLENBQUM7UUFDckIsSUFBSSxDQUFDLFFBQVEsQ0FBQyxRQUFRLEVBQUUsQ0FBQztJQUM3QixDQUFDOztxSEFqRFEsd0JBQXdCO3lHQUF4Qix3QkFBd0IsZ0hBRnRCLENBQUMsRUFBRSxPQUFPLEVBQUUsYUFBYSxFQUFFLFdBQVcsRUFBRSx3QkFBd0IsRUFBRSxLQUFLLEVBQUUsSUFBSSxFQUFFLENBQUM7MkZBRWxGLHdCQUF3QjtrQkFKcEMsU0FBUzttQkFBQztvQkFDUCxRQUFRLEVBQUUsbUJBQW1CO29CQUM3QixTQUFTLEVBQUUsQ0FBQyxFQUFFLE9BQU8sRUFBRSxhQUFhLEVBQUUsV0FBVywwQkFBMEIsRUFBRSxLQUFLLEVBQUUsSUFBSSxFQUFFLENBQUM7aUJBQzlGOytKQVE2QixlQUFlO3NCQUF4QyxLQUFLO3VCQUFDLGlCQUFpQjtnQkFFcEIsT0FBTztzQkFEVixLQUFLO3VCQUFDLFNBQVMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEaXJlY3RpdmUsIEVsZW1lbnRSZWYsIElucHV0IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcbmltcG9ydCB7IE5HX1ZBTElEQVRPUlMsIFZhbGlkYXRvciwgQWJzdHJhY3RDb250cm9sLCBWYWxpZGF0aW9uRXJyb3JzLCBGb3JtQ29udHJvbCB9IGZyb20gJ0Bhbmd1bGFyL2Zvcm1zJztcclxuaW1wb3J0IHsgVXRpbFNlcnZpY2UgfSBmcm9tICcuLi8uLi9zZXJ2aWNlcy91dGlscy5zZXJ2aWNlJztcclxuaW1wb3J0IHsgTWVzc2FnZUJ1aWxkZXJTZXJ2aWNlIH0gZnJvbSAnLi4vLi4vc2VydmljZXMvbWVzc2FnZXMtYnVpbGRlci5zZXJ2aWNlJztcclxuaW1wb3J0IHsgZGVib3VuY2VUaW1lLCBTdWJqZWN0LCB0YWtlVW50aWwgfSBmcm9tICdyeGpzJztcclxuaW1wb3J0IHsgdG9BcnJheSB9IGZyb20gJy4uLy4uL2NvbW1vbi51dGlscyc7XHJcbmltcG9ydCB7IExvY2FsaXplZE1lc3NhZ2UgfSBmcm9tICcuLi8uLi9pbnRlcmZhY2UnO1xyXG5cclxuXHJcbkBEaXJlY3RpdmUoe1xyXG4gICAgc2VsZWN0b3I6ICdbcmVxdWlyZWRXaXRob3V0XScsXHJcbiAgICBwcm92aWRlcnM6IFt7IHByb3ZpZGU6IE5HX1ZBTElEQVRPUlMsIHVzZUV4aXN0aW5nOiBSZXF1aXJlZFdpdGhvdXREaXJlY3RpdmUsIG11bHRpOiB0cnVlIH1dXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBSZXF1aXJlZFdpdGhvdXREaXJlY3RpdmUgaW1wbGVtZW50cyBWYWxpZGF0b3Ige1xyXG5cclxuICAgIHByaXZhdGUgdm1lc3NhZ2UgIDogTG9jYWxpemVkTWVzc2FnZSA9IHt9XHJcbiAgICBwcml2YXRlIGRlc3Ryb3kkICA6IFN1YmplY3Q8dm9pZD4gID0gbmV3IFN1YmplY3Q8dm9pZD4oKTtcclxuICAgIHByaXZhdGUgd2lyZWQgICAgIDogYm9vbGVhbiA9IGZhbHNlO1xyXG4gICAgcHJpdmF0ZSBmaWVsZE5hbWUgOiBzdHJpbmcgID0gJ2ZpZWxkJztcclxuXHJcbiAgICBASW5wdXQoJ3JlcXVpcmVkV2l0aG91dCcpIHJlcXVpcmVkV2l0aG91dDogc3RyaW5nIHwgc3RyaW5nW10gPSBbXTtcclxuICAgIEBJbnB1dCgnbWVzc2FnZScpXHJcbiAgICBzZXQgbWVzc2FnZShkYXRhOkxvY2FsaXplZE1lc3NhZ2Upe1xyXG4gICAgICAgIHRoaXMudm1lc3NhZ2UgPSBkYXRhXHJcbiAgICB9XHJcblxyXG4gICAgY29uc3RydWN0b3IoXHJcbiAgICAgICAgcHJpdmF0ZSBtYjogTWVzc2FnZUJ1aWxkZXJTZXJ2aWNlLFxyXG4gICAgICAgIHByaXZhdGUgZWw6IEVsZW1lbnRSZWYsXHJcbiAgICAgICAgcHJpdmF0ZSB1dGw6IFV0aWxTZXJ2aWNlXHJcbiAgICApIHsgdGhpcy5maWVsZE5hbWUgPSB0aGlzLmVsLm5hdGl2ZUVsZW1lbnQubmFtZSB9XHJcblxyXG4gICAgdmFsaWRhdGUoY29udHJvbDogQWJzdHJhY3RDb250cm9sKTogVmFsaWRhdGlvbkVycm9ycyB8IG51bGwge1xyXG4gICAgICAgIHRoaXMudXRsLnNldFZhbGlkYXRpb25SdWxlcyhjb250cm9sLCAncmVxdWlyZWRfd2l0aG91dCcpO1xyXG4gICAgICAgIHRoaXMud2lyZVNpYmxpbmdXYXRjaGVycyhjb250cm9sKVxyXG4gICAgICAgIHJldHVybiB0aGlzLmlzVmFsaWQoY29udHJvbCwgdGhpcy5yZXF1aXJlZFdpdGhvdXQpXHJcbiAgICB9XHJcblxyXG4gICAgcHJpdmF0ZSBpc1ZhbGlkKGNvbnRyb2w6IEFic3RyYWN0Q29udHJvbCwgYXJnczogc3RyaW5nIHwgc3RyaW5nW10pOiBWYWxpZGF0aW9uRXJyb3JzIHwgbnVsbCB7XHJcbiAgICAgICAgaWYgKCF0aGlzLnV0bC5yZXF1aXJlZFdpdGhvdXQoY29udHJvbCwgYXJncykpIHtcclxuICAgICAgICAgICAgcmV0dXJuIHsgJ3JlcXVpcmVkX3dpdGhvdXQnOiB0aGlzLm1iLmNhbGwoJ3JlcXVpcmVkX3dpdGhvdXQnLCB0aGlzLmZpZWxkTmFtZSwgLi4udG9BcnJheShhcmdzKSwgdGhpcy52bWVzc2FnZSkgfVxyXG4gICAgICAgIH1cclxuICAgICAgICByZXR1cm4gbnVsbDtcclxuICAgIH1cclxuXHJcbiAgICBwcml2YXRlIHdpcmVTaWJsaW5nV2F0Y2hlcnMoY29udHJvbDogQWJzdHJhY3RDb250cm9sKTogdm9pZCB7XHJcbiAgICAgICAgaWYgKHRoaXMud2lyZWQpIHJldHVybjtcclxuICAgICAgICBsZXQgbmFtZXMgICAgPSB0b0FycmF5KHRoaXMucmVxdWlyZWRXaXRob3V0KVxyXG4gICAgICAgIGxldCBzaWJsaW5ncyA9IG5hbWVzLm1hcChuYW1lID0+IGNvbnRyb2wucm9vdC5nZXQobmFtZSkgYXMgRm9ybUNvbnRyb2wpXHJcblxyXG4gICAgICAgIGlmIChzaWJsaW5ncy5maWx0ZXIoQm9vbGVhbikubGVuZ3RoICE9PSBuYW1lcy5sZW5ndGgpIHJldHVybjtcclxuICAgICAgICB0aGlzLndpcmVkID0gdHJ1ZTtcclxuXHJcbiAgICAgICAgc2libGluZ3MuZm9yRWFjaChzaWJsaW5nID0+IHtcclxuICAgICAgICAgICAgc2libGluZy52YWx1ZUNoYW5nZXMucGlwZShkZWJvdW5jZVRpbWUoMjAwKSx0YWtlVW50aWwodGhpcy5kZXN0cm95JCkpXHJcbiAgICAgICAgICAgICAgICAuc3Vic2NyaWJlKCgpID0+IGNvbnRyb2wudXBkYXRlVmFsdWVBbmRWYWxpZGl0eSh7IG9ubHlTZWxmOiB0cnVlIH0pKTtcclxuICAgICAgICB9KTtcclxuICAgIH1cclxuXHJcbiAgICBuZ09uRGVzdHJveSgpOiB2b2lkIHtcclxuICAgICAgICB0aGlzLmRlc3Ryb3kkLm5leHQoKTtcclxuICAgICAgICB0aGlzLmRlc3Ryb3kkLmNvbXBsZXRlKCk7XHJcbiAgICB9XHJcbn1cclxuIl19

package/esm2020/lib/rule/required_without_all/required-without-all.directive.mjs

@@ -0,0 +1,67 @@
+import { Directive, Input } from '@angular/core';
+import { NG_VALIDATORS } from '@angular/forms';
+import { Subject, takeUntil, debounceTime } from 'rxjs';
+import { toArray } from '../../common.utils';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/messages-builder.service";
+import * as i2 from "../../services/utils.service";
+export class RequiredWithoutAllDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.destroy$ = new Subject();
+        this.wired = false;
+        this.fieldName = 'field';
+        this.requiredWithoutAll = [];
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'required_without_all');
+        this.wireSiblingWatchers(control);
+        return this.isValid(control, this.requiredWithoutAll);
+    }
+    isValid(control, args) {
+        if (!this.utl.requiredWithoutAll(control, args)) {
+            return { 'required_without_all': this.mb.call('required_without_all', this.fieldName, ...toArray(args), this.vmessage) };
+        }
+        return null;
+    }
+    wireSiblingWatchers(control) {
+        if (this.wired)
+            return;
+        let names = toArray(this.requiredWithoutAll);
+        let siblings = names.map(name => control.root.get(name));
+        if (siblings.filter(Boolean).length !== names.length)
+            return;
+        this.wired = true;
+        siblings.forEach(sibling => {
+            sibling.valueChanges.pipe(debounceTime(200), takeUntil(this.destroy$))
+                .subscribe(() => control.updateValueAndValidity({ onlySelf: true }));
+        });
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+    }
+}
+RequiredWithoutAllDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: RequiredWithoutAllDirective, deps: [{ token: i1.MessageBuilderService }, { token: i0.ElementRef }, { token: i2.UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+RequiredWithoutAllDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: RequiredWithoutAllDirective, selector: "[requiredWithoutAll]", inputs: { requiredWithoutAll: "requiredWithoutAll", message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: RequiredWithoutAllDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: RequiredWithoutAllDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[requiredWithoutAll]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: RequiredWithoutAllDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: i1.MessageBuilderService }, { type: i0.ElementRef }, { type: i2.UtilService }]; }, propDecorators: { requiredWithoutAll: [{
+                type: Input,
+                args: ['requiredWithoutAll']
+            }], message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/rule/rule.directive.mjs

@@ -0,0 +1,35 @@
+import { Directive, Input } from '@angular/core';
+import { NG_VALIDATORS } from '@angular/forms';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/validate-rule.service";
+export class RuleDirective {
+    constructor(ruleValidate, el) {
+        this.ruleValidate = ruleValidate;
+        this.el = el;
+        this.vmessage = {};
+        this.fieldName = 'field';
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        return this.ruleValidate.gererateRuleAndValidate(this.fieldName, control, this.rule, this.vmessage);
+    }
+}
+RuleDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: RuleDirective, deps: [{ token: i1.ValidateRuleService }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+RuleDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: RuleDirective, selector: "[Rule], [rule]", inputs: { rule: ["Rule", "rule"], message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: RuleDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: RuleDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[Rule], [rule]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: RuleDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ValidateRuleService }, { type: i0.ElementRef }]; }, propDecorators: { rule: [{
+                type: Input,
+                args: ['Rule']
+            }], message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnVsZS5kaXJlY3RpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZy1hYnNvbHV0ZS12YWxpZGF0b3Ivc3JjL2xpYi9ydWxlL3J1bGUuZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsS0FBSyxFQUFZLE1BQU0sZUFBZSxDQUFDO0FBQzNELE9BQU8sRUFBRSxhQUFhLEVBQStDLE1BQU0sZ0JBQWdCLENBQUM7OztBQVE1RixNQUFNLE9BQU8sYUFBYTtJQVd6QixZQUNTLFlBQWtDLEVBQ2xDLEVBQW1CO1FBRG5CLGlCQUFZLEdBQVosWUFBWSxDQUFzQjtRQUNsQyxPQUFFLEdBQUYsRUFBRSxDQUFpQjtRQVhqQixhQUFRLEdBQTJCLEVBQUUsQ0FBQTtRQUNyQyxjQUFTLEdBQVcsT0FBTyxDQUFDO1FBV3JDLElBQUksQ0FBQyxTQUFTLEdBQUcsSUFBSSxDQUFDLEVBQUUsQ0FBQyxhQUFhLENBQUMsSUFBSSxDQUFDO0lBQUEsQ0FBQztJQVIvQyxJQUNPLE9BQU8sQ0FBQyxJQUEyQjtRQUNuQyxJQUFJLENBQUMsUUFBUSxHQUFHLElBQUksQ0FBQTtJQUN4QixDQUFDO0lBUUosUUFBUSxDQUFDLE9BQXVCO1FBQy9CLE9BQU8sSUFBSSxDQUFDLFlBQVksQ0FBQyx1QkFBdUIsQ0FBQyxJQUFJLENBQUMsU0FBUyxFQUFDLE9BQU8sRUFBQyxJQUFJLENBQUMsSUFBSSxFQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsQ0FBQztJQUNsRyxDQUFDOzswR0FuQlcsYUFBYTs4RkFBYixhQUFhLGlHQUZkLENBQUMsRUFBRSxPQUFPLEVBQUUsYUFBYSxFQUFFLFdBQVcsRUFBRSxhQUFhLEVBQUUsS0FBSyxFQUFFLElBQUksRUFBRSxDQUFDOzJGQUVwRSxhQUFhO2tCQUp6QixTQUFTO21CQUFDO29CQUNWLFFBQVEsRUFBRSxnQkFBZ0I7b0JBQzFCLFNBQVMsRUFBRSxDQUFDLEVBQUUsT0FBTyxFQUFFLGFBQWEsRUFBRSxXQUFXLGVBQWUsRUFBRSxLQUFLLEVBQUUsSUFBSSxFQUFFLENBQUM7aUJBQ2hGO21JQU1lLElBQUk7c0JBQWxCLEtBQUs7dUJBQUMsTUFBTTtnQkFFTixPQUFPO3NCQURiLEtBQUs7dUJBQUMsU0FBUyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERpcmVjdGl2ZSwgSW5wdXQsRWxlbWVudFJlZn0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcbmltcG9ydCB7IE5HX1ZBTElEQVRPUlMsIFZhbGlkYXRvcixBYnN0cmFjdENvbnRyb2wsIFZhbGlkYXRpb25FcnJvcnMgfSBmcm9tICdAYW5ndWxhci9mb3Jtcyc7XHJcbmltcG9ydCB7IFZhbGlkYXRlUnVsZVNlcnZpY2UgfSBmcm9tICcuLi9zZXJ2aWNlcy92YWxpZGF0ZS1ydWxlLnNlcnZpY2UnO1xyXG5pbXBvcnQgeyBMb2NhbGl6ZWRNZXNzYWdlR3JvdXAgfSBmcm9tICcuLi9pbnRlcmZhY2UnO1xyXG5cclxuQERpcmVjdGl2ZSh7XHJcblx0c2VsZWN0b3I6ICdbUnVsZV0sIFtydWxlXScsXHJcblx0cHJvdmlkZXJzOiBbeyBwcm92aWRlOiBOR19WQUxJREFUT1JTLCB1c2VFeGlzdGluZzogUnVsZURpcmVjdGl2ZSwgbXVsdGk6IHRydWUgfV1cclxufSlcclxuZXhwb3J0IGNsYXNzIFJ1bGVEaXJlY3RpdmUgaW1wbGVtZW50cyBWYWxpZGF0b3J7XHJcblxyXG4gICAgcHJpdmF0ZSB2bWVzc2FnZSA6IExvY2FsaXplZE1lc3NhZ2VHcm91cCA9IHt9XHJcbiAgICBwcml2YXRlIGZpZWxkTmFtZTogc3RyaW5nID0gJ2ZpZWxkJztcclxuXHJcblx0QElucHV0KCdSdWxlJykgcnVsZSAhOiBzdHJpbmcgfCBzdHJpbmdbXTtcclxuXHRASW5wdXQoJ21lc3NhZ2UnKVxyXG4gICAgc2V0IG1lc3NhZ2UoZGF0YTogTG9jYWxpemVkTWVzc2FnZUdyb3VwKSB7XHJcbiAgICAgICAgdGhpcy52bWVzc2FnZSA9IGRhdGFcclxuICAgIH1cclxuXHJcblx0Y29uc3RydWN0b3IoXHJcblx0XHRwcml2YXRlIHJ1bGVWYWxpZGF0ZSA6IFZhbGlkYXRlUnVsZVNlcnZpY2UsXHJcblx0XHRwcml2YXRlIGVsIFx0XHRcdCA6IEVsZW1lbnRSZWYsXHJcblx0KXt0aGlzLmZpZWxkTmFtZSA9IHRoaXMuZWwubmF0aXZlRWxlbWVudC5uYW1lO31cclxuXHJcblxyXG5cdHZhbGlkYXRlKGNvbnRyb2w6QWJzdHJhY3RDb250cm9sKTogVmFsaWRhdGlvbkVycm9ycyB8IG51bGx7XHJcblx0XHRyZXR1cm4gdGhpcy5ydWxlVmFsaWRhdGUuZ2VyZXJhdGVSdWxlQW5kVmFsaWRhdGUodGhpcy5maWVsZE5hbWUsY29udHJvbCx0aGlzLnJ1bGUsdGhpcy52bWVzc2FnZSk7XHJcblx0fVxyXG59XHJcbiJdfQ==

package/esm2020/lib/rule/rule.module.mjs

@@ -0,0 +1,141 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { MessageBuilderService } from '../services/messages-builder.service';
+import { ValidateRuleService } from '../services/validate-rule.service';
+import { UtilService } from '../services/utils.service';
+import { RuleDirective } from './rule.directive';
+import { AboveDirective } from './above/above.directive';
+import { AcceptedDirective } from './accepted/accepted.directive';
+import { AfterDirective } from './after/after.directive';
+import { AlphaDirective } from './alpha/alpha.directive';
+import { AlphaNumericDirective } from './alpha_numeric/alpha-numeric.directive';
+import { ArrayDirective } from './array/array.directive';
+import { BeforeDirective } from './before/before.directive';
+import { BooleanDirective } from './boolean/boolean.directive';
+import { ConfirmedDirective } from './confirmed/confirmed.directive';
+import { DateDirective } from './date/date.directive';
+import { DateFormatDirective } from './date_format/date-format.directive';
+import { DifferentDirective } from './different/different.directive';
+import { EmailDirective } from './email/email.directive';
+import { EndsWithDirective } from './ends_with/ends-with.directive';
+import { EqualsDirective } from './equals/equals.directive';
+import { InDirective } from './in/in.directive';
+import { IncludesDirective } from './includes/includes.directive';
+import { IntegerDirective } from './integer/integer.directive';
+import { IpDirective } from './ip/ip.directive';
+import { Ipv4Directive } from './ipv4/ipv4.directive';
+import { Ipv6Directive } from './ipv6/ipv6.directive';
+import { JsonDirective } from './json/json.directive';
+import { MaxDirective } from './max/max.directive';
+import { MinDirective } from './min/min.directive';
+import { NotEqualsDirective } from './not_equals/not-equals.directive';
+import { NotInDirective } from './not_in/not-in.directive';
+import { NumberDirective } from './number/number.directive';
+import { RangeDirective } from './range/range.directive';
+import { BetweenDirective } from './between/between.directive';
+import { RegexDirective } from './regex/regex.directive';
+import { SameDirective } from './same/same.directive';
+import { StartsWithDirective } from './starts_with/starts-with.directive';
+import { StringDirective } from './string/string.directive';
+import { UnderDirective } from './under/under.directive';
+import { UrlDirective } from './url/url.directive';
+import { AlphaDashDirective } from './alpha_dash/alpha-dash.directive';
+import { NotRegexDirective } from './not_regex/not-regex.directive';
+import { UuidDirective } from './uuid/uuid.directive';
+import { UniqueDirective } from './unique/unique.directive';
+import { CreditCardDirective } from './credit_card/credit-card.directive';
+import { DebitCardDirective } from './debit_card/debit-card.directive';
+import { CvvDirective } from './cvv/cvv.directive';
+import { StrengthDirective } from './strength/strength.directive';
+import { PhoneNoDirective } from './phone_no/phone-no.directive';
+import { RequiredDirective } from '../rule/required/required.directive';
+import { RequiredIfDirective } from './required_if/required-if.directive';
+import { RequiredUnlessDirective } from './required_unless/required-unless.directive';
+import { RequiredWithDirective } from './required_with/required-with.directive';
+import { RequiredWithAllDirective } from './required_with_all/required-with-all.directive';
+import { RequiredWithoutDirective } from './required_without/required-without.directive';
+import { RequiredWithoutAllDirective } from './required_without_all/required-without-all.directive';
+import { MimesDirective } from './mimes/mimes.directive';
+import { SizeDirective } from './size/size.directive';
+import { DimensionDirective } from './dimension/dimension.directive';
+import { ImageDirective } from './image/image.directive';
+import { VideoDirective } from './video/video.directive';
+import { ExistsDirective } from './exists/exists.directive';
+import * as i0 from "@angular/core";
+const rulesDirectives = [
+    RuleDirective,
+    RequiredDirective, AboveDirective, AcceptedDirective, AfterDirective,
+    AlphaDirective, AlphaNumericDirective, ArrayDirective, UrlDirective,
+    DateDirective, BeforeDirective, BooleanDirective, ConfirmedDirective,
+    DateFormatDirective, DifferentDirective, EmailDirective, InDirective,
+    EqualsDirective, EndsWithDirective, IncludesDirective, Ipv4Directive,
+    SameDirective, IpDirective, Ipv6Directive, JsonDirective, MaxDirective,
+    MinDirective, NotEqualsDirective, NotInDirective, StartsWithDirective,
+    RangeDirective, BetweenDirective, RegexDirective, IntegerDirective,
+    NumberDirective, StringDirective, UnderDirective, NotRegexDirective,
+    UuidDirective, UniqueDirective, CreditCardDirective, DebitCardDirective,
+    CvvDirective, StrengthDirective, PhoneNoDirective, RequiredIfDirective,
+    RequiredUnlessDirective, RequiredWithDirective, RequiredWithAllDirective,
+    RequiredWithoutDirective, RequiredWithoutAllDirective, MimesDirective,
+    SizeDirective, DimensionDirective, ImageDirective, VideoDirective,
+    ExistsDirective, AlphaDashDirective
+];
+export class RuleModule {
+}
+RuleModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: RuleModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+RuleModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.3.0", ngImport: i0, type: RuleModule, declarations: [RuleDirective,
+        RequiredDirective, AboveDirective, AcceptedDirective, AfterDirective,
+        AlphaDirective, AlphaNumericDirective, ArrayDirective, UrlDirective,
+        DateDirective, BeforeDirective, BooleanDirective, ConfirmedDirective,
+        DateFormatDirective, DifferentDirective, EmailDirective, InDirective,
+        EqualsDirective, EndsWithDirective, IncludesDirective, Ipv4Directive,
+        SameDirective, IpDirective, Ipv6Directive, JsonDirective, MaxDirective,
+        MinDirective, NotEqualsDirective, NotInDirective, StartsWithDirective,
+        RangeDirective, BetweenDirective, RegexDirective, IntegerDirective,
+        NumberDirective, StringDirective, UnderDirective, NotRegexDirective,
+        UuidDirective, UniqueDirective, CreditCardDirective, DebitCardDirective,
+        CvvDirective, StrengthDirective, PhoneNoDirective, RequiredIfDirective,
+        RequiredUnlessDirective, RequiredWithDirective, RequiredWithAllDirective,
+        RequiredWithoutDirective, RequiredWithoutAllDirective, MimesDirective,
+        SizeDirective, DimensionDirective, ImageDirective, VideoDirective,
+        ExistsDirective, AlphaDashDirective], imports: [CommonModule], exports: [RuleDirective,
+        RequiredDirective, AboveDirective, AcceptedDirective, AfterDirective,
+        AlphaDirective, AlphaNumericDirective, ArrayDirective, UrlDirective,
+        DateDirective, BeforeDirective, BooleanDirective, ConfirmedDirective,
+        DateFormatDirective, DifferentDirective, EmailDirective, InDirective,
+        EqualsDirective, EndsWithDirective, IncludesDirective, Ipv4Directive,
+        SameDirective, IpDirective, Ipv6Directive, JsonDirective, MaxDirective,
+        MinDirective, NotEqualsDirective, NotInDirective, StartsWithDirective,
+        RangeDirective, BetweenDirective, RegexDirective, IntegerDirective,
+        NumberDirective, StringDirective, UnderDirective, NotRegexDirective,
+        UuidDirective, UniqueDirective, CreditCardDirective, DebitCardDirective,
+        CvvDirective, StrengthDirective, PhoneNoDirective, RequiredIfDirective,
+        RequiredUnlessDirective, RequiredWithDirective, RequiredWithAllDirective,
+        RequiredWithoutDirective, RequiredWithoutAllDirective, MimesDirective,
+        SizeDirective, DimensionDirective, ImageDirective, VideoDirective,
+        ExistsDirective, AlphaDashDirective] });
+RuleModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: RuleModule, providers: [
+        UtilService,
+        ValidateRuleService,
+        MessageBuilderService,
+    ], imports: [CommonModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: RuleModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        ...rulesDirectives
+                    ],
+                    imports: [
+                        CommonModule
+                    ],
+                    providers: [
+                        UtilService,
+                        ValidateRuleService,
+                        MessageBuilderService,
+                    ],
+                    exports: [
+                        ...rulesDirectives
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rule.module.js","sourceRoot":"","sources":["../../../../../projects/ng-absolute-validator/src/lib/rule/rule.module.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,qBAAqB,EAAE,MAAM,sCAAsC,CAAC;AAC7E,OAAO,EAAE,mBAAmB,EAAE,MAAM,mCAAmC,CAAC;AACxE,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AACxD,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAClE,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,EAAE,qBAAqB,EAAE,MAAM,yCAAyC,CAAC;AAChF,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAC5D,OAAO,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAC/D,OAAO,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AACrE,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACtD,OAAO,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAC;AAC1E,OAAO,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AACrE,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAC;AACpE,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAC5D,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAClE,OAAO,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAC/D,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACtD,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACtD,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACtD,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AACvE,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAC5D,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAC/D,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACtD,OAAO,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAC;AAC1E,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAC5D,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AACvE,OAAO,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAC;AACpE,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACtD,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAC5D,OAAO,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAC;AAC1E,OAAO,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AACvE,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAClE,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AACjE,OAAO,EAAE,iBAAiB,EAAE,MAAM,qCAAqC,CAAC;AACxE,OAAO,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAC;AAC1E,OAAO,EAAE,uBAAuB,EAAE,MAAM,6CAA6C,CAAC;AACtF,OAAO,EAAE,qBAAqB,EAAE,MAAM,yCAAyC,CAAC;AAChF,OAAO,EAAE,wBAAwB,EAAE,MAAM,iDAAiD,CAAC;AAC3F,OAAO,EAAE,wBAAwB,EAAE,MAAM,+CAA+C,CAAC;AACzF,OAAO,EAAE,2BAA2B,EAAE,MAAM,uDAAuD,CAAC;AACpG,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACtD,OAAO,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AACrE,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;;AAG5D,MAAM,eAAe,GAAG;IACpB,aAAa;IACb,iBAAiB,EAAE,cAAc,EAAE,iBAAiB,EAAE,cAAc;IACpE,cAAc,EAAE,qBAAqB,EAAE,cAAc,EAAE,YAAY;IACnE,aAAa,EAAE,eAAe,EAAE,gBAAgB,EAAE,kBAAkB;IACpE,mBAAmB,EAAE,kBAAkB,EAAE,cAAc,EAAE,WAAW;IACpE,eAAe,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,aAAa;IACpE,aAAa,EAAE,WAAW,EAAE,aAAa,EAAE,aAAa,EAAE,YAAY;IACtE,YAAY,EAAE,kBAAkB,EAAE,cAAc,EAAE,mBAAmB;IACrE,cAAc,EAAE,gBAAgB,EAAE,cAAc,EAAE,gBAAgB;IAClE,eAAe,EAAE,eAAe,EAAE,cAAc,EAAE,iBAAiB;IACnE,aAAa,EAAE,eAAe,EAAE,mBAAmB,EAAE,kBAAkB;IACvE,YAAY,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,mBAAmB;IACtE,uBAAuB,EAAE,qBAAqB,EAAE,wBAAwB;IACxE,wBAAwB,EAAE,2BAA2B,EAAE,cAAc;IACrE,aAAa,EAAE,kBAAkB,EAAE,cAAc,EAAE,cAAc;IACjE,eAAe,EAAE,kBAAkB;CACtC,CAAC;AAmBF,MAAM,OAAO,UAAU;;uGAAV,UAAU;wGAAV,UAAU,iBAnCnB,aAAa;QACb,iBAAiB,EAAE,cAAc,EAAE,iBAAiB,EAAE,cAAc;QACpE,cAAc,EAAE,qBAAqB,EAAE,cAAc,EAAE,YAAY;QACnE,aAAa,EAAE,eAAe,EAAE,gBAAgB,EAAE,kBAAkB;QACpE,mBAAmB,EAAE,kBAAkB,EAAE,cAAc,EAAE,WAAW;QACpE,eAAe,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,aAAa;QACpE,aAAa,EAAE,WAAW,EAAE,aAAa,EAAE,aAAa,EAAE,YAAY;QACtE,YAAY,EAAE,kBAAkB,EAAE,cAAc,EAAE,mBAAmB;QACrE,cAAc,EAAE,gBAAgB,EAAE,cAAc,EAAE,gBAAgB;QAClE,eAAe,EAAE,eAAe,EAAE,cAAc,EAAE,iBAAiB;QACnE,aAAa,EAAE,eAAe,EAAE,mBAAmB,EAAE,kBAAkB;QACvE,YAAY,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,mBAAmB;QACtE,uBAAuB,EAAE,qBAAqB,EAAE,wBAAwB;QACxE,wBAAwB,EAAE,2BAA2B,EAAE,cAAc;QACrE,aAAa,EAAE,kBAAkB,EAAE,cAAc,EAAE,cAAc;QACjE,eAAe,EAAE,kBAAkB,aAQ/B,YAAY,aAvBhB,aAAa;QACb,iBAAiB,EAAE,cAAc,EAAE,iBAAiB,EAAE,cAAc;QACpE,cAAc,EAAE,qBAAqB,EAAE,cAAc,EAAE,YAAY;QACnE,aAAa,EAAE,eAAe,EAAE,gBAAgB,EAAE,kBAAkB;QACpE,mBAAmB,EAAE,kBAAkB,EAAE,cAAc,EAAE,WAAW;QACpE,eAAe,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,aAAa;QACpE,aAAa,EAAE,WAAW,EAAE,aAAa,EAAE,aAAa,EAAE,YAAY;QACtE,YAAY,EAAE,kBAAkB,EAAE,cAAc,EAAE,mBAAmB;QACrE,cAAc,EAAE,gBAAgB,EAAE,cAAc,EAAE,gBAAgB;QAClE,eAAe,EAAE,eAAe,EAAE,cAAc,EAAE,iBAAiB;QACnE,aAAa,EAAE,eAAe,EAAE,mBAAmB,EAAE,kBAAkB;QACvE,YAAY,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,mBAAmB;QACtE,uBAAuB,EAAE,qBAAqB,EAAE,wBAAwB;QACxE,wBAAwB,EAAE,2BAA2B,EAAE,cAAc;QACrE,aAAa,EAAE,kBAAkB,EAAE,cAAc,EAAE,cAAc;QACjE,eAAe,EAAE,kBAAkB;wGAoB1B,UAAU,aAVR;QACP,WAAW;QACX,mBAAmB;QACnB,qBAAqB;KACxB,YANG,YAAY;2FAYP,UAAU;kBAjBtB,QAAQ;mBAAC;oBACN,YAAY,EAAE;wBACV,GAAG,eAAe;qBACrB;oBACD,OAAO,EAAE;wBACL,YAAY;qBACf;oBACD,SAAS,EAAE;wBACP,WAAW;wBACX,mBAAmB;wBACnB,qBAAqB;qBACxB;oBACD,OAAO,EAAE;wBACL,GAAG,eAAe;qBACrB;iBAEJ","sourcesContent":["import { NgModule } from '@angular/core';\r\nimport { CommonModule } from '@angular/common';\r\nimport { MessageBuilderService } from '../services/messages-builder.service';\r\nimport { ValidateRuleService } from '../services/validate-rule.service';\r\nimport { UtilService } from '../services/utils.service';\r\nimport { RuleDirective } from './rule.directive';\r\nimport { AboveDirective } from './above/above.directive';\r\nimport { AcceptedDirective } from './accepted/accepted.directive';\r\nimport { AfterDirective } from './after/after.directive';\r\nimport { AlphaDirective } from './alpha/alpha.directive';\r\nimport { AlphaNumericDirective } from './alpha_numeric/alpha-numeric.directive';\r\nimport { ArrayDirective } from './array/array.directive';\r\nimport { BeforeDirective } from './before/before.directive';\r\nimport { BooleanDirective } from './boolean/boolean.directive';\r\nimport { ConfirmedDirective } from './confirmed/confirmed.directive';\r\nimport { DateDirective } from './date/date.directive';\r\nimport { DateFormatDirective } from './date_format/date-format.directive';\r\nimport { DifferentDirective } from './different/different.directive';\r\nimport { EmailDirective } from './email/email.directive';\r\nimport { EndsWithDirective } from './ends_with/ends-with.directive';\r\nimport { EqualsDirective } from './equals/equals.directive';\r\nimport { InDirective } from './in/in.directive';\r\nimport { IncludesDirective } from './includes/includes.directive';\r\nimport { IntegerDirective } from './integer/integer.directive';\r\nimport { IpDirective } from './ip/ip.directive';\r\nimport { Ipv4Directive } from './ipv4/ipv4.directive';\r\nimport { Ipv6Directive } from './ipv6/ipv6.directive';\r\nimport { JsonDirective } from './json/json.directive';\r\nimport { MaxDirective } from './max/max.directive';\r\nimport { MinDirective } from './min/min.directive';\r\nimport { NotEqualsDirective } from './not_equals/not-equals.directive';\r\nimport { NotInDirective } from './not_in/not-in.directive';\r\nimport { NumberDirective } from './number/number.directive';\r\nimport { RangeDirective } from './range/range.directive';\r\nimport { BetweenDirective } from './between/between.directive';\r\nimport { RegexDirective } from './regex/regex.directive';\r\nimport { SameDirective } from './same/same.directive';\r\nimport { StartsWithDirective } from './starts_with/starts-with.directive';\r\nimport { StringDirective } from './string/string.directive';\r\nimport { UnderDirective } from './under/under.directive';\r\nimport { UrlDirective } from './url/url.directive';\r\nimport { AlphaDashDirective } from './alpha_dash/alpha-dash.directive';\r\nimport { NotRegexDirective } from './not_regex/not-regex.directive';\r\nimport { UuidDirective } from './uuid/uuid.directive';\r\nimport { UniqueDirective } from './unique/unique.directive';\r\nimport { CreditCardDirective } from './credit_card/credit-card.directive';\r\nimport { DebitCardDirective } from './debit_card/debit-card.directive';\r\nimport { CvvDirective } from './cvv/cvv.directive';\r\nimport { StrengthDirective } from './strength/strength.directive';\r\nimport { PhoneNoDirective } from './phone_no/phone-no.directive';\r\nimport { RequiredDirective } from '../rule/required/required.directive';\r\nimport { RequiredIfDirective } from './required_if/required-if.directive';\r\nimport { RequiredUnlessDirective } from './required_unless/required-unless.directive';\r\nimport { RequiredWithDirective } from './required_with/required-with.directive';\r\nimport { RequiredWithAllDirective } from './required_with_all/required-with-all.directive';\r\nimport { RequiredWithoutDirective } from './required_without/required-without.directive';\r\nimport { RequiredWithoutAllDirective } from './required_without_all/required-without-all.directive';\r\nimport { MimesDirective } from './mimes/mimes.directive';\r\nimport { SizeDirective } from './size/size.directive';\r\nimport { DimensionDirective } from './dimension/dimension.directive';\r\nimport { ImageDirective } from './image/image.directive';\r\nimport { VideoDirective } from './video/video.directive';\r\nimport { ExistsDirective } from './exists/exists.directive';\r\n\r\n\r\nconst rulesDirectives = [\r\n    RuleDirective,\r\n    RequiredDirective, AboveDirective, AcceptedDirective, AfterDirective,\r\n    AlphaDirective, AlphaNumericDirective, ArrayDirective, UrlDirective,\r\n    DateDirective, BeforeDirective, BooleanDirective, ConfirmedDirective,\r\n    DateFormatDirective, DifferentDirective, EmailDirective, InDirective,\r\n    EqualsDirective, EndsWithDirective, IncludesDirective, Ipv4Directive,\r\n    SameDirective, IpDirective, Ipv6Directive, JsonDirective, MaxDirective,\r\n    MinDirective, NotEqualsDirective, NotInDirective, StartsWithDirective,\r\n    RangeDirective, BetweenDirective, RegexDirective, IntegerDirective,\r\n    NumberDirective, StringDirective, UnderDirective, NotRegexDirective,\r\n    UuidDirective, UniqueDirective, CreditCardDirective, DebitCardDirective,\r\n    CvvDirective, StrengthDirective, PhoneNoDirective, RequiredIfDirective,\r\n    RequiredUnlessDirective, RequiredWithDirective, RequiredWithAllDirective,\r\n    RequiredWithoutDirective, RequiredWithoutAllDirective, MimesDirective,\r\n    SizeDirective, DimensionDirective, ImageDirective, VideoDirective,\r\n    ExistsDirective, AlphaDashDirective\r\n];\r\n\r\n@NgModule({\r\n    declarations: [\r\n        ...rulesDirectives\r\n    ],\r\n    imports: [\r\n        CommonModule\r\n    ],\r\n    providers: [\r\n        UtilService,\r\n        ValidateRuleService,\r\n        MessageBuilderService,\r\n    ],\r\n    exports: [\r\n        ...rulesDirectives\r\n    ],\r\n\r\n})\r\nexport class RuleModule { }\r\n"]}