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

package/surveys/survey-engine-expressions.d.ts

@@ -0,0 +1,120 @@
+import { Expression } from "survey-engine/lib/data_types";
+import { Duration } from "../types/duration";
+export declare const NativeSurveyEngineExpressions: {
+    getters: {
+        getContext: () => Expression;
+        getResponses: () => Expression;
+        getRenderedItems: () => Expression;
+        getAttribute: (objectRef: Expression, attributeName: string) => Expression;
+        getArrayItemAtIndex: (arrayRef: Expression, index: number) => Expression;
+        getArrayItemByKey: (arrayRef: Expression, itemKey: string) => Expression;
+        getObjByHierarchicalKey: (objectRef: Expression, itemKey: string) => Expression;
+        getNestedObjectByKey: (objectRef: Expression, itemKey: string) => Expression;
+    };
+    previousResponses: {
+        getItemsByKey: (itemKey: string) => Expression;
+        getLastItemByKey: (itemKey: string) => Expression;
+        getAllResponsesForSurveyKey: (surveyKey: string) => Expression;
+        filterResponsesByIncludesKeys: (responsesRef: Expression, itemKey: string, searchKeys: string) => Expression;
+        filterResponsesByValue: (responsesRef: Expression, itemKey: string, expectedValue: string) => Expression;
+        getLastFromSurveyItemResponses: (responsesRef: Expression) => Expression;
+    };
+    isDefined: (arg: Expression) => Expression;
+    hasResponse: (itemKey: string, responseKey: string) => Expression;
+    getResponseItem: (itemKey: string, responseKey: string) => Expression;
+    getResponseValueAsNum: (itemKey: string, responseKey: string) => Expression;
+    getResponseValueAsStr: (itemKey: string, responseKey: string) => Expression;
+    checkResponseValueWithRegex: (itemKey: string, responseKey: string, regexPattern: string) => Expression;
+    responseHasKeysAny: (itemKey: string, responseKey: string, ...optionKeys: string[]) => Expression;
+    responseHasKeysAll: (itemKey: string, responseKey: string, ...optionKeys: string[]) => Expression;
+    responseHasOnlyKeysOtherThan: (itemKey: string, responseKey: string, ...optionKeys: string[]) => Expression;
+    getSurveyItemValidation: (itemKey: string, validationKey: string) => Expression;
+    dateResponseDiffFromNow: (itemKey: string, responseKey: string, unit: 'years' | 'months' | 'days' | 'hours' | 'minutes' | 'seconds', ignoreSign?: boolean | undefined) => Expression;
+    countResponseItems: (itemKey: string, responseKey: string) => Expression;
+    compare: {
+        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;
+    };
+    logic: {
+        or: (...args: Expression[]) => Expression;
+        and: (...args: Expression[]) => Expression;
+        not: (arg: Expression) => Expression;
+    };
+    getSecondsSince: (referenceTime: Expression) => Expression;
+    timestampWithOffset: (delta: Duration, reference?: number | Expression | undefined) => Expression;
+};
+export declare const SurveyEngine: {
+    singleChoice: {
+        any: (itemKey: string, ...optionKeys: string[]) => Expression;
+        none: (itemKey: string, ...optionKeys: string[]) => Expression;
+        getDateValue: (itemKey: string, optionKey: string) => Expression;
+        getNumValue: (itemKey: string, optionKey: string) => Expression;
+        regexCheck: (itemKey: string, optionKey: string, pattern: string) => Expression;
+    };
+    multipleChoice: {
+        any: (itemKey: string, ...optionKeys: string[]) => Expression;
+        none: (itemKey: string, ...optionKeys: string[]) => Expression;
+        all: (itemKey: string, ...optionKeys: string[]) => Expression;
+        selectionCount: (itemKey: string) => Expression;
+        getDateValue: (itemKey: string, optionKey: string) => Expression;
+        getNumValue: (itemKey: string, optionKey: string) => Expression;
+        regexCheck: (itemKey: string, optionKey: string, pattern: string) => Expression;
+    };
+    textInput: {
+        regexCheck: (itemKey: string, pattern: string) => Expression;
+    };
+    multilineTextInput: {
+        regexCheck: (itemKey: string, pattern: string) => Expression;
+    };
+    datePicker: {
+        get: (itemKey: string) => Expression;
+    };
+    hasParticipantFlag: (key: string, value: string) => Expression;
+    getters: {
+        getContext: () => Expression;
+        getResponses: () => Expression;
+        getRenderedItems: () => Expression;
+        getAttribute: (objectRef: Expression, attributeName: string) => Expression;
+        getArrayItemAtIndex: (arrayRef: Expression, index: number) => Expression;
+        getArrayItemByKey: (arrayRef: Expression, itemKey: string) => Expression;
+        getObjByHierarchicalKey: (objectRef: Expression, itemKey: string) => Expression;
+        getNestedObjectByKey: (objectRef: Expression, itemKey: string) => Expression;
+    };
+    previousResponses: {
+        getItemsByKey: (itemKey: string) => Expression;
+        getLastItemByKey: (itemKey: string) => Expression;
+        getAllResponsesForSurveyKey: (surveyKey: string) => Expression;
+        filterResponsesByIncludesKeys: (responsesRef: Expression, itemKey: string, searchKeys: string) => Expression;
+        filterResponsesByValue: (responsesRef: Expression, itemKey: string, expectedValue: string) => Expression;
+        getLastFromSurveyItemResponses: (responsesRef: Expression) => Expression;
+    };
+    isDefined: (arg: Expression) => Expression;
+    hasResponse: (itemKey: string, responseKey: string) => Expression;
+    getResponseItem: (itemKey: string, responseKey: string) => Expression;
+    getResponseValueAsNum: (itemKey: string, responseKey: string) => Expression;
+    getResponseValueAsStr: (itemKey: string, responseKey: string) => Expression;
+    checkResponseValueWithRegex: (itemKey: string, responseKey: string, regexPattern: string) => Expression;
+    responseHasKeysAny: (itemKey: string, responseKey: string, ...optionKeys: string[]) => Expression;
+    responseHasKeysAll: (itemKey: string, responseKey: string, ...optionKeys: string[]) => Expression;
+    responseHasOnlyKeysOtherThan: (itemKey: string, responseKey: string, ...optionKeys: string[]) => Expression;
+    getSurveyItemValidation: (itemKey: string, validationKey: string) => Expression;
+    dateResponseDiffFromNow: (itemKey: string, responseKey: string, unit: 'years' | 'months' | 'days' | 'hours' | 'minutes' | 'seconds', ignoreSign?: boolean | undefined) => Expression;
+    countResponseItems: (itemKey: string, responseKey: string) => Expression;
+    compare: {
+        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;
+    };
+    logic: {
+        or: (...args: Expression[]) => Expression;
+        and: (...args: Expression[]) => Expression;
+        not: (arg: Expression) => Expression;
+    };
+    getSecondsSince: (referenceTime: Expression) => Expression;
+    timestampWithOffset: (delta: Duration, reference?: number | Expression | undefined) => Expression;
+};

