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

package/surveys/utils/optionDefGenerators.d.ts

@@ -0,0 +1,69 @@
+import { Expression } from "survey-engine/lib/data_types";
+import { ClozeProps, DateInputProps, NumericInputProps, OptionDef, StyledTextComponentProp, TextInputProps } from "../types/item-properties";
+interface CommonProps {
+    key?: string;
+    content?: Map<string, string> | StyledTextComponentProp[];
+    displayCondition?: Expression;
+}
+interface OptionProps {
+    disabled?: Expression;
+    className?: string;
+    displayCondition?: Expression;
+}
+interface OptionTextProps extends CommonProps {
+    className?: string;
+}
+export declare const SingleChoiceOptionTypes: {
+    option: (key: string, content: Map<string, string> | StyledTextComponentProp[], extraProps?: OptionProps | undefined) => OptionDef;
+    textInput: (props: TextInputProps & {
+        key: string;
+        displayCondition?: Expression;
+    }) => OptionDef;
+    numberInput: (props: NumericInputProps & {
+        key: string;
+        displayCondition?: Expression;
+    }) => OptionDef;
+    cloze: (props: ClozeProps & {
+        key: string;
+        displayCondition?: Expression;
+    }) => OptionDef;
+};
+export declare const MultipleChoiceOptionTypes: {
+    option: (key: string, content: Map<string, string> | StyledTextComponentProp[], extraProps?: OptionProps | undefined) => OptionDef;
+    subtitle: (props: OptionTextProps) => OptionDef;
+    textInput: (props: TextInputProps & {
+        key: string;
+        displayCondition?: Expression;
+    }) => OptionDef;
+    numberInput: (props: NumericInputProps & {
+        key: string;
+        displayCondition?: Expression;
+    }) => OptionDef;
+    cloze: (props: ClozeProps & {
+        key: string;
+        displayCondition?: Expression;
+    }) => OptionDef;
+};
+export declare const ClozeItemTypes: {
+    text: (props: OptionTextProps) => OptionDef;
+    markdown: (props: OptionTextProps) => OptionDef;
+    textInput: (props: TextInputProps & {
+        key: string;
+        displayCondition?: Expression;
+    }) => OptionDef;
+    dateInput: (props: DateInputProps & {
+        key: string;
+        displayCondition?: Expression;
+    }) => OptionDef;
+    clozeLineBreak: () => OptionDef;
+    numberInput: (props: NumericInputProps & {
+        key: string;
+        displayCondition?: Expression;
+    }) => OptionDef;
+    dropDown: (props: {
+        key: string;
+        displayCondition?: Expression;
+        options: Array<OptionDef>;
+    }) => OptionDef;
+};
+export {};

package/surveys/utils/optionDefGenerators.js

