case-editor-tools 1.0.0-beta.16 → 1.0.0-beta.17

package/constants/key-definitions.d.ts

@@ -0,0 +1,14 @@
+export declare const responseGroupKey = "rg";
+export declare const singleChoiceKey = "scg";
+export declare const likertScaleGroupKey = "lg";
+export declare const responsiveSingleChoiceArrayKey = "rsca";
+export declare const responsiveBipolarLikertArrayKey = "rsbla";
+export declare const likertScaleKey = "likert";
+export declare const multipleChoiceKey = "mcg";
+export declare const dropDownKey = "ddg";
+export declare const sliderCategoricalKey = "scc";
+export declare const inputKey = "ic";
+export declare const numericInputKey = "num";
+export declare const datePickerKey = "date";
+export declare const matrixKey = "mat";
+export declare const clozeKey = "cloze";

package/constants/key-definitions.js

@@ -0,0 +1,34 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const responseGroupKey = 'rg';
+const singleChoiceKey = 'scg';
+const likertScaleGroupKey = 'lg';
+const responsiveSingleChoiceArrayKey = 'rsca';
+const responsiveBipolarLikertArrayKey = 'rsbla';
+const likertScaleKey = 'likert';
+const multipleChoiceKey = 'mcg';
+const dropDownKey = 'ddg';
+const sliderCategoricalKey = "scc";
+const inputKey = "ic";
+const numericInputKey = "num";
+const datePickerKey = "date";
+const matrixKey = "mat";
+const clozeKey = "cloze";
+
+exports.clozeKey = clozeKey;
+exports.datePickerKey = datePickerKey;
+exports.dropDownKey = dropDownKey;
+exports.inputKey = inputKey;
+exports.likertScaleGroupKey = likertScaleGroupKey;
+exports.likertScaleKey = likertScaleKey;
+exports.matrixKey = matrixKey;
+exports.multipleChoiceKey = multipleChoiceKey;
+exports.numericInputKey = numericInputKey;
+exports.responseGroupKey = responseGroupKey;
+exports.responsiveBipolarLikertArrayKey = responsiveBipolarLikertArrayKey;
+exports.responsiveSingleChoiceArrayKey = responsiveSingleChoiceArrayKey;
+exports.singleChoiceKey = singleChoiceKey;
+exports.sliderCategoricalKey = sliderCategoricalKey;
+//# sourceMappingURL=key-definitions.js.map

package/constants/key-definitions.js.map

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

package/exporter/index.d.ts

@@ -0,0 +1,2 @@
+import { Study } from "../types/study";
+export declare const generateFilesForStudy: (study: Study, pretty?: boolean | undefined) => void;

package/exporter/index.js