package/surveys/survey-engine-expressions.js

@@ -0,0 +1,407 @@
+'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('../expression-utils/expressionGen.js');
+
+/**
+ * Logical OR expression
+ * @returns expression that return true if any of the arguments evaluates to true
+ */
+const or = (...args) => expressionUtils_expressionGen.generateExpression('or', undefined, ...args);
+/**
+ * Logical AND expression
+ * @returns expression that return true if all of the arguments evaluates to true
+ */
+const and = (...args) => expressionUtils_expressionGen.generateExpression('and', undefined, ...args);
+/**
+ * Logical NOT expression
+ * @returns expression that negates the argument - true if arg is false, false if arg is true
+ */
+const not = (arg) => expressionUtils_expressionGen.generateExpression('not', undefined, arg);
+/**
+ * [===] Equality check
+ * @returns expression that return true of both arguments are equal
+ */
+const eq = (val1, val2) => expressionUtils_expressionGen.generateExpression('eq', undefined, val1, val2);
+/**
+ * [<] val1 is less than val2?
+ * @param val1
+ * @param val2
+ * @returns
+ */
+const lt = (val1, val2) => expressionUtils_expressionGen.generateExpression('lt', undefined, val1, val2);
+/**
+ * [<=] val1 is less than  or equal to val2?
+ * @param val1
+ * @param val2
+ * @returns
+ */
+const lte = (val1, val2) => expressionUtils_expressionGen.generateExpression('lte', undefined, val1, val2);
+/**
+ * [>] val1 is greater than val2?
+ * @param val1
+ * @param val2
+ * @returns
+ */
+const gt = (val1, val2) => expressionUtils_expressionGen.generateExpression('gt', undefined, val1, val2);
+/**
+ * [>=] val1 is greater than or equal to val2?
+ * @param val1
+ * @param val2
+ * @returns
+ */
+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);
+/**
+ * Extract value from a response if exits parsed as a number
+ * @param itemKey full key of the survey item (e.g. SURVEY.GROUP.QUESTIONKEY)
+ * @param responseKey full key of the response slot inside the item (e.g. rg.num)
+ * @returns expression that returns the value or undefined
+ */
+const getResponseValueAsNum = (itemKey, responseKey) => {
+    return expressionUtils_expressionGen.generateExpression('getResponseValueAsNum', 'float', itemKey, responseKey);
+};
+/**
+ * Extract value from a response if exits as string
+ * @param itemKey full key of the survey item (e.g. SURVEY.GROUP.QUESTIONKEY)
+ * @param responseKey full key of the response slot inside the item (e.g. rg.input)
+ * @returns expression that returns the value or undefined
+ */
+const getResponseValueAsStr = (itemKey, responseKey) => {
+    return expressionUtils_expressionGen.generateExpression('getResponseValueAsStr', 'string', itemKey, responseKey);
+};
+/**
+ * Count the number of existing response items inside the slot
+ * @param itemKey full key of the survey item (e.g. SURVEY.GROUP.QUESTIONKEY)
+ * @param responseKey full key of the response slot inside the item (e.g. rg.mcg)
+ * @returns expression that returns the number of items of the response slot
+ */
+const countResponseItems = (itemKey, responseKey) => {
+    return expressionUtils_expressionGen.generateExpression('countResponseItems', undefined, itemKey, responseKey);
+};
+/**
+ * Evaluates an expression and checks if the return value is defined
+ * @param arg Expression with a potentially undefined return value
+ * @returns
+ */
+const isDefined = (arg) => {
+    return expressionUtils_expressionGen.generateExpression('isDefined', undefined, arg);
+};
+/**
+ * Reference to the context variable storing e.g. participant infos
+ * @returns
+ */
+const getContext = () => {
+    return expressionUtils_expressionGen.generateExpression('getContext', undefined);
+};
+/**
+ * Reference to the current response array
+ * @returns
+ */
+const getResponses = () => {
+    return expressionUtils_expressionGen.generateExpression('getResponses', undefined);
+};
+/**
+ * Reference to the list of currently active survey questions
+ * @returns
+ */
+const getRenderedItems = () => {
+    return expressionUtils_expressionGen.generateExpression('getRenderedItems', undefined);
+};
+/**
+ * Extract value of an attribute of the referenced object
+ * @param objectRef expression that references an object
+ * @param attributeName name of the attribute to be extracted
+ * @returns
+ */
+const getAttribute = (objectRef, attributeName) => {
+    return expressionUtils_expressionGen.generateExpression('getAttribute', undefined, objectRef, attributeName);
+};
+/**
+ * Extract value at index
+ * @param arrayRef expression that references an array
+ * @param index position in the array
+ * @returns
+ */
+const getArrayItemAtIndex = (arrayRef, index) => {
+    return expressionUtils_expressionGen.generateExpression('getArrayItemAtIndex', undefined, arrayRef, index);
+};
+/**
+ * Extract value with a specific key
+ * @param arrayRef expression that references an array
+ * @param itemKey key of the target item
+ * @returns
+ */
+const getArrayItemByKey = (arrayRef, itemKey) => {
+    return expressionUtils_expressionGen.generateExpression('getArrayItemByKey', undefined, arrayRef, itemKey);
+};
+/**
+ * Extract value with a specific key from the hierarchical tree
+ * @param objectRef expression that references the root object
+ * @param itemKey key of the target item
+ * @returns
+ */
+const getObjByHierarchicalKey = (objectRef, itemKey) => {
+    return expressionUtils_expressionGen.generateExpression('getObjByHierarchicalKey', undefined, objectRef, itemKey);
+};
+/**
+ * Extract value with a specific key from the tree
+ * @param objectRef expression that references the root object
+ * @param itemKey key of the target item
+ * @returns
+ */
+const getNestedObjectByKey = (objectRef, itemKey) => {
+    return expressionUtils_expressionGen.generateExpression('getNestedObjectByKey', undefined, objectRef, itemKey);
+};
+/**
+ * Retrieve items by the same key from the previous responses arrays
+ * @param itemKey key of the target item
+ * @returns
+ */
+const findPreviousSurveyResponsesByKey = (itemKey) => {
+    return expressionUtils_expressionGen.generateExpression('findPreviousSurveyResponsesByKey', undefined, itemKey);
+};
+/**
+ * Retrieve all previous responses for a specific survey key
+ * @param surveyKey key of the target survey
+ * @returns
+ */
+const getPreviousResponses = (surveyKey) => {
+    return expressionUtils_expressionGen.generateExpression('getPreviousResponses', undefined, surveyKey);
+};
+/**
+ * Retrieve last item for a specific key from the previous responses arrays
+ * @param itemKey key of the target item
+ * @returns
+ */
+const getLastFromSurveyResponses = (itemKey) => {
+    return expressionUtils_expressionGen.generateExpression('getLastFromSurveyResponses', undefined, itemKey);
+};
+const filterResponsesByIncludesKeys = (responsesRef, itemKey, searchKeys) => {
+    return expressionUtils_expressionGen.generateExpression('filterResponsesByIncludesKeys', undefined, responsesRef, itemKey, ...searchKeys);
+};
+const filterResponsesByValue = (responsesRef, itemKey, expectedValue) => {
+    return expressionUtils_expressionGen.generateExpression('filterResponsesByValue', undefined, responsesRef, itemKey, expectedValue);
+};
+/**
+ * Given a list of previous responses (list of single responses), retrieve the latest one.
+ * @param responsesRef expression that references a list of response items
+ * @returns
+ */
+const getLastFromSurveyItemResponses = (responsesRef) => {
+    return expressionUtils_expressionGen.generateExpression('getLastFromSurveyItemResponses', undefined, responsesRef);
+};
+/**
+ * Calculate time difference between "now" and the reference time in seconds
+ * @param referenceTime expression that should return a time (in POSIX timestamp form)
+ * @returns expression returns undefined if rerefence time is evaluated to undefined
+ */
+const getSecondsSince = (referenceTime) => {
+    return expressionUtils_expressionGen.generateExpression('getSecondsSince', undefined, referenceTime);
+};
+/**
+ * Get response object for a specific item and slot
+ * @param itemKey full key of the survey item (e.g. SURVEY.GROUP.QUESTIONKEY)
+ * @param responseKey full key of the response slot inside the item (e.g. rg.num)
+ * @returns
+ */
+const getResponseItem = (itemKey, responseKey) => {
+    return expressionUtils_expressionGen.generateExpression('getResponseItem', undefined, itemKey, responseKey);
+};
+/**
+ * Check if an item has a specific response object (by key)
+ * @param itemKey full key of the survey item (e.g. SURVEY.GROUP.QUESTIONKEY)
+ * @param responseKey full key of the response slot inside the item (e.g. rg.num)
+ * @returns
+ */
+const hasResponse = (itemKey, responseKey) => {
+    return expressionUtils_expressionGen.generateExpression('hasResponse', undefined, itemKey, responseKey);
+};
+/**
+ * Evaluate if regex expression is fulfilled on the responses value attribute
+ * @param itemKey full key of the survey item (e.g. SURVEY.GROUP.QUESTIONKEY)
+ * @param responseKey full key of the response slot inside the item (e.g. rg.input)
+ * @param regexPattern regex pattern to check value against
+ * @returns
+ */
+const checkResponseValueWithRegex = (itemKey, responseKey, regexPattern) => {
+    return expressionUtils_expressionGen.generateExpression('checkResponseValueWithRegex', undefined, itemKey, responseKey, regexPattern);
+};
+/**
+ * Check if any of the following options is selected
+ * @param itemKey full key of the survey item (e.g. SURVEY.GROUP.QUESTIONKEY)
+ * @param responseKey full key of the response slot inside the item (e.g. rg.scg)
+ * @param optionKeys keys of the option that should be selected
+ * @returns
+ */
+const responseHasKeysAny = (itemKey, responseKey, ...optionKeys) => {
+    return expressionUtils_expressionGen.generateExpression('responseHasKeysAny', undefined, itemKey, responseKey, ...optionKeys);
+};
+/**
+ * Check if all of the following options are selected
+ * @param itemKey full key of the survey item (e.g. SURVEY.GROUP.QUESTIONKEY)
+ * @param responseKey full key of the response slot inside the item (e.g. rg.scg)
+ * @param optionKeys keys of the option that should be selected
+ * @returns
+ */
+const responseHasKeysAll = (itemKey, responseKey, ...optionKeys) => {
+    return expressionUtils_expressionGen.generateExpression('responseHasKeysAll', undefined, itemKey, responseKey, ...optionKeys);
+};
+/**
+ * Check if only other options were selected
+ * @param itemKey full key of the survey item (e.g. SURVEY.GROUP.QUESTIONKEY)
+ * @param responseKey full key of the response slot inside the item (e.g. rg.scg)
+ * @param optionKeys keys of the option that shouldn't be selected
+ * @returns
+ */
+const responseHasOnlyKeysOtherThan = (itemKey, responseKey, ...optionKeys) => {
+    return expressionUtils_expressionGen.generateExpression('responseHasOnlyKeysOtherThan', undefined, itemKey, responseKey, ...optionKeys);
+};
+/**
+ * To use evaluated validations rules, we can reference them with this method.
+ * @param itemKey full key of the survey item (e.g. SURVEY.GROUP.QUESTIONKEY)
+ * @param validationKey key of the validation rule
+ * @returns
+ */
+const getSurveyItemValidation = (itemKey, validationKey) => {
+    return expressionUtils_expressionGen.generateExpression('getSurveyItemValidation', undefined, itemKey, validationKey);
+};
+/**
+ * Calculate difference of a selected date input and current timestamp with selected unit
+ * @param itemKey full key of the survey item (e.g. SURVEY.GROUP.QUESTIONKEY)
+ * @param responseKey full key of the response slot inside the item (e.g. rg.input)
+ * @param unit in which unit should the difference be returned
+ * @param ignoreSign if set to true, sign (+/-) is ignored and the absolute value of the difference is returned
+ * @returns
+ */
+const dateResponseDiffFromNow = (itemKey, responseKey, unit, ignoreSign) => {
+    return expressionUtils_expressionGen.generateExpression('dateResponseDiffFromNow', undefined, itemKey, responseKey, unit, ignoreSign ? 1 : undefined);
+};
+/**
+ * Check participant flags object if contains the specified key value pair
+ * @param key retrieve participant flag's value for this key
+ * @param value string value to be checked for a match
+ * @returns
+ */
+const hasParticipantFlag = (key, value) => {
+    return eq(getAttribute(getAttribute(getContext(), 'participantFlags'), key), value);
+};
+/**
+ * Counts the number of selected options in a multiple choice question
+ * @param itemKey full key of the survey item (e.g. SURVEY.GROUP.QUESTIONKEY)
+ * @returns
+ */
+const multipleChoiceSelectionCount = (itemKey) => {
+    return countResponseItems(itemKey, [constants_keyDefinitions.responseGroupKey, constants_keyDefinitions.multipleChoiceKey].join('.'));
+};
+const getDatePickerResponseValue = (itemKey) => {
+    return getResponseValueAsNum(itemKey, [constants_keyDefinitions.responseGroupKey, constants_keyDefinitions.datePickerKey].join('.'));
+};
+const singleChoiceOptionsSelected = (itemKey, ...optionKeys) => responseHasKeysAll(itemKey, [constants_keyDefinitions.responseGroupKey, constants_keyDefinitions.singleChoiceKey].join('.'), ...optionKeys);
+const multipleChoiceOptionsSelected = (itemKey, ...optionKeys) => responseHasKeysAny(itemKey, [constants_keyDefinitions.responseGroupKey, constants_keyDefinitions.multipleChoiceKey].join('.'), ...optionKeys);
+const multipleChoiceAllOfTheseSelected = (itemKey, ...optionKeys) => responseHasKeysAll(itemKey, [constants_keyDefinitions.responseGroupKey, constants_keyDefinitions.multipleChoiceKey].join('.'), ...optionKeys);
+const multipleChoiceOnlyOtherKeysSelected = (itemKey, ...optionKeys) => responseHasOnlyKeysOtherThan(itemKey, [constants_keyDefinitions.responseGroupKey, constants_keyDefinitions.multipleChoiceKey].join('.'), ...optionKeys);
+const singleChoiceOnlyOtherOptionSelected = (itemKey, ...optionKeys) => responseHasOnlyKeysOtherThan(itemKey, [constants_keyDefinitions.responseGroupKey, constants_keyDefinitions.singleChoiceKey].join('.'), ...optionKeys);
+const singleChoiceGetNumOptionValue = (itemKey, optionKey) => {
+    return getResponseValueAsNum(itemKey, [constants_keyDefinitions.responseGroupKey, constants_keyDefinitions.singleChoiceKey, optionKey].join('.'));
+};
+const multipleChoiceGetNumOptionValue = (itemKey, optionKey) => {
+    return getResponseValueAsNum(itemKey, [constants_keyDefinitions.responseGroupKey, constants_keyDefinitions.multipleChoiceKey, optionKey].join('.'));
+};
+const singleChoiceTextInputRegexCheck = (itemKey, optionKey, pattern) => {
+    return checkResponseValueWithRegex(itemKey, [constants_keyDefinitions.responseGroupKey, constants_keyDefinitions.singleChoiceKey, optionKey].join('.'), pattern);
+};
+const mulitpleChoiceTextInputRegexCheck = (itemKey, optionKey, pattern) => {
+    return checkResponseValueWithRegex(itemKey, [constants_keyDefinitions.responseGroupKey, constants_keyDefinitions.multipleChoiceKey, optionKey].join('.'), pattern);
+};
+const textInputRegexCheck = (itemKey, pattern) => {
+    return checkResponseValueWithRegex(itemKey, [constants_keyDefinitions.responseGroupKey, constants_keyDefinitions.inputKey].join('.'), pattern);
+};
+const multilineTextInputRegexCheck = (itemKey, pattern) => {
+    return checkResponseValueWithRegex(itemKey, [constants_keyDefinitions.responseGroupKey, constants_keyDefinitions.inputKey].join('.'), pattern);
+};
+const NativeSurveyEngineExpressions = {
+    getters: {
+        // root data reference:
+        getContext,
+        getResponses,
+        getRenderedItems,
+        // object access:
+        getAttribute,
+        getArrayItemAtIndex,
+        getArrayItemByKey,
+        getObjByHierarchicalKey,
+        getNestedObjectByKey,
+    },
+    // query methods for previous names:
+    previousResponses: {
+        getItemsByKey: findPreviousSurveyResponsesByKey,
+        getLastItemByKey: getLastFromSurveyResponses,
+        getAllResponsesForSurveyKey: getPreviousResponses,
+        filterResponsesByIncludesKeys,
+        filterResponsesByValue,
+        getLastFromSurveyItemResponses,
+    },
+    // client side shortcut methods:
+    isDefined,
+    hasResponse,
+    getResponseItem,
+    getResponseValueAsNum,
+    getResponseValueAsStr,
+    checkResponseValueWithRegex,
+    responseHasKeysAny,
+    responseHasKeysAll,
+    responseHasOnlyKeysOtherThan,
+    getSurveyItemValidation,
+    dateResponseDiffFromNow,
+    countResponseItems,
+    compare: {
+        eq,
+        lt,
+        lte,
+        gt,
+        gte,
+    },
+    logic: {
+        or,
+        and,
+        not,
+    },
+    // Other
+    getSecondsSince,
+    timestampWithOffset,
+};
+const SurveyEngine = Object.assign(Object.assign({}, NativeSurveyEngineExpressions), { singleChoice: {
+        any: singleChoiceOptionsSelected,
+        none: singleChoiceOnlyOtherOptionSelected,
+        getDateValue: singleChoiceGetNumOptionValue,
+        getNumValue: singleChoiceGetNumOptionValue,
+        regexCheck: singleChoiceTextInputRegexCheck,
+    }, multipleChoice: {
+        any: multipleChoiceOptionsSelected,
+        none: multipleChoiceOnlyOtherKeysSelected,
+        all: multipleChoiceAllOfTheseSelected,
+        selectionCount: multipleChoiceSelectionCount,
+        getDateValue: multipleChoiceGetNumOptionValue,
+        getNumValue: multipleChoiceGetNumOptionValue,
+        regexCheck: mulitpleChoiceTextInputRegexCheck,
+    }, textInput: {
+        regexCheck: textInputRegexCheck,
+    }, multilineTextInput: {
+        regexCheck: multilineTextInputRegexCheck,
+    }, datePicker: {
+        get: getDatePickerResponseValue,
+    }, hasParticipantFlag });
+
+exports.NativeSurveyEngineExpressions = NativeSurveyEngineExpressions;
+exports.SurveyEngine = SurveyEngine;
+//# sourceMappingURL=survey-engine-expressions.js.map

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

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

