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

package/surveys/survey-editor/component-editor.d.ts

@@ -0,0 +1,84 @@
+import { ItemComponent, Expression, LocalizedObject, ComponentProperties } from "survey-engine/data_types";
+import { NewComponentProps } from "./data-types";
+interface ComponentEditorInt {
+    getComponent: () => ItemComponent;
+    getComponentJSON: (pretty?: boolean) => string;
+    setKey: (key: string | undefined) => void;
+    setRole: (role: string) => void;
+    setDisplayCondition: (expression: Expression | undefined) => void;
+    setDisabled: (expression: Expression | undefined) => void;
+    setContent: (translations: LocalizedObject[] | undefined) => void;
+    setDescription: (translations: LocalizedObject[] | undefined) => void;
+    setStyles: (styles: Array<{
+        key: string;
+        value: string;
+    }> | undefined) => void;
+    setDType: (dtype: 'string' | 'number' | 'date') => void;
+    setProperties: (props: ComponentProperties | undefined) => void;
+    setOrder: (orderExp: Expression | undefined) => void;
+    addItemComponent: (item: ItemComponent, atPosition?: number) => void;
+    updateItemComponent: (selector: string | number, updatedItem: ItemComponent) => void;
+    removeItem: (index: number) => void;
+}
+export declare class ComponentEditor implements ComponentEditorInt {
+    component: ItemComponent;
+    constructor(existingComponent?: ItemComponent, newComponent?: NewComponentProps);
+    getComponent(): {
+        role: string;
+        key?: string | undefined;
+        content?: LocalizedObject[] | undefined;
+        displayCondition?: boolean | Expression | undefined;
+        disabled?: boolean | Expression | undefined;
+        style?: {
+            key: string;
+            value: string;
+        }[] | undefined;
+        description?: LocalizedObject[] | undefined;
+        properties?: ComponentProperties | undefined;
+    } | {
+        items: ItemComponent[];
+        order?: Expression | undefined;
+        role: string;
+        key?: string | undefined;
+        content?: LocalizedObject[] | undefined;
+        displayCondition?: boolean | Expression | undefined;
+        disabled?: boolean | Expression | undefined;
+        style?: {
+            key: string;
+            value: string;
+        }[] | undefined;
+        description?: LocalizedObject[] | undefined;
+        properties?: ComponentProperties | undefined;
+    } | {
+        key: string;
+        dtype?: string | undefined;
+        role: string;
+        content?: LocalizedObject[] | undefined;
+        displayCondition?: boolean | Expression | undefined;
+        disabled?: boolean | Expression | undefined;
+        style?: {
+            key: string;
+            value: string;
+        }[] | undefined;
+        description?: LocalizedObject[] | undefined;
+        properties?: ComponentProperties | undefined;
+    };
+    getComponentJSON(pretty?: boolean): string;
+    setKey(key: string | undefined): void;
+    setRole(role: string): void;
+    setDisplayCondition(expression: Expression | undefined): void;
+    setDisabled(expression: Expression | undefined): void;
+    setContent(translations: LocalizedObject[] | undefined): void;
+    setDescription(translations: LocalizedObject[] | undefined): void;
+    setStyles(styles: Array<{
+        key: string;
+        value: string;
+    }> | undefined): void;
+    setDType(dtype: 'string' | 'number' | 'date'): void;
+    setProperties(props: ComponentProperties | undefined): void;
+    setOrder(orderExp: Expression | undefined): void;
+    addItemComponent(item: ItemComponent, atPosition?: number): void;
+    updateItemComponent(selector: string | number, updatedItem: ItemComponent): void;
+    removeItem(index: number): void;
+}
+export {};

package/surveys/survey-editor/component-editor.js

