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

package/surveys/utils/optionDefGenerators.js

@@ -0,0 +1,211 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var surveys_surveyEngineExpressions = require('../survey-engine-expressions.js');
+var surveys_utils_randomKeyGenerator = require('./randomKeyGenerator.js');
+require('../../constants/key-definitions.js');
+require('../../types/duration.js');
+require('../../expression-utils/expressionGen.js');
+
+const option = (key, content, extraProps) => {
+    const styles = [];
+    if ((extraProps === null || extraProps === void 0 ? void 0 : extraProps.className) !== undefined) {
+        styles.push({
+            key: 'className', value: extraProps.className
+        });
+    }
+    return {
+        key: key,
+        role: 'option',
+        content: !Array.isArray(content) ? content : undefined,
+        items: Array.isArray(content) ? content : undefined,
+        displayCondition: extraProps === null || extraProps === void 0 ? void 0 : extraProps.displayCondition,
+        disabled: extraProps === null || extraProps === void 0 ? void 0 : extraProps.disabled,
+        style: styles,
+    };
+};
+const multipleChoiceOptionSubtitle = (props) => {
+    const styles = [];
+    if (props.className !== undefined) {
+        styles.push({
+            key: 'className', value: props.className
+        });
+    }
+    return {
+        key: props.key ? props.key : surveys_utils_randomKeyGenerator.generateRandomKey(6),
+        role: 'text',
+        content: !Array.isArray(props.content) ? props.content : undefined,
+        displayCondition: props.displayCondition,
+        style: styles,
+    };
+};
+const markdown = (props) => {
+    const styles = [];
+    if (props.className !== undefined) {
+        styles.push({
+            key: 'className', value: props.className
+        });
+    }
+    return {
+        key: props.key ? props.key : surveys_utils_randomKeyGenerator.generateRandomKey(6),
+        role: 'markdown',
+        content: !Array.isArray(props.content) ? props.content : undefined,
+        displayCondition: props.displayCondition,
+        style: styles,
+    };
+};
+const textInput = (props) => {
+    const style = [];
+    if (props.maxLength !== undefined) {
+        style.push({ key: 'maxLength', value: props.maxLength.toFixed(0) });
+    }
+    if (props.className !== undefined) {
+        style.push({ key: 'className', value: props.className });
+    }
+    if (props.inputMaxWidth !== undefined) {
+        style.push({ key: 'inputMaxWidth', value: props.inputMaxWidth });
+    }
+    return {
+        key: props.key,
+        role: 'input',
+        content: props.inputLabel,
+        description: props.placeholderText,
+        displayCondition: props.displayCondition,
+        disabled: props.disabled,
+        style: style.length > 0 ? style : undefined,
+    };
+};
+const numberInput = (props) => {
+    var _a, _b, _c, _d;
+    const style = [];
+    if (props.inputMaxWidth !== undefined) {
+        style.push({ key: 'inputMaxWidth', value: props.inputMaxWidth });
+    }
+    if (props.labelBehindInput) {
+        style.push({ key: 'labelPlacement', value: 'after' });
+    }
+    return {
+        key: props.key,
+        role: 'numberInput',
+        content: props.inputLabel,
+        displayCondition: props.displayCondition,
+        disabled: props.disabled,
+        optionProps: {
+            min: ((_a = props.componentProperties) === null || _a === void 0 ? void 0 : _a.min) !== undefined ? (typeof (props.componentProperties.min) === 'number' ? { dtype: 'num', num: props.componentProperties.min } : props.componentProperties.min) : undefined,
+            max: ((_b = props.componentProperties) === null || _b === void 0 ? void 0 : _b.max) !== undefined ? (typeof ((_c = props.componentProperties) === null || _c === void 0 ? void 0 : _c.max) === 'number' ? { dtype: 'num', num: props.componentProperties.max } : props.componentProperties.max) : undefined,
+            stepSize: ((_d = props.componentProperties) === null || _d === void 0 ? void 0 : _d.stepSize) ? (typeof (props.componentProperties.stepSize) === 'number' ? { dtype: 'num', num: props.componentProperties.stepSize } : props.componentProperties.stepSize) : undefined,
+        },
+        style: style.length > 0 ? style : undefined,
+    };
+};
+const dateInput = (props) => {
+    return {
+        key: props.key,
+        role: 'dateInput',
+        optionProps: {
+            dateInputMode: { str: props.dateInputMode },
+            min: props.minRelativeDate ? {
+                dtype: 'exp', exp: surveys_surveyEngineExpressions.SurveyEngine.timestampWithOffset(props.minRelativeDate.delta, props.minRelativeDate.reference)
+            } : undefined,
+            max: props.maxRelativeDate ? {
+                dtype: 'exp', exp: surveys_surveyEngineExpressions.SurveyEngine.timestampWithOffset(props.maxRelativeDate.delta, props.maxRelativeDate.reference ? props.maxRelativeDate.reference : undefined)
+            } : undefined,
+        },
+        content: props.inputLabelText,
+        displayCondition: props.displayCondition,
+    };
+};
+const timeInput = (props) => {
+    const style = [];
+    if (props.minTime) {
+        style.push({
+            key: 'minTime', value: props.minTime,
+        });
+    }
+    if (props.maxTime) {
+        style.push({
+            key: 'maxTime', value: props.maxTime,
+        });
+    }
+    if (props.defaultValue) {
+        style.push({
+            key: 'defaultValue', value: props.defaultValue,
+        });
+    }
+    if (props.labelBehindInput) {
+        style.push({ key: 'labelPlacement', value: 'after' });
+    }
+    return {
+        key: props.key,
+        role: 'timeInput',
+        optionProps: {
+            stepSize: props.step,
+        },
+        content: props.inputLabelText,
+        displayCondition: props.displayCondition,
+        style: style.length > 0 ? style : undefined,
+    };
+};
+const dropDown = (props) => {
+    return {
+        key: props.key,
+        role: 'dropDownGroup',
+        displayCondition: props.displayCondition,
+        description: props.placeholder,
+        items: props.options,
+    };
+};
+const cloze = (props) => {
+    const styles = [];
+    if (props.className !== undefined) {
+        styles.push({
+            key: 'className', value: props.className
+        });
+    }
+    return {
+        key: props.key,
+        role: 'cloze',
+        items: props.items,
+        displayCondition: props.displayCondition,
+        style: styles.length > 0 ? styles : undefined,
+    };
+};
+const clozeLineBreak = () => {
+    return {
+        key: surveys_utils_randomKeyGenerator.generateRandomKey(5),
+        role: 'lineBreak',
+    };
+};
+const SingleChoiceOptionTypes = {
+    option,
+    textInput,
+    //dateInput,
+    timeInput,
+    numberInput,
+    cloze,
+};
+const MultipleChoiceOptionTypes = {
+    option,
+    subtitle: multipleChoiceOptionSubtitle,
+    textInput,
+    // dateInput
+    timeInput,
+    numberInput,
+    cloze,
+};
+const ClozeItemTypes = {
+    text: multipleChoiceOptionSubtitle,
+    markdown,
+    textInput,
+    dateInput,
+    timeInput,
+    clozeLineBreak,
+    numberInput,
+    dropDown,
+};
+
+exports.ClozeItemTypes = ClozeItemTypes;
+exports.MultipleChoiceOptionTypes = MultipleChoiceOptionTypes;
+exports.SingleChoiceOptionTypes = SingleChoiceOptionTypes;
+//# sourceMappingURL=optionDefGenerators.js.map

