@mtna/web-form-angular 1.0.1 → 1.0.2-SNAPSHOT.1

package/esm2015/lib/components/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 '../../utilities';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services";
+import * as i2 from "../form-disabler/form-disabler.component";
+import * as i3 from "../form-item/form-item.component";
+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: ["color", "control", "header", "inList", "item", "parentIds", "readonly", "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/components/form/form.component.ts","../../../../../../../projects/web-form-angular/src/lib/components/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';\nimport { CanDestroyNotify, mixinDestroyNotifier } from '@mtna/core-angular';\nimport { AnnotatableNumberMap } from '@mtna/pojo-social-angular';\nimport { Form, FormControlStatus, FormItem } from '@mtna/web-form-ts';\nimport { BehaviorSubject, Subscription } from 'rxjs';\nimport { distinctUntilChanged, skipWhile, takeUntil } from 'rxjs/operators';\n\nimport { FormStep } from '../../models';\nimport { MtnaWfManagerService, MtnaWfNgFormService, MtnaWfUIService } from '../../services';\nimport { findFormControl } from '../../utilities';\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"]}

package/esm2015/lib/components/form/form.module.js

@@ -0,0 +1,60 @@
+import { A11yModule } from '@angular/cdk/a11y';
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { FlexLayoutModule } from '@angular/flex-layout';
+import { FormsModule, ReactiveFormsModule } from '@angular/forms';
+import { MatMomentDateModule } from '@angular/material-moment-adapter';
+import { ErrorStateMatcher } from '@angular/material/core';
+import { MtnaWfInstantValidationResultErrorStateMatcher } from '../../validators/instant-validation-result-error-state-matcher';
+import { MtnaWfFormDisablerModule } from '../form-disabler/form-disabler.module';
+import { MtnaWfFormItemModule } from '../form-item/form-item.module';
+import { MtnaWfFormStepperModule } from '../form-stepper/form-stepper.module';
+import { MtnaWfStepCardModule } from '../step-card/step-card.module';
+import { MtnaWfFormComponent } from './form.component';
+import * as i0 from "@angular/core";
+export class MtnaFormModule {
+}
+MtnaFormModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MtnaFormModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+MtnaFormModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MtnaFormModule, declarations: [MtnaWfFormComponent], imports: [A11yModule,
+        CommonModule,
+        FlexLayoutModule,
+        FormsModule,
+        MtnaWfFormItemModule,
+        ReactiveFormsModule,
+        MtnaWfFormDisablerModule,
+        MatMomentDateModule,
+        MtnaWfFormStepperModule,
+        MtnaWfStepCardModule], exports: [MtnaWfFormComponent] });
+MtnaFormModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MtnaFormModule, providers: [{ provide: ErrorStateMatcher, useClass: MtnaWfInstantValidationResultErrorStateMatcher }], imports: [[
+            A11yModule,
+            CommonModule,
+            FlexLayoutModule,
+            FormsModule,
+            MtnaWfFormItemModule,
+            ReactiveFormsModule,
+            MtnaWfFormDisablerModule,
+            MatMomentDateModule,
+            MtnaWfFormStepperModule,
+            MtnaWfStepCardModule,
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MtnaFormModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        A11yModule,
+                        CommonModule,
+                        FlexLayoutModule,
+                        FormsModule,
+                        MtnaWfFormItemModule,
+                        ReactiveFormsModule,
+                        MtnaWfFormDisablerModule,
+                        MatMomentDateModule,
+                        MtnaWfFormStepperModule,
+                        MtnaWfStepCardModule,
+                    ],
+                    declarations: [MtnaWfFormComponent],
+                    exports: [MtnaWfFormComponent],
+                    providers: [{ provide: ErrorStateMatcher, useClass: MtnaWfInstantValidationResultErrorStateMatcher }],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/form/index.js

@@ -0,0 +1,3 @@
+export * from './form.component';
+export * from './form.module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy93ZWItZm9ybS1hbmd1bGFyL3NyYy9saWIvY29tcG9uZW50cy9mb3JtL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyxlQUFlLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2Zvcm0uY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vZm9ybS5tb2R1bGUnO1xuIl19

package/esm2015/lib/{form → components/form-disabler}/form-disabler.component.js

@@ -35,4 +35,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImpo
         }], propDecorators: { formDisabled: [{
                 type: Input
             }] } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9ybS1kaXNhYmxlci5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy93ZWItZm9ybS1hbmd1bGFyL3NyYy9saWIvZm9ybS9mb3JtLWRpc2FibGVyLmNvbXBvbmVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSx1REFBdUQ7QUFDdkQsT0FBTyxFQUFFLFNBQVMsRUFBRSxLQUFLLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBb0JqRCxNQUFNLE9BQU8sMkJBQTJCO0lBbEJ4QztRQW1CVyxpQkFBWSxHQUFHLEtBQUssQ0FBQztLQUMvQjs7eUhBRlksMkJBQTJCOzZHQUEzQiwyQkFBMkIsZ0dBaEI1Qjs7OztHQUlUOzRGQVlVLDJCQUEyQjtrQkFsQnZDLFNBQVM7bUJBQUM7b0JBQ1QsUUFBUSxFQUFFLGdCQUFnQjtvQkFDMUIsUUFBUSxFQUFFOzs7O0dBSVQ7b0JBQ0QsTUFBTSxFQUFFO3dCQUNOOzs7Ozs7O0tBT0M7cUJBQ0Y7aUJBQ0Y7OEJBRVUsWUFBWTtzQkFBcEIsS0FBSyIsInNvdXJjZXNDb250ZW50IjpbIi8qIGVzbGludC1kaXNhYmxlIEBhbmd1bGFyLWVzbGludC9jb21wb25lbnQtc2VsZWN0b3IgKi9cbmltcG9ydCB7IENvbXBvbmVudCwgSW5wdXQgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuQENvbXBvbmVudCh7XG4gIHNlbGVjdG9yOiAnW2Zvcm1EaXNhYmxlZF0nLFxuICB0ZW1wbGF0ZTogYFxuICAgIDxmaWVsZHNldCBbZGlzYWJsZWRdPVwiZm9ybURpc2FibGVkXCI+XG4gICAgICA8bmctY29udGVudD48L25nLWNvbnRlbnQ+XG4gICAgPC9maWVsZHNldD5cbiAgYCxcbiAgc3R5bGVzOiBbXG4gICAgYFxuICAgICAgZmllbGRzZXQge1xuICAgICAgICBkaXNwbGF5OiBibG9jaztcbiAgICAgICAgbWFyZ2luOiB1bnNldDtcbiAgICAgICAgcGFkZGluZzogdW5zZXQ7XG4gICAgICAgIGJvcmRlcjogdW5zZXQ7XG4gICAgICB9XG4gICAgYCxcbiAgXSxcbn0pXG5leHBvcnQgY2xhc3MgTXRuYVdmRm9ybURpc2FibGVyQ29tcG9uZW50IHtcbiAgQElucHV0KCkgZm9ybURpc2FibGVkID0gZmFsc2U7XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9ybS1kaXNhYmxlci5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy93ZWItZm9ybS1hbmd1bGFyL3NyYy9saWIvY29tcG9uZW50cy9mb3JtLWRpc2FibGVyL2Zvcm0tZGlzYWJsZXIuY29tcG9uZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLHVEQUF1RDtBQUN2RCxPQUFPLEVBQUUsU0FBUyxFQUFFLEtBQUssRUFBRSxNQUFNLGVBQWUsQ0FBQzs7QUFvQmpELE1BQU0sT0FBTywyQkFBMkI7SUFsQnhDO1FBbUJXLGlCQUFZLEdBQUcsS0FBSyxDQUFDO0tBQy9COzt5SEFGWSwyQkFBMkI7NkdBQTNCLDJCQUEyQixnR0FoQjVCOzs7O0dBSVQ7NEZBWVUsMkJBQTJCO2tCQWxCdkMsU0FBUzttQkFBQztvQkFDVCxRQUFRLEVBQUUsZ0JBQWdCO29CQUMxQixRQUFRLEVBQUU7Ozs7R0FJVDtvQkFDRCxNQUFNLEVBQUU7d0JBQ047Ozs7Ozs7S0FPQztxQkFDRjtpQkFDRjs4QkFFVSxZQUFZO3NCQUFwQixLQUFLIiwic291cmNlc0NvbnRlbnQiOlsiLyogZXNsaW50LWRpc2FibGUgQGFuZ3VsYXItZXNsaW50L2NvbXBvbmVudC1zZWxlY3RvciAqL1xuaW1wb3J0IHsgQ29tcG9uZW50LCBJbnB1dCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5AQ29tcG9uZW50KHtcbiAgc2VsZWN0b3I6ICdbZm9ybURpc2FibGVkXScsXG4gIHRlbXBsYXRlOiBgXG4gICAgPGZpZWxkc2V0IFtkaXNhYmxlZF09XCJmb3JtRGlzYWJsZWRcIj5cbiAgICAgIDxuZy1jb250ZW50PjwvbmctY29udGVudD5cbiAgICA8L2ZpZWxkc2V0PlxuICBgLFxuICBzdHlsZXM6IFtcbiAgICBgXG4gICAgICBmaWVsZHNldCB7XG4gICAgICAgIGRpc3BsYXk6IGJsb2NrO1xuICAgICAgICBtYXJnaW46IHVuc2V0O1xuICAgICAgICBwYWRkaW5nOiB1bnNldDtcbiAgICAgICAgYm9yZGVyOiB1bnNldDtcbiAgICAgIH1cbiAgICBgLFxuICBdLFxufSlcbmV4cG9ydCBjbGFzcyBNdG5hV2ZGb3JtRGlzYWJsZXJDb21wb25lbnQge1xuICBASW5wdXQoKSBmb3JtRGlzYWJsZWQgPSBmYWxzZTtcbn1cbiJdfQ==

