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

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

@@ -2,11 +2,12 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var surveyEditor_itemEditor = require('../item-editor-8fd24b61.js');
+var surveys_surveyEditor_itemEditor = require('../../item-editor-c6933791.js');
 require('./component-editor.js');
 require('../utils/randomKeyGenerator.js');
+require('../../logger/logger.js');
 
 
 
-exports.ItemEditor = surveyEditor_itemEditor.ItemEditor;
+exports.ItemEditor = surveys_surveyEditor_itemEditor.ItemEditor;
 //# sourceMappingURL=item-editor.js.map

package/{build → surveys}/survey-editor/item-editor.js.map

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

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

@@ -1,4 +1,5 @@
-import { Survey, LocalizedString, SurveyItem, SurveyContextDef, Expression } from "survey-engine/lib/data_types";
+import { Survey, LocalizedString, SurveyItem, SurveyContextDef, Expression } from "survey-engine/data_types";
+import { SurveyAvailableFor } from "../types";
 import { NewItemProps } from "./data-types";
 interface SurveyEditorInt {
     setSurveyName: (name: Array<LocalizedString>) => void;
@@ -6,6 +7,8 @@ interface SurveyEditorInt {
     setSurveyDuration: (duration: Array<LocalizedString>) => void;
     setSurveyContextRules: (contextRules: SurveyContextDef) => void;
     setPrefillRules: (rules: Expression[]) => void;
+    setAvailableFor: (value?: SurveyAvailableFor) => void;
+    setRequireLoginBeforeSubmission: (value?: boolean) => void;
     changeItemKey: (oldKey: string, newKey: string) => void;
     addNewSurveyItem: (itemProps: NewItemProps, parentKey?: string, atPosition?: number) => SurveyItem | undefined;
     updateSurveyItem: (item: SurveyItem) => void;
@@ -26,6 +29,8 @@ export declare class SurveyEditor implements SurveyEditorInt {
         small: number;
         large: number;
     }): void;
+    setAvailableFor(value?: SurveyAvailableFor | undefined): void;
+    setRequireLoginBeforeSubmission(value?: boolean | undefined): void;
     setSurveyContextRules(contextRules: SurveyContextDef): void;
     setPrefillRules(rules: Expression[]): void;
     addNewSurveyItem(newItem: NewItemProps, parentKey?: string, atPosition?: number): SurveyItem | undefined;

package/{build → surveys}/survey-editor/survey-editor.js

@@ -2,7 +2,8 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var surveyEditor_itemEditor = require('../item-editor-8fd24b61.js');
+var surveys_surveyEditor_itemEditor = require('../../item-editor-c6933791.js');
+var logger_logger = require('../../logger/logger.js');
 require('./component-editor.js');
 require('../utils/randomKeyGenerator.js');
 
@@ -51,6 +52,12 @@ class SurveyEditor {
     setMaxItemPerPage(itemLimits) {
         this.survey.maxItemsPerPage = itemLimits;
     }
+    setAvailableFor(value) {
+        this.survey.availableFor = value;
+    }
+    setRequireLoginBeforeSubmission(value) {
+        this.survey.requireLoginBeforeSubmission = value;
+    }
     setSurveyContextRules(contextRules) {
         this.survey.contextRules = Object.assign({}, contextRules);
     }
@@ -63,10 +70,10 @@ class SurveyEditor {
         if (!parentKey) {
             newItem.itemKey = this.surveyKey + '.' + newItem.itemKey;
             if (this.survey.current.surveyDefinition.items.find(it => newItem.itemKey === it.key)) {
-                console.error('item already exists with key: ', newItem.itemKey);
+                logger_logger.Logger.criticalError('Duplicate key in survey: ' + newItem.itemKey);
                 return undefined;
             }
-            const item = (new surveyEditor_itemEditor.ItemEditor(undefined, newItem)).getItem();
+            const item = (new surveys_surveyEditor_itemEditor.ItemEditor(undefined, newItem)).getItem();
             if (atPosition !== undefined) {
                 this.survey.current.surveyDefinition.items.splice(atPosition, 0, item);
             }
@@ -82,10 +89,10 @@ class SurveyEditor {
         }
         newItem.itemKey = parentKey + '.' + newItem.itemKey;
         if (obj.items.find(it => newItem.itemKey === it.key)) {
-            console.error('item already exists with key: ', newItem.itemKey);
+            logger_logger.Logger.criticalError('Duplicate key in survey: ' + newItem.itemKey);
             return undefined;
         }
-        const item = (new surveyEditor_itemEditor.ItemEditor(undefined, newItem)).getItem();
+        const item = (new surveys_surveyEditor_itemEditor.ItemEditor(undefined, newItem)).getItem();
         if (atPosition !== undefined) {
             obj.items.splice(atPosition, 0, item);
         }
@@ -101,7 +108,7 @@ class SurveyEditor {
             return;
         }
         if (parent.items.find(it => surveyItem.key === it.key)) {
-            console.error('item already exists with key: ', surveyItem.key);
+            logger_logger.Logger.criticalError('Duplicate key in survey: ' + surveyItem.key);
             return undefined;
         }
         if (atPosition !== undefined) {
@@ -175,7 +182,7 @@ class SurveyEditor {
                 obj = this.survey.current.surveyDefinition;
                 continue;
             }
-            if (!surveyEditor_itemEditor.data_types.isSurveyGroupItem(obj)) {
+            if (!surveys_surveyEditor_itemEditor.isSurveyGroupItem(obj)) {
                 console.warn('survey item is not a group: ', obj.key);
                 return;
             }
@@ -215,7 +222,7 @@ class SurveyEditor {
     }
     changeItemKeyForSubtree(currentItem, newKey) {
         currentItem = Object.assign({}, currentItem);
-        if (surveyEditor_itemEditor.data_types.isSurveyGroupItem(currentItem)) {
+        if (surveys_surveyEditor_itemEditor.isSurveyGroupItem(currentItem)) {
             currentItem.items = currentItem.items.map(item => {
                 const newSubkey = newKey + '.' + item.key.slice(item.key.lastIndexOf('.') + 1);
                 return this.changeItemKeyForSubtree(item, newSubkey);

package/{build → surveys}/survey-editor/survey-editor.js.map

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

package/{build/expression-utils/surveyEngineExpressions.d.ts → surveys/survey-engine-expressions.d.ts}

@@ -1,4 +1,4 @@
-import { Expression } from "survey-engine/lib/data_types";
+import { Expression } from "survey-engine/data_types";
 import { Duration } from "../types/duration";
 export declare const NativeSurveyEngineExpressions: {
     getters: {
@@ -22,6 +22,7 @@ export declare const NativeSurveyEngineExpressions: {
     isDefined: (arg: Expression) => Expression;
     hasResponse: (itemKey: string, responseKey: string) => Expression;
     getResponseItem: (itemKey: string, responseKey: string) => Expression;
+    parseValueAsNum: (valueRef: Expression) => Expression;
     getResponseValueAsNum: (itemKey: string, responseKey: string) => Expression;
     getResponseValueAsStr: (itemKey: string, responseKey: string) => Expression;
     checkResponseValueWithRegex: (itemKey: string, responseKey: string, regexPattern: string) => Expression;
@@ -72,7 +73,12 @@ export declare const SurveyEngine: {
     datePicker: {
         get: (itemKey: string) => Expression;
     };
-    hasParticipantFlag: (key: string, value: string) => Expression;
+    participantFlags: {
+        hasKey: (key: string) => Expression;
+        hasKeyAndValue: (key: string, value: string) => Expression;
+        getAsNum: (key: string) => Expression;
+    };
+    isLoggedIn: () => Expression;
     getters: {
         getContext: () => Expression;
         getResponses: () => Expression;
@@ -94,6 +100,7 @@ export declare const SurveyEngine: {
     isDefined: (arg: Expression) => Expression;
     hasResponse: (itemKey: string, responseKey: string) => Expression;
     getResponseItem: (itemKey: string, responseKey: string) => Expression;
+    parseValueAsNum: (valueRef: Expression) => Expression;
     getResponseValueAsNum: (itemKey: string, responseKey: string) => Expression;
     getResponseValueAsStr: (itemKey: string, responseKey: string) => Expression;
     checkResponseValueWithRegex: (itemKey: string, responseKey: string, regexPattern: string) => Expression;

package/{build/expression-utils/surveyEngineExpressions.js → surveys/survey-engine-expressions.js}

@@ -4,7 +4,7 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var constants_keyDefinitions = require('../constants/key-definitions.js');
 var types_duration = require('../types/duration.js');
-var expressionUtils_expressionGen = require('./expressionGen.js');
+var expressionUtils_expressionGen = require('../expression-utils/expressionGen.js');
 
 /**
  * Logical OR expression
@@ -61,6 +61,14 @@ const gte = (val1, val2) => expressionUtils_expressionGen.generateExpression('gt
  * @returns
  */
 const timestampWithOffset = (delta, reference) => expressionUtils_expressionGen.generateExpression('timestampWithOffset', undefined, types_duration.durationObjectToSeconds(delta), reference ? reference : undefined);
+/**
+ * Parse the result of an expression as a number
+ * @param valueRef expression that returns a string with the value that should be parsed
+ * @returns expression that returns the value or undefined
+ */
+const parseValueAsNum = (valueRef) => {
+    return expressionUtils_expressionGen.generateExpression('parseValueAsNum', 'float', valueRef);
+};
 /**
  * Extract value from a response if exits parsed as a number
  * @param itemKey full key of the survey item (e.g. SURVEY.GROUP.QUESTIONKEY)
@@ -286,15 +294,38 @@ const getSurveyItemValidation = (itemKey, validationKey) => {
 const dateResponseDiffFromNow = (itemKey, responseKey, unit, ignoreSign) => {
     return expressionUtils_expressionGen.generateExpression('dateResponseDiffFromNow', undefined, itemKey, responseKey, unit, ignoreSign ? 1 : undefined);
 };
+/**
+ * Check participant flags object if contains the specified key value pair
+ * @param key retrieve participant flag's value for this key
+ * @returns
+ */
+const parseParticipantFlagAsNum = (key) => {
+    return parseValueAsNum(getAttribute(getAttribute(getContext(), 'participantFlags'), key));
+};
+/**
+ * Check participant flags object if contains the specified key value pair
+ * @param key retrieve participant flag's value for this key
+ * @returns
+ */
+const hasParticipantFlagKey = (key) => {
+    return isDefined(getAttribute(getAttribute(getContext(), 'participantFlags'), key));
+};
 /**
  * Check participant flags object if contains the specified key value pair
  * @param key retrieve participant flag's value for this key
  * @param value string value to be checked for a match
  * @returns
  */
-const hasParticipantFlag = (key, value) => {
+const hasParticipantFlagKeyAndValue = (key, value) => {
     return eq(getAttribute(getAttribute(getContext(), 'participantFlags'), key), value);
 };
+/**
+ * Check if the participant is logged in currently.
+ * @returns true if context variable isLoggedIn is set and true
+ */
+const isLoggedIn = () => {
+    return and(isDefined(getAttribute(getContext(), 'isLoggedIn')), getAttribute(getContext(), 'isLoggedIn'));
+};
 /**
  * Counts the number of selected options in a multiple choice question
  * @param itemKey full key of the survey item (e.g. SURVEY.GROUP.QUESTIONKEY)
@@ -355,6 +386,7 @@ const NativeSurveyEngineExpressions = {
     isDefined,
     hasResponse,
     getResponseItem,
+    parseValueAsNum,
     getResponseValueAsNum,
     getResponseValueAsStr,
     checkResponseValueWithRegex,
@@ -400,8 +432,12 @@ const SurveyEngine = Object.assign(Object.assign({}, NativeSurveyEngineExpressio
         regexCheck: multilineTextInputRegexCheck,
     }, datePicker: {
         get: getDatePickerResponseValue,
-    }, hasParticipantFlag });
+    }, participantFlags: {
+        hasKey: hasParticipantFlagKey,
+        hasKeyAndValue: hasParticipantFlagKeyAndValue,
+        getAsNum: parseParticipantFlagAsNum,
+    }, isLoggedIn });
 
 exports.NativeSurveyEngineExpressions = NativeSurveyEngineExpressions;
 exports.SurveyEngine = SurveyEngine;
-//# sourceMappingURL=surveyEngineExpressions.js.map
+//# sourceMappingURL=survey-engine-expressions.js.map

package/{build/expression-utils/surveyEngineExpressions.js.map → surveys/survey-engine-expressions.js.map}

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

package/surveys/survey-items.d.ts

@@ -0,0 +1,66 @@
+import { ItemGroupComponent, Expression, ItemComponent, SurveyItem, ExpressionArg, ResponseComponent } from "survey-engine/data_types";
+import { ClozeQuestionProps, DateInputQuestionProps, GenericQuestionProps, MultiLineTextInput, NumericInputQuestionProps, OptionDef, ResponsiveBipolarLikertArrayQuestionProps, ResponsiveSingleChoiceArrayQuestionProps, TextInputQuestionProps } from "./types/item-properties";
+import { LikertGroupRow } from "./responseTypeGenerators/likertGroupComponents";
+interface OptionQuestionProps extends GenericQuestionProps {
+    responseOptions: Array<OptionDef>;
+}
+interface LikertGroupQuestionProps extends GenericQuestionProps {
+    rows: Array<LikertGroupRow>;
+    scaleOptions: Array<{
+        key: string;
+        className?: string;
+        content: Map<string, string>;
+    }>;
+    stackOnSmallScreen?: boolean;
+}
+interface NumericSliderProps extends GenericQuestionProps {
+    sliderLabel: Map<string, string>;
+    noResponseLabel: Map<string, string>;
+    min?: number | ExpressionArg;
+    max?: number | ExpressionArg;
+    stepSize?: number | ExpressionArg;
+}
+interface CustomResponseItem extends ResponseComponent {
+    mapToRole?: 'singleChoiceGroup' | 'multipleChoiceGroup' | 'input';
+    items?: ItemComponent[];
+}
+interface CustomQuestionProps extends GenericQuestionProps {
+    responseItemDefs: CustomResponseItem[];
+}
+interface DisplayProps {
+    parentKey: string;
+    itemKey: string;
+    content: Array<ItemComponent>;
+    condition?: Expression;
+}
+interface EQ5DHealthSliderProps {
+    role: 'eq5d-health-indicator';
+    key: string;
+    displayCondition?: Expression;
+    disabled?: Expression;
+    instructionText: Map<string, string>;
+    valueBoxText: Map<string, string>;
+    maxHealthText: Map<string, string>;
+    minHealthText: Map<string, string>;
+}
+export declare const initEQ5DHealthIndicatorQuestion: (props: EQ5DHealthSliderProps) => ItemGroupComponent;
+export declare const SurveyItems: {
+    singleChoice: (props: OptionQuestionProps) => SurveyItem;
+    responsiveSingleChoiceArray: (props: ResponsiveSingleChoiceArrayQuestionProps) => SurveyItem;
+    responsiveBipolarLikertArray: (props: ResponsiveBipolarLikertArrayQuestionProps) => SurveyItem;
+    multipleChoice: (props: OptionQuestionProps) => SurveyItem;
+    dateInput: (props: DateInputQuestionProps) => SurveyItem;
+    textInput: (props: TextInputQuestionProps) => SurveyItem;
+    clozeQuestion: (props: ClozeQuestionProps) => SurveyItem;
+    numericInput: (props: NumericInputQuestionProps) => SurveyItem;
+    multilineTextInput: (props: MultiLineTextInput) => SurveyItem;
+    dropDown: (props: OptionQuestionProps) => SurveyItem;
+    numericSlider: (props: NumericSliderProps) => SurveyItem;
+    display: (props: DisplayProps) => SurveyItem;
+    surveyEnd: (parentKey: string, content: Map<string, string>, condition?: Expression | undefined) => SurveyItem;
+    customQuestion: (props: CustomQuestionProps) => SurveyItem;
+    old: {
+        simpleLikertGroup: (props: LikertGroupQuestionProps) => SurveyItem;
+    };
+};
+export {};

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;