@@ -0,0 +1,112 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+class ComponentEditor {
+    constructor(existingComponent, newComponent) {
+        if (existingComponent) {
+            this.component = Object.assign({}, existingComponent);
+        }
+        else if (newComponent) {
+            this.component = {
+                key: newComponent.key ? newComponent.key : undefined,
+                role: newComponent.role ? newComponent === null || newComponent === void 0 ? void 0 : newComponent.role : 'none',
+            };
+            if (newComponent.isGroup) {
+                this.component.items = [];
+            }
+        }
+        else {
+            this.component = { role: 'undefined' };
+        }
+    }
+    getComponent() {
+        return Object.assign({}, this.component);
+    }
+    ;
+    getComponentJSON(pretty) {
+        return JSON.stringify(this.component, undefined, pretty ? '  ' : undefined);
+    }
+    ;
+    setKey(key) {
+        this.component.key = key;
+    }
+    ;
+    setRole(role) {
+        this.component.role = role;
+    }
+    ;
+    setDisplayCondition(expression) {
+        this.component.displayCondition = expression;
+    }
+    ;
+    setDisabled(expression) {
+        this.component.disabled = expression;
+    }
+    ;
+    setContent(translations) {
+        this.component.content = translations ? [...translations] : undefined;
+    }
+    ;
+    setDescription(translations) {
+        this.component.description = translations ? [...translations] : undefined;
+    }
+    ;
+    setStyles(styles) {
+        this.component.style = styles ? [...styles] : undefined;
+    }
+    ;
+    // response components:
+    setDType(dtype) {
+        this.component.dtype = dtype;
+    }
+    ;
+    setProperties(props) {
+        this.component.properties = Object.assign({}, props);
+    }
+    ;
+    // item group component:
+    setOrder(orderExp) {
+        this.component.order = orderExp;
+    }
+    ;
+    addItemComponent(item, atPosition) {
+        if (!this.component.items) {
+            this.component.items = [];
+        }
+        if (atPosition !== undefined) {
+            this.component.items.splice(atPosition, 0, Object.assign({}, item));
+        }
+        else {
+            this.component.items.push(Object.assign({}, item));
+        }
+    }
+    ;
+    updateItemComponent(selector, updatedItem) {
+        if (!this.component.items) {
+            console.warn('items array missing on the component');
+            return;
+        }
+        if (typeof (selector) === 'string') {
+            // find by key:
+            const ind = this.component.items.findIndex(c => c.key === selector);
+            if (ind < 0) {
+                console.warn('could not find component with given key: ', selector);
+                return;
+            }
+            this.component.items[ind] = Object.assign({}, updatedItem);
+        }
+        else if (typeof (selector) === 'number') {
+            // find by index:
+            this.component.items[selector] = Object.assign({}, updatedItem);
+        }
+    }
+    ;
+    removeItem(index) {
+        this.component.items.splice(index, 1);
+    }
+    ;
+}
+
+exports.ComponentEditor = ComponentEditor;
+//# sourceMappingURL=component-editor.js.map

package/surveys/survey-editor/component-editor.js.map

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

package/surveys/survey-editor/data-types.d.ts

@@ -0,0 +1,13 @@
+import { SurveyItemTypes } from "survey-engine/data_types";
+export interface NewItemProps {
+    itemKey?: string;
+    isGroup?: boolean;
+    type?: SurveyItemTypes;
+}
+export interface NewComponentProps {
+    key?: string;
+    isGroup?: boolean;
+    role?: string;
+}
+export interface SurveyProperties {
+}

package/surveys/survey-editor/data-types.js

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

package/surveys/survey-editor/data-types.js.map

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

package/surveys/survey-editor/item-editor.d.ts

