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

package/expression-utils/studyEngineExpressions.js

@@ -11,7 +11,7 @@ const and = (...args) => expressionUtils_expressionGen.generateExpression('and',
 const not = (arg) => expressionUtils_expressionGen.generateExpression('not', undefined, arg);
 /**
  * Check if the current event has the given type
- * @param equalsType string with the possible values: 'ENTER', 'SUBMIT', 'TIMER
+ * @param equalsType string with the possible values: 'ENTER', 'SUBMIT', 'TIMER', 'MERGE'
  * @returns if event type matches the argument, return true otherwise false
  */
 const checkEventType = (equalsType) => expressionUtils_expressionGen.generateExpression('checkEventType', undefined, equalsType);
@@ -37,12 +37,40 @@ const responseHasKeysAny = (itemKey, responseSlotKey, ...optionKeys) => expressi
  * @returns true if a response key is present, but is not in the list defined by optionKeys. If item or the response group is not found, returns false.
  */
 const responseHasOnlyKeysOtherThan = (itemKey, responseSlotKey, ...optionKeys) => expressionUtils_expressionGen.generateExpression('responseHasOnlyKeysOtherThan', undefined, itemKey, responseSlotKey, ...optionKeys);
+/**
+ *
+ * @param itemKey full key to the survey item, in the form, e.g., <surveyKey>.<groupKey>.<itemKey>
+ * @param responseKey  full key to the response that should exists
+ * @returns if item contains responseKey return true
+ */
+const hasResponseKey = (itemKey, responseKey) => {
+    return expressionUtils_expressionGen.generateExpression('hasResponseKey', undefined, itemKey, responseKey);
+};
+/**
+ *
+ * @param itemKey full key to the survey item, in the form, e.g., <surveyKey>.<groupKey>.<itemKey>
+ * @param responseKey full key to the response that should exists
+ * @param value the response object with the above key should have this value
+ * @returns if the response object exists and has the value return true
+ */
+const hasResponseKeyWithValue = (itemKey, responseKey, value) => {
+    return expressionUtils_expressionGen.generateExpression('hasResponseKeyWithValue', undefined, itemKey, responseKey, value);
+};
 const getResponseValueAsNum = (itemKey, responseKey) => {
     return expressionUtils_expressionGen.generateExpression('getResponseValueAsNum', 'float', itemKey, responseKey);
 };
 const getResponseValueAsStr = (itemKey, responseKey) => {
     return expressionUtils_expressionGen.generateExpression('getResponseValueAsStr', 'string', itemKey, responseKey);
 };
+/**
+ * Retrieve the selected keys from a response slot
+ * @param itemKey full key to the survey item, in the form, e.g., <surveyKey>.<groupKey>.<itemKey>
+ * @param responseKey key of the response slot, where keys should be retrieved from
+ * @returns
+ */
+const getSelectedKeys = (itemKey, responseKey) => {
+    return expressionUtils_expressionGen.generateExpression('getSelectedKeys', 'string', itemKey, responseKey);
+};
 const countResponseItems = (itemKey, responseKey) => {
     return expressionUtils_expressionGen.generateExpression('countResponseItems', undefined, itemKey, responseKey);
 };
@@ -61,37 +89,71 @@ const checkConditionForOldResponses = (condition, checkType, surveyKey, querySin
  * @returns timestamp
  */
 const getStudyEntryTime = () => expressionUtils_expressionGen.generateExpression('getStudyEntryTime');
+const getStudyEntryTimeForIncoming = () => expressionUtils_expressionGen.generateExpression('incomingState:getStudyEntryTime');
 /**
  * Determines if a specific survey key is currently assigned to the participant.
  * @param surveyKey - string - key of the survey to check for.
  * @returns true if the participant has a survey with this surveyKey assigned, otherwise false.
  */
 const hasSurveyKeyAssigned = (surveyKey) => expressionUtils_expressionGen.generateExpression('hasSurveyKeyAssigned', undefined, surveyKey);
+const hasSurveyKeyAssignedForIncoming = (surveyKey) => expressionUtils_expressionGen.generateExpression('incomingState:hasSurveyKeyAssigned', undefined, surveyKey);
 /**
  * Method to access the timestamp for a surveyKey is assigned from
  * @param surveyKey - string - key of the survey to check for.
  * @returns timestamp
  */
 const getSurveyKeyAssignedFrom = (surveyKey) => expressionUtils_expressionGen.generateExpression('getSurveyKeyAssignedFrom', undefined, surveyKey);
+const getSurveyKeyAssignedFromForIncoming = (surveyKey) => expressionUtils_expressionGen.generateExpression('incomingState:getSurveyKeyAssignedFrom', undefined, surveyKey);
 /**
  * Method to access the timestamp for a surveyKey is assigned until
  * @param surveyKey - string - key of the survey to check for.
  * @returns timestamp
  */
 const getSurveyKeyAssignedUntil = (surveyKey) => expressionUtils_expressionGen.generateExpression('getSurveyKeyAssignedUntil', undefined, surveyKey);
+const getSurveyKeyAssignedUntilForIncoming = (surveyKey) => expressionUtils_expressionGen.generateExpression('incomingState:getSurveyKeyAssignedUntil', undefined, surveyKey);
 /**
  * Check if a participant has a specific study status
  * @param status - string
  * @returns true/false
  */
 const hasStudyStatus = (status) => expressionUtils_expressionGen.generateExpression('getSurveyKeyAssignedUntil', undefined, status);
+const hasStudyStatusForIncoming = (status) => expressionUtils_expressionGen.generateExpression('incomingState:getSurveyKeyAssignedUntil', undefined, status);
 /**
- * Check if a participant flag is present
+ * Check if a participant flag with specific value is present
  * @param key look up this flag
  * @param value and for this value
  * @returns return true if key - value pair (with case sensitive matching for both key and value) is present. If any of the two is different, or participant flags is empty, it returns false.
  */
-const hasParticipantFlag = (key, value) => expressionUtils_expressionGen.generateExpression('hasParticipantFlag', undefined, key, value);
+const hasParticipantFlagKeyAndValue = (key, value) => expressionUtils_expressionGen.generateExpression('hasParticipantFlag', undefined, key, value);
+const hasParticipantFlagKeyAndValueForIncoming = (key, value) => expressionUtils_expressionGen.generateExpression('incomingState:hasParticipantFlag', undefined, key, value);
+/**
+ * Check if a participant flag is present
+ * @param key look up this flag
+ * @returns return true if key is present. If any of the two is different, or participant flags is empty, it returns false.
+ */
+const hasParticipantFlagKey = (key) => expressionUtils_expressionGen.generateExpression('hasParticipantFlagKey', undefined, key);
+const hasParticipantFlagKeyForIncoming = (key) => expressionUtils_expressionGen.generateExpression('incomingState:hasParticipantFlagKey', undefined, key);
+/**
+ * Retrieve the value of a participant flag
+ * @param key look up this flag
+ * @returns return the value or an empty string if not present
+ */
+const getParticipantFlagValue = (key) => expressionUtils_expressionGen.generateExpression('getParticipantFlagValue', undefined, key);
+const getParticipantFlagValueForIncoming = (key) => expressionUtils_expressionGen.generateExpression('incomingState:getParticipantFlagValue', undefined, key);
+/**
+ * Checks if the participant has a message type assigned (at least one)
+ * @param messageType
+ * @returns return true if a message with the given message type is assigned
+ */
+const hasMessageTypeAssigned = (messageType) => expressionUtils_expressionGen.generateExpression('hasMessageTypeAssigned', undefined, messageType);
+const hasMessageTypeAssignedForIncoming = (messageType) => expressionUtils_expressionGen.generateExpression('incomingState:hasMessageTypeAssigned', undefined, messageType);
+/**
+ * Retrieve the timestamp (scheduledFor) for a particular message type. Return 0 if not assigned.
+ * @param messageType
+ * @returns timestamp value or zero
+ */
+const getMessageNextTime = (messageType) => expressionUtils_expressionGen.generateExpression('getMessageNextTime', undefined, messageType);
+const getMessageNextTimeForIncoming = (messageType) => expressionUtils_expressionGen.generateExpression('incomingState:getMessageNextTime', undefined, messageType);
 /**
  * Check if the last submission is older than the reference timestamp
  * @param reference look up this flag
@@ -99,6 +161,7 @@ const hasParticipantFlag = (key, value) => expressionUtils_expressionGen.generat
  * @returns boolean
  */
 const lastSubmissionDateOlderThan = (reference, surveyKey) => expressionUtils_expressionGen.generateExpression('lastSubmissionDateOlderThan', undefined, reference, surveyKey);
+const lastSubmissionDateOlderThanForIncoming = (reference, surveyKey) => expressionUtils_expressionGen.generateExpression('incomingState:lastSubmissionDateOlderThan', undefined, reference, surveyKey);
 const eq = (val1, val2) => expressionUtils_expressionGen.generateExpression('eq', undefined, val1, val2);
 const lt = (val1, val2) => expressionUtils_expressionGen.generateExpression('lt', undefined, val1, val2);
 const lte = (val1, val2) => expressionUtils_expressionGen.generateExpression('lte', undefined, val1, val2);
@@ -138,10 +201,16 @@ const IFTHEN = (condition, ...args) => expressionUtils_expressionGen.generateExp
  * @returns
  */
 const UPDATE_STUDY_STATUS = (status) => expressionUtils_expressionGen.generateExpression('UPDATE_STUDY_STATUS', undefined, status);
+/**
+ * Generate and store a new session id to the participant's state
+ * @param status new status value
+ * @returns
+ */
+const START_NEW_STUDY_SESSION = () => expressionUtils_expressionGen.generateExpression('START_NEW_STUDY_SESSION', undefined);
 /**
  * Add or update a participant flag
  * @param key
- * @param newValue
+ * @param newValue: string, number or expression where result should be written in the flag's value
  * @returns
  */
 const UPDATE_FLAG = (key, newValue) => expressionUtils_expressionGen.generateExpression('UPDATE_FLAG', undefined, key, newValue);
@@ -149,11 +218,23 @@ const REMOVE_FLAG = (key) => expressionUtils_expressionGen.generateExpression('R
 const ADD_NEW_SURVEY = (surveyKey, category, activeFrom, activeUntil) => expressionUtils_expressionGen.generateExpression('ADD_NEW_SURVEY', undefined, surveyKey, activeFrom !== undefined ? activeFrom : 0, activeUntil !== undefined ? activeUntil : 0, category);
 const REMOVE_ALL_SURVEYS = () => expressionUtils_expressionGen.generateExpression('REMOVE_ALL_SURVEYS');
 /**
- * When submitting the response, item response with the given key would be added to the report array
- * @param itemKey find and add this item to the report array
+ * Add participant message
+ * @param messageType message type
+ * @param scheduledFor timestamp or expression returning a timestamp
  * @returns
  */
-const ADD_REPORT = (itemKey) => expressionUtils_expressionGen.generateExpression('ADD_REPORT', undefined, itemKey);
+const ADD_MESSAGE = (messageType, scheduledFor) => expressionUtils_expressionGen.generateExpression('ADD_MESSAGE', undefined, messageType, scheduledFor);
+/**
+ * Remove all messages scheduled for the participant
+ * @returns
+ */
+const REMOVE_ALL_MESSAGES = () => expressionUtils_expressionGen.generateExpression('REMOVE_ALL_MESSAGES', undefined);
+/**
+ * Remove all messages with this message type
+ * @param messageType message type
+ * @returns
+ */
+const REMOVE_MESSAGES_BY_TYPE = (messageType) => expressionUtils_expressionGen.generateExpression('REMOVE_MESSAGES_BY_TYPE', undefined, messageType);
 const REMOVE_SURVEY_BY_KEY = (surveyKey, selector) => {
     if (selector === 'all') {
         return expressionUtils_expressionGen.generateExpression('REMOVE_SURVEYS_BY_KEY', undefined, surveyKey);
@@ -162,14 +243,80 @@ const REMOVE_SURVEY_BY_KEY = (surveyKey, selector) => {
         return expressionUtils_expressionGen.generateExpression('REMOVE_SURVEY_BY_KEY', undefined, surveyKey, selector);
     }
 };
-const REMOVE_ALL_REPORTS = () => expressionUtils_expressionGen.generateExpression('REMOVE_ALL_REPORTS');
-const REMOVE_REPORT_BY_KEY = (surveyKey, selector) => {
-    if (selector === 'all') {
-        return expressionUtils_expressionGen.generateExpression('REMOVE_REPORTS_BY_KEY', undefined, surveyKey);
-    }
-    else {
-        return expressionUtils_expressionGen.generateExpression('REMOVE_REPORT_BY_KEY', undefined, surveyKey, selector);
-    }
+/**
+ * Initialises or resets a report for the current event
+ * @param reportKey key to be used for the report
+ */
+const INIT_REPORT = (reportKey) => {
+    return expressionUtils_expressionGen.generateExpression('INIT_REPORT', undefined, reportKey);
+};
+/**
+ * Remove the report from the list of reports to be added at the end of the event
+ * @param reportKey key of the report that should be removed
+ * @returns
+ */
+const CANCEL_REPORT = (reportKey) => {
+    return expressionUtils_expressionGen.generateExpression('CANCEL_REPORT', undefined, reportKey);
+};
+/**
+ * Remove the confidential responses with this key for the participant
+ * @param key key of the confidential responses that should be removed
+ * @returns
+ */
+const REMOVE_CONFIDENTIAL_RESPONSE_BY_KEY = (key) => {
+    return expressionUtils_expressionGen.generateExpression('REMOVE_CONFIDENTIAL_RESPONSE_BY_KEY', undefined, key);
+};
+/**
+ * Remove all confidential responses for the participant
+ * @returns
+ */
+const REMOVE_ALL_CONFIDENTIAL_RESPONSES = () => {
+    return expressionUtils_expressionGen.generateExpression('REMOVE_ALL_CONFIDENTIAL_RESPONSES', undefined);
+};
+/**
+ * Update one value attribute in a report. If report was not initialized, one will be added to the list.
+ * @param reportKey
+ * @param attributeKey update / create this attribute in the report
+ * @param value this should be the value for the given attribute
+ * @param dtype optional dtype to set info for the app how to render this data.
+ * @returns
+ */
+const UPDATE_REPORT_DATA = (reportKey, attributeKey, value, dtype) => {
+    return expressionUtils_expressionGen.generateExpression('UPDATE_REPORT_DATA', undefined, reportKey, attributeKey, value, dtype);
+};
+/**
+ * Method to remove one attribute (key and value) from the report
+ * @param reportKey
+ * @param attributeKey
+ * @returns
+ */
+const REMOVE_REPORT_DATA = (reportKey, attributeKey) => {
+    return expressionUtils_expressionGen.generateExpression('REMOVE_REPORT_DATA', undefined, reportKey, attributeKey);
+};
+const setReportIcon = (reportKey, icon) => {
+    return UPDATE_REPORT_DATA(reportKey, 'icon', icon);
+};
+const setReportMessage = (reportKey, content, asTranslationKey) => {
+    return UPDATE_REPORT_DATA(reportKey, 'message', content, asTranslationKey ? undefined : 'rawMessage');
+};
+const setReportSummary = (reportKey, content, asTranslationKey) => {
+    return UPDATE_REPORT_DATA(reportKey, 'summary', content, asTranslationKey ? undefined : 'rawMessage');
+};
+// ##################
+// Prefill rule methods:
+const GET_LAST_SURVEY_ITEM = (surveyKey, itemKey, submittedLaterThan) => {
+    return expressionUtils_expressionGen.generateExpression('GET_LAST_SURVEY_ITEM', undefined, surveyKey, itemKey, submittedLaterThan ? types_duration.durationObjectToSeconds(submittedLaterThan) : undefined);
+};
+// ##################
+// Context previous responses methods:
+const LAST_RESPONSES_BY_KEY = (surveyKey, limit) => {
+    return expressionUtils_expressionGen.generateExpression('LAST_RESPONSES_BY_KEY', undefined, surveyKey, limit);
+};
+const ALL_RESPONSES_SINCE = (sinceTimestamp) => {
+    return expressionUtils_expressionGen.generateExpression('ALL_RESPONSES_SINCE', undefined, sinceTimestamp);
+};
+const RESPONSES_SINCE_BY_KEY = (sinceTimestamp, surveyKey) => {
+    return expressionUtils_expressionGen.generateExpression('RESPONSES_SINCE_BY_KEY', undefined, sinceTimestamp, surveyKey);
 };
 // ##################
 // Extra methods:
@@ -178,6 +325,9 @@ const multipleChoiceOptionsSelected = (itemKey, ...optionKeys) => expressionUtil
 const multipleChoiceAllOfTheseSelected = (itemKey, ...optionKeys) => and(...optionKeys.map(option => expressionUtils_expressionGen.generateExpression('responseHasKeysAny', undefined, itemKey, [constants_keyDefinitions.responseGroupKey, constants_keyDefinitions.multipleChoiceKey].join('.'), option)));
 const multipleChoiceOnlyOtherKeysSelected = (itemKey, ...optionKeys) => expressionUtils_expressionGen.generateExpression('responseHasOnlyKeysOtherThan', undefined, itemKey, [constants_keyDefinitions.responseGroupKey, constants_keyDefinitions.multipleChoiceKey].join('.'), ...optionKeys);
 const singleChoiceOnlyOtherOptionSelected = (itemKey, ...optionKeys) => expressionUtils_expressionGen.generateExpression('responseHasOnlyKeysOtherThan', undefined, itemKey, [constants_keyDefinitions.responseGroupKey, constants_keyDefinitions.singleChoiceKey].join('.'), ...optionKeys);
+const consentAcceptedCondition = (itemKey) => {
+    return hasResponseKey(itemKey, [constants_keyDefinitions.responseGroupKey, constants_keyDefinitions.consentKey].join('.'));
+};
 const stopParticipation = () => UPDATE_STUDY_STATUS('inactive');
 const finishParticipation = () => UPDATE_STUDY_STATUS('finished');
 /**
@@ -216,6 +366,9 @@ const NativeStudyEngineExpressions = {
     responseHasOnlyKeysOtherThan,
     getResponseValueAsNum,
     getResponseValueAsStr,
+    getSelectedKeys,
+    hasResponseKey,
+    hasResponseKeyWithValue,
     countResponseItems,
     // Old responses
     checkConditionForOldResponses,
@@ -226,8 +379,26 @@ const NativeStudyEngineExpressions = {
         getSurveyKeyAssignedFrom,
         getSurveyKeyAssignedUntil,
         hasStudyStatus,
-        hasParticipantFlag,
+        hasParticipantFlagKeyAndValue,
+        hasParticipantFlagKey,
+        getParticipantFlagValue,
         lastSubmissionDateOlderThan,
+        hasMessageTypeAssigned,
+        getMessageNextTime,
+        incomingParticipantState: {
+            // for merge event
+            getStudyEntryTime: getStudyEntryTimeForIncoming,
+            hasSurveyKeyAssigned: hasSurveyKeyAssignedForIncoming,
+            getSurveyKeyAssignedFrom: getSurveyKeyAssignedFromForIncoming,
+            getSurveyKeyAssignedUntil: getSurveyKeyAssignedUntilForIncoming,
+            hasStudyStatus: hasStudyStatusForIncoming,
+            hasParticipantFlagKeyAndValue: hasParticipantFlagKeyAndValueForIncoming,
+            hasParticipantFlagKey: hasParticipantFlagKeyForIncoming,
+            getParticipantFlagValue: getParticipantFlagValueForIncoming,
+            lastSubmissionDateOlderThan: lastSubmissionDateOlderThanForIncoming,
+            hasMessageTypeAssigned: hasMessageTypeAssignedForIncoming,
+            getMessageNextTime: getMessageNextTimeForIncoming,
+        }
     },
     // logical and comparision
     eq,
@@ -247,6 +418,7 @@ const StudyEngineActions = {
     ifThen: IFTHEN,
     participantActions: {
         updateStudyStatus: UPDATE_STUDY_STATUS,
+        startNewStudySession: START_NEW_STUDY_SESSION,
         updateFlag: UPDATE_FLAG,
         removeFlag: REMOVE_FLAG,
         assignedSurveys: {
@@ -255,9 +427,23 @@ const StudyEngineActions = {
             remove: REMOVE_SURVEY_BY_KEY,
         },
         reports: {
-            add: ADD_REPORT,
-            removeAll: REMOVE_ALL_REPORTS,
-            remove: REMOVE_REPORT_BY_KEY,
+            init: INIT_REPORT,
+            cancel: CANCEL_REPORT,
+            updateData: UPDATE_REPORT_DATA,
+            removeData: REMOVE_REPORT_DATA,
+            // Extra methods:
+            setReportIcon,
+            setReportMessage,
+            setReportSummary,
+        },
+        messages: {
+            add: ADD_MESSAGE,
+            removeAll: REMOVE_ALL_MESSAGES,
+            remove: REMOVE_MESSAGES_BY_TYPE,
+        },
+        confidentialResponses: {
+            removeByKey: REMOVE_CONFIDENTIAL_RESPONSE_BY_KEY,
+            removeAll: REMOVE_ALL_CONFIDENTIAL_RESPONSES,
         },
         // Extra methods:
         stopParticipation,
@@ -271,10 +457,20 @@ const StudyEngine = Object.assign(Object.assign(Object.assign({}, NativeStudyEng
         any: multipleChoiceOptionsSelected,
         none: multipleChoiceOnlyOtherKeysSelected,
         all: multipleChoiceAllOfTheseSelected,
+    }, consent: {
+        accepted: consentAcceptedCondition,
     }, survey: {
         isActive: hasSurveyKeyActive,
         validFromOlderThan: hasSurveyKeyValidFromOlderThan,
         validUntilSoonerThan: hasSurveyKeyValidUntilSoonerThan,
+    }, prefillRules: {
+        GET_LAST_SURVEY_ITEM,
+    }, contextRules: {
+        previousResponses: {
+            LAST_RESPONSES_BY_KEY,
+            ALL_RESPONSES_SINCE,
+            RESPONSES_SINCE_BY_KEY,
+        }
     } });
 
 exports.NativeStudyEngineExpressions = NativeStudyEngineExpressions;

package/expression-utils/studyEngineExpressions.js.map

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

package/{item-editor-cb5ebc1a.js → item-editor-59f51ecc.js}

@@ -2,62 +2,80 @@
 
 var surveys_surveyEditor_componentEditor = require('./surveys/survey-editor/component-editor.js');
 var surveys_utils_randomKeyGenerator = require('./surveys/utils/randomKeyGenerator.js');
+var logger_logger = require('./logger/logger.js');
 
 var data_types = {};
 
 var expression = {};
 
-Object.defineProperty(expression, "__esModule", { value: true });
-expression.isExpression = (value) => {
-    return typeof (value) === 'object' && value.name !== undefined && value.name.length > 0;
-};
-expression.expressionArgParser = (arg) => {
-    switch (arg.dtype) {
-        case 'num':
-            return arg.num;
-        case 'str':
-            return arg.str;
-        case 'exp':
-            return arg.exp;
-        default:
-            return arg.str;
-    }
+Object.defineProperty(expression, '__esModule', { value: true });
+
+const isExpression = (value) => {
+    return typeof (value) === 'object' && value.name !== undefined && value.name.length > 0;
+};
+const expressionArgParser = (arg) => {
+    switch (arg.dtype) {
+        case 'num':
+            return arg.num;
+        case 'str':
+            return arg.str;
+        case 'exp':
+            return arg.exp;
+        default:
+            return arg.str;
+    }
 };
 
+expression.expressionArgParser = expressionArgParser;
+expression.isExpression = isExpression;
+
 var surveyItem = {};
 
-Object.defineProperty(surveyItem, "__esModule", { value: true });
-surveyItem.isSurveyGroupItem = (item) => {
-    const items = item.items;
-    return items !== undefined && items.length > 0;
+Object.defineProperty(surveyItem, '__esModule', { value: true });
+
+const isSurveyGroupItem$1 = (item) => {
+    const items = item.items;
+    return items !== undefined && items.length > 0;
 };
 
+surveyItem.isSurveyGroupItem = isSurveyGroupItem$1;
+
 var surveyItemComponent = {};
 
-Object.defineProperty(surveyItemComponent, "__esModule", { value: true });
-surveyItemComponent.isItemGroupComponent = (item) => {
-    const items = item.items;
-    return items !== undefined && items.length > 0;
+Object.defineProperty(surveyItemComponent, '__esModule', { value: true });
+
+const isItemGroupComponent$1 = (item) => {
+    const items = item.items;
+    return items !== undefined && items.length > 0;
 };
 
+surveyItemComponent.isItemGroupComponent = isItemGroupComponent$1;
+
 var response = {};
 
-Object.defineProperty(response, "__esModule", { value: true });
-response.isSurveyGroupItemResponse = (item) => {
-    const items = item.items;
-    return items !== undefined && items.length > 0;
+Object.defineProperty(response, '__esModule', { value: true });
+
+const isSurveyGroupItemResponse = (item) => {
+    const items = item.items;
+    return items !== undefined && items.length > 0;
 };
 
-(function (exports) {
-function __export(m) {
-    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
-}
-Object.defineProperty(exports, "__esModule", { value: true });
-__export(expression);
-__export(surveyItem);
-__export(surveyItemComponent);
-__export(response);
-}(data_types));
+response.isSurveyGroupItemResponse = isSurveyGroupItemResponse;
+
+Object.defineProperty(data_types, '__esModule', { value: true });
+
+var data_types_expression = expression;
+var data_types_surveyItem = surveyItem;
+var data_types_surveyItemComponent = surveyItemComponent;
+var data_types_response = response;
+
+
+
+data_types.expressionArgParser = data_types_expression.expressionArgParser;
+data_types.isExpression = data_types_expression.isExpression;
+var isSurveyGroupItem = data_types.isSurveyGroupItem = data_types_surveyItem.isSurveyGroupItem;
+var isItemGroupComponent = data_types.isItemGroupComponent = data_types_surveyItemComponent.isItemGroupComponent;
+data_types.isSurveyGroupItemResponse = data_types_response.isSurveyGroupItemResponse;
 
 const initialRootComp = () => {
     return {
@@ -104,6 +122,9 @@ class ItemEditor {
     setKey(newKey) {
         this.surveyItem.key = newKey;
     }
+    setConfidentialMode(confidentialMode) {
+        this.surveyItem.confidentialMode = confidentialMode;
+    }
     addToFollows(key) {
         if (!this.surveyItem.follows) {
             this.surveyItem.follows = [];
@@ -281,7 +302,7 @@ class ItemEditor {
                 obj = currentItem.components.items[ind];
                 continue;
             }
-            if (!data_types.isItemGroupComponent(obj)) {
+            if (!isItemGroupComponent(obj)) {
                 obj.items = [];
                 // leaf found
                 break;
@@ -298,7 +319,7 @@ class ItemEditor {
             return;
         }
         if (obj.items.find(it => props.key === it.key)) {
-            console.error('item already exists with key: ', props.key);
+            logger_logger.Logger.criticalError('Duplicate key: ' + props.key);
             return undefined;
         }
         const newComponent = (new surveys_surveyEditor_componentEditor.ComponentEditor(undefined, props)).getComponent();
@@ -340,7 +361,7 @@ class ItemEditor {
                 obj = currentItem.components.items[ind];
                 continue;
             }
-            if (!data_types.isItemGroupComponent(obj)) {
+            if (!isItemGroupComponent(obj)) {
                 obj.items = [];
                 // leaf found
                 break;
@@ -357,7 +378,7 @@ class ItemEditor {
             return;
         }
         if (obj.items.find(it => newComp.key === it.key)) {
-            console.error('item already exists with key: ', newComp.key);
+            logger_logger.Logger.criticalError('Duplicate key: ' + newComp.key);
             return undefined;
         }
         if (atPosition !== undefined) {
@@ -392,7 +413,7 @@ class ItemEditor {
         const parentIds = ids.slice(1, ids.length - 1);
         let obj = responseGroup;
         for (const currentKey of parentIds) {
-            if (!data_types.isItemGroupComponent(obj)) {
+            if (!isItemGroupComponent(obj)) {
                 // leaf found
                 break;
             }
@@ -433,7 +454,7 @@ class ItemEditor {
         const parentIds = ids.slice(1, ids.length - 1);
         let obj = responseGroup;
         for (const currentKey of parentIds) {
-            if (!data_types.isItemGroupComponent(obj)) {
+            if (!isItemGroupComponent(obj)) {
                 // leaf found
                 break;
             }
@@ -468,7 +489,7 @@ class ItemEditor {
                 obj = currentItem.components.items[ind];
                 continue;
             }
-            if (!data_types.isItemGroupComponent(obj)) {
+            if (!isItemGroupComponent(obj)) {
                 obj.items = [];
                 // leaf found
                 break;
@@ -517,5 +538,5 @@ class ItemEditor {
 }
 
 exports.ItemEditor = ItemEditor;
-exports.data_types = data_types;
-//# sourceMappingURL=item-editor-cb5ebc1a.js.map
+exports.isSurveyGroupItem = isSurveyGroupItem;
+//# sourceMappingURL=item-editor-59f51ecc.js.map

package/item-editor-59f51ecc.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"item-editor-59f51ecc.js","sources":["../node_modules/survey-engine/data_types/expression.js","../node_modules/survey-engine/data_types/survey-item.js","../node_modules/survey-engine/data_types/survey-item-component.js","../node_modules/survey-engine/data_types/response.js","../node_modules/survey-engine/data_types/index.js"],"sourcesContent":["'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nconst isExpression = (value) => {\r\n    return typeof (value) === 'object' && value.name !== undefined && value.name.length > 0;\r\n};\r\nconst expressionArgParser = (arg) => {\r\n    switch (arg.dtype) {\r\n        case 'num':\r\n            return arg.num;\r\n        case 'str':\r\n            return arg.str;\r\n        case 'exp':\r\n            return arg.exp;\r\n        default:\r\n            return arg.str;\r\n    }\r\n};\n\nexports.expressionArgParser = expressionArgParser;\nexports.isExpression = isExpression;\n//# sourceMappingURL=expression.js.map\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nconst isSurveyGroupItem = (item) => {\r\n    const items = item.items;\r\n    return items !== undefined && items.length > 0;\r\n};\n\nexports.isSurveyGroupItem = isSurveyGroupItem;\n//# sourceMappingURL=survey-item.js.map\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nconst isItemGroupComponent = (item) => {\r\n    const items = item.items;\r\n    return items !== undefined && items.length > 0;\r\n};\n\nexports.isItemGroupComponent = isItemGroupComponent;\n//# sourceMappingURL=survey-item-component.js.map\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nconst isSurveyGroupItemResponse = (item) => {\r\n    const items = item.items;\r\n    return items !== undefined && items.length > 0;\r\n};\n\nexports.isSurveyGroupItemResponse = isSurveyGroupItemResponse;\n//# sourceMappingURL=response.js.map\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar data_types_expression = require('./expression.js');\nvar data_types_surveyItem = require('./survey-item.js');\nvar data_types_surveyItemComponent = require('./survey-item-component.js');\nvar data_types_response = require('./response.js');\n\n\n\nexports.expressionArgParser = data_types_expression.expressionArgParser;\nexports.isExpression = data_types_expression.isExpression;\nexports.isSurveyGroupItem = data_types_surveyItem.isSurveyGroupItem;\nexports.isItemGroupComponent = data_types_surveyItemComponent.isItemGroupComponent;\nexports.isSurveyGroupItemResponse = data_types_response.isSurveyGroupItemResponse;\n//# sourceMappingURL=index.js.map\n"],"names":["isSurveyGroupItem","isItemGroupComponent","require$$0","require$$1","require$$2","require$$3"],"mappings":"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"}

package/logger/index.d.ts

@@ -0,0 +1 @@
+export { Logger } from './logger';

package/logger/index.js

@@ -0,0 +1,10 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var logger_logger = require('./logger.js');
+
+
+
+exports.Logger = logger_logger.Logger;
+//# sourceMappingURL=index.js.map

package/logger/index.js.map

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

package/package.json

@@ -1,25 +1,25 @@
 {
   "name": "case-editor-tools",
   "description": "Javascript tools to simplify survey and study coding for CASE.",
-  "version": "1.0.0-beta.9",
+  "version": "1.0.2",
   "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/plugin-node-resolve": "^13.1.3",
+    "rollup": "^2.67.0",
     "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.2",
     "typescript": "^4.4.4"
   },
   "scripts": {
     "build": "rollup -c"
   },
   "dependencies": {
-    "survey-engine": "^0.10.0"
+    "survey-engine": "^1.1.3"
   }
 }

package/surveys/index.d.ts

@@ -1,2 +1,3 @@
 export { SurveyItems } from './survey-items';
+export { SingleChoiceOptionTypes, MultipleChoiceOptionTypes, ClozeItemTypes } from './utils/optionDefGenerators';
 export { SurveyEngine } from './survey-engine-expressions';