case-editor-tools 1.0.0-beta.3 → 1.0.0-beta.30

package/surveys/survey-items.js

@@ -0,0 +1,302 @@
+'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-c6933791.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_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);
+    // 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);
+    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 => 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))))
+        });
+    }
+    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 => 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))))
+        });
+    }
+    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 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 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);
+    // 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 = {
+    singleChoice: generateSingleChoiceQuestion,
+    responsiveSingleChoiceArray: generateResponsiveSingleChoiceArrayQuestion,
+    responsiveBipolarLikertArray: generateResponsiveBipolarLikertArray,
+    multipleChoice: generateMultipleChoiceQuestion,
+    dateInput: generateDatePickerInput,
+    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/{build → surveys}/types/group.d.ts

@@ -1,4 +1,4 @@
-import { Expression, SurveyItem } from "survey-engine/lib/data_types";
+import { Expression, SurveyItem } from "survey-engine/data_types";
 import { ItemEditor } from "../survey-editor/item-editor";
 export declare abstract class Group {
     groupEditor: ItemEditor;

package/{build → surveys}/types/group.js

@@ -2,9 +2,9 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var logger_logger = require('../logger/logger.js');
-var surveyEditor_itemEditor = require('../item-editor-8fd24b61.js');
-var utils_simpleGenerators = require('../utils/simple-generators.js');
+var logger_logger = require('../../logger/logger.js');
+var surveys_surveyEditor_itemEditor = require('../../item-editor-c6933791.js');
+var surveys_utils_simpleGenerators = require('../utils/simple-generators.js');
 require('../survey-editor/component-editor.js');
 require('../utils/randomKeyGenerator.js');
 
@@ -12,7 +12,7 @@ class Group {
     constructor(parentKey, groupKey, selectionMethod) {
         this.parentKey = parentKey;
         this.key = [this.parentKey, groupKey].join('.');
-        this.groupEditor = new surveyEditor_itemEditor.ItemEditor(undefined, {
+        this.groupEditor = new surveys_surveyEditor_itemEditor.ItemEditor(undefined, {
             itemKey: this.key,
             isGroup: true
         });
@@ -41,7 +41,7 @@ class Group {
         return this.groupEditor.getItem();
     }
     addPageBreak() {
-        this.groupEditor.addSurveyItem(utils_simpleGenerators.generatePageBreak(this.key));
+        this.groupEditor.addSurveyItem(surveys_utils_simpleGenerators.generatePageBreak(this.key));
     }
     addItem(item, pageBreakAfter) {
         this.groupEditor.addSurveyItem(item);

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,20 @@
+'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_surveyDefinition = require('./survey-definition.js');
+require('../../logger/logger.js');
+require('../../item-editor-c6933791.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.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":";;;;;;;;;;;;;;;;;;"}

package/surveys/types/item-properties.d.ts

@@ -0,0 +1,189 @@
+import { ComponentProperties, Expression, ItemComponent, Validation } from "survey-engine/data_types";
+import { Duration } from "../../types/duration";
+export interface StyledTextComponentProp {
+    content: Map<string, string>;
+    className?: string;
+}
+export interface OptionDef {
+    key: string;
+    role: string;
+    content?: Map<string, string>;
+    items?: Array<StyledTextComponentProp> | Array<OptionDef>;
+    description?: Map<string, string>;
+    displayCondition?: Expression;
+    disabled?: Expression;
+    style?: Array<{
+        key: string;
+        value: string;
+    }>;
+    optionProps?: ComponentProperties;
+}
+export interface GenericQuestionProps {
+    parentKey: string;
+    itemKey: string;
+    version?: number;
+    questionText: Map<string, string> | Array<StyledTextComponentProp>;
+    questionSubText?: Map<string, string>;
+    titleClassName?: string;
+    helpGroupContent?: Array<{
+        content: Map<string, string>;
+        style?: Array<{
+            key: string;
+            value: string;
+        }>;
+    }>;
+    condition?: Expression;
+    topDisplayCompoments?: Array<ItemComponent>;
+    bottomDisplayCompoments?: Array<ItemComponent>;
+    isRequired?: boolean;
+    footnoteText?: Map<string, string>;
+    customValidations?: Array<Validation>;
+}
+/**
+ * Numeric Input
+ */
+export interface NumericInputProps {
+    inputLabel: Map<string, string>;
+    labelBehindInput?: boolean;
+    componentProperties?: ComponentProperties;
+    inputMaxWidth?: string;
+    disabled?: Expression;
+}
+export declare type NumericInputQuestionProps = GenericQuestionProps & NumericInputProps;
+/**
+ * Date Input
+ */
+export interface DateInputProps {
+    dateInputMode: 'YMD' | 'YM' | 'Y';
+    inputLabelText?: Map<string, string>;
+    placeholderText?: Map<string, string>;
+    minRelativeDate?: {
+        reference?: number | Expression;
+        delta: Duration;
+    };
+    maxRelativeDate?: {
+        reference?: number | Expression;
+        delta: Duration;
+    };
+}
+export declare type DateInputQuestionProps = DateInputProps & GenericQuestionProps;
+/**
+ * Text Input
+ */
+export interface TextInputProps {
+    placeholderText?: Map<string, string>;
+    inputLabel?: Map<string, string>;
+    inputMaxWidth?: string;
+    className?: string;
+    maxLength?: number;
+    disabled?: Expression;
+}
+export declare type TextInputQuestionProps = TextInputProps & GenericQuestionProps;
+export interface MultiLineTextInput extends GenericQuestionProps {
+    inputLabelText?: Map<string, string>;
+    placeholderText?: Map<string, string>;
+    maxLength?: number;
+}
+/**
+ * Cloze Question
+ */
+export interface ClozeProps {
+    items: Array<OptionDef>;
+}
+export declare type ClozeQuestionProps = ClozeProps & GenericQuestionProps;
+/**
+ * Response Single Choice Likert Array
+ */
+export declare type ResponsiveSingleChoiceArrayVariant = 'horizontal' | 'vertical' | 'table';
+export interface ResponsiveSingleChoiceArrayProps {
+    scaleOptions: Array<{
+        key: string;
+        className?: string;
+        content: Map<string, string> | StyledTextComponentProp[];
+    }>;
+    rows: Array<{
+        key: string;
+        content: Map<string, string> | StyledTextComponentProp[];
+        horizontalModeProps?: {
+            labelPlacement?: 'none' | 'top' | 'bottom';
+            className?: string;
+        };
+        verticalModeProps?: {
+            className?: string;
+        };
+        tableModeProps?: {
+            className?: string;
+        };
+    }>;
+    defaultMode: ResponsiveSingleChoiceArrayVariant;
+    responsiveModes?: {
+        sm?: ResponsiveSingleChoiceArrayVariant;
+        md?: ResponsiveSingleChoiceArrayVariant;
+        lg?: ResponsiveSingleChoiceArrayVariant;
+        xl?: ResponsiveSingleChoiceArrayVariant;
+        xxl?: ResponsiveSingleChoiceArrayVariant;
+    };
+    rgClassName?: string;
+    tableModeProps?: {
+        className?: string;
+        layout?: "fixed";
+        firstColWidth?: string;
+        optionHeaderClassName?: string;
+        hideRowBorder?: boolean;
+    };
+    horizontalModeProps?: {
+        hideRowBorder?: boolean;
+    };
+    verticalModeProps?: {
+        hideRowBorder?: boolean;
+        useReverseOptionOrder?: boolean;
+    };
+}
+export declare type ResponsiveSingleChoiceArrayQuestionProps = GenericQuestionProps & ResponsiveSingleChoiceArrayProps;
+/**
+ * Response Bipolar Likert Array
+ */
+export declare type ResponsiveBipolarLikertArrayVariant = 'withLabelRow' | 'vertical' | 'table';
+export interface ResponsiveBipolarLikertArrayProps {
+    scaleOptions: Array<{
+        key: string;
+    }>;
+    rows: Array<{
+        key: string;
+        startLabel: Map<string, string> | StyledTextComponentProp[];
+        endLabel: Map<string, string> | StyledTextComponentProp[];
+        withLabelRowModeProps?: {
+            className?: string;
+        };
+        verticalModeProps?: {
+            className?: string;
+        };
+        tableModeProps?: {
+            className?: string;
+        };
+    }>;
+    defaultMode: ResponsiveBipolarLikertArrayVariant;
+    responsiveModes?: {
+        sm?: ResponsiveBipolarLikertArrayVariant;
+        md?: ResponsiveBipolarLikertArrayVariant;
+        lg?: ResponsiveBipolarLikertArrayVariant;
+        xl?: ResponsiveBipolarLikertArrayVariant;
+        xxl?: ResponsiveBipolarLikertArrayVariant;
+    };
+    rgClassName?: string;
+    tableModeProps?: {
+        className?: string;
+        layout?: "fixed";
+        labelColWidth?: string;
+        hideRowBorder?: boolean;
+    };
+    withLabelRowModeProps?: {
+        hideRowBorder?: boolean;
+        maxLabelWidth?: string;
+        useBottomLabel?: boolean;
+    };
+    verticalModeProps?: {
+        hideRowBorder?: boolean;
+    };
+}
+export declare type ResponsiveBipolarLikertArrayQuestionProps = GenericQuestionProps & ResponsiveBipolarLikertArrayProps;

package/surveys/types/item-properties.js

@@ -0,0 +1,3 @@
+'use strict';
+
+//# sourceMappingURL=item-properties.js.map

package/surveys/types/item-properties.js.map

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

package/{build → surveys}/types/item.d.ts

@@ -1,4 +1,4 @@
-import { Expression, SurveySingleItem } from "survey-engine/lib/data_types";
+import { Expression, SurveySingleItem } from "survey-engine/data_types";
 export declare abstract class Item {
     key: string;
     item: SurveySingleItem;

package/{build/types/surveyDefinition.d.ts → surveys/types/survey-definition.d.ts}

@@ -1,19 +1,23 @@
-import { SurveyItem } from "survey-engine/lib/data_types";
+import { SurveyItem } from "survey-engine/data_types";
 import { SurveyEditor } from "../survey-editor/survey-editor";
+export declare type SurveyAvailableFor = 'public' | 'temporary_participants' | 'active_participants';
 export interface SurveyProps {
     surveyKey: string;
     name: Map<string, string>;
     description: Map<string, string>;
     durationText: Map<string, string>;
+    availableFor?: SurveyAvailableFor;
+    requireLoginBeforeSubmission?: boolean;
 }
 export declare abstract class SurveyDefinition {
     key: string;
     editor: SurveyEditor;
     constructor(props: SurveyProps);
     abstract buildSurvey(): void;
-    getSurvey(): import("survey-engine/lib/data_types").Survey;
+    getSurvey(): import("survey-engine/data_types").Survey;
     getSurveyJSON(pretty?: boolean): string;
-    addItem(item: SurveyItem): void;
+    addItem(item: SurveyItem, pageBreakAfter?: boolean): void;
+    addPageBreak(): void;
     addSurveyItemToPath(item: SurveyItem, parentKey: string): void;
     private checkDuplicateChildKeys;
 }

package/{build/types/surveyDefinition.js → surveys/types/survey-definition.js}

@@ -2,23 +2,25 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var logger_logger = require('../logger/logger.js');
-var surveyEditor_itemEditor = require('../item-editor-8fd24b61.js');
-var surveyEditor_surveyEditor = require('../survey-editor/survey-editor.js');
-var utils_simpleGenerators = require('../utils/simple-generators.js');
+var logger_logger = require('../../logger/logger.js');
+var surveys_surveyEditor_itemEditor = require('../../item-editor-c6933791.js');
+var surveys_surveyEditor_surveyEditor = require('../survey-editor/survey-editor.js');
+var surveys_utils_simpleGenerators = require('../utils/simple-generators.js');
 require('../survey-editor/component-editor.js');
 require('../utils/randomKeyGenerator.js');
 
 class SurveyDefinition {
     constructor(props) {
-        this.editor = new surveyEditor_surveyEditor.SurveyEditor();
+        this.editor = new surveys_surveyEditor_surveyEditor.SurveyEditor();
         this.editor.changeItemKey('survey', props.surveyKey);
         this.key = props.surveyKey;
         // define name and description of the survey
-        this.editor.setSurveyName(utils_simpleGenerators.generateLocStrings(props.name));
-        this.editor.setSurveyDescription(utils_simpleGenerators.generateLocStrings(props.description));
-        this.editor.setSurveyDuration(utils_simpleGenerators.generateLocStrings(props.durationText));
-        const rootItemEditor = new surveyEditor_itemEditor.ItemEditor(this.editor.findSurveyItem(props.surveyKey));
+        this.editor.setSurveyName(surveys_utils_simpleGenerators.generateLocStrings(props.name));
+        this.editor.setSurveyDescription(surveys_utils_simpleGenerators.generateLocStrings(props.description));
+        this.editor.setSurveyDuration(surveys_utils_simpleGenerators.generateLocStrings(props.durationText));
+        this.editor.setAvailableFor(props.availableFor);
+        this.editor.setRequireLoginBeforeSubmission(props.requireLoginBeforeSubmission);
+        const rootItemEditor = new surveys_surveyEditor_itemEditor.ItemEditor(this.editor.findSurveyItem(props.surveyKey));
         rootItemEditor.setSelectionMethod({ name: 'sequential' });
         this.editor.updateSurveyItem(rootItemEditor.getItem());
     }
@@ -32,8 +34,14 @@ class SurveyDefinition {
         this.checkDuplicateChildKeys();
         return this.editor.getSurveyJSON(pretty);
     }
-    addItem(item) {
+    addItem(item, pageBreakAfter) {
         this.editor.addExistingSurveyItem(item, this.key);
+        if (pageBreakAfter) {
+            this.addPageBreak();
+        }
+    }
+    addPageBreak() {
+        this.editor.addExistingSurveyItem(surveys_utils_simpleGenerators.generatePageBreak(this.key), this.key);
     }
     addSurveyItemToPath(item, parentKey) {
         this.editor.addExistingSurveyItem(item, parentKey);
@@ -57,4 +65,4 @@ class SurveyDefinition {
 }
 
 exports.SurveyDefinition = SurveyDefinition;
-//# sourceMappingURL=surveyDefinition.js.map
+//# sourceMappingURL=survey-definition.js.map