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

package/item-editor-7f825952.js

@@ -0,0 +1,522 @@
+'use strict';
+
+var surveys_surveyEditor_componentEditor = require('./surveys/survey-editor/component-editor.js');
+var surveys_utils_randomKeyGenerator = require('./surveys/utils/randomKeyGenerator.js');
+var logger_logger = require('./logger/logger.js');
+
+var data_types = {};
+
+var expression = {};
+
+Object.defineProperty(expression, "__esModule", { value: true });
+expression.isExpression = (value) => {
+    return typeof (value) === 'object' && value.name !== undefined && value.name.length > 0;
+};
+expression.expressionArgParser = (arg) => {
+    switch (arg.dtype) {
+        case 'num':
+            return arg.num;
+        case 'str':
+            return arg.str;
+        case 'exp':
+            return arg.exp;
+        default:
+            return arg.str;
+    }
+};
+
+var surveyItem = {};
+
+Object.defineProperty(surveyItem, "__esModule", { value: true });
+surveyItem.isSurveyGroupItem = (item) => {
+    const items = item.items;
+    return items !== undefined && items.length > 0;
+};
+
+var surveyItemComponent = {};
+
+Object.defineProperty(surveyItemComponent, "__esModule", { value: true });
+surveyItemComponent.isItemGroupComponent = (item) => {
+    const items = item.items;
+    return items !== undefined && items.length > 0;
+};
+
+var response = {};
+
+Object.defineProperty(response, "__esModule", { value: true });
+response.isSurveyGroupItemResponse = (item) => {
+    const items = item.items;
+    return items !== undefined && items.length > 0;
+};
+
+(function (exports) {
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+__export(expression);
+__export(surveyItem);
+__export(surveyItemComponent);
+__export(response);
+}(data_types));
+
+const initialRootComp = () => {
+    return {
+        role: 'root',
+        order: { name: 'sequential' },
+        items: []
+    };
+};
+class ItemEditor {
+    constructor(existingItem, newItem) {
+        this.surveyItem = { key: '', version: 0 };
+        if (existingItem) {
+            this.surveyItem = Object.assign({}, existingItem);
+            // console.log(this.surveyItem);
+        }
+        else {
+            const key = (newItem === null || newItem === void 0 ? void 0 : newItem.itemKey) ? newItem.itemKey : 'no key';
+            if (newItem === null || newItem === void 0 ? void 0 : newItem.isGroup) {
+                const currentItem = {
+                    key,
+                    version: 1,
+                    items: [],
+                };
+                this.surveyItem = currentItem;
+            }
+            else {
+                const currentItem = {
+                    key,
+                    version: 1,
+                };
+                if (newItem === null || newItem === void 0 ? void 0 : newItem.type) {
+                    currentItem.type = newItem.type;
+                }
+                this.surveyItem = currentItem;
+            }
+        }
+    }
+    getItem() {
+        return Object.assign({}, this.surveyItem);
+    }
+    getItemJSON(pretty) {
+        return JSON.stringify(this.surveyItem, undefined, pretty ? '  ' : undefined);
+    }
+    setKey(newKey) {
+        this.surveyItem.key = newKey;
+    }
+    addToFollows(key) {
+        if (!this.surveyItem.follows) {
+            this.surveyItem.follows = [];
+        }
+        if (this.surveyItem.follows.includes(key)) {
+            console.warn('follows array already includes key: ', key);
+            return;
+        }
+        this.surveyItem.follows.push(key);
+    }
+    removeFromFollows(key) {
+        if (!this.surveyItem.follows) {
+            console.warn('follows array already empty');
+            return;
+        }
+        if (!this.surveyItem.follows.includes(key)) {
+            console.warn('follows array does not include key: ', key);
+            return;
+        }
+        this.surveyItem.follows = this.surveyItem.follows.filter(k => k !== key);
+    }
+    ;
+    clearFollows() {
+        if (!this.surveyItem.follows) {
+            console.warn('follows array already empty');
+            return;
+        }
+        this.surveyItem.follows = undefined;
+    }
+    ;
+    setCondition(exp) {
+        this.surveyItem.condition = exp;
+    }
+    ;
+    setPriority(prio) {
+        this.surveyItem.priority = prio;
+    }
+    ;
+    setVersion(version) {
+        this.surveyItem.version = version;
+    }
+    ;
+    setVersionTags(tags) {
+        this.surveyItem.versionTags = [...tags];
+    }
+    ;
+    // methods for survey group items:
+    addSurveyItem(item, atPosition) {
+        if (atPosition !== undefined) {
+            this.surveyItem.items.splice(atPosition, 0, Object.assign({}, item));
+        }
+        else {
+            this.surveyItem.items.push(Object.assign({}, item));
+        }
+    }
+    ;
+    updateSurveyItem(item) {
+        const ind = this.surveyItem.items.findIndex(it => item.key === it.key);
+        if (ind < 0) {
+            console.warn('item not found in the items array');
+            return;
+        }
+        this.surveyItem.items[ind] = Object.assign({}, item);
+    }
+    ;
+    removeItem(key) {
+        if (!this.surveyItem.items.find(it => it.key === key)) {
+            console.warn('group items does not contain item with key: ', key);
+            return;
+        }
+        this.surveyItem.items = this.surveyItem.items.filter(it => it.key !== key);
+    }
+    ;
+    changeItemPosition(key, newPosition) {
+        console.warn('unimplemented');
+    }
+    ;
+    setSelectionMethod(exp) {
+        this.surveyItem.selectionMethod = exp;
+    }
+    ;
+    // methods for survey single items:
+    setItemType(type) {
+        this.surveyItem.type = type;
+    }
+    ;
+    setTitleComponent(title) {
+        const currentItem = this.surveyItem;
+        if (!currentItem.components) {
+            currentItem.components = Object.assign({}, initialRootComp());
+        }
+        title.role = 'title';
+        const ind = currentItem.components.items.findIndex(comp => comp.role === 'title');
+        if (ind < 0) {
+            currentItem.components.items.push(Object.assign({}, title));
+            return;
+        }
+        currentItem.components.items[ind] = Object.assign({}, title);
+    }
+    setHelpGroupComponent(helpGroup) {
+        const currentItem = this.surveyItem;
+        if (!currentItem.components) {
+            currentItem.components = Object.assign({}, initialRootComp());
+        }
+        helpGroup.role = 'helpGroup';
+        const ind = currentItem.components.items.findIndex(comp => comp.role === 'helpGroup');
+        if (ind < 0) {
+            currentItem.components.items.push(Object.assign({}, helpGroup));
+            return;
+        }
+        currentItem.components.items[ind] = Object.assign({}, helpGroup);
+    }
+    ;
+    // for warning, error, texts:
+    addDisplayComponent(comp, atPosition) {
+        const currentItem = this.surveyItem;
+        if (!currentItem.components) {
+            currentItem.components = Object.assign({}, initialRootComp());
+        }
+        if (atPosition !== undefined) {
+            currentItem.components.items.splice(atPosition, 0, Object.assign({}, comp));
+        }
+        else {
+            currentItem.components.items.push(Object.assign({}, comp));
+        }
+    }
+    ;
+    updateDisplayComponent(at, comp) {
+        const currentItem = this.surveyItem;
+        if (!currentItem.components || !currentItem.components.items || currentItem.components.items.length <= at + 1 || at < 0) {
+            console.warn('component not found at ', at);
+            return;
+        }
+        currentItem.components.items[at] = Object.assign({}, comp);
+    }
+    ;
+    removeDisplayComponent(at) {
+        const currentItem = this.surveyItem;
+        if (!currentItem.components || !currentItem.components.items || currentItem.components.items.length <= at + 1 || at < 0) {
+            console.warn('component not found at ', at);
+            return;
+        }
+        currentItem.components.items.splice(at, 1);
+    }
+    ;
+    addNewResponseComponent(props, parentKey, atPosition) {
+        const currentItem = this.surveyItem;
+        if (!currentItem.components) {
+            currentItem.components = Object.assign({}, initialRootComp());
+        }
+        if (!parentKey) {
+            props.role = 'responseGroup';
+            if (!props.key) {
+                props.key = 'rg';
+            }
+            props.isGroup = true;
+            const newComponent = (new surveys_surveyEditor_componentEditor.ComponentEditor(undefined, props)).getComponent();
+            const ind = currentItem.components.items.findIndex(comp => comp.role === 'responseGroup');
+            if (ind < 0) {
+                currentItem.components.items.push(newComponent);
+                return Object.assign({}, newComponent);
+            }
+            currentItem.components.items[ind] = newComponent;
+            return Object.assign({}, newComponent);
+        }
+        const ids = parentKey.split('.');
+        let obj = undefined;
+        for (const currentKey of ids) {
+            if (!obj) {
+                const ind = currentItem.components.items.findIndex(c => c.key === currentKey);
+                if (ind < 0) {
+                    console.warn('response component not found: ', currentKey);
+                    return;
+                }
+                obj = currentItem.components.items[ind];
+                continue;
+            }
+            if (!data_types.isItemGroupComponent(obj)) {
+                obj.items = [];
+                // leaf found
+                break;
+            }
+            const index = obj.items.findIndex(it => it.key === currentKey);
+            if (index < 0) {
+                console.warn('item component cannot be found: ', currentKey);
+                return;
+            }
+            obj = obj.items[index];
+        }
+        if (!obj) {
+            console.warn('survey item cannot be found: ', parentKey);
+            return;
+        }
+        if (obj.items.find(it => props.key === it.key)) {
+            logger_logger.Logger.criticalError('Duplicate key: ' + props.key);
+            return undefined;
+        }
+        const newComponent = (new surveys_surveyEditor_componentEditor.ComponentEditor(undefined, props)).getComponent();
+        if (atPosition !== undefined) {
+            obj.items.splice(atPosition, 0, newComponent);
+        }
+        else {
+            obj.items.push(newComponent);
+        }
+        return newComponent;
+    }
+    ;
+    addExistingResponseComponent(newComp, parentKey, atPosition) {
+        const currentItem = this.surveyItem;
+        if (!currentItem.components) {
+            currentItem.components = Object.assign({}, initialRootComp());
+        }
+        if (newComp.key === undefined) {
+            newComp.key = surveys_utils_randomKeyGenerator.generateRandomKey(4);
+        }
+        if (!parentKey) {
+            const ind = currentItem.components.items.findIndex(comp => comp.role === 'responseGroup');
+            if (ind < 0) {
+                currentItem.components.items.push(newComp);
+                return Object.assign({}, newComp);
+            }
+            currentItem.components.items[ind] = newComp;
+            return Object.assign({}, newComp);
+        }
+        const ids = parentKey.split('.');
+        let obj = undefined;
+        for (const currentKey of ids) {
+            if (!obj) {
+                const ind = currentItem.components.items.findIndex(c => c.key === currentKey);
+                if (ind < 0) {
+                    console.warn('response component not found: ', currentKey);
+                    return;
+                }
+                obj = currentItem.components.items[ind];
+                continue;
+            }
+            if (!data_types.isItemGroupComponent(obj)) {
+                obj.items = [];
+                // leaf found
+                break;
+            }
+            const index = obj.items.findIndex(it => it.key === currentKey);
+            if (index < 0) {
+                console.warn('item component cannot be found: ', currentKey);
+                return;
+            }
+            obj = obj.items[index];
+        }
+        if (!obj) {
+            console.warn('item component cannot be found: ', parentKey);
+            return;
+        }
+        if (obj.items.find(it => newComp.key === it.key)) {
+            logger_logger.Logger.criticalError('Duplicate key: ' + newComp.key);
+            return undefined;
+        }
+        if (atPosition !== undefined) {
+            obj.items.splice(atPosition, 0, newComp);
+        }
+        else {
+            obj.items.push(newComp);
+        }
+        return newComp;
+    }
+    ;
+    updateResponseComponent(path, item) {
+        const currentItem = this.surveyItem;
+        if (!currentItem.components) {
+            return;
+        }
+        const responseGroup = currentItem.components.items.find(comp => comp.role === 'responseGroup');
+        if (!responseGroup) {
+            console.warn('no responseGroup found');
+            return;
+        }
+        if (responseGroup.key === path) {
+            const ind = currentItem.components.items.findIndex(it => it.key === path);
+            if (ind < 0) {
+                console.warn('item component cannot be found: ', path);
+                return;
+            }
+            currentItem.components.items[ind] = Object.assign({}, item);
+            return;
+        }
+        const ids = path.split('.');
+        const parentIds = ids.slice(1, ids.length - 1);
+        let obj = responseGroup;
+        for (const currentKey of parentIds) {
+            if (!data_types.isItemGroupComponent(obj)) {
+                // leaf found
+                break;
+            }
+            const index = obj.items.findIndex(it => it.key === currentKey);
+            if (index < 0) {
+                console.warn('item component cannot be found: ', currentKey);
+                return;
+            }
+            obj = obj.items[index];
+        }
+        if (!obj) {
+            console.warn('survey item cannot be found: ', path);
+            return;
+        }
+        const ind = obj.items.findIndex(it => it.key === ids[ids.length - 1]);
+        if (ind < 0) {
+            console.warn('item component cannot be found: ', path);
+            return;
+        }
+        obj.items[ind] = Object.assign({}, item);
+    }
+    ;
+    removeResponseComponent(keyPath) {
+        const currentItem = this.surveyItem;
+        if (!currentItem.components) {
+            return;
+        }
+        const responseGroup = currentItem.components.items.find(comp => comp.role === 'responseGroup');
+        if (!responseGroup) {
+            console.warn('no responseGroup found');
+            return;
+        }
+        if (responseGroup.key === keyPath) {
+            currentItem.components.items = currentItem.components.items.filter(it => it.role !== 'responseGroup');
+            return;
+        }
+        const ids = keyPath.split('.');
+        const parentIds = ids.slice(1, ids.length - 1);
+        let obj = responseGroup;
+        for (const currentKey of parentIds) {
+            if (!data_types.isItemGroupComponent(obj)) {
+                // leaf found
+                break;
+            }
+            const index = obj.items.findIndex(it => it.key === currentKey);
+            if (index < 0) {
+                console.warn('item component cannot be found: ', currentKey);
+                return;
+            }
+            obj = obj.items[index];
+        }
+        if (!obj) {
+            console.warn('survey item cannot be found: ', keyPath);
+            return;
+        }
+        obj.items = obj.items.filter(comp => comp.key !== ids[ids.length - 1]);
+    }
+    ;
+    findResponseComponent(key) {
+        const currentItem = this.surveyItem;
+        if (!currentItem.components) {
+            return;
+        }
+        const ids = key.split('.');
+        let obj = undefined;
+        for (const currentKey of ids) {
+            if (!obj) {
+                const ind = currentItem.components.items.findIndex(c => c.key === currentKey);
+                if (ind < 0) {
+                    console.warn('item component not found: ', currentKey);
+                    return;
+                }
+                obj = currentItem.components.items[ind];
+                continue;
+            }
+            if (!data_types.isItemGroupComponent(obj)) {
+                obj.items = [];
+                // leaf found
+                break;
+            }
+            const index = obj.items.findIndex(it => it.key === currentKey);
+            if (index < 0) {
+                console.warn('item component cannot be found: ', currentKey);
+                return;
+            }
+            obj = obj.items[index];
+        }
+        if (!obj) {
+            console.warn('item component cannot be found: ', key);
+            return;
+        }
+        return obj;
+    }
+    ;
+    addValidation(v) {
+        const currentItem = this.surveyItem;
+        if (!currentItem.validations) {
+            currentItem.validations = [];
+        }
+        if (currentItem.validations.find(valid => v.key === valid.key)) {
+            console.warn('validation key already used: ', v.key);
+            return;
+        }
+        currentItem.validations.push(Object.assign({}, v));
+        this.surveyItem = Object.assign({}, currentItem);
+    }
+    ;
+    removeValidation(vKey) {
+        const currentItem = this.surveyItem;
+        if (!currentItem.validations) {
+            console.warn('validation key not found used: ', vKey);
+            return;
+        }
+        if (currentItem.validations.find(valid => vKey === valid.key)) {
+            console.warn('validation key not found used: ', vKey);
+            return;
+        }
+        currentItem.validations = currentItem.validations.filter(v => v.key !== vKey);
+        this.surveyItem = Object.assign({}, currentItem);
+    }
+    ;
+}
+
+exports.ItemEditor = ItemEditor;
+exports.data_types = data_types;
+//# sourceMappingURL=item-editor-7f825952.js.map

