@mtna/web-form-angular 0.0.1

package/esm2015/lib/file-upload/file-upload.component.js

@@ -0,0 +1,66 @@
+import { Component, EventEmitter, Input, Output } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@mtna/file-manager-angular";
+import * as i2 from "@angular/material/button";
+import * as i3 from "@angular/material/icon";
+import * as i4 from "@angular/material/progress-spinner";
+import * as i5 from "@angular/common";
+import * as i6 from "@mtna/core-angular";
+export class MtnaWfFileUploadComponent {
+    constructor(fileService) {
+        this.fileService = fileService;
+        this.header = null;
+        this.indicatorStatus = 'INACTIVE';
+        this.readonly = false;
+        this.file = new EventEmitter();
+        this.loading = false;
+    }
+    fileToUpload(file) {
+        this.loading = true;
+        this.fileService.uploadFile(file).subscribe((fileInfo) => {
+            this.loading = false;
+            this.fileInfo = fileInfo;
+            this.file.emit(fileInfo);
+        });
+    }
+    handleDownload(template) {
+        this.fileService.downloadFileGET(template.key, template.fileName, template.contentType);
+    }
+    ngOnInit() {
+        var _a;
+        if ((_a = this.item) === null || _a === void 0 ? void 0 : _a.value) {
+            this.fileInfo = this.item.value;
+        }
+    }
+    removeFile() {
+        if (this.fileInfo) {
+            this.loading = true;
+            this.fileService.deleteFile(this.fileInfo).subscribe(() => {
+                this.loading = false;
+                this.fileInfo = undefined;
+                this.file.emit(undefined);
+            });
+        }
+    }
+}
+MtnaWfFileUploadComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MtnaWfFileUploadComponent, deps: [{ token: i1.FileService }], target: i0.ɵɵFactoryTarget.Component });
+MtnaWfFileUploadComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: MtnaWfFileUploadComponent, selector: "mtna-wf-file-upload-item", inputs: { header: "header", indicatorStatus: "indicatorStatus", item: "item", readonly: "readonly" }, outputs: { file: "file" }, ngImport: i0, template: "<ng-container *ngTemplateOutlet=\"header\"></ng-container>\n\n<div class=\"content\" [mtnaHighlight]=\"indicatorStatus === 'ACTIVE' && !item?.questionText && !item?.descriptiveText\">\n  <ng-container *ngIf=\"!readonly; else readOnly\">\n    <ng-container *ngIf=\"!loading; else loader\">\n      <mtna-file-download\n        *ngIf=\"!!fileInfo; else fileUpload\"\n        [fileInfo]=\"fileInfo\"\n        [canRemove]=\"true\"\n        color=\"primary\"\n        [canDownload]=\"true\"\n        (download)=\"handleDownload($event)\"\n        (remove)=\"removeFile()\"\n      ></mtna-file-download>\n\n      <ng-template #fileUpload>\n        <mtna-file-upload\n          [automaticUpload]=\"false\"\n          color=\"primary\"\n          [buttonText]=\"'CHOOSE A FILE'\"\n          (fileToUpload)=\"fileToUpload($event)\"\n        ></mtna-file-upload>\n      </ng-template>\n    </ng-container>\n  </ng-container>\n\n  <!-- READONLY -->\n  <ng-template #readOnly>\n    <!-- anchor being used, due to <fieldset disabled> blocking a <button>'s click event -->\n    <a\n      *ngIf=\"!!item && !!item.value\"\n      class=\"single-icon-button\"\n      color=\"primary\"\n      mat-stroked-button\n      role=\"button\"\n      (click)=\"handleDownload(item.value)\"\n    >\n      <mat-icon color=\"primary\">file_download</mat-icon>\n      {{ (item!.value!.fileName ? item!.value!.fileName : '') | uppercase }}\n    </a>\n  </ng-template>\n</div>\n\n<!-- PROGRESS SPINNER -->\n<ng-template #loader>\n  <mat-spinner diameter=\"125\" strokeWidth=\"10\" mode=\"indeterminate\"></mat-spinner>\n</ng-template>\n", styles: [":host{display:block;margin:1rem 0}mtna-file-download{margin:37px 0}mat-spinner{margin:0 87.5px}\n"], components: [{ type: i1.MtnaFileDownloadComponent, selector: "mtna-file-download", inputs: ["color", "canDownload", "canRemove", "fileInfo", "loading"], outputs: ["download", "remove"] }, { type: i1.MtnaFileUploadComponent, selector: "mtna-file-upload", inputs: ["automaticUpload", "buttonText", "buttonColor", "disabled", "fileUploadUrl", "isProd", "maxUploadSize", "uploading"], outputs: ["uploaded", "fileToUpload", "uploadStatus"] }, { type: i2.MatAnchor, selector: "a[mat-button], a[mat-raised-button], a[mat-icon-button], a[mat-fab],             a[mat-mini-fab], a[mat-stroked-button], a[mat-flat-button]", inputs: ["disabled", "disableRipple", "color", "tabIndex"], exportAs: ["matButton", "matAnchor"] }, { type: i3.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { type: i4.MatSpinner, selector: "mat-spinner", inputs: ["color"] }], directives: [{ type: i5.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet"] }, { type: i6.MtnaHighlightDirective, selector: "[mtnaHighlight]", inputs: ["mtnaHighlight", "mtnaHighlightColor"], exportAs: ["mtnaHighlight"] }, { type: i5.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], pipes: { "uppercase": i5.UpperCasePipe } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MtnaWfFileUploadComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'mtna-wf-file-upload-item',
+                    templateUrl: './file-upload.component.html',
+                    styleUrls: ['./file-upload.component.scss'],
+                }]
+        }], ctorParameters: function () { return [{ type: i1.FileService }]; }, propDecorators: { header: [{
+                type: Input
+            }], indicatorStatus: [{
+                type: Input
+            }], item: [{
+                type: Input
+            }], readonly: [{
+                type: Input
+            }], file: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/file-upload/index.js

@@ -0,0 +1,2 @@
+export * from './file-upload.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy93ZWItZm9ybS1hbmd1bGFyL3NyYy9saWIvZmlsZS11cGxvYWQvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx5QkFBeUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZmlsZS11cGxvYWQuY29tcG9uZW50JztcbiJdfQ==

package/esm2015/lib/form/base-form-item.model.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFzZS1mb3JtLWl0ZW0ubW9kZWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy93ZWItZm9ybS1hbmd1bGFyL3NyYy9saWIvZm9ybS9iYXNlLWZvcm0taXRlbS5tb2RlbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQWJzdHJhY3RDb250cm9sIH0gZnJvbSAnQGFuZ3VsYXIvZm9ybXMnO1xuXG5pbXBvcnQgeyBGb3JtSXRlbSB9IGZyb20gJ0BtdG5hL3dlYi1mb3JtLXRzJztcblxuLyoqXG4gKiBUaGUgQmFzaWMgc2V0dXAgZm9yIGEgRm9ybUl0ZW0uIEFueSBkeW5hbWljIGNvbXBvbmVudHMgdG8gYmUgcmVuZGVyZWQgc2hvdWxkXG4gKiBpbXBsZW1lbnQgdGhpcyBpbnRlcmZhY2UgdG8gZW5zdXJlIHRoZXkgY29udGFpbiB0aGUgbmVjZXNzYXJ5IGlucHV0cy5cbiAqXG4gKiBAcHJvcCBjb250cm9sIC0gQWJzdHJhY3RDb250cm9sIHwgbnVsbCB8IHVuZGVmaW5lZDtcbiAqIEBwcm9wIGl0ZW0gLSBGb3JtSXRlbVxuICogQHByb3AgcmVhZG9ubHkgLSBib29sZWFuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgQmFzZUZvcm1JdGVtIHtcbiAgY29udHJvbDogQWJzdHJhY3RDb250cm9sIHwgbnVsbCB8IHVuZGVmaW5lZDtcbiAgaXRlbTogRm9ybUl0ZW07XG4gIHJlYWRvbmx5OiBib29sZWFuO1xufVxuIl19

package/esm2015/lib/form/form-disabler.component.js

@@ -0,0 +1,38 @@
+/* eslint-disable @angular-eslint/component-selector */
+import { Component, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+export class MtnaWfFormDisablerComponent {
+    constructor() {
+        this.formDisabled = false;
+    }
+}
+MtnaWfFormDisablerComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MtnaWfFormDisablerComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+MtnaWfFormDisablerComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: MtnaWfFormDisablerComponent, selector: "[formDisabled]", inputs: { formDisabled: "formDisabled" }, ngImport: i0, template: `
+    <fieldset [disabled]="formDisabled">
+      <ng-content></ng-content>
+    </fieldset>
+  `, isInline: true, styles: ["\n      fieldset {\n        display: block;\n        margin: unset;\n        padding: unset;\n        border: unset;\n      }\n    "] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MtnaWfFormDisablerComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: '[formDisabled]',
+                    template: `
+    <fieldset [disabled]="formDisabled">
+      <ng-content></ng-content>
+    </fieldset>
+  `,
+                    styles: [
+                        `
+      fieldset {
+        display: block;
+        margin: unset;
+        padding: unset;
+        border: unset;
+      }
+    `,
+                    ],
+                }]
+        }], propDecorators: { formDisabled: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9ybS1kaXNhYmxlci5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy93ZWItZm9ybS1hbmd1bGFyL3NyYy9saWIvZm9ybS9mb3JtLWRpc2FibGVyLmNvbXBvbmVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSx1REFBdUQ7QUFDdkQsT0FBTyxFQUFFLFNBQVMsRUFBRSxLQUFLLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBb0JqRCxNQUFNLE9BQU8sMkJBQTJCO0lBbEJ4QztRQW1CVyxpQkFBWSxHQUFHLEtBQUssQ0FBQztLQUMvQjs7eUhBRlksMkJBQTJCOzZHQUEzQiwyQkFBMkIsZ0dBaEI1Qjs7OztHQUlUOzRGQVlVLDJCQUEyQjtrQkFsQnZDLFNBQVM7bUJBQUM7b0JBQ1QsUUFBUSxFQUFFLGdCQUFnQjtvQkFDMUIsUUFBUSxFQUFFOzs7O0dBSVQ7b0JBQ0QsTUFBTSxFQUFFO3dCQUNOOzs7Ozs7O0tBT0M7cUJBQ0Y7aUJBQ0Y7OEJBRVUsWUFBWTtzQkFBcEIsS0FBSyIsInNvdXJjZXNDb250ZW50IjpbIi8qIGVzbGludC1kaXNhYmxlIEBhbmd1bGFyLWVzbGludC9jb21wb25lbnQtc2VsZWN0b3IgKi9cbmltcG9ydCB7IENvbXBvbmVudCwgSW5wdXQgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuQENvbXBvbmVudCh7XG4gIHNlbGVjdG9yOiAnW2Zvcm1EaXNhYmxlZF0nLFxuICB0ZW1wbGF0ZTogYFxuICAgIDxmaWVsZHNldCBbZGlzYWJsZWRdPVwiZm9ybURpc2FibGVkXCI+XG4gICAgICA8bmctY29udGVudD48L25nLWNvbnRlbnQ+XG4gICAgPC9maWVsZHNldD5cbiAgYCxcbiAgc3R5bGVzOiBbXG4gICAgYFxuICAgICAgZmllbGRzZXQge1xuICAgICAgICBkaXNwbGF5OiBibG9jaztcbiAgICAgICAgbWFyZ2luOiB1bnNldDtcbiAgICAgICAgcGFkZGluZzogdW5zZXQ7XG4gICAgICAgIGJvcmRlcjogdW5zZXQ7XG4gICAgICB9XG4gICAgYCxcbiAgXSxcbn0pXG5leHBvcnQgY2xhc3MgTXRuYVdmRm9ybURpc2FibGVyQ29tcG9uZW50IHtcbiAgQElucHV0KCkgZm9ybURpc2FibGVkID0gZmFsc2U7XG59XG4iXX0=

package/esm2015/lib/form/form-item.directive.js

@@ -0,0 +1,22 @@
+import { Directive } from '@angular/core';
+import * as i0 from "@angular/core";
+/* eslint-disable @angular-eslint/directive-selector */
+/**
+ * Used to retrieve the host container for a dynamically rendered component.
+ *
+ * @export
+ */
+export class MtnaWfFormItemDirective {
+    constructor(viewContainerRef) {
+        this.viewContainerRef = viewContainerRef;
+    }
+}
+MtnaWfFormItemDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MtnaWfFormItemDirective, deps: [{ token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Directive });
+MtnaWfFormItemDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.17", type: MtnaWfFormItemDirective, selector: "[formItemHost]", ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MtnaWfFormItemDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[formItemHost]',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ViewContainerRef }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9ybS1pdGVtLmRpcmVjdGl2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3dlYi1mb3JtLWFuZ3VsYXIvc3JjL2xpYi9mb3JtL2Zvcm0taXRlbS5kaXJlY3RpdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBb0IsTUFBTSxlQUFlLENBQUM7O0FBRTVELHVEQUF1RDtBQUN2RDs7OztHQUlHO0FBSUgsTUFBTSxPQUFPLHVCQUF1QjtJQUNsQyxZQUFtQixnQkFBa0M7UUFBbEMscUJBQWdCLEdBQWhCLGdCQUFnQixDQUFrQjtJQUFHLENBQUM7O3FIQUQ5Qyx1QkFBdUI7eUdBQXZCLHVCQUF1Qjs0RkFBdkIsdUJBQXVCO2tCQUhuQyxTQUFTO21CQUFDO29CQUNULFFBQVEsRUFBRSxnQkFBZ0I7aUJBQzNCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRGlyZWN0aXZlLCBWaWV3Q29udGFpbmVyUmVmIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbi8qIGVzbGludC1kaXNhYmxlIEBhbmd1bGFyLWVzbGludC9kaXJlY3RpdmUtc2VsZWN0b3IgKi9cbi8qKlxuICogVXNlZCB0byByZXRyaWV2ZSB0aGUgaG9zdCBjb250YWluZXIgZm9yIGEgZHluYW1pY2FsbHkgcmVuZGVyZWQgY29tcG9uZW50LlxuICpcbiAqIEBleHBvcnRcbiAqL1xuQERpcmVjdGl2ZSh7XG4gIHNlbGVjdG9yOiAnW2Zvcm1JdGVtSG9zdF0nLFxufSlcbmV4cG9ydCBjbGFzcyBNdG5hV2ZGb3JtSXRlbURpcmVjdGl2ZSB7XG4gIGNvbnN0cnVjdG9yKHB1YmxpYyB2aWV3Q29udGFpbmVyUmVmOiBWaWV3Q29udGFpbmVyUmVmKSB7fVxufVxuIl19

package/esm2015/lib/form/form.component.js

@@ -0,0 +1,250 @@
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output, ViewEncapsulation, } from '@angular/core';
+import { mixinDestroyNotifier } from '@mtna/core-angular';
+import { BehaviorSubject, Subscription } from 'rxjs';
+import { distinctUntilChanged, skipWhile, takeUntil } from 'rxjs/operators';
+import { findFormControl } from '../core/utilities/find-form-control';
+import * as i0 from "@angular/core";
+import * as i1 from "../core/services";
+import * as i2 from "./form-disabler.component";
+import * as i3 from "../groups/group-components";
+import * as i4 from "@angular/common";
+import * as i5 from "@angular/forms";
+export class MtnaWfFormComponent extends mixinDestroyNotifier(class {
+}) {
+    constructor(mtnaFormManager, ngFormService, uiService) {
+        super();
+        this.mtnaFormManager = mtnaFormManager;
+        this.ngFormService = ngFormService;
+        this.uiService = uiService;
+        this._emitStatusOnMtnaFormChange = false;
+        this.readonly$ = new BehaviorSubject(true);
+        /**
+         * Emitted every time a form control's validation status changes.
+         * The `id` is the form control's name and the `status` is the new validation status for the control.
+         */
+        this.status = new EventEmitter();
+        this.focusedSection = new EventEmitter();
+        this.mtnaFormChange = new EventEmitter();
+        this.componentIds = [];
+        this._hasPreviousForm = false;
+        this._initialStatusEmitted = false;
+        this._constructionDate = new Date();
+        // Initialize the subscription to observe input changes
+        this._subscribeAndEmitMtnaFormChanges();
+    }
+    set annotations(map) {
+        this.uiService.registerAnnotations(map);
+    }
+    /** Whether to emit the status of each step each time the {@link mtnaForm} is set to a new value. Defaults to false.*/
+    get emitStatusOnMtnaFormChange() {
+        return this._emitStatusOnMtnaFormChange;
+    }
+    set emitStatusOnMtnaFormChange(emitStatusOnMtnaFormChange) {
+        this._emitStatusOnMtnaFormChange = coerceBooleanProperty(emitStatusOnMtnaFormChange);
+    }
+    get mtnaForm() {
+        return this._mtnaForm;
+    }
+    set mtnaForm(form) {
+        if (!!form && !this.ngForm) {
+            // serialize the form when input is set the first time
+            this._handleFormSerialization(form);
+            this._checkAndSubscribeToFormStatus();
+        }
+        this._mtnaForm = form;
+        if (form) {
+            this.mtnaFormManager.setMtnaForm(form);
+            // If indicated, re-emit the status of each step when there is a new form
+            if (this.emitStatusOnMtnaFormChange && this.ngForm) {
+                for (const key in this._steps) {
+                    if (Object.prototype.hasOwnProperty.call(this._steps, key)) {
+                        this._emitFormControlStatus(key);
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * The form can contain sections not included in the steps.
+     * To avoid misalignment of steps-to-sections, we map each step to
+     * its instanceId
+     */
+    set steps(newSteps) {
+        if (!!newSteps && !!newSteps.length) {
+            if (!this._steps) {
+                this._steps = {};
+            }
+            for (const step of newSteps) {
+                this._steps[step.instanceId] = step;
+            }
+            this._checkAndSubscribeToFormStatus();
+        }
+    }
+    get readonly() {
+        return this.readonly$.value;
+    }
+    set readonly(r) {
+        const newValue = coerceBooleanProperty(r);
+        if (newValue !== this.readonly$.value) {
+            this.readonly$.next(r);
+        }
+    }
+    ngAfterViewInit() {
+        const afterViewInitDate = new Date();
+        const secondsToRender = (afterViewInitDate.getTime() - this._constructionDate.getTime()) / 1000;
+        console.warn('[MtnaFormComponent] afterViewInit - took ', secondsToRender, ' to render');
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+        this.uiService.resetComponentMap();
+    }
+    _trackByInstanceId(index, formItem) {
+        return formItem.instanceId;
+    }
+    /** Subscribe and emit form status changes for the steps. */
+    _checkAndSubscribeToFormStatus() {
+        // Only subscribe once both the steps and the angular have been initialized
+        if (this.ngForm && this._steps) {
+            // Update form status subscriptions anytime the readonly input changes
+            this.readonly$.pipe(takeUntil(this.destroyed$), distinctUntilChanged()).subscribe((readonly) => {
+                if (readonly) {
+                    // Don't emit statuses while form is in readonly
+                    this._unsubscribeFromNgFormChanges();
+                }
+                else if (!this._ngFormStatusChangeSub || this._ngFormStatusChangeSub.closed) {
+                    // For performance, subscribe should only trigger again if the subscription didn't previously exist
+                    this._emitInitialStepsStatusAndSubscribeToChanges(!this._initialStatusEmitted);
+                    this._initialStatusEmitted = true;
+                }
+            });
+        }
+    }
+    /**
+     * Find a form control with the given name, then emit it's status.
+     *
+     * @param name — The unique name of the form cotrol to find and emit the status for.
+     */
+    _emitFormControlStatus(name) {
+        if (this.ngForm) {
+            const control = findFormControl(name, this.ngForm);
+            if (control) {
+                this.status.emit({
+                    id: name,
+                    status: control.status,
+                });
+            }
+        }
+    }
+    /**
+     * @param emitInitialValues Whether to emit initial step values or just listen for future changes
+     */
+    _emitInitialStepsStatusAndSubscribeToChanges(emitInitialValues) {
+        if (this._steps && this.ngForm) {
+            this._unsubscribeFromNgFormChanges();
+            this._ngFormStatusChangeSub = new Subscription();
+            // Find the form control for each step and only subscribe to those.
+            for (const key in this._steps) {
+                if (Object.prototype.hasOwnProperty.call(this._steps, key)) {
+                    const control = findFormControl(key, this.ngForm);
+                    if (control) {
+                        if (emitInitialValues) {
+                            this.status.emit({
+                                id: key,
+                                // Angular introduced this status in v13, once we update, this type cast can be removed.
+                                status: control.status,
+                            });
+                        }
+                        // Subscribe to status changes of each step & emit on change
+                        this._ngFormStatusChangeSub.add(control.statusChanges
+                            .pipe(takeUntil(this.destroyed$), distinctUntilChanged())
+                            .subscribe((status) => this.status.emit({ id: key, status })));
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Observes input changes for readOnly, in order to handle internal change subscriptions.
+     * When the form is not readonly, we subscribe to form status & form item changes, so we can emit them.
+     * When the form is readonly, we do not want to emit any changes, so we unsubscribe.
+     */
+    _subscribeAndEmitMtnaFormChanges() {
+        this.readonly$
+            .pipe(takeUntil(this.destroyed$), 
+        // we don't want to create subscriptions until we have a form to subscribe to
+        skipWhile(() => !this.mtnaForm), distinctUntilChanged())
+            .subscribe((readonly) => {
+            if (readonly) {
+                this._unsubscribeFromMtnaFormChanges();
+            }
+            else if (!this._mtnaFormItemChangeSub || this._mtnaFormItemChangeSub.closed) {
+                // For performance, subscribe should only trigger again if one of the subscriptions didn't previously exist
+                this._subscribeToMtnaFormItemChanges();
+            }
+        });
+    }
+    _handleFormSerialization(form) {
+        // Get the registered form from the service if it exists
+        this._hasPreviousForm = this.ngFormService.hasForm();
+        if (this._hasPreviousForm) {
+            this.ngForm = this.ngFormService.getForm();
+            // FIXME this is necessary because the initial visiblity is based on the mtnaForm item's disable property
+            // If the user changes a value, goes to another tab (destroying form) and comes back, the initial values are incorrect
+            this.mtnaForm = this.mtnaFormManager.insertNewValues(form, this.ngFormService.getFormValue());
+        }
+        else {
+            this.ngForm = this.mtnaFormManager.serializeMtnaFormItem(form);
+            this.ngFormService.setForm(this.ngForm);
+        }
+    }
+    /**
+     * Adds or removes a FormItem whenever a new MtnaWfFormItemChange occurs,
+     * and emits a new MtnaForm.
+     */
+    _subscribeToMtnaFormItemChanges() {
+        this._unsubscribeFromMtnaFormChanges();
+        this._mtnaFormItemChangeSub = this.mtnaFormManager.formChanges
+            .pipe(takeUntil(this.destroyed$), skipWhile((change) => !change))
+            .subscribe((newForm) => this.mtnaFormChange.emit(newForm));
+    }
+    _unsubscribeFromNgFormChanges() {
+        if (!!this._ngFormStatusChangeSub && !this._ngFormStatusChangeSub.closed) {
+            this._ngFormStatusChangeSub.unsubscribe();
+        }
+    }
+    _unsubscribeFromMtnaFormChanges() {
+        if (!!this._mtnaFormItemChangeSub && !this._mtnaFormItemChangeSub.closed) {
+            this._mtnaFormItemChangeSub.unsubscribe();
+        }
+    }
+}
+MtnaWfFormComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MtnaWfFormComponent, deps: [{ token: i1.MtnaWfManagerService }, { token: i1.MtnaWfNgFormService }, { token: i1.MtnaWfUIService }], target: i0.ɵɵFactoryTarget.Component });
+MtnaWfFormComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: MtnaWfFormComponent, selector: "mtna-form", inputs: { annotations: "annotations", emitStatusOnMtnaFormChange: "emitStatusOnMtnaFormChange", mtnaForm: "mtnaForm", steps: "steps", readonly: "readonly" }, outputs: { status: "status", focusedSection: "focusedSection", mtnaFormChange: "mtnaFormChange" }, usesInheritance: true, ngImport: i0, template: "<form *ngIf=\"ngForm\" [formGroup]=\"ngForm\" [formDisabled]=\"readonly\">\n  <mtna-wf-item\n    *ngFor=\"let item of mtnaForm?.items; let index = index; trackBy: _trackByInstanceId\"\n    [item]=\"item\"\n    [control]=\"ngForm.controls[item.instanceId]\"\n    [readonly]=\"readonly\"\n    [parentIds]=\"componentIds\"\n    [step]=\"_steps?.[item.instanceId]\"\n    (focusedSection)=\"focusedSection.emit($event)\"\n  ></mtna-wf-item>\n</form>\n", styles: ["mtna-form form{display:block}mtna-form form .mtna-wf-section{display:block;margin:32px 0}mtna-form form fieldset[disabled] .mtna-wf-item .mtna-wf-date-item .mat-form-field.mat-form-field-appearance-outline .mat-form-field-flex:hover .mat-form-field-outline{opacity:0}mtna-form form fieldset[disabled] .mtna-wf-item .mtna-wf-date-item .mat-form-field.mat-form-field-appearance-outline .mat-form-field-flex:hover .mat-form-field-outline-thick{opacity:1}mtna-form form fieldset[disabled] .mtna-wf-item .mtna-wf-date-item .mat-form-field.mat-form-field-appearance-outline .mat-form-field-flex:hover .mat-form-field-outline-thick .mat-form-field-outline-end,mtna-form form fieldset[disabled] .mtna-wf-item .mtna-wf-date-item .mat-form-field.mat-form-field-appearance-outline .mat-form-field-flex:hover .mat-form-field-outline-thick .mat-form-field-outline-gap,mtna-form form fieldset[disabled] .mtna-wf-item .mtna-wf-date-item .mat-form-field.mat-form-field-appearance-outline .mat-form-field-flex:hover .mat-form-field-outline-thick .mat-form-field-outline-start{border-width:1px}mtna-form form fieldset[disabled] .mtna-wf-item .mtna-wf-date-item .mat-form-field.mat-form-field-appearance-outline .mat-form-field-suffix .mat-datepicker-toggle .mat-icon-button{cursor:default}mtna-form .mtna-wf-item,mtna-form .mtna-wf-title{margin-top:1rem}mtna-form .mtna-wf-text{margin:.5rem 0;font-size:.9rem}mtna-form .mtna-wf-title-item,mtna-form .mtna-wf-text-item{margin:0}mtna-form mtna-annotations-indicator+mtna-wf-value-item .mtna-wf-title-item,mtna-form mtna-annotations-indicator+mtna-wf-value-item .mtna-wf-text-item{padding-right:24px}\n"], components: [{ type: i2.MtnaWfFormDisablerComponent, selector: "[formDisabled]", inputs: ["formDisabled"] }, { type: i3.MtnaWfFormItemComponent, selector: "mtna-wf-item", inputs: ["item", "readonly", "control", "parentIds", "step"], outputs: ["focusedSection"] }], directives: [{ type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i5.ɵNgNoValidate, selector: "form:not([ngNoForm]):not([ngNativeValidate])" }, { type: i5.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { type: i5.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { type: i4.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MtnaWfFormComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'mtna-form',
+                    templateUrl: './form.component.html',
+                    styleUrls: ['./form.component.scss'],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    encapsulation: ViewEncapsulation.None,
+                }]
+        }], ctorParameters: function () { return [{ type: i1.MtnaWfManagerService }, { type: i1.MtnaWfNgFormService }, { type: i1.MtnaWfUIService }]; }, propDecorators: { annotations: [{
+                type: Input
+            }], emitStatusOnMtnaFormChange: [{
+                type: Input
+            }], mtnaForm: [{
+                type: Input
+            }], steps: [{
+                type: Input
+            }], readonly: [{
+                type: Input
+            }], status: [{
+                type: Output
+            }], focusedSection: [{
+                type: Output
+            }], mtnaFormChange: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"form.component.js","sourceRoot":"","sources":["../../../../../../projects/web-form-angular/src/lib/form/form.component.ts","../../../../../../projects/web-form-angular/src/lib/form/form.component.html"],"names":[],"mappings":"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","sourcesContent":["import { BooleanInput, coerceBooleanProperty } from '@angular/cdk/coercion';\nimport {\n  AfterViewInit,\n  ChangeDetectionStrategy,\n  Component,\n  EventEmitter,\n  Input,\n  OnDestroy,\n  Output,\n  ViewEncapsulation,\n} from '@angular/core';\nimport { FormGroup } from '@angular/forms';\n\nimport { CanDestroyNotify, mixinDestroyNotifier } from '@mtna/core-angular';\nimport { AnnotatableNumberMap } from '@mtna/pojo-social-angular';\nimport { Form, FormControlStatus, FormItem } from '@mtna/web-form-ts';\n\nimport { BehaviorSubject, Subscription } from 'rxjs';\nimport { distinctUntilChanged, skipWhile, takeUntil } from 'rxjs/operators';\n\nimport { findFormControl } from '../core/utilities/find-form-control';\nimport { MtnaWfManagerService, MtnaWfNgFormService, MtnaWfUIService } from '../core/services';\nimport { FormStep } from '../form-stepper/models/form-step.model';\n\n@Component({\n  selector: 'mtna-form',\n  templateUrl: './form.component.html',\n  styleUrls: ['./form.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  encapsulation: ViewEncapsulation.None,\n})\nexport class MtnaWfFormComponent extends mixinDestroyNotifier(class {}) implements AfterViewInit, CanDestroyNotify, OnDestroy {\n  static ngAcceptInputType_emitStatusOnMtnaFormChange: BooleanInput;\n  static ngAcceptInputTypes_readonly: BooleanInput;\n\n  @Input()\n  set annotations(map: AnnotatableNumberMap) {\n    this.uiService.registerAnnotations(map);\n  }\n\n  /** Whether to emit the status of each step each time the {@link mtnaForm} is set to a new value. Defaults to false.*/\n  @Input()\n  get emitStatusOnMtnaFormChange(): boolean {\n    return this._emitStatusOnMtnaFormChange;\n  }\n  set emitStatusOnMtnaFormChange(emitStatusOnMtnaFormChange: boolean) {\n    this._emitStatusOnMtnaFormChange = coerceBooleanProperty(emitStatusOnMtnaFormChange);\n  }\n  private _emitStatusOnMtnaFormChange = false;\n\n  @Input()\n  get mtnaForm(): Form | null | undefined {\n    return this._mtnaForm;\n  }\n  set mtnaForm(form: Form | null | undefined) {\n    if (!!form && !this.ngForm) {\n      // serialize the form when input is set the first time\n      this._handleFormSerialization(form);\n      this._checkAndSubscribeToFormStatus();\n    }\n    this._mtnaForm = form;\n    if (form) {\n      this.mtnaFormManager.setMtnaForm(form);\n\n      // If indicated, re-emit the status of each step when there is a new form\n      if (this.emitStatusOnMtnaFormChange && this.ngForm) {\n        for (const key in this._steps) {\n          if (Object.prototype.hasOwnProperty.call(this._steps, key)) {\n            this._emitFormControlStatus(key);\n          }\n        }\n      }\n    }\n  }\n  private _mtnaForm: Form | null | undefined;\n\n  /**\n   * The form can contain sections not included in the steps.\n   * To avoid misalignment of steps-to-sections, we map each step to\n   * its instanceId\n   */\n  @Input()\n  set steps(newSteps: Array<FormStep> | null | undefined) {\n    if (!!newSteps && !!newSteps.length) {\n      if (!this._steps) {\n        this._steps = {};\n      }\n      for (const step of newSteps) {\n        this._steps[step.instanceId] = step;\n      }\n      this._checkAndSubscribeToFormStatus();\n    }\n  }\n\n  @Input()\n  get readonly(): boolean {\n    return this.readonly$.value;\n  }\n  set readonly(r: boolean) {\n    const newValue = coerceBooleanProperty(r);\n    if (newValue !== this.readonly$.value) {\n      this.readonly$.next(r);\n    }\n  }\n  private readonly$ = new BehaviorSubject<boolean>(true);\n\n  /**\n   * Emitted every time a form control's validation status changes.\n   * The `id` is the form control's name and the `status` is the new validation status for the control.\n   */\n  @Output() status = new EventEmitter<{ id: string; status: FormControlStatus }>();\n  @Output() focusedSection = new EventEmitter<FormStep>();\n  @Output() mtnaFormChange = new EventEmitter<Form>();\n\n  ngForm: FormGroup | undefined;\n  componentIds = [];\n  _steps: { [id: string]: FormStep } | undefined;\n\n  private _constructionDate: Date;\n  private _hasPreviousForm = false;\n  private _ngFormStatusChangeSub?: Subscription;\n  private _mtnaFormItemChangeSub?: Subscription;\n  private _initialStatusEmitted = false;\n\n  constructor(\n    private mtnaFormManager: MtnaWfManagerService,\n    private ngFormService: MtnaWfNgFormService,\n    private uiService: MtnaWfUIService\n  ) {\n    super();\n    this._constructionDate = new Date();\n    // Initialize the subscription to observe input changes\n    this._subscribeAndEmitMtnaFormChanges();\n  }\n\n  ngAfterViewInit(): void {\n    const afterViewInitDate = new Date();\n    const secondsToRender = (afterViewInitDate.getTime() - this._constructionDate.getTime()) / 1000;\n    console.warn('[MtnaFormComponent] afterViewInit - took ', secondsToRender, ' to render');\n  }\n\n  ngOnDestroy() {\n    super.ngOnDestroy();\n    this.uiService.resetComponentMap();\n  }\n\n  _trackByInstanceId(index: number, formItem: FormItem) {\n    return formItem.instanceId;\n  }\n\n  /** Subscribe and emit form status changes for the steps. */\n  private _checkAndSubscribeToFormStatus() {\n    // Only subscribe once both the steps and the angular have been initialized\n    if (this.ngForm && this._steps) {\n      // Update form status subscriptions anytime the readonly input changes\n      this.readonly$.pipe(takeUntil(this.destroyed$), distinctUntilChanged()).subscribe((readonly) => {\n        if (readonly) {\n          // Don't emit statuses while form is in readonly\n          this._unsubscribeFromNgFormChanges();\n        } else if (!this._ngFormStatusChangeSub || this._ngFormStatusChangeSub.closed) {\n          // For performance, subscribe should only trigger again if the subscription didn't previously exist\n          this._emitInitialStepsStatusAndSubscribeToChanges(!this._initialStatusEmitted);\n          this._initialStatusEmitted = true;\n        }\n      });\n    }\n  }\n\n  /**\n   * Find a form control with the given name, then emit it's status.\n   *\n   * @param name — The unique name of the form cotrol to find and emit the status for.\n   */\n  private _emitFormControlStatus(name: string) {\n    if (this.ngForm) {\n      const control = findFormControl(name, this.ngForm);\n      if (control) {\n        this.status.emit({\n          id: name,\n          status: control.status as FormControlStatus,\n        });\n      }\n    }\n  }\n\n  /**\n   * @param emitInitialValues Whether to emit initial step values or just listen for future changes\n   */\n  private _emitInitialStepsStatusAndSubscribeToChanges(emitInitialValues: boolean) {\n    if (this._steps && this.ngForm) {\n      this._unsubscribeFromNgFormChanges();\n      this._ngFormStatusChangeSub = new Subscription();\n\n      // Find the form control for each step and only subscribe to those.\n      for (const key in this._steps) {\n        if (Object.prototype.hasOwnProperty.call(this._steps, key)) {\n          const control = findFormControl(key, this.ngForm);\n          if (control) {\n            if (emitInitialValues) {\n              this.status.emit({\n                id: key,\n                // Angular introduced this status in v13, once we update, this type cast can be removed.\n                status: control.status as FormControlStatus,\n              });\n            }\n            // Subscribe to status changes of each step & emit on change\n            this._ngFormStatusChangeSub.add(\n              control.statusChanges\n                .pipe(takeUntil(this.destroyed$), distinctUntilChanged())\n                .subscribe((status) => this.status.emit({ id: key, status }))\n            );\n          }\n        }\n      }\n    }\n  }\n\n  /**\n   * Observes input changes for readOnly, in order to handle internal change subscriptions.\n   * When the form is not readonly, we subscribe to form status & form item changes, so we can emit them.\n   * When the form is readonly, we do not want to emit any changes, so we unsubscribe.\n   */\n  private _subscribeAndEmitMtnaFormChanges() {\n    this.readonly$\n      .pipe(\n        takeUntil(this.destroyed$),\n        // we don't want to create subscriptions until we have a form to subscribe to\n        skipWhile(() => !this.mtnaForm),\n        distinctUntilChanged()\n      )\n      .subscribe((readonly) => {\n        if (readonly) {\n          this._unsubscribeFromMtnaFormChanges();\n        } else if (!this._mtnaFormItemChangeSub || this._mtnaFormItemChangeSub.closed) {\n          // For performance, subscribe should only trigger again if one of the subscriptions didn't previously exist\n          this._subscribeToMtnaFormItemChanges();\n        }\n      });\n  }\n\n  private _handleFormSerialization(form: Form) {\n    // Get the registered form from the service if it exists\n    this._hasPreviousForm = this.ngFormService.hasForm();\n    if (this._hasPreviousForm) {\n      this.ngForm = this.ngFormService.getForm();\n      // FIXME this is necessary because the initial visiblity is based on the mtnaForm item's disable property\n      // If the user changes a value, goes to another tab (destroying form) and comes back, the initial values are incorrect\n      this.mtnaForm = this.mtnaFormManager.insertNewValues(form, this.ngFormService.getFormValue());\n    } else {\n      this.ngForm = this.mtnaFormManager.serializeMtnaFormItem(form) as FormGroup;\n      this.ngFormService.setForm(this.ngForm);\n    }\n  }\n\n  /**\n   * Adds or removes a FormItem whenever a new MtnaWfFormItemChange occurs,\n   * and emits a new MtnaForm.\n   */\n  private _subscribeToMtnaFormItemChanges() {\n    this._unsubscribeFromMtnaFormChanges();\n    this._mtnaFormItemChangeSub = this.mtnaFormManager.formChanges\n      .pipe(\n        takeUntil(this.destroyed$),\n        skipWhile((change) => !change)\n      )\n      .subscribe((newForm: Form) => this.mtnaFormChange.emit(newForm));\n  }\n\n  private _unsubscribeFromNgFormChanges() {\n    if (!!this._ngFormStatusChangeSub && !this._ngFormStatusChangeSub.closed) {\n      this._ngFormStatusChangeSub.unsubscribe();\n    }\n  }\n\n  private _unsubscribeFromMtnaFormChanges() {\n    if (!!this._mtnaFormItemChangeSub && !this._mtnaFormItemChangeSub.closed) {\n      this._mtnaFormItemChangeSub.unsubscribe();\n    }\n  }\n}\n","<form *ngIf=\"ngForm\" [formGroup]=\"ngForm\" [formDisabled]=\"readonly\">\n  <mtna-wf-item\n    *ngFor=\"let item of mtnaForm?.items; let index = index; trackBy: _trackByInstanceId\"\n    [item]=\"item\"\n    [control]=\"ngForm.controls[item.instanceId]\"\n    [readonly]=\"readonly\"\n    [parentIds]=\"componentIds\"\n    [step]=\"_steps?.[item.instanceId]\"\n    (focusedSection)=\"focusedSection.emit($event)\"\n  ></mtna-wf-item>\n</form>\n"]}