package/surveys/utils/optionDefGenerators.js.map

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

package/surveys/utils/randomKeyGenerator.d.ts

@@ -0,0 +1 @@
+export declare const generateRandomKey: (length: number) => string;

package/surveys/utils/randomKeyGenerator.js

@@ -0,0 +1,16 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const generateRandomKey = (length) => {
+    var result = '';
+    var characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    var charactersLength = characters.length;
+    for (var i = 0; i < length; i++) {
+        result += characters.charAt(Math.floor(Math.random() * charactersLength));
+    }
+    return result;
+};
+
+exports.generateRandomKey = generateRandomKey;
+//# sourceMappingURL=randomKeyGenerator.js.map

package/surveys/utils/randomKeyGenerator.js.map

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

package/surveys/utils/simple-generators.d.ts

@@ -0,0 +1,14 @@
+import { LocalizedString, ItemComponent, ExpressionName, Expression, ItemGroupComponent, SurveySingleItem } from "survey-engine/data_types";
+import { DateDisplayComponentProp, StyledTextComponentProp } from "../types/item-properties";
+export declare const generateLocStrings: (translations: Map<string, string>) => LocalizedString[];
+export declare const generateDateDisplayComp: (key: string, item: DateDisplayComponentProp) => ItemComponent;
+export declare const generateTitleComponent: (content: Map<string, string> | Array<StyledTextComponentProp | DateDisplayComponentProp>, description?: Map<string, string> | undefined, className?: string | undefined) => ItemComponent;
+export declare const generateHelpGroupComponent: (items: Array<{
+    content: Map<string, string>;
+    style?: Array<{
+        key: string;
+        value: string;
+    }>;
+}>) => ItemGroupComponent;
+export declare const expWithArgs: (name: ExpressionName, ...args: any[]) => Expression;
+export declare const generatePageBreak: (parentKey: string, key?: string | undefined) => SurveySingleItem;

