ngx-form-validator-super
Version:
A super flexible and time saving Validation logic handeling directive for Angular Reactive forms.
852 lines (836 loc) • 37.5 kB
JavaScript
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core'), require('@angular/forms')) :
typeof define === 'function' && define.amd ? define('ngx-form-validator-super', ['exports', '@angular/core', '@angular/forms'], factory) :
(global = global || self, factory(global['ngx-form-validator-super'] = {}, global.ng.core, global.ng.forms));
}(this, (function (exports, i0, forms) { 'use strict';
var NgxFormValidatorComponent = /** @class */ (function () {
function NgxFormValidatorComponent() {
}
NgxFormValidatorComponent.prototype.ngOnInit = function () {
};
return NgxFormValidatorComponent;
}());
NgxFormValidatorComponent.decorators = [
{ type: i0.Component, args: [{
selector: 'lib-ngx-form-validator',
template: "\n <p>\n ngx-form-validator works!\n </p>\n "
},] }
];
NgxFormValidatorComponent.ctorParameters = function () { return []; };
/*! *****************************************************************************
Copyright (c) Microsoft Corporation.
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
***************************************************************************** */
/* global Reflect, Promise */
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b)
if (Object.prototype.hasOwnProperty.call(b, p))
d[p] = b[p]; };
return extendStatics(d, b);
};
function __extends(d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
}
var __assign = function () {
__assign = Object.assign || function __assign(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s)
if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
function __rest(s, e) {
var t = {};
for (var p in s)
if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
t[p] = s[p];
if (s != null && typeof Object.getOwnPropertySymbols === "function")
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
t[p[i]] = s[p[i]];
}
return t;
}
function __decorate(decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
r = Reflect.decorate(decorators, target, key, desc);
else
for (var i = decorators.length - 1; i >= 0; i--)
if (d = decorators[i])
r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
}
function __param(paramIndex, decorator) {
return function (target, key) { decorator(target, key, paramIndex); };
}
function __metadata(metadataKey, metadataValue) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
return Reflect.metadata(metadataKey, metadataValue);
}
function __awaiter(thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try {
step(generator.next(value));
}
catch (e) {
reject(e);
} }
function rejected(value) { try {
step(generator["throw"](value));
}
catch (e) {
reject(e);
} }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
}
function __generator(thisArg, body) {
var _ = { label: 0, sent: function () { if (t[0] & 1)
throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function () { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f)
throw new TypeError("Generator is already executing.");
while (_)
try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
return t;
if (y = 0, t)
op = [op[0] & 2, t.value];
switch (op[0]) {
case 0:
case 1:
t = op;
break;
case 4:
_.label++;
return { value: op[1], done: false };
case 5:
_.label++;
y = op[1];
op = [0];
continue;
case 7:
op = _.ops.pop();
_.trys.pop();
continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
_ = 0;
continue;
}
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) {
_.label = op[1];
break;
}
if (op[0] === 6 && _.label < t[1]) {
_.label = t[1];
t = op;
break;
}
if (t && _.label < t[2]) {
_.label = t[2];
_.ops.push(op);
break;
}
if (t[2])
_.ops.pop();
_.trys.pop();
continue;
}
op = body.call(thisArg, _);
}
catch (e) {
op = [6, e];
y = 0;
}
finally {
f = t = 0;
}
if (op[0] & 5)
throw op[1];
return { value: op[0] ? op[1] : void 0, done: true };
}
}
var __createBinding = Object.create ? (function (o, m, k, k2) {
if (k2 === undefined)
k2 = k;
Object.defineProperty(o, k2, { enumerable: true, get: function () { return m[k]; } });
}) : (function (o, m, k, k2) {
if (k2 === undefined)
k2 = k;
o[k2] = m[k];
});
function __exportStar(m, o) {
for (var p in m)
if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p))
__createBinding(o, m, p);
}
function __values(o) {
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
if (m)
return m.call(o);
if (o && typeof o.length === "number")
return {
next: function () {
if (o && i >= o.length)
o = void 0;
return { value: o && o[i++], done: !o };
}
};
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
}
function __read(o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m)
return o;
var i = m.call(o), r, ar = [], e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
ar.push(r.value);
}
catch (error) {
e = { error: error };
}
finally {
try {
if (r && !r.done && (m = i["return"]))
m.call(i);
}
finally {
if (e)
throw e.error;
}
}
return ar;
}
function __spread() {
for (var ar = [], i = 0; i < arguments.length; i++)
ar = ar.concat(__read(arguments[i]));
return ar;
}
function __spreadArrays() {
for (var s = 0, i = 0, il = arguments.length; i < il; i++)
s += arguments[i].length;
for (var r = Array(s), k = 0, i = 0; i < il; i++)
for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
r[k] = a[j];
return r;
}
;
function __await(v) {
return this instanceof __await ? (this.v = v, this) : new __await(v);
}
function __asyncGenerator(thisArg, _arguments, generator) {
if (!Symbol.asyncIterator)
throw new TypeError("Symbol.asyncIterator is not defined.");
var g = generator.apply(thisArg, _arguments || []), i, q = [];
return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
function verb(n) { if (g[n])
i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
function resume(n, v) { try {
step(g[n](v));
}
catch (e) {
settle(q[0][3], e);
} }
function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
function fulfill(value) { resume("next", value); }
function reject(value) { resume("throw", value); }
function settle(f, v) { if (f(v), q.shift(), q.length)
resume(q[0][0], q[0][1]); }
}
function __asyncDelegator(o) {
var i, p;
return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
}
function __asyncValues(o) {
if (!Symbol.asyncIterator)
throw new TypeError("Symbol.asyncIterator is not defined.");
var m = o[Symbol.asyncIterator], i;
return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
function settle(resolve, reject, d, v) { Promise.resolve(v).then(function (v) { resolve({ value: v, done: d }); }, reject); }
}
function __makeTemplateObject(cooked, raw) {
if (Object.defineProperty) {
Object.defineProperty(cooked, "raw", { value: raw });
}
else {
cooked.raw = raw;
}
return cooked;
}
;
var __setModuleDefault = Object.create ? (function (o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function (o, v) {
o["default"] = v;
};
function __importStar(mod) {
if (mod && mod.__esModule)
return mod;
var result = {};
if (mod != null)
for (var k in mod)
if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
__createBinding(result, mod, k);
__setModuleDefault(result, mod);
return result;
}
function __importDefault(mod) {
return (mod && mod.__esModule) ? mod : { default: mod };
}
function __classPrivateFieldGet(receiver, privateMap) {
if (!privateMap.has(receiver)) {
throw new TypeError("attempted to get private field on non-instance");
}
return privateMap.get(receiver);
}
function __classPrivateFieldSet(receiver, privateMap, value) {
if (!privateMap.has(receiver)) {
throw new TypeError("attempted to set private field on non-instance");
}
privateMap.set(receiver, value);
return value;
}
var PanelLogic = /** @class */ (function () {
function PanelLogic() {
this.IsConsoleShow = false;
this.pos1 = 0;
this.pos2 = 0;
this.pos3 = 0;
this.pos4 = 0;
}
PanelLogic.prototype.updateControlStatus = function (formControl, allControls) {
var _this = this;
this.Control = formControl;
this.AllControls = allControls;
var div = document.getElementById('__XConsl');
if (!this.IsConsoleShow) {
if (div) {
div.style.display = "none";
}
return;
}
if (!div) {
div = document.createElement('div');
//let div = document.createElement('div');
div.style.position = "fixed";
div.id = "__XConsl";
div.style.top = "20px";
div.style.zIndex = "999";
div.style.minHeight = "350px";
div.style.width = "350px";
div.style.overflow = "auto";
div.style.maxHeight = "90vh";
div.style.right = "30px";
div.style.padding = "0px";
div.style.fontSize = "13px";
div.style.border = "1px solid #dfdfdf";
div.style.backgroundColor = "#fff";
div.style.boxShadow = "0px 2px 3px #00000022";
document.getElementsByTagName('body')[0].append(div);
}
div.style.display = "block";
var content = "";
setTimeout(function () {
// this.dragElement(div)
var controlCopy = _this.Control.form.controls;
//let AllControls = this.ValidatorLogic.GetAllControls(controlCopy);
content += "<div id=\"_ngx-super-ff\" style='background-color:#707070;font-family:arial ;text-align:center;color:#fff;padding:4px;'>Form Valid : " + _this.Control.form.valid + " </div>";
content += "<table style=\"width:100%;margin:4px;\" class=\"_ng-super-panel\">";
content += "<tr>";
content += "<th>Control</th><th>Validation</th><th>Value</th>";
content += "</tr>";
_this.AllControls.forEach(function (e) {
content += "<tr>\n <td style=\"text-align:center;font-falimy:arial; border:1px solid #efefef;padding:2px" + (e.errors ? ";border-left:4px solid #DA4667;color:#000;\"" : ";border-left:4px solid #5EFF00;color:#555;") + "\"> " + e.name + " </td> <td> " + JSON.stringify(e.errors) + "</td>\n <td style=\"min-width:100px;\"> " + e.value + " </span>\n </tr>\n ";
});
content += "</table>";
div.innerHTML = content;
}, 200);
};
//dragElement(document.getElementById("mydiv"));
PanelLogic.prototype.dragElement = function (elmnt) {
if (document.getElementById("_ngx-super-ff")) {
// if present, the header is where you move the DIV from:
document.getElementById("_ngx-super-ff").onmousedown = this.dragMouseDown;
}
else {
// otherwise, move the DIV from anywhere inside the DIV:
elmnt.onmousedown = this.dragMouseDown;
}
};
PanelLogic.prototype.dragMouseDown = function (e) {
e = e || window.event;
e.preventDefault();
// get the mouse cursor position at startup:
this.pos3 = e.clientX;
this.pos4 = e.clientY;
document.onmouseup = this.closeDragElement;
// call a function whenever the cursor moves:
document.onmousemove = this.elementDrag;
};
PanelLogic.prototype.elementDrag = function (e) {
e = e || window.event;
e.preventDefault();
// calculate the new cursor position:
this.pos1 = this.pos3 - e.clientX;
this.pos2 = this.pos4 - e.clientY;
this.pos3 = e.clientX;
this.pos4 = e.clientY;
// set the element's new position:
e.style.top = (e.offsetTop - this.pos2) + "px";
e.style.left = (e.offsetLeft - this.pos1) + "px";
};
PanelLogic.prototype.closeDragElement = function () {
// stop moving when mouse button is released:
document.onmouseup = null;
document.onmousemove = null;
};
return PanelLogic;
}());
PanelLogic.ɵprov = i0.ɵɵdefineInjectable({ factory: function PanelLogic_Factory() { return new PanelLogic(); }, token: PanelLogic, providedIn: "root" });
PanelLogic.decorators = [
{ type: i0.Injectable, args: [{ providedIn: 'root' },] }
];
PanelLogic.ctorParameters = function () { return []; };
var ValidatorLogic = /** @class */ (function () {
function ValidatorLogic(panelLogic) {
this.panelLogic = panelLogic;
this.ValidationLabels = {};
}
ValidatorLogic.prototype.GetAllControls = function (controls) {
var extractedControls = [];
for (var ctrl in controls) {
if (controls[ctrl] instanceof forms.FormControl) {
controls[ctrl].name = ctrl;
extractedControls.push(controls[ctrl]);
// Setting control status to valid for elements thata are nto visible on UI
if (!controls[ctrl].nativeElement) {
controls[ctrl].errors = null;
controls[ctrl].status = 'VALID';
}
else if ((!document.body.contains(controls[ctrl].nativeElement))) {
controls[ctrl].setValue(null);
controls[ctrl].errors = null;
controls[ctrl].status = 'VALID';
}
else {
controls[ctrl].updateValueAndValidity({ emitEvent: false });
}
}
if (controls[ctrl] instanceof forms.FormArray) {
extractedControls = __spread(extractedControls, this.GetAllControls(controls[ctrl].controls));
}
if (controls[ctrl] instanceof forms.FormGroup) {
extractedControls = __spread(extractedControls, this.GetAllControls(controls[ctrl].controls));
}
}
return extractedControls;
};
ValidatorLogic.prototype.ValidateControls = function (changedControl) {
var _this = this;
try {
var allControls = this.GetAllControls(this.formControl.form.controls);
var controls_1 = [];
var selectedControlIndex_1 = -1;
var hasError_1 = false;
if (changedControl) {
selectedControlIndex_1 = allControls.findIndex(function (x) { return (x.nativeElement && x.nativeElement.isSameNode(changedControl)); });
controls_1 = allControls.map(function (x, index) {
if (index != selectedControlIndex_1) {
return index;
}
else
return -1;
}).filter(function (x) { return x != -1; });
}
this.errorControl = null;
allControls.forEach(function (formControl, index) {
if (formControl.nativeElement)
if ((!controls_1.includes(index) && formControl.nativeElement.type == "checkbox") || (selectedControlIndex_1 > -1 && (!controls_1.includes(index) || (index == selectedControlIndex_1))) || ((selectedControlIndex_1 == -1) && formControl.nativeElement.type != "checkbox")) {
_this.AddRemoveErrorMsg(false, "", formControl.nativeElement);
// Show validation msg only when forms submits not when control value changes
if (!changedControl || index == selectedControlIndex_1) {
for (var errorName in formControl.errors) {
var erroObj = {};
erroObj[errorName] = formControl.errors[errorName];
hasError_1 = true;
// if(!changedControl)
_this.setErrorControl(formControl.nativeElement);
_this.AddRemoveErrorMsg(true, erroObj, formControl.nativeElement);
}
}
controls_1.push(index);
}
});
if (!hasError_1) {
this.formControl['form'].status = 'VALID';
}
this.panelLogic.updateControlStatus(this.formControl, allControls);
if (this.errorControl && !changedControl) {
// this.toatser.error("Please fill the required details.", "Error !")
this.scrollTo(this.errorControl.ele);
}
return hasError_1;
}
catch (ex) {
console.error(ex);
}
};
ValidatorLogic.prototype.setErrorControl = function (element) {
var yAxis = element.getBoundingClientRect().y;
if (!this.errorControl) {
this.errorControl = { ele: element, y: yAxis };
return;
}
if (this.errorControl.y > yAxis) {
this.errorControl = { ele: element, y: yAxis };
}
};
ValidatorLogic.prototype.scrollTo = function (element) {
if (element) {
element.scrollIntoView({ behavior: "smooth", block: "center", inline: "nearest" });
var t_1 = null;
var func_1 = function () {
t_1 = setTimeout(function () {
element.focus();
window.onscroll = null;
}, 100);
};
func_1();
window.onscroll = function () {
if (t_1) {
clearTimeout(t_1);
t_1 = null;
}
func_1();
};
}
};
ValidatorLogic.prototype.GetValidationType = function (ele) {
if (!ele.attributes["validationHint"]) {
return 1;
}
var validationType = ele.attributes["validationHint"].value;
if (validationType = "borderOnly") {
return 2;
}
return 1;
};
ValidatorLogic.prototype.GetValidationContainer = function (ele) {
if (!ele.attributes["validationContainerId"]) {
return null;
}
return document.getElementById(ele.attributes["validationContainerId"].value) || null;
};
ValidatorLogic.prototype.AddRemoveErrorMsg = function (isAdd, error, ele) {
if (!ele || !ele.parentElement) {
return;
}
var validationContainer = this.GetValidationContainer(ele);
var validationType = this.GetValidationType(ele);
var childs = [];
var errorName = error ? Object.keys(error)[0] : null;
var errorObj = error ? error[errorName] : null;
ele.classList.remove('_BrdrError');
if (validationContainer) {
if (validationContainer.childNodes.length > 0) {
childs = validationContainer.childNodes;
}
}
else {
childs = ele.parentElement.childNodes;
}
if (validationType == 2) {
ele.classList.remove('_BrdrError');
if (validationContainer) {
validationContainer.classList.remove('_BrdrError');
}
}
for (var i = 0; i < childs.length; i++) {
if (childs[i].classList && childs[i].classList.contains('_ErX')) {
childs[i].remove();
}
}
if (isAdd) {
var div_1 = document.createElement('div');
if (validationType == 2) {
if (validationContainer) {
validationContainer.classList.add('_BrdrError');
}
else {
ele.classList.add('_BrdrError');
}
return;
}
ele.classList.add('_BrdrError');
div_1.classList.add('_ErX');
this.GetErrorMsg(errorName, function (errorLabel) {
if (errorLabel && (errorObj.hasOwnProperty('requiredLength') || errorObj.hasOwnProperty('max'))) {
errorLabel = errorLabel.replace('_', errorObj.requiredLength || errorObj.max);
}
div_1.innerHTML = ' <small class="ngx-validation-label " >' + errorLabel + '</small>';
// Adding validation msg to given container element
if (validationContainer) {
//If container has childs
if (validationContainer.childNodes.lenght > 0) {
validationContainer.children[validationContainer.children.length - 1].insertAdjacentElement('beforeend', div_1);
}
else {
// if container has no child
validationContainer.appendChild(div_1);
}
}
else {
// adding validation on from control it self
ele.parentElement.insertAdjacentElement("beforeend", div_1);
}
});
}
};
ValidatorLogic.prototype.GetErrorMsg = function (errorCode, cb) {
var eCode = {
required: "This field is required.",
email: "Invalid email.",
number: "Invalid number",
max: "Maxlength exceeds",
minlength: "Minimum length of this field must be _ .",
invalidOfficerTitle: "Select valid Officer Title.",
requiredExpiryDate: "Please enter card's expiry date.",
inavlidExpiryDate: "Past date is not allowed",
phoneLength: "Phone number must be _ digits long.",
zipLength: "Zip must be _ digits long.",
};
cb(this.ValidationLabels[errorCode]);
};
ValidatorLogic.prototype.TogglePanel = function () {
this.panelLogic.IsConsoleShow = !this.panelLogic.IsConsoleShow;
this.panelLogic.updateControlStatus(this.formControl, this.GetAllControls(this.formControl.form.controls));
};
return ValidatorLogic;
}());
ValidatorLogic.ɵprov = i0.ɵɵdefineInjectable({ factory: function ValidatorLogic_Factory() { return new ValidatorLogic(i0.ɵɵinject(PanelLogic)); }, token: ValidatorLogic, providedIn: "root" });
ValidatorLogic.decorators = [
{ type: i0.Injectable, args: [{ providedIn: 'root' },] }
];
ValidatorLogic.ctorParameters = function () { return [
{ type: PanelLogic }
]; };
var NGXFormValidator = /** @class */ (function () {
function NGXFormValidator(controlContainer, ValidatorLogic, ele) {
var _this = this;
this.controlContainer = controlContainer;
this.ValidatorLogic = ValidatorLogic;
this.ele = ele;
this.btnClickHandler = function (event) {
event.preventDefault();
_this.CallValidation(event.target);
};
this.SetMutationOserver();
}
NGXFormValidator.prototype.ngOnInit = function () {
};
NGXFormValidator.prototype.SetMutationOserver = function () {
var _this = this;
if (!this.ele) {
return;
}
var observer = new MutationObserver(function (mutations) {
var buttons = _this.GetSubmitButtons();
if (buttons && buttons.length > 0) {
buttons.forEach(function (button) {
_this.OnSubmitBtnClick(button);
});
}
});
observer.observe(this.ele.nativeElement, { childList: true, subtree: true, attributes: true });
};
NGXFormValidator.prototype.GetSubmitButtons = function () {
if (!this.ele) {
return;
}
var submitButtons = this.ele.nativeElement.querySelectorAll("button[type=submit]");
return submitButtons;
};
NGXFormValidator.prototype.OnSubmitBtnClick = function (btnRef) {
btnRef.removeEventListener('click', this.btnClickHandler);
btnRef.addEventListener('click', this.btnClickHandler);
};
NGXFormValidator.prototype.CallValidation = function (target) {
this.ValidatorLogic.formControl = this.controlContainer;
if (!this.ValidatorLogic.ValidateControls(null)) {
target.removeEventListener('click', this.btnClickHandler);
target.click();
}
};
NGXFormValidator.prototype.change = function (event) {
this.ValidatorLogic.formControl = this.controlContainer;
if (event.srcElement.attributes.formcontrolname) {
this.ValidatorLogic.ValidateControls(event.srcElement);
}
};
NGXFormValidator.prototype.submit = function (e) {
//e.currentTarget.stopPropagation();
//this.ValidatorLogic.formControl = this.controlContainer
// this.ValidatorLogic.ValidateControls(null);
// e.target.onSubmit=null;
return false;
};
NGXFormValidator.prototype.openPanel = function () {
this.ValidatorLogic.formControl = this.controlContainer;
this.ValidatorLogic.TogglePanel();
};
return NGXFormValidator;
}());
NGXFormValidator.decorators = [
{ type: i0.Directive, args: [{
selector: '[ngxValidator]'
},] }
];
NGXFormValidator.ctorParameters = function () { return [
{ type: forms.ControlContainer },
{ type: ValidatorLogic },
{ type: i0.ElementRef }
]; };
NGXFormValidator.propDecorators = {
change: [{ type: i0.HostListener, args: ["change", ["$event"],] }],
submit: [{ type: i0.HostListener, args: ["submit", ["$event"],] }],
openPanel: [{ type: i0.HostListener, args: ['document:keydown.shift.f8', ['$event'],] }]
};
var NativeElementInjectorDirective = /** @class */ (function () {
function NativeElementInjectorDirective(el, control, model) {
this.el = el;
this.control = control;
this.model = model;
this.appendNativeElement();
}
NativeElementInjectorDirective.prototype.onChange = function (event) {
this.appendNativeElement();
};
NativeElementInjectorDirective.prototype.ngAfterViewInit = function () {
this.appendNativeElement();
};
NativeElementInjectorDirective.prototype.appendNativeElement = function () {
if (!!this.model)
this.model.control.nativeElement = this.el.nativeElement;
else if (this.control.control)
this.control.control.nativeElement = this.el.nativeElement;
};
return NativeElementInjectorDirective;
}());
NativeElementInjectorDirective.decorators = [
{ type: i0.Directive, args: [{
selector: '[ngModel], [formControl], [formControlName]',
},] }
];
NativeElementInjectorDirective.ctorParameters = function () { return [
{ type: i0.ElementRef },
{ type: forms.NgControl },
{ type: forms.NgModel, decorators: [{ type: i0.Optional }] }
]; };
NativeElementInjectorDirective.propDecorators = {
validationContainerId: [{ type: i0.Input, args: ['validationContainerId',] }],
onChange: [{ type: i0.HostListener, args: ['change', ['$event'],] }]
};
var NgxValidatorLabelService = /** @class */ (function () {
function NgxValidatorLabelService(ValidatorLogic) {
this.ValidatorLogic = ValidatorLogic;
}
NgxValidatorLabelService.prototype.setValidationMsg = function (labels) {
this.ValidatorLogic.ValidationLabels = labels;
};
NgxValidatorLabelService.prototype.appendValidationMsg = function (labels) {
this.ValidatorLogic.ValidationLabels = Object.assign({}, labels);
};
NgxValidatorLabelService.prototype.clearValidationMsg = function () {
this.ValidatorLogic.ValidationLabels = {};
};
return NgxValidatorLabelService;
}());
NgxValidatorLabelService.ɵprov = i0.ɵɵdefineInjectable({ factory: function NgxValidatorLabelService_Factory() { return new NgxValidatorLabelService(i0.ɵɵinject(ValidatorLogic)); }, token: NgxValidatorLabelService, providedIn: "root" });
NgxValidatorLabelService.decorators = [
{ type: i0.Injectable, args: [{ providedIn: 'root' },] }
];
NgxValidatorLabelService.ctorParameters = function () { return [
{ type: ValidatorLogic }
]; };
var TestComponent = /** @class */ (function () {
function TestComponent() {
}
TestComponent.prototype.ngOnInit = function () {
};
return TestComponent;
}());
TestComponent.decorators = [
{ type: i0.Component, args: [{
selector: 'lib-test',
template: "<p>test works!</p>\n",
styles: [""]
},] }
];
TestComponent.ctorParameters = function () { return []; };
var NgxFormValidatorModule = /** @class */ (function () {
function NgxFormValidatorModule() {
}
NgxFormValidatorModule.forRoot = function () {
return {
ngModule: NgxFormValidatorModule,
providers: [NgxValidatorLabelService]
};
};
return NgxFormValidatorModule;
}());
NgxFormValidatorModule.decorators = [
{ type: i0.NgModule, args: [{
declarations: [NgxFormValidatorComponent, NGXFormValidator, NativeElementInjectorDirective, TestComponent],
imports: [],
exports: [NgxFormValidatorComponent,
NGXFormValidator,
NativeElementInjectorDirective
],
providers: [
ValidatorLogic,
NgxValidatorLabelService
]
},] }
];
/*
* Public API Surface of ngx-form-validator
*/
/**
* Generated bundle index. Do not edit.
*/
exports.NGXFormValidator = NGXFormValidator;
exports.NativeElementInjectorDirective = NativeElementInjectorDirective;
exports.NgxFormValidatorComponent = NgxFormValidatorComponent;
exports.NgxFormValidatorModule = NgxFormValidatorModule;
exports.NgxValidatorLabelService = NgxValidatorLabelService;
exports.ɵa = ValidatorLogic;
exports.ɵb = PanelLogic;
exports.ɵc = TestComponent;
Object.defineProperty(exports, '__esModule', { value: true });
})));
//# sourceMappingURL=ngx-form-validator-super.umd.js.map