case-editor-tools 1.0.0-beta.14 → 1.0.0-beta.18

package/constants/key-definitions.d.ts

@@ -11,3 +11,4 @@ export declare const inputKey = "ic";
 export declare const numericInputKey = "num";
 export declare const datePickerKey = "date";
 export declare const matrixKey = "mat";
+export declare const clozeKey = "cloze";

package/constants/key-definitions.js

@@ -14,8 +14,10 @@ const sliderCategoricalKey = "scc";
 const inputKey = "ic";
 const numericInputKey = "num";
 const datePickerKey = "date";
-const matrixKey = "mat";
+const matrixKey = "mat";
+const clozeKey = "cloze";
 
+exports.clozeKey = clozeKey;
 exports.datePickerKey = datePickerKey;
 exports.dropDownKey = dropDownKey;
 exports.inputKey = inputKey;

package/constants/key-definitions.js.map

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

package/package.json

@@ -1,19 +1,19 @@
 {
   "name": "case-editor-tools",
   "description": "Javascript tools to simplify survey and study coding for CASE.",
-  "version": "1.0.0-beta.14",
+  "version": "1.0.0-beta.18",
   "main": "index.js",
   "license": "Apache-2.0",
   "repository": "github:case-framework/case-editor-tools",
   "devDependencies": {
     "@rollup/plugin-commonjs": "^21.0.1",
     "@rollup/plugin-node-resolve": "^13.0.6",
-    "rollup": "^2.59.0",
+    "rollup": "^2.60.2",
     "rollup-plugin-copy": "^3.4.0",
     "rollup-plugin-delete": "^2.0.0",
     "rollup-plugin-multi-input": "^1.3.1",
     "rollup-plugin-peer-deps-external": "^2.2.4",
-    "rollup-plugin-typescript2": "^0.30.0",
+    "rollup-plugin-typescript2": "^0.31.1",
     "typescript": "^4.4.4"
   },
   "scripts": {

package/surveys/index.js

@@ -14,6 +14,8 @@ require('./utils/simple-generators.js');
 require('../types/duration.js');
 require('../constants/key-definitions.js');
 require('./utils/simple-question-editor.js');
+require('./responseTypeGenerators/optionGroupComponents.js');
+require('./responseTypeGenerators/likertGroupComponents.js');
 require('../expression-utils/expressionGen.js');
 
 

package/surveys/index.js.map

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

package/surveys/responseTypeGenerators/likertGroupComponents.d.ts

@@ -0,0 +1,27 @@
+import { Expression, ItemComponent, ItemGroupComponent } from "survey-engine/lib/data_types";
+import { ResponsiveBipolarLikertArrayProps, ResponsiveSingleChoiceArrayProps } from "../types";
+export interface LikertGroupRow {
+    key: string;
+    content: Map<string, string>;
+    descriptions?: ItemComponent[];
+    hideTopBorder?: boolean;
+    hideLabels?: boolean;
+    optionDisabled?: Array<{
+        optionKey: string;
+        exp: Expression;
+    }>;
+    displayCondition?: Expression;
+}
+export declare const initLikertScaleGroup: (key: string, rows: Array<LikertGroupRow>, scaleOptions: {
+    key: string;
+    className?: string | undefined;
+    content: Map<string, string>;
+}[], stackOnSmallScreen?: boolean | undefined, displayCondition?: Expression | undefined) => ItemGroupComponent;
+export declare const initResponsiveSingleChoiceArray: (rgKey: string, props: ResponsiveSingleChoiceArrayProps, displayCondition?: Expression | undefined) => ItemGroupComponent;
+export declare const initResponsiveBipolarLikertArray: (rgKey: string, props: ResponsiveBipolarLikertArrayProps, displayCondition?: Expression | undefined) => ItemGroupComponent;
+export declare const initLikertScaleItem: (key: string, options: {
+    key: string;
+    className?: string | undefined;
+    content?: Map<string, string> | undefined;
+    disabled?: Expression | undefined;
+}[], stackOnSmallScreen?: boolean | undefined, displayCondition?: Expression | undefined) => ItemGroupComponent;

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/lib/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/lib/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;