package/surveys/utils/simple-generators.js

@@ -0,0 +1,131 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var surveys_surveyEditor_componentEditor = require('../survey-editor/component-editor.js');
+var surveys_types_itemProperties = require('../types/item-properties.js');
+var surveys_utils_randomKeyGenerator = require('./randomKeyGenerator.js');
+
+const generateLocStrings = (translations) => {
+    // console.log(translations);
+    const locString = new Array();
+    translations.forEach((value, key) => {
+        const item = {
+            code: key,
+            parts: [{ str: value }]
+        };
+        locString.push(item);
+    });
+    return locString;
+};
+const generateDateDisplayComp = (key, item) => {
+    // console.log(translations);
+    const styleArray = [
+        { key: 'dateFormat', value: item.dateFormat }
+    ];
+    if (item.className) {
+        styleArray.push({ key: 'className', value: item.className });
+    }
+    const locString = new Array();
+    const dateExp = item.date;
+    item.languageCodes.forEach((code) => {
+        const translatedItem = {
+            code: code,
+            parts: [{ dtype: 'exp', exp: dateExp }]
+        };
+        locString.push(translatedItem);
+    });
+    return {
+        key: key,
+        role: 'dateDisplay',
+        content: locString,
+        style: styleArray,
+    };
+};
+const generateTitleComponent = (content, description, className) => {
+    let items = undefined;
+    let currentContent = undefined;
+    if (Array.isArray(content)) {
+        items = content.map((item, index) => {
+            if (surveys_types_itemProperties.isDateDisplayComponentProp(item)) {
+                return generateDateDisplayComp(index.toFixed(), item);
+            }
+            return {
+                key: index.toFixed(),
+                role: 'text',
+                content: generateLocStrings(item.content),
+                style: item.className ? [{ key: 'className', value: item.className }] : undefined
+            };
+        });
+    }
+    else {
+        currentContent = generateLocStrings(content);
+    }
+    const style = className ? [{ key: 'className', value: className }] : undefined;
+    return {
+        role: 'title',
+        content: currentContent,
+        items: items,
+        style: style,
+        description: description ? generateLocStrings(description) : undefined,
+    };
+};
+const generateHelpGroupComponent = (items) => {
+    // init group
+    const groupEdit = new surveys_surveyEditor_componentEditor.ComponentEditor(undefined, {
+        isGroup: true,
+        role: 'helpGroup',
+    });
+    groupEdit.setOrder({
+        name: 'sequential'
+    });
+    items.forEach(item => {
+        const itemEditor = new surveys_surveyEditor_componentEditor.ComponentEditor(undefined, {
+            role: 'text',
+        });
+        itemEditor.setContent(generateLocStrings(item.content));
+        if (item.style) {
+            itemEditor.setStyles(item.style);
+        }
+        groupEdit.addItemComponent(itemEditor.getComponent());
+    });
+    return groupEdit.getComponent();
+};
+const expWithArgs = (name, ...args) => {
+    return {
+        name: name,
+        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
+            };
+        })
+    };
+};
+const generatePageBreak = (parentKey, key) => {
+    return {
+        key: parentKey + '.' + (key ? key : "PB_" + surveys_utils_randomKeyGenerator.generateRandomKey(4)),
+        version: 0,
+        type: 'pageBreak'
+    };
+};
+
+exports.expWithArgs = expWithArgs;
+exports.generateDateDisplayComp = generateDateDisplayComp;
+exports.generateHelpGroupComponent = generateHelpGroupComponent;
+exports.generateLocStrings = generateLocStrings;
+exports.generatePageBreak = generatePageBreak;
+exports.generateTitleComponent = generateTitleComponent;
+//# sourceMappingURL=simple-generators.js.map

