@glowgreen/gg-questionnaire-v2 0.0.1

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

@@ -0,0 +1,943 @@
+/**
+ * @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";
+var QuestionnaireService = /** @class */ (function () {
+    function QuestionnaireService(formConstuctor, options) {
+        this.formConstuctor = formConstuctor;
+        this.options = options;
+        this.dataChangedEvent = new EventEmitter();
+        this.skippable = false;
+    }
+    /**
+     * Loads a questionnaire from data.
+     * @param questionnaire The questionnaire data to load, often parsed JSON from the editor.
+     * @param savedState The saved state of the questionnaire, often from localstorage.
+     * @returns null
+     * @author Will Poulson
+     */
+    /**
+     * 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
+     */
+    QuestionnaireService.prototype.loadQuestionnaire = /**
+     * 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
+     */
+    function (questionnaire, savedState) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var e_1, _a, e_2, _b, newData, _c, _d, section, _e, _f, question, control;
+            return tslib_1.__generator(this, function (_g) {
+                switch (_g.label) {
+                    case 0:
+                        this.originalQuestionnaire = _.cloneDeep(questionnaire);
+                        this.currentQuestionnaire = _.cloneDeep(questionnaire);
+                        if (savedState && Object.keys(savedState).length > 0) {
+                            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);
+                        }
+                        return [4 /*yield*/, this.updateQuestionnaire(savedState)];
+                    case 1:
+                        _g.sent();
+                        try {
+                            for (_c = tslib_1.__values(this.currentQuestionnaire.sections), _d = _c.next(); !_d.done; _d = _c.next()) {
+                                section = _d.value;
+                                try {
+                                    for (_e = tslib_1.__values(section.questions), _f = _e.next(); !_f.done; _f = _e.next()) {
+                                        question = _f.value;
+                                        control = this.currentQuestionnaireForm.get([section.name, question.name]);
+                                        if (!control.value && question.defaultValue) {
+                                            control.setValue(question.defaultValue);
+                                        }
+                                    }
+                                }
+                                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                                finally {
+                                    try {
+                                        if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                                    }
+                                    finally { if (e_2) throw e_2.error; }
+                                }
+                            }
+                        }
+                        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                        finally {
+                            try {
+                                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+                            }
+                            finally { if (e_1) throw e_1.error; }
+                        }
+                        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 [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Updates the current questionnaire, used when a value is updated to check conditions.
+     * @param savedState The saved state of the questionnaire, often from localstorage.
+     * @returns null
+     * @author Will Poulson
+     */
+    /**
+     * 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
+     */
+    QuestionnaireService.prototype.updateQuestionnaire = /**
+     * 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
+     */
+    function (savedState) {
+        var _this = this;
+        /** @type {?} */
+        var 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 {?}
+         */
+        function () {
+            _this.dataChangedEvent.emit();
+            _this.updateQuestionnaire(_this.currentQuestionnaireForm.getRawValue());
+        }));
+        if (this.currentQuestion) {
+            this.questionValueChangeSubscription = this.currentQuestion.formControl.valueChanges.subscribe((/**
+             * @return {?}
+             */
+            function () {
+                _this.clearFields(_this.currentQuestion.data.clearfields);
+            }));
+        }
+        return;
+    };
+    Object.defineProperty(QuestionnaireService.prototype, "isValid", {
+        get: /**
+         * @return {?}
+         */
+        function () {
+            return this.currentQuestionnaireForm.valid;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @param {?} name
+     * @return {?}
+     */
+    QuestionnaireService.prototype.sectionValid = /**
+     * @param {?} name
+     * @return {?}
+     */
+    function (name) {
+        return this.currentQuestionnaireForm.get(name).valid;
+    };
+    /**
+     * Clears all the fields parsed
+     * @param clearfields An array of strings, paths to clear.
+     * @author Will Poulson
+     */
+    /**
+     * Clears all the fields parsed
+     * @author Will Poulson
+     * @private
+     * @param {?} clearfields An array of strings, paths to clear.
+     * @return {?}
+     */
+    QuestionnaireService.prototype.clearFields = /**
+     * Clears all the fields parsed
+     * @author Will Poulson
+     * @private
+     * @param {?} clearfields An array of strings, paths to clear.
+     * @return {?}
+     */
+    function (clearfields) {
+        var e_3, _a;
+        if (!clearfields || clearfields.length === 0) {
+            return;
+        }
+        try {
+            for (var clearfields_1 = tslib_1.__values(clearfields), clearfields_1_1 = clearfields_1.next(); !clearfields_1_1.done; clearfields_1_1 = clearfields_1.next()) {
+                var clearfield = clearfields_1_1.value;
+                /** @type {?} */
+                var control = this.currentQuestionnaireForm.get(clearfield);
+                if (control) {
+                    control.reset(undefined);
+                }
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (clearfields_1_1 && !clearfields_1_1.done && (_a = clearfields_1.return)) _a.call(clearfields_1);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+    };
+    /**
+     * Unloads the current questionnaire.
+     * Useful when exiting a questionnaire page or completing a questionnaire.
+     * @author Will Poulson
+     */
+    /**
+     * Unloads the current questionnaire.
+     * Useful when exiting a questionnaire page or completing a questionnaire.
+     * @author Will Poulson
+     * @return {?}
+     */
+    QuestionnaireService.prototype.unloadQuestionnaire = /**
+     * Unloads the current questionnaire.
+     * Useful when exiting a questionnaire page or completing a questionnaire.
+     * @author Will Poulson
+     * @return {?}
+     */
+    function () {
+        this.originalQuestionnaire = undefined;
+        this.currentQuestionnaireForm = undefined;
+        this.currentQuestionnaire = undefined;
+        this.currentSectionName = undefined;
+        this.currentQuestionName = undefined;
+    };
+    Object.defineProperty(QuestionnaireService.prototype, "currentSection", {
+        /**
+         * Gets the current selected section.
+         * @returns An object containing the section data and the related form group.
+         * @author Will Poulson
+         */
+        get: /**
+         * Gets the current selected section.
+         * @author Will Poulson
+         * @return {?} An object containing the section data and the related form group.
+         */
+        function () {
+            var _this = this;
+            if (!this.currentSectionName) {
+                return null;
+            }
+            /** @type {?} */
+            var data = this.currentQuestionnaire.sections.find((/**
+             * @param {?} x
+             * @return {?}
+             */
+            function (x) {
+                return x.name === _this.currentSectionName;
+            }));
+            if (!data) {
+                return null;
+            }
+            return {
+                data: data,
+                formGroup: (/** @type {?} */ (this.currentQuestionnaireForm.get(data.name)))
+            };
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(QuestionnaireService.prototype, "availableSections", {
+        /**
+         * Gets all the avaialble sections.
+         * @returns An array of all avaialble sections.
+         * @author Will Poulson
+         */
+        get: /**
+         * Gets all the avaialble sections.
+         * @author Will Poulson
+         * @return {?} An array of all avaialble sections.
+         */
+        function () {
+            if (!this.currentQuestionnaire || !this.currentQuestionnaire.sections) {
+                return [];
+            }
+            return this.currentQuestionnaire.sections;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(QuestionnaireService.prototype, "currentData", {
+        /**
+         * Gets the current data for the entire questionnaire.
+         * @returns An object of data.
+         * @author Will Poulson
+         */
+        get: /**
+         * Gets the current data for the entire questionnaire.
+         * @author Will Poulson
+         * @return {?} An object of data.
+         */
+        function () {
+            return this.currentQuestionnaireForm.getRawValue();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(QuestionnaireService.prototype, "currentQuestion", {
+        /**
+         * Gets the current selected question.
+         * @returns An object containing the question data and the related form control.
+         * @author Will Poulson
+         */
+        get: /**
+         * Gets the current selected question.
+         * @author Will Poulson
+         * @return {?} An object containing the question data and the related form control.
+         */
+        function () {
+            var _this = this;
+            if (!this.currentQuestionName) {
+                return null;
+            }
+            /** @type {?} */
+            var data = this.currentSection.data.questions.find((/**
+             * @param {?} x
+             * @return {?}
+             */
+            function (x) {
+                return x.name === _this.currentQuestionName;
+            }));
+            if (!data) {
+                return null;
+            }
+            return {
+                data: data,
+                formControl: (/** @type {?} */ (this.currentSection.formGroup.get(data.name)))
+            };
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * 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.
+     * @returns A promise which will resolve when the question has been navigated to.
+     * @author Will Poulson
+     */
+    /**
+     * 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.
+     */
+    QuestionnaireService.prototype.nextQuestion = /**
+     * 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.
+     */
+    function () {
+        var _this = this;
+        return new Promise((/**
+         * @param {?} resolve
+         * @param {?} reject
+         * @return {?}
+         */
+        function (resolve, reject) {
+            if (!_this.options.allowSkipRequiredField) {
+                if (!_this.currentQuestion.formControl.valid) {
+                    return reject('Current question is invalid');
+                }
+            }
+            _this.getCurrentQuestionIndex().then((/**
+             * @param {?} currentIndex
+             * @return {?}
+             */
+            function (currentIndex) {
+                /** @type {?} */
+                var newIndex = currentIndex + 1;
+                _this.navigateToQuestion(newIndex).then((/**
+                 * @return {?}
+                 */
+                function () {
+                    return resolve();
+                })).catch((/**
+                 * @param {?} error
+                 * @return {?}
+                 */
+                function (error) {
+                    return reject(error);
+                }));
+            })).catch((/**
+             * @param {?} error
+             * @return {?}
+             */
+            function (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.
+     * @returns A promise which will resolve when the question has been navigated to.
+     * @author Will Poulson
+     */
+    /**
+     * 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.
+     */
+    QuestionnaireService.prototype.prevQuestion = /**
+     * 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.
+     */
+    function () {
+        var _this = this;
+        return new Promise((/**
+         * @param {?} resolve
+         * @param {?} reject
+         * @return {?}
+         */
+        function (resolve, reject) {
+            if (!_this.options.allowNavigateBackwards) {
+                return reject('This questionnaire does not allow for backwards navigation');
+            }
+            _this.getCurrentQuestionIndex().then((/**
+             * @param {?} currentIndex
+             * @return {?}
+             */
+            function (currentIndex) {
+                /** @type {?} */
+                var newIndex = currentIndex - 1;
+                _this.navigateToQuestion(newIndex).then((/**
+                 * @return {?}
+                 */
+                function () {
+                    return resolve();
+                })).catch((/**
+                 * @param {?} error
+                 * @return {?}
+                 */
+                function (error) {
+                    return reject(error);
+                }));
+            })).catch((/**
+             * @param {?} error
+             * @return {?}
+             */
+            function (error) {
+                return reject(error);
+            }));
+        }));
+    };
+    /**
+     * Gets the current questions index.
+     * @returns A promise which resolves a number.
+     * @author Will Poulson
+     */
+    /**
+     * Gets the current questions index.
+     * @author Will Poulson
+     * @private
+     * @return {?} A promise which resolves a number.
+     */
+    QuestionnaireService.prototype.getCurrentQuestionIndex = /**
+     * Gets the current questions index.
+     * @author Will Poulson
+     * @private
+     * @return {?} A promise which resolves a number.
+     */
+    function () {
+        var _this = this;
+        return new Promise((/**
+         * @param {?} resolve
+         * @param {?} reject
+         * @return {?}
+         */
+        function (resolve, reject) {
+            /** @type {?} */
+            var 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.
+     * @param index The index to navigate to.
+     * @returns A promise which will resolve when the question has been navigated to.
+     * @author Will Poulson
+     */
+    /**
+     * 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.
+     */
+    QuestionnaireService.prototype.navigateToQuestion = /**
+     * 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.
+     */
+    function (index) {
+        var _this = this;
+        return new Promise((/**
+         * @param {?} resolve
+         * @param {?} reject
+         * @return {?}
+         */
+        function (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.
+     * @returns A promise which will resolve when the section has been navigated to.
+     * @author Will Poulson
+     */
+    /**
+     * Navigates to the next section.
+     * @author Will Poulson
+     * @return {?} A promise which will resolve when the section has been navigated to.
+     */
+    QuestionnaireService.prototype.nextSection = /**
+     * Navigates to the next section.
+     * @author Will Poulson
+     * @return {?} A promise which will resolve when the section has been navigated to.
+     */
+    function () {
+        var _this = this;
+        return new Promise((/**
+         * @param {?} resolve
+         * @param {?} reject
+         * @return {?}
+         */
+        function (resolve, reject) {
+            _this.getCurrentSectionIndex().then((/**
+             * @param {?} currentIndex
+             * @return {?}
+             */
+            function (currentIndex) {
+                /** @type {?} */
+                var newIndex = currentIndex + 1;
+                _this.navigateToSection(newIndex).then((/**
+                 * @return {?}
+                 */
+                function () {
+                    return resolve();
+                })).catch((/**
+                 * @param {?} error
+                 * @return {?}
+                 */
+                function (error) {
+                    return reject(error);
+                }));
+            })).catch((/**
+             * @param {?} error
+             * @return {?}
+             */
+            function (error) {
+                return reject(error);
+            }));
+        }));
+    };
+    /**
+     * Navigates to the previous section.
+     * @returns A promise which will resolve when the section has been navigated to.
+     * @author Will Poulson
+     */
+    /**
+     * Navigates to the previous section.
+     * @author Will Poulson
+     * @return {?} A promise which will resolve when the section has been navigated to.
+     */
+    QuestionnaireService.prototype.prevSection = /**
+     * Navigates to the previous section.
+     * @author Will Poulson
+     * @return {?} A promise which will resolve when the section has been navigated to.
+     */
+    function () {
+        var _this = this;
+        return new Promise((/**
+         * @param {?} resolve
+         * @param {?} reject
+         * @return {?}
+         */
+        function (resolve, reject) {
+            _this.getCurrentSectionIndex().then((/**
+             * @param {?} currentIndex
+             * @return {?}
+             */
+            function (currentIndex) {
+                /** @type {?} */
+                var newIndex = currentIndex - 1;
+                _this.navigateToQuestion(newIndex).then((/**
+                 * @return {?}
+                 */
+                function () {
+                    return resolve();
+                })).catch((/**
+                 * @param {?} error
+                 * @return {?}
+                 */
+                function (error) {
+                    return reject(error);
+                }));
+            })).catch((/**
+             * @param {?} error
+             * @return {?}
+             */
+            function (error) {
+                return reject(error);
+            }));
+        }));
+    };
+    /**
+     * Gets the current section index.
+     * @returns A promise which resolves a number.
+     * @author Will Poulson
+     */
+    /**
+     * Gets the current section index.
+     * @author Will Poulson
+     * @private
+     * @return {?} A promise which resolves a number.
+     */
+    QuestionnaireService.prototype.getCurrentSectionIndex = /**
+     * Gets the current section index.
+     * @author Will Poulson
+     * @private
+     * @return {?} A promise which resolves a number.
+     */
+    function () {
+        var _this = this;
+        return new Promise((/**
+         * @param {?} resolve
+         * @param {?} reject
+         * @return {?}
+         */
+        function (resolve, reject) {
+            /** @type {?} */
+            var 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.
+     * @param index The index to navigate to.
+     * @returns A promise which will resolve when the section has been navigated to.
+     * @author Will Poulson
+     */
+    /**
+     * 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.
+     */
+    QuestionnaireService.prototype.navigateToSection = /**
+     * 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.
+     */
+    function (index) {
+        var _this = this;
+        return new Promise((/**
+         * @param {?} resolve
+         * @param {?} reject
+         * @return {?}
+         */
+        function (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.
+     * @param answer The value to answer the question with.
+     * @author Will Poulson
+     */
+    /**
+     * Answers the current question with the parsed value.
+     * @author Will Poulson
+     * @param {?} answer The value to answer the question with.
+     * @param {?=} sendToNextQuestion
+     * @return {?}
+     */
+    QuestionnaireService.prototype.answerCurrentQuestion = /**
+     * Answers the current question with the parsed value.
+     * @author Will Poulson
+     * @param {?} answer The value to answer the question with.
+     * @param {?=} sendToNextQuestion
+     * @return {?}
+     */
+    function (answer, sendToNextQuestion) {
+        var _this = this;
+        this.currentQuestion.formControl.setValue(answer);
+        if (sendToNextQuestion && this.skippable) { // Timeout to prevent skipping glitch.
+            this.skippable = false;
+            setTimeout((/**
+             * @return {?}
+             */
+            function () {
+                _this.nextQuestion();
+                _this.skippable = true;
+            }), 150);
+        }
+    };
+    /**
+     * Adds a repeater item to the current question.
+     * Current question must be of type Repeater.
+     * @returns A promise which resolves when the repeater item has been added.
+     * @author Will Poulson
+     */
+    /**
+     * 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.
+     */
+    QuestionnaireService.prototype.addRepeaterItem = /**
+     * 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.
+     */
+    function () {
+        var _this = this;
+        return new Promise((/**
+         * @param {?} resolve
+         * @param {?} reject
+         * @return {?}
+         */
+        function (resolve, reject) {
+            if (_this.currentQuestion.data.type !== QuestionType.Repeater) {
+                return reject("Current question isn't a repeater");
+            }
+            /** @type {?} */
+            var 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.
+     * @param index The index at which to remove.
+     * @returns A promise which resolves when the repeater item has been removed.
+     * @author Will Poulson
+     */
+    /**
+     * 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.
+     */
+    QuestionnaireService.prototype.removeRepeaterItem = /**
+     * 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.
+     */
+    function (index) {
+        var _this = this;
+        return new Promise((/**
+         * @param {?} resolve
+         * @param {?} reject
+         * @return {?}
+         */
+        function (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
+     * @param index The index at which to get the label for.
+     * @returns A string which is the display text.
+     * @author Will Poulson
+     */
+    /**
+     * 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.
+     */
+    QuestionnaireService.prototype.getRepeaterItemLabel = /**
+     * 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.
+     */
+    function (index) {
+        var e_4, _a;
+        if (!this.currentQuestion.formControl || !(this.currentQuestion.formControl instanceof FormArray)) {
+            return '';
+        }
+        /** @type {?} */
+        var repeaterItem = this.currentQuestion.formControl.controls[index];
+        if (!repeaterItem) {
+            return '';
+        }
+        /** @type {?} */
+        var template = this.currentQuestion.data.repeaterDisplayName;
+        /** @type {?} */
+        var splitTemplate = template.split(' ');
+        /** @type {?} */
+        var displayArray = [];
+        try {
+            for (var splitTemplate_1 = tslib_1.__values(splitTemplate), splitTemplate_1_1 = splitTemplate_1.next(); !splitTemplate_1_1.done; splitTemplate_1_1 = splitTemplate_1.next()) {
+                var templateItem = splitTemplate_1_1.value;
+                if (templateItem.match(/\[.*?\]/)) {
+                    /** @type {?} */
+                    var path = templateItem.replace(/[\[\]']+/g, '');
+                    /** @type {?} */
+                    var item = repeaterItem.get(path);
+                    /** @type {?} */
+                    var value = item.value ? item.value : '?';
+                    displayArray.push(value);
+                }
+                else {
+                    displayArray.push(templateItem);
+                }
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (splitTemplate_1_1 && !splitTemplate_1_1.done && (_a = splitTemplate_1.return)) _a.call(splitTemplate_1);
+            }
+            finally { if (e_4) throw e_4.error; }
+        }
+        /** @type {?} */
+        var display = displayArray.join(' ');
+        return display;
+    };
+    QuestionnaireService.decorators = [
+        { type: Injectable, args: [{
+                    providedIn: 'root'
+                },] }
+    ];
+    /** @nocollapse */
+    QuestionnaireService.ctorParameters = function () { return [
+        { 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" });
+    return QuestionnaireService;
+}());
+export { QuestionnaireService };
+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":"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","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"]}