case-editor-tools 1.0.0-beta.2 → 1.0.0-beta.20

package/surveys/responseTypeGenerators/likertGroupComponents.js

@@ -0,0 +1,347 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var surveys_surveyEditor_componentEditor = require('../survey-editor/component-editor.js');
+var surveys_utils_randomKeyGenerator = require('../utils/randomKeyGenerator.js');
+var surveys_utils_simpleGenerators = require('../utils/simple-generators.js');
+
+const initLikertScaleGroup = (key, rows, scaleOptions, stackOnSmallScreen, displayCondition) => {
+    const groupEdit = new surveys_surveyEditor_componentEditor.ComponentEditor(undefined, {
+        key: key,
+        isGroup: true,
+        role: 'likertGroup',
+    });
+    if (displayCondition) {
+        groupEdit.setDisplayCondition(displayCondition);
+    }
+    rows.forEach((row, index) => {
+        groupEdit.addItemComponent({
+            key: surveys_utils_randomKeyGenerator.generateRandomKey(4),
+            role: 'text',
+            style: [{
+                    key: 'className', value: 'fw-bold' + (index !== 0 ? ' pt-1 mt-2' : '') + ((!row.hideTopBorder && index > 0) ? ' border-top border-1 border-grey-2' : '') + (row.descriptions ? ' mb-0' : ' mb-1')
+                }, { key: 'variant', value: 'h6' }],
+            content: surveys_utils_simpleGenerators.generateLocStrings(row.content),
+        });
+        if (row.descriptions) {
+            row.descriptions.forEach(desc => {
+                groupEdit.addItemComponent(desc);
+            });
+        }
+        const item = initLikertScaleItem(row.key, scaleOptions.map(option => {
+            var _a, _b;
+            return {
+                key: option.key,
+                className: option.className,
+                content: row.hideLabels ? undefined : option.content,
+                disabled: (_b = (_a = row.optionDisabled) === null || _a === void 0 ? void 0 : _a.find(cond => cond.optionKey === option.key)) === null || _b === void 0 ? void 0 : _b.exp,
+            };
+        }), stackOnSmallScreen, row.displayCondition);
+        groupEdit.addItemComponent(item);
+    });
+    return groupEdit.getComponent();
+};
+const initResponsiveSingleChoiceArray = (rgKey, props, displayCondition) => {
+    var _a, _b;
+    const groupEdit = new surveys_surveyEditor_componentEditor.ComponentEditor(undefined, {
+        key: rgKey,
+        isGroup: true,
+        role: 'responsiveSingleChoiceArray',
+    });
+    if (displayCondition) {
+        groupEdit.setDisplayCondition(displayCondition);
+    }
+    const style = [
+        { key: 'defaultMode', value: props.defaultMode },
+    ];
+    if (props.responsiveModes) {
+        if (props.responsiveModes.sm) {
+            style.push({ key: 'smMode', value: props.responsiveModes.sm });
+        }
+        if (props.responsiveModes.md) {
+            style.push({ key: 'mdMode', value: props.responsiveModes.md });
+        }
+        if (props.responsiveModes.lg) {
+            style.push({ key: 'lgMode', value: props.responsiveModes.lg });
+        }
+        if (props.responsiveModes.xl) {
+            style.push({ key: 'xlMode', value: props.responsiveModes.xl });
+        }
+        if (props.responsiveModes.xxl) {
+            style.push({ key: 'xxlMode', value: props.responsiveModes.xxl });
+        }
+    }
+    if (props.rgClassName) {
+        style.push({ key: 'className', value: props.rgClassName });
+    }
+    if (props.verticalModeProps) {
+        if (props.verticalModeProps.useReverseOptionOrder) {
+            style.push({ key: 'verticalModeReverseOrder', value: 'true' });
+        }
+    }
+    if (props.tableModeProps) {
+        style.push({ key: 'tableModeClassName', value: 'table-borderless mb-0 ' + props.tableModeProps.className });
+        if (props.tableModeProps.layout) {
+            style.push({ key: 'tableModeLayout', value: props.tableModeProps.layout });
+        }
+        if (props.tableModeProps.firstColWidth) {
+            style.push({ key: 'tableModeFirstColWidth', value: props.tableModeProps.firstColWidth });
+        }
+    }
+    groupEdit.setStyles(style);
+    const defaultBorderClass = 'border-bottom border-grey-2';
+    let tableModeOptionHeaderClassName = undefined;
+    if (!((_a = props.tableModeProps) === null || _a === void 0 ? void 0 : _a.hideRowBorder)) {
+        tableModeOptionHeaderClassName = defaultBorderClass;
+    }
+    if ((_b = props.tableModeProps) === null || _b === void 0 ? void 0 : _b.optionHeaderClassName) {
+        tableModeOptionHeaderClassName += ' ' + props.tableModeProps.optionHeaderClassName;
+    }
+    const optionStyles = [];
+    if (tableModeOptionHeaderClassName) {
+        optionStyles.push({ key: 'tableModeClassName', value: tableModeOptionHeaderClassName });
+    }
+    groupEdit.addItemComponent({
+        key: 'header',
+        role: 'options',
+        style: optionStyles.length > 0 ? optionStyles : undefined,
+        items: props.scaleOptions.map(option => {
+            return {
+                key: option.key,
+                role: 'option',
+                style: option.className ? [{ key: 'className', value: option.className }] : undefined,
+                content: !Array.isArray(option.content) ? surveys_utils_simpleGenerators.generateLocStrings(option.content) : undefined,
+                items: Array.isArray(option.content) ? option.content.map((cont, index) => {
+                    return {
+                        key: index.toFixed(),
+                        role: 'text',
+                        content: surveys_utils_simpleGenerators.generateLocStrings(cont.content),
+                        style: cont.className ? [{ key: 'className', value: cont.className }] : undefined,
+                    };
+                }) : [],
+            };
+        })
+    });
+    props.rows.forEach((row, index) => {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        let tableModeRowClassName = undefined;
+        let horizontalModeRowClassName = undefined;
+        let verticalModeRowClassName = undefined;
+        const isLast = index === props.rows.length - 1;
+        if (!((_a = props.tableModeProps) === null || _a === void 0 ? void 0 : _a.hideRowBorder) && !isLast) {
+            tableModeRowClassName = defaultBorderClass;
+        }
+        if ((_b = row.tableModeProps) === null || _b === void 0 ? void 0 : _b.className) {
+            tableModeRowClassName += ' ' + ((_c = row.tableModeProps) === null || _c === void 0 ? void 0 : _c.className);
+        }
+        if (!((_d = props.horizontalModeProps) === null || _d === void 0 ? void 0 : _d.hideRowBorder) && !isLast) {
+            horizontalModeRowClassName = defaultBorderClass;
+        }
+        if ((_e = row.horizontalModeProps) === null || _e === void 0 ? void 0 : _e.className) {
+            horizontalModeRowClassName += ' ' + ((_f = row.horizontalModeProps) === null || _f === void 0 ? void 0 : _f.className);
+        }
+        if (!((_g = props.verticalModeProps) === null || _g === void 0 ? void 0 : _g.hideRowBorder) && !isLast) {
+            verticalModeRowClassName = defaultBorderClass;
+        }
+        if ((_h = row.verticalModeProps) === null || _h === void 0 ? void 0 : _h.className) {
+            verticalModeRowClassName += ' ' + ((_j = row.verticalModeProps) === null || _j === void 0 ? void 0 : _j.className);
+        }
+        const rowStyles = [];
+        if (tableModeRowClassName) {
+            rowStyles.push({ key: 'tableModeClassName', value: tableModeRowClassName });
+        }
+        if (horizontalModeRowClassName) {
+            rowStyles.push({ key: 'horizontalModeClassName', value: horizontalModeRowClassName });
+        }
+        if (verticalModeRowClassName) {
+            rowStyles.push({ key: 'verticalModeClassName', value: verticalModeRowClassName });
+        }
+        if ((_k = row.horizontalModeProps) === null || _k === void 0 ? void 0 : _k.labelPlacement) {
+            rowStyles.push({ key: 'horizontalModeLabelPlacement', value: row.horizontalModeProps.labelPlacement });
+        }
+        groupEdit.addItemComponent({
+            key: row.key,
+            role: 'row',
+            style: rowStyles.length > 0 ? rowStyles : undefined,
+            content: !Array.isArray(row.content) ? surveys_utils_simpleGenerators.generateLocStrings(row.content) : undefined,
+            items: Array.isArray(row.content) ? row.content.map((cont, index) => {
+                return {
+                    key: index.toFixed(),
+                    role: 'text',
+                    content: surveys_utils_simpleGenerators.generateLocStrings(cont.content),
+                    style: cont.className ? [{ key: 'className', value: cont.className }] : undefined,
+                };
+            }) : [],
+        });
+    });
+    return groupEdit.getComponent();
+};
+const initResponsiveBipolarLikertArray = (rgKey, props, displayCondition) => {
+    var _a;
+    const groupEdit = new surveys_surveyEditor_componentEditor.ComponentEditor(undefined, {
+        key: rgKey,
+        isGroup: true,
+        role: 'responsiveBipolarLikertScaleArray',
+    });
+    if (displayCondition) {
+        groupEdit.setDisplayCondition(displayCondition);
+    }
+    const style = [
+        { key: 'defaultMode', value: props.defaultMode },
+    ];
+    if (props.responsiveModes) {
+        if (props.responsiveModes.sm) {
+            style.push({ key: 'smMode', value: props.responsiveModes.sm });
+        }
+        if (props.responsiveModes.md) {
+            style.push({ key: 'mdMode', value: props.responsiveModes.md });
+        }
+        if (props.responsiveModes.lg) {
+            style.push({ key: 'lgMode', value: props.responsiveModes.lg });
+        }
+        if (props.responsiveModes.xl) {
+            style.push({ key: 'xlMode', value: props.responsiveModes.xl });
+        }
+        if (props.responsiveModes.xxl) {
+            style.push({ key: 'xxlMode', value: props.responsiveModes.xxl });
+        }
+    }
+    if (props.rgClassName) {
+        style.push({ key: 'className', value: props.rgClassName });
+    }
+    if (props.withLabelRowModeProps) {
+        if (props.withLabelRowModeProps.maxLabelWidth) {
+            style.push({ key: 'labelRowMaxLabelWidth', value: props.withLabelRowModeProps.maxLabelWidth });
+        }
+    }
+    style.push({ key: 'labelRowPosition', value: ((_a = props.withLabelRowModeProps) === null || _a === void 0 ? void 0 : _a.useBottomLabel) ? 'bottom' : 'top' });
+    if (props.tableModeProps) {
+        style.push({ key: 'tableModeClassName', value: 'table-borderless mb-0 ' + props.tableModeProps.className });
+        if (props.tableModeProps.layout) {
+            style.push({ key: 'tableModeLayout', value: props.tableModeProps.layout });
+        }
+        if (props.tableModeProps.labelColWidth) {
+            style.push({ key: 'tableModeLabelColWidth', value: props.tableModeProps.labelColWidth });
+        }
+    }
+    groupEdit.setStyles(style);
+    const defaultBorderClass = 'border-bottom border-grey-2';
+    groupEdit.addItemComponent({
+        key: 'options',
+        role: 'options',
+        items: props.scaleOptions.map(option => {
+            return {
+                key: option.key,
+                role: 'option',
+            };
+        })
+    });
+    props.rows.forEach((row, index) => {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        let tableModeRowClassName = undefined;
+        let withLabelRowModeClassName = undefined;
+        let verticalModeRowClassName = undefined;
+        const isLast = index === props.rows.length - 1;
+        if (!((_a = props.tableModeProps) === null || _a === void 0 ? void 0 : _a.hideRowBorder) && !isLast) {
+            tableModeRowClassName = defaultBorderClass;
+        }
+        if ((_b = row.tableModeProps) === null || _b === void 0 ? void 0 : _b.className) {
+            tableModeRowClassName += ' ' + ((_c = row.tableModeProps) === null || _c === void 0 ? void 0 : _c.className);
+        }
+        if (!((_d = props.withLabelRowModeProps) === null || _d === void 0 ? void 0 : _d.hideRowBorder) && !isLast) {
+            withLabelRowModeClassName = defaultBorderClass;
+        }
+        if ((_e = row.withLabelRowModeProps) === null || _e === void 0 ? void 0 : _e.className) {
+            withLabelRowModeClassName += ' ' + ((_f = row.withLabelRowModeProps) === null || _f === void 0 ? void 0 : _f.className);
+        }
+        if (!((_g = props.verticalModeProps) === null || _g === void 0 ? void 0 : _g.hideRowBorder) && !isLast) {
+            verticalModeRowClassName = defaultBorderClass;
+        }
+        if ((_h = row.verticalModeProps) === null || _h === void 0 ? void 0 : _h.className) {
+            verticalModeRowClassName += ' ' + ((_j = row.verticalModeProps) === null || _j === void 0 ? void 0 : _j.className);
+        }
+        const rowStyles = [];
+        if (tableModeRowClassName) {
+            rowStyles.push({ key: 'tableModeClassName', value: tableModeRowClassName });
+        }
+        if (withLabelRowModeClassName) {
+            rowStyles.push({ key: 'withLabelRowModeClassName', value: withLabelRowModeClassName });
+        }
+        if (verticalModeRowClassName) {
+            rowStyles.push({ key: 'verticalModeClassName', value: verticalModeRowClassName });
+        }
+        const startLabel = {
+            key: 'start',
+            role: 'start',
+            content: !Array.isArray(row.startLabel) ? surveys_utils_simpleGenerators.generateLocStrings(row.startLabel) : undefined,
+            items: Array.isArray(row.startLabel) ? row.startLabel.map((cont, index) => {
+                return {
+                    key: index.toFixed(),
+                    role: 'text',
+                    content: surveys_utils_simpleGenerators.generateLocStrings(cont.content),
+                    style: cont.className ? [{ key: 'className', value: cont.className }] : undefined,
+                };
+            }) : [],
+        };
+        const endLabel = {
+            key: 'end',
+            role: 'end',
+            content: !Array.isArray(row.endLabel) ? surveys_utils_simpleGenerators.generateLocStrings(row.endLabel) : undefined,
+            items: Array.isArray(row.endLabel) ? row.endLabel.map((cont, index) => {
+                return {
+                    key: index.toFixed(),
+                    role: 'text',
+                    content: surveys_utils_simpleGenerators.generateLocStrings(cont.content),
+                    style: cont.className ? [{ key: 'className', value: cont.className }] : undefined,
+                };
+            }) : [],
+        };
+        groupEdit.addItemComponent({
+            key: row.key,
+            role: 'row',
+            style: rowStyles.length > 0 ? rowStyles : undefined,
+            items: [
+                startLabel, endLabel
+            ],
+        });
+    });
+    return groupEdit.getComponent();
+};
+const initLikertScaleItem = (key, options, stackOnSmallScreen, displayCondition) => {
+    // init group
+    const groupEdit = new surveys_surveyEditor_componentEditor.ComponentEditor(undefined, {
+        key: key,
+        isGroup: true,
+        role: 'likert',
+    });
+    groupEdit.setDisplayCondition(displayCondition);
+    if (stackOnSmallScreen) {
+        groupEdit.setStyles([
+            { key: 'responsive', value: 'stackOnSmallScreen' }
+        ]);
+    }
+    options.forEach((option) => {
+        const optionComponent = new surveys_surveyEditor_componentEditor.ComponentEditor(undefined, {
+            key: option.key,
+            role: 'option',
+        });
+        if (option.content) {
+            optionComponent.setContent(surveys_utils_simpleGenerators.generateLocStrings(option.content));
+        }
+        if (option.className) {
+            optionComponent.setStyles([{
+                    key: 'className', value: option.className
+                }]);
+        }
+        optionComponent.setDisabled(option.disabled);
+        groupEdit.addItemComponent(optionComponent.getComponent());
+    });
+    return groupEdit.getComponent();
+};
+
+exports.initLikertScaleGroup = initLikertScaleGroup;
+exports.initLikertScaleItem = initLikertScaleItem;
+exports.initResponsiveBipolarLikertArray = initResponsiveBipolarLikertArray;
+exports.initResponsiveSingleChoiceArray = initResponsiveSingleChoiceArray;
+//# sourceMappingURL=likertGroupComponents.js.map