package/surveys/utils/simple-generators.js.map

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

package/surveys/utils/simple-question-editor.d.ts

@@ -0,0 +1,14 @@
+import { ConfidentialMode, Expression, ItemComponent } from "survey-engine/data_types";
+import { ItemEditor } from "../survey-editor/item-editor";
+import { DateDisplayComponentProp, StyledTextComponentProp } from "../types/item-properties";
+export declare class SimpleQuestionEditor {
+    editor: ItemEditor;
+    key: string;
+    constructor(parentKey: string, key: string, version: number, confidentialMode?: ConfidentialMode);
+    getItem(): import("survey-engine/data_types").SurveyItem;
+    setTitle(title: Map<string, string> | Array<StyledTextComponentProp | DateDisplayComponentProp>, description?: Map<string, string>, className?: string): void;
+    setCondition(exp: Expression): void;
+    addDisplayComponent(comp: ItemComponent, atPosition?: number): void;
+    addHasResponseValidation(): void;
+    setResponseGroupWithContent(content: ItemComponent): void;
+}

package/surveys/utils/simple-question-editor.js

@@ -0,0 +1,47 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var constants_keyDefinitions = require('../../constants/key-definitions.js');
+var surveys_surveyEditor_itemEditor = require('../../item-editor-59f51ecc.js');
+var surveys_utils_simpleGenerators = require('./simple-generators.js');
+require('../survey-editor/component-editor.js');
+require('./randomKeyGenerator.js');
+require('../../logger/logger.js');
+require('../types/item-properties.js');
+
+class SimpleQuestionEditor {
+    constructor(parentKey, key, version, confidentialMode) {
+        const itemKey = [parentKey, key].join('.');
+        this.key = itemKey;
+        this.editor = new surveys_surveyEditor_itemEditor.ItemEditor(undefined, { itemKey: itemKey, isGroup: false });
+        this.editor.setVersion(version);
+        this.editor.setConfidentialMode(confidentialMode);
+    }
+    getItem() {
+        return this.editor.getItem();
+    }
+    setTitle(title, description, className) {
+        this.editor.setTitleComponent(surveys_utils_simpleGenerators.generateTitleComponent(title, description, className));
+    }
+    setCondition(exp) {
+        this.editor.setCondition(exp);
+    }
+    addDisplayComponent(comp, atPosition) {
+        this.editor.addDisplayComponent(comp, atPosition);
+    }
+    addHasResponseValidation() {
+        this.editor.addValidation({
+            key: 'r1',
+            type: 'hard',
+            rule: surveys_utils_simpleGenerators.expWithArgs('hasResponse', this.key, constants_keyDefinitions.responseGroupKey)
+        });
+    }
+    setResponseGroupWithContent(content) {
+        const rg = this.editor.addNewResponseComponent({ role: 'responseGroup' });
+        this.editor.addExistingResponseComponent(content, rg === null || rg === void 0 ? void 0 : rg.key);
+    }
+}
+
+exports.SimpleQuestionEditor = SimpleQuestionEditor;
+//# sourceMappingURL=simple-question-editor.js.map

package/surveys/utils/simple-question-editor.js.map

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

package/types/duration.d.ts

@@ -0,0 +1,9 @@
+export interface Duration {
+    years?: number;
+    months?: number;
+    days?: number;
+    hours?: number;
+    minutes?: number;
+    seconds?: number;
+}
+export declare const durationObjectToSeconds: (duration: Duration) => number;

package/types/duration.js

@@ -0,0 +1,29 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const durationObjectToSeconds = (duration) => {
+    let value = 0;
+    if (duration.years !== undefined) {
+        value += duration.years * 31536000;
+    }
+    if (duration.months !== undefined) {
+        value += duration.months * 2592000;
+    }
+    if (duration.days !== undefined) {
+        value += duration.days * 86400;
+    }
+    if (duration.hours !== undefined) {
+        value += duration.hours * 3600;
+    }
+    if (duration.minutes !== undefined) {
+        value += duration.minutes * 60;
+    }
+    if (duration.seconds !== undefined) {
+        value += duration.seconds;
+    }
+    return value;
+};
+
+exports.durationObjectToSeconds = durationObjectToSeconds;
+//# sourceMappingURL=duration.js.map

package/types/duration.js.map

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

package/types/expression.d.ts