@@ -0,0 +1,66 @@
+import { SurveyItem, SurveyItemTypes, Expression, Validation, ItemComponent, ItemGroupComponent, ConfidentialMode } from "survey-engine/data_types";
+import { NewItemProps, NewComponentProps } from "./data-types";
+interface ItemEditorInt {
+    getItem: () => SurveyItem;
+    getItemJSON: (pretty?: boolean) => string;
+    setKey: (newKey: string) => void;
+    addToFollows: (key: string) => void;
+    removeFromFollows: (key: string) => void;
+    clearFollows: () => void;
+    setCondition: (exp: Expression | undefined) => void;
+    setPriority: (prio: number | undefined) => void;
+    setVersion: (version: number) => void;
+    setVersionTags: (tags: string[]) => void;
+    addSurveyItem: (item: SurveyItem, atPosition?: number) => void;
+    updateSurveyItem: (item: SurveyItem) => void;
+    removeItem: (key: string) => void;
+    changeItemPosition: (key: string, newPosition: number) => void;
+    setSelectionMethod: (exp: Expression | undefined) => void;
+    setItemType: (type: SurveyItemTypes) => void;
+    setTitleComponent: (title: ItemComponent) => void;
+    setHelpGroupComponent: (helpGroup: ItemGroupComponent) => void;
+    addDisplayComponent: (comp: ItemComponent, atPosition?: number) => void;
+    updateDisplayComponent: (at: number, comp: ItemComponent) => void;
+    removeDisplayComponent: (at: number) => void;
+    addNewResponseComponent: (props: NewComponentProps, parentKey?: string, atPosition?: number) => ItemComponent | undefined;
+    addExistingResponseComponent: (newComp: ItemComponent, parentKey?: string, atPosition?: number) => ItemComponent | undefined;
+    updateResponseComponent: (path: string, item: ItemComponent) => void;
+    removeResponseComponent: (key: string) => void;
+    findResponseComponent: (key: string) => ItemComponent | undefined;
+    addValidation: (v: Validation) => void;
+    removeValidation: (vKey: string) => void;
+}
+export declare class ItemEditor implements ItemEditorInt {
+    private surveyItem;
+    constructor(existingItem?: SurveyItem, newItem?: NewItemProps);
+    getItem(): SurveyItem;
+    getItemJSON(pretty?: boolean): string;
+    setKey(newKey: string): void;
+    setConfidentialMode(confidentialMode?: ConfidentialMode): void;
+    addToFollows(key: string): void;
+    removeFromFollows(key: string): void;
+    clearFollows(): void;
+    setCondition(exp: Expression | undefined): void;
+    setPriority(prio: number | undefined): void;
+    setVersion(version: number): void;
+    setVersionTags(tags: string[]): void;
+    addSurveyItem(item: SurveyItem, atPosition?: number): void;
+    updateSurveyItem(item: SurveyItem): void;
+    removeItem(key: string): void;
+    changeItemPosition(key: string, newPosition: number): void;
+    setSelectionMethod(exp: Expression | undefined): void;
+    setItemType(type: SurveyItemTypes): void;
+    setTitleComponent(title: ItemComponent): void;
+    setHelpGroupComponent(helpGroup: ItemGroupComponent): void;
+    addDisplayComponent(comp: ItemComponent, atPosition?: number): void;
+    updateDisplayComponent(at: number, comp: ItemComponent): void;
+    removeDisplayComponent(at: number): void;
+    addNewResponseComponent(props: NewComponentProps, parentKey?: string, atPosition?: number): ItemComponent | undefined;
+    addExistingResponseComponent(newComp: ItemComponent, parentKey?: string, atPosition?: number): ItemComponent | undefined;
+    updateResponseComponent(path: string, item: ItemComponent): void;
+    removeResponseComponent(keyPath: string): void;
+    findResponseComponent(key: string): ItemComponent | undefined;
+    addValidation(v: Validation): void;
+    removeValidation(vKey: string): void;
+}
+export {};

package/surveys/survey-editor/item-editor.js

@@ -0,0 +1,13 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var surveys_surveyEditor_itemEditor = require('../../item-editor-59f51ecc.js');
+require('./component-editor.js');
+require('../utils/randomKeyGenerator.js');
+require('../../logger/logger.js');
+
+
+
+exports.ItemEditor = surveys_surveyEditor_itemEditor.ItemEditor;
+//# sourceMappingURL=item-editor.js.map

package/surveys/survey-editor/item-editor.js.map

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

package/surveys/survey-editor/survey-editor.d.ts

@@ -0,0 +1,48 @@
+import { Survey, LocalizedString, SurveyItem, SurveyContextDef, Expression } from "survey-engine/data_types";
+import { SurveyAvailableFor } from "../types";
+import { NewItemProps } from "./data-types";
+interface SurveyEditorInt {
+    setSurveyName: (name: Array<LocalizedString>) => void;
+    setSurveyDescription: (description: Array<LocalizedString>) => void;
+    setSurveyDuration: (duration: Array<LocalizedString>) => void;
+    setSurveyContextRules: (contextRules: SurveyContextDef) => void;
+    setPrefillRules: (rules: Expression[]) => void;
+    setAvailableFor: (value?: SurveyAvailableFor) => void;
+    setRequireLoginBeforeSubmission: (value?: boolean) => void;
+    changeItemKey: (oldKey: string, newKey: string) => void;
+    addNewSurveyItem: (itemProps: NewItemProps, parentKey?: string, atPosition?: number) => SurveyItem | undefined;
+    updateSurveyItem: (item: SurveyItem) => void;
+    removeItem: (key: string) => void;
+    findSurveyItem: (itemKey: string) => SurveyItem | undefined;
+    moveSurveyItem: (item: SurveyItem, destination: string) => void;
+    getSurvey: () => Survey;
+    getSurveyJSON: (pretty?: boolean) => string;
+}
+export declare class SurveyEditor implements SurveyEditorInt {
+    private survey;
+    private surveyKey;
+    constructor(survey?: Survey);
+    setSurveyName(name: Array<LocalizedString>): void;
+    setSurveyDescription(description: Array<LocalizedString>): void;
+    setSurveyDuration(duration: Array<LocalizedString>): void;
+    setMaxItemPerPage(itemLimits: {
+        small: number;
+        large: number;
+    }): void;
+    setAvailableFor(value?: SurveyAvailableFor | undefined): void;
+    setRequireLoginBeforeSubmission(value?: boolean | undefined): void;
+    setSurveyContextRules(contextRules: SurveyContextDef): void;
+    setPrefillRules(rules: Expression[]): void;
+    addNewSurveyItem(newItem: NewItemProps, parentKey?: string, atPosition?: number): SurveyItem | undefined;
+    addExistingSurveyItem(surveyItem: SurveyItem, parentKey: string, atPosition?: number): SurveyItem | undefined;
+    changeItemKey(oldKey: string, newKey: string, ignoreReferences?: boolean): void;
+    updateSurveyItem(item: SurveyItem): void;
+    removeItem(key: string): void;
+    moveSurveyItem(item: SurveyItem, destination: string): void;
+    findSurveyItem(itemKey: string): SurveyItem | undefined;
+    getSurvey(): Survey;
+    getSurveyJSON(pretty?: boolean): string;
+    private getKeyListForPath;
+    private changeItemKeyForSubtree;
+}
+export {};

