angular-dynamic-forms-lite
Version:
Efficient dynamic and customizable Angular 7+ forms.
1,420 lines (1,384 loc) • 93.6 kB
JavaScript
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core'), require('@angular/forms'), require('rxjs/operators')) :
typeof define === 'function' && define.amd ? define('angular-dynamic-forms-lite', ['exports', '@angular/core', '@angular/forms', 'rxjs/operators'], factory) :
(global = global || self, factory(global['angular-dynamic-forms-lite'] = {}, global.ng.core, global.ng.forms, global.rxjs.operators));
}(this, function (exports, core, forms, operators) { 'use strict';
/*! *****************************************************************************
Copyright (c) Microsoft Corporation. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use
this file except in compliance with the License. You may obtain a copy of the
License at http://www.apache.org/licenses/LICENSE-2.0
THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
MERCHANTABLITY OR NON-INFRINGEMENT.
See the Apache Version 2.0 License for specific language governing permissions
and limitations under the License.
***************************************************************************** */
/* 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 (b.hasOwnProperty(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) {
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) : new P(function (resolve) { resolve(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 };
}
}
function __exportStar(m, exports) {
for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
}
function __values(o) {
var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
if (m) return m.call(o);
return {
next: function () {
if (o && i >= o.length) o = void 0;
return { value: o && o[i++], done: !o };
}
};
}
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;
};
function __importStar(mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
result.default = mod;
return result;
}
function __importDefault(mod) {
return (mod && mod.__esModule) ? mod : { default: mod };
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var FormRootDirective = /** @class */ (function () {
function FormRootDirective(viewContainerRef) {
this.viewContainerRef = viewContainerRef;
}
/**
* @param {?} index
* @return {?}
*/
FormRootDirective.prototype.getViewRef = /**
* @param {?} index
* @return {?}
*/
function (index) {
return this.viewContainerRef.get(index);
};
/**
* @return {?}
*/
FormRootDirective.prototype.getViewRefs = /**
* @return {?}
*/
function () {
/** @type {?} */
var viewRefs = [];
for (var i = 0; i < this.getSize(); i++) {
viewRefs.push(this.viewContainerRef.get(i));
}
return viewRefs;
};
/**
* @param {?} viewRef
* @return {?}
*/
FormRootDirective.prototype.containsViewRef = /**
* @param {?} viewRef
* @return {?}
*/
function (viewRef) {
return this.viewContainerRef.indexOf(viewRef) !== -1;
};
/**
* @return {?}
*/
FormRootDirective.prototype.getSize = /**
* @return {?}
*/
function () {
return this.viewContainerRef.length;
};
/**
* @return {?}
*/
FormRootDirective.prototype.clearView = /**
* @return {?}
*/
function () {
this.viewContainerRef.clear();
};
FormRootDirective.decorators = [
{ type: core.Directive, args: [{
selector: "[form-root], form-root"
},] }
];
/** @nocollapse */
FormRootDirective.ctorParameters = function () { return [
{ type: core.ViewContainerRef }
]; };
return FormRootDirective;
}());
if (false) {
/** @type {?} */
FormRootDirective.prototype.viewContainerRef;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/** @type {?} */
var FIELD_METADATA = new core.InjectionToken("metadata");
/** @type {?} */
var FIELD_FORM_CONTROL = new core.InjectionToken("form control");
/** @type {?} */
var FIELD_DYNAMIC_CONTROLLER = new core.InjectionToken("dynamic controller");
/** @type {?} */
var FIELD_NAME = new core.InjectionToken("form field name");
var FormFieldInjector = /** @class */ (function () {
function FormFieldInjector(_parentInjector, _additionalTokens) {
this._parentInjector = _parentInjector;
this._additionalTokens = _additionalTokens;
}
/**
* @param {?} token
* @param {?=} notFoundValue
* @param {?=} flags
* @return {?}
*/
FormFieldInjector.prototype.get = /**
* @param {?} token
* @param {?=} notFoundValue
* @param {?=} flags
* @return {?}
*/
function (token, notFoundValue, flags) {
/** @type {?} */
var value = this._additionalTokens.get(token);
return value !== undefined ? value : this._parentInjector.get(token, notFoundValue, flags);
};
return FormFieldInjector;
}());
if (false) {
/**
* @type {?}
* @private
*/
FormFieldInjector.prototype._parentInjector;
/**
* @type {?}
* @private
*/
FormFieldInjector.prototype._additionalTokens;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/** @type {?} */
var DEFAULT_SUB_TYPE = "DEFAULT";
/** @enum {string} */
var DynamicFormType = {
/**
* Number form type
*/
GROUP: "GROUP",
/**
* Array form type
*/
ARRAY: "ARRAY",
/**
* Single form type
*/
SINGLE: "SINGLE",
/**
* Hidden form type
*/
HIDDEN: "HIDDEN",
};
/**
* @param {?} value
* @return {?}
*/
function isDynamicFieldType(value) {
return value in DynamicFormType;
}
/** @type {?} */
var DEFAULT_FORM_COMPONENTS = new core.InjectionToken("default form components");
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* Describes a form field using its type and sub type.
*/
var /**
* Describes a form field using its type and sub type.
*/
SubType = /** @class */ (function () {
function SubType(type, subType) {
if (type === void 0) { type = DynamicFormType.SINGLE; }
if (subType === void 0) { subType = DEFAULT_SUB_TYPE; }
this.type = type;
this.subType = subType;
}
/**
* @param {?} type
* @param {?=} subType
* @return {?}
*/
SubType.of = /**
* @param {?} type
* @param {?=} subType
* @return {?}
*/
function (type, subType) {
return new SubType(type, subType);
};
/**
* @param {?} fieldType
* @return {?}
*/
SubType.toSubType = /**
* @param {?} fieldType
* @return {?}
*/
function (fieldType) {
return fieldType instanceof SubType ? fieldType : SubType.of(fieldType);
};
return SubType;
}());
if (false) {
/** @type {?} */
SubType.prototype.type;
/** @type {?} */
SubType.prototype.subType;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @record
* @template M, T, S
*/
function CreateFormContextOptions() { }
if (false) {
/** @type {?|undefined} */
CreateFormContextOptions.prototype.initialValue;
/** @type {?|undefined} */
CreateFormContextOptions.prototype.formControl;
/** @type {?} */
CreateFormContextOptions.prototype.setting;
/** @type {?} */
CreateFormContextOptions.prototype.settings;
}
/**
* @record
* @template T, S
*/
function FieldFactory() { }
if (false) {
/**
* @template M
* @param {?} params
* @return {?}
*/
FieldFactory.prototype.create = function (params) { };
/**
* @param {?} formRoot
* @param {?} root
* @return {?}
*/
FieldFactory.prototype.render = function (formRoot, root) { };
/**
* @param {?} context
* @return {?}
*/
FieldFactory.prototype.updateChildren = function (context) { };
}
var ParentFieldFactory = /** @class */ (function () {
function ParentFieldFactory(factories, componentFactoryResolver, injector, formBuilder, settings) {
this.factories = factories;
this.componentFactoryResolver = componentFactoryResolver;
this.injector = injector;
this.formBuilder = formBuilder;
this.settings = settings;
}
/**
* @template M
* @param {?} params
* @return {?}
*/
ParentFieldFactory.prototype.create = /**
* @template M
* @param {?} params
* @return {?}
*/
function (params) {
return this.getFactory(params.setting).create(params);
};
/**
* @param {?} formRoot
* @param {?} root
* @return {?}
*/
ParentFieldFactory.prototype.render = /**
* @param {?} formRoot
* @param {?} root
* @return {?}
*/
function (formRoot, root) {
return this.getFactory(root.setting).render(formRoot, root);
};
/**
* @param {?} context
* @return {?}
*/
ParentFieldFactory.prototype.updateChildren = /**
* @param {?} context
* @return {?}
*/
function (context) {
return this.getFactory(context.setting).updateChildren(context);
};
/**
* @template M, H
* @param {?} formControl
* @param {?} setting
* @param {?} value
* @param {?} dynamicController
* @return {?}
*/
ParentFieldFactory.prototype.resolveComponent = /**
* @template M, H
* @param {?} formControl
* @param {?} setting
* @param {?} value
* @param {?} dynamicController
* @return {?}
*/
function (formControl, setting, value, dynamicController) {
/** @type {?} */
var componentFactory;
try {
componentFactory = this.componentFactoryResolver.resolveComponentFactory(setting.component);
}
catch (e) {
console.error("Cannot resolve component factory for " + setting.name + ". " + (setting.component ? "" : "Component is undefined."));
throw e;
}
/** @type {?} */
var additionalTokens = new WeakMap();
additionalTokens.set(FIELD_METADATA, setting.metadata || {});
additionalTokens.set(FIELD_FORM_CONTROL, formControl);
additionalTokens.set(FIELD_DYNAMIC_CONTROLLER, dynamicController);
additionalTokens.set(FIELD_NAME, setting.name);
/** @type {?} */
var dynamicInjector = new FormFieldInjector(this.injector, additionalTokens);
/** @type {?} */
var componentRef = componentFactory.create(dynamicInjector);
dynamicController.componentRef = componentRef;
this.patchAsyncChangeDetection(formControl, componentRef.changeDetectorRef);
return (/** @type {?} */ ({
initialValue: value,
formControl: formControl,
setting: setting,
settings: this.settings,
componentRef: componentRef,
children: []
}));
};
/**
* @private
* @param {?} formControl
* @param {?} cdr
* @return {?}
*/
ParentFieldFactory.prototype.patchAsyncChangeDetection = /**
* @private
* @param {?} formControl
* @param {?} cdr
* @return {?}
*/
function (formControl, cdr) {
formControl.statusChanges
.pipe(operators.bufferCount(2, 1), operators.map((/**
* @param {?} __0
* @return {?}
*/
function (_a) {
var _b = __read(_a, 1), prevState = _b[0];
return prevState;
})), operators.filter((/**
* @param {?} prevState
* @return {?}
*/
function (prevState) { return prevState === "PENDING"; })))
.subscribe((/**
* @return {?}
*/
function () { return cdr.markForCheck(); }));
};
/**
* @private
* @template M
* @param {?} setting
* @return {?}
*/
ParentFieldFactory.prototype.getFactory = /**
* @private
* @template M
* @param {?} setting
* @return {?}
*/
function (setting) {
/** @type {?} */
var factoryType = SubType.toSubType(setting.type).type;
/** @type {?} */
var factory = this.factories[factoryType];
if (!factory) {
throw new Error("Field factory " + factoryType + " does not exist.");
}
return new factory(this, this.formBuilder);
};
return ParentFieldFactory;
}());
if (false) {
/**
* @type {?}
* @private
*/
ParentFieldFactory.prototype.factories;
/**
* @type {?}
* @private
*/
ParentFieldFactory.prototype.componentFactoryResolver;
/**
* @type {?}
* @private
*/
ParentFieldFactory.prototype.injector;
/**
* @type {?}
* @private
*/
ParentFieldFactory.prototype.formBuilder;
/**
* @type {?}
* @private
*/
ParentFieldFactory.prototype.settings;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @abstract
*/
var /**
* @abstract
*/
DynamicController = /** @class */ (function () {
function DynamicController() {
}
Object.defineProperty(DynamicController.prototype, "componentRef", {
set: /**
* @param {?} _componentRef
* @return {?}
*/
function (_componentRef) {
this._componentRef = _componentRef;
},
enumerable: true,
configurable: true
});
return DynamicController;
}());
if (false) {
/**
* @type {?}
* @protected
*/
DynamicController.prototype._componentRef;
/**
* @abstract
* @param {?} context
* @return {?}
*/
DynamicController.prototype.onInit = function (context) { };
/**
* @abstract
* @protected
* @return {?}
*/
DynamicController.prototype.destory = function () { };
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @template M
*/
var /**
* @template M
*/
DynamicGroupController = /** @class */ (function (_super) {
__extends(DynamicGroupController, _super);
function DynamicGroupController(formGroup, fieldFactory, setting, settings) {
var _this = _super.call(this) || this;
_this.formGroup = formGroup;
_this.fieldFactory = fieldFactory;
_this.setting = setting;
_this.settings = settings;
return _this;
}
/**
* @param {?} context
* @return {?}
*/
DynamicGroupController.prototype.onInit = /**
* @param {?} context
* @return {?}
*/
function (context) { };
/**
* @protected
* @return {?}
*/
DynamicGroupController.prototype.destory = /**
* @protected
* @return {?}
*/
function () {
// TODO
};
return DynamicGroupController;
}(DynamicController));
if (false) {
/**
* @type {?}
* @private
*/
DynamicGroupController.prototype.formGroup;
/**
* @type {?}
* @private
*/
DynamicGroupController.prototype.fieldFactory;
/**
* @type {?}
* @private
*/
DynamicGroupController.prototype.setting;
/**
* @type {?}
* @private
*/
DynamicGroupController.prototype.settings;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var GroupFieldFactory = /** @class */ (function () {
function GroupFieldFactory(parentFieldFactory, formBuilder) {
this.parentFieldFactory = parentFieldFactory;
this.formBuilder = formBuilder;
}
/**
* @template M
* @param {?} options
* @return {?}
*/
GroupFieldFactory.prototype.create = /**
* @template M
* @param {?} options
* @return {?}
*/
function (options) {
var setting = options.setting, settings = options.settings;
var _a = __read(this.createChildContexts(options), 2), formControl = _a[0], children = _a[1];
/** @type {?} */
var dynamicController = new DynamicGroupController(formControl, this.parentFieldFactory, setting, settings);
/** @type {?} */
var groupFormContext = __assign({}, this.parentFieldFactory.resolveComponent(formControl, setting, options.initialValue, dynamicController), { children: children });
/** @type {?} */
var groupComponent = (/** @type {?} */ (groupFormContext.componentRef.instance));
if (!groupComponent.formRoot) {
throw new Error("Group component " + setting.name + " is not a group component. It is missing the 'formRoot' directive.");
}
dynamicController.onInit(groupFormContext);
return groupFormContext;
};
/**
* @param {?} formRoot
* @param {?} root
* @return {?}
*/
GroupFieldFactory.prototype.render = /**
* @param {?} formRoot
* @param {?} root
* @return {?}
*/
function (formRoot, root) {
var _this = this;
/** @type {?} */
var viewRef = formRoot.viewContainerRef.insert(root.componentRef.hostView);
viewRef.detectChanges();
/** @type {?} */
var entries = Object.entries(root.children);
entries.forEach((/**
* @param {?} __0
* @return {?}
*/
function (_a) {
var _b = __read(_a, 2), _id = _b[0], context = _b[1];
/** @type {?} */
var component = (/** @type {?} */ (root.componentRef.instance));
_this.parentFieldFactory.render(component.formRoot, context);
}));
return viewRef;
};
/**
* @param {?} context
* @return {?}
*/
GroupFieldFactory.prototype.updateChildren = /**
* @param {?} context
* @return {?}
*/
function (context) {
/** @type {?} */
var controlEntires = Object.entries(context.formControl.controls);
/** @type {?} */
var entries = Object.entries(context.children);
entries.forEach((/**
* @param {?} __0
* @return {?}
*/
function (_a) {
var _b = __read(_a, 2), _id = _b[0], child = _b[1];
/** @type {?} */
var missingFormControl = controlEntires.find((/**
* @param {?} entry
* @return {?}
*/
function (entry) { return child.formControl === entry[1]; }));
if (missingFormControl) {
context.formControl.setControl(missingFormControl[0], missingFormControl[1]);
}
}));
};
/**
* @private
* @template M
* @param {?} options
* @return {?}
*/
GroupFieldFactory.prototype.createChildContexts = /**
* @private
* @template M
* @param {?} options
* @return {?}
*/
function (options) {
var _this = this;
var setting = options.setting, settings = options.settings;
if (options.formControl) {
/** @type {?} */
var controlEntires = Object.entries(options.formControl.controls);
/** @type {?} */
var children_1 = {};
controlEntires.forEach((/**
* @param {?} __0
* @return {?}
*/
function (_a) {
var _b = __read(_a, 2), id = _b[0], formControl = _b[1];
children_1[id] = _this.parentFieldFactory.create({
formControl: formControl,
setting: _this.getSetting(id, settings),
settings: settings
});
}));
return [options.formControl, children_1];
}
var value = options.initialValue;
if (typeof value !== "object") {
throw new Error("Value of group " + setting.name + " is not an object");
}
/** @type {?} */
var children = {};
/** @type {?} */
var formChildren = {};
Object.entries(value).forEach((/**
* @param {?} __0
* @return {?}
*/
function (_a) {
var _b = __read(_a, 2), id = _b[0], child = _b[1];
children[id] = _this.parentFieldFactory.create({
initialValue: child,
setting: _this.getSetting(id, settings),
settings: settings
});
formChildren[id] = children[id].formControl;
}));
/** @type {?} */
var formControl = this.formBuilder.group(formChildren);
return [formControl, children];
};
/**
* @private
* @template M
* @param {?} id
* @param {?} settings
* @return {?}
*/
GroupFieldFactory.prototype.getSetting = /**
* @private
* @template M
* @param {?} id
* @param {?} settings
* @return {?}
*/
function (id, settings) {
/** @type {?} */
var childSetting = (/** @type {?} */ (settings.get(id)));
if (!childSetting) {
throw new Error("Form field '" + id + "' has no assigned form field setting.");
}
return childSetting;
};
return GroupFieldFactory;
}());
if (false) {
/**
* @type {?}
* @private
*/
GroupFieldFactory.prototype.parentFieldFactory;
/**
* @type {?}
* @private
*/
GroupFieldFactory.prototype.formBuilder;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var ArrayRenderer = /** @class */ (function () {
// TODO is arrayRoot needed
function ArrayRenderer(parentFieldFactory, arrayRoot) {
this.parentFieldFactory = parentFieldFactory;
this.arrayRoot = arrayRoot;
}
/**
* @param {?} context
* @param {?} pageEvent
* @return {?}
*/
ArrayRenderer.prototype.render = /**
* @param {?} context
* @param {?} pageEvent
* @return {?}
*/
function (context, pageEvent) {
this.renderChildren(this.arrayRoot, this.getChildrenToRender((/** @type {?} */ (context.children)), pageEvent));
};
/**
* @private
* @param {?} arrayRoot
* @param {?} contexts
* @return {?}
*/
ArrayRenderer.prototype.renderChildren = /**
* @private
* @param {?} arrayRoot
* @param {?} contexts
* @return {?}
*/
function (arrayRoot, contexts) {
var _this = this;
arrayRoot.clearView();
contexts.forEach((/**
* @param {?} context
* @return {?}
*/
function (context) {
if (context.componentRef.hostView.destroyed) {
// recreate the view if it is destroyed
/** @type {?} */
var newContext = _this.parentFieldFactory.create(context);
_this.parentFieldFactory.render(arrayRoot, newContext);
return;
}
_this.parentFieldFactory.render(arrayRoot, context);
}));
};
/**
* @private
* @param {?} children
* @param {?} pageEvent
* @return {?}
*/
ArrayRenderer.prototype.getChildrenToRender = /**
* @private
* @param {?} children
* @param {?} pageEvent
* @return {?}
*/
function (children, pageEvent) {
return children.slice(pageEvent.pageIndex * pageEvent.pageSize, (pageEvent.pageIndex + 1) * pageEvent.pageSize);
};
return ArrayRenderer;
}());
if (false) {
/**
* @type {?}
* @private
*/
ArrayRenderer.prototype.parentFieldFactory;
/**
* @type {?}
* @private
*/
ArrayRenderer.prototype.arrayRoot;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @template M, CM
*/
var /**
* @template M, CM
*/
DynamicArrayController = /** @class */ (function (_super) {
__extends(DynamicArrayController, _super);
function DynamicArrayController(parentFieldFactory) {
var _this = _super.call(this) || this;
_this.parentFieldFactory = parentFieldFactory;
_this.subscriptions = [];
return _this;
}
/**
* @param {?} context
* @return {?}
*/
DynamicArrayController.prototype.onInit = /**
* @param {?} context
* @return {?}
*/
function (context) {
var _this = this;
this.arrayContext = context;
this.renderer = new ArrayRenderer(this.parentFieldFactory, this.arrayRoot);
this.paginator.updateTotalSize(this.children.length);
this.subscriptions.push(this.paginator.onPageEvent().subscribe((/**
* @param {?} event
* @return {?}
*/
function (event) { return _this.renderPage(event); })));
};
Object.defineProperty(DynamicArrayController.prototype, "paginator", {
get: /**
* @return {?}
*/
function () {
return this.setting.renderStrategy.paginator;
},
enumerable: true,
configurable: true
});
Object.defineProperty(DynamicArrayController.prototype, "children", {
get: /**
* @private
* @return {?}
*/
function () {
return (/** @type {?} */ (this.arrayContext.children));
},
enumerable: true,
configurable: true
});
Object.defineProperty(DynamicArrayController.prototype, "formArray", {
get: /**
* @private
* @return {?}
*/
function () {
return this.arrayContext.formControl;
},
enumerable: true,
configurable: true
});
Object.defineProperty(DynamicArrayController.prototype, "setting", {
get: /**
* @private
* @return {?}
*/
function () {
return (/** @type {?} */ (this.arrayContext.setting));
},
enumerable: true,
configurable: true
});
Object.defineProperty(DynamicArrayController.prototype, "settings", {
get: /**
* @private
* @return {?}
*/
function () {
return this.arrayContext.settings;
},
enumerable: true,
configurable: true
});
/**
* @param {?} value
* @return {?}
*/
DynamicArrayController.prototype.push = /**
* @param {?} value
* @return {?}
*/
function (value) {
/** @type {?} */
var newChildContext = this.parentFieldFactory.create({
setting: this.setting.childSetting,
settings: this.settings,
initialValue: value
});
this.children.push(newChildContext);
this.parentFieldFactory.updateChildren(this.arrayContext);
this.paginator.updateTotalSize(this.children.length);
this.renderPage();
};
/**
* @param {?} index
* @return {?}
*/
DynamicArrayController.prototype.removeAt = /**
* @param {?} index
* @return {?}
*/
function (index) {
if (index >= this.children.length || index < 0) {
return false;
}
this.children.splice(index, 1);
this.parentFieldFactory.updateChildren(this.arrayContext);
this.paginator.updateTotalSize(this.children.length);
this.renderPage();
return true;
};
/**
* @protected
* @return {?}
*/
DynamicArrayController.prototype.destory = /**
* @protected
* @return {?}
*/
function () {
this.subscriptions.forEach((/**
* @param {?} s
* @return {?}
*/
function (s) { return s.unsubscribe(); }));
};
/**
* @private
* @param {?=} pageEvent
* @return {?}
*/
DynamicArrayController.prototype.renderPage = /**
* @private
* @param {?=} pageEvent
* @return {?}
*/
function (pageEvent) {
if (pageEvent === void 0) { pageEvent = this.paginator.currentPage; }
return this.renderer.render(this.arrayContext, pageEvent);
};
Object.defineProperty(DynamicArrayController.prototype, "arrayRoot", {
get: /**
* @private
* @return {?}
*/
function () {
return ((/** @type {?} */ (this._componentRef.instance))).formRoot;
},
enumerable: true,
configurable: true
});
return DynamicArrayController;
}(DynamicController));
if (false) {
/**
* @type {?}
* @private
*/
DynamicArrayController.prototype.arrayContext;
/**
* @type {?}
* @private
*/
DynamicArrayController.prototype.subscriptions;
/**
* @type {?}
* @private
*/
DynamicArrayController.prototype.renderer;
/**
* @type {?}
* @private
*/
DynamicArrayController.prototype.parentFieldFactory;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var ArrayFieldFactory = /** @class */ (function () {
function ArrayFieldFactory(parentFieldFactory, formBuilder) {
this.parentFieldFactory = parentFieldFactory;
this.formBuilder = formBuilder;
}
/**
* @template M
* @param {?} options
* @return {?}
*/
ArrayFieldFactory.prototype.create = /**
* @template M
* @param {?} options
* @return {?}
*/
function (options) {
var setting = options.setting;
if (!setting.childSetting) {
throw new Error("Array " + options.setting.name + " needs 'childSetting' as part of its setting.");
}
var _a = __read(this.createChildContexts(options), 2), formControl = _a[0], children = _a[1];
/** @type {?} */
var dynamicController = new DynamicArrayController(this.parentFieldFactory);
/** @type {?} */
var arrayComponentContext = __assign({}, this.parentFieldFactory.resolveComponent(formControl, setting, options.initialValue, dynamicController), { children: children });
/** @type {?} */
var arrayComponent = (/** @type {?} */ (arrayComponentContext.componentRef.instance));
if (!arrayComponent.formRoot) {
throw new Error("Array component " + setting.name + " is not an array component. It is missing the 'formRoot' directive.");
}
// initialize controller after all values and children are resolved
dynamicController.onInit(arrayComponentContext);
return arrayComponentContext;
};
/**
* @param {?} arrayContext
* @return {?}
*/
ArrayFieldFactory.prototype.updateChildren = /**
* @param {?} arrayContext
* @return {?}
*/
function (arrayContext) {
/** @type {?} */
var unchecked = __spread(arrayContext.formControl.controls);
((/** @type {?} */ (arrayContext.children))).forEach((/**
* @param {?} child
* @param {?} i
* @return {?}
*/
function (child, i) {
if (arrayContext.formControl.controls.indexOf(child.formControl) === -1) {
arrayContext.formControl.insert(i, child.formControl);
}
else {
unchecked.splice(unchecked.indexOf(child.formControl), 1);
}
}));
unchecked.forEach((/**
* @param {?} control
* @return {?}
*/
function (control) { return arrayContext.formControl.removeAt(arrayContext.formControl.controls.indexOf(control)); }));
};
/**
* @param {?} formRoot
* @param {?} arrayContext
* @return {?}
*/
ArrayFieldFactory.prototype.render = /**
* @param {?} formRoot
* @param {?} arrayContext
* @return {?}
*/
function (formRoot, arrayContext) {
/** @type {?} */
var viewRef = formRoot.viewContainerRef.insert(arrayContext.componentRef.hostView);
viewRef.detectChanges();
/** @type {?} */
var arrayComponent = (/** @type {?} */ (arrayContext.componentRef.instance));
/** @type {?} */
var paginator = ((/** @type {?} */ (arrayContext.setting))).renderStrategy.paginator;
/** @type {?} */
var pageEvent = { pageIndex: paginator.pageIndex, pageSize: paginator.pageSize };
/** @type {?} */
var renderer = new ArrayRenderer(this.parentFieldFactory, arrayComponent.formRoot);
renderer.render(arrayContext, pageEvent);
return viewRef;
};
/**
* @private
* @template M
* @param {?} options
* @return {?}
*/
ArrayFieldFactory.prototype.createChildContexts = /**
* @private
* @template M
* @param {?} options
* @return {?}
*/
function (options) {
var _this = this;
if (options.formControl) {
/** @type {?} */
var children_1 = options.formControl.controls.map((/**
* @param {?} formControl
* @return {?}
*/
function (formControl) {
return _this.parentFieldFactory.create({
formControl: formControl,
setting: options.setting.childSetting,
settings: options.settings
});
}));
return [options.formControl, children_1];
}
/** @type {?} */
var values = options.initialValue ? options.initialValue : [];
if (!Array.isArray(values)) {
throw new Error("Value of " + options.setting.name + " is not an array.");
}
/** @type {?} */
var children = values.map((/**
* @param {?} value
* @return {?}
*/
function (value) {
return _this.parentFieldFactory.create({
initialValue: value,
setting: options.setting.childSetting,
settings: options.settings
});
}));
/** @type {?} */
var formControl = this.formBuilder.array(children.map((/**
* @param {?} context
* @return {?}
*/
function (context) { return context.formControl; })));
return [formControl, children];
};
return ArrayFieldFactory;
}());
if (false) {
/**
* @type {?}
* @private
*/
ArrayFieldFactory.prototype.parentFieldFactory;
/**
* @type {?}
* @private
*/
ArrayFieldFactory.prototype.formBuilder;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @template M
*/
var /**
* @template M
*/
DynamicSingleController = /** @class */ (function (_super) {
__extends(DynamicSingleController, _super);
function DynamicSingleController(formControl, fieldFactory, setting, settings) {
var _this = _super.call(this) || this;
_this.formControl = formControl;
_this.fieldFactory = fieldFactory;
_this.setting = setting;
_this.settings = settings;
return _this;
}
/**
* @param {?} context
* @return {?}
*/
DynamicSingleController.prototype.onInit = /**
* @param {?} context
* @return {?}
*/
function (context) { };
/**
* @protected
* @return {?}
*/
DynamicSingleController.prototype.destory = /**
* @protected
* @return {?}
*/
function () {
// TODO
};
return DynamicSingleController;
}(DynamicController));
if (false) {
/**
* @type {?}
* @private
*/
DynamicSingleCo