package/esm2015/lib/components/form-disabler/form-disabler.module.js

@@ -0,0 +1,18 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { MtnaWfFormDisablerComponent } from './form-disabler.component';
+import * as i0 from "@angular/core";
+export class MtnaWfFormDisablerModule {
+}
+MtnaWfFormDisablerModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MtnaWfFormDisablerModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+MtnaWfFormDisablerModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MtnaWfFormDisablerModule, declarations: [MtnaWfFormDisablerComponent], imports: [CommonModule], exports: [MtnaWfFormDisablerComponent] });
+MtnaWfFormDisablerModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MtnaWfFormDisablerModule, imports: [[CommonModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MtnaWfFormDisablerModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule],
+                    exports: [MtnaWfFormDisablerComponent],
+                    declarations: [MtnaWfFormDisablerComponent],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9ybS1kaXNhYmxlci5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy93ZWItZm9ybS1hbmd1bGFyL3NyYy9saWIvY29tcG9uZW50cy9mb3JtLWRpc2FibGVyL2Zvcm0tZGlzYWJsZXIubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUMvQyxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRXpDLE9BQU8sRUFBRSwyQkFBMkIsRUFBRSxNQUFNLDJCQUEyQixDQUFDOztBQU94RSxNQUFNLE9BQU8sd0JBQXdCOztzSEFBeEIsd0JBQXdCO3VIQUF4Qix3QkFBd0IsaUJBRnBCLDJCQUEyQixhQUZoQyxZQUFZLGFBQ1osMkJBQTJCO3VIQUcxQix3QkFBd0IsWUFKMUIsQ0FBQyxZQUFZLENBQUM7NEZBSVosd0JBQXdCO2tCQUxwQyxRQUFRO21CQUFDO29CQUNSLE9BQU8sRUFBRSxDQUFDLFlBQVksQ0FBQztvQkFDdkIsT0FBTyxFQUFFLENBQUMsMkJBQTJCLENBQUM7b0JBQ3RDLFlBQVksRUFBRSxDQUFDLDJCQUEyQixDQUFDO2lCQUM1QyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbW1vbk1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XG5pbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5pbXBvcnQgeyBNdG5hV2ZGb3JtRGlzYWJsZXJDb21wb25lbnQgfSBmcm9tICcuL2Zvcm0tZGlzYWJsZXIuY29tcG9uZW50JztcblxuQE5nTW9kdWxlKHtcbiAgaW1wb3J0czogW0NvbW1vbk1vZHVsZV0sXG4gIGV4cG9ydHM6IFtNdG5hV2ZGb3JtRGlzYWJsZXJDb21wb25lbnRdLFxuICBkZWNsYXJhdGlvbnM6IFtNdG5hV2ZGb3JtRGlzYWJsZXJDb21wb25lbnRdLFxufSlcbmV4cG9ydCBjbGFzcyBNdG5hV2ZGb3JtRGlzYWJsZXJNb2R1bGUge31cbiJdfQ==

package/esm2015/lib/components/form-disabler/index.js

@@ -0,0 +1,3 @@
+export * from './form-disabler.component';
+export * from './form-disabler.module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy93ZWItZm9ybS1hbmd1bGFyL3NyYy9saWIvY29tcG9uZW50cy9mb3JtLWRpc2FibGVyL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyx3QkFBd0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZm9ybS1kaXNhYmxlci5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9mb3JtLWRpc2FibGVyLm1vZHVsZSc7XG4iXX0=

package/esm2015/lib/components/form-item/form-item.component.js

@@ -0,0 +1,124 @@
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { ChangeDetectionStrategy, Component, EventEmitter, HostBinding, Input, Output, ViewEncapsulation, } from '@angular/core';
+import { isConditionalItem } from '@mtna/web-form-ts';
+import { getItemClassSuffix, MTNA_WF_EXPAND_COLLAPSE } from '../../utilities';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/ui.service";
+import * as i2 from "@mtna/pojo-social-angular";
+import * as i3 from "../form-item-injector/form-item-injector.component";
+import * as i4 from "../item-header/item-header.component";
+import * as i5 from "@angular/common";
+/**
+ * Component that wraps an MtnaForm item.
+ *
+ * ChangeDetectionStrategy.OnPush was not working as of 9/19/2018.
+ * Dynamic components in the ValueItemComponent were not being initialized (ngOnInit was never called).
+ *
+ * @export
+ */
+export class MtnaWfFormItemComponent {
+    constructor(_elementRef, uiService) {
+        this._elementRef = _elementRef;
+        this.uiService = uiService;
+        this.visible = true;
+        this._header = null;
+        this._inList = false;
+        this._parentIds = new Array();
+        this._readonly = false;
+        this.focusedSection = new EventEmitter();
+        this.indicatorStatus = 'INACTIVE';
+    }
+    get elementId() {
+        return this.item ? this.item.instanceId : '';
+    }
+    get control() {
+        return this._control;
+    }
+    set control(control) {
+        this._control = control;
+    }
+    get header() {
+        return this._header;
+    }
+    set header(value) {
+        this._header = value;
+    }
+    get inList() {
+        return this._inList;
+    }
+    set inList(value) {
+        this._inList = coerceBooleanProperty(value);
+    }
+    get item() {
+        return this._item;
+    }
+    set item(value) {
+        this._item = value;
+    }
+    get parentIds() {
+        return this._parentIds;
+    }
+    set parentIds(value) {
+        this._parentIds = value;
+    }
+    get readonly() {
+        return this._readonly;
+    }
+    set readonly(value) {
+        this._readonly = coerceBooleanProperty(value);
+    }
+    get step() {
+        return this._step;
+    }
+    set step(value) {
+        this._step = value;
+    }
+    ngOnInit() {
+        if (isConditionalItem(this.item)) {
+            this.visible = !this.item.hideOnDisable || !this.item.disabled;
+        }
+        this.uiService.registerSelf(this);
+        this._elementRef.nativeElement.classList.add(`mtna-wf-${getItemClassSuffix(this.item.itemId)}`);
+    }
+    toggleFormItems(data) {
+        this.uiService.toggleFormItems(data.enabledItemIds, data.disabledItemIds, data.enabled, data.callerId, data.reset);
+    }
+}
+MtnaWfFormItemComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MtnaWfFormItemComponent, deps: [{ token: i0.ElementRef }, { token: i1.MtnaWfUIService }], target: i0.ɵɵFactoryTarget.Component });
+MtnaWfFormItemComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: MtnaWfFormItemComponent, selector: "mtna-wf-item", inputs: { color: "color", control: "control", header: "header", inList: "inList", item: "item", parentIds: "parentIds", readonly: "readonly", step: "step" }, outputs: { focusedSection: "focusedSection" }, host: { properties: { "@mtnaWfExpandCollapse": "this.visible", "attr.id": "this.elementId" } }, ngImport: i0, template: "<mtna-annotations-indicator\n  *ngIf=\"item.annotationEnabled\"\n  [annotatableId]=\"item.annotatableId\"\n  color=\"primary\"\n  [count]=\"annotations$ | async\"\n  (status)=\"indicatorStatus = $event\"\n></mtna-annotations-indicator>\n\n<mtna-wf-item-injector\n  [color]=\"color\"\n  [control]=\"control\"\n  [header]=\"header\"\n  [indicatorStatus]=\"indicatorStatus\"\n  [inList]=\"inList\"\n  [item]=\"item\"\n  [parentIds]=\"parentIds\"\n  [readonly]=\"readonly\"\n  [step]=\"step\"\n  (focusedSection)=\"focusedSection.emit($event)\"\n  (toggleFormItems)=\"toggleFormItems($event)\"\n></mtna-wf-item-injector>\n\n<ng-template #header let-hideRequiredMarker=\"hideRequiredMarker\">\n  <mtna-wf-item-header\n    *ngIf=\"!!item.questionText || !!item.descriptiveText\"\n    [descriptiveText]=\"item.descriptiveText\"\n    [disabled]=\"control?.disabled\"\n    [hideRequiredMarker]=\"hideRequiredMarker\"\n    [invalid]=\"control?.invalid && (control?.dirty || control?.touched)\"\n    [questionText]=\"item.questionText\"\n    [required]=\"item.required\"\n  ></mtna-wf-item-header>\n</ng-template>\n\n<!-- <ng-container [ngSwitch]=\"item.itemId | mtnaWfGetObjectType\">\n  <mtna-wf-section\n    *ngSwitchCase=\"'sectionimpl'\"\n    [control]=\"$any(control)\"\n    [item]=\"$any(item)\"\n    [mtnaHighlight]=\"indicatorStatus === 'ACTIVE'\"\n    [parentIds]=\"parentIds.concat(item.instanceId)\"\n    [readonly]=\"readonly\"\n    [step]=\"step\"\n    (focused)=\"focusedSection.emit($event)\"\n  ></mtna-wf-section>\n\n  <mtna-wf-group\n    *ngSwitchCase=\"'formitemgroupimpl'\"\n    [indicatorStatus]=\"indicatorStatus\"\n    [item]=\"$any(item)\"\n    [control]=\"$any(control)\"\n    [mtnaHighlight]=\"indicatorStatus === 'ACTIVE' && (!!item.descriptiveText || !!item.questionText)\"\n    [parentIds]=\"parentIds.concat(item.instanceId)\"\n    [readonly]=\"readonly\"\n  ></mtna-wf-group>\n\n  <mtna-wf-repeatable-item-container\n    *ngSwitchCase=\"'repeatableitem'\"\n    [indicatorStatus]=\"indicatorStatus\"\n    [item]=\"$any(item)\"\n    [control]=\"$any(control)\"\n    [mtnaHighlight]=\"indicatorStatus === 'ACTIVE' && (!!item.descriptiveText || !!item.questionText)\"\n    [parentIds]=\"parentIds.concat(item.instanceId)\"\n    [readonly]=\"readonly\"\n  ></mtna-wf-repeatable-item-container>\n\n  <mtna-wf-value-item\n    *ngSwitchDefault\n    [indicatorStatus]=\"indicatorStatus\"\n    [item]=\"$any(item)\"\n    [control]=\"control\"\n    [mtnaHighlight]=\"indicatorStatus === 'ACTIVE' && (!!item.descriptiveText || !!item.questionText)\"\n    [parentIds]=\"parentIds.concat(item.instanceId)\"\n    [readonly]=\"readonly\"\n  ></mtna-wf-value-item>\n</ng-container> -->\n", styles: ["mtna-wf-item{display:block;position:relative}mtna-wf-item mtna-annotations-indicator{position:absolute;top:0;right:0;z-index:2}\n"], components: [{ type: i2.MtnaAnnotationsIndicatorComponent, selector: "mtna-annotations-indicator", inputs: ["color", "annotatableId", "annotatableItemName", "count"], outputs: ["status"] }, { type: i3.MtnaWfItemInjector, selector: "mtna-wf-item-injector", inputs: ["color", "control", "header", "indicatorStatus", "inList", "item", "parentIds", "readonly", "step"], outputs: ["focusedSection", "toggleFormItems"] }, { type: i4.MtnaWfItemHeaderComponent, selector: "mtna-wf-item-header", inputs: ["descriptiveText", "disabled", "hideRequiredMarker", "invalid", "questionText", "required"] }], directives: [{ type: i5.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], pipes: { "async": i5.AsyncPipe }, animations: [MTNA_WF_EXPAND_COLLAPSE], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MtnaWfFormItemComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'mtna-wf-item',
+                    templateUrl: './form-item.component.html',
+                    styleUrls: ['./form-item.component.scss'],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    encapsulation: ViewEncapsulation.None,
+                    animations: [MTNA_WF_EXPAND_COLLAPSE],
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.MtnaWfUIService }]; }, propDecorators: { visible: [{
+                type: HostBinding,
+                args: ['@mtnaWfExpandCollapse']
+            }], elementId: [{
+                type: HostBinding,
+                args: ['attr.id']
+            }], color: [{
+                type: Input
+            }], control: [{
+                type: Input
+            }], header: [{
+                type: Input
+            }], inList: [{
+                type: Input
+            }], item: [{
+                type: Input
+            }], parentIds: [{
+                type: Input
+            }], readonly: [{
+                type: Input
+            }], step: [{
+                type: Input
+            }], focusedSection: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"form-item.component.js","sourceRoot":"","sources":["../../../../../../../projects/web-form-angular/src/lib/components/form-item/form-item.component.ts","../../../../../../../projects/web-form-angular/src/lib/components/form-item/form-item.component.html"],"names":[],"mappings":"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","sourcesContent":["import { coerceBooleanProperty } from '@angular/cdk/coercion';\nimport {\n  ChangeDetectionStrategy,\n  Component,\n  ElementRef,\n  EventEmitter,\n  HostBinding,\n  Input,\n  OnInit,\n  Output,\n  TemplateRef,\n  ViewEncapsulation,\n} from '@angular/core';\nimport { AbstractControl } from '@angular/forms';\nimport { ThemePalette } from '@angular/material/core';\nimport { AnnotationIndicatorStatus } from '@mtna/pojo-social-angular';\nimport { FormItem, isConditionalItem } from '@mtna/web-form-ts';\nimport { Observable } from 'rxjs';\n\nimport { FormStep, ToggleFormItemsData } from '../../models';\nimport { MtnaWfUIService } from '../../services/ui.service';\nimport { getItemClassSuffix, MTNA_WF_EXPAND_COLLAPSE } from '../../utilities';\n\n/**\n * Component that wraps an MtnaForm item.\n *\n * ChangeDetectionStrategy.OnPush was not working as of 9/19/2018.\n * Dynamic components in the ValueItemComponent were not being initialized (ngOnInit was never called).\n *\n * @export\n */\n@Component({\n  selector: 'mtna-wf-item',\n  templateUrl: './form-item.component.html',\n  styleUrls: ['./form-item.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  encapsulation: ViewEncapsulation.None,\n  animations: [MTNA_WF_EXPAND_COLLAPSE],\n})\nexport class MtnaWfFormItemComponent implements OnInit {\n  @HostBinding('@mtnaWfExpandCollapse') visible = true;\n\n  @HostBinding('attr.id')\n  get elementId(): string {\n    return this.item ? this.item.instanceId : '';\n  }\n\n  @Input() color: ThemePalette;\n\n  @Input()\n  get control(): AbstractControl | null | undefined {\n    return this._control;\n  }\n  set control(control: AbstractControl | null | undefined) {\n    this._control = control;\n  }\n  protected _control: AbstractControl | null | undefined;\n\n  @Input()\n  get header(): TemplateRef<unknown> | null {\n    return this._header;\n  }\n  set header(value: TemplateRef<unknown> | null) {\n    this._header = value;\n  }\n  private _header: TemplateRef<unknown> | null = null;\n\n  @Input()\n  get inList(): boolean {\n    return this._inList;\n  }\n  set inList(value: boolean) {\n    this._inList = coerceBooleanProperty(value);\n  }\n  private _inList = false;\n\n  @Input()\n  get item(): FormItem {\n    return this._item;\n  }\n  set item(value: FormItem) {\n    this._item = value;\n  }\n  protected _item!: FormItem;\n\n  @Input()\n  get parentIds(): Array<string> {\n    return this._parentIds;\n  }\n  set parentIds(value: Array<string>) {\n    this._parentIds = value;\n  }\n  private _parentIds = new Array<string>();\n\n  @Input()\n  get readonly(): boolean {\n    return this._readonly;\n  }\n  set readonly(value: boolean) {\n    this._readonly = coerceBooleanProperty(value);\n  }\n  protected _readonly = false;\n\n  @Input()\n  get step(): FormStep | null | undefined {\n    return this._step;\n  }\n  set step(value: FormStep | null | undefined) {\n    this._step = value;\n  }\n  private _step: FormStep | null | undefined;\n\n  @Output() focusedSection = new EventEmitter<FormStep>();\n\n  annotations$?: Observable<number | null>;\n  indicatorStatus: AnnotationIndicatorStatus = 'INACTIVE';\n\n  constructor(private _elementRef: ElementRef, private uiService: MtnaWfUIService) {}\n\n  ngOnInit() {\n    if (isConditionalItem(this.item)) {\n      this.visible = !this.item.hideOnDisable || !this.item.disabled;\n    }\n    this.uiService.registerSelf(this);\n\n    this._elementRef.nativeElement.classList.add(`mtna-wf-${getItemClassSuffix(this.item.itemId)}`);\n  }\n\n  toggleFormItems(data: ToggleFormItemsData) {\n    this.uiService.toggleFormItems(data.enabledItemIds, data.disabledItemIds, data.enabled, data.callerId, data.reset);\n  }\n}\n","<mtna-annotations-indicator\n  *ngIf=\"item.annotationEnabled\"\n  [annotatableId]=\"item.annotatableId\"\n  color=\"primary\"\n  [count]=\"annotations$ | async\"\n  (status)=\"indicatorStatus = $event\"\n></mtna-annotations-indicator>\n\n<mtna-wf-item-injector\n  [color]=\"color\"\n  [control]=\"control\"\n  [header]=\"header\"\n  [indicatorStatus]=\"indicatorStatus\"\n  [inList]=\"inList\"\n  [item]=\"item\"\n  [parentIds]=\"parentIds\"\n  [readonly]=\"readonly\"\n  [step]=\"step\"\n  (focusedSection)=\"focusedSection.emit($event)\"\n  (toggleFormItems)=\"toggleFormItems($event)\"\n></mtna-wf-item-injector>\n\n<ng-template #header let-hideRequiredMarker=\"hideRequiredMarker\">\n  <mtna-wf-item-header\n    *ngIf=\"!!item.questionText || !!item.descriptiveText\"\n    [descriptiveText]=\"item.descriptiveText\"\n    [disabled]=\"control?.disabled\"\n    [hideRequiredMarker]=\"hideRequiredMarker\"\n    [invalid]=\"control?.invalid && (control?.dirty || control?.touched)\"\n    [questionText]=\"item.questionText\"\n    [required]=\"item.required\"\n  ></mtna-wf-item-header>\n</ng-template>\n\n<!-- <ng-container [ngSwitch]=\"item.itemId | mtnaWfGetObjectType\">\n  <mtna-wf-section\n    *ngSwitchCase=\"'sectionimpl'\"\n    [control]=\"$any(control)\"\n    [item]=\"$any(item)\"\n    [mtnaHighlight]=\"indicatorStatus === 'ACTIVE'\"\n    [parentIds]=\"parentIds.concat(item.instanceId)\"\n    [readonly]=\"readonly\"\n    [step]=\"step\"\n    (focused)=\"focusedSection.emit($event)\"\n  ></mtna-wf-section>\n\n  <mtna-wf-group\n    *ngSwitchCase=\"'formitemgroupimpl'\"\n    [indicatorStatus]=\"indicatorStatus\"\n    [item]=\"$any(item)\"\n    [control]=\"$any(control)\"\n    [mtnaHighlight]=\"indicatorStatus === 'ACTIVE' && (!!item.descriptiveText || !!item.questionText)\"\n    [parentIds]=\"parentIds.concat(item.instanceId)\"\n    [readonly]=\"readonly\"\n  ></mtna-wf-group>\n\n  <mtna-wf-repeatable-item-container\n    *ngSwitchCase=\"'repeatableitem'\"\n    [indicatorStatus]=\"indicatorStatus\"\n    [item]=\"$any(item)\"\n    [control]=\"$any(control)\"\n    [mtnaHighlight]=\"indicatorStatus === 'ACTIVE' && (!!item.descriptiveText || !!item.questionText)\"\n    [parentIds]=\"parentIds.concat(item.instanceId)\"\n    [readonly]=\"readonly\"\n  ></mtna-wf-repeatable-item-container>\n\n  <mtna-wf-value-item\n    *ngSwitchDefault\n    [indicatorStatus]=\"indicatorStatus\"\n    [item]=\"$any(item)\"\n    [control]=\"control\"\n    [mtnaHighlight]=\"indicatorStatus === 'ACTIVE' && (!!item.descriptiveText || !!item.questionText)\"\n    [parentIds]=\"parentIds.concat(item.instanceId)\"\n    [readonly]=\"readonly\"\n  ></mtna-wf-value-item>\n</ng-container> -->\n"]}

