case-editor-tools 1.0.0-beta.7 → 1.0.0

package/surveys/survey-items.js

@@ -0,0 +1,384 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var surveys_surveyEditor_componentEditor = require('./survey-editor/component-editor.js');
+var surveys_surveyEditor_itemEditor = require('../item-editor-59f51ecc.js');
+var surveys_utils_componentGenerators = require('./utils/componentGenerators.js');
+var types_duration = require('../types/duration.js');
+var constants_keyDefinitions = require('../constants/key-definitions.js');
+var surveys_utils_simpleGenerators = require('./utils/simple-generators.js');
+var surveys_utils_simpleQuestionEditor = require('./utils/simple-question-editor.js');
+var surveys_surveyEngineExpressions = require('./survey-engine-expressions.js');
+var surveys_types_itemProperties = require('./types/item-properties.js');
+var surveys_responseTypeGenerators_optionGroupComponents = require('./responseTypeGenerators/optionGroupComponents.js');
+var surveys_responseTypeGenerators_likertGroupComponents = require('./responseTypeGenerators/likertGroupComponents.js');
+require('./utils/randomKeyGenerator.js');
+require('../logger/logger.js');
+require('../expression-utils/expressionGen.js');
+
+const commonQuestionGenerator = (props, rg_inner) => {
+    const simpleEditor = new surveys_utils_simpleQuestionEditor.SimpleQuestionEditor(props.parentKey, props.itemKey, props.version ? props.version : 1, props.confidentialMode);
+    // QUESTION TEXT
+    simpleEditor.setTitle(props.questionText, props.questionSubText, props.titleClassName);
+    if (props.condition) {
+        simpleEditor.setCondition(props.condition);
+    }
+    if (props.helpGroupContent) {
+        simpleEditor.editor.setHelpGroupComponent(surveys_utils_simpleGenerators.generateHelpGroupComponent(props.helpGroupContent));
+    }
+    if (props.topDisplayCompoments) {
+        props.topDisplayCompoments.forEach(comp => simpleEditor.addDisplayComponent(comp));
+    }
+    simpleEditor.setResponseGroupWithContent(rg_inner);
+    if (props.bottomDisplayCompoments) {
+        props.bottomDisplayCompoments.forEach(comp => simpleEditor.addDisplayComponent(comp));
+    }
+    if (props.isRequired) {
+        simpleEditor.addHasResponseValidation();
+    }
+    if (props.customValidations) {
+        props.customValidations.forEach(v => simpleEditor.editor.addValidation(v));
+    }
+    if (props.footnoteText) {
+        simpleEditor.addDisplayComponent(surveys_utils_componentGenerators.ComponentGenerators.footnote({ content: props.footnoteText }));
+    }
+    return simpleEditor.getItem();
+};
+const generateNumericInputQuestion = (props) => {
+    var _a, _b, _c, _d;
+    const style = [];
+    if (props.inputMaxWidth) {
+        style.push({
+            key: 'inputMaxWidth', value: props.inputMaxWidth,
+        });
+    }
+    if (props.labelBehindInput) {
+        style.push({ key: 'labelPlacement', value: 'after' });
+    }
+    const rg_inner = {
+        key: constants_keyDefinitions.numericInputKey,
+        role: 'numberInput',
+        properties: {
+            min: ((_a = props.componentProperties) === null || _a === void 0 ? void 0 : _a.min) !== undefined ? (typeof (props.componentProperties.min) === 'number' ? { dtype: 'num', num: props.componentProperties.min } : props.componentProperties.min) : undefined,
+            max: ((_b = props.componentProperties) === null || _b === void 0 ? void 0 : _b.max) !== undefined ? (typeof ((_c = props.componentProperties) === null || _c === void 0 ? void 0 : _c.max) === 'number' ? { dtype: 'num', num: props.componentProperties.max } : props.componentProperties.max) : undefined,
+            stepSize: ((_d = props.componentProperties) === null || _d === void 0 ? void 0 : _d.stepSize) ? (typeof (props.componentProperties.stepSize) === 'number' ? { dtype: 'num', num: props.componentProperties.stepSize } : props.componentProperties.stepSize) : undefined,
+        },
+        content: surveys_utils_simpleGenerators.generateLocStrings(props.inputLabel),
+        style: style.length > 0 ? style : undefined,
+    };
+    return commonQuestionGenerator(props, rg_inner);
+};
+const generateSingleChoiceQuestion = (props) => {
+    const rg_inner = surveys_responseTypeGenerators_optionGroupComponents.initSingleChoiceGroup(constants_keyDefinitions.singleChoiceKey, props.responseOptions);
+    return commonQuestionGenerator(props, rg_inner);
+};
+const generateDropDownQuestion = (props) => {
+    const rg_inner = surveys_responseTypeGenerators_optionGroupComponents.initDropdownGroup(constants_keyDefinitions.dropDownKey, props.responseOptions, undefined, undefined, undefined, props.placeholder);
+    return commonQuestionGenerator(props, rg_inner);
+};
+const generateMultipleChoiceQuestion = (props) => {
+    const rg_inner = surveys_responseTypeGenerators_optionGroupComponents.initMultipleChoiceGroup(constants_keyDefinitions.multipleChoiceKey, props.responseOptions);
+    return commonQuestionGenerator(props, rg_inner);
+};
+const generateSimpleLikertGroupQuestion = (props) => {
+    var _a;
+    const rg_inner = surveys_responseTypeGenerators_likertGroupComponents.initLikertScaleGroup(constants_keyDefinitions.likertScaleGroupKey, props.rows, props.scaleOptions, props.stackOnSmallScreen);
+    // Add extra validation for likert
+    if (props.isRequired) {
+        if (!props.customValidations) {
+            props.customValidations = [];
+        }
+        (_a = props.customValidations) === null || _a === void 0 ? void 0 : _a.push({
+            key: 'r',
+            type: 'hard',
+            rule: surveys_utils_simpleGenerators.expWithArgs('and', ...props.rows.map(r => surveys_utils_simpleGenerators.expWithArgs('responseHasKeysAny', [props.parentKey, props.itemKey].join('.'), [constants_keyDefinitions.responseGroupKey, constants_keyDefinitions.likertScaleGroupKey, r.key].join('.'), ...props.scaleOptions.map(o => o.key))))
+        });
+    }
+    return commonQuestionGenerator(props, rg_inner);
+};
+const generateResponsiveSingleChoiceArrayQuestion = (props) => {
+    var _a;
+    const rg_inner = surveys_responseTypeGenerators_likertGroupComponents.initResponsiveSingleChoiceArray(constants_keyDefinitions.responsiveSingleChoiceArrayKey, Object.assign({}, props));
+    // Add extra validation
+    if (props.isRequired) {
+        if (!props.customValidations) {
+            props.customValidations = [];
+        }
+        (_a = props.customValidations) === null || _a === void 0 ? void 0 : _a.push({
+            key: 'r',
+            type: 'hard',
+            rule: surveys_utils_simpleGenerators.expWithArgs('and', ...props.rows.map(r => {
+                const hasRespExp = surveys_utils_simpleGenerators.expWithArgs('responseHasKeysAny', [props.parentKey, props.itemKey].join('.'), [constants_keyDefinitions.responseGroupKey, constants_keyDefinitions.responsiveSingleChoiceArrayKey, r.key].join('.'), ...props.scaleOptions.map(o => o.key));
+                if (r.displayCondition === undefined) {
+                    return hasRespExp;
+                }
+                return surveys_surveyEngineExpressions.SurveyEngine.logic.or(surveys_surveyEngineExpressions.SurveyEngine.logic.not(r.displayCondition), hasRespExp);
+            }))
+        });
+    }
+    return commonQuestionGenerator(props, rg_inner);
+};
+const generateResponsiveBipolarLikertArray = (props) => {
+    var _a;
+    const rg_inner = surveys_responseTypeGenerators_likertGroupComponents.initResponsiveBipolarLikertArray(constants_keyDefinitions.responsiveBipolarLikertArrayKey, Object.assign({}, props));
+    // Add extra validation
+    if (props.isRequired) {
+        if (!props.customValidations) {
+            props.customValidations = [];
+        }
+        (_a = props.customValidations) === null || _a === void 0 ? void 0 : _a.push({
+            key: 'r',
+            type: 'hard',
+            rule: surveys_utils_simpleGenerators.expWithArgs('and', ...props.rows.map(r => {
+                const hasRespExp = surveys_utils_simpleGenerators.expWithArgs('responseHasKeysAny', [props.parentKey, props.itemKey].join('.'), [constants_keyDefinitions.responseGroupKey, constants_keyDefinitions.responsiveBipolarLikertArrayKey, r.key].join('.'), ...props.scaleOptions.map(o => o.key));
+                if (r.displayCondition === undefined) {
+                    return hasRespExp;
+                }
+                return surveys_surveyEngineExpressions.SurveyEngine.logic.or(surveys_surveyEngineExpressions.SurveyEngine.logic.not(r.displayCondition), hasRespExp);
+            }))
+        });
+    }
+    return commonQuestionGenerator(props, rg_inner);
+};
+const generateNumericSliderQuestion = (props) => {
+    const rg_inner = {
+        key: 'slider', role: 'sliderNumeric',
+        content: surveys_utils_simpleGenerators.generateLocStrings(props.sliderLabel),
+        description: surveys_utils_simpleGenerators.generateLocStrings(props.noResponseLabel),
+        properties: {
+            min: props.min !== undefined ? (typeof (props.min) === 'number' ? { dtype: 'num', num: props.min } : props.min) : undefined,
+            max: props.max !== undefined ? (typeof (props.max) === 'number' ? { dtype: 'num', num: props.max } : props.max) : undefined,
+            stepSize: props.stepSize ? (typeof (props.stepSize) === 'number' ? { dtype: 'num', num: props.stepSize } : props.stepSize) : undefined,
+        }
+    };
+    return commonQuestionGenerator(props, rg_inner);
+};
+const generateDatePickerInput = (props) => {
+    const rg_inner = {
+        key: constants_keyDefinitions.datePickerKey, role: 'dateInput',
+        properties: {
+            dateInputMode: { str: props.dateInputMode },
+            min: props.minRelativeDate ? {
+                dtype: 'exp', exp: surveys_surveyEngineExpressions.SurveyEngine.timestampWithOffset(props.minRelativeDate.delta, props.minRelativeDate.reference)
+            } : undefined,
+            max: props.maxRelativeDate ? {
+                dtype: 'exp', exp: surveys_utils_simpleGenerators.expWithArgs('timestampWithOffset', types_duration.durationObjectToSeconds(props.maxRelativeDate.delta), props.maxRelativeDate.reference ? props.maxRelativeDate.reference : undefined)
+            } : undefined,
+        },
+        content: props.inputLabelText ? surveys_utils_simpleGenerators.generateLocStrings(props.inputLabelText) : undefined,
+        description: props.placeholderText ? surveys_utils_simpleGenerators.generateLocStrings(props.placeholderText) : undefined,
+    };
+    return commonQuestionGenerator(props, rg_inner);
+};
+const generateTimeInput = (props) => {
+    const style = [];
+    if (props.minTime) {
+        style.push({
+            key: 'minTime', value: props.minTime,
+        });
+    }
+    if (props.maxTime) {
+        style.push({
+            key: 'maxTime', value: props.maxTime,
+        });
+    }
+    if (props.defaultValue) {
+        style.push({
+            key: 'defaultValue', value: props.defaultValue,
+        });
+    }
+    if (props.labelBehindInput) {
+        style.push({ key: 'labelPlacement', value: 'after' });
+    }
+    const rg_inner = {
+        key: constants_keyDefinitions.timeInputKey, role: 'timeInput',
+        properties: {
+            stepSize: props.step,
+        },
+        content: props.inputLabelText ? surveys_utils_simpleGenerators.generateLocStrings(props.inputLabelText) : undefined,
+        style: style.length > 0 ? style : undefined,
+    };
+    return commonQuestionGenerator(props, rg_inner);
+};
+const generateTextInputQuestion = (props) => {
+    const style = [];
+    if (props.maxLength !== undefined) {
+        style.push({ key: 'maxLength', value: props.maxLength.toFixed(0) });
+    }
+    if (props.className !== undefined) {
+        style.push({ key: 'className', value: props.className });
+    }
+    if (props.inputMaxWidth !== undefined) {
+        style.push({ key: 'inputMaxWidth', value: props.inputMaxWidth });
+    }
+    const rg_inner = {
+        key: constants_keyDefinitions.inputKey, role: 'input',
+        content: props.inputLabel ? surveys_utils_simpleGenerators.generateLocStrings(props.inputLabel) : undefined,
+        description: props.placeholderText ? surveys_utils_simpleGenerators.generateLocStrings(props.placeholderText) : undefined,
+        style: style.length > 0 ? [...style] : undefined,
+        disabled: props.disabled,
+    };
+    return commonQuestionGenerator(props, rg_inner);
+};
+const generateConsentQuestion = (props) => {
+    const style = props.className ? [{ key: 'className', value: props.className }] : undefined;
+    const rg_inner = {
+        key: constants_keyDefinitions.consentKey, role: 'consent',
+        items: [
+            {
+                key: 'label', role: 'label',
+                content: !Array.isArray(props.checkBoxLabel) ? surveys_utils_simpleGenerators.generateLocStrings(props.checkBoxLabel) : undefined,
+                items: Array.isArray(props.checkBoxLabel) ? props.checkBoxLabel.map((item, index) => {
+                    if (surveys_types_itemProperties.isDateDisplayComponentProp(item)) {
+                        return surveys_utils_simpleGenerators.generateDateDisplayComp(index.toFixed(), item);
+                    }
+                    return {
+                        key: index.toFixed(),
+                        role: 'text',
+                        content: surveys_utils_simpleGenerators.generateLocStrings(item.content),
+                        style: item.className ? [{ key: 'className', value: item.className }] : undefined
+                    };
+                }) : undefined,
+            },
+            {
+                key: 'title', role: 'title', content: surveys_utils_simpleGenerators.generateLocStrings(props.dialogTitle)
+            },
+            {
+                key: 'content', role: 'content', content: surveys_utils_simpleGenerators.generateLocStrings(props.dialogContent)
+            },
+            {
+                key: 'acceptBtn', role: 'acceptBtn', content: surveys_utils_simpleGenerators.generateLocStrings(props.acceptBtn)
+            },
+            {
+                key: 'rejectBtn', role: 'rejectBtn', content: surveys_utils_simpleGenerators.generateLocStrings(props.rejectBtn)
+            },
+        ],
+        style: style,
+    };
+    return commonQuestionGenerator(props, rg_inner);
+};
+const generateMultilineInput = (props) => {
+    const rg_inner = {
+        key: constants_keyDefinitions.inputKey, role: 'multilineTextInput',
+        content: props.inputLabelText ? surveys_utils_simpleGenerators.generateLocStrings(props.inputLabelText) : undefined,
+        description: props.placeholderText ? surveys_utils_simpleGenerators.generateLocStrings(props.placeholderText) : undefined,
+        style: props.maxLength !== undefined ? [{ key: 'maxLength', value: props.maxLength.toFixed(0) }] : undefined
+    };
+    return commonQuestionGenerator(props, rg_inner);
+};
+const generateClozeQuestion = (props) => {
+    const rg_inner = {
+        key: constants_keyDefinitions.clozeKey, role: 'cloze',
+        items: props.items.map((item) => {
+            const clozeItem = item;
+            const comp = surveys_responseTypeGenerators_optionGroupComponents.optionDefToItemComponent(clozeItem);
+            return comp;
+        })
+    };
+    return commonQuestionGenerator(props, rg_inner);
+};
+const generateCustomQuestion = (props) => {
+    const items = [];
+    props.responseItemDefs.forEach(item => {
+        const rolePrefix = item.mapToRole !== undefined ? `${item.mapToRole}` : '';
+        const role = `${rolePrefix}:${item.role}`;
+        delete item['mapToRole'];
+        const rg_inner = Object.assign(Object.assign({}, item), { role: role });
+        items.push(rg_inner);
+    });
+    const simpleEditor = new surveys_utils_simpleQuestionEditor.SimpleQuestionEditor(props.parentKey, props.itemKey, props.version ? props.version : 1, props.confidentialMode);
+    // QUESTION TEXT
+    simpleEditor.setTitle(props.questionText, props.questionSubText, props.titleClassName);
+    if (props.condition) {
+        simpleEditor.setCondition(props.condition);
+    }
+    if (props.helpGroupContent) {
+        simpleEditor.editor.setHelpGroupComponent(surveys_utils_simpleGenerators.generateHelpGroupComponent(props.helpGroupContent));
+    }
+    if (props.topDisplayCompoments) {
+        props.topDisplayCompoments.forEach(comp => simpleEditor.addDisplayComponent(comp));
+    }
+    simpleEditor.editor.addExistingResponseComponent({
+        key: constants_keyDefinitions.responseGroupKey,
+        role: 'responseGroup',
+        items,
+    });
+    if (props.bottomDisplayCompoments) {
+        props.bottomDisplayCompoments.forEach(comp => simpleEditor.addDisplayComponent(comp));
+    }
+    if (props.isRequired) {
+        simpleEditor.addHasResponseValidation();
+    }
+    if (props.customValidations) {
+        props.customValidations.forEach(v => simpleEditor.editor.addValidation(v));
+    }
+    if (props.footnoteText) {
+        simpleEditor.addDisplayComponent(surveys_utils_componentGenerators.ComponentGenerators.footnote({ content: props.footnoteText }));
+    }
+    return simpleEditor.getItem();
+};
+const generateDisplay = (props) => {
+    const simpleEditor = new surveys_utils_simpleQuestionEditor.SimpleQuestionEditor(props.parentKey, props.itemKey, 1);
+    props.content.forEach(item => simpleEditor.addDisplayComponent(item));
+    if (props.condition) {
+        simpleEditor.setCondition(props.condition);
+    }
+    return simpleEditor.getItem();
+};
+const generateSurveyEnd = (parentKey, content, condition) => {
+    const defaultKey = 'surveyEnd';
+    const itemKey = [parentKey, defaultKey].join('.');
+    const editor = new surveys_surveyEditor_itemEditor.ItemEditor(undefined, { itemKey: itemKey, type: 'surveyEnd', isGroup: false });
+    editor.setTitleComponent(surveys_utils_simpleGenerators.generateTitleComponent(content));
+    // CONDITION
+    editor.setCondition(condition);
+    return editor.getItem();
+};
+const initEQ5DHealthIndicatorQuestion = (props) => {
+    // init group
+    const groupEdit = new surveys_surveyEditor_componentEditor.ComponentEditor(undefined, {
+        key: props.key,
+        isGroup: true,
+        role: props.role,
+    });
+    const instructionTextEditor = new surveys_surveyEditor_componentEditor.ComponentEditor(undefined, { role: 'instruction', });
+    instructionTextEditor.setContent(surveys_utils_simpleGenerators.generateLocStrings(props.instructionText));
+    groupEdit.addItemComponent(instructionTextEditor.getComponent());
+    const valueBoxTextEditor = new surveys_surveyEditor_componentEditor.ComponentEditor(undefined, { role: 'valuebox', });
+    valueBoxTextEditor.setContent(surveys_utils_simpleGenerators.generateLocStrings(props.valueBoxText));
+    groupEdit.addItemComponent(valueBoxTextEditor.getComponent());
+    const minHealthTextEditor = new surveys_surveyEditor_componentEditor.ComponentEditor(undefined, { role: 'mintext', });
+    minHealthTextEditor.setContent(surveys_utils_simpleGenerators.generateLocStrings(props.minHealthText));
+    groupEdit.addItemComponent(minHealthTextEditor.getComponent());
+    const maxHealthTextEditor = new surveys_surveyEditor_componentEditor.ComponentEditor(undefined, { role: 'maxtext', });
+    maxHealthTextEditor.setContent(surveys_utils_simpleGenerators.generateLocStrings(props.maxHealthText));
+    groupEdit.addItemComponent(maxHealthTextEditor.getComponent());
+    return groupEdit.getComponent();
+};
+const SurveyItems = {
+    consent: generateConsentQuestion,
+    singleChoice: generateSingleChoiceQuestion,
+    responsiveSingleChoiceArray: generateResponsiveSingleChoiceArrayQuestion,
+    responsiveBipolarLikertArray: generateResponsiveBipolarLikertArray,
+    multipleChoice: generateMultipleChoiceQuestion,
+    dateInput: generateDatePickerInput,
+    timeInput: generateTimeInput,
+    textInput: generateTextInputQuestion,
+    // eq5dSlider: todo,
+    clozeQuestion: generateClozeQuestion,
+    numericInput: generateNumericInputQuestion,
+    multilineTextInput: generateMultilineInput,
+    dropDown: generateDropDownQuestion,
+    numericSlider: generateNumericSliderQuestion,
+    display: generateDisplay,
+    surveyEnd: generateSurveyEnd,
+    customQuestion: generateCustomQuestion,
+    old: {
+        simpleLikertGroup: generateSimpleLikertGroupQuestion,
+    }
+};
+
+exports.SurveyItems = SurveyItems;
+exports.initEQ5DHealthIndicatorQuestion = initEQ5DHealthIndicatorQuestion;
+//# sourceMappingURL=survey-items.js.map

