@glowgreen/gg-questionnaire-v2 0.0.1

package/esm2015/lib/services/questionnaire.service.js

@@ -0,0 +1,644 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import * as tslib_1 from "tslib";
+import { Injectable, Inject, EventEmitter } from '@angular/core';
+import { FormConstructorService } from './form-constructor.service';
+import { FormArray } from '@angular/forms';
+import * as _ from 'lodash';
+import { QuestionType } from '../enums/question-type.enum';
+import * as i0 from "@angular/core";
+import * as i1 from "./form-constructor.service";
+export class QuestionnaireService {
+    /**
+     * @param {?} formConstuctor
+     * @param {?} options
+     */
+    constructor(formConstuctor, options) {
+        this.formConstuctor = formConstuctor;
+        this.options = options;
+        this.dataChangedEvent = new EventEmitter();
+        this.skippable = false;
+    }
+    /**
+     * Loads a questionnaire from data.
+     * @author Will Poulson
+     * @param {?} questionnaire The questionnaire data to load, often parsed JSON from the editor.
+     * @param {?=} savedState The saved state of the questionnaire, often from localstorage.
+     * @return {?} null
+     */
+    loadQuestionnaire(questionnaire, savedState) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            this.originalQuestionnaire = _.cloneDeep(questionnaire);
+            this.currentQuestionnaire = _.cloneDeep(questionnaire);
+            if (savedState && Object.keys(savedState).length > 0) {
+                /** @type {?} */
+                const newData = this.formConstuctor.generateFormsForQuestionnaire(_.cloneDeep(this.originalQuestionnaire), this.currentQuestionnaireForm, true);
+                this.formConstuctor.constructRepeaterFromsFromState(savedState, newData.sections, newData.forms);
+                this.currentQuestionnaireForm = newData.forms;
+                this.currentQuestionnaireForm.patchValue(savedState);
+            }
+            yield this.updateQuestionnaire(savedState);
+            for (const section of this.currentQuestionnaire.sections) {
+                for (const question of section.questions) {
+                    /** @type {?} */
+                    const control = this.currentQuestionnaireForm.get([section.name, question.name]);
+                    if (!control.value && question.defaultValue) {
+                        control.setValue(question.defaultValue);
+                    }
+                }
+            }
+            if (this.options.skipToFirstSection) {
+                this.currentSectionName = Object.keys(this.currentQuestionnaireForm.controls)[0];
+            }
+            if (this.options.skipToFirstQuestion) {
+                this.currentQuestionName = Object.keys(this.currentSection.formGroup.controls)[0];
+            }
+            return;
+        });
+    }
+    /**
+     * Updates the current questionnaire, used when a value is updated to check conditions.
+     * @author Will Poulson
+     * @param {?=} savedState The saved state of the questionnaire, often from localstorage.
+     * @return {?} null
+     */
+    updateQuestionnaire(savedState) {
+        /** @type {?} */
+        const newData = this.formConstuctor.generateFormsForQuestionnaire(_.cloneDeep(this.originalQuestionnaire), this.currentQuestionnaireForm);
+        this.currentQuestionnaireForm = newData.forms;
+        this.currentQuestionnaire.sections = newData.sections;
+        if (savedState && Object.keys(savedState).length > 0) {
+            this.currentQuestionnaireForm.patchValue(savedState);
+        }
+        if (this.questionnaireValueChangeSubscription) {
+            this.questionnaireValueChangeSubscription.unsubscribe();
+        }
+        if (this.questionValueChangeSubscription) {
+            this.questionValueChangeSubscription.unsubscribe();
+        }
+        this.questionnaireValueChangeSubscription = this.currentQuestionnaireForm.valueChanges.subscribe((/**
+         * @return {?}
+         */
+        () => {
+            this.dataChangedEvent.emit();
+            this.updateQuestionnaire(this.currentQuestionnaireForm.getRawValue());
+        }));
+        if (this.currentQuestion) {
+            this.questionValueChangeSubscription = this.currentQuestion.formControl.valueChanges.subscribe((/**
+             * @return {?}
+             */
+            () => {
+                this.clearFields(this.currentQuestion.data.clearfields);
+            }));
+        }
+        return;
+    }
+    /**
+     * @return {?}
+     */
+    get isValid() {
+        return this.currentQuestionnaireForm.valid;
+    }
+    /**
+     * @param {?} name
+     * @return {?}
+     */
+    sectionValid(name) {
+        return this.currentQuestionnaireForm.get(name).valid;
+    }
+    /**
+     * Clears all the fields parsed
+     * @author Will Poulson
+     * @private
+     * @param {?} clearfields An array of strings, paths to clear.
+     * @return {?}
+     */
+    clearFields(clearfields) {
+        if (!clearfields || clearfields.length === 0) {
+            return;
+        }
+        for (const clearfield of clearfields) {
+            /** @type {?} */
+            const control = this.currentQuestionnaireForm.get(clearfield);
+            if (control) {
+                control.reset(undefined);
+            }
+        }
+    }
+    /**
+     * Unloads the current questionnaire.
+     * Useful when exiting a questionnaire page or completing a questionnaire.
+     * @author Will Poulson
+     * @return {?}
+     */
+    unloadQuestionnaire() {
+        this.originalQuestionnaire = undefined;
+        this.currentQuestionnaireForm = undefined;
+        this.currentQuestionnaire = undefined;
+        this.currentSectionName = undefined;
+        this.currentQuestionName = undefined;
+    }
+    /**
+     * Gets the current selected section.
+     * @author Will Poulson
+     * @return {?} An object containing the section data and the related form group.
+     */
+    get currentSection() {
+        if (!this.currentSectionName) {
+            return null;
+        }
+        /** @type {?} */
+        const data = this.currentQuestionnaire.sections.find((/**
+         * @param {?} x
+         * @return {?}
+         */
+        (x) => {
+            return x.name === this.currentSectionName;
+        }));
+        if (!data) {
+            return null;
+        }
+        return {
+            data: data,
+            formGroup: (/** @type {?} */ (this.currentQuestionnaireForm.get(data.name)))
+        };
+    }
+    /**
+     * Gets all the avaialble sections.
+     * @author Will Poulson
+     * @return {?} An array of all avaialble sections.
+     */
+    get availableSections() {
+        if (!this.currentQuestionnaire || !this.currentQuestionnaire.sections) {
+            return [];
+        }
+        return this.currentQuestionnaire.sections;
+    }
+    /**
+     * Gets the current data for the entire questionnaire.
+     * @author Will Poulson
+     * @return {?} An object of data.
+     */
+    get currentData() {
+        return this.currentQuestionnaireForm.getRawValue();
+    }
+    /**
+     * Gets the current selected question.
+     * @author Will Poulson
+     * @return {?} An object containing the question data and the related form control.
+     */
+    get currentQuestion() {
+        if (!this.currentQuestionName) {
+            return null;
+        }
+        /** @type {?} */
+        const data = this.currentSection.data.questions.find((/**
+         * @param {?} x
+         * @return {?}
+         */
+        (x) => {
+            return x.name === this.currentQuestionName;
+        }));
+        if (!data) {
+            return null;
+        }
+        return {
+            data: data,
+            formControl: (/** @type {?} */ (this.currentSection.formGroup.get(data.name)))
+        };
+    }
+    /**
+     * Navigates to the next question.
+     * If there is no question to navigate to it will reject with a out of bounds exception.
+     * If allowSkipRequiredField is false then it will reject if the current question is invalid.
+     * If emitSectionFinishEvent is true then it will emit an event if it's navigating past the length of questions.
+     * @author Will Poulson
+     * @return {?} A promise which will resolve when the question has been navigated to.
+     */
+    nextQuestion() {
+        return new Promise((/**
+         * @param {?} resolve
+         * @param {?} reject
+         * @return {?}
+         */
+        (resolve, reject) => {
+            if (!this.options.allowSkipRequiredField) {
+                if (!this.currentQuestion.formControl.valid) {
+                    return reject('Current question is invalid');
+                }
+            }
+            this.getCurrentQuestionIndex().then((/**
+             * @param {?} currentIndex
+             * @return {?}
+             */
+            (currentIndex) => {
+                /** @type {?} */
+                const newIndex = currentIndex + 1;
+                this.navigateToQuestion(newIndex).then((/**
+                 * @return {?}
+                 */
+                () => {
+                    return resolve();
+                })).catch((/**
+                 * @param {?} error
+                 * @return {?}
+                 */
+                (error) => {
+                    return reject(error);
+                }));
+            })).catch((/**
+             * @param {?} error
+             * @return {?}
+             */
+            (error) => {
+                return reject(error);
+            }));
+        }));
+    }
+    /**
+     * Navigates to the previous question.
+     * If there is no question to navigate to it will reject with a out of bounds exception.
+     * If allowNavigateBackwards is false then it will reject.
+     * @author Will Poulson
+     * @return {?} A promise which will resolve when the question has been navigated to.
+     */
+    prevQuestion() {
+        return new Promise((/**
+         * @param {?} resolve
+         * @param {?} reject
+         * @return {?}
+         */
+        (resolve, reject) => {
+            if (!this.options.allowNavigateBackwards) {
+                return reject('This questionnaire does not allow for backwards navigation');
+            }
+            this.getCurrentQuestionIndex().then((/**
+             * @param {?} currentIndex
+             * @return {?}
+             */
+            (currentIndex) => {
+                /** @type {?} */
+                const newIndex = currentIndex - 1;
+                this.navigateToQuestion(newIndex).then((/**
+                 * @return {?}
+                 */
+                () => {
+                    return resolve();
+                })).catch((/**
+                 * @param {?} error
+                 * @return {?}
+                 */
+                (error) => {
+                    return reject(error);
+                }));
+            })).catch((/**
+             * @param {?} error
+             * @return {?}
+             */
+            (error) => {
+                return reject(error);
+            }));
+        }));
+    }
+    /**
+     * Gets the current questions index.
+     * @author Will Poulson
+     * @private
+     * @return {?} A promise which resolves a number.
+     */
+    getCurrentQuestionIndex() {
+        return new Promise((/**
+         * @param {?} resolve
+         * @param {?} reject
+         * @return {?}
+         */
+        (resolve, reject) => {
+            /** @type {?} */
+            const currentIndex = this.currentSection.data.questions.indexOf(this.currentQuestion.data);
+            if (currentIndex === -1) {
+                return reject('Could not find current question');
+            }
+            return resolve(currentIndex);
+        }));
+    }
+    /**
+     * Checks a question is in bounds then navigates to it.
+     * @author Will Poulson
+     * @param {?} index The index to navigate to.
+     * @return {?} A promise which will resolve when the question has been navigated to.
+     */
+    navigateToQuestion(index) {
+        return new Promise((/**
+         * @param {?} resolve
+         * @param {?} reject
+         * @return {?}
+         */
+        (resolve, reject) => {
+            if (this.currentSection.data.questions.length - 1 < index || index < 0) {
+                return reject('Out of bounds exception');
+            }
+            this.currentQuestionName = this.currentSection.data.questions[index].name;
+            return resolve();
+        }));
+    }
+    /**
+     * Navigates to the next section.
+     * @author Will Poulson
+     * @return {?} A promise which will resolve when the section has been navigated to.
+     */
+    nextSection() {
+        return new Promise((/**
+         * @param {?} resolve
+         * @param {?} reject
+         * @return {?}
+         */
+        (resolve, reject) => {
+            this.getCurrentSectionIndex().then((/**
+             * @param {?} currentIndex
+             * @return {?}
+             */
+            (currentIndex) => {
+                /** @type {?} */
+                const newIndex = currentIndex + 1;
+                this.navigateToSection(newIndex).then((/**
+                 * @return {?}
+                 */
+                () => {
+                    return resolve();
+                })).catch((/**
+                 * @param {?} error
+                 * @return {?}
+                 */
+                (error) => {
+                    return reject(error);
+                }));
+            })).catch((/**
+             * @param {?} error
+             * @return {?}
+             */
+            (error) => {
+                return reject(error);
+            }));
+        }));
+    }
+    /**
+     * Navigates to the previous section.
+     * @author Will Poulson
+     * @return {?} A promise which will resolve when the section has been navigated to.
+     */
+    prevSection() {
+        return new Promise((/**
+         * @param {?} resolve
+         * @param {?} reject
+         * @return {?}
+         */
+        (resolve, reject) => {
+            this.getCurrentSectionIndex().then((/**
+             * @param {?} currentIndex
+             * @return {?}
+             */
+            (currentIndex) => {
+                /** @type {?} */
+                const newIndex = currentIndex - 1;
+                this.navigateToQuestion(newIndex).then((/**
+                 * @return {?}
+                 */
+                () => {
+                    return resolve();
+                })).catch((/**
+                 * @param {?} error
+                 * @return {?}
+                 */
+                (error) => {
+                    return reject(error);
+                }));
+            })).catch((/**
+             * @param {?} error
+             * @return {?}
+             */
+            (error) => {
+                return reject(error);
+            }));
+        }));
+    }
+    /**
+     * Gets the current section index.
+     * @author Will Poulson
+     * @private
+     * @return {?} A promise which resolves a number.
+     */
+    getCurrentSectionIndex() {
+        return new Promise((/**
+         * @param {?} resolve
+         * @param {?} reject
+         * @return {?}
+         */
+        (resolve, reject) => {
+            /** @type {?} */
+            const currentIndex = this.currentQuestionnaire.sections.indexOf(this.currentSection.data);
+            if (currentIndex === -1) {
+                return reject('Could not find current section');
+            }
+            return resolve(currentIndex);
+        }));
+    }
+    /**
+     * Checks a section is in bounds then navigates to it.
+     * @author Will Poulson
+     * @param {?} index The index to navigate to.
+     * @return {?} A promise which will resolve when the section has been navigated to.
+     */
+    navigateToSection(index) {
+        return new Promise((/**
+         * @param {?} resolve
+         * @param {?} reject
+         * @return {?}
+         */
+        (resolve, reject) => {
+            if (this.currentQuestionnaire.sections.length - 1 < index || index < 0) {
+                return reject('Out of bounds exception');
+            }
+            this.currentSectionName = this.currentQuestionnaire.sections[index].name;
+            return resolve();
+        }));
+    }
+    /**
+     * Answers the current question with the parsed value.
+     * @author Will Poulson
+     * @param {?} answer The value to answer the question with.
+     * @param {?=} sendToNextQuestion
+     * @return {?}
+     */
+    answerCurrentQuestion(answer, sendToNextQuestion) {
+        this.currentQuestion.formControl.setValue(answer);
+        if (sendToNextQuestion && this.skippable) { // Timeout to prevent skipping glitch.
+            this.skippable = false;
+            setTimeout((/**
+             * @return {?}
+             */
+            () => {
+                this.nextQuestion();
+                this.skippable = true;
+            }), 150);
+        }
+    }
+    /**
+     * Adds a repeater item to the current question.
+     * Current question must be of type Repeater.
+     * @author Will Poulson
+     * @return {?} A promise which resolves when the repeater item has been added.
+     */
+    addRepeaterItem() {
+        return new Promise((/**
+         * @param {?} resolve
+         * @param {?} reject
+         * @return {?}
+         */
+        (resolve, reject) => {
+            if (this.currentQuestion.data.type !== QuestionType.Repeater) {
+                return reject(`Current question isn't a repeater`);
+            }
+            /** @type {?} */
+            const repeaterForm = this.formConstuctor.generateFormsForRepeater(this.currentQuestion.data);
+            if (!repeaterForm) {
+                return reject(`Repeater template failed to generate. May be due to the repeater having no items in the editor.`);
+            }
+            if (!(this.currentQuestion.formControl instanceof FormArray)) {
+                return reject(`The current questions control isn't of type FormArray`);
+            }
+            this.currentQuestion.formControl.push(repeaterForm);
+            return resolve();
+        }));
+    }
+    /**
+     * Removes a repeater item on the current question.
+     * Current question must be of type Repeater.
+     * @author Will Poulson
+     * @param {?} index The index at which to remove.
+     * @return {?} A promise which resolves when the repeater item has been removed.
+     */
+    removeRepeaterItem(index) {
+        return new Promise((/**
+         * @param {?} resolve
+         * @param {?} reject
+         * @return {?}
+         */
+        (resolve, reject) => {
+            if (this.currentQuestion.data.type !== QuestionType.Repeater) {
+                return reject(`Current question isn't a repeater`);
+            }
+            if (!(this.currentQuestion.formControl instanceof FormArray)) {
+                return reject(`The current questions control isn't of type FormArray`);
+            }
+            this.currentQuestion.formControl.removeAt(index);
+            return resolve();
+        }));
+    }
+    /**
+     * Returns the display text for a given repeater item
+     * @author Will Poulson
+     * @param {?} index The index at which to get the label for.
+     * @return {?} A string which is the display text.
+     */
+    getRepeaterItemLabel(index) {
+        if (!this.currentQuestion.formControl || !(this.currentQuestion.formControl instanceof FormArray)) {
+            return '';
+        }
+        /** @type {?} */
+        const repeaterItem = this.currentQuestion.formControl.controls[index];
+        if (!repeaterItem) {
+            return '';
+        }
+        /** @type {?} */
+        const template = this.currentQuestion.data.repeaterDisplayName;
+        /** @type {?} */
+        const splitTemplate = template.split(' ');
+        /** @type {?} */
+        const displayArray = [];
+        for (const templateItem of splitTemplate) {
+            if (templateItem.match(/\[.*?\]/)) {
+                /** @type {?} */
+                const path = templateItem.replace(/[\[\]']+/g, '');
+                /** @type {?} */
+                const item = repeaterItem.get(path);
+                /** @type {?} */
+                const value = item.value ? item.value : '?';
+                displayArray.push(value);
+            }
+            else {
+                displayArray.push(templateItem);
+            }
+        }
+        /** @type {?} */
+        const display = displayArray.join(' ');
+        return display;
+    }
+}
+QuestionnaireService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+/** @nocollapse */
+QuestionnaireService.ctorParameters = () => [
+    { type: FormConstructorService },
+    { type: undefined, decorators: [{ type: Inject, args: ['options',] }] }
+];
+/** @nocollapse */ QuestionnaireService.ngInjectableDef = i0.defineInjectable({ factory: function QuestionnaireService_Factory() { return new QuestionnaireService(i0.inject(i1.FormConstructorService), i0.inject("options")); }, token: QuestionnaireService, providedIn: "root" });
+if (false) {
+    /** @type {?} */
+    QuestionnaireService.prototype.dataChangedEvent;
+    /**
+     * @type {?}
+     * @private
+     */
+    QuestionnaireService.prototype.originalQuestionnaire;
+    /**
+     * @type {?}
+     * @private
+     */
+    QuestionnaireService.prototype.currentQuestionnaire;
+    /**
+     * @type {?}
+     * @private
+     */
+    QuestionnaireService.prototype.currentQuestionnaireForm;
+    /**
+     * @type {?}
+     * @private
+     */
+    QuestionnaireService.prototype.currentSectionName;
+    /**
+     * @type {?}
+     * @private
+     */
+    QuestionnaireService.prototype.currentQuestionName;
+    /**
+     * @type {?}
+     * @private
+     */
+    QuestionnaireService.prototype.questionnaireValueChangeSubscription;
+    /**
+     * @type {?}
+     * @private
+     */
+    QuestionnaireService.prototype.questionValueChangeSubscription;
+    /**
+     * @type {?}
+     * @private
+     */
+    QuestionnaireService.prototype.skippable;
+    /**
+     * @type {?}
+     * @private
+     */
+    QuestionnaireService.prototype.formConstuctor;
+    /**
+     * @type {?}
+     * @private
+     */
+    QuestionnaireService.prototype.options;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"questionnaire.service.js","sourceRoot":"ng://@glowgreen/gg-questionnaire-v2/","sources":["lib/services/questionnaire.service.ts"],"names":[],"mappings":";;;;;AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AACjE,OAAO,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC;AAEpE,OAAO,EAA8B,SAAS,EAAe,MAAM,gBAAgB,CAAC;AAIpF,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAE5B,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;;;AAK3D,MAAM,OAAO,oBAAoB;;;;;IAgB/B,YACU,cAAsC,EACnB,OAA6B;QADhD,mBAAc,GAAd,cAAc,CAAwB;QACnB,YAAO,GAAP,OAAO,CAAsB;QAjBnD,qBAAgB,GAAsB,IAAI,YAAY,EAAO,CAAC;QAa7D,cAAS,GAAG,KAAK,CAAC;IAKtB,CAAC;;;;;;;;IASQ,iBAAiB,CAAC,aAA4B,EAAE,UAAmB;;YAC9E,IAAI,CAAC,qBAAqB,GAAG,CAAC,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC;YACxD,IAAI,CAAC,oBAAoB,GAAG,CAAC,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC;YAEvD,IAAI,UAAU,IAAI,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE;;sBAC9C,OAAO,GAAG,IAAI,CAAC,cAAc,CAAC,6BAA6B,CAC/D,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,qBAAqB,CAAC,EACvC,IAAI,CAAC,wBAAwB,EAC7B,IAAI,CACL;gBACD,IAAI,CAAC,cAAc,CAAC,+BAA+B,CAAC,UAAU,EAAE,OAAO,CAAC,QAAQ,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC;gBACjG,IAAI,CAAC,wBAAwB,GAAG,OAAO,CAAC,KAAK,CAAC;gBAC9C,IAAI,CAAC,wBAAwB,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC;aACtD;YAED,MAAM,IAAI,CAAC,mBAAmB,CAAC,UAAU,CAAC,CAAC;YAE3C,KAAK,MAAM,OAAO,IAAI,IAAI,CAAC,oBAAoB,CAAC,QAAQ,EAAE;gBACxD,KAAK,MAAM,QAAQ,IAAI,OAAO,CAAC,SAAS,EAAE;;0BAClC,OAAO,GAAG,IAAI,CAAC,wBAAwB,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,IAAI,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC;oBAChF,IAAI,CAAC,OAAO,CAAC,KAAK,IAAI,QAAQ,CAAC,YAAY,EAAE;wBAC3C,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC;qBACzC;iBACF;aACF;YAED,IAAI,IAAI,CAAC,OAAO,CAAC,kBAAkB,EAAE;gBACnC,IAAI,CAAC,kBAAkB,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,wBAAwB,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;aAClF;YAED,IAAI,IAAI,CAAC,OAAO,CAAC,mBAAmB,EAAE;gBACpC,IAAI,CAAC,mBAAmB,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;aACnF;YAED,OAAO;QACT,CAAC;KAAA;;;;;;;IAQM,mBAAmB,CAAC,UAAmB;;cACtC,OAAO,GAAG,IAAI,CAAC,cAAc,CAAC,6BAA6B,CAC/D,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,qBAAqB,CAAC,EACvC,IAAI,CAAC,wBAAwB,CAC9B;QACD,IAAI,CAAC,wBAAwB,GAAG,OAAO,CAAC,KAAK,CAAC;QAC9C,IAAI,CAAC,oBAAoB,CAAC,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC;QAEtD,IAAI,UAAU,IAAI,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE;YACpD,IAAI,CAAC,wBAAwB,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC;SACtD;QAED,IAAI,IAAI,CAAC,oCAAoC,EAAE;YAC7C,IAAI,CAAC,oCAAoC,CAAC,WAAW,EAAE,CAAC;SACzD;QAED,IAAI,IAAI,CAAC,+BAA+B,EAAE;YACxC,IAAI,CAAC,+BAA+B,CAAC,WAAW,EAAE,CAAC;SACpD;QAED,IAAI,CAAC,oCAAoC,GAAG,IAAI,CAAC,wBAAwB,CAAC,YAAY,CAAC,SAAS;;;QAAC,GAAG,EAAE;YACpG,IAAI,CAAC,gBAAgB,CAAC,IAAI,EAAE,CAAC;YAC7B,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,wBAAwB,CAAC,WAAW,EAAE,CAAC,CAAC;QACxE,CAAC,EAAC,CAAC;QAEH,IAAI,IAAI,CAAC,eAAe,EAAE;YACxB,IAAI,CAAC,+BAA+B,GAAG,IAAI,CAAC,eAAe,CAAC,WAAW,CAAC,YAAY,CAAC,SAAS;;;YAAC,GAAG,EAAE;gBAClG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;YAC1D,CAAC,EAAC,CAAC;SACJ;QAED,OAAO;IACT,CAAC;;;;IAED,IAAW,OAAO;QAChB,OAAO,IAAI,CAAC,wBAAwB,CAAC,KAAK,CAAC;IAC7C,CAAC;;;;;IAEM,YAAY,CAAC,IAAY;QAC9B,OAAO,IAAI,CAAC,wBAAwB,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC;IACvD,CAAC;;;;;;;;IAOO,WAAW,CAAC,WAA0B;QAC5C,IAAI,CAAC,WAAW,IAAI,WAAW,CAAC,MAAM,KAAK,CAAC,EAAE;YAC5C,OAAO;SACR;QAED,KAAK,MAAM,UAAU,IAAI,WAAW,EAAE;;kBAC9B,OAAO,GAAG,IAAI,CAAC,wBAAwB,CAAC,GAAG,CAAC,UAAU,CAAC;YAE7D,IAAI,OAAO,EAAE;gBACX,OAAO,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;aAC1B;SACF;IACH,CAAC;;;;;;;IAOM,mBAAmB;QACxB,IAAI,CAAC,qBAAqB,GAAG,SAAS,CAAC;QACvC,IAAI,CAAC,wBAAwB,GAAG,SAAS,CAAC;QAC1C,IAAI,CAAC,oBAAoB,GAAG,SAAS,CAAC;QACtC,IAAI,CAAC,kBAAkB,GAAG,SAAS,CAAC;QACpC,IAAI,CAAC,mBAAmB,GAAG,SAAS,CAAC;IACvC,CAAC;;;;;;IAOD,IAAW,cAAc;QACvB,IAAI,CAAC,IAAI,CAAC,kBAAkB,EAAE;YAC5B,OAAO,IAAI,CAAC;SACb;;cAEK,IAAI,GAAG,IAAI,CAAC,oBAAoB,CAAC,QAAQ,CAAC,IAAI;;;;QAAC,CAAC,CAAC,EAAE,EAAE;YACzD,OAAO,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,kBAAkB,CAAC;QAC5C,CAAC,EAAC;QAEF,IAAI,CAAC,IAAI,EAAE;YACT,OAAO,IAAI,CAAC;SACb;QAED,OAAO;YACL,IAAI,EAAE,IAAI;YACV,SAAS,EAAE,mBAAA,IAAI,CAAC,wBAAwB,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,EAAa;SACrE,CAAC;IACJ,CAAC;;;;;;IAOD,IAAW,iBAAiB;QAC1B,IAAI,CAAC,IAAI,CAAC,oBAAoB,IAAI,CAAC,IAAI,CAAC,oBAAoB,CAAC,QAAQ,EAAE;YACrE,OAAO,EAAE,CAAC;SACX;QACD,OAAO,IAAI,CAAC,oBAAoB,CAAC,QAAQ,CAAC;IAC5C,CAAC;;;;;;IAOD,IAAW,WAAW;QACpB,OAAO,IAAI,CAAC,wBAAwB,CAAC,WAAW,EAAE,CAAC;IACrD,CAAC;;;;;;IAQD,IAAW,eAAe;QACxB,IAAI,CAAC,IAAI,CAAC,mBAAmB,EAAE;YAC7B,OAAO,IAAI,CAAC;SACb;;cAEK,IAAI,GAAG,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI;;;;QAAC,CAAC,CAAC,EAAE,EAAE;YACzD,OAAO,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,mBAAmB,CAAC;QAC7C,CAAC,EAAC;QAEF,IAAI,CAAC,IAAI,EAAE;YACT,OAAO,IAAI,CAAC;SACb;QAED,OAAO;YACL,IAAI,EAAE,IAAI;YACV,WAAW,EAAE,mBAAA,IAAI,CAAC,cAAc,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,EAAmB;SAC7E,CAAC;IACJ,CAAC;;;;;;;;;IAUM,YAAY;QACjB,OAAO,IAAI,OAAO;;;;;QAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACrC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,sBAAsB,EAAE;gBACxC,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,WAAW,CAAC,KAAK,EAAE;oBAC3C,OAAO,MAAM,CAAC,6BAA6B,CAAC,CAAC;iBAC9C;aACF;YAED,IAAI,CAAC,uBAAuB,EAAE,CAAC,IAAI;;;;YAAC,CAAC,YAAY,EAAE,EAAE;;sBAC7C,QAAQ,GAAG,YAAY,GAAG,CAAC;gBAEjC,IAAI,CAAC,kBAAkB,CAAC,QAAQ,CAAC,CAAC,IAAI;;;gBAAC,GAAG,EAAE;oBAC1C,OAAO,OAAO,EAAE,CAAC;gBACnB,CAAC,EAAC,CAAC,KAAK;;;;gBAAC,CAAC,KAAK,EAAE,EAAE;oBACjB,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC;gBACvB,CAAC,EAAC,CAAC;YACL,CAAC,EAAC,CAAC,KAAK;;;;YAAC,CAAC,KAAK,EAAE,EAAE;gBACjB,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC;YACvB,CAAC,EAAC,CAAC;QACL,CAAC,EAAC,CAAC;IACL,CAAC;;;;;;;;IASM,YAAY;QACjB,OAAO,IAAI,OAAO;;;;;QAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACrC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,sBAAsB,EAAE;gBACxC,OAAO,MAAM,CAAC,4DAA4D,CAAC,CAAC;aAC7E;YAED,IAAI,CAAC,uBAAuB,EAAE,CAAC,IAAI;;;;YAAC,CAAC,YAAY,EAAE,EAAE;;sBAC7C,QAAQ,GAAG,YAAY,GAAG,CAAC;gBAEjC,IAAI,CAAC,kBAAkB,CAAC,QAAQ,CAAC,CAAC,IAAI;;;gBAAC,GAAG,EAAE;oBAC1C,OAAO,OAAO,EAAE,CAAC;gBACnB,CAAC,EAAC,CAAC,KAAK;;;;gBAAC,CAAC,KAAK,EAAE,EAAE;oBACjB,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC;gBACvB,CAAC,EAAC,CAAC;YACL,CAAC,EAAC,CAAC,KAAK;;;;YAAC,CAAC,KAAK,EAAE,EAAE;gBACjB,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC;YACvB,CAAC,EAAC,CAAC;QACL,CAAC,EAAC,CAAC;IACL,CAAC;;;;;;;IAOO,uBAAuB;QAC7B,OAAO,IAAI,OAAO;;;;;QAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;;kBAC/B,YAAY,GAAG,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC;YAE1F,IAAI,YAAY,KAAK,CAAC,CAAC,EAAE;gBACvB,OAAO,MAAM,CAAC,iCAAiC,CAAC,CAAC;aAClD;YAED,OAAO,OAAO,CAAC,YAAY,CAAC,CAAC;QAC/B,CAAC,EAAC,CAAC;IACL,CAAC;;;;;;;IAQM,kBAAkB,CAAC,KAAa;QACrC,OAAO,IAAI,OAAO;;;;;QAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACrC,IAAI,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC,GAAG,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE;gBACtE,OAAO,MAAM,CAAC,yBAAyB,CAAC,CAAC;aAC1C;YAED,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC;YAC1E,OAAO,OAAO,EAAE,CAAC;QACnB,CAAC,EAAC,CAAC;IACL,CAAC;;;;;;IAOM,WAAW;QAChB,OAAO,IAAI,OAAO;;;;;QAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACrC,IAAI,CAAC,sBAAsB,EAAE,CAAC,IAAI;;;;YAAC,CAAC,YAAY,EAAE,EAAE;;sBAC5C,QAAQ,GAAG,YAAY,GAAG,CAAC;gBACjC,IAAI,CAAC,iBAAiB,CAAC,QAAQ,CAAC,CAAC,IAAI;;;gBAAC,GAAG,EAAE;oBACzC,OAAO,OAAO,EAAE,CAAC;gBACnB,CAAC,EAAC,CAAC,KAAK;;;;gBAAC,CAAC,KAAK,EAAE,EAAE;oBACjB,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC;gBACvB,CAAC,EAAC,CAAC;YACL,CAAC,EAAC,CAAC,KAAK;;;;YAAC,CAAC,KAAK,EAAE,EAAE;gBACjB,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC;YACvB,CAAC,EAAC,CAAC;QACL,CAAC,EAAC,CAAC;IACL,CAAC;;;;;;IAOM,WAAW;QAChB,OAAO,IAAI,OAAO;;;;;QAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACrC,IAAI,CAAC,sBAAsB,EAAE,CAAC,IAAI;;;;YAAC,CAAC,YAAY,EAAE,EAAE;;sBAC5C,QAAQ,GAAG,YAAY,GAAG,CAAC;gBACjC,IAAI,CAAC,kBAAkB,CAAC,QAAQ,CAAC,CAAC,IAAI;;;gBAAC,GAAG,EAAE;oBAC1C,OAAO,OAAO,EAAE,CAAC;gBACnB,CAAC,EAAC,CAAC,KAAK;;;;gBAAC,CAAC,KAAK,EAAE,EAAE;oBACjB,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC;gBACvB,CAAC,EAAC,CAAC;YACL,CAAC,EAAC,CAAC,KAAK;;;;YAAC,CAAC,KAAK,EAAE,EAAE;gBACjB,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC;YACvB,CAAC,EAAC,CAAC;QACL,CAAC,EAAC,CAAC;IACL,CAAC;;;;;;;IAOO,sBAAsB;QAC5B,OAAO,IAAI,OAAO;;;;;QAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;;kBAC/B,YAAY,GAAG,IAAI,CAAC,oBAAoB,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC;YAEzF,IAAI,YAAY,KAAK,CAAC,CAAC,EAAE;gBACvB,OAAO,MAAM,CAAC,gCAAgC,CAAC,CAAC;aACjD;YAED,OAAO,OAAO,CAAC,YAAY,CAAC,CAAC;QAC/B,CAAC,EAAC,CAAC;IACL,CAAC;;;;;;;IAQM,iBAAiB,CAAC,KAAa;QACpC,OAAO,IAAI,OAAO;;;;;QAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACrC,IAAI,IAAI,CAAC,oBAAoB,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,GAAG,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE;gBACtE,OAAO,MAAM,CAAC,yBAAyB,CAAC,CAAC;aAC1C;YAED,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC,oBAAoB,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC;YACzE,OAAO,OAAO,EAAE,CAAC;QACnB,CAAC,EAAC,CAAC;IACL,CAAC;;;;;;;;IAOM,qBAAqB,CAAC,MAAW,EAAE,kBAA4B;QACpE,IAAI,CAAC,eAAe,CAAC,WAAW,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;QAClD,IAAI,kBAAkB,IAAI,IAAI,CAAC,SAAS,EAAE,EAAE,sCAAsC;YAChF,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;YACvB,UAAU;;;YAAC,GAAG,EAAE;gBACd,IAAI,CAAC,YAAY,EAAE,CAAC;gBACpB,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;YACxB,CAAC,GAAE,GAAG,CAAC,CAAC;SACT;IACH,CAAC;;;;;;;IAQM,eAAe;QACpB,OAAO,IAAI,OAAO;;;;;QAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACrC,IAAI,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,KAAK,YAAY,CAAC,QAAQ,EAAE;gBAC5D,OAAO,MAAM,CAAC,mCAAmC,CAAC,CAAC;aACpD;;kBACK,YAAY,GAAG,IAAI,CAAC,cAAc,CAAC,wBAAwB,CAAC,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC;YAE5F,IAAI,CAAC,YAAY,EAAE;gBACjB,OAAO,MAAM,CAAC,iGAAiG,CAAC,CAAC;aAClH;YAGD,IAAI,CAAC,CAAC,IAAI,CAAC,eAAe,CAAC,WAAW,YAAY,SAAS,CAAC,EAAE;gBAC5D,OAAO,MAAM,CAAC,uDAAuD,CAAC,CAAC;aACxE;YAED,IAAI,CAAC,eAAe,CAAC,WAAW,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;YACpD,OAAO,OAAO,EAAE,CAAC;QACnB,CAAC,EAAC,CAAC;IACL,CAAC;;;;;;;;IASM,kBAAkB,CAAC,KAAa;QACrC,OAAO,IAAI,OAAO;;;;;QAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACrC,IAAI,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,KAAK,YAAY,CAAC,QAAQ,EAAE;gBAC5D,OAAO,MAAM,CAAC,mCAAmC,CAAC,CAAC;aACpD;YAED,IAAI,CAAC,CAAC,IAAI,CAAC,eAAe,CAAC,WAAW,YAAY,SAAS,CAAC,EAAE;gBAC5D,OAAO,MAAM,CAAC,uDAAuD,CAAC,CAAC;aACxE;YAED,IAAI,CAAC,eAAe,CAAC,WAAW,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;YACjD,OAAO,OAAO,EAAE,CAAC;QACnB,CAAC,EAAC,CAAC;IACL,CAAC;;;;;;;IAQM,oBAAoB,CAAC,KAAa;QACvC,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,WAAW,IAAI,CAAC,CAAC,IAAI,CAAC,eAAe,CAAC,WAAW,YAAY,SAAS,CAAC,EAAE;YACjG,OAAO,EAAE,CAAC;SACX;;cAEK,YAAY,GAAG,IAAI,CAAC,eAAe,CAAC,WAAW,CAAC,QAAQ,CAAC,KAAK,CAAC;QAErE,IAAI,CAAC,YAAY,EAAE;YACjB,OAAO,EAAE,CAAC;SACX;;cAEK,QAAQ,GAAG,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,mBAAmB;;cACxD,aAAa,GAAG,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC;;cAEnC,YAAY,GAAG,EAAE;QACvB,KAAK,MAAM,YAAY,IAAI,aAAa,EAAE;YACxC,IAAI,YAAY,CAAC,KAAK,CAAC,SAAS,CAAC,EAAE;;sBAC3B,IAAI,GAAG,YAAY,CAAC,OAAO,CAAC,WAAW,EAAE,EAAE,CAAC;;sBAC5C,IAAI,GAAG,YAAY,CAAC,GAAG,CAAC,IAAI,CAAC;;sBAC7B,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG;gBAC3C,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;aAC1B;iBAAM;gBACL,YAAY,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;aACjC;SACF;;cAEK,OAAO,GAAG,YAAY,CAAC,IAAI,CAAC,GAAG,CAAC;QACtC,OAAO,OAAO,CAAC;IACjB,CAAC;;;YAleF,UAAU,SAAC;gBACV,UAAU,EAAE,MAAM;aACnB;;;;YAZQ,sBAAsB;4CA+B1B,MAAM,SAAC,SAAS;;;;;IAjBnB,gDAAqE;;;;;IAErE,qDAA6C;;;;;IAE7C,oDAA4C;;;;;IAC5C,wDAA4C;;;;;IAE5C,kDAAmC;;;;;IACnC,mDAAoC;;;;;IAEpC,oEAA2D;;;;;IAC3D,+DAAsD;;;;;IAEtD,yCAA0B;;;;;IAGxB,8CAA8C;;;;;IAC9C,uCAAwD","sourcesContent":["import { Injectable, Inject, EventEmitter } from '@angular/core';\nimport { FormConstructorService } from './form-constructor.service';\nimport { Questionnaire } from '../interfaces/questionnaire';\nimport { FormGroup, AbstractControl, FormArray, FormBuilder } from '@angular/forms';\nimport { Section } from '../interfaces/section';\nimport { Question } from '../interfaces/question';\nimport { Subscription } from 'rxjs';\nimport * as _ from 'lodash';\nimport { QuestionnaireOptions } from '../interfaces/questionnaire-options';\nimport { QuestionType } from '../enums/question-type.enum';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class QuestionnaireService {\n  public dataChangedEvent: EventEmitter<any> = new EventEmitter<any>();\n\n  private originalQuestionnaire: Questionnaire;\n\n  private currentQuestionnaire: Questionnaire;\n  private currentQuestionnaireForm: FormGroup;\n\n  private currentSectionName: string;\n  private currentQuestionName: string;\n\n  private questionnaireValueChangeSubscription: Subscription;\n  private questionValueChangeSubscription: Subscription;\n\n  private skippable = false;\n\n  constructor(\n    private formConstuctor: FormConstructorService,\n    @Inject('options') private options: QuestionnaireOptions\n  ) { }\n\n  /**\n   * Loads a questionnaire from data.\n   * @param questionnaire The questionnaire data to load, often parsed JSON from the editor.\n   * @param savedState The saved state of the questionnaire, often from localstorage.\n   * @returns null\n   * @author Will Poulson\n   */\n  public async loadQuestionnaire(questionnaire: Questionnaire, savedState?: Object): Promise<any> {\n    this.originalQuestionnaire = _.cloneDeep(questionnaire);\n    this.currentQuestionnaire = _.cloneDeep(questionnaire);\n\n    if (savedState && Object.keys(savedState).length > 0) {\n      const newData = this.formConstuctor.generateFormsForQuestionnaire(\n        _.cloneDeep(this.originalQuestionnaire),\n        this.currentQuestionnaireForm,\n        true\n      );\n      this.formConstuctor.constructRepeaterFromsFromState(savedState, newData.sections, newData.forms);\n      this.currentQuestionnaireForm = newData.forms;\n      this.currentQuestionnaireForm.patchValue(savedState);\n    }\n\n    await this.updateQuestionnaire(savedState);\n\n    for (const section of this.currentQuestionnaire.sections) {\n      for (const question of section.questions) {\n        const control = this.currentQuestionnaireForm.get([section.name, question.name]);\n        if (!control.value && question.defaultValue) {\n          control.setValue(question.defaultValue);\n        }\n      }\n    }\n\n    if (this.options.skipToFirstSection) {\n      this.currentSectionName = Object.keys(this.currentQuestionnaireForm.controls)[0];\n    }\n\n    if (this.options.skipToFirstQuestion) {\n      this.currentQuestionName = Object.keys(this.currentSection.formGroup.controls)[0];\n    }\n\n    return;\n  }\n\n  /**\n   * Updates the current questionnaire, used when a value is updated to check conditions.\n   * @param savedState The saved state of the questionnaire, often from localstorage.\n   * @returns null\n   * @author Will Poulson\n   */\n  public updateQuestionnaire(savedState?: Object): Promise<any> {\n    const newData = this.formConstuctor.generateFormsForQuestionnaire(\n      _.cloneDeep(this.originalQuestionnaire),\n      this.currentQuestionnaireForm\n    );\n    this.currentQuestionnaireForm = newData.forms;\n    this.currentQuestionnaire.sections = newData.sections;\n\n    if (savedState && Object.keys(savedState).length > 0) {\n      this.currentQuestionnaireForm.patchValue(savedState);\n    }\n\n    if (this.questionnaireValueChangeSubscription) {\n      this.questionnaireValueChangeSubscription.unsubscribe();\n    }\n\n    if (this.questionValueChangeSubscription) {\n      this.questionValueChangeSubscription.unsubscribe();\n    }\n\n    this.questionnaireValueChangeSubscription = this.currentQuestionnaireForm.valueChanges.subscribe(() => {\n      this.dataChangedEvent.emit();\n      this.updateQuestionnaire(this.currentQuestionnaireForm.getRawValue());\n    });\n\n    if (this.currentQuestion) {\n      this.questionValueChangeSubscription = this.currentQuestion.formControl.valueChanges.subscribe(() => {\n        this.clearFields(this.currentQuestion.data.clearfields);\n      });\n    }\n\n    return;\n  }\n\n  public get isValid() {\n    return this.currentQuestionnaireForm.valid;\n  }\n\n  public sectionValid(name: string) {\n    return this.currentQuestionnaireForm.get(name).valid;\n  }\n\n  /**\n   * Clears all the fields parsed\n   * @param clearfields An array of strings, paths to clear.\n   * @author Will Poulson\n   */\n  private clearFields(clearfields: Array<string>) {\n    if (!clearfields || clearfields.length === 0) {\n      return;\n    }\n\n    for (const clearfield of clearfields) {\n      const control = this.currentQuestionnaireForm.get(clearfield);\n\n      if (control) {\n        control.reset(undefined);\n      }\n    }\n  }\n\n  /**\n   * Unloads the current questionnaire.\n   * Useful when exiting a questionnaire page or completing a questionnaire.\n   * @author Will Poulson\n   */\n  public unloadQuestionnaire() {\n    this.originalQuestionnaire = undefined;\n    this.currentQuestionnaireForm = undefined;\n    this.currentQuestionnaire = undefined;\n    this.currentSectionName = undefined;\n    this.currentQuestionName = undefined;\n  }\n\n  /**\n   * Gets the current selected section.\n   * @returns An object containing the section data and the related form group.\n   * @author Will Poulson\n   */\n  public get currentSection(): { data: Section; formGroup: FormGroup; } | null {\n    if (!this.currentSectionName) {\n      return null;\n    }\n\n    const data = this.currentQuestionnaire.sections.find((x) => {\n      return x.name === this.currentSectionName;\n    });\n\n    if (!data) {\n      return null;\n    }\n\n    return {\n      data: data,\n      formGroup: this.currentQuestionnaireForm.get(data.name) as FormGroup\n    };\n  }\n\n  /**\n   * Gets all the avaialble sections.\n   * @returns An array of all avaialble sections.\n   * @author Will Poulson\n   */\n  public get availableSections(): Array<Section> {\n    if (!this.currentQuestionnaire || !this.currentQuestionnaire.sections) {\n      return [];\n    }\n    return this.currentQuestionnaire.sections;\n  }\n\n  /**\n   * Gets the current data for the entire questionnaire.\n   * @returns An object of data.\n   * @author Will Poulson\n   */\n  public get currentData() {\n    return this.currentQuestionnaireForm.getRawValue();\n  }\n\n\n  /**\n   * Gets the current selected question.\n   * @returns An object containing the question data and the related form control.\n   * @author Will Poulson\n   */\n  public get currentQuestion(): { data: Question; formControl: AbstractControl; } | null {\n    if (!this.currentQuestionName) {\n      return null;\n    }\n\n    const data = this.currentSection.data.questions.find((x) => {\n      return x.name === this.currentQuestionName;\n    });\n\n    if (!data) {\n      return null;\n    }\n\n    return {\n      data: data,\n      formControl: this.currentSection.formGroup.get(data.name) as AbstractControl\n    };\n  }\n\n  /**\n   * Navigates to the next question.\n   * If there is no question to navigate to it will reject with a out of bounds exception.\n   * If allowSkipRequiredField is false then it will reject if the current question is invalid.\n   * If emitSectionFinishEvent is true then it will emit an event if it's navigating past the length of questions.\n   * @returns A promise which will resolve when the question has been navigated to.\n   * @author Will Poulson\n   */\n  public nextQuestion() {\n    return new Promise((resolve, reject) => {\n      if (!this.options.allowSkipRequiredField) {\n        if (!this.currentQuestion.formControl.valid) {\n          return reject('Current question is invalid');\n        }\n      }\n\n      this.getCurrentQuestionIndex().then((currentIndex) => {\n        const newIndex = currentIndex + 1;\n\n        this.navigateToQuestion(newIndex).then(() => {\n          return resolve();\n        }).catch((error) => {\n          return reject(error);\n        });\n      }).catch((error) => {\n        return reject(error);\n      });\n    });\n  }\n\n  /**\n   * Navigates to the previous question.\n   * If there is no question to navigate to it will reject with a out of bounds exception.\n   * If allowNavigateBackwards is false then it will reject.\n   * @returns A promise which will resolve when the question has been navigated to.\n   * @author Will Poulson\n   */\n  public prevQuestion() {\n    return new Promise((resolve, reject) => {\n      if (!this.options.allowNavigateBackwards) {\n        return reject('This questionnaire does not allow for backwards navigation');\n      }\n\n      this.getCurrentQuestionIndex().then((currentIndex) => {\n        const newIndex = currentIndex - 1;\n\n        this.navigateToQuestion(newIndex).then(() => {\n          return resolve();\n        }).catch((error) => {\n          return reject(error);\n        });\n      }).catch((error) => {\n        return reject(error);\n      });\n    });\n  }\n\n  /**\n   * Gets the current questions index.\n   * @returns A promise which resolves a number.\n   * @author Will Poulson\n   */\n  private getCurrentQuestionIndex(): Promise<number> {\n    return new Promise((resolve, reject) => {\n      const currentIndex = this.currentSection.data.questions.indexOf(this.currentQuestion.data);\n\n      if (currentIndex === -1) {\n        return reject('Could not find current question');\n      }\n\n      return resolve(currentIndex);\n    });\n  }\n\n  /**\n   * Checks a question is in bounds then navigates to it.\n   * @param index The index to navigate to.\n   * @returns A promise which will resolve when the question has been navigated to.\n   * @author Will Poulson\n   */\n  public navigateToQuestion(index: number) {\n    return new Promise((resolve, reject) => {\n      if (this.currentSection.data.questions.length - 1 < index || index < 0) {\n        return reject('Out of bounds exception');\n      }\n\n      this.currentQuestionName = this.currentSection.data.questions[index].name;\n      return resolve();\n    });\n  }\n\n  /**\n   * Navigates to the next section.\n   * @returns A promise which will resolve when the section has been navigated to.\n   * @author Will Poulson\n   */\n  public nextSection() {\n    return new Promise((resolve, reject) => {\n      this.getCurrentSectionIndex().then((currentIndex) => {\n        const newIndex = currentIndex + 1;\n        this.navigateToSection(newIndex).then(() => {\n          return resolve();\n        }).catch((error) => {\n          return reject(error);\n        });\n      }).catch((error) => {\n        return reject(error);\n      });\n    });\n  }\n\n  /**\n   * Navigates to the previous section.\n   * @returns A promise which will resolve when the section has been navigated to.\n   * @author Will Poulson\n   */\n  public prevSection() {\n    return new Promise((resolve, reject) => {\n      this.getCurrentSectionIndex().then((currentIndex) => {\n        const newIndex = currentIndex - 1;\n        this.navigateToQuestion(newIndex).then(() => {\n          return resolve();\n        }).catch((error) => {\n          return reject(error);\n        });\n      }).catch((error) => {\n        return reject(error);\n      });\n    });\n  }\n\n  /**\n   * Gets the current section index.\n   * @returns A promise which resolves a number.\n   * @author Will Poulson\n   */\n  private getCurrentSectionIndex(): Promise<number> {\n    return new Promise((resolve, reject) => {\n      const currentIndex = this.currentQuestionnaire.sections.indexOf(this.currentSection.data);\n\n      if (currentIndex === -1) {\n        return reject('Could not find current section');\n      }\n\n      return resolve(currentIndex);\n    });\n  }\n\n  /**\n   * Checks a section is in bounds then navigates to it.\n   * @param index The index to navigate to.\n   * @returns A promise which will resolve when the section has been navigated to.\n   * @author Will Poulson\n   */\n  public navigateToSection(index: number) {\n    return new Promise((resolve, reject) => {\n      if (this.currentQuestionnaire.sections.length - 1 < index || index < 0) {\n        return reject('Out of bounds exception');\n      }\n\n      this.currentSectionName = this.currentQuestionnaire.sections[index].name;\n      return resolve();\n    });\n  }\n\n  /**\n   * Answers the current question with the parsed value.\n   * @param answer The value to answer the question with.\n   * @author Will Poulson\n   */\n  public answerCurrentQuestion(answer: any, sendToNextQuestion?: boolean) {\n    this.currentQuestion.formControl.setValue(answer);\n    if (sendToNextQuestion && this.skippable) { // Timeout to prevent skipping glitch.\n      this.skippable = false;\n      setTimeout(() => {\n        this.nextQuestion();\n        this.skippable = true;\n      }, 150);\n    }\n  }\n\n  /**\n   * Adds a repeater item to the current question.\n   * Current question must be of type Repeater.\n   * @returns A promise which resolves when the repeater item has been added.\n   * @author Will Poulson\n   */\n  public addRepeaterItem() {\n    return new Promise((resolve, reject) => {\n      if (this.currentQuestion.data.type !== QuestionType.Repeater) {\n        return reject(`Current question isn't a repeater`);\n      }\n      const repeaterForm = this.formConstuctor.generateFormsForRepeater(this.currentQuestion.data);\n\n      if (!repeaterForm) {\n        return reject(`Repeater template failed to generate. May be due to the repeater having no items in the editor.`);\n      }\n\n\n      if (!(this.currentQuestion.formControl instanceof FormArray)) {\n        return reject(`The current questions control isn't of type FormArray`);\n      }\n\n      this.currentQuestion.formControl.push(repeaterForm);\n      return resolve();\n    });\n  }\n\n  /**\n   * Removes a repeater item on the current question.\n   * Current question must be of type Repeater.\n   * @param index The index at which to remove.\n   * @returns A promise which resolves when the repeater item has been removed.\n   * @author Will Poulson\n   */\n  public removeRepeaterItem(index: number) {\n    return new Promise((resolve, reject) => {\n      if (this.currentQuestion.data.type !== QuestionType.Repeater) {\n        return reject(`Current question isn't a repeater`);\n      }\n\n      if (!(this.currentQuestion.formControl instanceof FormArray)) {\n        return reject(`The current questions control isn't of type FormArray`);\n      }\n\n      this.currentQuestion.formControl.removeAt(index);\n      return resolve();\n    });\n  }\n\n  /**\n   * Returns the display text for a given repeater item\n   * @param index The index at which to get the label for.\n   * @returns A string which is the display text.\n   * @author Will Poulson\n   */\n  public getRepeaterItemLabel(index: number): string {\n    if (!this.currentQuestion.formControl || !(this.currentQuestion.formControl instanceof FormArray)) {\n      return '';\n    }\n\n    const repeaterItem = this.currentQuestion.formControl.controls[index];\n\n    if (!repeaterItem) {\n      return '';\n    }\n\n    const template = this.currentQuestion.data.repeaterDisplayName;\n    const splitTemplate = template.split(' ');\n\n    const displayArray = [];\n    for (const templateItem of splitTemplate) {\n      if (templateItem.match(/\\[.*?\\]/)) {\n        const path = templateItem.replace(/[\\[\\]']+/g, '');\n        const item = repeaterItem.get(path);\n        const value = item.value ? item.value : '?';\n        displayArray.push(value);\n      } else {\n        displayArray.push(templateItem);\n      }\n    }\n\n    const display = displayArray.join(' ');\n    return display;\n  }\n}\n"]}