@@ -0,0 +1,99 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var fs = require('fs');
+var logger_logger = require('../logger/logger.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
+
+const generateFilesForStudy = (study, pretty) => {
+    const outputName = study.outputFolderName ? study.outputFolderName : study.studyKey;
+    const outputRoot = `./output/${outputName}`;
+    logger_logger.Logger.log(`Start generating files for study ${outputName}.`);
+    if (!fs__default["default"].existsSync(outputRoot)) {
+        fs__default["default"].mkdirSync(outputRoot, { recursive: true });
+    }
+    // Surveys:
+    generateSurveyFiles(study, outputRoot, pretty);
+    // Study rules:
+    generateStudyRuleFile(study, outputRoot, pretty);
+    // Custom Study rules: (manually triggered rules)
+    generateCustomStudyRules(study, outputRoot, pretty);
+};
+const generateSurveyFiles = (study, outputPath, pretty) => {
+    if (study.surveys.length > 0) {
+        logger_logger.Logger.log(`\tSurveys:`);
+    }
+    else {
+        logger_logger.Logger.log(`\tNo surveys in the study.`);
+    }
+    const surveyOutPath = `${outputPath}/surveys`;
+    if (!fs__default["default"].existsSync(surveyOutPath)) {
+        fs__default["default"].mkdirSync(surveyOutPath, { recursive: true });
+    }
+    study.surveys.forEach(survey => {
+        const fileName = `${surveyOutPath}/${survey.key}.json`;
+        const outputObject = {
+            studyKey: study.studyKey,
+            survey: survey.getSurvey()
+        };
+        try {
+            fs__default["default"].writeFileSync(fileName, JSON.stringify(outputObject, undefined, pretty ? 2 : undefined));
+        }
+        catch (err) {
+            logger_logger.Logger.error(err);
+            return;
+        }
+        logger_logger.Logger.success(`\t\t${survey.key} saved`);
+    });
+};
+const generateStudyRuleFile = (study, outputPath, pretty) => {
+    if (!study.studyRules) {
+        logger_logger.Logger.log(`\tNo study rules in the study.`);
+        return;
+    }
+    else {
+        logger_logger.Logger.log(`\tStudy rule:`);
+    }
+    const fileName = `${outputPath}/studyRules.json`;
+    const outputObject = study.studyRules.get();
+    try {
+        fs__default["default"].writeFileSync(fileName, JSON.stringify(outputObject, undefined, pretty ? 2 : undefined));
+    }
+    catch (err) {
+        logger_logger.Logger.error(err);
+        return;
+    }
+    logger_logger.Logger.success(`\t\tStudy rules saved`);
+};
+const generateCustomStudyRules = (study, outputPath, pretty) => {
+    if (!study.customStudyRules || study.customStudyRules.length < 0) {
+        logger_logger.Logger.log(`\tNo custom study rules in the study.`);
+        return;
+    }
+    else {
+        logger_logger.Logger.log(`\tCustom study rules:`);
+    }
+    const customRulePath = `${outputPath}/customRules`;
+    if (!fs__default["default"].existsSync(customRulePath)) {
+        fs__default["default"].mkdirSync(customRulePath, { recursive: true });
+    }
+    study.customStudyRules.forEach(studyRule => {
+        const fileName = `${customRulePath}/${studyRule.name}.json`;
+        const outputObject = studyRule.rules;
+        try {
+            fs__default["default"].writeFileSync(fileName, JSON.stringify(outputObject, undefined, pretty ? 2 : undefined));
+        }
+        catch (err) {
+            logger_logger.Logger.error(err);
+            return;
+        }
+        logger_logger.Logger.success(`\t\tRule ${studyRule.name} saved`);
+    });
+};
+
+exports.generateFilesForStudy = generateFilesForStudy;
+//# sourceMappingURL=index.js.map

package/exporter/index.js.map

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

package/expression-utils/expressionGen.d.ts

@@ -0,0 +1,2 @@
+import { Expression, ExpressionName } from "survey-engine/lib/data_types";
+export declare const generateExpression: (name: ExpressionName, returnType?: "string" | "float" | undefined, ...args: any[]) => Expression;

package/{src/expression-utils/expressionGen.ts → expression-utils/expressionGen.js}

@@ -1,28 +1,31 @@
-import { Expression, ExpressionName } from "survey-engine/lib/data_types"
+'use strict';
 
+Object.defineProperty(exports, '__esModule', { value: true });
 
-export const generateExpression = (name: ExpressionName,
-    returnType?: 'string' | 'float',
-    ...args: any[]): Expression => {
-    return {
-        name: name,
-        returnType: returnType,
-        data: args.filter(a => a !== undefined).map(arg => {
-            if (typeof (arg) === 'string') {
-                return {
-                    dtype: 'str',
-                    str: arg
-                }
-            } else if (typeof (arg) === 'number') {
-                return {
-                    dtype: 'num',
-                    num: arg
-                }
-            }
-            return {
-                dtype: 'exp',
-                exp: arg as Expression
-            }
-        })
-    }
-}
+const generateExpression = (name, returnType, ...args) => {
+    return {
+        name: name,
+        returnType: returnType,
+        data: args.filter(a => a !== undefined).map(arg => {
+            if (typeof (arg) === 'string') {
+                return {
+                    dtype: 'str',
+                    str: arg
+                };
+            }
+            else if (typeof (arg) === 'number') {
+                return {
+                    dtype: 'num',
+                    num: arg
+                };
+            }
+            return {
+                dtype: 'exp',
+                exp: arg
+            };
+        })
+    };
+};
+
+exports.generateExpression = generateExpression;
+//# sourceMappingURL=expressionGen.js.map

package/expression-utils/expressionGen.js.map

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

package/expression-utils/studyEngineExpressions.d.ts

@@ -0,0 +1,114 @@
+import { Expression } from "survey-engine/lib/data_types";
+import { Duration } from "../types/duration";
+export declare const NativeStudyEngineExpressions: {
+    checkEventType: (equalsType: 'ENTER' | 'SUBMIT' | 'TIMER') => Expression;
+    checkSurveyResponseKey: (surveyKey: string) => Expression;
+    responseHasKeysAny: (itemKey: string, responseSlotKey: string, ...optionKeys: string[]) => Expression;
+    responseHasOnlyKeysOtherThan: (itemKey: string, responseSlotKey: string, ...optionKeys: string[]) => Expression;
+    getResponseValueAsNum: (itemKey: string, responseKey: string) => Expression;
+    getResponseValueAsStr: (itemKey: string, responseKey: string) => Expression;
+    countResponseItems: (itemKey: string, responseKey: string) => Expression;
+    checkConditionForOldResponses: (condition: Expression, checkType?: number | "all" | "any" | undefined, surveyKey?: string | undefined, querySince?: number | Expression | undefined, queryUntil?: number | Expression | undefined) => Expression;
+    participantState: {
+        getStudyEntryTime: () => Expression;
+        hasSurveyKeyAssigned: (surveyKey: string) => Expression;
+        getSurveyKeyAssignedFrom: (surveyKey: string) => Expression;
+        getSurveyKeyAssignedUntil: (surveyKey: string) => Expression;
+        hasStudyStatus: (status: string) => Expression;
+        hasParticipantFlag: (key: string, value: string) => Expression;
+        lastSubmissionDateOlderThan: (reference: number | Expression, surveyKey?: string | undefined) => Expression;
+    };
+    eq: (val1: Expression | string | number, val2: Expression | string | number) => Expression;
+    lt: (val1: Expression | string | number, val2: Expression | string | number) => Expression;
+    lte: (val1: Expression | string | number, val2: Expression | string | number) => Expression;
+    gt: (val1: Expression | string | number, val2: Expression | string | number) => Expression;
+    gte: (val1: Expression | string | number, val2: Expression | string | number) => Expression;
+    or: (...args: Expression[]) => Expression;
+    and: (...args: Expression[]) => Expression;
+    not: (arg: Expression) => Expression;
+    timestampWithOffset: (delta: Duration, reference?: number | Expression | undefined) => Expression;
+};
+export declare const StudyEngineActions: {
+    if: (condition: Expression, actionIfTrue: Expression, actionIfFalse?: Expression | undefined) => Expression;
+    do: (...args: Expression[]) => Expression;
+    ifThen: (condition: Expression, ...args: Expression[]) => Expression;
+    participantActions: {
+        updateStudyStatus: (status: string) => Expression;
+        updateFlag: (key: string, newValue: string) => Expression;
+        removeFlag: (key: string) => Expression;
+        assignedSurveys: {
+            add: (surveyKey: string, category: 'prio' | 'normal' | 'optional', activeFrom?: number | Expression | undefined, activeUntil?: number | Expression | undefined) => Expression;
+            removeAll: () => Expression;
+            remove: (surveyKey: string, selector: 'first' | 'last' | 'all') => Expression;
+        };
+        reports: {
+            add: (itemKey: string) => Expression;
+            removeAll: () => Expression;
+            remove: (surveyKey: string, selector: 'first' | 'last' | 'all') => Expression;
+        };
+        stopParticipation: () => Expression;
+        finishParticipation: () => Expression;
+    };
+};
+export declare const StudyEngine: {
+    singleChoice: {
+        any: (itemKey: string, ...optionKeys: string[]) => Expression;
+        none: (itemKey: string, ...optionKeys: string[]) => Expression;
+    };
+    multipleChoice: {
+        any: (itemKey: string, ...optionKeys: string[]) => Expression;
+        none: (itemKey: string, ...optionKeys: string[]) => Expression;
+        all: (itemKey: string, ...optionKeys: string[]) => Expression;
+    };
+    survey: {
+        isActive: (surveyKey: string) => Expression;
+        validFromOlderThan: (surveyKey: string, delta: Duration, reference?: number | Expression | undefined) => Expression;
+        validUntilSoonerThan: (surveyKey: string, delta: Duration, reference?: number | Expression | undefined) => Expression;
+    };
+    if: (condition: Expression, actionIfTrue: Expression, actionIfFalse?: Expression | undefined) => Expression;
+    do: (...args: Expression[]) => Expression;
+    ifThen: (condition: Expression, ...args: Expression[]) => Expression;
+    participantActions: {
+        updateStudyStatus: (status: string) => Expression;
+        updateFlag: (key: string, newValue: string) => Expression;
+        removeFlag: (key: string) => Expression;
+        assignedSurveys: {
+            add: (surveyKey: string, category: 'prio' | 'normal' | 'optional', activeFrom?: number | Expression | undefined, activeUntil?: number | Expression | undefined) => Expression;
+            removeAll: () => Expression;
+            remove: (surveyKey: string, selector: 'first' | 'last' | 'all') => Expression;
+        };
+        reports: {
+            add: (itemKey: string) => Expression;
+            removeAll: () => Expression;
+            remove: (surveyKey: string, selector: 'first' | 'last' | 'all') => Expression;
+        };
+        stopParticipation: () => Expression;
+        finishParticipation: () => Expression;
+    };
+    checkEventType: (equalsType: 'ENTER' | 'SUBMIT' | 'TIMER') => Expression;
+    checkSurveyResponseKey: (surveyKey: string) => Expression;
+    responseHasKeysAny: (itemKey: string, responseSlotKey: string, ...optionKeys: string[]) => Expression;
+    responseHasOnlyKeysOtherThan: (itemKey: string, responseSlotKey: string, ...optionKeys: string[]) => Expression;
+    getResponseValueAsNum: (itemKey: string, responseKey: string) => Expression;
+    getResponseValueAsStr: (itemKey: string, responseKey: string) => Expression;
+    countResponseItems: (itemKey: string, responseKey: string) => Expression;
+    checkConditionForOldResponses: (condition: Expression, checkType?: number | "all" | "any" | undefined, surveyKey?: string | undefined, querySince?: number | Expression | undefined, queryUntil?: number | Expression | undefined) => Expression;
+    participantState: {
+        getStudyEntryTime: () => Expression;
+        hasSurveyKeyAssigned: (surveyKey: string) => Expression;
+        getSurveyKeyAssignedFrom: (surveyKey: string) => Expression;
+        getSurveyKeyAssignedUntil: (surveyKey: string) => Expression;
+        hasStudyStatus: (status: string) => Expression;
+        hasParticipantFlag: (key: string, value: string) => Expression;
+        lastSubmissionDateOlderThan: (reference: number | Expression, surveyKey?: string | undefined) => Expression;
+    };
+    eq: (val1: Expression | string | number, val2: Expression | string | number) => Expression;
+    lt: (val1: Expression | string | number, val2: Expression | string | number) => Expression;
+    lte: (val1: Expression | string | number, val2: Expression | string | number) => Expression;
+    gt: (val1: Expression | string | number, val2: Expression | string | number) => Expression;
+    gte: (val1: Expression | string | number, val2: Expression | string | number) => Expression;
+    or: (...args: Expression[]) => Expression;
+    and: (...args: Expression[]) => Expression;
+    not: (arg: Expression) => Expression;
+    timestampWithOffset: (delta: Duration, reference?: number | Expression | undefined) => Expression;
+};

package/expression-utils/studyEngineExpressions.js

@@ -0,0 +1,283 @@
+'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
+ * @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);
+const getResponseValueAsNum = (itemKey, responseKey) => {
+    return expressionUtils_expressionGen.generateExpression('getResponseValueAsNum', 'float', itemKey, responseKey);
+};
+const getResponseValueAsStr = (itemKey, responseKey) => {
+    return expressionUtils_expressionGen.generateExpression('getResponseValueAsStr', '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');
+/**
+ * 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);
+/**
+ * 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);
+/**
+ * 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);
+/**
+ * Check if a participant has a specific study status
+ * @param status - string
+ * @returns true/false
+ */
+const hasStudyStatus = (status) => expressionUtils_expressionGen.generateExpression('getSurveyKeyAssignedUntil', undefined, status);
+/**
+ * Check if a participant flag 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);
+/**
+ * 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 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);
+/**
+ * Add or update a participant flag
+ * @param key
+ * @param newValue
+ * @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');
+/**
+ * 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
+ * @returns
+ */
+const ADD_REPORT = (itemKey) => expressionUtils_expressionGen.generateExpression('ADD_REPORT', undefined, itemKey);
+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);
+    }
+};
+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);
+    }
+};
+// ##################
+// 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 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,
+    countResponseItems,
+    // Old responses
+    checkConditionForOldResponses,
+    // Participant state:
+    participantState: {
+        getStudyEntryTime,
+        hasSurveyKeyAssigned,
+        getSurveyKeyAssignedFrom,
+        getSurveyKeyAssignedUntil,
+        hasStudyStatus,
+        hasParticipantFlag,
+        lastSubmissionDateOlderThan,
+    },
+    // 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,
+        updateFlag: UPDATE_FLAG,
+        removeFlag: REMOVE_FLAG,
+        assignedSurveys: {
+            add: ADD_NEW_SURVEY,
+            removeAll: REMOVE_ALL_SURVEYS,
+            remove: REMOVE_SURVEY_BY_KEY,
+        },
+        reports: {
+            add: ADD_REPORT,
+            removeAll: REMOVE_ALL_REPORTS,
+            remove: REMOVE_REPORT_BY_KEY,
+        },
+        // 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,
+    }, survey: {
+        isActive: hasSurveyKeyActive,
+        validFromOlderThan: hasSurveyKeyValidFromOlderThan,
+        validUntilSoonerThan: hasSurveyKeyValidUntilSoonerThan,
+    } });
+
+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":";;"}