@@ -0,0 +1,169 @@
+'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 dropDown = (props) => {
+    return {
+        key: props.key,
+        role: 'dropDownGroup',
+        displayCondition: props.displayCondition,
+        items: props.options,
+    };
+};
+const cloze = (props) => {
+    return {
+        key: props.key,
+        role: 'cloze',
+        items: props.items,
+        displayCondition: props.displayCondition,
+    };
+};
+const clozeLineBreak = () => {
+    return {
+        key: surveys_utils_randomKeyGenerator.generateRandomKey(5),
+        role: 'lineBreak',
+    };
+};
+const SingleChoiceOptionTypes = {
+    option,
+    textInput,
+    //dateInput,
+    numberInput,
+    cloze,
+};
+const MultipleChoiceOptionTypes = {
+    option,
+    subtitle: multipleChoiceOptionSubtitle,
+    textInput,
+    // dateInput,
+    numberInput,
+    cloze,
+};
+const ClozeItemTypes = {
+    text: multipleChoiceOptionSubtitle,
+    markdown,
+    textInput,
+    dateInput,
+    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/{src/surveys/utils/randomKeyGenerator.ts → surveys/utils/randomKeyGenerator.js}

@@ -1,11 +1,16 @@
+'use strict';
 
+Object.defineProperty(exports, '__esModule', { value: true });
 
-export const generateRandomKey = (length: number): string => {
-    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;
-}
+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,13 @@
+import { LocalizedString, ItemComponent, ExpressionName, Expression, ItemGroupComponent, SurveySingleItem } from "survey-engine/lib/data_types";
+import { StyledTextComponentProp } from "../types/item-properties";
+export declare const generateLocStrings: (translations: Map<string, string>) => LocalizedString[];
+export declare const generateTitleComponent: (content: Map<string, string> | Array<StyledTextComponentProp>, 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,102 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var surveys_surveyEditor_componentEditor = require('../survey-editor/component-editor.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 generateTitleComponent = (content, description, className) => {
+    let items = undefined;
+    let currentContent = undefined;
+    if (Array.isArray(content)) {
+        items = content.map((item, index) => {
+            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.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 { Expression, ItemComponent } from "survey-engine/lib/data_types";
+import { ItemEditor } from "../survey-editor/item-editor";
+import { StyledTextComponentProp } from "../types/item-properties";
+export declare class SimpleQuestionEditor {
+    editor: ItemEditor;
+    key: string;
+    constructor(parentKey: string, key: string, version: number);
+    getItem(): import("survey-engine/lib/data_types").SurveyItem;
+    setTitle(title: Map<string, string> | Array<StyledTextComponentProp>, 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,45 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var constants_keyDefinitions = require('../../constants/key-definitions.js');
+var surveys_surveyEditor_itemEditor = require('../../item-editor-7f825952.js');
+var surveys_utils_simpleGenerators = require('./simple-generators.js');
+require('../survey-editor/component-editor.js');
+require('./randomKeyGenerator.js');
+require('../../logger/logger.js');
+
+class SimpleQuestionEditor {
+    constructor(parentKey, key, version) {
+        const itemKey = [parentKey, key].join('.');
+        this.key = itemKey;
+        this.editor = new surveys_surveyEditor_itemEditor.ItemEditor(undefined, { itemKey: itemKey, isGroup: false });
+        this.editor.setVersion(version);
+    }
+    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/{src/types/duration.ts → types/duration.js}

@@ -1,32 +1,29 @@
-export interface Duration {
-    years?: number;
-    months?: number;
-    days?: number;
-    hours?: number;
-    minutes?: number;
-    seconds?: number;
-};
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
 
-export const durationObjectToSeconds = (duration: Duration): number => {
-    let value = 0;
+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;
+};
 
-    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/lib/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/study.d.ts

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

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,8 @@
+import { Expression } from 'survey-engine/lib/data_types';
+export declare class StudyRules {
+    private enterRules?;
+    private submitRules?;
+    private timerRules?;
+    constructor(enterRules?: Expression[], submitRules?: Expression[], timerRules?: Expression[]);
+    get(): Expression[];
+}

package/types/studyRules.js

@@ -0,0 +1,32 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var expressionUtils_studyEngineExpressions = require('../expression-utils/studyEngineExpressions.js');
+require('../constants/key-definitions.js');
+require('./duration.js');
+require('../expression-utils/expressionGen.js');
+
+class StudyRules {
+    constructor(enterRules, submitRules, timerRules) {
+        this.enterRules = enterRules;
+        this.submitRules = submitRules;
+        this.timerRules = timerRules;
+    }
+    get() {
+        const rules = [];
+        if (this.enterRules) {
+            rules.push(expressionUtils_studyEngineExpressions.StudyEngine.ifThen(expressionUtils_studyEngineExpressions.StudyEngine.checkEventType('ENTER'), ...this.enterRules));
+        }
+        if (this.submitRules) {
+            rules.push(expressionUtils_studyEngineExpressions.StudyEngine.ifThen(expressionUtils_studyEngineExpressions.StudyEngine.checkEventType('SUBMIT'), ...this.submitRules));
+        }
+        if (this.timerRules) {
+            rules.push(expressionUtils_studyEngineExpressions.StudyEngine.ifThen(expressionUtils_studyEngineExpressions.StudyEngine.checkEventType('TIMER'), ...this.timerRules));
+        }
+        return rules;
+    }
+}
+
+exports.StudyRules = StudyRules;
+//# sourceMappingURL=studyRules.js.map

package/types/studyRules.js.map

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

package/.editorconfig

@@ -1,13 +0,0 @@
-# Editor configuration, see https://editorconfig.org
-root = true
-
-[*]
-charset = utf-8
-indent_style = space
-indent_size = 2
-insert_final_newline = true
-trim_trailing_whitespace = true
-
-[*.md]
-max_line_length = off
-trim_trailing_whitespace = false