package/esm2015/lib/components/form-item/form-item.module.js

@@ -0,0 +1,22 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { MatMomentDateModule } from '@angular/material-moment-adapter';
+import { MtnaAnnotationsIndicatorModule } from '@mtna/pojo-social-angular';
+import { MtnaWfItemInjectorModule } from '../form-item-injector';
+import { MtnaWfItemHeaderModule } from '../item-header';
+import { MtnaWfFormItemComponent } from './form-item.component';
+import * as i0 from "@angular/core";
+export class MtnaWfFormItemModule {
+}
+MtnaWfFormItemModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MtnaWfFormItemModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+MtnaWfFormItemModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MtnaWfFormItemModule, declarations: [MtnaWfFormItemComponent], imports: [CommonModule, MtnaAnnotationsIndicatorModule, MtnaWfItemInjectorModule, MtnaWfItemHeaderModule, MatMomentDateModule], exports: [MtnaWfFormItemComponent] });
+MtnaWfFormItemModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MtnaWfFormItemModule, imports: [[CommonModule, MtnaAnnotationsIndicatorModule, MtnaWfItemInjectorModule, MtnaWfItemHeaderModule, MatMomentDateModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MtnaWfFormItemModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule, MtnaAnnotationsIndicatorModule, MtnaWfItemInjectorModule, MtnaWfItemHeaderModule, MatMomentDateModule],
+                    declarations: [MtnaWfFormItemComponent],
+                    exports: [MtnaWfFormItemComponent],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/form-item/index.js

@@ -0,0 +1,3 @@
+export * from './form-item.component';
+export * from './form-item.module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy93ZWItZm9ybS1hbmd1bGFyL3NyYy9saWIvY29tcG9uZW50cy9mb3JtLWl0ZW0vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLG9CQUFvQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9mb3JtLWl0ZW0uY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vZm9ybS1pdGVtLm1vZHVsZSc7XG4iXX0=

package/esm2015/lib/components/form-item-component-provider/form-item-component-provider.js

@@ -0,0 +1,8 @@
+import { InjectedComponentProvider } from '@mtna/core-angular';
+import { MTNA_WF_ITEM_INJECTED_COMPONENTS } from './form-item-injected-components';
+export class MtnaWfItemComponentProvider extends InjectedComponentProvider {
+    getInjectedComponents() {
+        return MTNA_WF_ITEM_INJECTED_COMPONENTS;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9ybS1pdGVtLWNvbXBvbmVudC1wcm92aWRlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3dlYi1mb3JtLWFuZ3VsYXIvc3JjL2xpYi9jb21wb25lbnRzL2Zvcm0taXRlbS1jb21wb25lbnQtcHJvdmlkZXIvZm9ybS1pdGVtLWNvbXBvbmVudC1wcm92aWRlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQXFCLHlCQUF5QixFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFFbEYsT0FBTyxFQUFFLGdDQUFnQyxFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFFbkYsTUFBTSxPQUFPLDJCQUE0QixTQUFRLHlCQUF5QjtJQUNqRSxxQkFBcUI7UUFDMUIsT0FBTyxnQ0FBZ0MsQ0FBQztJQUMxQyxDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RlZENvbXBvbmVudCwgSW5qZWN0ZWRDb21wb25lbnRQcm92aWRlciB9IGZyb20gJ0BtdG5hL2NvcmUtYW5ndWxhcic7XG5cbmltcG9ydCB7IE1UTkFfV0ZfSVRFTV9JTkpFQ1RFRF9DT01QT05FTlRTIH0gZnJvbSAnLi9mb3JtLWl0ZW0taW5qZWN0ZWQtY29tcG9uZW50cyc7XG5cbmV4cG9ydCBjbGFzcyBNdG5hV2ZJdGVtQ29tcG9uZW50UHJvdmlkZXIgZXh0ZW5kcyBJbmplY3RlZENvbXBvbmVudFByb3ZpZGVyIHtcbiAgcHVibGljIGdldEluamVjdGVkQ29tcG9uZW50cygpOiBJbmplY3RlZENvbXBvbmVudFtdIHtcbiAgICByZXR1cm4gTVROQV9XRl9JVEVNX0lOSkVDVEVEX0NPTVBPTkVOVFM7XG4gIH1cbn1cbiJdfQ==