package/surveys/responseTypeGenerators/likertGroupComponents.js.map

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

package/surveys/responseTypeGenerators/matrixGroupComponent.d.ts

@@ -0,0 +1,49 @@
+import { ComponentProperties, Expression, ItemGroupComponent } from "survey-engine/data_types";
+interface HeaderRow {
+    role: 'headerRow';
+    key: string;
+    displayCondition?: Expression;
+    disabled?: Expression;
+    cells: Array<{
+        role: 'text';
+        key: string;
+        content?: Map<string, string>;
+        description?: Map<string, string>;
+    }>;
+}
+interface RadioRow {
+    role: 'radioRow';
+    key: string;
+    displayCondition?: Expression;
+    disabled?: Expression;
+    cells: Array<{
+        role: 'label' | 'option';
+        key: string;
+        content?: Map<string, string>;
+        description?: Map<string, string>;
+    }>;
+}
+export interface ResponseRowCell {
+    role: 'label' | 'check' | 'input' | 'numberInput' | 'dropDownGroup';
+    key: string;
+    content?: Map<string, string>;
+    description?: Map<string, string>;
+    properties?: ComponentProperties;
+    items?: Array<{
+        role: 'option';
+        key: string;
+        content?: Map<string, string>;
+        disabled?: Expression;
+        displayCondition?: Expression;
+    }>;
+}
+interface ResponseRow {
+    role: 'responseRow';
+    key: string;
+    displayCondition?: Expression;
+    disabled?: Expression;
+    cells: Array<ResponseRowCell>;
+}
+declare type MatrixRow = HeaderRow | RadioRow | ResponseRow;
+export declare const initMatrixQuestion: (key: string, rows: Array<MatrixRow>, order?: Expression | undefined) => ItemGroupComponent;
+export {};