package/surveys/survey-items.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"survey-items.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/surveys/types/group.d.ts

@@ -0,0 +1,23 @@
+import { Expression, SurveyItem } from "survey-engine/data_types";
+import { ItemEditor } from "../survey-editor/item-editor";
+export declare abstract class Group {
+    groupEditor: ItemEditor;
+    key: string;
+    private parentKey;
+    constructor(parentKey: string, groupKey: string, selectionMethod?: Expression);
+    abstract buildGroup(): void;
+    /**
+     * Check if this group is currently part of a path, by checking if the key attribute exists in the path of the group.
+     * @param partialKey Is this key segment included somewhere in the parent key of this item.
+     * @returns
+     */
+    isPartOf(partialKey: string): boolean;
+    /**
+     * Use this method to retrieve the generated survey item
+     * @returns
+     */
+    get(): SurveyItem;
+    addPageBreak(): void;
+    addItem(item: SurveyItem, pageBreakAfter?: boolean): void;
+    private checkDuplicateChildKeys;
+}

package/surveys/types/group.js

@@ -0,0 +1,72 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var logger_logger = require('../../logger/logger.js');
+var surveys_surveyEditor_itemEditor = require('../../item-editor-59f51ecc.js');
+var surveys_utils_simpleGenerators = require('../utils/simple-generators.js');
+require('../survey-editor/component-editor.js');
+require('../utils/randomKeyGenerator.js');
+require('./item-properties.js');
+
+class Group {
+    constructor(parentKey, groupKey, selectionMethod) {
+        this.parentKey = parentKey;
+        this.key = [this.parentKey, groupKey].join('.');
+        this.groupEditor = new surveys_surveyEditor_itemEditor.ItemEditor(undefined, {
+            itemKey: this.key,
+            isGroup: true
+        });
+        if (!selectionMethod) {
+            this.groupEditor.setSelectionMethod({ name: 'sequential' });
+        }
+        else {
+            this.groupEditor.setSelectionMethod(selectionMethod);
+        }
+    }
+    /**
+     * Check if this group is currently part of a path, by checking if the key attribute exists in the path of the group.
+     * @param partialKey Is this key segment included somewhere in the parent key of this item.
+     * @returns
+     */
+    isPartOf(partialKey) {
+        return this.parentKey.includes(partialKey);
+    }
+    /**
+     * Use this method to retrieve the generated survey item
+     * @returns
+     */
+    get() {
+        this.buildGroup();
+        this.checkDuplicateChildKeys();
+        return this.groupEditor.getItem();
+    }
+    addPageBreak() {
+        this.groupEditor.addSurveyItem(surveys_utils_simpleGenerators.generatePageBreak(this.key));
+    }
+    addItem(item, pageBreakAfter) {
+        this.groupEditor.addSurveyItem(item);
+        if (pageBreakAfter) {
+            this.addPageBreak();
+        }
+    }
+    checkDuplicateChildKeys() {
+        const group = this.groupEditor.getItem();
+        const keys = group.items.map(item => item.key);
+        const hasDuplicates = keys.some((key, index) => {
+            const isDuplicateKey = keys.indexOf(key) !== index;
+            if (isDuplicateKey) {
+                logger_logger.Logger.error('Duplicate key:');
+                logger_logger.Logger.criticalError(`${key} is used twice (at index ${keys.indexOf(key)} and at index ${index})`);
+            }
+            return isDuplicateKey;
+        });
+        if (hasDuplicates) {
+            logger_logger.Logger.error('\nSurvey contains duplicate keys.\nPlease check the lines above for more infos.\nProcess stopped prematurely.');
+            process.exit(1);
+        }
+    }
+}
+
+exports.Group = Group;
+//# sourceMappingURL=group.js.map

package/surveys/types/group.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"group.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/surveys/types/index.d.ts

@@ -0,0 +1,4 @@
+export * from './group';
+export * from './item';
+export * from './item-properties';
+export * from './survey-definition';

package/surveys/types/index.js

@@ -0,0 +1,22 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var surveys_types_group = require('./group.js');
+var surveys_types_item = require('./item.js');
+var surveys_types_itemProperties = require('./item-properties.js');
+var surveys_types_surveyDefinition = require('./survey-definition.js');
+require('../../logger/logger.js');
+require('../../item-editor-59f51ecc.js');
+require('../survey-editor/component-editor.js');
+require('../utils/randomKeyGenerator.js');
+require('../utils/simple-generators.js');
+require('../survey-editor/survey-editor.js');
+
+
+
+exports.Group = surveys_types_group.Group;
+exports.Item = surveys_types_item.Item;
+exports.isDateDisplayComponentProp = surveys_types_itemProperties.isDateDisplayComponentProp;
+exports.SurveyDefinition = surveys_types_surveyDefinition.SurveyDefinition;
+//# sourceMappingURL=index.js.map

package/surveys/types/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;"}