package/item-editor-7f825952.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"item-editor-7f825952.js","sources":["../node_modules/survey-engine/lib/data_types/expression.js","../node_modules/survey-engine/lib/data_types/survey-item.js","../node_modules/survey-engine/lib/data_types/survey-item-component.js","../node_modules/survey-engine/lib/data_types/response.js","../node_modules/survey-engine/lib/data_types/index.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.isExpression = (value) => {\n    return typeof (value) === 'object' && value.name !== undefined && value.name.length > 0;\n};\nexports.expressionArgParser = (arg) => {\n    switch (arg.dtype) {\n        case 'num':\n            return arg.num;\n        case 'str':\n            return arg.str;\n        case 'exp':\n            return arg.exp;\n        default:\n            return arg.str;\n    }\n};\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.isSurveyGroupItem = (item) => {\n    const items = item.items;\n    return items !== undefined && items.length > 0;\n};\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.isItemGroupComponent = (item) => {\n    const items = item.items;\n    return items !== undefined && items.length > 0;\n};\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.isSurveyGroupItemResponse = (item) => {\n    const items = item.items;\n    return items !== undefined && items.length > 0;\n};\n","\"use strict\";\nfunction __export(m) {\n    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];\n}\nObject.defineProperty(exports, \"__esModule\", { value: true });\n__export(require(\"./expression\"));\n__export(require(\"./survey-item\"));\n__export(require(\"./survey-item-component\"));\n__export(require(\"./response\"));\n"],"names":["require$$0","require$$1","require$$2","require$$3"],"mappings":"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"}