package/surveys/responseTypeGenerators/matrixGroupComponent.js

@@ -0,0 +1,99 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var surveys_surveyEditor_componentEditor = require('../survey-editor/component-editor.js');
+var surveys_utils_simpleGenerators = require('../utils/simple-generators.js');
+require('../utils/randomKeyGenerator.js');
+
+const initMatrixQuestion = (key, rows, order) => {
+    // init group
+    const groupEdit = new surveys_surveyEditor_componentEditor.ComponentEditor(undefined, {
+        key: key,
+        isGroup: true,
+        role: 'matrix',
+    });
+    groupEdit.setOrder(order ? order : {
+        name: 'sequential'
+    });
+    // init rows
+    rows.forEach(rowDef => {
+        const rowEditor = new surveys_surveyEditor_componentEditor.ComponentEditor(undefined, {
+            key: rowDef.key,
+            role: rowDef.role,
+        });
+        if (rowDef.displayCondition) {
+            rowEditor.setDisplayCondition(rowDef.displayCondition);
+        }
+        if (rowDef.disabled) {
+            rowEditor.setDisabled(rowDef.disabled);
+        }
+        switch (rowDef.role) {
+            case 'headerRow':
+                rowDef.cells.forEach(cell => {
+                    const cellEditor = new surveys_surveyEditor_componentEditor.ComponentEditor(undefined, {
+                        key: cell.key,
+                        role: cell.role,
+                    });
+                    if (cell.content) {
+                        cellEditor.setContent(surveys_utils_simpleGenerators.generateLocStrings(cell.content));
+                    }
+                    if (cell.description) {
+                        cellEditor.setDescription(surveys_utils_simpleGenerators.generateLocStrings(cell.description));
+                    }
+                    rowEditor.addItemComponent(cellEditor.getComponent());
+                });
+                break;
+            case 'radioRow':
+                rowDef.cells.forEach(cell => {
+                    const cellEditor = new surveys_surveyEditor_componentEditor.ComponentEditor(undefined, {
+                        key: cell.key,
+                        role: cell.role,
+                    });
+                    if (cell.content) {
+                        cellEditor.setContent(surveys_utils_simpleGenerators.generateLocStrings(cell.content));
+                    }
+                    if (cell.description) {
+                        cellEditor.setDescription(surveys_utils_simpleGenerators.generateLocStrings(cell.description));
+                    }
+                    rowEditor.addItemComponent(cellEditor.getComponent());
+                });
+                break;
+            case 'responseRow':
+                rowDef.cells.forEach(cell => {
+                    const cellEditor = new surveys_surveyEditor_componentEditor.ComponentEditor(undefined, {
+                        key: cell.key,
+                        role: cell.role,
+                    });
+                    if (cell.content) {
+                        cellEditor.setContent(surveys_utils_simpleGenerators.generateLocStrings(cell.content));
+                    }
+                    if (cell.description) {
+                        cellEditor.setDescription(surveys_utils_simpleGenerators.generateLocStrings(cell.description));
+                    }
+                    cellEditor.setProperties(cell.properties);
+                    if (cell.items) {
+                        cell.items.forEach(opt => {
+                            const cellOptionEditor = new surveys_surveyEditor_componentEditor.ComponentEditor(undefined, {
+                                key: opt.key,
+                                role: opt.role,
+                            });
+                            if (opt.content) {
+                                cellOptionEditor.setContent(surveys_utils_simpleGenerators.generateLocStrings(opt.content));
+                            }
+                            cellOptionEditor.setDisabled(opt.disabled);
+                            cellOptionEditor.setDisplayCondition(opt.displayCondition);
+                            cellEditor.addItemComponent(cellOptionEditor.getComponent());
+                        });
+                    }
+                    rowEditor.addItemComponent(cellEditor.getComponent());
+                });
+                break;
+        }
+        groupEdit.addItemComponent(rowEditor.getComponent());
+    });
+    return groupEdit.getComponent();
+};
+
+exports.initMatrixQuestion = initMatrixQuestion;
+//# sourceMappingURL=matrixGroupComponent.js.map