@@ -0,0 +1,4 @@
+import { Expression, ExpressionArg } from "survey-engine/data_types";
+export declare const isExpression: (value: Expression | any) => value is Expression;
+export declare type ExpressionArgDType = 'exp' | 'num' | 'str';
+export declare const expressionArgParser: (arg: ExpressionArg) => any;

package/types/expression.js

@@ -0,0 +1,23 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const isExpression = (value) => {
+    return typeof (value) === 'object' && value.name !== undefined && value.name.length > 0;
+};
+const expressionArgParser = (arg) => {
+    switch (arg.dtype) {
+        case 'num':
+            return arg.num;
+        case 'str':
+            return arg.str;
+        case 'exp':
+            return arg.exp;
+        default:
+            return arg.str;
+    }
+};
+
+exports.expressionArgParser = expressionArgParser;
+exports.isExpression = isExpression;
+//# sourceMappingURL=expression.js.map

package/types/expression.js.map

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

package/types/messageConfig.d.ts

@@ -0,0 +1,49 @@
+import { Expression } from "survey-engine/data_types";
+import { Duration } from "./duration";
+export declare type MessageType = 'registration' | 'invitation' | 'verify-email' | 'verification-code' | 'password-reset' | 'password-changed' | 'account-id-changed' | 'weekly' | 'study-reminder' | 'newsletter' | 'account-deleted';
+export interface MessageConfig {
+    sendTo: 'study-participants' | 'all-users' | 'scheduled-participant-messages';
+    label: string;
+    headerOverrides?: {
+        from: string;
+        sender: string;
+        replyTo: string[];
+    };
+    messageType: MessageType;
+    sendingTime: {
+        hour: number;
+        minute: number;
+    };
+    period: Duration;
+    defaultLanguage: string;
+    condition?: Expression;
+    translations: Array<{
+        lang: string;
+        subject: string;
+    }>;
+}
+export declare const buildMessageConfig: (props: MessageConfig, studyKey: string) => {
+    sendTo: "study-participants" | "all-users" | "scheduled-participant-messages";
+    studyKey: string;
+    label: string;
+    headerOverrides: {
+        from: string;
+        sender: string;
+        replyTo: string[];
+    } | undefined;
+    messageType: MessageType;
+    sendingTime: {
+        hour: number;
+        minute: number;
+    };
+    condition: {
+        dtype: string;
+        exp: Expression | undefined;
+    };
+    period: number;
+    defaultLanguage: string;
+    translations: {
+        lang: string;
+        subject: string;
+    }[];
+};

package/types/messageConfig.js

@@ -0,0 +1,23 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var types_duration = require('./duration.js');
+
+const buildMessageConfig = (props, studyKey) => {
+    return {
+        sendTo: props.sendTo,
+        studyKey: studyKey,
+        label: props.label,
+        headerOverrides: props.headerOverrides,
+        messageType: props.messageType,
+        sendingTime: props.sendingTime,
+        condition: { dtype: 'exp', exp: props.condition },
+        period: Math.floor(types_duration.durationObjectToSeconds(props.period)),
+        defaultLanguage: props.defaultLanguage,
+        translations: props.translations,
+    };
+};
+
+exports.buildMessageConfig = buildMessageConfig;
+//# sourceMappingURL=messageConfig.js.map

package/types/messageConfig.js.map

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

package/types/study.d.ts

@@ -0,0 +1,15 @@
+import { Expression } from "survey-engine/data_types";
+import { StudyRules } from "./studyRules";
+import { SurveyDefinition } from "../surveys/types/survey-definition";
+import { MessageConfig } from "./messageConfig";
+export interface Study {
+    studyKey: string;
+    outputFolderName?: string;
+    surveys: SurveyDefinition[];
+    studyRules?: StudyRules;
+    customStudyRules?: Array<{
+        name: string;
+        rules: Expression[];
+    }>;
+    messageConfigs?: Array<MessageConfig>;
+}

package/types/study.js

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

package/types/study.js.map

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

package/types/studyRules.d.ts

@@ -0,0 +1,9 @@
+import { Expression } from 'survey-engine/data_types';
+export declare class StudyRules {
+    private enterRules?;
+    private submitRules?;
+    private timerRules?;
+    private mergeRules?;
+    constructor(enterRules?: Expression[], submitRules?: Expression[], timerRules?: Expression[], mergeRules?: Expression[]);
+    get(): Expression[];
+}