package/{src/logger/index.ts → logger/index.d.ts}

@@ -1 +1 @@
-export { Logger } from './logger';
+export { Logger } from './logger';

package/logger/index.js

@@ -0,0 +1,10 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var logger_logger = require('./logger.js');
+
+
+
+exports.Logger = logger_logger.Logger;
+//# sourceMappingURL=index.js.map

package/logger/index.js.map

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

package/logger/logger.d.ts

@@ -0,0 +1,9 @@
+export declare class Logger {
+    static pretty: boolean;
+    static warn: (msg: any) => void;
+    static error: (msg: any) => void;
+    static criticalError: (msg: any) => void;
+    static success: (msg: any) => void;
+    static log: (msg: any) => void;
+    private static prepocessMsg;
+}

package/logger/logger.js

@@ -0,0 +1,31 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+class Logger {
+    static prepocessMsg(msg) {
+        if (typeof (msg) === 'object') {
+            return JSON.stringify(msg, undefined, Logger.pretty ? 2 : undefined);
+        }
+        return msg;
+    }
+}
+Logger.pretty = true;
+Logger.warn = (msg) => {
+    console.error(`\x1b[33m${Logger.prepocessMsg(msg)}\x1b[0m`);
+};
+Logger.error = (msg) => {
+    console.error(`\x1b[31m${Logger.prepocessMsg(msg)}\x1b[0m`);
+};
+Logger.criticalError = (msg) => {
+    console.error(`\x1b[41m${Logger.prepocessMsg(msg)}\x1b[0m`);
+};
+Logger.success = (msg) => {
+    console.log(`\x1b[32m${Logger.prepocessMsg(msg)}\x1b[0m`);
+};
+Logger.log = (msg) => {
+    console.log(`${Logger.prepocessMsg(msg)}`);
+};
+
+exports.Logger = Logger;
+//# sourceMappingURL=logger.js.map