package/surveys/survey-items.d.ts

@@ -0,0 +1,133 @@
+import { ItemGroupComponent, Expression, ComponentProperties, ItemComponent, SurveyItem, ExpressionArg } from "survey-engine/lib/data_types";
+import { ClozeQuestionProps, DateInputQuestionProps, GenericQuestionProps, MultiLineTextInput, NumericInputQuestionProps, OptionDef, ResponsiveBipolarLikertArrayProps, ResponsiveBipolarLikertArrayQuestionProps, ResponsiveSingleChoiceArrayProps, ResponsiveSingleChoiceArrayQuestionProps, TextInputQuestionProps } from "./types/item-properties";
+interface OptionQuestionProps extends GenericQuestionProps {
+    responseOptions: Array<OptionDef>;
+}
+interface LikertGroupQuestionProps extends GenericQuestionProps {
+    rows: Array<LikertGroupRow>;
+    scaleOptions: Array<{
+        key: string;
+        className?: string;
+        content: Map<string, string>;
+    }>;
+    stackOnSmallScreen?: boolean;
+}
+interface NumericSliderProps extends GenericQuestionProps {
+    sliderLabel: Map<string, string>;
+    noResponseLabel: Map<string, string>;
+    min?: number | ExpressionArg;
+    max?: number | ExpressionArg;
+    stepSize?: number | ExpressionArg;
+}
+interface DisplayProps {
+    parentKey: string;
+    itemKey: string;
+    content: Array<ItemComponent>;
+    condition?: Expression;
+}
+export declare const initSingleChoiceGroup: (key: string, optionItems: OptionDef[], order?: Expression | undefined) => ItemGroupComponent;
+export declare const initMultipleChoiceGroup: (key: string, optionItems: OptionDef[], order?: Expression | undefined) => ItemGroupComponent;
+export declare const initDropdownGroup: (key: string, optionItems: OptionDef[], order?: Expression | undefined, groupDisabled?: Expression | undefined, groupContent?: Map<string, string> | undefined, groupDescription?: Map<string, string> | undefined) => ItemGroupComponent;
+export declare const initSliderCategoricalGroup: (key: string, optionItems: OptionDef[], order?: Expression | undefined, groupDisabled?: Expression | undefined) => ItemGroupComponent;
+interface HeaderRow {
+    role: 'headerRow';
+    key: string;
+    displayCondition?: Expression;
+    disabled?: Expression;
+    cells: Array<{
+        role: 'text';
+        key: string;
+        content?: Map<string, string>;
+        description?: Map<string, string>;
+    }>;
+}
+interface RadioRow {
+    role: 'radioRow';
+    key: string;
+    displayCondition?: Expression;
+    disabled?: Expression;
+    cells: Array<{
+        role: 'label' | 'option';
+        key: string;
+        content?: Map<string, string>;
+        description?: Map<string, string>;
+    }>;
+}
+export interface ResponseRowCell {
+    role: 'label' | 'check' | 'input' | 'numberInput' | 'dropDownGroup';
+    key: string;
+    content?: Map<string, string>;
+    description?: Map<string, string>;
+    properties?: ComponentProperties;
+    items?: Array<{
+        role: 'option';
+        key: string;
+        content?: Map<string, string>;
+        disabled?: Expression;
+        displayCondition?: Expression;
+    }>;
+}
+interface ResponseRow {
+    role: 'responseRow';
+    key: string;
+    displayCondition?: Expression;
+    disabled?: Expression;
+    cells: Array<ResponseRowCell>;
+}
+declare type MatrixRow = HeaderRow | RadioRow | ResponseRow;
+export declare const initMatrixQuestion: (key: string, rows: Array<MatrixRow>, order?: Expression | undefined) => ItemGroupComponent;
+interface EQ5DHealthSliderProps {
+    role: 'eq5d-health-indicator';
+    key: string;
+    displayCondition?: Expression;
+    disabled?: Expression;
+    instructionText: Map<string, string>;
+    valueBoxText: Map<string, string>;
+    maxHealthText: Map<string, string>;
+    minHealthText: Map<string, string>;
+}
+export declare const initEQ5DHealthIndicatorQuestion: (props: EQ5DHealthSliderProps) => ItemGroupComponent;
+interface LikertGroupRow {
+    key: string;
+    content: Map<string, string>;
+    descriptions?: ItemComponent[];
+    hideTopBorder?: boolean;
+    hideLabels?: boolean;
+    optionDisabled?: Array<{
+        optionKey: string;
+        exp: Expression;
+    }>;
+    displayCondition?: Expression;
+}
+export declare const initLikertScaleGroup: (key: string, rows: Array<LikertGroupRow>, scaleOptions: {
+    key: string;
+    className?: string | undefined;
+    content: Map<string, string>;
+}[], stackOnSmallScreen?: boolean | undefined, displayCondition?: Expression | undefined) => ItemGroupComponent;
+export declare const initResponsiveSingleChoiceArray: (rgKey: string, props: ResponsiveSingleChoiceArrayProps, displayCondition?: Expression | undefined) => ItemGroupComponent;
+export declare const initResponsiveBipolarLikertArray: (rgKey: string, props: ResponsiveBipolarLikertArrayProps, displayCondition?: Expression | undefined) => ItemGroupComponent;
+export declare const initLikertScaleItem: (key: string, options: {
+    key: string;
+    className?: string | undefined;
+    content?: Map<string, string> | undefined;
+    disabled?: Expression | undefined;
+}[], stackOnSmallScreen?: boolean | undefined, displayCondition?: Expression | undefined) => ItemGroupComponent;
+export declare const SurveyItems: {
+    singleChoice: (props: OptionQuestionProps) => SurveyItem;
+    responsiveSingleChoiceArray: (props: ResponsiveSingleChoiceArrayQuestionProps) => SurveyItem;
+    responsiveBipolarLikertArray: (props: ResponsiveBipolarLikertArrayQuestionProps) => SurveyItem;
+    multipleChoice: (props: OptionQuestionProps) => SurveyItem;
+    dateInput: (props: DateInputQuestionProps) => SurveyItem;
+    textInput: (props: TextInputQuestionProps) => SurveyItem;
+    clozeQuestion: (props: ClozeQuestionProps) => SurveyItem;
+    numericInput: (props: NumericInputQuestionProps) => SurveyItem;
+    multilineTextInput: (props: MultiLineTextInput) => SurveyItem;
+    dropDown: (props: OptionQuestionProps) => SurveyItem;
+    numericSlider: (props: NumericSliderProps) => SurveyItem;
+    display: (props: DisplayProps) => SurveyItem;
+    surveyEnd: (parentKey: string, content: Map<string, string>, condition?: Expression | undefined) => SurveyItem;
+    old: {
+        simpleLikertGroup: (props: LikertGroupQuestionProps) => SurveyItem;
+    };
+};
+export {};