package/surveys/responseTypeGenerators/matrixGroupComponent.js.map

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

package/surveys/responseTypeGenerators/optionGroupComponents.d.ts

@@ -0,0 +1,7 @@
+import { Expression, ItemComponent, ItemGroupComponent } from "survey-engine/data_types";
+import { OptionDef } from "../types";
+export declare const optionDefToItemComponent: (optionDef: OptionDef) => ItemComponent;
+export declare const initSingleChoiceGroup: (key: string, optionItems: OptionDef[], order?: Expression | undefined) => ItemGroupComponent;
+export declare const initMultipleChoiceGroup: (key: string, optionItems: OptionDef[], order?: Expression | undefined) => ItemGroupComponent;
+export declare const initDropdownGroup: (key: string, optionItems: OptionDef[], order?: Expression | undefined, groupDisabled?: Expression | undefined, groupContent?: Map<string, string> | undefined, groupDescription?: Map<string, string> | undefined) => ItemGroupComponent;
+export declare const initSliderCategoricalGroup: (key: string, optionItems: OptionDef[], order?: Expression | undefined, groupDisabled?: Expression | undefined) => ItemGroupComponent;

package/surveys/responseTypeGenerators/optionGroupComponents.js

@@ -0,0 +1,125 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var surveys_surveyEditor_componentEditor = require('../survey-editor/component-editor.js');
+var surveys_utils_simpleGenerators = require('../utils/simple-generators.js');
+require('../utils/randomKeyGenerator.js');
+
+const optionDefToItemComponent = (optionDef) => {
+    const isGroup = optionDef.items && optionDef.items.length > 0;
+    const optEditor = new surveys_surveyEditor_componentEditor.ComponentEditor(undefined, {
+        key: optionDef.key,
+        role: optionDef.role,
+        isGroup: isGroup
+    });
+    if (isGroup) {
+        optEditor.setOrder({
+            name: 'sequential'
+        });
+    }
+    if (optionDef.content) {
+        optEditor.setContent(surveys_utils_simpleGenerators.generateLocStrings(optionDef.content));
+    }
+    if (optionDef.description) {
+        optEditor.setDescription(surveys_utils_simpleGenerators.generateLocStrings(optionDef.description));
+    }
+    switch (optionDef.role) {
+        case 'date':
+            optEditor.setDType('date');
+            break;
+        case 'numberInput':
+            optEditor.setDType('number');
+            break;
+    }
+    if (optionDef.displayCondition) {
+        optEditor.setDisplayCondition(optionDef.displayCondition);
+    }
+    if (optionDef.disabled) {
+        optEditor.setDisabled(optionDef.disabled);
+    }
+    if (optionDef.style) {
+        optEditor.setStyles(optionDef.style);
+    }
+    if (optionDef.optionProps) {
+        if (typeof (optionDef.optionProps.min) === 'number') {
+            optionDef.optionProps.min = { dtype: 'num', num: optionDef.optionProps.min };
+        }
+        if (typeof (optionDef.optionProps.max) === 'number') {
+            optionDef.optionProps.max = { dtype: 'num', num: optionDef.optionProps.max };
+        }
+        if (typeof (optionDef.optionProps.stepSize) === 'number') {
+            optionDef.optionProps.stepSize = { dtype: 'num', num: optionDef.optionProps.stepSize };
+        }
+        optEditor.setProperties(optionDef.optionProps);
+    }
+    if (optionDef.items) {
+        if (optionDef.role === 'text') {
+            optionDef.items.forEach((item, index) => {
+                const textItem = item;
+                optEditor.addItemComponent({
+                    key: index.toFixed(),
+                    role: 'text',
+                    content: surveys_utils_simpleGenerators.generateLocStrings(textItem.content),
+                    style: textItem.className ? [{ key: 'className', value: textItem.className }] : undefined
+                });
+            });
+        }
+        else {
+            optionDef.items.forEach((item) => {
+                const clozeItem = item;
+                const comp = optionDefToItemComponent(clozeItem);
+                optEditor.addItemComponent(comp);
+            });
+        }
+    }
+    return optEditor.getComponent();
+};
+const initResponseGroup = (type, key, optionItems, order, groupDisabled, groupContent, groupDescription) => {
+    // init group
+    const groupEdit = new surveys_surveyEditor_componentEditor.ComponentEditor(undefined, {
+        key: key,
+        isGroup: true,
+        role: type,
+    });
+    groupEdit.setOrder(order ? order : {
+        name: 'sequential'
+    });
+    if (groupDisabled) {
+        groupEdit.setDisabled(groupDisabled);
+    }
+    if (groupContent) {
+        groupEdit.setContent(groupContent);
+    }
+    if (groupDescription) {
+        groupEdit.setDescription(groupDescription);
+    }
+    // add option items
+    optionItems.forEach(optionDef => {
+        groupEdit.addItemComponent(optionDefToItemComponent(optionDef));
+    });
+    return groupEdit.getComponent();
+};
+const initSingleChoiceGroup = (key, optionItems, order) => {
+    // init group
+    return initResponseGroup('singleChoiceGroup', key, optionItems, order);
+};
+const initMultipleChoiceGroup = (key, optionItems, order) => {
+    // init group
+    return initResponseGroup('multipleChoiceGroup', key, optionItems, order);
+};
+const initDropdownGroup = (key, optionItems, order, groupDisabled, groupContent, groupDescription) => {
+    // init group
+    return initResponseGroup('dropDownGroup', key, optionItems, order, groupDisabled, groupContent ? surveys_utils_simpleGenerators.generateLocStrings(groupContent) : undefined, groupDescription ? surveys_utils_simpleGenerators.generateLocStrings(groupDescription) : undefined);
+};
+const initSliderCategoricalGroup = (key, optionItems, order, groupDisabled) => {
+    // init group
+    return initResponseGroup('sliderCategorical', key, optionItems, order, groupDisabled);
+};
+
+exports.initDropdownGroup = initDropdownGroup;
+exports.initMultipleChoiceGroup = initMultipleChoiceGroup;
+exports.initSingleChoiceGroup = initSingleChoiceGroup;
+exports.initSliderCategoricalGroup = initSliderCategoricalGroup;
+exports.optionDefToItemComponent = optionDefToItemComponent;
+//# sourceMappingURL=optionGroupComponents.js.map

