case-editor-tools 1.0.0-beta.9 → 1.0.2

package/surveys/responseTypeGenerators/optionGroupComponents.js

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

package/surveys/responseTypeGenerators/optionGroupComponents.js.map

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

package/surveys/survey-editor/component-editor.d.ts

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

package/surveys/survey-editor/data-types.d.ts

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

package/surveys/survey-editor/item-editor.d.ts

@@ -1,4 +1,4 @@
-import { SurveyItem, SurveyItemTypes, Expression, Validation, ItemComponent, ItemGroupComponent } from "survey-engine/lib/data_types";
+import { SurveyItem, SurveyItemTypes, Expression, Validation, ItemComponent, ItemGroupComponent, ConfidentialMode } from "survey-engine/data_types";
 import { NewItemProps, NewComponentProps } from "./data-types";
 interface ItemEditorInt {
     getItem: () => SurveyItem;
@@ -36,6 +36,7 @@ export declare class ItemEditor implements ItemEditorInt {
     getItem(): SurveyItem;
     getItemJSON(pretty?: boolean): string;
     setKey(newKey: string): void;
+    setConfidentialMode(confidentialMode?: ConfidentialMode): void;
     addToFollows(key: string): void;
     removeFromFollows(key: string): void;
     clearFollows(): void;

package/surveys/survey-editor/item-editor.js

@@ -2,9 +2,10 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var surveys_surveyEditor_itemEditor = require('../../item-editor-cb5ebc1a.js');
+var surveys_surveyEditor_itemEditor = require('../../item-editor-59f51ecc.js');
 require('./component-editor.js');
 require('../utils/randomKeyGenerator.js');
+require('../../logger/logger.js');
 
 
 

package/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/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/surveys/survey-editor/survey-editor.js

@@ -2,7 +2,8 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var surveys_surveyEditor_itemEditor = require('../../item-editor-cb5ebc1a.js');
+var surveys_surveyEditor_itemEditor = require('../../item-editor-59f51ecc.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,7 +70,7 @@ 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 surveys_surveyEditor_itemEditor.ItemEditor(undefined, newItem)).getItem();
@@ -82,7 +89,7 @@ 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 surveys_surveyEditor_itemEditor.ItemEditor(undefined, newItem)).getItem();
@@ -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 (!surveys_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 (surveys_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/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/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;
@@ -63,6 +64,9 @@ export declare const SurveyEngine: {
         getNumValue: (itemKey: string, optionKey: string) => Expression;
         regexCheck: (itemKey: string, optionKey: string, pattern: string) => Expression;
     };
+    consentQuestion: {
+        accepted: (itemKey: string) => Expression;
+    };
     textInput: {
         regexCheck: (itemKey: string, pattern: string) => Expression;
     };
@@ -72,7 +76,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 +103,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/surveys/survey-engine-expressions.js

@@ -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)
@@ -329,6 +360,9 @@ const textInputRegexCheck = (itemKey, pattern) => {
 const multilineTextInputRegexCheck = (itemKey, pattern) => {
     return checkResponseValueWithRegex(itemKey, [constants_keyDefinitions.responseGroupKey, constants_keyDefinitions.inputKey].join('.'), pattern);
 };
+const consentAcceptedCondition = (itemKey) => {
+    return hasResponse(itemKey, [constants_keyDefinitions.responseGroupKey, constants_keyDefinitions.consentKey].join('.'));
+};
 const NativeSurveyEngineExpressions = {
     getters: {
         // root data reference:
@@ -355,6 +389,7 @@ const NativeSurveyEngineExpressions = {
     isDefined,
     hasResponse,
     getResponseItem,
+    parseValueAsNum,
     getResponseValueAsNum,
     getResponseValueAsStr,
     checkResponseValueWithRegex,
@@ -394,13 +429,19 @@ const SurveyEngine = Object.assign(Object.assign({}, NativeSurveyEngineExpressio
         getDateValue: multipleChoiceGetNumOptionValue,
         getNumValue: multipleChoiceGetNumOptionValue,
         regexCheck: mulitpleChoiceTextInputRegexCheck,
+    }, consentQuestion: {
+        accepted: consentAcceptedCondition,
     }, textInput: {
         regexCheck: textInputRegexCheck,
     }, multilineTextInput: {
         regexCheck: multilineTextInputRegexCheck,
     }, datePicker: {
         get: getDatePickerResponseValue,
-    }, hasParticipantFlag });
+    }, participantFlags: {
+        hasKey: hasParticipantFlagKey,
+        hasKeyAndValue: hasParticipantFlagKeyAndValue,
+        getAsNum: parseParticipantFlagAsNum,
+    }, isLoggedIn });
 
 exports.NativeSurveyEngineExpressions = NativeSurveyEngineExpressions;
 exports.SurveyEngine = SurveyEngine;

package/surveys/survey-engine-expressions.js.map

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