@sbcore/ng-absolute-validator 14.0.0

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

@@ -0,0 +1,49 @@
+import { distinctUntilChanged, first } from 'rxjs/operators';
+import { Directive, Input } from '@angular/core';
+import { NG_ASYNC_VALIDATORS } from '@angular/forms';
+import { debounceTime, map, of, switchMap } from 'rxjs';
+import { cloneDeep } from '../../common.utils';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/utils.service";
+import * as i2 from "../../services/messages-builder.service";
+export class ExistsDirective {
+    constructor(el, utl, mb) {
+        this.el = el;
+        this.utl = utl;
+        this.mb = mb;
+        this.vmessage = {};
+        this.fieldName = 'field';
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'exists');
+        return control.valueChanges.pipe(debounceTime(200), distinctUntilChanged(), switchMap((value) => value ? this.isValid(value) : of(null)), first());
+    }
+    isValid(value) {
+        let cloned = cloneDeep(this.exists);
+        let request = { ...{ [this.exists.field || this.fieldName]: value }, ...cloned['request'] };
+        let exists = Object.assign(cloned, { request });
+        return this.utl.exists(exists).pipe(map((isValid) => {
+            return !isValid ? { 'exists': this.mb.call('exists', this.fieldName, this.vmessage) } : null;
+        }));
+    }
+}
+ExistsDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ExistsDirective, deps: [{ token: i0.ElementRef }, { token: i1.UtilService }, { token: i2.MessageBuilderService }], target: i0.ɵɵFactoryTarget.Directive });
+ExistsDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: ExistsDirective, selector: "[exists]", inputs: { exists: "exists", message: "message" }, providers: [{ provide: NG_ASYNC_VALIDATORS, useExisting: ExistsDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ExistsDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[exists]',
+                    providers: [{ provide: NG_ASYNC_VALIDATORS, useExisting: ExistsDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.UtilService }, { type: i2.MessageBuilderService }]; }, propDecorators: { exists: [{
+                type: Input,
+                args: ['exists']
+            }], message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,41 @@
+import { Directive, Input } from '@angular/core';
+import { NG_VALIDATORS } from '@angular/forms';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/messages-builder.service";
+import * as i2 from "../../services/utils.service";
+export class ImageDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.fieldName = 'field';
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'image');
+        return this.isValid(this.el.nativeElement.files);
+    }
+    isValid(fileInstance) {
+        if (!!fileInstance && fileInstance.length > 0 && !this.utl.image(fileInstance)) {
+            return { 'image': this.mb.call('image', this.fieldName, this.message) };
+        }
+        return null;
+    }
+}
+ImageDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ImageDirective, deps: [{ token: i1.MessageBuilderService }, { token: i0.ElementRef }, { token: i2.UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+ImageDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: ImageDirective, selector: "[image]", inputs: { message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: ImageDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ImageDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[image]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: ImageDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: i1.MessageBuilderService }, { type: i0.ElementRef }, { type: i2.UtilService }]; }, propDecorators: { message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,45 @@
+import { Directive, Input } from '@angular/core';
+import { NG_VALIDATORS } from '@angular/forms';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/messages-builder.service";
+import * as i2 from "../../services/utils.service";
+export class InDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.fieldName = 'field';
+        this.in = [];
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'in');
+        return this.isValid(control.value);
+    }
+    isValid(value) {
+        if (!!value && !this.utl.in(value, this.in)) {
+            return { 'in': this.mb.call('in', this.fieldName, this.in, this.vmessage) };
+        }
+        return null;
+    }
+}
+InDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: InDirective, deps: [{ token: i1.MessageBuilderService }, { token: i0.ElementRef }, { token: i2.UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+InDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: InDirective, selector: "[in]", inputs: { in: "in", message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: InDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: InDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[in]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: InDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: i1.MessageBuilderService }, { type: i0.ElementRef }, { type: i2.UtilService }]; }, propDecorators: { in: [{
+                type: Input,
+                args: ['in']
+            }], message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,45 @@
+import { Directive, Input } from '@angular/core';
+import { NG_VALIDATORS } from '@angular/forms';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/messages-builder.service";
+import * as i2 from "../../services/utils.service";
+export class IncludesDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.fieldName = 'field';
+        this.includes = [];
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'includes');
+        return this.isValid(control.value);
+    }
+    isValid(value) {
+        if (!!value && !this.utl.includes(value, this.includes)) {
+            return { 'includes': this.mb.call('includes', this.fieldName, this.includes, this.vmessage) };
+        }
+        return null;
+    }
+}
+IncludesDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: IncludesDirective, deps: [{ token: i1.MessageBuilderService }, { token: i0.ElementRef }, { token: i2.UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+IncludesDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: IncludesDirective, selector: "[includes]", inputs: { includes: "includes", message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: IncludesDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: IncludesDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[includes]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: IncludesDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: i1.MessageBuilderService }, { type: i0.ElementRef }, { type: i2.UtilService }]; }, propDecorators: { includes: [{
+                type: Input,
+                args: ['includes']
+            }], message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/rule/index.mjs

@@ -0,0 +1,60 @@
+export * from './above/above.directive';
+export * from './accepted/accepted.directive';
+export * from './after/after.directive';
+export * from './alpha/alpha.directive';
+export * from './alpha_numeric/alpha-numeric.directive';
+export * from './array/array.directive';
+export * from './before/before.directive';
+export * from './boolean/boolean.directive';
+export * from './confirmed/confirmed.directive';
+export * from './date/date.directive';
+export * from './date_format/date-format.directive';
+export * from './different/different.directive';
+export * from './email/email.directive';
+export * from './ends_with/ends-with.directive';
+export * from './equals/equals.directive';
+export * from './in/in.directive';
+export * from './includes/includes.directive';
+export * from './integer/integer.directive';
+export * from './ip/ip.directive';
+export * from './ipv4/ipv4.directive';
+export * from './ipv6/ipv6.directive';
+export * from './json/json.directive';
+export * from './max/max.directive';
+export * from './min/min.directive';
+export * from './not_equals/not-equals.directive';
+export * from './not_in/not-in.directive';
+export * from './number/number.directive';
+export * from './range/range.directive';
+export * from './between/between.directive';
+export * from './regex/regex.directive';
+export * from './same/same.directive';
+export * from './starts_with/starts-with.directive';
+export * from './string/string.directive';
+export * from './under/under.directive';
+export * from './url/url.directive';
+export * from './alpha_dash/alpha-dash.directive';
+export * from './not_regex/not-regex.directive';
+export * from './uuid/uuid.directive';
+export * from './unique/unique.directive';
+export * from './credit_card/credit-card.directive';
+export * from './debit_card/debit-card.directive';
+export * from './cvv/cvv.directive';
+export * from './strength/strength.directive';
+export * from './phone_no/phone-no.directive';
+export * from './required/required.directive';
+export * from './required_if/required-if.directive';
+export * from './required_unless/required-unless.directive';
+export * from './required_with/required-with.directive';
+export * from './required_with_all/required-with-all.directive';
+export * from './required_without/required-without.directive';
+export * from './required_without_all/required-without-all.directive';
+export * from './mimes/mimes.directive';
+export * from './size/size.directive';
+export * from './dimension/dimension.directive';
+export * from './image/image.directive';
+export * from './video/video.directive';
+export * from './exists/exists.directive';
+export * from './rule.directive';
+export * from './rule.module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZy1hYnNvbHV0ZS12YWxpZGF0b3Ivc3JjL2xpYi9ydWxlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYywrQkFBK0IsQ0FBQztBQUM5QyxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyx5Q0FBeUMsQ0FBQztBQUN4RCxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyw2QkFBNkIsQ0FBQztBQUM1QyxjQUFjLGlDQUFpQyxDQUFDO0FBQ2hELGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyxxQ0FBcUMsQ0FBQztBQUNwRCxjQUFjLGlDQUFpQyxDQUFDO0FBQ2hELGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyxpQ0FBaUMsQ0FBQztBQUNoRCxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYywrQkFBK0IsQ0FBQztBQUM5QyxjQUFjLDZCQUE2QixDQUFDO0FBQzVDLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMsbUNBQW1DLENBQUM7QUFDbEQsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyw2QkFBNkIsQ0FBQztBQUM1QyxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyxxQ0FBcUMsQ0FBQztBQUNwRCxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLG1DQUFtQyxDQUFDO0FBQ2xELGNBQWMsaUNBQWlDLENBQUM7QUFDaEQsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMscUNBQXFDLENBQUM7QUFDcEQsY0FBYyxtQ0FBbUMsQ0FBQztBQUNsRCxjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMsK0JBQStCLENBQUM7QUFDOUMsY0FBYywrQkFBK0IsQ0FBQztBQUM5QyxjQUFjLCtCQUErQixDQUFDO0FBQzlDLGNBQWMscUNBQXFDLENBQUM7QUFDcEQsY0FBYyw2Q0FBNkMsQ0FBQztBQUM1RCxjQUFjLHlDQUF5QyxDQUFDO0FBQ3hELGNBQWMsaURBQWlELENBQUM7QUFDaEUsY0FBYywrQ0FBK0MsQ0FBQztBQUM5RCxjQUFjLHVEQUF1RCxDQUFDO0FBQ3RFLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLGlDQUFpQyxDQUFDO0FBQ2hELGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLDJCQUEyQixDQUFDO0FBRTFDLGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyxlQUFlLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2Fib3ZlL2Fib3ZlLmRpcmVjdGl2ZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vYWNjZXB0ZWQvYWNjZXB0ZWQuZGlyZWN0aXZlJztcclxuZXhwb3J0ICogZnJvbSAnLi9hZnRlci9hZnRlci5kaXJlY3RpdmUnO1xyXG5leHBvcnQgKiBmcm9tICcuL2FscGhhL2FscGhhLmRpcmVjdGl2ZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vYWxwaGFfbnVtZXJpYy9hbHBoYS1udW1lcmljLmRpcmVjdGl2ZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vYXJyYXkvYXJyYXkuZGlyZWN0aXZlJztcclxuZXhwb3J0ICogZnJvbSAnLi9iZWZvcmUvYmVmb3JlLmRpcmVjdGl2ZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vYm9vbGVhbi9ib29sZWFuLmRpcmVjdGl2ZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vY29uZmlybWVkL2NvbmZpcm1lZC5kaXJlY3RpdmUnO1xyXG5leHBvcnQgKiBmcm9tICcuL2RhdGUvZGF0ZS5kaXJlY3RpdmUnO1xyXG5leHBvcnQgKiBmcm9tICcuL2RhdGVfZm9ybWF0L2RhdGUtZm9ybWF0LmRpcmVjdGl2ZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vZGlmZmVyZW50L2RpZmZlcmVudC5kaXJlY3RpdmUnO1xyXG5leHBvcnQgKiBmcm9tICcuL2VtYWlsL2VtYWlsLmRpcmVjdGl2ZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vZW5kc193aXRoL2VuZHMtd2l0aC5kaXJlY3RpdmUnO1xyXG5leHBvcnQgKiBmcm9tICcuL2VxdWFscy9lcXVhbHMuZGlyZWN0aXZlJztcclxuZXhwb3J0ICogZnJvbSAnLi9pbi9pbi5kaXJlY3RpdmUnO1xyXG5leHBvcnQgKiBmcm9tICcuL2luY2x1ZGVzL2luY2x1ZGVzLmRpcmVjdGl2ZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vaW50ZWdlci9pbnRlZ2VyLmRpcmVjdGl2ZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vaXAvaXAuZGlyZWN0aXZlJztcclxuZXhwb3J0ICogZnJvbSAnLi9pcHY0L2lwdjQuZGlyZWN0aXZlJztcclxuZXhwb3J0ICogZnJvbSAnLi9pcHY2L2lwdjYuZGlyZWN0aXZlJztcclxuZXhwb3J0ICogZnJvbSAnLi9qc29uL2pzb24uZGlyZWN0aXZlJztcclxuZXhwb3J0ICogZnJvbSAnLi9tYXgvbWF4LmRpcmVjdGl2ZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbWluL21pbi5kaXJlY3RpdmUnO1xyXG5leHBvcnQgKiBmcm9tICcuL25vdF9lcXVhbHMvbm90LWVxdWFscy5kaXJlY3RpdmUnO1xyXG5leHBvcnQgKiBmcm9tICcuL25vdF9pbi9ub3QtaW4uZGlyZWN0aXZlJztcclxuZXhwb3J0ICogZnJvbSAnLi9udW1iZXIvbnVtYmVyLmRpcmVjdGl2ZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vcmFuZ2UvcmFuZ2UuZGlyZWN0aXZlJztcclxuZXhwb3J0ICogZnJvbSAnLi9iZXR3ZWVuL2JldHdlZW4uZGlyZWN0aXZlJztcclxuZXhwb3J0ICogZnJvbSAnLi9yZWdleC9yZWdleC5kaXJlY3RpdmUnO1xyXG5leHBvcnQgKiBmcm9tICcuL3NhbWUvc2FtZS5kaXJlY3RpdmUnO1xyXG5leHBvcnQgKiBmcm9tICcuL3N0YXJ0c193aXRoL3N0YXJ0cy13aXRoLmRpcmVjdGl2ZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vc3RyaW5nL3N0cmluZy5kaXJlY3RpdmUnO1xyXG5leHBvcnQgKiBmcm9tICcuL3VuZGVyL3VuZGVyLmRpcmVjdGl2ZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vdXJsL3VybC5kaXJlY3RpdmUnO1xyXG5leHBvcnQgKiBmcm9tICcuL2FscGhhX2Rhc2gvYWxwaGEtZGFzaC5kaXJlY3RpdmUnO1xyXG5leHBvcnQgKiBmcm9tICcuL25vdF9yZWdleC9ub3QtcmVnZXguZGlyZWN0aXZlJztcclxuZXhwb3J0ICogZnJvbSAnLi91dWlkL3V1aWQuZGlyZWN0aXZlJztcclxuZXhwb3J0ICogZnJvbSAnLi91bmlxdWUvdW5pcXVlLmRpcmVjdGl2ZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vY3JlZGl0X2NhcmQvY3JlZGl0LWNhcmQuZGlyZWN0aXZlJztcclxuZXhwb3J0ICogZnJvbSAnLi9kZWJpdF9jYXJkL2RlYml0LWNhcmQuZGlyZWN0aXZlJztcclxuZXhwb3J0ICogZnJvbSAnLi9jdnYvY3Z2LmRpcmVjdGl2ZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vc3RyZW5ndGgvc3RyZW5ndGguZGlyZWN0aXZlJztcclxuZXhwb3J0ICogZnJvbSAnLi9waG9uZV9uby9waG9uZS1uby5kaXJlY3RpdmUnO1xyXG5leHBvcnQgKiBmcm9tICcuL3JlcXVpcmVkL3JlcXVpcmVkLmRpcmVjdGl2ZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vcmVxdWlyZWRfaWYvcmVxdWlyZWQtaWYuZGlyZWN0aXZlJztcclxuZXhwb3J0ICogZnJvbSAnLi9yZXF1aXJlZF91bmxlc3MvcmVxdWlyZWQtdW5sZXNzLmRpcmVjdGl2ZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vcmVxdWlyZWRfd2l0aC9yZXF1aXJlZC13aXRoLmRpcmVjdGl2ZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vcmVxdWlyZWRfd2l0aF9hbGwvcmVxdWlyZWQtd2l0aC1hbGwuZGlyZWN0aXZlJztcclxuZXhwb3J0ICogZnJvbSAnLi9yZXF1aXJlZF93aXRob3V0L3JlcXVpcmVkLXdpdGhvdXQuZGlyZWN0aXZlJztcclxuZXhwb3J0ICogZnJvbSAnLi9yZXF1aXJlZF93aXRob3V0X2FsbC9yZXF1aXJlZC13aXRob3V0LWFsbC5kaXJlY3RpdmUnO1xyXG5leHBvcnQgKiBmcm9tICcuL21pbWVzL21pbWVzLmRpcmVjdGl2ZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vc2l6ZS9zaXplLmRpcmVjdGl2ZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vZGltZW5zaW9uL2RpbWVuc2lvbi5kaXJlY3RpdmUnO1xyXG5leHBvcnQgKiBmcm9tICcuL2ltYWdlL2ltYWdlLmRpcmVjdGl2ZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vdmlkZW8vdmlkZW8uZGlyZWN0aXZlJztcclxuZXhwb3J0ICogZnJvbSAnLi9leGlzdHMvZXhpc3RzLmRpcmVjdGl2ZSc7XHJcblxyXG5leHBvcnQgKiBmcm9tICcuL3J1bGUuZGlyZWN0aXZlJztcclxuZXhwb3J0ICogZnJvbSAnLi9ydWxlLm1vZHVsZSc7XHJcblxyXG4iXX0=

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

@@ -0,0 +1,41 @@
+import { Directive, Input } from '@angular/core';
+import { NG_VALIDATORS } from '@angular/forms';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/messages-builder.service";
+import * as i2 from "../../services/utils.service";
+export class IntegerDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.fieldName = 'field';
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'integer');
+        return this.isValid(control.value);
+    }
+    isValid(value) {
+        if (!!value && !this.utl.integer(value)) {
+            return { 'integer': this.mb.call('integer', this.fieldName, this.vmessage) };
+        }
+        return null;
+    }
+}
+IntegerDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: IntegerDirective, deps: [{ token: i1.MessageBuilderService }, { token: i0.ElementRef }, { token: i2.UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+IntegerDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: IntegerDirective, selector: "[integer]", inputs: { message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: IntegerDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: IntegerDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[integer]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: IntegerDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: i1.MessageBuilderService }, { type: i0.ElementRef }, { type: i2.UtilService }]; }, propDecorators: { message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,41 @@
+import { Directive, Input } from '@angular/core';
+import { NG_VALIDATORS } from '@angular/forms';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/messages-builder.service";
+import * as i2 from "../../services/utils.service";
+export class IpDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.fieldName = 'field';
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'ip');
+        return this.isValid(control.value);
+    }
+    isValid(value) {
+        if (!!value && !this.utl.ip(value)) {
+            return { 'ip': this.mb.call('ip', this.fieldName, this.vmessage) };
+        }
+        return null;
+    }
+}
+IpDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: IpDirective, deps: [{ token: i1.MessageBuilderService }, { token: i0.ElementRef }, { token: i2.UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+IpDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: IpDirective, selector: "[ip]", inputs: { message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: IpDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: IpDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[ip]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: IpDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: i1.MessageBuilderService }, { type: i0.ElementRef }, { type: i2.UtilService }]; }, propDecorators: { message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,41 @@
+import { Directive, Input } from '@angular/core';
+import { NG_VALIDATORS } from '@angular/forms';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/messages-builder.service";
+import * as i2 from "../../services/utils.service";
+export class Ipv4Directive {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.fieldName = 'field';
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'ipv4');
+        return this.isValid(control.value);
+    }
+    isValid(value) {
+        if (!!value && !this.utl.ipv4(value)) {
+            return { 'ipv4': this.mb.call('ipv4', this.fieldName, this.vmessage) };
+        }
+        return null;
+    }
+}
+Ipv4Directive.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: Ipv4Directive, deps: [{ token: i1.MessageBuilderService }, { token: i0.ElementRef }, { token: i2.UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+Ipv4Directive.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: Ipv4Directive, selector: "[ipv4]", inputs: { message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: Ipv4Directive, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: Ipv4Directive, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[ipv4]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: Ipv4Directive, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: i1.MessageBuilderService }, { type: i0.ElementRef }, { type: i2.UtilService }]; }, propDecorators: { message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,41 @@
+import { Directive, Input } from '@angular/core';
+import { NG_VALIDATORS } from '@angular/forms';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/messages-builder.service";
+import * as i2 from "../../services/utils.service";
+export class Ipv6Directive {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.fieldName = 'field';
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'ipv6');
+        return this.isValid(control.value);
+    }
+    isValid(value) {
+        if (!this.utl.ipv6(value) && !!value) {
+            return { 'ipv6': this.mb.call('ipv6', this.fieldName, this.vmessage) };
+        }
+        return null;
+    }
+}
+Ipv6Directive.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: Ipv6Directive, deps: [{ token: i1.MessageBuilderService }, { token: i0.ElementRef }, { token: i2.UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+Ipv6Directive.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: Ipv6Directive, selector: "[ipv6]", inputs: { message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: Ipv6Directive, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: Ipv6Directive, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[ipv6]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: Ipv6Directive, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: i1.MessageBuilderService }, { type: i0.ElementRef }, { type: i2.UtilService }]; }, propDecorators: { message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,41 @@
+import { Directive, Input } from '@angular/core';
+import { NG_VALIDATORS } from '@angular/forms';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/messages-builder.service";
+import * as i2 from "../../services/utils.service";
+export class JsonDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.fieldName = 'field';
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'json');
+        return this.isValid(control.value);
+    }
+    isValid(value) {
+        if (!!value && !this.utl.json(value)) {
+            return { 'json': this.mb.call('json', this.fieldName, this.vmessage) };
+        }
+        return null;
+    }
+}
+JsonDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: JsonDirective, deps: [{ token: i1.MessageBuilderService }, { token: i0.ElementRef }, { token: i2.UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+JsonDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: JsonDirective, selector: "[json]", inputs: { message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: JsonDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: JsonDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[json]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: JsonDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: i1.MessageBuilderService }, { type: i0.ElementRef }, { type: i2.UtilService }]; }, propDecorators: { message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,51 @@
+import { Directive, Input } from '@angular/core';
+import { NG_VALIDATORS } from '@angular/forms';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/messages-builder.service";
+import * as i2 from "../../services/utils.service";
+export class MaxDirective {
+    constructor(mb, el, utl) {
+        this.mb = mb;
+        this.el = el;
+        this.utl = utl;
+        this.vmessage = {};
+        this.fieldName = 'field';
+        this.fieldName = this.el.nativeElement.name;
+    }
+    set message(data) {
+        this.vmessage = data;
+    }
+    validate(control) {
+        this.utl.setValidationRules(control, 'max');
+        return this.isValid(control.value);
+    }
+    isValid(value) {
+        let fnName = 'max.string';
+        if (this.utl.integer(value)) {
+            fnName = 'max.numeric';
+        }
+        if (this.utl.array(value)) {
+            fnName = 'max.array';
+        }
+        if (!this.utl.max(value, this.max) && !!value) {
+            return { 'max': this.mb.call(fnName, this.fieldName, this.max, this.vmessage) };
+        }
+        return null;
+    }
+}
+MaxDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: MaxDirective, deps: [{ token: i1.MessageBuilderService }, { token: i0.ElementRef }, { token: i2.UtilService }], target: i0.ɵɵFactoryTarget.Directive });
+MaxDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.3.0", type: MaxDirective, selector: "[max]", inputs: { max: "max", message: "message" }, providers: [{ provide: NG_VALIDATORS, useExisting: MaxDirective, multi: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: MaxDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[max]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: MaxDirective, multi: true }]
+                }]
+        }], ctorParameters: function () { return [{ type: i1.MessageBuilderService }, { type: i0.ElementRef }, { type: i2.UtilService }]; }, propDecorators: { max: [{
+                type: Input,
+                args: ['max']
+            }], message: [{
+                type: Input,
+                args: ['message']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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