case-editor-tools 1.0.0-beta.7 → 1.0.0

package/expression-utils/studyEngineExpressions.js

@@ -0,0 +1,479 @@
+'use strict';
+
+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');
+
+const or = (...args) => expressionUtils_expressionGen.generateExpression('or', undefined, ...args);
+const and = (...args) => expressionUtils_expressionGen.generateExpression('and', undefined, ...args);
+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', 'MERGE'
+ * @returns if event type matches the argument, return true otherwise false
+ */
+const checkEventType = (equalsType) => expressionUtils_expressionGen.generateExpression('checkEventType', undefined, equalsType);
+/**
+ * Check if the submitted survey has a specific key
+ * @param surveyKey string to check for
+ * @returns true, if the survey has the key, false otherwise
+ */
+const checkSurveyResponseKey = (surveyKey) => expressionUtils_expressionGen.generateExpression('checkSurveyResponseKey', undefined, surveyKey);
+/**
+ * Check survey response item, if any of the defined option keys is present in the given response group
+ * @param itemKey full key to the survey item, in the form, e.g., <surveyKey>.<groupKey>.<itemKey>
+ * @param responseSlotKey full key to the response group, e.g., 'rg.scg'
+ * @param optionKeys list of option keys to be checked for.
+ * @returns true if any of the option keys are present in the item's response. If item or the response group is not found, return false.
+ */
+const responseHasKeysAny = (itemKey, responseSlotKey, ...optionKeys) => expressionUtils_expressionGen.generateExpression('responseHasKeysAny', undefined, itemKey, responseSlotKey, ...optionKeys);
+/**
+ * Check survey response item, if only other keys have been selected
+ * @param itemKey full key to the survey item, in the form, e.g., <surveyKey>.<groupKey>.<itemKey>
+ * @param responseSlotKey full key to the response group, e.g., 'rg.mcg'
+ * @param optionKeys list of option keys to be checked for.
+ * @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);
+};
+/**
+ * Method to run a check on previous responses of the participant.
+ * @param condition expression that will be evaluated on each retrieved response
+ * @param checkType - optional - 'all'/'any'/<number>: determines how to calculate the final value of the check. Default: 'all'. 'all' means, all the retrieved responses need to fulfil the condition, otherwise the methods returns false. 'any' means at least one retrieved response needs to fulfil the condtion. In both cases, if there were no responses retrieved, returns false. If a number is given here, it means, at least this many response need to fulfil the condition.
+ * @param surveyKey - optional - filter for responses of this survey.
+ * @param querySince - optional - retrieve responses that were submitted later than this timestamp. Expressions need to return a timestamp, or hard coded numbers can be used as well.
+ * @param queryUntil - optional - retrieve responses that were submitted before this timestamp. Expressions need to return a timestamp, or hard coded numbers can be used as well.
+ * @returns true/false
+ */
+const checkConditionForOldResponses = (condition, checkType, surveyKey, querySince, queryUntil) => expressionUtils_expressionGen.generateExpression('checkConditionForOldResponses', undefined, condition, checkType, surveyKey, querySince, queryUntil);
+/**
+ * Method to access the timestamp for when the participant entered the study
+ * @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 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 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
+ * @param surveyKey - optional - check for this specific survey key. If empty, it would check for all the submissions.
+ * @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);
+const gt = (val1, val2) => expressionUtils_expressionGen.generateExpression('gt', undefined, val1, val2);
+const gte = (val1, val2) => expressionUtils_expressionGen.generateExpression('gte', undefined, val1, val2);
+/**
+ * Generate a timestamp value (POSIX timestamp). T = T_ref + delta. If 'reference' is not defined, the current time will be used as a reference.
+ * @param delta offset for the timestamp generation
+ * @param reference optional - a hard coded number, or an expression that should retrieve a timestamp (e.g., surveys assigned from, or response to a date question)
+ * @returns
+ */
+const timestampWithOffset = (delta, reference) => expressionUtils_expressionGen.generateExpression('timestampWithOffset', undefined, types_duration.durationObjectToSeconds(delta), reference ? reference : undefined);
+/**
+ * Control flow method to use an if-else like structure
+ * @param condition expression, return value interpreted as boolean
+ * @param actionIfTrue if condition evaluates to true, this action will be performed.
+ * @param actionIfFalse optional, if defined and the condition returns false, this action will be performed.
+ * @returns
+ */
+const IF = (condition, actionIfTrue, actionIfFalse) => expressionUtils_expressionGen.generateExpression('IF', undefined, condition, actionIfTrue, actionIfFalse);
+/**
+ * Perform a list of expressions / actions
+ * @param args: list of expressions to be evaluated
+ * @returns
+ */
+const DO = (...args) => expressionUtils_expressionGen.generateExpression('DO', undefined, ...args);
+/**
+ * Simple if statement (without else), that checks for the condition and executes the list of actions.
+ * @param condition condition to check, return value interpreted as boolean
+ * @param args list of actions to be performed if condition evaluates to true, otherwise they are ignored
+ * @returns
+ */
+const IFTHEN = (condition, ...args) => expressionUtils_expressionGen.generateExpression('IFTHEN', undefined, condition, ...args);
+/**
+ * Update the participant's study status
+ * @param status new status value
+ * @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: 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);
+const REMOVE_FLAG = (key) => expressionUtils_expressionGen.generateExpression('REMOVE_FLAG', undefined, key);
+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');
+/**
+ * Add participant message
+ * @param messageType message type
+ * @param scheduledFor timestamp or expression returning a timestamp
+ * @returns
+ */
+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);
+    }
+    else {
+        return expressionUtils_expressionGen.generateExpression('REMOVE_SURVEY_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:
+const singleChoiceOptionsSelected = (itemKey, ...optionKeys) => expressionUtils_expressionGen.generateExpression('responseHasKeysAny', undefined, itemKey, [constants_keyDefinitions.responseGroupKey, constants_keyDefinitions.singleChoiceKey].join('.'), ...optionKeys);
+const multipleChoiceOptionsSelected = (itemKey, ...optionKeys) => expressionUtils_expressionGen.generateExpression('responseHasKeysAny', undefined, itemKey, [constants_keyDefinitions.responseGroupKey, constants_keyDefinitions.multipleChoiceKey].join('.'), ...optionKeys);
+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');
+/**
+ * If a survey is assigned with validFrom <= now and validUnil >= now
+ * @param surveyKey which survey it should check for
+ * @returns
+ */
+const hasSurveyKeyActive = (surveyKey) => {
+    return and(lte(getSurveyKeyAssignedFrom(surveyKey), timestampWithOffset({ seconds: 1 })), gte(getSurveyKeyAssignedUntil(surveyKey), timestampWithOffset({ seconds: -1 })));
+};
+/**
+ * Results of "T_ref = reference + delta" will be checked against "validFrom" of the assinged survey (if present). True T_ref > T_validFrom.
+ * @param surveyKey which survey it should check for
+ * @param delta delta time to the reference time (by default current time).
+ * @param reference optional reference time. If undefined it will take the current time.
+ * @returns
+ */
+const hasSurveyKeyValidFromOlderThan = (surveyKey, delta, reference) => {
+    return lt(getSurveyKeyAssignedFrom(surveyKey), timestampWithOffset(delta, reference));
+};
+/**
+ * Results of "T_ref = reference + delta" will be checked against "validUntil" of the assinged survey (if present). True T_ref < T_validUntil.
+ * @param surveyKey which survey it should check for
+ * @param delta delta time to the reference time (by default current time).
+ * @param reference optional reference time. If undefined it will take the current time.
+ * @returns
+ */
+const hasSurveyKeyValidUntilSoonerThan = (surveyKey, delta, reference) => {
+    return gt(timestampWithOffset(delta, reference), getSurveyKeyAssignedUntil(surveyKey));
+};
+const NativeStudyEngineExpressions = {
+    checkEventType,
+    // Response checkers
+    checkSurveyResponseKey,
+    responseHasKeysAny,
+    responseHasOnlyKeysOtherThan,
+    getResponseValueAsNum,
+    getResponseValueAsStr,
+    getSelectedKeys,
+    hasResponseKey,
+    hasResponseKeyWithValue,
+    countResponseItems,
+    // Old responses
+    checkConditionForOldResponses,
+    // Participant state:
+    participantState: {
+        getStudyEntryTime,
+        hasSurveyKeyAssigned,
+        getSurveyKeyAssignedFrom,
+        getSurveyKeyAssignedUntil,
+        hasStudyStatus,
+        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,
+    lt,
+    lte,
+    gt,
+    gte,
+    or,
+    and,
+    not,
+    // Other
+    timestampWithOffset,
+};
+const StudyEngineActions = {
+    if: IF,
+    do: DO,
+    ifThen: IFTHEN,
+    participantActions: {
+        updateStudyStatus: UPDATE_STUDY_STATUS,
+        startNewStudySession: START_NEW_STUDY_SESSION,
+        updateFlag: UPDATE_FLAG,
+        removeFlag: REMOVE_FLAG,
+        assignedSurveys: {
+            add: ADD_NEW_SURVEY,
+            removeAll: REMOVE_ALL_SURVEYS,
+            remove: REMOVE_SURVEY_BY_KEY,
+        },
+        reports: {
+            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,
+        finishParticipation,
+    }
+};
+const StudyEngine = Object.assign(Object.assign(Object.assign({}, NativeStudyEngineExpressions), StudyEngineActions), { singleChoice: {
+        any: singleChoiceOptionsSelected,
+        none: singleChoiceOnlyOtherOptionSelected
+    }, multipleChoice: {
+        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;
+exports.StudyEngine = StudyEngine;
+exports.StudyEngineActions = StudyEngineActions;
+//# sourceMappingURL=studyEngineExpressions.js.map

package/expression-utils/studyEngineExpressions.js.map

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

package/index.js

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

package/index.js.map

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