package/logger/logger.js.map

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "case-editor-tools",
   "description": "Javascript tools to simplify survey and study coding for CASE.",
-  "version": "1.0.0-beta.16",
+  "version": "1.0.0-beta.17",
   "main": "index.js",
   "license": "Apache-2.0",
   "repository": "github:case-framework/case-editor-tools",

package/{src/surveys/index.ts → surveys/index.d.ts}

@@ -1,3 +1,3 @@
-export { SurveyItems } from './survey-items';
-export { SingleChoiceOptionTypes, MultipleChoiceOptionTypes, ClozeItemTypes } from './utils/optionDefGenerators';
-export { SurveyEngine } from './survey-engine-expressions';
+export { SurveyItems } from './survey-items';
+export { SingleChoiceOptionTypes, MultipleChoiceOptionTypes, ClozeItemTypes } from './utils/optionDefGenerators';
+export { SurveyEngine } from './survey-engine-expressions';

package/surveys/index.js

@@ -0,0 +1,26 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var surveys_surveyItems = require('./survey-items.js');
+var surveys_utils_optionDefGenerators = require('./utils/optionDefGenerators.js');
+var surveys_surveyEngineExpressions = require('./survey-engine-expressions.js');
+require('./survey-editor/component-editor.js');
+require('../item-editor-7f825952.js');
+require('./utils/randomKeyGenerator.js');
+require('../logger/logger.js');
+require('./utils/componentGenerators.js');
+require('./utils/simple-generators.js');
+require('../types/duration.js');
+require('../constants/key-definitions.js');
+require('./utils/simple-question-editor.js');
+require('../expression-utils/expressionGen.js');
+
+
+
+exports.SurveyItems = surveys_surveyItems.SurveyItems;
+exports.ClozeItemTypes = surveys_utils_optionDefGenerators.ClozeItemTypes;
+exports.MultipleChoiceOptionTypes = surveys_utils_optionDefGenerators.MultipleChoiceOptionTypes;
+exports.SingleChoiceOptionTypes = surveys_utils_optionDefGenerators.SingleChoiceOptionTypes;
+exports.SurveyEngine = surveys_surveyEngineExpressions.SurveyEngine;
+//# sourceMappingURL=index.js.map

package/surveys/index.js.map

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