package/surveys/survey-editor/survey-editor.js

@@ -0,0 +1,237 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var surveys_surveyEditor_itemEditor = require('../../item-editor-59f51ecc.js');
+var logger_logger = require('../../logger/logger.js');
+require('./component-editor.js');
+require('../utils/randomKeyGenerator.js');
+
+class SurveyEditor {
+    constructor(survey) {
+        if (survey) {
+            this.survey = Object.assign({}, survey);
+            this.surveyKey = this.survey.current.surveyDefinition.key;
+        }
+        else {
+            this.surveyKey = 'survey';
+            this.survey = {
+                props: {},
+                current: {
+                    versionId: '',
+                    surveyDefinition: {
+                        key: this.surveyKey,
+                        version: 1,
+                        items: []
+                    }
+                }
+            };
+        }
+    }
+    setSurveyName(name) {
+        if (!this.survey.props) {
+            this.survey.props = {};
+        }
+        this.survey.props.name = name;
+    }
+    ;
+    setSurveyDescription(description) {
+        if (!this.survey.props) {
+            this.survey.props = {};
+        }
+        this.survey.props.description = description;
+    }
+    ;
+    setSurveyDuration(duration) {
+        if (!this.survey.props) {
+            this.survey.props = {};
+        }
+        this.survey.props.typicalDuration = duration;
+    }
+    ;
+    setMaxItemPerPage(itemLimits) {
+        this.survey.maxItemsPerPage = itemLimits;
+    }
+    setAvailableFor(value) {
+        this.survey.availableFor = value;
+    }
+    setRequireLoginBeforeSubmission(value) {
+        this.survey.requireLoginBeforeSubmission = value;
+    }
+    setSurveyContextRules(contextRules) {
+        this.survey.contextRules = Object.assign({}, contextRules);
+    }
+    ;
+    setPrefillRules(rules) {
+        this.survey.prefillRules = [...rules];
+    }
+    ;
+    addNewSurveyItem(newItem, parentKey, atPosition) {
+        if (!parentKey) {
+            newItem.itemKey = this.surveyKey + '.' + newItem.itemKey;
+            if (this.survey.current.surveyDefinition.items.find(it => newItem.itemKey === it.key)) {
+                logger_logger.Logger.criticalError('Duplicate key in survey: ' + newItem.itemKey);
+                return undefined;
+            }
+            const item = (new surveys_surveyEditor_itemEditor.ItemEditor(undefined, newItem)).getItem();
+            if (atPosition !== undefined) {
+                this.survey.current.surveyDefinition.items.splice(atPosition, 0, item);
+            }
+            else {
+                this.survey.current.surveyDefinition.items.push(item);
+            }
+            return item;
+        }
+        const obj = this.findSurveyItem(parentKey);
+        if (!obj) {
+            console.warn('parent survey item cannot be found: ', parentKey);
+            return;
+        }
+        newItem.itemKey = parentKey + '.' + newItem.itemKey;
+        if (obj.items.find(it => newItem.itemKey === it.key)) {
+            logger_logger.Logger.criticalError('Duplicate key in survey: ' + newItem.itemKey);
+            return undefined;
+        }
+        const item = (new surveys_surveyEditor_itemEditor.ItemEditor(undefined, newItem)).getItem();
+        if (atPosition !== undefined) {
+            obj.items.splice(atPosition, 0, item);
+        }
+        else {
+            obj.items.push(item);
+        }
+        return item;
+    }
+    addExistingSurveyItem(surveyItem, parentKey, atPosition) {
+        const parent = this.findSurveyItem(parentKey);
+        if (!parent) {
+            console.warn('parent survey item cannot be found: ', parentKey);
+            return;
+        }
+        if (parent.items.find(it => surveyItem.key === it.key)) {
+            logger_logger.Logger.criticalError('Duplicate key in survey: ' + surveyItem.key);
+            return undefined;
+        }
+        if (atPosition !== undefined) {
+            parent.items.splice(atPosition, 0, surveyItem);
+        }
+        else {
+            parent.items.push(surveyItem);
+        }
+        return surveyItem;
+    }
+    changeItemKey(oldKey, newKey, ignoreReferences) {
+        if (oldKey === this.surveyKey) {
+            this.surveyKey = newKey;
+            this.survey.current.surveyDefinition = this.changeItemKeyForSubtree(this.survey.current.surveyDefinition, newKey);
+            return;
+        }
+        let obj = this.findSurveyItem(oldKey);
+        if (!obj) {
+            console.warn('survey item cannot be found: ', oldKey);
+            return;
+        }
+        obj = Object.assign(obj, this.changeItemKeyForSubtree(obj, newKey));
+        if (!ignoreReferences) {
+            // replace key in every expression of the survey
+            // replace key in every follows
+            console.warn('unimplemented UPDATING KEY REFERENCES');
+        }
+    }
+    ;
+    updateSurveyItem(item) {
+        if (item.key === this.surveyKey) {
+            this.survey.current.surveyDefinition = Object.assign(Object.assign({}, this.survey.current.surveyDefinition), item);
+            return;
+        }
+        const ids = item.key.split('.');
+        const parentIds = ids.slice(0, ids.length - 1);
+        const parentKey = parentIds.join('.');
+        const obj = this.findSurveyItem(parentKey);
+        if (!obj) {
+            console.warn('parent survey item cannot be found: ', parentKey);
+            return;
+        }
+        const index = obj.items.findIndex(it => it.key === item.key);
+        if (index < 0) {
+            console.warn('survey item cannot be found: ', item.key);
+            return;
+        }
+        obj.items[index] = Object.assign(Object.assign({}, obj.items[index]), item);
+        return;
+    }
+    ;
+    removeItem(key) {
+        // <- error if item is not found
+        console.warn('removeItem unimplemented');
+        return;
+    }
+    ;
+    moveSurveyItem(item, destination) {
+        console.warn('moveSurveyItem unimplemented');
+        // error if destination not exists
+        // change item key
+        // change key for all children recursivly
+    }
+    ;
+    findSurveyItem(itemKey) {
+        const ids = itemKey.split('.');
+        const paths = this.getKeyListForPath(ids);
+        let obj = undefined;
+        for (const currentKey of paths) {
+            if (!obj) {
+                obj = this.survey.current.surveyDefinition;
+                continue;
+            }
+            if (!surveys_surveyEditor_itemEditor.isSurveyGroupItem(obj)) {
+                console.warn('survey item is not a group: ', obj.key);
+                return;
+            }
+            const index = obj.items.findIndex(it => it.key === currentKey);
+            if (index < 0) {
+                console.warn('survey item cannot be found: ', currentKey);
+                return;
+            }
+            obj = obj.items[index];
+        }
+        return obj;
+    }
+    ;
+    getSurvey() {
+        return Object.assign({}, this.survey);
+    }
+    ;
+    getSurveyJSON(pretty) {
+        return JSON.stringify(this.survey, undefined, pretty ? '  ' : undefined);
+    }
+    ;
+    // Private methods:
+    getKeyListForPath(ids) {
+        const paths = [];
+        let compID = '';
+        for (let i = 0; i < ids.length; i++) {
+            const id = ids[i];
+            if (compID.length < 1) {
+                compID = id;
+            }
+            else {
+                compID += '.' + id;
+            }
+            paths.push(compID);
+        }
+        return paths;
+    }
+    changeItemKeyForSubtree(currentItem, newKey) {
+        currentItem = Object.assign({}, currentItem);
+        if (surveys_surveyEditor_itemEditor.isSurveyGroupItem(currentItem)) {
+            currentItem.items = currentItem.items.map(item => {
+                const newSubkey = newKey + '.' + item.key.slice(item.key.lastIndexOf('.') + 1);
+                return this.changeItemKeyForSubtree(item, newSubkey);
+            });
+        }
+        currentItem.key = newKey;
+        return currentItem;
+    }
+}
+
+exports.SurveyEditor = SurveyEditor;
+//# sourceMappingURL=survey-editor.js.map

package/surveys/survey-editor/survey-editor.js.map

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