@ng-flexy/form
Version:
Flexy components and tools to build Angular 8+ applications
2,376 lines • 107 kB
JavaScript
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core'), require('jsonata'), require('@angular/forms'), require('@ng-flexy/layout'), require('lodash'), require('@ng-flexy/core'), require('rxjs'), require('rxjs/operators'), require('@ngx-translate/core'), require('@angular/common/http'), require('@angular/common')) :
typeof define === 'function' && define.amd ? define('@ng-flexy/form', ['exports', '@angular/core', 'jsonata', '@angular/forms', '@ng-flexy/layout', 'lodash', '@ng-flexy/core', 'rxjs', 'rxjs/operators', '@ngx-translate/core', '@angular/common/http', '@angular/common'], factory) :
(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global["ng-flexy"] = global["ng-flexy"] || {}, global["ng-flexy"].form = {}), global.ng.core, global.jsonata_, global.ng.forms, global["@ng-flexy/layout"], global.lodash, global["@ng-flexy/core"], global.rxjs, global.rxjs.operators, global["@ngx-translate/core"], global.ng.common.http, global.ng.common));
})(this, (function (exports, i0, jsonata_, i3, i2, lodash, i4, rxjs, operators, core, i1, common) { 'use strict';
function _interopNamespace(e) {
if (e && e.__esModule) return e;
var n = Object.create(null);
if (e) {
Object.keys(e).forEach(function (k) {
if (k !== 'default') {
var d = Object.getOwnPropertyDescriptor(e, k);
Object.defineProperty(n, k, d.get ? d : {
enumerable: true,
get: function () { return e[k]; }
});
}
});
}
n["default"] = e;
return Object.freeze(n);
}
var i0__namespace = /*#__PURE__*/_interopNamespace(i0);
var jsonata___namespace = /*#__PURE__*/_interopNamespace(jsonata_);
var i3__namespace = /*#__PURE__*/_interopNamespace(i3);
var i2__namespace = /*#__PURE__*/_interopNamespace(i2);
var i4__namespace = /*#__PURE__*/_interopNamespace(i4);
var i1__namespace = /*#__PURE__*/_interopNamespace(i1);
var jsonata$4 = jsonata___namespace;
function bindAttributes(schema, nativeEl, renderer, data) {
if (nativeEl && renderer && schema.attributes) {
Object.keys(schema.attributes).forEach(function (attrKey) {
if (typeof schema.attributes[attrKey] === 'object') {
var attrValues_1 = [];
Object.keys(schema.attributes[attrKey]).forEach(function (oKey) {
if (schema.attributes[attrKey][oKey]) {
try {
var is = jsonata$4(schema.attributes[attrKey][oKey]).evaluate(data);
if (is) {
attrValues_1.push(oKey);
}
}
catch (e) {
// do nothing
}
}
});
renderer.setAttribute(nativeEl, attrKey, attrValues_1.join(' '));
}
else if (typeof schema.attributes[attrKey] === 'string') {
renderer.setAttribute(nativeEl, attrKey, schema.attributes[attrKey]);
}
});
}
}
var FlexyFormAttributesDirective = /** @class */ (function () {
function FlexyFormAttributesDirective(renderer, el) {
this.renderer = renderer;
this.el = el;
}
FlexyFormAttributesDirective.prototype.ngOnInit = function () {
var _this = this;
if (this.componentSchema && this.componentSchema.attributes) {
bindAttributes(this.componentSchema, this.el.nativeElement, this.renderer, this.flexyForm.currentData);
this._changesSubscription = this.flexyForm.currentData$.subscribe(function (data) {
bindAttributes(_this.componentSchema, _this.el.nativeElement, _this.renderer, data);
});
}
};
FlexyFormAttributesDirective.prototype.ngOnDestroy = function () {
if (this._changesSubscription) {
this._changesSubscription.unsubscribe();
}
};
return FlexyFormAttributesDirective;
}());
FlexyFormAttributesDirective.decorators = [
{ type: i0.Directive, args: [{
selector: '[flexyFormAttributes]'
},] }
];
FlexyFormAttributesDirective.ctorParameters = function () { return [
{ type: i0.Renderer2 },
{ type: i0.ElementRef }
]; };
FlexyFormAttributesDirective.propDecorators = {
flexyForm: [{ type: i0.Input }],
componentSchema: [{ type: i0.Input }]
};
var LAYOUT_SCHEMA_KEY = 'layoutSchema';
var LAYOUT_FORM_KEY = 'form';
var FlexyFormContainerDirective = /** @class */ (function () {
function FlexyFormContainerDirective(vc, resolver, renderer) {
this.vc = vc;
this.resolver = resolver;
this.renderer = renderer;
}
Object.defineProperty(FlexyFormContainerDirective.prototype, "componentSchema", {
get: function () {
return this._schema;
},
set: function (schema) {
this._schema = schema;
},
enumerable: false,
configurable: true
});
FlexyFormContainerDirective.prototype.ngOnInit = function () {
var _this = this;
if (!this._schema) {
return;
}
if (!this._schema.componentType) {
return;
}
var componentFactory = this.resolver.resolveComponentFactory(this._schema.componentType);
var viewContainerRef = this.vc;
viewContainerRef.clear();
var componentRef = viewContainerRef.createComponent(componentFactory);
componentRef.instance[LAYOUT_SCHEMA_KEY] = this._schema;
componentRef.instance[LAYOUT_FORM_KEY] = this.flexyForm;
this._schema.componentRef = componentRef;
if (this._schema.componentInputs) {
Object.keys(this._schema.componentInputs).forEach(function (key) {
componentRef.instance[key] = _this._schema.componentInputs[key];
});
}
this._componentRef = componentRef;
if (this._schema.attributes) {
bindAttributes(this._schema, this._componentRef.location.nativeElement, this.renderer, this.flexyForm.currentData);
}
this._changesSubscription = this.flexyForm.currentData$.subscribe(function (data) {
if (_this._componentRef) {
bindAttributes(_this.componentSchema, _this._componentRef.location.nativeElement, _this.renderer, data);
}
});
};
FlexyFormContainerDirective.prototype.ngOnDestroy = function () {
if (this._changesSubscription) {
this._changesSubscription.unsubscribe();
}
};
return FlexyFormContainerDirective;
}());
FlexyFormContainerDirective.decorators = [
{ type: i0.Directive, args: [{
selector: '[flexyFormContainer]'
},] }
];
FlexyFormContainerDirective.ctorParameters = function () { return [
{ type: i0.ViewContainerRef },
{ type: i0.ComponentFactoryResolver },
{ type: i0.Renderer2 }
]; };
FlexyFormContainerDirective.propDecorators = {
flexyForm: [{ type: i0.Input }],
componentSchema: [{ type: i0.Input }]
};
var COMPLEX_TYPE_INDEX_MARKER = '{%}';
exports.FlexyFormFieldType = void 0;
(function (FlexyFormFieldType) {
FlexyFormFieldType["String"] = "string";
FlexyFormFieldType["Number"] = "number";
FlexyFormFieldType["Boolean"] = "boolean";
FlexyFormFieldType["Array"] = "array";
FlexyFormFieldType["Group"] = "group";
})(exports.FlexyFormFieldType || (exports.FlexyFormFieldType = {}));
/*! *****************************************************************************
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) {
if (typeof b !== "function" && b !== null)
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
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;
}
/** @deprecated */
function __spread() {
for (var ar = [], i = 0; i < arguments.length; i++)
ar = ar.concat(__read(arguments[i]));
return ar;
}
/** @deprecated */
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 __spreadArray(to, from, pack) {
if (pack || arguments.length === 2)
for (var i = 0, l = from.length, ar; i < l; i++) {
if (ar || !(i in from)) {
if (!ar)
ar = Array.prototype.slice.call(from, 0, i);
ar[i] = from[i];
}
}
return to.concat(ar || Array.prototype.slice.call(from));
}
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, state, kind, f) {
if (kind === "a" && !f)
throw new TypeError("Private accessor was defined without a getter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
throw new TypeError("Cannot read private member from an object whose class did not declare it");
return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
}
function __classPrivateFieldSet(receiver, state, value, kind, f) {
if (kind === "m")
throw new TypeError("Private method is not writable");
if (kind === "a" && !f)
throw new TypeError("Private accessor was defined without a setter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
throw new TypeError("Cannot write private member to an object whose class did not declare it");
return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
}
exports.FlexyFormsValidators = void 0;
(function (FlexyFormsValidators) {
function notEmptyValidator(control) {
if (!control) {
return null;
}
if (FlexyFormsValidators.isEmpty(control)) {
return {
'not-empty': true
};
}
return null;
}
FlexyFormsValidators.notEmptyValidator = notEmptyValidator;
function noWhitespaceValidator(control) {
if (!control) {
return null;
}
if ((control.value || '').trim().length === 0) {
return { whitespace: true };
}
return null;
}
FlexyFormsValidators.noWhitespaceValidator = noWhitespaceValidator;
function emailValidator(control) {
if (!control) {
return null;
}
var re = new RegExp([
'^(([^<>()\\[\\]\\\\.,;:!#\\s@"]+(\\.[^<>()\\[\\]\\\\.,;:!#\\s@"]+)*)|(".+"))@',
'((\\[[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}])|(([a-zA-Z\\-0-9]+\\.)',
'+[a-zA-Z]{2,})|([a-zA-Z\\-0-9]+))$'
].join(''));
if (!FlexyFormsValidators.isEmpty(control) && !re.test(control.value)) {
return {
'invalid-email': {
currentValue: control.value
}
};
}
return null;
}
FlexyFormsValidators.emailValidator = emailValidator;
function booleanValidator(control) {
if (!control) {
return null;
}
if (!FlexyFormsValidators.isEmpty(control) && typeof control.value !== 'boolean') {
return {
'invalid-boolean': {
currentValue: control.value
}
};
}
return null;
}
FlexyFormsValidators.booleanValidator = booleanValidator;
function integerValidator(control) {
if (!control) {
return null;
}
var re = /^-?\d+$/;
if (!FlexyFormsValidators.isEmpty(control) && !re.test(control.value)) {
return {
'invalid-integer': {
currentValue: control.value
}
};
}
return null;
}
FlexyFormsValidators.integerValidator = integerValidator;
function minValidator(min) {
return function (control) {
if (!control) {
return null;
}
if (!(min || min === 0)) {
return {
'invalid-min': {
wrongConfiguration: true
}
};
}
var notNumber = FlexyFormsValidators.numberValidator(control);
if (notNumber) {
return notNumber;
}
if ((!FlexyFormsValidators.isEmpty(control) || control.value === 0) && control.value < min) {
return {
'invalid-min': {
minimumValue: min,
currentValue: control.value
}
};
}
return null;
};
}
FlexyFormsValidators.minValidator = minValidator;
function maxValidator(max) {
return function (control) {
if (!control) {
return null;
}
if (!(max || max === 0)) {
return {
'invalid-max': {
wrongConfiguration: true
}
};
}
var notNumber = FlexyFormsValidators.numberValidator(control);
if (notNumber) {
return notNumber;
}
if ((!FlexyFormsValidators.isEmpty(control) || control.value === 0) && control.value > max) {
return {
'invalid-max': {
maximumValue: max,
currentValue: control.value
}
};
}
return null;
};
}
FlexyFormsValidators.maxValidator = maxValidator;
function numberValidator(control) {
if (!control) {
return null;
}
var re = /^-?(\d+\.?\d*)$|^(\d*\.?\d+)$/;
if (!FlexyFormsValidators.isEmpty(control) && !re.test(control.value)) {
return {
'invalid-number': {
currentValue: control.value
}
};
}
return null;
}
FlexyFormsValidators.numberValidator = numberValidator;
function minLengthArray(min) {
return function (control) {
if (!control) {
return null;
}
if (!(min || min === 0)) {
return {
'min-length-array': {
wrongConfiguration: true
}
};
}
if (control.value && Array.isArray(control.value) && control.value.length >= min) {
return null;
}
return {
'min-length-array': {
minimumLength: min,
currentLength: control.value
}
};
};
}
FlexyFormsValidators.minLengthArray = minLengthArray;
function maxLengthArray(max) {
return function (control) {
if (!control) {
return null;
}
if (!(max || max === 0)) {
return {
'max-length-array': {
wrongConfiguration: true
}
};
}
if (control.value && control.value.length <= max) {
return null;
}
return {
'max-length-array': {
maximumLength: max,
currentLength: control.value
}
};
};
}
FlexyFormsValidators.maxLengthArray = maxLengthArray;
function isEmpty(control) {
if (!control) {
return null;
}
if (!control.value || (Array.isArray(control.value) && control.value.length === 0)) {
return true;
}
else {
return false;
}
}
FlexyFormsValidators.isEmpty = isEmpty;
function urlValidator(control) {
if (!control) {
return null;
}
var re = new RegExp([
'((([A-Za-z]{3,9}:(?:\\/\\/)?)(?:[\\-;:&=\\+\\$,\\w]+@)?[A-Za-z0-9\\.\\-]',
'+|(?:www\\.|[\\-;:&=\\+\\$,\\w]+@)[A-Za-z0-9\\.\\-]+)((?:\\/[\\+~%\\/\\.\\w\\-_]*)?\\??',
'(?:[\\-\\+=&;%@\\.\\w_]*)#?(?:[\\.\\!\\/\\\\\\w]*))?)'
].join(''));
if (!FlexyFormsValidators.isEmpty(control) && !re.test(control.value)) {
return {
'invalid-url': {
currentValue: control.value
}
};
}
return null;
}
FlexyFormsValidators.urlValidator = urlValidator;
function crossFieldValidator(fields) {
return function (control) {
if (!control) {
return null;
}
if (!(fields && fields.lower && fields.greater)) {
return {
'cross-field-invalid': {
wrongConfiguration: true
}
};
}
var lower = getControl(fields.lower.path, control);
var greater = getControl(fields.greater.path, control);
if (!(greater && greater.valid && lower && lower.valid && greater.value < lower.value)) {
return null;
}
return {
'cross-field-invalid': {
greater: fields.greater.name,
greaterPath: fields.greater.path,
greaterValue: greater && greater.value,
lower: fields.lower.name,
lowerPath: fields.lower.path,
lowerValue: lower && lower.value
}
};
};
}
FlexyFormsValidators.crossFieldValidator = crossFieldValidator;
function crossFieldMinValidator(minPath) {
return function (control) {
if (!control) {
return null;
}
if (!minPath) {
return {
'invalid-min': {
wrongConfiguration: true
}
};
}
var min = getControl(minPath, control);
if (!(min && control.valid && control.value < min.value)) {
return null;
}
return {
'invalid-min': {
minimumValue: min.value,
currentValue: control.value
}
};
};
}
FlexyFormsValidators.crossFieldMinValidator = crossFieldMinValidator;
function crossFieldMaxValidator(maxPath) {
return function (control) {
if (!control) {
return null;
}
if (!maxPath) {
return {
'invalid-max': {
wrongConfiguration: true
}
};
}
var max = getControl(maxPath, control);
if (!(max && control.valid && control.value > max.value)) {
return null;
}
return {
'invalid-max': {
maximumValue: max.value,
currentValue: control.value
}
};
};
}
FlexyFormsValidators.crossFieldMaxValidator = crossFieldMaxValidator;
function crossFieldAbsoluteMinValidator(minPath) {
return function (control) {
if (!control) {
return null;
}
if (!minPath) {
return {
'absolute-min-invalid': {
wrongConfiguration: true
}
};
}
var min = getControl(minPath, control);
if (min && control.valid && min.valid && Math.abs(control.value) >= min.value) {
return null;
}
return {
'absolute-min-invalid': {
min: min.value,
currentValue: control.value
}
};
};
}
FlexyFormsValidators.crossFieldAbsoluteMinValidator = crossFieldAbsoluteMinValidator;
function forbiddenValuesValidator(forbiddenValues) {
return function (control) {
if (!control) {
return null;
}
if (!forbiddenValues) {
return {
'forbidden-value': {
wrongConfiguration: true
}
};
}
if (!forbiddenValues.includes(control.value)) {
return null;
}
return {
'forbidden-value': {
value: control.value
}
};
};
}
FlexyFormsValidators.forbiddenValuesValidator = forbiddenValuesValidator;
function arrayUniqueFieldsValidator(data) {
return function (control) {
if (!control || !control.controls) {
return null;
}
if (!(data && data.path)) {
return {
'value-duplicate': {
wrongConfiguration: true
}
};
}
var comparedValues = [];
control.controls.forEach(function (item) {
var compared = getControl(data.path, item);
if (compared) {
comparedValues.push(compared.value);
}
});
if (lodash.uniq(comparedValues).length === comparedValues.length) {
return null;
}
return {
'value-duplicate': {
field: data.fieldName
}
};
};
}
FlexyFormsValidators.arrayUniqueFieldsValidator = arrayUniqueFieldsValidator;
function getControl(path, control) {
var arrayPath = [];
if (Array.isArray(path)) {
arrayPath = path;
}
else if (path) {
var parents = ('' + path).indexOf('../') !== -1 ? path.split('../') : [path];
var sPath = '' + parents.pop();
var stringPath = sPath.split('.').map(function (i) {
if (i.match(/^[0-9]+$/)) {
return parseInt(i, 10);
}
else {
return i;
}
});
parents.fill('../');
parents.push.apply(parents, __spreadArray([], __read(stringPath)));
arrayPath = parents;
}
arrayPath.forEach(function (i) {
if (control && control.parent && i === '../') {
control = control.parent;
}
else if (control && control.controls) {
control = Number.isInteger(i) ? control.get(Object.keys(control.controls)[i]) : control.controls[i];
}
});
return control;
}
})(exports.FlexyFormsValidators || (exports.FlexyFormsValidators = {}));
var HIDDEN_IF_GROUP_NAME = '__if__';
var HIDDEN_CALC_GROUP_NAME = '__calc__';
function parseFormJson(json) {
if (Array.isArray(json)) {
return parseFormVersion1(json);
}
else if (json.schemaVersion === 1) {
return parseFormVersion1(json.schema);
}
else {
var schema = json.schema;
assignHiddenNames(schema);
checkSchema(schema);
return json.schema;
}
}
function checkSchema(schema) {
if (schema && Array.isArray(schema)) {
schema.forEach(function (jsonItem, index) {
if (jsonItem.if &&
(jsonItem.name || jsonItem.type)) {
console.warn('Wrong if schema', jsonItem);
}
if (jsonItem.children) {
checkSchema(jsonItem.children);
}
});
}
}
function assignHiddenNames(schema) {
if (schema && Array.isArray(schema)) {
schema.forEach(function (jsonItem, index) {
// if ((jsonItem as FlexyFormIfJsonSchema).if && !(jsonItem as FlexyFormFieldLayoutJsonSchema).type) {
// (jsonItem as FlexyFormFieldLayoutJsonSchema).type = FlexyFormFieldType.Group;
// }
if (jsonItem.calc && !jsonItem.name) {
jsonItem.name =
HIDDEN_CALC_GROUP_NAME +
'.' +
(jsonItem.id
? jsonItem.id
: 'ui-' +
Math.random()
.toString(36)
.substr(2, 9));
}
if (jsonItem.children) {
assignHiddenNames(jsonItem.children);
}
});
}
}
function parseFormVersion1(json) {
var parsed = [];
json.forEach(function (item) {
parsed.push(parseFormVersion1Item(item));
});
return parsed;
}
function parseFormVersion1Item(item) {
var schema = {};
if (item.properties && item.properties.class) {
if (!schema.attributes) {
schema.attributes = {};
}
schema.attributes.class = item.properties.class;
}
if (item.component) {
Object.assign(schema, {
component: item.component,
properties: item.componentInputs ? item.componentInputs : {}
});
}
if (item.controlGroupName) {
Object.assign(schema, {
name: item.controlGroupName,
type: exports.FlexyFormFieldType.Group,
validators: item.validators,
groupKey: item.groupKey,
items: item.items ? parseFormVersion1Item(item.items) : void 0,
indexDef: item.itemKeyDef,
indexPattern: item.itemKeyPattern,
indexGenPattern: item.itemKeyGen
});
}
else if (item.controlArrayName) {
Object.assign(schema, {
name: item.controlArrayName,
type: exports.FlexyFormFieldType.Array,
validators: item.validators,
items: item.items ? parseFormVersion1Item(item.items) : void 0,
indexDef: item.itemIndexDef
});
}
else if (item.controlName) {
Object.assign(schema, {
name: item.controlName,
validators: item.validators
});
}
if (item.children) {
schema.children = parseFormVersion1(item.children);
}
return schema;
}
function replaceMarker(s, marker, key) {
return s.split(marker).join('' + key);
}
var jsonata$3 = jsonata___namespace;
var ifExpressionsCache = {};
var calculatedExpresionCache = {};
exports.FlexyFormDataMode = void 0;
(function (FlexyFormDataMode) {
FlexyFormDataMode["All"] = "all";
FlexyFormDataMode["Dirty"] = "dirty";
FlexyFormDataMode["Touched"] = "toched";
})(exports.FlexyFormDataMode || (exports.FlexyFormDataMode = {}));
function findErrors(schema, currentData) {
var e_1, _a;
var errors = {};
var _loop_1 = function (item) {
if (checkIf(item, currentData) && item.items) {
item.items.forEach(function (aItem, index) {
var arrItemError = findErrors([aItem], currentData);
if (arrItemError && Object.values(arrItemError).length) {
errors[item.formName + '.' + index] = arrItemError;
}
});
}
else if (checkIf(item, currentData) &&
item.formName &&
item.formControl &&
item.formControl.invalid) {
errors[item.formName] = item.formControl.errors;
}
if (checkIf(item, currentData) && item.children) {
Object.assign(errors, findErrors(item.children, currentData));
}
};
try {
for (var schema_1 = __values(schema), schema_1_1 = schema_1.next(); !schema_1_1.done; schema_1_1 = schema_1.next()) {
var item = schema_1_1.value;
_loop_1(item);
}
}
catch (e_1_1) { e_1 = { error: e_1_1 }; }
finally {
try {
if (schema_1_1 && !schema_1_1.done && (_a = schema_1.return)) _a.call(schema_1);
}
finally { if (e_1) throw e_1.error; }
}
return errors;
}
function findSchema(fieldName, schema) {
var e_2, _a;
try {
for (var schema_2 = __values(schema), schema_2_1 = schema_2.next(); !schema_2_1.done; schema_2_1 = schema_2.next()) {
var item = schema_2_1.value;
if (item.formName && item.formName === fieldName) {
return item;
}
else if (item.children) {
var childSchema = findSchema(fieldName, item.children);
if (childSchema) {
return childSchema;
}
}
}
}
catch (e_2_1) { e_2 = { error: e_2_1 }; }
finally {
try {
if (schema_2_1 && !schema_2_1.done && (_a = schema_2.return)) _a.call(schema_2);
}
finally { if (e_2) throw e_2.error; }
}
return null;
}
function calculate(calcExp, data) {
var value;
try {
if (!calculatedExpresionCache[calcExp]) {
calculatedExpresionCache[calcExp] = jsonata$3(calcExp);
}
value = calculatedExpresionCache[calcExp].evaluate(data);
}
catch (e) {
// console.error(e);
value = null;
}
return value;
}
function getSchemaData$1(schemas, currentData, mode) {
if (mode === void 0) { mode = exports.FlexyFormDataMode.All; }
var data = {};
if (schemas) {
schemas.forEach(function (schema) {
var fieldSchema = schema;
if (checkIf(fieldSchema, currentData)) {
var isFormControl = fieldSchema.formControl && fieldSchema.formName;
if (isFormControl && fieldSchema.formControl instanceof i3.FormControl) {
if (checkSchemaData(fieldSchema.formControl, mode)) {
lodash.set(data, fieldSchema.formName, fieldSchema.formControl.value);
}
}
else if (isFormControl && fieldSchema.formControl instanceof i3.FormArray) {
var arrayData = getArrayData(fieldSchema, currentData, mode, data);
if (mode === exports.FlexyFormDataMode.All) {
lodash.set(data, fieldSchema.formName, Object.values(arrayData));
}
else if (!isInputEmpty(arrayData)) {
lodash.set(data, fieldSchema.formName, arrayData);
}
}
if (checkIf(fieldSchema, currentData)) {
data = lodash.merge(data, getSchemaData$1(fieldSchema.children, currentData, mode));
}
}
});
}
return data;
}
function findRemoved(allData, originalData) {
var removed = {};
if (originalData) {
Object.keys(originalData).forEach(function (key) {
var path = key;
if (!isInputEmpty(originalData[key]) && isInputEmpty(allData[key])) {
lodash.set(removed, path, null);
}
else if (originalData[key] && Array.isArray(originalData[key])) {
originalData[key].forEach(function (item, index) {
if (!isInputEmpty(item) && isInputEmpty(allData[key][index])) {
if (!lodash.has(removed, path)) {
lodash.set(removed, path, {});
}
var v = lodash.get(removed, path);
v['' + index] = null;
}
else if (item && isObject(item)) {
var founded = findRemoved(allData[key][index], item);
if (founded && !isInputEmpty(founded)) {
if (!lodash.has(removed, path)) {
lodash.set(removed, path, {});
}
var v = lodash.get(removed, path);
v['' + index] = founded;
}
}
});
}
else if (originalData[key] && isObject(originalData[key])) {
var founded = findRemoved(allData[key], originalData[key]);
if (founded && !isInputEmpty(founded)) {
lodash.set(removed, path, founded);
}
}
});
}
return removed;
}
function clearEmptyArrayAndObjects(data) {
if (data) {
if (isObject(data)) {
Object.keys(data).forEach(function (key) {
if (isEmptyStructure(data[key])) {
delete data[key];
}
else if (isObject(data[key])) {
clearEmptyArrayAndObjects(data[key]);
}
});
}
}
}
function isObject(a) {
return !!a && a.constructor === Object;
}
function checkIf(fieldSchema, currentData) {
if (!fieldSchema.if) {
return true;
}
var ifName = 'IF_' + fieldSchema.if;
var ret;
try {
if (!ifExpressionsCache[ifName]) {
ifExpressionsCache[ifName] = jsonata$3(fieldSchema.if);
}
ret = ifExpressionsCache[ifName].evaluate(currentData ? currentData : {});
}
catch (e) {
// console.error(e);
ret = null;
}
return !!ret;
}
function getArrayData(fieldSchema, currentData, mode, data) {
var arrayData = {};
fieldSchema.items.forEach(function (item, index) {
var itemFormControl = item.formControl;
if (!itemFormControl || checkSchemaData(itemFormControl, mode)) {
if (item.children) {
var itemData = getSchemaData$1(item.children, currentData, mode);
if (!isInputEmpty(itemData)) {
arrayData['' + index] = itemData;
}
}
else {
arrayData['' + index] = item.formControl.value;
}
}
});
return arrayData;
}
function checkSchemaData(control, mode) {
return (control &&
(mode === exports.FlexyFormDataMode.All ||
(mode === exports.FlexyFormDataMode.Dirty && control.dirty) ||
(mode === exports.FlexyFormDataMode.Touched && control.touched)));
}
function isInputEmpty(v) {
return v === void 0 || v === '';
}
function isEmptyStructure(data) {
var ret = true;
if (Array.isArray(data)) {
if (data.length > 0) {
data.forEach(function (item) {
ret = ret && isEmptyStructure(item);
});
}
}
else if (isObject(data)) {
if (Object.keys(data).length > 0) {
Object.keys(data).forEach(function (key) {
ret = ret && isEmptyStructure(data[key]);
});
}
}
else {
return isInputEmpty(data);
}
return ret;
}
var FlexyForm = /** @class */ (function (_super) {
__extends(FlexyForm, _super);
function FlexyForm(formGroup, schema, data) {
var _this = _super.call(this, schema) || this;
_this.isStarted = false;
_this._calculatedRefs = {};
_this._currentDataSubject = new rxjs.BehaviorSubject(data);
_this.currentData$ = _this._currentDataSubject.asObservable();
_this.formGroup = formGroup;
_this.schema = schema;
_this._initCalculatedRefs(schema);
_this._originalData = lodash.cloneDeep(data);
_this._setCurrentData();
// refresh attributes
_this._setCurrentData();
// jump to next tick
// setTimeout(() => {
_this._subscribeChangesAndCalculate();
return _this;
// });
}
Object.defineProperty(FlexyForm.prototype, "valid", {
get: function () {
return !this.getAllErrors();
},
enumerable: false,
configurable: true
});
FlexyForm.prototype.getAllData = function () {
var data = lodash.cloneDeep(getSchemaData$1(this.schema, this.currentData));
this._clearHiddenData(data);
return data;
};
// @deprecated
FlexyForm.prototype.getDirtyData = function () {
var data = lodash.cloneDeep(getSchemaData$1(this.schema, this.currentData, exports.FlexyFormDataMode.Dirty));
this._clearHiddenData(data);
clearEmptyArrayAndObjects(data);
var allData = this.getAllData();
var removed = findRemoved(allData, this._originalData);
clearEmptyArrayAndObjects(removed);
return lodash.merge(data, removed);
};
FlexyForm.prototype.getAllErrors = function () {
return this._lastErrors;
};
FlexyForm.prototype.containsFieldSchema = function (fieldName) {
return !!findSchema(fieldName, this.schema);
};
FlexyForm.prototype.getFieldSchema = function (fieldName) {
return findSchema(fieldName, this.schema);
};
FlexyForm.prototype.getFieldInstance = function (fieldName) {
var schema = findSchema(fieldName, this.schema);
if (schema && schema.componentRef) {
return schema.componentRef.instance;
}
return null;
};
FlexyForm.prototype._subscribeChangesAndCalculate = function () {
var _this = this;
this._setCurrentData();
this.isStarted = true;
// this._setCurrentData();
this._changesSubscription = this.formGroup.valueChanges.subscribe(function (data) {
var hash = _this.currentDataHash;
_this._setCurrentData();
if (hash !== _this.currentDataHash) {
_this._currentDataSubject.next(_this.currentData);
}
});
this._currentDataSubject.next(this.currentData);
};
FlexyForm.prototype._setCurrentData = function () {
this.currentData = getSchemaData$1(this.schema, this.currentData);
this.currentDataHash = JSON.stringify(this.currentData);
this._calculate();
this.currentData = getSchemaData$1(this.schema, this.currentData);
this.currentDataHash = JSON.stringify(this.currentData);
var errors = findErrors(this.schema, this.currentData);
this._lastErrors = errors && Object.keys(errors).length ? errors : null;
};
FlexyForm.prototype._initCalculatedRefs = function (schema) {
var _this = this;
if (schema) {
schema.forEach(function (schemaItem) {
if (schemaItem.formName && schemaItem.formControl && schemaItem.calc) {
_this._calculatedRefs[schemaItem.formName] = {
calc: schemaItem.calc,
control: schemaItem.formControl
};
}
if (schemaItem.children) {
_this._initCalculatedRefs(schemaItem.children);
}
});
}
};
FlexyForm.prototype._calculate = function () {
var _this = this;
if (this._calculatedRefs) {
Object.values(this._calculatedRefs).forEach(function (calc) {
var value = calculate(calc.calc, _this.currentData);
if (value !== calc.control.value) {
calc.control.setValue(value);
calc.control.markAsDirty();
}
});
}
};
FlexyForm.prototype._clearHiddenData = function (data) {
if (data[HIDDEN_CALC_GROUP_NAME]) {
delete data[HIDDEN_CALC_GROUP_NAME];
}
};
return FlexyForm;
}(i2.FlexyLayout));
var FLEXY_FORM_VALIDATORS = new i0.InjectionToken('FLEXY_FORM_VALIDATORS');
var INPUTS_READONLY_KEY = 'readonly';
var SCHEMA_CONTROL_NAME_KEY = 'name';
var SCHEMA_GROUP_KEY = 'groupKey';
var SCHEMA_COMPONENT_INPUTS_KEY = 'properties';
var SCHEMA_DEFAULT_KEY = 'default';
var ɵ0 = function () { return i3.Validators.required; }, ɵ1 = function (data) { return i3.Validators.maxLength(data); }, ɵ2 = function (data) { return i3.Validators.minLength(data); }, ɵ3 = function (data) { return exports.FlexyFormsValidators.minValidator(data); }, ɵ4 = function (data) { return exports.FlexyFormsValidators.maxValidator(data); }, ɵ5 = function () { return exports.FlexyFormsValidators.numberValidator; }, ɵ6 = function () { return exports.FlexyFormsValidators.integerValidator; }, ɵ7 = function () { return exports.FlexyFormsValidators.booleanValidator; }, ɵ8 = function () { return exports.FlexyFormsValidators.emailValidator; }, ɵ9 = function () { return exports.FlexyFormsValidators.noWhitespaceValidator; }, ɵ10 = function () { return exports.FlexyFormsValidators.notEmptyValidator; }, ɵ11 = function (data) { return i3.Validators.pattern(data); }, ɵ12 = function (data) { return exports.FlexyFormsValidators.crossFieldValidator(data); }, ɵ13 = function (data) { return exports.FlexyFormsValidators.crossFieldMinValidator(data); }, ɵ14 = function (data) { return exports.FlexyFormsValidators.crossFieldMaxValidator(data); }, ɵ15 = function (data) { return exports.FlexyFormsValidators.crossFieldAbsoluteMinValidator(data); }, ɵ16 = function (data) { return exports.FlexyFormsValidators.forbiddenValuesValidator(data); }, ɵ17 = function (data) { return exports.FlexyFormsValidators.arrayUniqueFieldsValidator(data); }, ɵ18 = function (data) { return exports.FlexyFormsValidators.minLengthArray(data); }, ɵ19 = function (data) { return exports.FlexyFormsValidators.maxLengthArray(data); };
var DEFAULT_VALIDATORS_MAP = {
required: ɵ0,
maxLength: ɵ1,
minLength: ɵ2,
min: ɵ3,
max: ɵ4,
number: ɵ5,
integer: ɵ6,
boolean: ɵ7,
email: ɵ8,
noWhitespace: ɵ9,
notEmpty: ɵ10,
pattern: ɵ11,
crossField: ɵ12,
crossFieldMin: ɵ13,
crossFieldMax: ɵ14,
crossFieldAbsoluteMin: ɵ15,
forbiddenValues: ɵ16,
arrayUniqueFields: ɵ17,
minItems: ɵ18,
maxItems: ɵ19
};
var FlexyFormJsonMapperService = /** @class */ (function () {
function FlexyFormJsonMapperService(validatorsMap, jsonLayoutMapper, formBuilder, logger) {
this.jsonLayoutMapper = jsonLayoutMapper;
this.formBuilder = formBuilder;
this.logger = logger;
this._validatorsMap = DEFAULT_VALIDATORS_MAP;
if (validatorsMap) {
Object.assign(this._validatorsMap, validatorsMap);
}
}
Object.defineProperty(FlexyFormJsonMapperService.prototype, "supportedValidators", {
get: function () {
return Object.keys(this._validatorsMap);
},
enumerable: false,
configurable: true
});
FlexyFormJsonMapperService.prototype.createForm = function (json, readonlyMode, formData) {
if (readonlyMode === void 0) { readonlyMode = false; }
this.logger.debug('createForm');
FlexyFormJsonMapperService.controlCounter = 0;
var jsonSchema = parseFormJson(json);
var rootFormGroup = new i3.FormGroup({});
var dynamicSchema = this.map(jsonSchema, readonlyMode, formData, rootFormGroup);
this.logger.debug('countOfControls', FlexyFormJsonMapperService.controlCounter);
return new FlexyForm(rootFormGroup, dynamicSchema, formData);
};
FlexyFormJsonMapperService.prototype.createItemControl = function (itemsSchema, readonlyMode, value) {
var control;
if (itemsSchema.children) {
control = new i3.FormGroup({});
this.mapItem(itemsSchema, readonlyMode, value, control);
}
else {
control = this.formBuilder.control(value ? value : lodash.get(itemsSchema, 'componentInputs.default'), itemsSchema.validators
? this.mapValidators(itemsSchema.validators)
: []);
}
return control;
};
FlexyFormJsonMapperService.prototype.createArrayItemSchema = function (control, items, itemKeyDef, parentName, readonlyMode, formData, value, index, parentSchema) {
if (parentSchema === void 0) { parentSchema = null; }
var citems = lodash.cloneDeep(items);
this.populateComplexTypeIndexMarker([citems], index + 1, value, itemKeyDef);
var isComplex = citems && !!citems.children;
var schema;
if (isComplex) {
var withRootValues = Object.assign({}, value);
var groupSchema = this._jsonLayoutItemMap({}, '' + index, parentSchema);
groupSchema.children = this.map([citems], readonlyMode, withRootValues, control, groupSchema);
schema = groupSchema;
}
else {
schema = this.jsonLayoutMapper.map([citems])[0];
schema.formControl = control;
control.setValue(value);
schema.id = parentSchema.id + ':' + index;
if (!schema.componentInputs) {
schema.componentInputs = {};
}
schema.componentInputs[INPUTS_READONLY_KEY] = readonlyMode;
}
return schema;
};
FlexyFormJsonMapperService.prototype.createGroupItemSchema = function (control, items, itemKeyDef, parentName, readonlyMode, formData, value, key, parentSchema) {
if (parentSchema === void 0) { parentSchema = null; }
var citems = lodash.cloneDeep(items);
this.populateComplexTypeIndexMarker([citems], key, value, itemKeyDef);
var isComplex = citems && !!citems.children;
var schema;
if (isComplex) {
var withRootValues = Object.assign({}, value);
var groupSchema = this.map([citems], readonlyMode, withRootValues, control, null)[0];
schema = groupSchema;
}
else {
schema = this.jsonLayoutMapper.map([citems])[0];
schema.formControl = control;
control.setValue(value);
if (!schema.componentInputs) {
schema.componentInputs = {};
}
schema.componentInputs[INPUTS_READONLY_KEY] = readonlyMode;
schema.formName = citems.name;
}
schema.id = (parentSchema && parentSchema.id ? parentSchema.id + ':' : '') + key;
schema.groupKey = key;
return schema;
};
FlexyFormJsonMapperService.prototype.createSchema = function (json, readonlyMode, formData, parentFormGroup, parentControlGroupName, parentSchema) {
var _this = this;
if (readonlyMode === void 0) { readonlyMode = false; }
if (formData === void 0) { formData = {}; }
if (parentSchema === void 0) { parentSchema = null; }
var schema = [];
if (json && Array.isArray(json)) {
json.forEach(function (jsonItem, index) {
var schemaItem = _this.mapItem(jsonItem, readonlyMode, formData, parentFormGroup, parentControlGroupName, parentSchema, '' + index);
var itemParentFormGroup = parentFormGroup;
var itemParentControlGroupName = parentControlGroupName;
if (schemaItem.formControl instanceof i3.FormGroup) {
itemParentFormGroup = schemaItem.formControl;
if ([exports.FlexyFormFieldType.Group, exports.FlexyFormFieldType.Array].includes(jsonItem.type)) {
itemParentControlGroupName = _this.controlComplexName(jsonItem, itemParentControlGroupName);
}
}
if (jsonItem.children) {
schemaItem.children = _this.createSchema(jsonItem.children, readonlyMode, formData, itemParentFormGroup, itemParentControlGroupName, schemaItem);
}
schema.push(schemaItem);
});
}
return schema;
};
FlexyFormJsonMapperService.prototype.map = function (json, readonlyMode, formData, parentFormGroup, parentSchema) {
if (readonlyMode === void 0) { readonlyMode = false; }
if (parentSchema === void 0) { parentSchema = null; }
var dynamicSchema = this.createSchema(json, readonlyMode, formData, parentFormGroup, null, parentSchema);
return dynamicSchema;
};
FlexyFormJsonMapperService.prototype.createControl = function (config) {
return config instanceof i3.AbstractControl
? config
: config[1]
? this.formBuilder.control(config[0], config[1])
: this.formBuilder.control(config);
};
FlexyFormJsonMapperService.prototype.controlComplexName = function (jsonItem, parentName) {
return (parentName && jsonItem.name[0] === '.' ? parentName : '') + jsonItem.name;
};
FlexyFormJsonMapperService.prototype.mapItem = function (jsonItem, readonlyMode, formData, parentFormGroup, parentControlGroupName, parentSchema, schemaId) {
var _this = this;
if (readonlyMode === void 0) { readonlyMode = false; }
if (formData === void 0) { formData = {}; }
if (parentControlGroupName === void 0) { parentControlGroupName = null; }
if (parentSchema === void 0) { parentSchema = null; }
if (schemaId === void 0) { schemaId = ''; }
var formSchemaItem = this._jsonLayoutItemMap(jsonItem, schemaId, parentSchema);
if (readonlyMode) {
if (!formSchemaItem.componentInputs) {
formSchemaItem.componentInputs = {};
}
formSchemaItem.componentInputs[INPUTS_READONLY_KEY] = readonlyMode;
}
var controlName = '';
if (jsonItem.name &&
jsonItem.type !== exports.FlexyFormFieldType.Group &&
jsonItem.type !== exports.FlexyFormFieldType.Array) {
controlName = jsonItem.name;
this.mapItemSetFieldControl(formSchemaItem, jsonItem, parentControlGroupName, formData);
}
else if (jsonItem.items &&
jsonItem.type === exports.FlexyFormFieldType.Group) {
var groupJsonItem_1 = jsonItem;
controlName = groupJsonItem_1.name;
this.mapItemSetGroupControl(formSchemaItem, jsonItem, parentControlGroupName, readonlyMode);
var formGroupName = (parentControlGroupName && groupJsonItem_1.name[0] === '.' ? parentControlGroupName : '') + groupJsonItem_1.name;
var formGroupData_1 = lodash.has(formData, formGroupName) ? lodash.get(formData, formGroupName) : void 0;
if (formGroupData_1) {
jsonItem.children = [];
var isComplex_1 = !!groupJsonItem_1.items.children;
Object.keys(formGroupData_1).forEach(function (key) {
var schemaJson = lodash.cloneDeep(groupJsonItem_1.items);
schemaJson.name = '.' + key;
if (isComplex_1) {
schemaJson.type = exports.FlexyFormFieldType.Group;
}
schemaJson[SCHEMA_GROUP_KEY] = key;
_this.populateComplexTypeIndexMarker([schemaJson], key, formGroupData_1[key], groupJsonItem_1.indexDef);
groupJsonItem_1.children.push(schemaJson);
});
}
}
else if (jsonItem.items &&
jsonItem.type === exports.FlexyFormFieldType.Array) {
var arrayJsonItem = jsonItem;
controlName = arrayJsonItem.name;
this.mapItemSetArrayControl(formSchemaItem, arrayJsonItem, parentControlGroupName, formData, readonlyMode);
}
else {
controlName =
jsonItem.type === exports.FlexyFormFieldType.Group
? jsonItem.name
: formSchemaItem.id
? 'g-' + formSchemaItem.id
: 'd-' + Date.now();
formSchemaItem.groupKey = jsonItem.groupKey;
// TODO to think: form control is required also for non FlexyFormFieldLayoutSchema
formSchemaItem.formControl = new i3.FormGroup({}, this.mapValidators(jsonItem.validators));
}
var control = formSchemaItem.formControl;
if (control) {
parentFormGroup.addControl(this.unifyName(controlName, parentControlGroupName ? this.unifyName(parentControlGroupName) : ''), control);
}
return formSchemaItem;
};
FlexyFormJsonMapperService.prototype._jsonLayoutItemMap = function (jsonItem, schemaId, parentSchema) {
var schema = this.jsonLayoutMapper.mapItem(jsonItem, schemaId, parentSchema);
// const SCHEMA_GROUP_KEY = 'groupKey';
var SCHEMA_IF = 'if';
var SCHEMA_CALC = 'calc';
// TODO tothink is problem with populate form group controls from external domain
[SCHEMA_GROUP_KEY, SCHEMA_IF, SCHEMA_CALC].forEach(function (key) {
if (jsonItem[key]) {
schema[key] = jsonItem[key];
}
});
return schema;
};
FlexyFormJsonMapperService.prototype.mapItemSetArrayControl = function (formSchemaItem, jsonItem, parentControlGroupName, formData, readonlyMode) {
var formName = (parentControlGroupName && jsonItem.name[0] === '.' ? parentControlGroupName : '') + jsonItem.name;
// its possible in array in group
if (formName.endsWith('.')) {
formName = formName.slice(0, -1);
}
var val = lodash.has(formData, formName) ? lodash.get(formData, formName) : void 0;
var formControl = this.createArrayControl(jsonItem, readonlyMode, val);
formSchemaItem.formControl = formControl;
formSchemaItem.formName = formName;
if (jsonItem.items) {
formSchemaItem.items = this.createArrayItems(jsonItem.items, jsonItem.indexDef, formControl, formName, readonlyMode, val, formData, formSchemaItem);
formSchemaItem.componentInputs = Object.assign(Object.assign({}, formSchemaItem.componentInputs), {
jsonSchema: jsonItem,
readonly: readonlyMode
});
}
};
FlexyFormJsonMapperService.prototype.mapItemSetGroupControl = function (formSchemaItem, jsonItem, parentControlGroupName, readonlyMode) {
var formGroupName = (parentControlGroupName && jsonItem.name[0] === '.' ? parentControlGroupName : '') + jsonItem.name;
formSchemaItem.formControl = new i3.FormGroup({});
if (jsonItem.items) {
formSchemaItem.componentInputs = Object.assign(Object.assign({}, formSchemaItem.componentInputs), {
jsonSchema: jsonItem,
parentGroupName: formGroupName,
readonly: readonlyMode
});
}
};
FlexyFormJsonMapperService.prototype.mapItemSetFieldControl = function (formSchemaItem, jsonItem, parentControlGroupName, formData) {
FlexyFormJsonMapperService.controlCounter++;
var formName = (parentControlGroupName && jsonItem.name[0] === '.' ? parentControlGroupName : '') + jsonItem.name;
var val = lodash.has(formData, formName) ? lodash.get(formData, formName) : void 0;
var formControl = this.createControl(this.createControlConfig(jsonItem, val));
formSchemaItem.formName = formName;
formSchemaItem.formControl = formControl;
};
FlexyFormJsonMapperService.prototype.createArrayItems = function (items, itemKeyDef, arrayControl, parentName, readonlyMode, values, formData, parentSchema) {
var _this = this;
if (readonlyMode === void 0) { readonlyMode = false; }
if (parentSchema === void 0) { parentSchema = null; }
var formArray = arrayControl;
var formSchema = [];
formArray.controls.forEach(function (control, index) {
var value;
var key;
if (values && Array.isArray(values)) {
value = values[index];
key = '' + index;
}
else if (values && typeof values === 'object') {
key = Object.keys(values)[index];
value = values[key];
}
var schema = _this.createArrayItemSchema(control, items, itemKeyDef, parentName, readonlyMode, formData, value, index, parentSchema);
schema.formName = key;
formSchema.push(schema);
});
return formSchema;
};
FlexyFormJsonMapperService.prototype.populateComplexTypeIndexMarker = function (items, key, value, marker) {
var _this = this;
if (marker === void 0) { marker = COMPLEX_TYPE_INDEX_MARKER; }
items.forEach(function (item) {
if (item.name) {
item.name = replaceMarker(item.name, marker, key);
}
if (item.if) {
item.if = replaceMarker(item.if, marker, key);
}
if (item.calc) {
item.calc = replaceMarker(item.calc, marker, key);
}
if (item.attributes) {
Object.keys(item.attributes).forEach(function (attr) {
if (typeof item.attributes[attr] === 'string') {
item.attributes[attr] = replaceMarker('' + item.attributes[attr], marker, key);
}
else if (typeof item.attributes[attr] === 'object') {
Object.keys(item.attributes[attr]).forEach(function (attrVal) {
var replaced = replaceMarker(attrVal, marker, key);
item.attributes[attr][attrVal] = replaceMarker('' + item.attributes[attr][attrVal], marker, key);
if (replaced !== attrVal) {
item.attributes[attr][replaced] = item.attributes[attr][attrVal];
delete item.attributes[attr][attrVal];
}
});
}
});
}
if (item[SCHEMA_COMPONENT_INPUTS_KEY]) {
var componentInputs = ['title', 'label', 'legend'];
componentInputs.forEach(function (propName) {
if (item[SCHEMA_COMPONENT_INPUTS_KEY][propName]) {
item[SCHEMA_COMPONENT_INPUTS_KEY][propName] = replaceMarker(item[SCHEMA_COMPONENT_INPUTS_KEY][propName], marker, key);
}
});
}
if (item.children) {
_this.populateComplexTypeIndexMarker(item.children, key, value, marker);
}
if (item.items) {
_this.populateComplexTypeIndexMarker([item.items], key, value, marker);
}
});
};
FlexyFormJsonMapperService.prototype.createControlConfig = function (item, defaultValue) {
if (item.name) {
return [defaultValue !== void 0 ? defaultValue : item[SCHEMA_DEFAULT_KEY], this.mapValidators(item.validators)];
}
return [];
};
FlexyFormJsonMapperService.prototype.createArrayControl = function (item, readonlyMode, values) {
var _this = this;
if (readonlyMode === void 0) { readonlyMode = false; }
if (values === void 0) { values = []; }
var arraySchema = item;
var validators = [];
// TODO to thkink
// if (arraySchema.validators['minItems']) {
// validators.push(FlexyFormsValidators.minLengthArray(arraySchema.validators['minItems']));
// }
// if (arraySchema.validators['maxItems']) {
// validators.push(FlexyFormsValidators.maxLengthArray(arraySchema.validators['maxItems']));
// }
var formArray = new i3.FormArray([], this.mapValidators(item.validators));
if (item.type === exports.FlexyFormFieldType.Array && item.name) {
if (values && Array.isArray(values)) {
values.forEach(function (value) {
formArray.push(_this.createItemControl(arraySchema.items, readonlyMode, value));
});
}
else if (values) {
console.warn('Wrong type of data. Values should be array', values);
}
}
return formArray;
};
FlexyFormJsonMapperService.prototype.unifyName = function (controlName, parentControlName) {
if (parentControlName === void 0) { parentControlName = ''; }
if (controlName[0] === '.') {
controlName = controlName.substring(1);
}
var name = controlName ? controlName.split('.').join('/') : 'p_' + Date.now();
if (parentControlName) {
name = name.replace(parentControlName + '/', '');
}
return name;
};
FlexyFormJsonMapperService.prototype.mapValidators = function (jsonValidator) {
var _this = this;
var validators = [];
if (jsonValidator) {
Object.keys(jsonValidator).forEach(function (key) {
if (_this._validatorsMap[key]) {
validators.push(_this._validatorsMap[key](jsonValidator[key]));
}
else {
console.warn("Validator " + key + " is not supported");
}
});
}
return validators;
};
return FlexyFormJsonMapperService;
}());
FlexyFormJsonMapperService.controlCounter = 0;
FlexyFormJsonMapperService.ɵprov = i0__namespace.ɵɵdefineInjectable({ factory: function FlexyFormJsonMapperService_Factory() { return new FlexyFormJsonMapperService(i0__namespace.ɵɵinject(FLEXY_FORM_VALIDATORS, 8), i0__namespace.ɵɵinject(i2__namespace.FlexyLayoutJsonMapperService), i0__namespace.ɵɵinject(i3__namespace.FormBuilder), i0__namespace.ɵɵinject(i4__namespace.FlexyLoggerService)); }, token: FlexyFormJsonMapperService, providedIn: "root" });
FlexyFormJsonMapperService.decorators = [
{ type: i0.Injectable, args: [{
providedIn: 'root'
},] }
];
FlexyFormJsonMapperService.ctorParameters = function () { return [
{ type: undefined, decorators: [{ type: i0.Optional }, { type: i0.Inject, args: [FLEXY_FORM_VALIDATORS,] }] },
{ type: i2.FlexyLayoutJsonMapperService },
{ type: i3.FormBuilder },
{ type: i4.FlexyLoggerService }
]; };
var CHNAGES_DEBOUNCE_TIME = 50;
var FlexyFormComponent = /** @class */ (function () {
function FlexyFormComponent(jsonMapper, cdr) {
this.jsonMapper = jsonMapper;
this.cdr = cdr;
this.readonly = false;
this.changesDebounceTime = CHNAGES_DEBOUNCE_TIME;
this.created = new i0.EventEmitter();
this.changed = new i0.EventEmitter();
}
FlexyFormComponent.prototype.ngOnInit = function () {
var _this = this;
this.form = this.jsonMapper.createForm(lodash.cloneDeep(this.json), this.readonly, this.data);
this.created.emit(this.form);
this._changesSubscription = this.form.currentData$
.pipe(operators.skip(1), operators.debounceTime(this.changesDebounceTime || CHNAGES_DEBOUNCE_TIME))
.subscribe(function (data) {
_this.changed.emit({ valid: _this.form.valid, data: data });
});
};
FlexyFormComponent.prototype.ngOnDestroy = function () {
if (this._changesSubscription) {
this._changesSubscription.unsubscribe();
}
};
return FlexyFormComponent;
}());
FlexyFormComponent.decorators = [
{ type: i0.Component, args: [{
selector: 'flexy-form',
template: "\n <flexy-form-container *ngIf=\"form\" [form]=\"form\" [schema]=\"form.schema\"></flexy-form-container>\n "
},] }
];
FlexyFormComponent.ctorParameters = function () { return [
{ type: FlexyFormJsonMapperService },
{ type: i0.ChangeDetectorRef }
]; };
FlexyFormComponent.propDecorators = {
json: [{ type: i0.Input }],
data: [{ type: i0.Input }],
readonly: [{ type: i0.Input }],
changesDebounceTime: [{ type: i0.Input }],
created: [{ type: i0.Output }],
changed: [{ type: i0.Output }]
};
var FlexyFormContainerComponent = /** @class */ (function () {
function FlexyFormContainerComponent() {
}
return FlexyFormContainerComponent;
}());
FlexyFormContainerComponent.decorators = [
{ type: i0.Component, args: [{
selector: 'flexy-form-container',
template: "\n <ng-template #tmplRef let-schema let-form=\"form\">\n <ng-container *ngFor=\"let schemaItem of schema\">\n <ng-container *flexyFormIf=\"{ schema: schemaItem, form: form }\">\n <ng-container\n *ngIf=\"schemaItem.componentType\"\n flexyFormContainer\n [componentSchema]=\"schemaItem\"\n [flexyForm]=\"form\"\n ></ng-container>\n <ng-container *ngIf=\"!schemaItem.componentType\">\n <div flexyFormAttributes [componentSchema]=\"schemaItem\" [flexyForm]=\"form\">\n <ng-container *ngIf=\"schemaItem.children\">\n <ng-container *ngTemplateOutlet=\"tmplRef; context: { $implicit: schemaItem.children, form: form }\"></ng-container>\n </ng-container>\n </div>\n </ng-container>\n </ng-container>\n </ng-container>\n </ng-template>\n\n <ng-content></ng-content>\n <ng-container *ngTemplateOutlet=\"tmplRef; context: { $implicit: schema, form: form }\"></ng-container>\n "
// ,
// changeDetection: ChangeDetectionStrategy.OnPush
},] }
];
FlexyFormContainerComponent.propDecorators = {
form: [{ type: i0.Input }],
schema: [{ type: i0.Input }]
};
var jsonata$2 = jsonata___namespace;
var FlexyFlexyFormIfDirective = /** @class */ (function () {
function FlexyFlexyFormIfDirective(templateRef, viewContainer) {
this.templateRef = templateRef;
this.viewContainer = viewContainer;
this._visibility = true;
}
FlexyFlexyFormIfDirective.prototype.ngOnInit = function () {
var _this = this;
if (this.flexyFormIf && this.flexyFormIf.schema.if && this.flexyFormIf.form) {
this._visibility = this._isEnabled(this.flexyFormIf.form.currentData);
this._changesSubscription = this.flexyFormIf.form.currentData$.subscribe(function (data) {
_this._visibility = _this._isEnabled(data);
_this._render();
});
}
this._render();
};
FlexyFlexyFormIfDirective.prototype._render = function () {
if (this._visibility) {
if (!this._viewRef) {
this.viewContainer.clear();
if (this.templateRef) {
this._viewRef = this.viewContainer.createEmbeddedView(this.templateRef);
}
}
}
else {
this.viewContainer.clear();
this._viewRef = null;
}
};
FlexyFlexyFormIfDirective.prototype._isEnabled = function (data) {
var schema = this.flexyFormIf.schema;
var is = false;
if (schema.if) {
if (!this._ifCompiled) {
this._ifCompiled = jsonata$2(schema.if);
}
try {
is = !!this._ifCompiled.evaluate(data);
}
catch (e) {
// do nothing
}
}
return is;
};
return FlexyFlexyFormIfDirective;
}());
FlexyFlexyFormIfDirective.decorators = [
{ type: i0.Directive, args: [{
selector: '[flexyFormIf]'
},] }
];
FlexyFlexyFormIfDirective.ctorParameters = function () { return [
{ type: i0.TemplateRef },
{ type: i0.ViewContainerRef }
]; };
FlexyFlexyFormIfDirective.propDecorators = {
flexyFormIf: [{ type: i0.Input }]
};
var jsonata$1 = jsonata___namespace;
var FlexyFormAbstractOptionsComponent = /** @class */ (function () {
function FlexyFormAbstractOptionsComponent(optionsService, logger) {
this.optionsService = optionsService;
this.logger = logger;
this.filterData = {};
}
FlexyFormAbstractOptionsComponent.prototype.initOptions = function () {
return __awaiter(this, void 0, void 0, function () {
var options;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
if (!this.optionsUrl) return [3 /*break*/, 2];
this.loading = true;
return [4 /*yield*/, this.optionsService.loadOptions(this.optionsUrl, this.optionsMapper, this.optionsPath).toPromise()];
case 1:
options = _a.sent();
this._optionsCache = options;
this.loading = false;
if (this.optionsFilter && this.optionsFilter.filter) {
this._setOptionsFiltering();
}
else {
this.options = options;
}
return [3 /*break*/, 3];
case 2:
this.loading = false;
_a.label = 3;
case 3: return [2 /*return*/];
}
});
});
};
FlexyFormAbstractOptionsComponent.prototype._setOptionsFiltering = function () {
var _this = this;
try {
var jsonataExp_1 = jsonata$1(this.optionsFilter.filter);
this.logger.debug('jsonata', this.optionsFilter.filter);
this.changesSubscription = this.form.currentData$.subscribe(function (data) {
var isChanged = false;
_this.optionsFilter.observableFields.forEach(function (path) {
var vp = lodash.get(data, path);
if (lodash.get(_this.filterData, path) !== vp) {
lodash.set(_this.filterData, path, vp);
isChanged = true;
}
});
if (isChanged) {
_this.logger.debug('evaluate', {
optionsList: _this._optionsCache,
observableFields: _this.filterData
});
var jsonOptions = jsonataExp_1.evaluate({
optionsList: _this._optionsCache,
observableFields: _this.filterData
});
var options = jsonOptions ? (Array.isArray(jsonOptions) ? jsonOptions : [jsonOptions]) : [];
_this.options = options.filter(function (item) { return !!item; });
}
});
}
catch (e) {
this.logger.error('Wrong jsonata expresion', this.optionsFilter.filter, e);
}
};
return FlexyFormAbstractOptionsComponent;
}());
var REQUIRED_PATTERN_KEY = 'requiredPattern';
var FlexyFormFirstErrorPipe = /** @class */ (function () {
function FlexyFormFirstErrorPipe(translateService, logger) {
this.translateService = translateService;
this.logger = logger;
}
FlexyFormFirstErrorPipe.prototype.transform = function (errors) {
if (errors && Object.keys(errors) && Object.keys(errors).length) {
var key = Object.keys(errors)[0];
var error = typeof errors[key] === 'object' ? Object.assign({}, errors[key]) : '';
this.logger.debug('translate', key, errors[key]);
if (key === 'pattern') {
var patternKey = 'FLEXY_FORM_VALIDATION_PATTERN_' + error[REQUIRED_PATTERN_KEY];
var pattern = this.translateService.instant(patternKey);
if (pattern && pattern !== patternKey) {
error[REQUIRED_PATTERN_KEY] = pattern;
}
this.logger.debug('Validation error message: Check pattern translate', patternKey);
}
return this.translateService.instant('FLEXY_FORM_VALIDATION_' +
key
.split('-')
.join('_')
.toUpperCase(), error);
}
return '';
};
return FlexyFormFirstErrorPipe;
}());
FlexyFormFirstErrorPipe.decorators = [
{ type: i0.Pipe, args: [{ name: 'firstError' },] }
];
FlexyFormFirstErrorPipe.ctorParameters = function () { return [
{ type: core.TranslateService },
{ type: i4.FlexyLoggerService }
]; };
var FlexyOptionsMapperPipe = /** @class */ (function () {
function FlexyOptionsMapperPipe() {
}
FlexyOptionsMapperPipe.prototype.transform = function (value, mapper) {
if (!value || !Array.isArray(value) || !mapper || !mapper.value || !mapper.text) {
return [];
}
else {
return value
.filter(function (item) { return !!item && item[mapper.value]; })
.map(function (item) { return ({
value: item[mapper.value],
text: item[mapper.text]
}); });
}
};
return FlexyOptionsMapperPipe;
}());
FlexyOptionsMapperPipe.decorators = [
{ type: i0.Pipe, args: [{ name: 'flexyOptions' },] }
];
FlexyOptionsMapperPipe.ctorParameters = function () { return []; };
var FlexyFormSchemaService = /** @class */ (function () {
function FlexyFormSchemaService(jsonMapperService) {
this.jsonMapperService = jsonMapperService;
}
FlexyFormSchemaService.prototype.addGroupItemToSchema = function (parentSchemaRef, itemKey, groupSchema, controlGroupName, readonly) {
var schema = null;
if (!this.validateGroupKey(itemKey, groupSchema)) {
var jsonSchema = lodash.cloneDeep(groupSchema.items);
jsonSchema.name = controlGroupName;
jsonSchema.type = exports.FlexyFormFieldType.Group;
var newValue = jsonSchema && jsonSchema.children ? {} : null;
var control = this.jsonMapperService.createItemControl(jsonSchema, readonly, newValue);
parentSchemaRef.formControl.addControl(itemKey, control);
parentSchemaRef.formControl.markAsDirty();
schema = this.jsonMapperService.createGroupItemSchema(control, jsonSchema, groupSchema.indexDef, null, readonly, {}, newValue, itemKey, parentSchemaRef.formControl);
parentSchemaRef.children.push(schema);
// fix form control - should be the same but is not
parentSchemaRef.formControl.setControl(itemKey, schema.formControl);
}
return schema;
};
FlexyFormSchemaService.prototype.validateGroupKey = function (key, groupSchema) {
var patternReg = groupSchema.indexPattern ? new RegExp(groupSchema.indexPattern, 'g') : null;
if (!key) {
return 'empty';
}
else if (patternReg && !patternReg.exec(key)) {
return 'wrong_format';
}
return null;
};
FlexyFormSchemaService.prototype.removeGroupItemToSchema = function (layoutSchemaRef, index) {
if (layoutSchemaRef.children[index]) {
var schemaItem = layoutSchemaRef.children[index];
var groupKey = schemaItem.groupKey;
if (groupKey &&
layoutSchemaRef.formControl &&
layoutSchemaRef.formControl instanceof i3.FormGroup &&
layoutSchemaRef.formControl.contains(groupKey)) {
layoutSchemaRef.children.splice(index, 1);
layoutSchemaRef.formControl.removeControl(groupKey);
layoutSchemaRef.formControl.markAsDirty();
return groupKey;
}
}
return null;
};
return FlexyFormSchemaService;
}());
FlexyFormSchemaService.ɵprov = i0__namespace.ɵɵdefineInjectable({ factory: function FlexyFormSchemaService_Factory() { return new FlexyFormSchemaService(i0__namespace.ɵɵinject(FlexyFormJsonMapperService)); }, token: FlexyFormSchemaService, providedIn: "root" });
FlexyFormSchemaService.decorators = [
{ type: i0.Injectable, args: [{
providedIn: 'root'
},] }
];
FlexyFormSchemaService.ctorParameters = function () { return [
{ type: FlexyFormJsonMapperService }
]; };
function getSchemaData(schema) {
var fg = new i3.FormGroup({});
var ff = new FlexyForm(fg, [schema], {});
var allData = ff.getAllData();
if (schema.formName) {
return lodash.get(allData, schema.formName);
}
else {
return allData;
}
}
var jsonata = jsonata___namespace;
var FlexyFormControlOptionsService = /** @class */ (function () {
function FlexyFormControlOptionsService(httpClient, logger) {
this.httpClient = httpClient;
this.logger = logger;
}
FlexyFormControlOptionsService.prototype.loadOptions = function (optionsUrl, optionsMapper, optionsPath) {
var _this = this;
if (optionsMapper === void 0) { optionsMapper = null; }
if (optionsUrl) {
return this.httpClient.get(optionsUrl).pipe(operators.map(function (data) {
if (data && optionsPath) {
data = lodash.get(data, optionsPath);
}
var options = [];
if (data && Array.isArray(data) && optionsMapper) {
if (typeof optionsMapper === 'string') {
options.push.apply(options, __spreadArray([], __read(_this._jsonataMapperOptions(optionsMapper, data))));
}
else {
options.push.apply(options, __spreadArray([], __read(_this._optionsMapper(optionsMapper, data))));
}
}
else if (!optionsMapper) {
_this.logger.warn('Options loader: optionsMapper is required');
}
return options;
}));
}
};
FlexyFormControlOptionsService.prototype._jsonataMapperOptions = function (optionsMapper, data) {
var options = [];
try {
var compiled = jsonata(optionsMapper);
var jsonOptions = compiled.evaluate({ optionsData: data });
if (jsonOptions &&
Array.isArray(jsonOptions) &&
jsonOptions.length &&
jsonOptions[0].hasOwnProperty('text') &&
jsonOptions[0].hasOwnProperty('value')) {
options.push.apply(options, __spreadArray([], __read(jsonOptions)));
}
else {
this.logger.debug('Jsonata error debug', jsonOptions, optionsMapper, data);
this.logger.warn('Wrong jsonata mapping');
}
}
catch (e) {
this.logger.error('Wrong jsonata expresion', optionsMapper, e);
}
return options;
};
FlexyFormControlOptionsService.prototype._optionsMapper = function (optionsMapper, data) {
var textTemplate = this._mapperTemplate(optionsMapper.text);
var valueTemplate = this._mapperTemplate(optionsMapper.value);
var prefixTemplate = this._mapperTemplate(optionsMapper.prefixHtml);
var options = [];
if (data && data.length) {
data.forEach(function (item) {
options.push({
text: item && textTemplate ? textTemplate(item) : '' + lodash.get(item, optionsMapper.text),
value: item && valueTemplate ? valueTemplate(item) : lodash.get(item, optionsMapper.value),
prefixHtml: item && prefixTemplate ? prefixTemplate(item) : lodash.get(item, optionsMapper.prefixHtml),
_raw: item
});
});
}
return options;
};
FlexyFormControlOptionsService.prototype._mapperTemplate = function (mapper) {
if (!mapper) {
return;
}
// check if template?
if (mapper.includes('<%')) {
return lodash.template(mapper);
}
};
return FlexyFormControlOptionsService;
}());
FlexyFormControlOptionsService.ɵprov = i0__namespace.ɵɵdefineInjectable({ factory: function FlexyFormControlOptionsService_Factory() { return new FlexyFormControlOptionsService(i0__namespace.ɵɵinject(i1__namespace.HttpClient), i0__namespace.ɵɵinject(i4__namespace.FlexyLoggerService)); }, token: FlexyFormControlOptionsService, providedIn: "root" });
FlexyFormControlOptionsService.decorators = [
{ type: i0.Injectable, args: [{
providedIn: 'root'
},] }
];
FlexyFormControlOptionsService.ctorParameters = function () { return [
{ type: i1.HttpClient },
{ type: i4.FlexyLoggerService }
]; };
function findRawValue(rawIdKey, controlValue, options) {
if (rawIdKey) {
if (controlValue && Array.isArray(controlValue)) {
var ret_1 = [];
controlValue.forEach(function (valueItem) {
var v = valueItem && valueItem[rawIdKey];
if (v) {
var el = options && options.find(function (item) { return item && item._raw && item._raw[rawIdKey] === v; });
if (el && el.value) {
ret_1.push(el.value);
}
}
});
return ret_1;
}
else {
if (controlValue && typeof controlValue === 'object' && controlValue[rawIdKey]) {
var el = options.find(function (item) { return item && item._raw && item._raw[rawIdKey] === controlValue[rawIdKey]; });
return el ? el.value : null;
}
}
}
else {
return controlValue;
}
return;
}
function prepareControlValue(optionsRawId, data) {
if (data) {
var cloned = lodash.cloneDeep(data);
if (optionsRawId) {
if (Array.isArray(cloned)) {
cloned.forEach(function (item) {
item.value = item && item._raw;
});
}
else {
cloned.value = cloned && cloned._raw;
}
}
return Array.isArray(cloned) ? cloned.map(function (el) { return el && el.value; }) : cloned.value;
}
else {
return null;
}
}
function isRequired(control) {
if (!control) {
return null;
}
var required = false;
var formControl = new i3.FormControl();
if (control.validator) {
var validationResult = control.validator(formControl);
required = validationResult !== null && validationResult.required === true;
}
return required;
}
function markAsDirtyDeep(control) {
control.markAsDirty();
if (control instanceof i3.FormGroup) {
Object.keys(control.controls).forEach(function (key) { return markAsDirtyDeep(control.controls[key]); });
}
else if (control instanceof i3.FormArray) {
control.controls.forEach(function (child) { return markAsDirtyDeep(child); });
}
}
var PUBLIC_COMPONENTS = [
FlexyFormFirstErrorPipe,
FlexyOptionsMapperPipe,
FlexyFormContainerComponent,
FlexyFormAttributesDirective,
FlexyFormContainerDirective,
FlexyFlexyFormIfDirective,
FlexyFormComponent
];
var FlexyFormsModule = /** @class */ (function () {
function FlexyFormsModule() {
}
FlexyFormsModule.forRoot = function (validators) {
return {
ngModule: FlexyFormsModule,
providers: [
{
provide: FLEXY_FORM_VALIDATORS,
useValue: validators,
},
],
};
};
return FlexyFormsModule;
}());
FlexyFormsModule.decorators = [
{ type: i0.NgModule, args: [{
imports: [common.CommonModule, i3.FormsModule, i3.ReactiveFormsModule, core.TranslateModule, i2.FlexyLayoutModule],
declarations: __spreadArray([], __read(PUBLIC_COMPONENTS)),
exports: __spreadArray([], __read(PUBLIC_COMPONENTS)),
},] }
];
/*
* Public API Surface of form
*/
/**
* Generated bundle index. Do not edit.
*/
exports.COMPLEX_TYPE_INDEX_MARKER = COMPLEX_TYPE_INDEX_MARKER;
exports.FLEXY_FORM_VALIDATORS = FLEXY_FORM_VALIDATORS;
exports.FlexyFlexyFormIfDirective = FlexyFlexyFormIfDirective;
exports.FlexyForm = FlexyForm;
exports.FlexyFormAbstractOptionsComponent = FlexyFormAbstractOptionsComponent;
exports.FlexyFormAttributesDirective = FlexyFormAttributesDirective;
exports.FlexyFormComponent = FlexyFormComponent;
exports.FlexyFormContainerComponent = FlexyFormContainerComponent;
exports.FlexyFormContainerDirective = FlexyFormContainerDirective;
exports.FlexyFormControlOptionsService = FlexyFormControlOptionsService;
exports.FlexyFormFirstErrorPipe = FlexyFormFirstErrorPipe;
exports.FlexyFormJsonMapperService = FlexyFormJsonMapperService;
exports.FlexyFormSchemaService = FlexyFormSchemaService;
exports.FlexyFormsModule = FlexyFormsModule;
exports.FlexyOptionsMapperPipe = FlexyOptionsMapperPipe;
exports.HIDDEN_CALC_GROUP_NAME = HIDDEN_CALC_GROUP_NAME;
exports.HIDDEN_IF_GROUP_NAME = HIDDEN_IF_GROUP_NAME;
exports.assignHiddenNames = assignHiddenNames;
exports.calculate = calculate;
exports.checkSchema = checkSchema;
exports.clearEmptyArrayAndObjects = clearEmptyArrayAndObjects;
exports.findErrors = findErrors;
exports.findRawValue = findRawValue;
exports.findRemoved = findRemoved;
exports.findSchema = findSchema;
exports.getSchemaData = getSchemaData$1;
exports.isRequired = isRequired;
exports.markAsDirtyDeep = markAsDirtyDeep;
exports.parseFormJson = parseFormJson;
exports.parseFormVersion1 = parseFormVersion1;
exports.parseFormVersion1Item = parseFormVersion1Item;
exports.prepareControlValue = prepareControlValue;
exports.replaceMarker = replaceMarker;
exports["ɵ0"] = ɵ0;
exports["ɵ1"] = ɵ1;
exports["ɵ10"] = ɵ10;
exports["ɵ11"] = ɵ11;
exports["ɵ12"] = ɵ12;
exports["ɵ13"] = ɵ13;
exports["ɵ14"] = ɵ14;
exports["ɵ15"] = ɵ15;
exports["ɵ16"] = ɵ16;
exports["ɵ17"] = ɵ17;
exports["ɵ18"] = ɵ18;
exports["ɵ19"] = ɵ19;
exports["ɵ2"] = ɵ2;
exports["ɵ3"] = ɵ3;
exports["ɵ4"] = ɵ4;
exports["ɵ5"] = ɵ5;
exports["ɵ6"] = ɵ6;
exports["ɵ7"] = ɵ7;
exports["ɵ8"] = ɵ8;
exports["ɵ9"] = ɵ9;
Object.defineProperty(exports, '__esModule', { value: true });
}));
//# sourceMappingURL=ng-flexy-form.umd.js.map