@glowgreen/gg-questionnaire-v2 0.0.1

package/fesm2015/glowgreen-gg-questionnaire-v2.js

@@ -0,0 +1,1194 @@
+import { __awaiter } from 'tslib';
+import { cloneDeep } from 'lodash';
+import { Injectable, NgModule, defineInjectable, inject, EventEmitter, Inject } from '@angular/core';
+import { FormBuilder, Validators, FormsModule, ReactiveFormsModule, FormArray } from '@angular/forms';
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/** @enum {string} */
+const QuestionType = {
+    Input: 'input',
+    Select: 'select',
+    Textarea: 'textarea',
+    Repeater: 'repeater',
+    Checklist: 'checklist',
+    Attachment: 'attachment',
+    Upload: 'upload',
+    Signature: 'signature',
+};
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/** @enum {string} */
+const ConditionType = {
+    EqualTo: 'equalTo',
+    NotEqualTo: 'notEqualTo',
+    LessThan: 'lessThan',
+    GreaterThan: 'greaterThan',
+    Includes: 'includes',
+    Excludes: 'excludes',
+};
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/** @enum {string} */
+const ConditionRelationship = {
+    Every: 'every',
+    Any: 'any',
+};
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+class FilterService {
+    constructor() { }
+    /**
+     * Filters an array of sections based on their condition groups.
+     * @author Will Poulson
+     * @param {?} sections The array of sections to filter.
+     * @param {?} currentQuestionnaireForm The current form data, can be null/undefined.
+     * @return {?} An array of filtered sections with their filtered questions.
+     */
+    filterSections(sections, currentQuestionnaireForm) {
+        /** @type {?} */
+        const filteredSections = [];
+        for (const section of sections) {
+            if (this.meetsConditionGroups(section.conditionGroups, currentQuestionnaireForm)) {
+                /** @type {?} */
+                const filteredQuestions = [];
+                for (const question of section.questions) {
+                    if (this.meetsConditionGroups(question.conditionGroups, currentQuestionnaireForm)) {
+                        if (question.repeaterQuestions) {
+                            for (const repeaterQuestion of question.repeaterQuestions) {
+                                if (this.meetsConditionGroups(repeaterQuestion.conditionGroups, currentQuestionnaireForm)) ;
+                            }
+                        }
+                        filteredQuestions.push(question);
+                    }
+                }
+                section.questions = filteredQuestions;
+                filteredSections.push(section);
+            }
+        }
+        return filteredSections;
+    }
+    /**
+     * Checks if each condition groups conditions have been met.
+     * @author Will Poulson
+     * @private
+     * @param {?} conditionGroups The array of condition groups.
+     * @param {?} currentQuestionnaireForm The current form data, can be null/undefined.
+     * @return {?} A boolean stating if the condition groups conditions has been met.
+     */
+    meetsConditionGroups(conditionGroups, currentQuestionnaireForm) {
+        if (!conditionGroups || conditionGroups.length === 0) {
+            return true;
+        }
+        return conditionGroups.every((/**
+         * @param {?} x
+         * @return {?}
+         */
+        (x) => {
+            return this.meetsConditionGroup(x, currentQuestionnaireForm) === true;
+        }));
+    }
+    /**
+     * Checks if a condition groups conditions have been met.
+     * @author Will Poulson
+     * @private
+     * @param {?} conditionGroup The condition group to check.
+     * @param {?} currentQuestionnaireForm The current form data, can be null/undefined.
+     * @return {?} A boolean stating if the condition group conditions has been met.
+     */
+    meetsConditionGroup(conditionGroup, currentQuestionnaireForm) {
+        if (!conditionGroup.conditions || conditionGroup.conditions.length === 0) {
+            return true;
+        }
+        /** @type {?} */
+        const results = [];
+        for (const condition of conditionGroup.conditions) {
+            results.push(this.meetsCondition(condition, currentQuestionnaireForm));
+        }
+        switch (conditionGroup.relationship) {
+            case ConditionRelationship.Every:
+                return results.every((/**
+                 * @param {?} x
+                 * @return {?}
+                 */
+                (x) => {
+                    return x === true;
+                }));
+            case ConditionRelationship.Any:
+                return !!results.find((/**
+                 * @param {?} x
+                 * @return {?}
+                 */
+                (x) => {
+                    return x === true;
+                }));
+            default:
+                return true;
+        }
+    }
+    /**
+     * Checks if a condition has been met.
+     * @author Will Poulson
+     * @private
+     * @param {?} condition The condition to check.
+     * @param {?} currentQuestionnaireForm The current form data, can be null/undefined.
+     * @return {?} A boolean stating if the condition group conditions has been met.
+     */
+    meetsCondition(condition, currentQuestionnaireForm) {
+        /** @type {?} */
+        const v1s = this.getValuesForArray(condition.v1s, currentQuestionnaireForm);
+        /** @type {?} */
+        const v2s = this.getValuesForArray(condition.v2s, currentQuestionnaireForm);
+        /** @type {?} */
+        let result = false;
+        switch (condition.type) {
+            case ConditionType.Excludes:
+                result = v1s.filter((/**
+                 * @param {?} v1
+                 * @return {?}
+                 */
+                (v1) => {
+                    return v2s.indexOf(v1) > -1;
+                })).length === 0;
+                break;
+            case ConditionType.Includes:
+                result = v1s.filter((/**
+                 * @param {?} v1
+                 * @return {?}
+                 */
+                (v1) => {
+                    return v2s.indexOf(v1) > -1;
+                })).length !== 0;
+                break;
+            default:
+                for (let v2 of v2s) {
+                    for (let v1 of v1s) {
+                        switch (condition.type) {
+                            case ConditionType.EqualTo:
+                                v1 = this.getStringForValue(v1);
+                                v2 = this.getStringForValue(v2);
+                                if (v1 === v2) {
+                                    result = true;
+                                }
+                                break;
+                            case ConditionType.NotEqualTo:
+                                v1 = this.getStringForValue(v1);
+                                v2 = this.getStringForValue(v2);
+                                if (v1 !== v2) {
+                                    result = true;
+                                }
+                                break;
+                            case ConditionType.GreaterThan:
+                                v1 = parseFloat(v1);
+                                v2 = parseFloat(v2);
+                                if (v1 >= v2) {
+                                    result = true;
+                                }
+                                break;
+                            case ConditionType.LessThan:
+                                v1 = parseFloat(v1);
+                                v2 = parseFloat(v2);
+                                if (v1 <= v2) {
+                                    result = true;
+                                }
+                                break;
+                        }
+                    }
+                }
+        }
+        return result;
+    }
+    /**
+     * @private
+     * @param {?} value
+     * @return {?}
+     */
+    getStringForValue(value) {
+        switch (value) {
+            case null:
+                return 'null';
+            default:
+                return value.toString();
+        }
+    }
+    /**
+     * Gets the current values for an array of strings.
+     * @author Will Poulson
+     * @private
+     * @param {?} paths The array of strings to check.
+     * @param {?} currentQuestionnaireForm The current form data, can be null/undefined.
+     * @return {?} An array of strings/values
+     */
+    getValuesForArray(paths, currentQuestionnaireForm) {
+        if (currentQuestionnaireForm) {
+            /** @type {?} */
+            const values = [];
+            for (const path of paths) {
+                /** @type {?} */
+                const value = this.getValueForString(path, currentQuestionnaireForm);
+                values.push(value);
+            }
+            return values;
+        }
+        else {
+            return paths;
+        }
+    }
+    /**
+     * Gets a current value for a string.
+     * @author Will Poulson
+     * @private
+     * @param {?} path The string value to check.
+     * @param {?} currentQuestionnaireForm The current form data, can be null/undefined.
+     * @return {?} A string/value.
+     */
+    getValueForString(path, currentQuestionnaireForm) {
+        if (currentQuestionnaireForm) {
+            /** @type {?} */
+            const control = currentQuestionnaireForm.get(path);
+            return control ? control.value : this.convertStringToValue(path);
+        }
+        else {
+            return this.convertStringToValue(path);
+        }
+    }
+    /**
+     * Converts a string to a value.
+     * Eg. true/false.
+     * @author Will Poulson
+     * @private
+     * @param {?} path The string value to check for conversion;
+     * @return {?} Either a string or the converted value.
+     */
+    convertStringToValue(path) {
+        switch (path) {
+            case 'true':
+                return true;
+            case 'false':
+                return false;
+            case 'null':
+                return null;
+            default:
+                return path;
+        }
+    }
+}
+FilterService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+/** @nocollapse */
+FilterService.ctorParameters = () => [];
+/** @nocollapse */ FilterService.ngInjectableDef = defineInjectable({ factory: function FilterService_Factory() { return new FilterService(); }, token: FilterService, providedIn: "root" });
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/** @enum {string} */
+const ValidationType = {
+    Required: 'required',
+    Boolean: 'boolean',
+    Number: 'number',
+    String: 'string',
+    Email: 'email',
+    Telephone: 'telephone',
+};
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+class FormConstructorService {
+    /**
+     * @param {?} fb
+     * @param {?} filterService
+     */
+    constructor(fb, filterService) {
+        this.fb = fb;
+        this.filterService = filterService;
+    }
+    /**
+     * Constructs a form group based on the questionnaire data.
+     * This form group has been filtered down based on the conditions of the sections and questions.
+     * @author Will Poulson
+     * @param {?} questionnaire The questionnaire data to build the form group on.
+     * @param {?} currentQuestionnaireForm
+     * @param {?=} skipFilter
+     * @return {?} A filted form group.
+     */
+    generateFormsForQuestionnaire(questionnaire, currentQuestionnaireForm, skipFilter) {
+        /** @type {?} */
+        const sections = skipFilter ?
+            questionnaire.sections :
+            this.filterService.filterSections(questionnaire.sections, currentQuestionnaireForm);
+        /** @type {?} */
+        const questionnaireForms = this.generateFormsForSections(sections, currentQuestionnaireForm);
+        return { sections: sections, forms: questionnaireForms };
+    }
+    /**
+     * @private
+     * @param {?} sections
+     * @param {?} currentQuestionnaireForm
+     * @return {?}
+     */
+    generateFormsForSections(sections, currentQuestionnaireForm) {
+        /** @type {?} */
+        const questionnaireForms = this.fb.group({});
+        for (const section of sections) {
+            /** @type {?} */
+            const sectionForms = this.generateFormsForSection(section, currentQuestionnaireForm);
+            questionnaireForms.addControl(section.name, sectionForms);
+        }
+        return questionnaireForms;
+    }
+    /**
+     * Constructs a form group based on the section data.
+     * This form group has been filtered down based on the conditions of the questions.
+     * @author Will Poulson
+     * @private
+     * @param {?} section The section data to build the form group on.
+     * @param {?} currentQuestionnaireForm
+     * @return {?} A filtered form group.
+     */
+    generateFormsForSection(section, currentQuestionnaireForm) {
+        /** @type {?} */
+        const sectionForms = this.fb.group({});
+        for (const question of section.questions) {
+            /** @type {?} */
+            const questionControl = this.generateControlForQuestion(question, section, currentQuestionnaireForm);
+            sectionForms.addControl(question.name, questionControl);
+        }
+        return sectionForms;
+    }
+    /**
+     * Constructs an astract form control based on the question data.
+     * @author Will Poulson
+     * @private
+     * @param {?} question The question data to build the abstract control on.
+     * @param {?} section
+     * @param {?} currentQuestionnaireForm
+     * @return {?} An abstract control.
+     */
+    generateControlForQuestion(question, section, currentQuestionnaireForm) {
+        /** @type {?} */
+        const convertedValidators = this.convertValidators(question.validators);
+        switch (question.type) {
+            case QuestionType.Repeater:
+                /** @type {?} */
+                const currentArray = currentQuestionnaireForm ? ((/** @type {?} */ (currentQuestionnaireForm.get([section.name, question.name])))) : false;
+                /** @type {?} */
+                const newArray = currentArray ? currentArray.controls : [];
+                return this.fb.array(newArray, convertedValidators);
+            case QuestionType.Checklist:
+                return this.generateGroupForChecklist(question, convertedValidators);
+            default:
+                return this.fb.control(null, { validators: convertedValidators, updateOn: 'blur' });
+        }
+    }
+    /**
+     * Generates the form group for a checklist question.
+     * @author Will Poulson
+     * @private
+     * @param {?} question The question. Must be of type checklist or else null is returned.
+     * @param {?} convertedValidators
+     * @return {?} A form group.
+     */
+    generateGroupForChecklist(question, convertedValidators) {
+        if (question.type !== QuestionType.Checklist || question.checklistItems.length === 0) {
+            return null;
+        }
+        /** @type {?} */
+        const checklistForms = this.fb.group({}, convertedValidators);
+        for (const checklistItem of question.checklistItems) {
+            /** @type {?} */
+            const checklistItemControl = this.fb.control(false, { updateOn: 'blur' });
+            checklistForms.addControl(checklistItem.name, checklistItemControl);
+        }
+        return checklistForms;
+    }
+    /**
+     * Generates the form template for a repeater question.
+     * @author Will Poulson
+     * @param {?} question The question. Must be of type repeater or else null is returned.
+     * @return {?} A form group.
+     */
+    generateFormsForRepeater(question) {
+        if (question.type !== QuestionType.Repeater || question.repeaterQuestions.length === 0) {
+            console.log('Question isnt a repeater or has no questions, returning null');
+            return null;
+        }
+        /** @type {?} */
+        const repeaterForms = this.fb.group({});
+        for (const repeaterQuestion of question.repeaterQuestions) {
+            /** @type {?} */
+            const repeaterQuestionControl = this.generateControlForRepeaterQuestion(repeaterQuestion);
+            repeaterForms.addControl(repeaterQuestion.name, repeaterQuestionControl);
+        }
+        return repeaterForms;
+    }
+    /**
+     * Generates a control for a repeaters question.
+     * @author Will Poulson
+     * @private
+     * @param {?} repeaterQuestion A repeater question.
+     * @return {?} An abstract control.
+     */
+    generateControlForRepeaterQuestion(repeaterQuestion) {
+        /** @type {?} */
+        const convertedValidators = this.convertValidators(repeaterQuestion.validators);
+        return this.fb.control(null, { validators: convertedValidators, updateOn: 'blur' });
+    }
+    /**
+     * Converts an array of validators into form validators.
+     * @author Will Poulson
+     * @private
+     * @param {?} validators The uncoverted array of validators.
+     * @return {?} A convered array of form validators.
+     */
+    convertValidators(validators) {
+        if (!validators || validators.length === 0) {
+            return [];
+        }
+        /** @type {?} */
+        const convertedValidators = [];
+        for (const validator of validators) {
+            /** @type {?} */
+            const convertedValidator = this.convertValidator(validator);
+            if (convertedValidator) {
+                convertedValidators.push(convertedValidator);
+            }
+        }
+        return convertedValidators;
+    }
+    /**
+     * Converts a single validator into a form validator.
+     * @author Will Poulson
+     * @private
+     * @param {?} validator The unconverted validator.
+     * @return {?} A converted form validator.
+     */
+    convertValidator(validator) {
+        switch (validator.type) {
+            case ValidationType.Required:
+                return Validators.required;
+            default:
+                return null;
+        }
+    }
+    /**
+     * Constructs the forms for repeaters from saved state.
+     * @param {?} savedState The saved state to load.
+     * @param {?} sections The sections already generated by the form constructor.
+     * @param {?} currentQuestionnaireForm
+     * @return {?}
+     */
+    constructRepeaterFromsFromState(savedState, sections, currentQuestionnaireForm) {
+        for (const section of sections) {
+            for (const question of section.questions) {
+                if (question.type !== QuestionType.Repeater) {
+                    continue;
+                }
+                /** @type {?} */
+                const repeaterArray = savedState[section.name][question.name];
+                if (!repeaterArray || repeaterArray.length === 0) {
+                    continue;
+                }
+                /** @type {?} */
+                const repeaterFormArray = (/** @type {?} */ (currentQuestionnaireForm.get([section.name, question.name])));
+                if (repeaterFormArray.controls.length === repeaterArray.length) {
+                    continue;
+                }
+                for (const repeaterItem of repeaterArray) {
+                    /** @type {?} */
+                    const repeaterItemTemplate = this.generateFormsForRepeater(question);
+                    repeaterFormArray.push(repeaterItemTemplate);
+                }
+            }
+        }
+    }
+}
+FormConstructorService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+/** @nocollapse */
+FormConstructorService.ctorParameters = () => [
+    { type: FormBuilder },
+    { type: FilterService }
+];
+/** @nocollapse */ FormConstructorService.ngInjectableDef = defineInjectable({ factory: function FormConstructorService_Factory() { return new FormConstructorService(inject(FormBuilder), inject(FilterService)); }, token: FormConstructorService, providedIn: "root" });
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+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 __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 = defineInjectable({ factory: function QuestionnaireService_Factory() { return new QuestionnaireService(inject(FormConstructorService), inject("options")); }, token: QuestionnaireService, providedIn: "root" });
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+class GgQuestionnaireV2Module {
+    /**
+     * @param {?} options
+     * @return {?}
+     */
+    static forRoot(options) {
+        return {
+            ngModule: GgQuestionnaireV2Module,
+            providers: [
+                QuestionnaireService,
+                {
+                    provide: 'options',
+                    useValue: options
+                }
+            ]
+        };
+    }
+}
+GgQuestionnaireV2Module.decorators = [
+    { type: NgModule, args: [{
+                declarations: [],
+                providers: [
+                    FormConstructorService,
+                    FilterService
+                ],
+                imports: [
+                    FormsModule,
+                    ReactiveFormsModule
+                ],
+            },] }
+];
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/** @enum {string} */
+const InputType = {
+    Text: 'text',
+    Number: 'number',
+    Email: 'email',
+    Telephone: 'tel',
+    Password: 'password',
+    Color: 'color',
+    Date: 'date',
+    DateTimeLocal: 'datetime-local',
+    Time: 'time',
+    Month: 'month',
+    Week: 'week',
+};
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/** @enum {string} */
+const RepeaterQuestionType = {
+    Input: 'input',
+    Select: 'select',
+};
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+
+export { QuestionnaireService, GgQuestionnaireV2Module, ConditionRelationship, ConditionType, QuestionType, ValidationType, InputType, RepeaterQuestionType, FilterService as ɵb, FormConstructorService as ɵa };
+
+//# sourceMappingURL=glowgreen-gg-questionnaire-v2.js.map