@mtna/web-form-angular 0.0.1

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

@@ -0,0 +1,150 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { skipWhile, take } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+export class MtnaWfNgFormService {
+    constructor() {
+        this.unsavedChanges$ = new BehaviorSubject(false);
+    }
+    /**
+     * Informs a caller when the MtnaForm is dirty and has unsaved changes.
+     */
+    get unsavedChanges() {
+        return this.unsavedChanges$.asObservable();
+    }
+    /**
+     * Add a control from the ngForm
+     * @param controlId id of the control being added
+     * @param parentIds array of ids representing the path to the parent control
+     * @param newControl the new form control to be added
+     */
+    addControl(controlId, parentIds, newControl) {
+        if (!this.ngForm) {
+            return;
+        }
+        const parentControl = this.ngForm.get(parentIds);
+        parentControl.addControl(controlId, newControl);
+        parentControl.markAsTouched();
+        parentControl.markAsDirty();
+        this.forceUnsavedChange();
+    }
+    /**
+     * Remove a control from the ngForm.
+     *
+     * @param controlId is of the control to remove
+     * @param parentIds rray of ids representing the path to the parent control
+     */
+    removeControl(controlId, parentIds) {
+        if (!this.ngForm) {
+            return;
+        }
+        const parentControl = this.ngForm.get(parentIds);
+        parentControl.removeControl(controlId);
+        parentControl.markAsTouched();
+        parentControl.markAsDirty();
+        this.forceUnsavedChange();
+    }
+    /**
+     * Get the form if it exists
+     * @returns the angular form or null
+     */
+    getForm() {
+        return this.ngForm;
+    }
+    /**
+     * Returns a JSON representation of form values
+     */
+    getFormValue() {
+        var _a;
+        // This includes values for disabled controls.
+        // We loop through MtnaForm to insert values,
+        // so we need the disabled controls to ensure no info loss.
+        return (_a = this.ngForm) === null || _a === void 0 ? void 0 : _a.getRawValue();
+    }
+    /**
+     * @returns Whether a form has been set on this service
+     */
+    hasForm() {
+        return !!this.ngForm;
+    }
+    /**
+     * @returns Whether the form is dirty.
+     */
+    isFormDirty() {
+        return !!this.ngForm && this.ngForm.dirty;
+    }
+    /**
+     * Unsubscribes from value changes & sets the ngForm to null.
+     * Should be called when any component using an MtnaForm is destroyed.
+     */
+    disposeForm() {
+        this.unsubscribeValueChanges();
+        this.ngForm = undefined;
+    }
+    /**
+     * Forces the unsavedChanges observable to emit true.
+     * Use with care, one example is when repeatable items are added/removed from the form.
+     */
+    forceUnsavedChange() {
+        this.unsubscribeValueChanges();
+        this.unsavedChanges$.next(true);
+    }
+    /**
+     * Marks ngForm as pristine & untouched.
+     */
+    markAsPristineAndUntouched() {
+        if (this.ngForm) {
+            this.ngForm.markAsPristine();
+            this.ngForm.markAsUntouched();
+            this.unsavedChanges$.next(this.ngForm.dirty);
+            this.observeNgFormChanges();
+        }
+    }
+    /**
+     * Resets the ngForm.
+     */
+    resetForm() {
+        if (this.ngForm) {
+            this.ngForm.reset();
+            this.unsavedChanges$.next(this.ngForm.dirty);
+            this.observeNgFormChanges();
+        }
+    }
+    /**
+     * Sets a FormGroup on the service so an external source may observe changes.
+     * @param ngForm FormGroup to be registered.
+     */
+    setForm(ngForm) {
+        this.ngForm = ngForm;
+        this.unsavedChanges$.next(this.ngForm.dirty);
+        if (this.ngForm.pristine) {
+            this.observeNgFormChanges();
+        }
+    }
+    /**
+     * Subscribes to ngForm status changes & updates the unsavedChanges observable
+     */
+    observeNgFormChanges() {
+        this.unsubscribeValueChanges();
+        if (this.ngForm) {
+            this.valueChangeSubscription = this.ngForm.valueChanges
+                .pipe(skipWhile(() => (this.ngForm ? this.ngForm.pristine : true)), take(1))
+                .subscribe(() => { var _a; return this.unsavedChanges$.next((_a = this.ngForm) === null || _a === void 0 ? void 0 : _a.dirty); });
+        }
+    }
+    /**
+     * Removes the ngForm status change subscription.
+     */
+    unsubscribeValueChanges() {
+        if (!!this.valueChangeSubscription && !this.valueChangeSubscription.closed) {
+            this.valueChangeSubscription.unsubscribe();
+        }
+    }
+}
+MtnaWfNgFormService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MtnaWfNgFormService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+MtnaWfNgFormService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MtnaWfNgFormService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MtnaWfNgFormService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ng-form.service.js","sourceRoot":"","sources":["../../../../../../../projects/web-form-angular/src/lib/core/services/ng-form.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { AbstractControl, FormGroup } from '@angular/forms';\n\nimport { BehaviorSubject, Observable, Subject, Subscription } from 'rxjs';\nimport { skipWhile, take } from 'rxjs/operators';\n\n@Injectable({ providedIn: 'root' })\nexport class MtnaWfNgFormService {\n  private ngForm: FormGroup | undefined;\n  private unsavedChanges$: Subject<boolean> = new BehaviorSubject<boolean>(false);\n  private valueChangeSubscription: Subscription | undefined;\n\n  /**\n   * Informs a caller when the MtnaForm is dirty and has unsaved changes.\n   */\n  get unsavedChanges(): Observable<boolean> {\n    return this.unsavedChanges$.asObservable();\n  }\n\n  /**\n   * Add a control from the ngForm\n   * @param controlId id of the control being added\n   * @param parentIds array of ids representing the path to the parent control\n   * @param newControl the new form control to be added\n   */\n  addControl(controlId: string, parentIds: string[], newControl: AbstractControl) {\n    if (!this.ngForm) {\n      return;\n    }\n\n    const parentControl = this.ngForm.get(parentIds) as FormGroup;\n    parentControl.addControl(controlId, newControl);\n    parentControl.markAsTouched();\n    parentControl.markAsDirty();\n    this.forceUnsavedChange();\n  }\n\n  /**\n   * Remove a control from the ngForm.\n   *\n   * @param controlId is of the control to remove\n   * @param parentIds rray of ids representing the path to the parent control\n   */\n  removeControl(controlId: string, parentIds: string[]) {\n    if (!this.ngForm) {\n      return;\n    }\n\n    const parentControl = this.ngForm.get(parentIds) as FormGroup;\n    parentControl.removeControl(controlId);\n    parentControl.markAsTouched();\n    parentControl.markAsDirty();\n    this.forceUnsavedChange();\n  }\n\n  /**\n   * Get the form if it exists\n   * @returns the angular form or null\n   */\n  getForm(): FormGroup | undefined {\n    return this.ngForm;\n  }\n\n  /**\n   * Returns a JSON representation of form values\n   */\n  getFormValue() {\n    // This includes values for disabled controls.\n    // We loop through MtnaForm to insert values,\n    // so we need the disabled controls to ensure no info loss.\n    return this.ngForm?.getRawValue();\n  }\n\n  /**\n   * @returns Whether a form has been set on this service\n   */\n  hasForm(): boolean {\n    return !!this.ngForm;\n  }\n\n  /**\n   * @returns Whether the form is dirty.\n   */\n  isFormDirty(): boolean {\n    return !!this.ngForm && this.ngForm.dirty;\n  }\n\n  /**\n   * Unsubscribes from value changes & sets the ngForm to null.\n   * Should be called when any component using an MtnaForm is destroyed.\n   */\n  disposeForm() {\n    this.unsubscribeValueChanges();\n    this.ngForm = undefined;\n  }\n\n  /**\n   * Forces the unsavedChanges observable to emit true.\n   * Use with care, one example is when repeatable items are added/removed from the form.\n   */\n  forceUnsavedChange() {\n    this.unsubscribeValueChanges();\n    this.unsavedChanges$.next(true);\n  }\n\n  /**\n   * Marks ngForm as pristine & untouched.\n   */\n  markAsPristineAndUntouched() {\n    if (this.ngForm) {\n      this.ngForm.markAsPristine();\n      this.ngForm.markAsUntouched();\n      this.unsavedChanges$.next(this.ngForm.dirty);\n      this.observeNgFormChanges();\n    }\n  }\n\n  /**\n   * Resets the ngForm.\n   */\n  resetForm() {\n    if (this.ngForm) {\n      this.ngForm.reset();\n      this.unsavedChanges$.next(this.ngForm.dirty);\n      this.observeNgFormChanges();\n    }\n  }\n\n  /**\n   * Sets a FormGroup on the service so an external source may observe changes.\n   * @param ngForm FormGroup to be registered.\n   */\n  setForm(ngForm: FormGroup) {\n    this.ngForm = ngForm;\n    this.unsavedChanges$.next(this.ngForm.dirty);\n    if (this.ngForm.pristine) {\n      this.observeNgFormChanges();\n    }\n  }\n\n  /**\n   * Subscribes to ngForm status changes & updates the unsavedChanges observable\n   */\n  private observeNgFormChanges() {\n    this.unsubscribeValueChanges();\n    if (this.ngForm) {\n      this.valueChangeSubscription = this.ngForm.valueChanges\n        .pipe(\n          skipWhile(() => (this.ngForm ? this.ngForm.pristine : true)),\n          take(1)\n        )\n        .subscribe(() => this.unsavedChanges$.next(this.ngForm?.dirty));\n    }\n  }\n\n  /**\n   * Removes the ngForm status change subscription.\n   */\n  private unsubscribeValueChanges() {\n    if (!!this.valueChangeSubscription && !this.valueChangeSubscription.closed) {\n      this.valueChangeSubscription.unsubscribe();\n    }\n  }\n}\n"]}

package/esm2015/lib/core/services/ui.service.js

@@ -0,0 +1,333 @@
+import { Inject, Injectable, InjectionToken, Optional } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+import { isPresent, isType } from '@mtna/core-ts';
+import { isConditionalItem, isOptionGroupItemImpl, isOptionItemImpl } from '@mtna/web-form-ts';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/dialog";
+/** List of default error messages to display */
+export const DEFAULT_ERROR_MESSAGES = {
+    email: 'This field must include a valid email format.',
+    max: (item) => !isPresent(item) || !isPresent(item === null || item === void 0 ? void 0 : item.maxValue)
+        ? `This field's value must be less.`
+        : `${isPresent(item === null || item === void 0 ? void 0 : item.minValue) ? `Min value: ${item === null || item === void 0 ? void 0 : item.minValue} - ` : ''}Max value: ${item === null || item === void 0 ? void 0 : item.minValue}`,
+    maxlength: 'This field has exceeded the allowed maximum.',
+    maxSelected: null,
+    min: (item) => !isPresent(item) || !isPresent(item === null || item === void 0 ? void 0 : item.minValue)
+        ? `This field's value must be greater.`
+        : `Min value: ${item === null || item === void 0 ? void 0 : item.minValue}${!isPresent(item === null || item === void 0 ? void 0 : item.maxValue) ? '' : ` - Max value: ${item === null || item === void 0 ? void 0 : item.maxValue}`}`,
+    minlength: 'This field has not met the required minimum.',
+    minSelected: null,
+    nonDigit: `This field's value must be numeric.`,
+    pattern: `This field's input does not meet the accepted pattern.`,
+    positive: `This field's value cannot be negative.`,
+    required: 'This field is required.',
+    requiredTrue: `This field's value must be 'true'.`,
+    wholeNumber: `This field cannot contain a decimal.`,
+    matDatepickerParse: `This field's value is not an accepted format.`,
+};
+export const WEB_FORM_CUSTOM_ERRORS = new InjectionToken('mtnaWebFormCustomFormErrors');
+export class MtnaWfUIService {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    constructor(dialog, errors) {
+        this.dialog = dialog;
+        /** Map of annotation counts for each annotatable item */
+        this.annotations = {};
+        /** Map of components in the MtnaForm */
+        this.components = {};
+        /** Map of item.disabled values that have changed */
+        this.disabledState = {};
+        /** Map of toggler ID's for components that have multiple togglers */
+        this.multipleEnablers = {};
+        // Workaround for: Metadata collected contains an error that will be reported at runtime: Could not resolve type CustomErrors.
+        // see https://stackoverflow.com/questions/49513359/could-not-resolve-type-document-in-angular5/53715642#53715642
+        this.errors = errors;
+    }
+    getDisabledStates() {
+        return Object.assign({}, this.disabledState);
+    }
+    /**
+     * Returns an error message matching the error id
+     * @param errorId Id of the error, to find the associated error message
+     * @param item FormItem to pass to ValidationErrors that are functions. For instance,
+     * this is useful for 'min' & 'max' value limits to display more helpful messages
+     */
+    getError(errorId, item) {
+        // default when no custom message exists
+        let error = DEFAULT_ERROR_MESSAGES[errorId];
+        if (!!this.errors && !!item) {
+            // check for instance specific, via instanceId
+            if (isPresent(this.errors[item.instanceId]) && isPresent(this.errors[item.instanceId][errorId])) {
+                error = this.errors[item.instanceId][errorId];
+                // check for item specific, via itemId
+            }
+            else if (isPresent(this.errors[item.itemId]) && isPresent(this.errors[item.itemId][errorId])) {
+                error = this.errors[item.itemId][errorId];
+            }
+        }
+        return typeof error === 'function' ? error(item) : error;
+    }
+    /**
+     * Get a registered component by intance id.
+     * @param id the instanceId
+     * @returns the {@link FormItemComponent} that represents that ID or undefined if not registered.
+     */
+    getItem(id) {
+        return this.components[id];
+    }
+    /**
+     * Sets the initial map of annotation counts, and/or pushes the new count onto the component observable stream
+     * @param map AnnotatableNumberMap of counts mapped to their annotatableIds
+     */
+    registerAnnotations(map) {
+        for (const id in map) {
+            if (Object.prototype.hasOwnProperty.call(map, id)) {
+                if (!this.annotations[id]) {
+                    this.annotations[id] = new BehaviorSubject(map[id]);
+                }
+                else {
+                    this.annotations[id].next(map[id]);
+                }
+            }
+        }
+    }
+    /**
+     * Maps a component to its items instanceId.
+     * @param component component calling this method, i.e. 'this'
+     */
+    registerSelf(component) {
+        this.components[component.item.instanceId] = component;
+        if (!!component.item.annotatableId && component.item.annotationEnabled) {
+            if (!this.annotations[component.item.annotatableId]) {
+                this.annotations[component.item.annotatableId] = new BehaviorSubject(null);
+            }
+            component.annotations$ = this.annotations[component.item.annotatableId].asObservable();
+        }
+    }
+    /**
+     * Toggles a FormItem's visiblity and enable/disable state
+     *
+     * @param enabledItemIds array of component IDs for enabled items.
+     * @param disabledItemIds array of component IDs for disabled items.
+     * @param enabled Whether the enabledItemIds are enabled.
+     * @param callerId instanceId of the item invoking this function
+     * @param reset Whether to reset the multiple enabler map of the toggled item
+     */
+    toggleFormItems(enabledItemIds, disabledItemIds, enabled, callerId, reset = false) {
+        if ((!enabledItemIds || !enabledItemIds.length) && (!disabledItemIds || !disabledItemIds.length)) {
+            return;
+        }
+        const allIds = [enabledItemIds, disabledItemIds];
+        for (let i = 0; i < allIds.length; i++) {
+            const itemIds = allIds[i];
+            const isEnabled = i === 0 ? enabled : !enabled;
+            for (const id of itemIds) {
+                const component = this.components[id];
+                // If component is registered, toggle it
+                if (component) {
+                    const item = component.item;
+                    const hasMultipleEnablers = isConditionalItem(item) && item.condition ? item.condition.itemIds.length > 1 : false;
+                    // If item has more than 1 enabler, handle multiple enablers
+                    if (hasMultipleEnablers) {
+                        if (reset) {
+                            this.multipleEnablers[item.instanceId] = null;
+                        }
+                        // If a map has not been registered, then build up a map to register
+                        // Should only happen the first time an item is toggled.
+                        if (!this.multipleEnablers[item.instanceId] && isConditionalItem(item)) {
+                            this.multipleEnablers[item.instanceId] = this._registerCurrentEnablers(item);
+                        }
+                        // handle Multiple Enablers
+                        this._handleMultipleEnablers(component, isEnabled, callerId);
+                    }
+                    else {
+                        // Not multiple enablers
+                        this._toggleDisabledStateAndControl(component, isEnabled);
+                    }
+                }
+                else {
+                    console.error('[toggleFormItems] component has not been registerd', id, enabled, callerId);
+                }
+            }
+        }
+    }
+    /**
+     * Generates map of all IDs currently influencing an item.
+     * @param toggledItem item being toggled
+     */
+    _registerCurrentEnablers(toggledItem) {
+        var _a;
+        const enablers = {};
+        const allIds = ((_a = toggledItem.condition) === null || _a === void 0 ? void 0 : _a.itemIds) || [];
+        for (const id of allIds) {
+            const component = this.components[id];
+            if (component) {
+                if (this._isCurrentlyToggling(component, toggledItem.instanceId)) {
+                    enablers[component.item.instanceId] = component.item.instanceId;
+                }
+            }
+            else {
+                console.error('[registerCurrentEnablers] component has not been registered.', id);
+            }
+        }
+        return enablers;
+    }
+    /**
+     * Resets the map of components. This should be called by the form when
+     * it is destroyed.
+     */
+    resetComponentMap() {
+        this.annotations = {};
+        this.components = {};
+        this.disabledState = {};
+        this.multipleEnablers = {};
+    }
+    /**
+     * Determines if an influencer is currently toggling the specified toggledItemId.
+     * @param influencer Item to check whether it's currently influencing the toggledItemId
+     * @param toggledId InstanceId of the item being toggled
+     * @returns Whether the influencer is currently toggling the toggled item
+     */
+    _isCurrentlyToggling(influencer, toggledId) {
+        var _a, _b, _c;
+        const item = influencer.item;
+        // Item has single option property, so check if selected, or item.value is 'true'
+        if (isOptionItemImpl(item)) {
+            return item.option.selected || !!item.value || !!((_a = influencer.control) === null || _a === void 0 ? void 0 : _a.value);
+        }
+        else if (isOptionGroupItemImpl(item)) {
+            const value = (_c = (_b = influencer.control) === null || _b === void 0 ? void 0 : _b.value) !== null && _c !== void 0 ? _c : item.value;
+            if (Array.isArray(value)) {
+                // find the index of options that contain the 'toggledId' in their enabledItems
+                // & check if at least 1 is selected, or its 'true' in the value
+                const optionIndexes = item.options.map((o, i) => (o.enabledItems.some((id) => id === toggledId) ? i : null)).filter(isPresent);
+                return optionIndexes.some((i) => !!value[i]);
+            }
+            else if (typeof value === 'string' && value.length) {
+                // if the value is a single value, get the enabling option ids and check for the value in them
+                return item.options.some((o) => o.option.id === value && o.enabledItems.some((id) => id === toggledId));
+            }
+        }
+        return false;
+    }
+    /**
+     * Handles component visibility for a FormItem with multiple enablers in its condition
+     * @param component FormItemComponent being toggled
+     * @param enabled Whether the component is being enabled
+     * @param callerId ID of the caller toggling this component
+     */
+    _handleMultipleEnablers(component, enabled, callerId) {
+        var _a;
+        const item = component.item;
+        const enablers = Object.assign({}, this.multipleEnablers[item.instanceId]);
+        let isEnabled;
+        if (enabled) {
+            enablers[callerId] = callerId;
+            isEnabled =
+                isConditionalItem(item) &&
+                    !!item.condition &&
+                    (!item.condition.allRequired || item.condition.itemIds.every((id) => !!enablers[id]));
+        }
+        else {
+            delete enablers[callerId];
+            isEnabled = !((isConditionalItem(item) && ((_a = item.condition) === null || _a === void 0 ? void 0 : _a.allRequired)) || !Object.keys(enablers).length);
+        }
+        // If enabled === disabled, then the state has changed
+        if (this._isDisabled(item) === isEnabled) {
+            this._toggleDisabledStateAndControl(component, isEnabled);
+        }
+        // set the new enabler map
+        this.multipleEnablers[item.instanceId] = enablers;
+    }
+    /**
+     * Enables or disables the control on a FormItemComponent
+     * @param component FormItemComponent to enable or disable its control
+     * @param enabled whether to enable the control
+     */
+    _toggleControlState(component, enabled) {
+        var _a, _b, _c;
+        if (enabled && !((_a = component.control) === null || _a === void 0 ? void 0 : _a.enabled)) {
+            // Enable the control if it isn't already
+            if (component.control instanceof FormGroup) {
+                this._enableIndividualControls(component);
+            }
+            else {
+                (_b = component.control) === null || _b === void 0 ? void 0 : _b.enable();
+            }
+        }
+        else if (!enabled && ((_c = component.control) === null || _c === void 0 ? void 0 : _c.enabled)) {
+            // Disable the control if it isn't already
+            component.control.disable();
+        }
+    }
+    /**
+     * Toggles both the component visiblity and the control's enable/disable status
+     * @param component FormItemComponent to show or hide and enable or disable
+     * @param enabled whether to show the component and whether to enable the component
+     */
+    _toggleDisabledStateAndControl(component, enabled) {
+        this.disabledState[component.item.instanceId] = !enabled;
+        this._toggleControlState(component, enabled);
+        if (isConditionalItem(component.item) && component.item.hideOnDisable) {
+            component.visible = enabled;
+        }
+    }
+    /**
+     * Enables controls individually using recursion.
+     * FormGroups should only exist for items with 'items' arrays, or
+     * if the component is a BaseParentItemControl
+     * @param comp FormItemComponent
+     */
+    _enableIndividualControls(comp) {
+        const group = comp.control;
+        if (isOptionItemImpl(comp.item) || isOptionGroupItemImpl(comp.item)) {
+            const map = comp.item.optionItemMap;
+            const self = group.get(comp.item.instanceId);
+            self === null || self === void 0 ? void 0 : self.enable();
+            for (const optionId in map) {
+                if (Object.prototype.hasOwnProperty.call(map, optionId)) {
+                    const childComp = this.components[map[optionId].instanceId];
+                    if (!this._isDisabled(childComp.item)) {
+                        this._toggleControlState(childComp, true);
+                    }
+                }
+            }
+        }
+        else if (isType(comp.item, 'items') && comp.item.items.length) {
+            // Item must have 'items' array
+            for (const item of comp.item.items) {
+                const childComp = this.components[item.instanceId];
+                if (!this._isDisabled(item)) {
+                    this._toggleControlState(childComp, true);
+                }
+            }
+        }
+        group.updateValueAndValidity();
+    }
+    /**
+     * Determines if a component is disabled. Prioritizes the disabledState value,
+     * if it exists, otherwise returns the item's previous disabled value
+     * @param item item to check for its disabled state
+     */
+    _isDisabled(item) {
+        const existsInDisabledStatMap = isPresent(this.disabledState[item.instanceId]);
+        if (!existsInDisabledStatMap) {
+            return isConditionalItem(item) ? item.disabled : false;
+        }
+        else {
+            return this.disabledState[item.instanceId];
+        }
+    }
+}
+MtnaWfUIService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MtnaWfUIService, deps: [{ token: i1.MatDialog }, { token: WEB_FORM_CUSTOM_ERRORS, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+MtnaWfUIService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MtnaWfUIService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MtnaWfUIService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.MatDialog }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [WEB_FORM_CUSTOM_ERRORS]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ui.service.js","sourceRoot":"","sources":["../../../../../../../projects/web-form-angular/src/lib/core/services/ui.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, InjectionToken, Optional } from '@angular/core';\nimport { FormGroup, ValidationErrors } from '@angular/forms';\nimport { MatDialog } from '@angular/material/dialog';\n\nimport { isPresent, isType } from '@mtna/core-ts';\nimport { AnnotatableNumberMap } from '@mtna/pojo-social-angular';\nimport { ConditionalItem, FormItem, FormItemImpl, isConditionalItem, isOptionGroupItemImpl, isOptionItemImpl } from '@mtna/web-form-ts';\n\nimport { BehaviorSubject } from 'rxjs';\n\nimport type { MtnaWfFormItemComponent } from '../../groups/group-components';\n\n/** Registry of custom error messages for a specific form item. A custom error can also\n * be a function returning a string. The FormItem object is passed to any ValidationErrors\n * that are functions, so item specific information can be provided.\n * @example {\n * max: `This field's value must be less.`,\n * min: (item: FormItemImpl<any>) => instanceofWholeNumberItem(item)\n * ? `This field's value must be greater than ${item.minValue}.`\n * : `This field's value must be greater.`\n * }\n */\n// tslint:disable-next-line:interface-over-type-literal\nexport type CustomErrors = {\n  [id: string]: ValidationErrors;\n};\n\n/** List of default error messages to display */\nexport const DEFAULT_ERROR_MESSAGES: ValidationErrors = {\n  email: 'This field must include a valid email format.',\n  max: (item?: FormItemImpl<number> & { maxValue: number; minValue: number }) =>\n    !isPresent(item) || !isPresent(item?.maxValue)\n      ? `This field's value must be less.`\n      : `${isPresent(item?.minValue) ? `Min value: ${item?.minValue} - ` : ''}Max value: ${item?.minValue}`,\n  maxlength: 'This field has exceeded the allowed maximum.',\n  maxSelected: null,\n  min: (item?: FormItemImpl<number> & { maxValue: number; minValue: number }) =>\n    !isPresent(item) || !isPresent(item?.minValue)\n      ? `This field's value must be greater.`\n      : `Min value: ${item?.minValue}${!isPresent(item?.maxValue) ? '' : ` - Max value: ${item?.maxValue}`}`,\n  minlength: 'This field has not met the required minimum.',\n  minSelected: null,\n  nonDigit: `This field's value must be numeric.`,\n  pattern: `This field's input does not meet the accepted pattern.`,\n  positive: `This field's value cannot be negative.`,\n  required: 'This field is required.',\n  requiredTrue: `This field's value must be 'true'.`,\n  wholeNumber: `This field cannot contain a decimal.`,\n  matDatepickerParse: `This field's value is not an accepted format.`,\n};\n\nexport const WEB_FORM_CUSTOM_ERRORS = new InjectionToken<CustomErrors>('mtnaWebFormCustomFormErrors');\n\n@Injectable({ providedIn: 'root' })\nexport class MtnaWfUIService {\n  /** Map of annotation counts for each annotatable item */\n  private annotations: { [id: string]: BehaviorSubject<number | null> } = {};\n  /** Map of components in the MtnaForm */\n  private components: { [instanceId: string]: MtnaWfFormItemComponent } = {};\n  /** Map of item.disabled values that have changed */\n  private disabledState: { [instanceId: string]: boolean } = {};\n  /** Map of toggler ID's for components that have multiple togglers */\n  private multipleEnablers: { [instanceId: string]: { [togglerId: string]: string } | null } = {};\n  private errors: CustomErrors;\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  constructor(private dialog: MatDialog, @Optional() @Inject(WEB_FORM_CUSTOM_ERRORS) errors?: any) {\n    // Workaround for: Metadata collected contains an error that will be reported at runtime: Could not resolve type CustomErrors.\n    // see https://stackoverflow.com/questions/49513359/could-not-resolve-type-document-in-angular5/53715642#53715642\n    this.errors = errors as CustomErrors;\n  }\n\n  getDisabledStates() {\n    return { ...this.disabledState };\n  }\n\n  /**\n   * Returns an error message matching the error id\n   * @param errorId Id of the error, to find the associated error message\n   * @param item FormItem to pass to ValidationErrors that are functions. For instance,\n   * this is useful for 'min' & 'max' value limits to display more helpful messages\n   */\n  getError(errorId: string, item?: FormItemImpl<unknown>): string {\n    // default when no custom message exists\n    let error = DEFAULT_ERROR_MESSAGES[errorId];\n    if (!!this.errors && !!item) {\n      // check for instance specific, via instanceId\n      if (isPresent(this.errors[item.instanceId]) && isPresent(this.errors[item.instanceId][errorId])) {\n        error = this.errors[item.instanceId][errorId];\n        // check for item specific, via itemId\n      } else if (isPresent(this.errors[item.itemId]) && isPresent(this.errors[item.itemId][errorId])) {\n        error = this.errors[item.itemId][errorId];\n      }\n    }\n    return typeof error === 'function' ? error(item) : error;\n  }\n\n  /**\n   * Get a registered component by intance id.\n   * @param id the instanceId\n   * @returns the {@link FormItemComponent} that represents that ID or undefined if not registered.\n   */\n  getItem(id: string): MtnaWfFormItemComponent | undefined {\n    return this.components[id];\n  }\n\n  /**\n   * Sets the initial map of annotation counts, and/or pushes the new count onto the component observable stream\n   * @param map AnnotatableNumberMap of counts mapped to their annotatableIds\n   */\n  registerAnnotations(map: AnnotatableNumberMap) {\n    for (const id in map) {\n      if (Object.prototype.hasOwnProperty.call(map, id)) {\n        if (!this.annotations[id]) {\n          this.annotations[id] = new BehaviorSubject<number | null>(map[id]);\n        } else {\n          this.annotations[id].next(map[id]);\n        }\n      }\n    }\n  }\n\n  /**\n   * Maps a component to its items instanceId.\n   * @param component component calling this method, i.e. 'this'\n   */\n  registerSelf(component: MtnaWfFormItemComponent) {\n    this.components[component.item.instanceId] = component;\n    if (!!component.item.annotatableId && component.item.annotationEnabled) {\n      if (!this.annotations[component.item.annotatableId]) {\n        this.annotations[component.item.annotatableId] = new BehaviorSubject<number | null>(null);\n      }\n      component.annotations$ = this.annotations[component.item.annotatableId].asObservable();\n    }\n  }\n\n  /**\n   * Toggles a FormItem's visiblity and enable/disable state\n   *\n   * @param enabledItemIds array of component IDs for enabled items.\n   * @param disabledItemIds array of component IDs for disabled items.\n   * @param enabled Whether the enabledItemIds are enabled.\n   * @param callerId instanceId of the item invoking this function\n   * @param reset Whether to reset the multiple enabler map of the toggled item\n   */\n  toggleFormItems(enabledItemIds: Array<string>, disabledItemIds: Array<string>, enabled: boolean, callerId: string, reset = false) {\n    if ((!enabledItemIds || !enabledItemIds.length) && (!disabledItemIds || !disabledItemIds.length)) {\n      return;\n    }\n    const allIds = [enabledItemIds, disabledItemIds];\n    for (let i = 0; i < allIds.length; i++) {\n      const itemIds = allIds[i];\n      const isEnabled = i === 0 ? enabled : !enabled;\n      for (const id of itemIds) {\n        const component = this.components[id];\n        // If component is registered, toggle it\n        if (component) {\n          const item = component.item;\n          const hasMultipleEnablers = isConditionalItem(item) && item.condition ? item.condition.itemIds.length > 1 : false;\n          // If item has more than 1 enabler, handle multiple enablers\n          if (hasMultipleEnablers) {\n            if (reset) {\n              this.multipleEnablers[item.instanceId] = null;\n            }\n            // If a map has not been registered, then build up a map to register\n            // Should only happen the first time an item is toggled.\n            if (!this.multipleEnablers[item.instanceId] && isConditionalItem(item)) {\n              this.multipleEnablers[item.instanceId] = this._registerCurrentEnablers(item);\n            }\n            // handle Multiple Enablers\n            this._handleMultipleEnablers(component, isEnabled, callerId);\n          } else {\n            // Not multiple enablers\n            this._toggleDisabledStateAndControl(component, isEnabled);\n          }\n        } else {\n          console.error('[toggleFormItems] component has not been registerd', id, enabled, callerId);\n        }\n      }\n    }\n  }\n\n  /**\n   * Generates map of all IDs currently influencing an item.\n   * @param toggledItem item being toggled\n   */\n  private _registerCurrentEnablers(toggledItem: ConditionalItem): { [callerId: string]: string } {\n    const enablers: { [callerId: string]: string } = {};\n    const allIds = toggledItem.condition?.itemIds || [];\n\n    for (const id of allIds) {\n      const component = this.components[id];\n      if (component) {\n        if (this._isCurrentlyToggling(component, toggledItem.instanceId)) {\n          enablers[component.item.instanceId] = component.item.instanceId;\n        }\n      } else {\n        console.error('[registerCurrentEnablers] component has not been registered.', id);\n      }\n    }\n\n    return enablers;\n  }\n\n  /**\n   * Resets the map of components. This should be called by the form when\n   * it is destroyed.\n   */\n  resetComponentMap() {\n    this.annotations = {};\n    this.components = {};\n    this.disabledState = {};\n    this.multipleEnablers = {};\n  }\n\n  /**\n   * Determines if an influencer is currently toggling the specified toggledItemId.\n   * @param influencer Item to check whether it's currently influencing the toggledItemId\n   * @param toggledId InstanceId of the item being toggled\n   * @returns Whether the influencer is currently toggling the toggled item\n   */\n  private _isCurrentlyToggling(influencer: MtnaWfFormItemComponent, toggledId: string): boolean {\n    const item = influencer.item;\n    // Item has single option property, so check if selected, or item.value is 'true'\n    if (isOptionItemImpl(item)) {\n      return item.option.selected || !!item.value || !!influencer.control?.value;\n    } else if (isOptionGroupItemImpl(item)) {\n      const value = influencer.control?.value ?? item.value;\n      if (Array.isArray(value)) {\n        // find the index of options that contain the 'toggledId' in their enabledItems\n        // & check if at least 1 is selected, or its 'true' in the value\n        const optionIndexes = item.options.map((o, i) => (o.enabledItems.some((id) => id === toggledId) ? i : null)).filter(isPresent);\n        return optionIndexes.some((i) => !!value[i]);\n      } else if (typeof value === 'string' && value.length) {\n        // if the value is a single value, get the enabling option ids and check for the value in them\n        return item.options.some((o) => o.option.id === value && o.enabledItems.some((id) => id === toggledId));\n      }\n    }\n    return false;\n  }\n\n  /**\n   * Handles component visibility for a FormItem with multiple enablers in its condition\n   * @param component FormItemComponent being toggled\n   * @param enabled Whether the component is being enabled\n   * @param callerId ID of the caller toggling this component\n   */\n  private _handleMultipleEnablers(component: MtnaWfFormItemComponent, enabled: boolean, callerId: string) {\n    const item = component.item;\n    const enablers = { ...this.multipleEnablers[item.instanceId] };\n    let isEnabled: boolean;\n    if (enabled) {\n      enablers[callerId] = callerId;\n      isEnabled =\n        isConditionalItem(item) &&\n        !!item.condition &&\n        (!item.condition.allRequired || item.condition.itemIds.every((id) => !!enablers[id]));\n    } else {\n      delete enablers[callerId];\n      isEnabled = !((isConditionalItem(item) && item.condition?.allRequired) || !Object.keys(enablers).length);\n    }\n    // If enabled === disabled, then the state has changed\n    if (this._isDisabled(item) === isEnabled) {\n      this._toggleDisabledStateAndControl(component, isEnabled);\n    }\n    // set the new enabler map\n    this.multipleEnablers[item.instanceId] = enablers;\n  }\n\n  /**\n   * Enables or disables the control on a FormItemComponent\n   * @param component FormItemComponent to enable or disable its control\n   * @param enabled whether to enable the control\n   */\n  private _toggleControlState(component: MtnaWfFormItemComponent, enabled: boolean) {\n    if (enabled && !component.control?.enabled) {\n      // Enable the control if it isn't already\n      if (component.control instanceof FormGroup) {\n        this._enableIndividualControls(component);\n      } else {\n        component.control?.enable();\n      }\n    } else if (!enabled && component.control?.enabled) {\n      // Disable the control if it isn't already\n      component.control.disable();\n    }\n  }\n\n  /**\n   * Toggles both the component visiblity and the control's enable/disable status\n   * @param component FormItemComponent to show or hide and enable or disable\n   * @param enabled whether to show the component and whether to enable the component\n   */\n  private _toggleDisabledStateAndControl(component: MtnaWfFormItemComponent, enabled: boolean) {\n    this.disabledState[component.item.instanceId] = !enabled;\n    this._toggleControlState(component, enabled);\n    if (isConditionalItem(component.item) && component.item.hideOnDisable) {\n      component.visible = enabled;\n    }\n  }\n\n  /**\n   * Enables controls individually using recursion.\n   * FormGroups should only exist for items with 'items' arrays, or\n   * if the component is a BaseParentItemControl\n   * @param comp FormItemComponent\n   */\n  private _enableIndividualControls(comp: MtnaWfFormItemComponent) {\n    const group = comp.control as FormGroup;\n\n    if (isOptionItemImpl(comp.item) || isOptionGroupItemImpl(comp.item)) {\n      const map = comp.item.optionItemMap;\n      const self = group.get(comp.item.instanceId);\n      self?.enable();\n      for (const optionId in map) {\n        if (Object.prototype.hasOwnProperty.call(map, optionId)) {\n          const childComp = this.components[map[optionId].instanceId];\n          if (!this._isDisabled(childComp.item)) {\n            this._toggleControlState(childComp, true);\n          }\n        }\n      }\n    } else if (isType<{ items: FormItemImpl<unknown>[] }>(comp.item, 'items') && comp.item.items.length) {\n      // Item must have 'items' array\n      for (const item of comp.item.items) {\n        const childComp = this.components[item.instanceId];\n        if (!this._isDisabled(item)) {\n          this._toggleControlState(childComp, true);\n        }\n      }\n    }\n    group.updateValueAndValidity();\n  }\n\n  /**\n   * Determines if a component is disabled. Prioritizes the disabledState value,\n   * if it exists, otherwise returns the item's previous disabled value\n   * @param item item to check for its disabled state\n   */\n  private _isDisabled(item: ConditionalItem | FormItem): boolean {\n    const existsInDisabledStatMap = isPresent(this.disabledState[item.instanceId]);\n    if (!existsInDisabledStatMap) {\n      return isConditionalItem(item) ? item.disabled : false;\n    } else {\n      return this.disabledState[item.instanceId];\n    }\n  }\n}\n"]}

package/esm2015/lib/core/utilities/find-form-control.js

@@ -0,0 +1,29 @@
+import { isFormGroup } from './is-form-group';
+/**
+ * Recursively find a form control by name in a form group.
+ * Depth first search down the tree of form groups to find a control.
+ *
+ * @note This will only work if the entire form has unique form control names.
+ * @param name The unique name of the form cotrol to find.
+ * @param group The {@link FormGroup} to search through.
+ * @returns the found control or null
+ */
+export function findFormControl(name, group) {
+    for (const key in group.controls) {
+        if (Object.prototype.hasOwnProperty.call(group.controls, key)) {
+            const control = group.controls[key];
+            if (key === name) {
+                return control;
+            }
+            // Recurse down if it's a FormGroup
+            if (isFormGroup(control)) {
+                const found = findFormControl(name, control);
+                if (found) {
+                    return found;
+                }
+            }
+        }
+    }
+    return null;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/core/utilities/find-form-item.js

@@ -0,0 +1,25 @@
+import { isType } from '@mtna/core-ts';
+/**
+ * Recursively find a {@link FormItem} by instanceId in a {@link Form}.
+ * Depth first search down the tree of {@link FormItemGroup} to find an item.
+ *
+ * @param instanceId The unique ID of the {@link FormItem} to find.
+ * @param group The {@link Form} or {@link FormItemGroup} to search through.
+ * @returns the found {@link FormItem} or `null`
+ */
+export function findFormItem(instanceId, group) {
+    for (const item of group.items) {
+        if (item.instanceId === instanceId) {
+            return item;
+        }
+        // If it's a FormGroup, search through it's children
+        if (isType(item, 'items')) {
+            const found = findFormItem(instanceId, item);
+            if (found) {
+                return found;
+            }
+        }
+    }
+    return null;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/core/utilities/flatten-steps.js

@@ -0,0 +1,10 @@
+import { isFormStepGroup } from '../../form-stepper/models';
+/**
+ * Flattens formStepGroup.steps and combines all steps into single array
+ * @param steps Array<FormStep | FormStepGroup>
+ * @returns FormStep[] array of the steps and children of step groups
+ */
+export function flattenSteps(steps) {
+    return steps.reduce((a, b) => a.concat(isFormStepGroup(b) ? b.steps : b), new Array());
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmxhdHRlbi1zdGVwcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3dlYi1mb3JtLWFuZ3VsYXIvc3JjL2xpYi9jb3JlL3V0aWxpdGllcy9mbGF0dGVuLXN0ZXBzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBMkIsZUFBZSxFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFFckY7Ozs7R0FJRztBQUNILE1BQU0sVUFBVSxZQUFZLENBQUMsS0FBc0M7SUFDakUsT0FBTyxLQUFLLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxlQUFlLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxFQUFFLElBQUksS0FBSyxFQUFZLENBQUMsQ0FBQztBQUNuRyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRm9ybVN0ZXAsIEZvcm1TdGVwR3JvdXAsIGlzRm9ybVN0ZXBHcm91cCB9IGZyb20gJy4uLy4uL2Zvcm0tc3RlcHBlci9tb2RlbHMnO1xuXG4vKipcbiAqIEZsYXR0ZW5zIGZvcm1TdGVwR3JvdXAuc3RlcHMgYW5kIGNvbWJpbmVzIGFsbCBzdGVwcyBpbnRvIHNpbmdsZSBhcnJheVxuICogQHBhcmFtIHN0ZXBzIEFycmF5PEZvcm1TdGVwIHwgRm9ybVN0ZXBHcm91cD5cbiAqIEByZXR1cm5zIEZvcm1TdGVwW10gYXJyYXkgb2YgdGhlIHN0ZXBzIGFuZCBjaGlsZHJlbiBvZiBzdGVwIGdyb3Vwc1xuICovXG5leHBvcnQgZnVuY3Rpb24gZmxhdHRlblN0ZXBzKHN0ZXBzOiBBcnJheTxGb3JtU3RlcCB8IEZvcm1TdGVwR3JvdXA+KTogQXJyYXk8Rm9ybVN0ZXA+IHtcbiAgcmV0dXJuIHN0ZXBzLnJlZHVjZSgoYSwgYikgPT4gYS5jb25jYXQoaXNGb3JtU3RlcEdyb3VwKGIpID8gYi5zdGVwcyA6IGIpLCBuZXcgQXJyYXk8Rm9ybVN0ZXA+KCkpO1xufVxuIl19