@crnk/angular-ngrx/expression/forms/crnk.expression.form.validators.base.js

Angular helper library for ngrx-json-api and crnk:

var __extends = (this && this.__extends) || (function () {
    var extendStatics = Object.setPrototypeOf ||
        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
    return function (d, b) {
        extendStatics(d, b);
        function __() { this.constructor = d; }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    };
})();
import { Directive, forwardRef } from "@angular/core";
import { CheckboxRequiredValidator, EmailValidator, MaxLengthValidator, MinLengthValidator, NG_VALIDATORS, PatternValidator, RequiredValidator } from '@angular/forms';
export var EXPRESSION_REQUIRED_VALIDATOR = {
    provide: NG_VALIDATORS,
    useExisting: forwardRef(function () { return ExpressionRequiredValidatorDirective; }),
    multi: true
};
var ExpressionRequiredValidatorDirective = /** @class */ (function (_super) {
    __extends(ExpressionRequiredValidatorDirective, _super);
    function ExpressionRequiredValidatorDirective() {
        return _super !== null && _super.apply(this, arguments) || this;
    }
    ExpressionRequiredValidatorDirective.decorators = [
        { type: Directive, args: [{
                    selector: ':not([type=checkbox])[required][crnkFormExpression],:not([type=checkbox])[required][crnkExpression]',
                    providers: [EXPRESSION_REQUIRED_VALIDATOR],
                    host: { '[attr.required]': 'required ? "" : null' }
                },] },
    ];
    /** @nocollapse */
    ExpressionRequiredValidatorDirective.ctorParameters = function () { return []; };
    return ExpressionRequiredValidatorDirective;
}(RequiredValidator));
export { ExpressionRequiredValidatorDirective };
export var EXPRESSION_EMAIL_VALIDATOR = {
    provide: NG_VALIDATORS,
    useExisting: forwardRef(function () { return ExpressionEmailValidatorDirective; }),
    multi: true
};
var ExpressionEmailValidatorDirective = /** @class */ (function (_super) {
    __extends(ExpressionEmailValidatorDirective, _super);
    function ExpressionEmailValidatorDirective() {
        return _super !== null && _super.apply(this, arguments) || this;
    }
    ExpressionEmailValidatorDirective.decorators = [
        { type: Directive, args: [{
                    selector: '[email][crnkFormExpression],[email][crnkExpression]',
                    providers: [EXPRESSION_EMAIL_VALIDATOR]
                },] },
    ];
    /** @nocollapse */
    ExpressionEmailValidatorDirective.ctorParameters = function () { return []; };
    return ExpressionEmailValidatorDirective;
}(EmailValidator));
export { ExpressionEmailValidatorDirective };
export var EXPRESSION_CHECKBOX_REQUIRED_VALIDATOR = {
    provide: NG_VALIDATORS,
    useExisting: forwardRef(function () { return ExpressionCheckboxRequiredValidatorDirective; }),
    multi: true
};
var ExpressionCheckboxRequiredValidatorDirective = /** @class */ (function (_super) {
    __extends(ExpressionCheckboxRequiredValidatorDirective, _super);
    function ExpressionCheckboxRequiredValidatorDirective() {
        return _super !== null && _super.apply(this, arguments) || this;
    }
    ExpressionCheckboxRequiredValidatorDirective.decorators = [
        { type: Directive, args: [{
                    selector: 'input[type=checkbox][required][crnkFormExpression],input[type=checkbox][required][crnkExpression]',
                    providers: [EXPRESSION_CHECKBOX_REQUIRED_VALIDATOR],
                    host: { '[attr.required]': 'required ? "" : null' }
                },] },
    ];
    /** @nocollapse */
    ExpressionCheckboxRequiredValidatorDirective.ctorParameters = function () { return []; };
    return ExpressionCheckboxRequiredValidatorDirective;
}(CheckboxRequiredValidator));
export { ExpressionCheckboxRequiredValidatorDirective };
export var EXPRESSION_MIN_LENGTH_VALIDATOR = {
    provide: NG_VALIDATORS,
    useExisting: forwardRef(function () { return ExpressionMinLengthValidatorDirective; }),
    multi: true
};
var ExpressionMinLengthValidatorDirective = /** @class */ (function (_super) {
    __extends(ExpressionMinLengthValidatorDirective, _super);
    function ExpressionMinLengthValidatorDirective() {
        return _super !== null && _super.apply(this, arguments) || this;
    }
    ExpressionMinLengthValidatorDirective.decorators = [
        { type: Directive, args: [{
                    selector: '[minlength][crnkFormExpression],[minlength][crnkExpression]',
                    providers: [EXPRESSION_MIN_LENGTH_VALIDATOR],
                    host: { '[attr.minlength]': 'minlength ? minlength : null' }
                },] },
    ];
    /** @nocollapse */
    ExpressionMinLengthValidatorDirective.ctorParameters = function () { return []; };
    return ExpressionMinLengthValidatorDirective;
}(MinLengthValidator));
export { ExpressionMinLengthValidatorDirective };
export var EXPRESSION_MAX_LENGTH_VALIDATOR = {
    provide: NG_VALIDATORS,
    useExisting: forwardRef(function () { return ExpressionMaxLengthValidatorDirective; }),
    multi: true
};
var ExpressionMaxLengthValidatorDirective = /** @class */ (function (_super) {
    __extends(ExpressionMaxLengthValidatorDirective, _super);
    function ExpressionMaxLengthValidatorDirective() {
        return _super !== null && _super.apply(this, arguments) || this;
    }
    ExpressionMaxLengthValidatorDirective.decorators = [
        { type: Directive, args: [{
                    selector: '[maxlength][crnkFormExpression],[maxlength][crnkExpression]',
                    providers: [EXPRESSION_MAX_LENGTH_VALIDATOR],
                    host: { '[attr.maxlength]': 'maxlength ? maxlength : null' }
                },] },
    ];
    /** @nocollapse */
    ExpressionMaxLengthValidatorDirective.ctorParameters = function () { return []; };
    return ExpressionMaxLengthValidatorDirective;
}(MaxLengthValidator));
export { ExpressionMaxLengthValidatorDirective };
export var EXPRESSION_PATTERN_VALIDATOR = {
    provide: NG_VALIDATORS,
    useExisting: forwardRef(function () { return ExpressionPatternValidatorDirective; }),
    multi: true
};
var ExpressionPatternValidatorDirective = /** @class */ (function (_super) {
    __extends(ExpressionPatternValidatorDirective, _super);
    function ExpressionPatternValidatorDirective() {
        return _super !== null && _super.apply(this, arguments) || this;
    }
    ExpressionPatternValidatorDirective.decorators = [
        { type: Directive, args: [{
                    selector: '[pattern][crnkFormExpression],[pattern][crnkExpression]',
                    providers: [EXPRESSION_PATTERN_VALIDATOR],
                    host: { '[attr.pattern]': 'pattern ? pattern : null' }
                },] },
    ];
    /** @nocollapse */
    ExpressionPatternValidatorDirective.ctorParameters = function () { return []; };
    return ExpressionPatternValidatorDirective;
}(PatternValidator));
export { ExpressionPatternValidatorDirective };
//# sourceMappingURL=crnk.expression.form.validators.base.js.map