@mtna/web-form-angular 0.0.1

package/esm2015/lib/core/services/form-manager.service.js

@@ -0,0 +1,465 @@
+import { Injectable } from '@angular/core';
+import { isType } from '@mtna/core-ts';
+import { isConditionalItem, isForm, isFormItemGroupImpl, isOptionGroupItemImpl, isOptionItemImpl, isRepeatableItem, isSection, isTableItem, MtnaWfFormItemChange, } from '@mtna/web-form-ts';
+import { Subject } from 'rxjs';
+import { take } from 'rxjs/operators';
+import { findFormControl, MtnaWfSerializer } from '../utilities';
+import * as i0 from "@angular/core";
+import * as i1 from "./api.service";
+import * as i2 from "./ng-form.service";
+import * as i3 from "./ui.service";
+/**
+ * Allows a caller to (de)serializae an MtnaForm. It contains the determining logic for returning specific form controls
+ * and deserializing new MtnaForms from the reactive values, as well as registering custom Form Items & functions.
+ *
+ * @export
+ */
+export class MtnaWfManagerService {
+    constructor(apiService, ngFormManager, uiService) {
+        this.apiService = apiService;
+        this.ngFormManager = ngFormManager;
+        this.uiService = uiService;
+        this.components = new Map();
+        this.formChange$ = new Subject();
+        /** A map of all {@link FormItemValidationResult} keyed on id */
+        this._formItemValidationResults = {};
+        /**
+         * Any FormService extension class should override this method in order to call the
+         * dynamicWebFormItemBuilder/dynamicReactiveFormControlBuilder methods. During web form generation, this method is checked &
+         * the current FormItem is passed in, which can be used by the overriding method.
+         *
+         * @example dynamicFormConditional = (item: FormItem) => item.itemId.includes({some itemId})
+         *
+         */
+        this.dynamicFormConditional = () => false;
+    }
+    /**
+     * Observable stream of MtnaForm changes. Used to inform a subscriber that an MtnaForm has been changed.
+     *
+     * @returns Observable<MtnaForm> to which a caller can subscribe
+     */
+    get formChanges() {
+        return this.formChange$.asObservable();
+    }
+    /**
+     * Adds or removes a FormItem from the form & modifies other affected FormItems
+     * @param change MtnaWfFormItemChange
+     */
+    changeMtnaFormItem(change) {
+        if (!this._mtnaForm) {
+            return;
+        }
+        if (change.actionType === 'REMOVE') {
+            // remove the repeatable item from the mtnaform
+            let newForm = this._modifyFormItem(this._mtnaForm, change);
+            // modify the conditions of all effected form items
+            newForm = this._modifyFormItemConditions(newForm, change);
+            this.ngFormManager.removeControl(change.id, change.parentIds);
+            this.formChange$.next(newForm);
+        }
+        else {
+            this.apiService
+                .getRepeatableItem(this._mtnaForm.instanceId, change.id)
+                .pipe(take(1))
+                .subscribe((newItem) => {
+                const newFormControl = this.serializeMtnaFormItem(newItem);
+                if (newFormControl && this._mtnaForm) {
+                    this.ngFormManager.addControl(newItem.instanceId, change.parentIds, newFormControl);
+                    // Add the new repeatable item into the mtnaform
+                    let newForm = this._modifyFormItem(this._mtnaForm, Object.assign(Object.assign({}, change), { id: newItem.instanceId }), newItem);
+                    // Generate a list of all formitem conditions needing change & modify those items in the form
+                    const conditionChanges = this.generateConditionChangeArray(newItem, 'ADD');
+                    newForm = this._modifyFormItemConditions(newForm, Object.assign(Object.assign({}, change), { conditionChanges }));
+                    this.itemToggleQue = conditionChanges;
+                    // emit the new mtnaform
+                    this.formChange$.next(newForm);
+                }
+            });
+        }
+    }
+    /**
+     * Returns a ConditionChange array for items existing in the <item> which enable/disable FormItems outside the <item>'s scope.
+     * @param item FormItem that effects the condition of other FormItems
+     * @param action Whether this item was added (ADD), or removed (REMOVE)
+     * @returns Array<ConditionChange>
+     */
+    generateConditionChangeArray(item, action) {
+        const internalMap = {};
+        this._buildInternalIdsMap(item, internalMap);
+        const conditionChanges = new Array();
+        this._buildConditionChangeArray(item, conditionChanges, internalMap, action);
+        return conditionChanges;
+    }
+    /** @returns The top level validation results (usually the errors), keyed on ID. */
+    getFormItemValidationResults() {
+        return this._formItemValidationResults;
+    }
+    /**
+     * Returns a new MtnaForm using the previous MtnaForm & reactive form values.
+     *
+     * @param mtnaForm MtnaForm requiring value insertion
+     * @param ngFormValues JSON object of  ngForm values
+     * @returns new MtnaForm
+     */
+    insertNewValues(mtnaForm, ngFormValues) {
+        return Object.assign(Object.assign({}, mtnaForm), { items: MtnaWfSerializer.insertFormItemValues(mtnaForm, ngFormValues, this.uiService.getDisabledStates(), this.dynamicFormConditional, this.dynamicWebFormItemBuilder) });
+    }
+    /**
+     * Serializes a Form | FormItem into FormControl(s)
+     *
+     * @param item Form | FormItem requiring serialization
+     * @returns FormGroup | FormControl
+     */
+    serializeMtnaFormItem(item) {
+        return MtnaWfSerializer.determineSerializeFunctionToUse(item, this, this.dynamicFormConditional, this.dynamicReactiveFormControlBuilder);
+    }
+    //#region Custom Component/Function Registration
+    getDynamicComponent(id) {
+        return this.components.get(id);
+    }
+    /**
+     * Registers a map of components to be dynamically rendered inside an MtnaForm.
+     *
+     * @param components the map of components that a ValueItem will use for rendering
+     * @prop string - the type(itemId suffix) of component, used for retrieval
+     * @prop Type - the component to be rendered, an extension of BaseFormItem
+     */
+    registerDynamicComponents(components) {
+        this.components = components;
+    }
+    /**
+     * Sets an MtnaForm on the service
+     * @param form MtnaForm to be used for internal modification
+     */
+    setMtnaForm(form) {
+        this._mtnaForm = Object.assign({}, form);
+        if (!!this.itemToggleQue && !!this.itemToggleQue.length) {
+            // The form needs time to rerender, so we push this loop to the end of the stack
+            setTimeout(() => {
+                if (this.itemToggleQue) {
+                    for (const change of this.itemToggleQue) {
+                        this.uiService.toggleFormItems(change.enabledItems, change.disabledItems, !!change.enable, change.enablerId, true);
+                    }
+                }
+                this.itemToggleQue = null;
+            }, 0);
+        }
+        // Keep track of any errors coming from the server and revalidate those controls
+        this._updateServerSideErrors();
+    }
+    /**
+     * Function to be overridden by extended service in order to handle form generation for any application-specific dynamic form components.
+     * Should return a new ValueItem<any>.
+     * Step 3
+     *
+     * @example dynamicWebFormItemBuilder(section: Section | Form, item: FormItem, ngFormValue: any): ValueItem {
+     * const newValue = this.generateNewValue(item, rfValue, section);
+     * return { ...item, ...newValue }
+     * }
+     * @param section the current FormSection
+     * @param item the current FormItem
+     * @param ngFormValue the ngForm JSON value
+     * @returns a new ValueItem
+     */
+    dynamicWebFormItemBuilder(
+    /* eslint-disable @typescript-eslint/no-unused-vars */
+    section, item, ngFormValue, disabledState
+    /* eslint-enable @typescript-eslint/no-unused-vars */
+    ) {
+        return null;
+    }
+    /**
+     * Function to be overridden by extended service in order to handle reactive form generation
+     * for any application-specific dynamic form components.
+     * Should return FormControl | FormGroup.
+     *
+     * @example dynamicReactiveFormControlBuilder(item: FormItem) {
+     * return this.buildFormControlForDynamicComponent(item: FormItem);
+     * }
+     * @param item FormItem used to generate form controls
+     * @returns FormControl | FormGroup
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    dynamicReactiveFormControlBuilder(item) {
+        return null;
+    }
+    //#endregion
+    //#region INTERNAL METHODS
+    /**
+     * Recursively traverses a Form to insert or remove a designated FormItem.
+     * @param item MtnaForm to search through
+     * @param change: MtnaWfFormItemChange for adding or removing a FormItem
+     * @param newItem FormItem to add to its parent
+     */
+    _modifyFormItem(item, change, newItem) {
+        if (!change.parentIds.length) {
+            // At this point, we reach the Parent FormItem
+            if (change.actionType === 'REPLACE') {
+                if ('items' in item) {
+                    const index = item.items.findIndex((i) => i.instanceId === (newItem === null || newItem === void 0 ? void 0 : newItem.instanceId));
+                    const newItems = [...item.items];
+                    if (newItem) {
+                        newItems.splice(index, 1, newItem);
+                    }
+                    return Object.assign(Object.assign({}, item), { items: newItems });
+                }
+                return item;
+            }
+            else if (isRepeatableItem(item)) {
+                return Object.assign(Object.assign({}, item), { items: change.actionType === 'ADD' ? item.items.concat(newItem || []) : item.items.filter((i) => i.instanceId !== change.id) });
+            }
+            else {
+                return item;
+            }
+        }
+        if (isForm(item) || isSection(item) || isFormItemGroupImpl(item) || isRepeatableItem(item)) {
+            const items = [...item.items];
+            const indexToModify = item.items.findIndex((i) => i.instanceId === change.parentIds[0]);
+            const itemToModify = item.items[indexToModify];
+            items.splice(indexToModify, 1, this._modifyFormItem(itemToModify, Object.assign(Object.assign({}, change), { parentIds: change.parentIds.slice(1) }), newItem));
+            return Object.assign(Object.assign({}, item), { items });
+        }
+        else if (isTableItem(item)) {
+            return this._modifyTableItem(item, change, newItem);
+        }
+        else if (isOptionItemImpl(item) || isOptionGroupItemImpl(item)) {
+            return this._modifyOptionItem(item, change, newItem)[0];
+        }
+        return item;
+    }
+    /**
+     * Traverses an OptionItemMap of a FormItem to insert or remove a designated FormItem
+     * @param optionItem FormItem with an optionItemMap, e.g. OptionItemImpl | OptionGroupItemImpl
+     * @param change MtnaWfFormItemChange for adding or removing a FormItem
+     * @param newItem FormItem to be added to its parent
+     * @returns FormItem with an optionItemMap containing FormItems
+     */
+    _modifyOptionItem(optionItem, change, newItem) {
+        let found = false;
+        const optionItemMap = {};
+        // Loop through the map and set the items to a new map
+        // Check if any FormItem in the map matches the next parent ID
+        for (const id in optionItem.optionItemMap) {
+            if (Object.prototype.hasOwnProperty.call(optionItem.optionItemMap, id)) {
+                // If one matches, modify & set it on the new map
+                if (optionItem.optionItemMap[id].instanceId === change.parentIds[0]) {
+                    found = true;
+                    optionItemMap[id] = this._modifyFormItem(optionItem.optionItemMap[id], Object.assign(Object.assign({}, change), { parentIds: change.parentIds.slice(1) }), newItem);
+                }
+                else {
+                    optionItemMap[id] = optionItem.optionItemMap[id];
+                }
+            }
+        }
+        // return the item with its new optionItemMap, & whether we found the matching item
+        return [Object.assign(Object.assign({}, optionItem), { optionItemMap }), found];
+    }
+    /**
+     * Traverses table rows to insert or remove a FormItem
+     * @param tableItem TableItem to traverse
+     * @param change MtnaWfFormItemChange for adding or removing a FormItem
+     * @param newItem FormItem to be added to its parent
+     * @returns TableItem with a FormItem added or removed
+     */
+    _modifyTableItem(tableItem, change, newItem) {
+        let found = false;
+        // Map the table rows to find the FormItem with matching instanceId
+        const tableRows = tableItem.tableRows.map((row) => {
+            // If the item was found, skip mapping further rows
+            if (!found) {
+                return Object.assign(Object.assign({}, row), { items: row.items.map((rowItem) => {
+                        // If we found the next matching FormItem, toggle 'found', and return the modified FormItem
+                        if (!!rowItem && rowItem.instanceId === change.parentIds[0]) {
+                            found = true;
+                            return this._modifyFormItem(rowItem, Object.assign(Object.assign({}, change), { parentIds: change.parentIds.slice(1) }), newItem);
+                        }
+                        // If the FormItem instanceId doesn't match, but it has FormItems in its 'optionItemMap',
+                        // We need to check if a matching FormItem exists in its map
+                        if ('optionItemMap' in rowItem) {
+                            const returned = this._modifyOptionItem(rowItem, change, newItem);
+                            found = returned[1];
+                            return returned[0];
+                        }
+                        return rowItem;
+                    }) });
+            }
+            return row;
+        });
+        return Object.assign(Object.assign({}, tableItem), { tableRows });
+    }
+    /**
+     * Adds or removes instanceIds from the 'itemIds' in a FormItem's condition
+     * @param form MtnaForm to search through & replace formitems with the new condition
+     * @param change The change that recently occurred in the mtnaForm
+     */
+    _modifyFormItemConditions(form, change) {
+        let newForm = form;
+        if (change.conditionChanges) {
+            const formItems = {};
+            for (const cc of change.conditionChanges) {
+                for (const toggledId of [...cc.enabledItems, ...cc.disabledItems]) {
+                    let formItem = formItems[toggledId];
+                    const formItemComponent = this.uiService.getItem(toggledId);
+                    if (!formItem && (formItemComponent === null || formItemComponent === void 0 ? void 0 : formItemComponent.item)) {
+                        formItem = formItemComponent === null || formItemComponent === void 0 ? void 0 : formItemComponent.item;
+                    }
+                    if (isConditionalItem(formItem) && formItem.condition) {
+                        const itemConditionItemIds = formItem.condition.itemIds || [];
+                        const itemIds = change.actionType === 'ADD'
+                            ? [...itemConditionItemIds, cc.enablerId]
+                            : itemConditionItemIds.filter((i) => i !== cc.enablerId);
+                        const newItem = Object.assign(Object.assign({}, formItem), { condition: Object.assign(Object.assign({}, formItem.condition), { itemIds }) });
+                        const newChange = new MtnaWfFormItemChange(newItem.instanceId, (formItemComponent === null || formItemComponent === void 0 ? void 0 : formItemComponent.parentIds) || [], 'REPLACE');
+                        newForm = this._modifyFormItem(newForm, newChange, newItem);
+                        formItems[toggledId] = newItem;
+                    }
+                }
+                if (change.actionType === 'REMOVE') {
+                    this.uiService.toggleFormItems(cc.enabledItems, cc.disabledItems, !!cc.enable, cc.enablerId);
+                }
+            }
+        }
+        return newForm;
+    }
+    /**
+     * Builds a map of all instanceIds inside an item. Checks 'items' & 'optionItemMap'
+     * @param item Item to recurse
+     * @param idMap map of the item's internal instanceIds
+     */
+    _buildInternalIdsMap(item, idMap) {
+        idMap[item.instanceId] = true;
+        if (isType(item, 'items')) {
+            const items = item.items;
+            for (const subItem of items) {
+                this._buildInternalIdsMap(subItem, idMap);
+            }
+        }
+        else if (isType(item, 'optionItemMap')) {
+            const map = item.optionItemMap;
+            for (const id in map) {
+                if (Object.prototype.hasOwnProperty.call(map, id)) {
+                    this._buildInternalIdsMap(map[id], idMap);
+                }
+            }
+        }
+    }
+    /**
+     * Builds an array of ConditionChanges to be implemented in an MtnaForm.
+     * @param item FormItem that was added/removed, which affects conditions of other FormItems
+     * @param changes Array to build up
+     * @param internalIdMap Map of all instanceIds located in the item; in order to exclude them from the condition changes
+     * @param action Whether the item was added or removed
+     */
+    _buildConditionChangeArray(item, changes, internalIdMap, action) {
+        if (isOptionItemImpl(item)) {
+            const enable = !!action && action === 'ADD' ? item.option.selected || item.value === item.option.option.id : false;
+            this._pushConditionToArray(item.instanceId, item.option.enabledItems, item.option.disabledItems, changes, internalIdMap, enable);
+            this._buildArrayFromOptionItemMap(item, changes, internalIdMap);
+        }
+        else if (isOptionGroupItemImpl(item)) {
+            for (const option of item.options) {
+                const enable = !!action && action === 'ADD' ? option.selected || (!!item.value && item.value.some((v) => v === option.option.id)) : false;
+                this._pushConditionToArray(item.instanceId, option.enabledItems, option.disabledItems, changes, internalIdMap, enable);
+            }
+            this._buildArrayFromOptionItemMap(item, changes, internalIdMap, action);
+        }
+        else if (isType(item, 'items')) {
+            const items = item.items;
+            for (const subItem of items) {
+                this._buildConditionChangeArray(subItem, changes, internalIdMap, action);
+            }
+        }
+    }
+    /**
+     * Builds an array of ConditionChanges from an item's optionItemMap
+     * @param item FormItem with an optionItemMap
+     * @param conditions Array of ConditionChanges to push on new changes
+     * @param itemMap map of instanceIds exisiting in an item; in order to exclude them from the changes
+     * @param action Whether an item was added or removed
+     */
+    _buildArrayFromOptionItemMap(item, conditions, itemMap, action) {
+        if (item.optionItemMap) {
+            for (const id in item.optionItemMap) {
+                if (Object.prototype.hasOwnProperty.call(item.optionItemMap, id)) {
+                    const subItem = item.optionItemMap[id];
+                    this._buildConditionChangeArray(subItem, conditions, itemMap, action);
+                }
+            }
+        }
+    }
+    /**
+     * Pushes a new ConditionChange onto the conditions array. If a ConditionChange with matching id exists,
+     * it merges the new values into it
+     * @param enablerId instanceId of the item that enables other FormItems
+     * @param enabled the item's 'enabledItems' array
+     * @param disabled the item's 'disabledItems' array
+     * @param conditions Array of ConditionChanges to build up
+     * @param itemMap map of instanceIds inside an item; to ensure no internal ids are included in a change
+     * @param enable Whether the 'enabledItems' should toggled enabled
+     */
+    _pushConditionToArray(enablerId, enabled, disabled, conditions, itemMap, enable) {
+        const enabledItems = enabled.filter((e) => !itemMap[e]);
+        const disabledItems = disabled.filter((d) => !itemMap[d]);
+        if (!!enabledItems.length || !!disabledItems.length) {
+            const index = conditions.findIndex((c) => c.enablerId === enablerId);
+            if (index < 0) {
+                conditions.push({ enablerId: enablerId, enabledItems, disabledItems, enable });
+            }
+            else {
+                const prev = conditions[index];
+                const newId = {
+                    enablerId,
+                    enabledItems: [...prev.enabledItems, ...enabledItems],
+                    disabledItems: [...prev.disabledItems, ...disabledItems],
+                    enable,
+                };
+                conditions.splice(index, 1, newId);
+            }
+        }
+    }
+    /**
+     * Store all validation errors on the service.
+     * Revalidate form controls that previously had errors or have new errors now.
+     */
+    _updateServerSideErrors() {
+        var _a;
+        // Keep track of IDs for each control that needs to be revalidated
+        const controlIdsToRevalidate = new Set();
+        // Collect controls previously in error to revalidate
+        if (this._formItemValidationResults) {
+            for (const id in this._formItemValidationResults) {
+                if (Object.prototype.hasOwnProperty.call(this._formItemValidationResults, id)) {
+                    controlIdsToRevalidate.add(id);
+                }
+            }
+        }
+        // Clear out all previous stored errors
+        this._formItemValidationResults = {};
+        if ((_a = this._mtnaForm) === null || _a === void 0 ? void 0 : _a.validationResult) {
+            for (const result of this._mtnaForm.validationResult.formItemValidationResults) {
+                if (result.validationStatus === 'ERRORS') {
+                    // Store errors so that the validationResultValidator can validate each control
+                    this._formItemValidationResults[result.id] = result;
+                    // We need to revalidate these controls that have errors
+                    controlIdsToRevalidate.add(result.id);
+                }
+            }
+        }
+        // Only revalidate controls actually changes
+        const form = this.ngFormManager.getForm();
+        if (form) {
+            for (const id of controlIdsToRevalidate) {
+                const control = findFormControl(id, form);
+                if (control) {
+                    control.updateValueAndValidity();
+                }
+            }
+        }
+    }
+}
+MtnaWfManagerService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MtnaWfManagerService, deps: [{ token: i1.MtnaWfApiService }, { token: i2.MtnaWfNgFormService }, { token: i3.MtnaWfUIService }], target: i0.ɵɵFactoryTarget.Injectable });
+MtnaWfManagerService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MtnaWfManagerService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MtnaWfManagerService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.MtnaWfApiService }, { type: i2.MtnaWfNgFormService }, { type: i3.MtnaWfUIService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"form-manager.service.js","sourceRoot":"","sources":["../../../../../../../projects/web-form-angular/src/lib/core/services/form-manager.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Type } from '@angular/core';\nimport { AbstractControl } from '@angular/forms';\n\nimport { isType } from '@mtna/core-ts';\nimport {\n  ConditionalItem,\n  ConditionChange,\n  Form,\n  FormItem,\n  FormItemGroup,\n  FormItemImpl,\n  FormItemValidationResult,\n  isConditionalItem,\n  isForm,\n  isFormItemGroupImpl,\n  isOptionGroupItemImpl,\n  isOptionItemImpl,\n  isRepeatableItem,\n  isSection,\n  isTableItem,\n  MtnaWfFormItemChange,\n  MtnaWfFormItemChangeAction,\n  Option,\n  OptionGroupItemImpl,\n  OptionItemImpl,\n  RepeatableItem,\n  Section,\n  TableItem,\n  TableRowItem,\n  ValueItem,\n} from '@mtna/web-form-ts';\n\nimport { Observable, Subject } from 'rxjs';\nimport { take } from 'rxjs/operators';\n\nimport { MtnaWfApiService } from './api.service';\nimport { findFormControl, MtnaWfSerializer } from '../utilities';\nimport { MtnaWfNgFormService } from './ng-form.service';\nimport { MtnaWfUIService } from './ui.service';\nimport type { BaseFormItem } from '../../form';\n\n/**\n * types of FormItems that can be passed into the 'modifyMtnaFormItem' method to add/remove items\n */\ntype ParentItemUnion =\n  | Form\n  | Section\n  | FormItemGroup\n  | RepeatableItem\n  | TableItem\n  | OptionItemImpl<Option<unknown>, unknown>\n  | OptionGroupItemImpl<Option<unknown>>;\n\n/**\n * Allows a caller to (de)serializae an MtnaForm. It contains the determining logic for returning specific form controls\n * and deserializing new MtnaForms from the reactive values, as well as registering custom Form Items & functions.\n *\n * @export\n */\n@Injectable()\nexport class MtnaWfManagerService {\n  protected components = new Map<string, Type<BaseFormItem>>();\n  protected formChange$ = new Subject<Form>();\n  /** A map of all {@link FormItemValidationResult} keyed on id */\n  protected _formItemValidationResults: Record<string, FormItemValidationResult> = {};\n  /** ConditionChanges on 'add' must wait until the form rerenders to toggle items */\n  protected itemToggleQue: Array<ConditionChange> | null | undefined;\n  protected _mtnaForm: Form | undefined;\n\n  /**\n   * Observable stream of MtnaForm changes. Used to inform a subscriber that an MtnaForm has been changed.\n   *\n   * @returns Observable<MtnaForm> to which a caller can subscribe\n   */\n  get formChanges(): Observable<Form> {\n    return this.formChange$.asObservable();\n  }\n\n  constructor(protected apiService: MtnaWfApiService, protected ngFormManager: MtnaWfNgFormService, protected uiService: MtnaWfUIService) {}\n\n  /**\n   * Adds or removes a FormItem from the form & modifies other affected FormItems\n   * @param change MtnaWfFormItemChange\n   */\n  changeMtnaFormItem(change: MtnaWfFormItemChange) {\n    if (!this._mtnaForm) {\n      return;\n    }\n\n    if (change.actionType === 'REMOVE') {\n      // remove the repeatable item from the mtnaform\n      let newForm = this._modifyFormItem(this._mtnaForm, change) as Form;\n      // modify the conditions of all effected form items\n      newForm = this._modifyFormItemConditions(newForm, change);\n\n      this.ngFormManager.removeControl(change.id, change.parentIds);\n      this.formChange$.next(newForm);\n    } else {\n      this.apiService\n        .getRepeatableItem(this._mtnaForm.instanceId, change.id)\n        .pipe(take(1))\n        .subscribe((newItem: FormItemImpl<unknown>) => {\n          const newFormControl = this.serializeMtnaFormItem(newItem);\n          if (newFormControl && this._mtnaForm) {\n            this.ngFormManager.addControl(newItem.instanceId, change.parentIds, newFormControl);\n            // Add the new repeatable item into the mtnaform\n            let newForm = this._modifyFormItem(this._mtnaForm, { ...change, id: newItem.instanceId }, newItem) as Form;\n\n            // Generate a list of all formitem conditions needing change & modify those items in the form\n            const conditionChanges = this.generateConditionChangeArray(newItem, 'ADD');\n            newForm = this._modifyFormItemConditions(newForm, { ...change, conditionChanges });\n            this.itemToggleQue = conditionChanges;\n            // emit the new mtnaform\n            this.formChange$.next(newForm);\n          }\n        });\n    }\n  }\n\n  /**\n   * Returns a ConditionChange array for items existing in the <item> which enable/disable FormItems outside the <item>'s scope.\n   * @param item FormItem that effects the condition of other FormItems\n   * @param action Whether this item was added (ADD), or removed (REMOVE)\n   * @returns Array<ConditionChange>\n   */\n  generateConditionChangeArray(item: FormItem, action?: MtnaWfFormItemChangeAction): Array<ConditionChange> {\n    const internalMap = {};\n    this._buildInternalIdsMap(item, internalMap);\n    const conditionChanges = new Array<ConditionChange>();\n    this._buildConditionChangeArray(item, conditionChanges, internalMap, action);\n    return conditionChanges;\n  }\n\n  /** @returns The top level validation results (usually the errors), keyed on ID. */\n  getFormItemValidationResults(): Record<string, FormItemValidationResult> {\n    return this._formItemValidationResults;\n  }\n\n  /**\n   * Returns a new MtnaForm using the previous MtnaForm & reactive form values.\n   *\n   * @param mtnaForm MtnaForm requiring value insertion\n   * @param ngFormValues JSON object of  ngForm values\n   * @returns new MtnaForm\n   */\n  insertNewValues(mtnaForm: Form, ngFormValues: Record<string, unknown>): Form {\n    return {\n      ...mtnaForm,\n      items: MtnaWfSerializer.insertFormItemValues(\n        mtnaForm,\n        ngFormValues,\n        this.uiService.getDisabledStates(),\n        this.dynamicFormConditional,\n        this.dynamicWebFormItemBuilder\n      ),\n    };\n  }\n\n  /**\n   * Serializes a Form | FormItem into FormControl(s)\n   *\n   * @param item Form | FormItem requiring serialization\n   * @returns FormGroup | FormControl\n   */\n  serializeMtnaFormItem(item: Form | FormItemImpl<unknown>): AbstractControl | null {\n    return MtnaWfSerializer.determineSerializeFunctionToUse(\n      item,\n      this,\n      this.dynamicFormConditional,\n      this.dynamicReactiveFormControlBuilder\n    );\n  }\n\n  //#region Custom Component/Function Registration\n  getDynamicComponent(id: string): Type<BaseFormItem> | undefined {\n    return this.components.get(id);\n  }\n\n  /**\n   * Registers a map of components to be dynamically rendered inside an MtnaForm.\n   *\n   * @param components the map of components that a ValueItem will use for rendering\n   * @prop string - the type(itemId suffix) of component, used for retrieval\n   * @prop Type - the component to be rendered, an extension of BaseFormItem\n   */\n  registerDynamicComponents(components: Map<string, Type<BaseFormItem>>) {\n    this.components = components;\n  }\n\n  /**\n   * Sets an MtnaForm on the service\n   * @param form MtnaForm to be used for internal modification\n   */\n  setMtnaForm(form: Form) {\n    this._mtnaForm = { ...form };\n    if (!!this.itemToggleQue && !!this.itemToggleQue.length) {\n      // The form needs time to rerender, so we push this loop to the end of the stack\n      setTimeout(() => {\n        if (this.itemToggleQue) {\n          for (const change of this.itemToggleQue) {\n            this.uiService.toggleFormItems(change.enabledItems, change.disabledItems, !!change.enable, change.enablerId, true);\n          }\n        }\n        this.itemToggleQue = null;\n      }, 0);\n    }\n\n    // Keep track of any errors coming from the server and revalidate those controls\n    this._updateServerSideErrors();\n  }\n\n  /**\n   * Any FormService extension class should override this method in order to call the\n   * dynamicWebFormItemBuilder/dynamicReactiveFormControlBuilder methods. During web form generation, this method is checked &\n   * the current FormItem is passed in, which can be used by the overriding method.\n   *\n   * @example dynamicFormConditional = (item: FormItem) => item.itemId.includes({some itemId})\n   *\n   */\n  protected dynamicFormConditional: (item: FormItem) => boolean = () => false;\n\n  /**\n   * Function to be overridden by extended service in order to handle form generation for any application-specific dynamic form components.\n   * Should return a new ValueItem<any>.\n   * Step 3\n   *\n   * @example dynamicWebFormItemBuilder(section: Section | Form, item: FormItem, ngFormValue: any): ValueItem {\n   * const newValue = this.generateNewValue(item, rfValue, section);\n   * return { ...item, ...newValue }\n   * }\n   * @param section the current FormSection\n   * @param item the current FormItem\n   * @param ngFormValue the ngForm JSON value\n   * @returns a new ValueItem\n   */\n  protected dynamicWebFormItemBuilder(\n    /* eslint-disable @typescript-eslint/no-unused-vars */\n    section: Form | FormItemGroup | RepeatableItem | undefined,\n    item: FormItem,\n    ngFormValue: unknown,\n    disabledState?: { [instanceId: string]: boolean }\n    /* eslint-enable @typescript-eslint/no-unused-vars */\n  ): ValueItem<unknown> | null {\n    return null;\n  }\n\n  /**\n   * Function to be overridden by extended service in order to handle reactive form generation\n   * for any application-specific dynamic form components.\n   * Should return FormControl | FormGroup.\n   *\n   * @example dynamicReactiveFormControlBuilder(item: FormItem) {\n   * return this.buildFormControlForDynamicComponent(item: FormItem);\n   * }\n   * @param item FormItem used to generate form controls\n   * @returns FormControl | FormGroup\n   */\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  protected dynamicReactiveFormControlBuilder(item: FormItem): AbstractControl | null {\n    return null;\n  }\n\n  //#endregion\n\n  //#region INTERNAL METHODS\n  /**\n   * Recursively traverses a Form to insert or remove a designated FormItem.\n   * @param item MtnaForm to search through\n   * @param change: MtnaWfFormItemChange for adding or removing a FormItem\n   * @param newItem FormItem to add to its parent\n   */\n  protected _modifyFormItem<I extends Form | Section | FormItem | FormItemImpl<unknown>>(\n    item: I,\n    change: MtnaWfFormItemChange,\n    newItem?: FormItem\n  ): Form | Section | FormItem | FormItemImpl<unknown> {\n    if (!change.parentIds.length) {\n      // At this point, we reach the Parent FormItem\n      if (change.actionType === 'REPLACE') {\n        if ('items' in item) {\n          const index = item.items.findIndex((i) => i.instanceId === newItem?.instanceId);\n          const newItems = [...item.items];\n          if (newItem) {\n            newItems.splice(index, 1, newItem);\n          }\n          return { ...item, items: newItems };\n        }\n        return item;\n      } else if (isRepeatableItem(item)) {\n        return {\n          ...item,\n          items: change.actionType === 'ADD' ? item.items.concat(newItem || []) : item.items.filter((i) => i.instanceId !== change.id),\n        };\n      } else {\n        return item;\n      }\n    }\n\n    if (isForm(item) || isSection(item) || isFormItemGroupImpl(item) || isRepeatableItem(item)) {\n      const items = [...item.items];\n      const indexToModify = item.items.findIndex((i) => i.instanceId === change.parentIds[0]);\n      const itemToModify = item.items[indexToModify] as ParentItemUnion;\n\n      items.splice(\n        indexToModify,\n        1,\n        this._modifyFormItem(itemToModify, { ...change, parentIds: change.parentIds.slice(1) }, newItem) as FormItem\n      );\n      return {\n        ...item,\n        items,\n      };\n    } else if (isTableItem(item)) {\n      return this._modifyTableItem(item as TableItem, change, newItem);\n    } else if (isOptionItemImpl(item) || isOptionGroupItemImpl(item)) {\n      return this._modifyOptionItem(\n        item as OptionItemImpl<Option<unknown>, unknown> | OptionGroupItemImpl<Option<unknown>>,\n        change,\n        newItem\n      )[0];\n    }\n    return item;\n  }\n\n  /**\n   * Traverses an OptionItemMap of a FormItem to insert or remove a designated FormItem\n   * @param optionItem FormItem with an optionItemMap, e.g. OptionItemImpl | OptionGroupItemImpl\n   * @param change MtnaWfFormItemChange for adding or removing a FormItem\n   * @param newItem FormItem to be added to its parent\n   * @returns FormItem with an optionItemMap containing FormItems\n   */\n  private _modifyOptionItem(\n    optionItem: OptionItemImpl<Option<unknown>, unknown> | OptionGroupItemImpl<Option<unknown>>,\n    change: MtnaWfFormItemChange,\n    newItem?: FormItem\n  ): [OptionItemImpl<Option<unknown>, unknown> | OptionGroupItemImpl<Option<unknown>>, boolean] {\n    let found = false;\n    const optionItemMap: { [id: string]: FormItem } = {};\n    // Loop through the map and set the items to a new map\n    // Check if any FormItem in the map matches the next parent ID\n    for (const id in optionItem.optionItemMap) {\n      if (Object.prototype.hasOwnProperty.call(optionItem.optionItemMap, id)) {\n        // If one matches, modify & set it on the new map\n        if (optionItem.optionItemMap[id].instanceId === change.parentIds[0]) {\n          found = true;\n          optionItemMap[id] = this._modifyFormItem(\n            optionItem.optionItemMap[id] as ParentItemUnion,\n            { ...change, parentIds: change.parentIds.slice(1) },\n            newItem\n          ) as FormItem;\n        } else {\n          optionItemMap[id] = optionItem.optionItemMap[id];\n        }\n      }\n    }\n    // return the item with its new optionItemMap, & whether we found the matching item\n    return [{ ...optionItem, optionItemMap }, found];\n  }\n\n  /**\n   * Traverses table rows to insert or remove a FormItem\n   * @param tableItem TableItem to traverse\n   * @param change MtnaWfFormItemChange for adding or removing a FormItem\n   * @param newItem FormItem to be added to its parent\n   * @returns TableItem with a FormItem added or removed\n   */\n  private _modifyTableItem(tableItem: TableItem, change: MtnaWfFormItemChange, newItem?: FormItem): TableItem {\n    let found = false;\n    // Map the table rows to find the FormItem with matching instanceId\n    const tableRows: TableRowItem[] = tableItem.tableRows.map((row: TableRowItem) => {\n      // If the item was found, skip mapping further rows\n      if (!found) {\n        return {\n          ...row,\n          items: row.items.map((rowItem: FormItem) => {\n            // If we found the next matching FormItem, toggle 'found', and return the modified FormItem\n            if (!!rowItem && rowItem.instanceId === change.parentIds[0]) {\n              found = true;\n              return this._modifyFormItem(\n                rowItem as ParentItemUnion,\n                { ...change, parentIds: change.parentIds.slice(1) },\n                newItem\n              ) as FormItem;\n            }\n            // If the FormItem instanceId doesn't match, but it has FormItems in its 'optionItemMap',\n            // We need to check if a matching FormItem exists in its map\n            if ('optionItemMap' in rowItem) {\n              const returned = this._modifyOptionItem(\n                rowItem as OptionItemImpl<Option<unknown>, unknown> | OptionGroupItemImpl<Option<unknown>>,\n                change,\n                newItem\n              );\n              found = returned[1];\n              return returned[0];\n            }\n            return rowItem;\n          }),\n        };\n      }\n      return row;\n    });\n    return { ...tableItem, tableRows };\n  }\n\n  /**\n   * Adds or removes instanceIds from the 'itemIds' in a FormItem's condition\n   * @param form MtnaForm to search through & replace formitems with the new condition\n   * @param change The change that recently occurred in the mtnaForm\n   */\n  private _modifyFormItemConditions(form: Form, change: MtnaWfFormItemChange): Form {\n    let newForm = form;\n    if (change.conditionChanges) {\n      const formItems: { [key: string]: FormItem | ConditionalItem } = {};\n      for (const cc of change.conditionChanges) {\n        for (const toggledId of [...cc.enabledItems, ...cc.disabledItems]) {\n          let formItem = formItems[toggledId];\n          const formItemComponent = this.uiService.getItem(toggledId);\n          if (!formItem && formItemComponent?.item) {\n            formItem = formItemComponent?.item;\n          }\n          if (isConditionalItem(formItem) && formItem.condition) {\n            const itemConditionItemIds = formItem.condition.itemIds || [];\n            const itemIds =\n              change.actionType === 'ADD'\n                ? [...itemConditionItemIds, cc.enablerId]\n                : itemConditionItemIds.filter((i) => i !== cc.enablerId);\n\n            const newItem: ConditionalItem = { ...formItem, condition: { ...formItem.condition, itemIds } };\n            const newChange = new MtnaWfFormItemChange(newItem.instanceId, formItemComponent?.parentIds || [], 'REPLACE');\n\n            newForm = this._modifyFormItem(newForm, newChange, newItem as FormItem & ConditionalItem) as Form;\n            formItems[toggledId] = newItem;\n          }\n        }\n        if (change.actionType === 'REMOVE') {\n          this.uiService.toggleFormItems(cc.enabledItems, cc.disabledItems, !!cc.enable, cc.enablerId);\n        }\n      }\n    }\n    return newForm;\n  }\n\n  /**\n   * Builds a map of all instanceIds inside an item. Checks 'items' & 'optionItemMap'\n   * @param item Item to recurse\n   * @param idMap map of the item's internal instanceIds\n   */\n  private _buildInternalIdsMap(item: FormItem, idMap: Record<string, boolean>) {\n    idMap[item.instanceId] = true;\n    if (isType<{ items: FormItem[] }>(item, 'items')) {\n      const items: FormItem[] = item.items;\n      for (const subItem of items) {\n        this._buildInternalIdsMap(subItem, idMap);\n      }\n    } else if (isType<{ optionItemMap: { [id: string]: FormItem } }>(item, 'optionItemMap')) {\n      const map: { [id: string]: FormItem } = item.optionItemMap;\n      for (const id in map) {\n        if (Object.prototype.hasOwnProperty.call(map, id)) {\n          this._buildInternalIdsMap(map[id], idMap);\n        }\n      }\n    }\n  }\n\n  /**\n   * Builds an array of ConditionChanges to be implemented in an MtnaForm.\n   * @param item FormItem that was added/removed, which affects conditions of other FormItems\n   * @param changes Array to build up\n   * @param internalIdMap Map of all instanceIds located in the item; in order to exclude them from the condition changes\n   * @param action Whether the item was added or removed\n   */\n  private _buildConditionChangeArray(\n    item: FormItem,\n    changes: Array<ConditionChange>,\n    internalIdMap: Record<string, boolean>,\n    action?: MtnaWfFormItemChangeAction\n  ) {\n    if (isOptionItemImpl(item)) {\n      const enable = !!action && action === 'ADD' ? item.option.selected || item.value === item.option.option.id : false;\n      this._pushConditionToArray(item.instanceId, item.option.enabledItems, item.option.disabledItems, changes, internalIdMap, enable);\n      this._buildArrayFromOptionItemMap(item, changes, internalIdMap);\n    } else if (isOptionGroupItemImpl(item)) {\n      for (const option of item.options) {\n        const enable =\n          !!action && action === 'ADD' ? option.selected || (!!item.value && item.value.some((v) => v === option.option.id)) : false;\n        this._pushConditionToArray(item.instanceId, option.enabledItems, option.disabledItems, changes, internalIdMap, enable);\n      }\n      this._buildArrayFromOptionItemMap(item, changes, internalIdMap, action);\n    } else if (isType<{ items: FormItem[] }>(item, 'items')) {\n      const items: FormItem[] = item.items;\n      for (const subItem of items) {\n        this._buildConditionChangeArray(subItem, changes, internalIdMap, action);\n      }\n    }\n  }\n\n  /**\n   * Builds an array of ConditionChanges from an item's optionItemMap\n   * @param item FormItem with an optionItemMap\n   * @param conditions Array of ConditionChanges to push on new changes\n   * @param itemMap map of instanceIds exisiting in an item; in order to exclude them from the changes\n   * @param action Whether an item was added or removed\n   */\n  private _buildArrayFromOptionItemMap(\n    item: OptionItemImpl<Option<unknown>, unknown> | OptionGroupItemImpl<Option<unknown>>,\n    conditions: Array<ConditionChange>,\n    itemMap: Record<string, boolean>,\n    action?: MtnaWfFormItemChangeAction\n  ) {\n    if (item.optionItemMap) {\n      for (const id in item.optionItemMap) {\n        if (Object.prototype.hasOwnProperty.call(item.optionItemMap, id)) {\n          const subItem = item.optionItemMap[id];\n          this._buildConditionChangeArray(subItem, conditions, itemMap, action);\n        }\n      }\n    }\n  }\n\n  /**\n   * Pushes a new ConditionChange onto the conditions array. If a ConditionChange with matching id exists,\n   * it merges the new values into it\n   * @param enablerId instanceId of the item that enables other FormItems\n   * @param enabled the item's 'enabledItems' array\n   * @param disabled the item's 'disabledItems' array\n   * @param conditions Array of ConditionChanges to build up\n   * @param itemMap map of instanceIds inside an item; to ensure no internal ids are included in a change\n   * @param enable Whether the 'enabledItems' should toggled enabled\n   */\n  private _pushConditionToArray(\n    enablerId: string,\n    enabled: string[],\n    disabled: string[],\n    conditions: Array<ConditionChange>,\n    itemMap: Record<string, boolean>,\n    enable: boolean\n  ) {\n    const enabledItems = enabled.filter((e) => !itemMap[e]);\n    const disabledItems = disabled.filter((d) => !itemMap[d]);\n    if (!!enabledItems.length || !!disabledItems.length) {\n      const index = conditions.findIndex((c) => c.enablerId === enablerId);\n      if (index < 0) {\n        conditions.push({ enablerId: enablerId, enabledItems, disabledItems, enable });\n      } else {\n        const prev = conditions[index];\n        const newId: ConditionChange = {\n          enablerId,\n          enabledItems: [...prev.enabledItems, ...enabledItems],\n          disabledItems: [...prev.disabledItems, ...disabledItems],\n          enable,\n        };\n        conditions.splice(index, 1, newId);\n      }\n    }\n  }\n\n  /**\n   * Store all validation errors on the service.\n   * Revalidate form controls that previously had errors or have new errors now.\n   */\n  private _updateServerSideErrors() {\n    // Keep track of IDs for each control that needs to be revalidated\n    const controlIdsToRevalidate = new Set<string>();\n\n    // Collect controls previously in error to revalidate\n    if (this._formItemValidationResults) {\n      for (const id in this._formItemValidationResults) {\n        if (Object.prototype.hasOwnProperty.call(this._formItemValidationResults, id)) {\n          controlIdsToRevalidate.add(id);\n        }\n      }\n    }\n\n    // Clear out all previous stored errors\n    this._formItemValidationResults = {};\n    if (this._mtnaForm?.validationResult) {\n      for (const result of this._mtnaForm.validationResult.formItemValidationResults) {\n        if (result.validationStatus === 'ERRORS') {\n          // Store errors so that the validationResultValidator can validate each control\n          this._formItemValidationResults[result.id] = result;\n          // We need to revalidate these controls that have errors\n          controlIdsToRevalidate.add(result.id);\n        }\n      }\n    }\n\n    // Only revalidate controls actually changes\n    const form = this.ngFormManager.getForm();\n    if (form) {\n      for (const id of controlIdsToRevalidate) {\n        const control = findFormControl(id, form);\n        if (control) {\n          control.updateValueAndValidity();\n        }\n      }\n    }\n  }\n\n  //#endregion\n}\n"]}

package/esm2015/lib/core/services/index.js

@@ -0,0 +1,5 @@
+export * from './api.service';
+export * from './form-manager.service';
+export * from './ng-form.service';
+export * from './ui.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy93ZWItZm9ybS1hbmd1bGFyL3NyYy9saWIvY29yZS9zZXJ2aWNlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGVBQWUsQ0FBQztBQUM5QixjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyxjQUFjLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2FwaS5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vZm9ybS1tYW5hZ2VyLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9uZy1mb3JtLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi91aS5zZXJ2aWNlJztcbiJdfQ==