package/surveys/responseTypeGenerators/optionGroupComponents.js.map

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

package/{build → surveys}/survey-editor/component-editor.d.ts

@@ -1,4 +1,4 @@
-import { ItemComponent, Expression, LocalizedObject, ComponentProperties } from "survey-engine/lib/data_types";
+import { ItemComponent, Expression, LocalizedObject, ComponentProperties } from "survey-engine/data_types";
 import { NewComponentProps } from "./data-types";
 interface ComponentEditorInt {
     getComponent: () => ItemComponent;

package/{build → surveys}/survey-editor/data-types.d.ts

@@ -1,4 +1,4 @@
-import { SurveyItemTypes } from "survey-engine/lib/data_types";
+import { SurveyItemTypes } from "survey-engine/data_types";
 export interface NewItemProps {
     itemKey?: string;
     isGroup?: boolean;

package/{build → surveys}/survey-editor/item-editor.d.ts

@@ -1,4 +1,4 @@
-import { SurveyItem, SurveyItemTypes, Expression, Validation, ItemComponent, ItemGroupComponent } from "survey-engine/lib/data_types";
+import { SurveyItem, SurveyItemTypes, Expression, Validation, ItemComponent, ItemGroupComponent } from "survey-engine/data_types";
 import { NewItemProps, NewComponentProps } from "./data-types";
 interface ItemEditorInt {
     getItem: () => SurveyItem;