@media-quest/builder 0.0.1 → 0.0.3

package/src/Builder-question.spec.ts

@@ -0,0 +1,68 @@
+import type { BuilderQuestionDto } from "./Builder-question";
+import { BuilderQuestion } from "./Builder-question";
+import type { BuilderObjectId } from "./BuilderObject";
+
+const question1: BuilderQuestionDto = {
+    id: "q1" as BuilderObjectId.QuestionID,
+    prefix: "q1",
+    text: "sadf",
+    options: [],
+    _type: "select-one",
+};
+
+const question2: BuilderQuestionDto = {
+    id: "q3" as BuilderObjectId.QuestionID,
+    prefix: "a",
+    text: "har du..",
+    _type: "select-one",
+    // options: []
+    options: [
+        {
+            id: "q3-opt1" as BuilderObjectId.QuestionOptionID,
+            value: 0,
+            label: "Nei",
+        },
+        {
+            id: "q3-opt2" as BuilderObjectId.QuestionOptionID,
+            value: 1,
+            label: "Ja",
+        },
+        {
+            id: "q3-opt3" as BuilderObjectId.QuestionOptionID,
+            value: 9,
+            label: "Vet ikke",
+        },
+    ],
+};
+
+describe("Builder Question", () => {
+    test("Can create question from json", () => {
+        const q1 = BuilderQuestion.fromJson(question1);
+        const q1AsJson = q1.toJson();
+        expect(question1).toStrictEqual(q1AsJson);
+        const q2Instance = BuilderQuestion.fromJson(question2);
+        const q2AsJson = q2Instance.toJson();
+        expect(question2).toStrictEqual(q2AsJson);
+    });
+    test("Can add options", () => {
+        const q1 = BuilderQuestion.fromJson(question1);
+        expect(q1.options.length).toBe(0);
+        q1.addOption("Ja", 1);
+        expect(q1.options.length).toBe(1);
+        const nei = q1.addOption("Nei", 0, 0);
+        expect(q1.options.length).toBe(2);
+        expect(q1.options[0]).toBe(nei);
+        const vetIkke = q1.addOption("Vet-ikke", 9);
+        expect(q1.options.length).toBe(3);
+        expect(q1.options[2]).toBe(vetIkke);
+    });
+    test("Can delete options", () => {
+        const q = BuilderQuestion.fromJson(question2);
+        expect(q.options.length).toBe(3);
+        const o1 = q.options[0];
+        const o2 = q.options[1];
+        const o3 = q.options[2];
+        const didDelete = q.deleteOption(o1);
+        expect(q.options.length).toBe(2);
+    });
+});

package/src/Builder-question.ts

@@ -0,0 +1,101 @@
+import type { BuilderOptionDto } from "./Builder-option";
+import { BuilderOption } from "./Builder-option";
+import { BuilderObject, BuilderObjectId } from "./BuilderObject";
+
+export type BuilderQuestionType =
+    | "select-one"
+    | "select-many"
+    | "text"
+    | "color"
+    | "radio"
+    | "email"
+    | "time"
+    | "checkbox"
+    | "textarea"
+    | "date"
+    | "numeric-range"
+    | "duration";
+
+export interface BuilderQuestionDto {
+    readonly id: BuilderObjectId.QuestionID;
+    _type: BuilderQuestionType;
+    text: string;
+    options: ReadonlyArray<BuilderOptionDto>;
+    prefix: string;
+}
+
+export class BuilderQuestion extends BuilderObject<"builder-question", BuilderQuestionDto> {
+    readonly objectType = "builder-question";
+    id: BuilderObjectId.QuestionID;
+    type: BuilderQuestionType;
+    questionText = "";
+    options: BuilderOption[] = [];
+    prefix = "";
+
+    static create = (type: BuilderQuestionType) => {
+        const id = BuilderObjectId.questionId();
+
+        return new BuilderQuestion({
+            id,
+            _type: type,
+            text: "",
+            options: [],
+            prefix: "",
+        });
+    };
+
+    public static fromJson(dto: BuilderQuestionDto): BuilderQuestion {
+        const question = new BuilderQuestion(dto);
+        return question;
+    }
+
+    private constructor(dto: BuilderQuestionDto) {
+        super(dto);
+        this.id = dto.id as BuilderObjectId.QuestionID;
+        this.type = dto._type;
+        this.questionText = dto.text;
+        this.prefix = dto.prefix;
+        this.options = dto.options.map((o) => BuilderOption.fromJson(o));
+    }
+
+    addOption(label: string, value: number, atIndex = -1) {
+        const option = BuilderOption.create(value, label);
+        if (atIndex >= 0 && atIndex < this.options.length) {
+            this.options.splice(atIndex, 0, option);
+        } else {
+            this.options.push(option);
+        }
+        return option;
+    }
+
+    deleteOption(option: BuilderOption): boolean {
+        const filtered = this.options.filter((o) => o.id !== option.id);
+        const didDelete = filtered.length === this.options.length - 1;
+        this.options = filtered;
+        return didDelete;
+    }
+
+    toJson() {
+        const optionsJson = this.options.map((o) => o.toJson());
+        const dto: BuilderQuestionDto = {
+            id: this.id,
+            prefix: this.prefix,
+            _type: this.type,
+            text: this.questionText,
+            options: optionsJson,
+        };
+        return dto;
+    }
+
+    clone(): BuilderQuestionDto {
+        const cloneId = BuilderObjectId.questionId();
+        const dto = this.toJson();
+        const optionsClone = this.options.map((o) => o.clone());
+        const clonedDto: BuilderQuestionDto = {
+            ...dto,
+            id: cloneId,
+            options: optionsClone,
+        };
+        return clonedDto;
+    }
+}

package/src/Builder-schema.spec.ts

@@ -0,0 +1,302 @@
+import type { BuilderSchemaDto } from "./Builder-schema";
+import { BuilderSchema } from "./Builder-schema";
+import { BuilderPage } from "./Builder-page";
+import type { BuilderTagDto } from "./BuilderTag";
+import { BuilderTag } from "./BuilderTag";
+import type { BuilderObjectId } from "./BuilderObject";
+
+const tag1: BuilderTagDto = BuilderTag.create("tag1", "This tag is defined in schemaDto1").toJson();
+
+const tag2: BuilderTagDto = BuilderTag.create("tag2", "This tag is defined in schemaDto1").toJson();
+const tag3: BuilderTagDto = BuilderTag.create("tag3", "This tag is defined in schemaDto1").toJson();
+
+const schemaDto1: BuilderSchemaDto = {
+    backgroundColor: "gray",
+    baseHeight: 1200,
+    baseWidth: 1022,
+    mainImage: false,
+    id: "dto1",
+    name: "dto1-name",
+    tags: [tag1, tag2, tag3],
+    pages: [
+        {
+            id: "page1" as BuilderObjectId.PageID,
+            _type: "info-page",
+            prefix: "p1",
+            mainText: {
+                text: "hello from test",
+                autoplay: false,
+                autoplayDelay: 0,
+                audioFile: false,
+            },
+
+            nextButton: {
+                id: "next-button-text-id" as BuilderObjectId.QuestionOptionID,
+                label: "Neste",
+                value: -1,
+            },
+            defaultQuestion: {
+                id: "q1" as BuilderObjectId.QuestionID,
+                prefix: "one-prefix",
+                _type: "select-one",
+                text: "q1-text",
+                options: [
+                    {
+                        id: "opt-nei" as BuilderObjectId.QuestionOptionID,
+                        value: 0,
+                        label: "Nei",
+                    },
+                    {
+                        id: "opt-ja" as BuilderObjectId.QuestionOptionID,
+                        value: 1,
+                        label: "Ja",
+                    },
+                    {
+                        id: "opt-vet-ikke" as BuilderObjectId.QuestionOptionID,
+                        value: 9,
+                        label: "Vet ikke",
+                    },
+                ],
+            },
+            tags: [
+                tag1.tag,
+                tag2.tag,
+                // { tag: 'can_read', description: 'The patient can read' },
+                // { tag: 'is grown up', description: 'Is grownUp.' }
+            ],
+            questions: [],
+            autoplaySequence: [],
+        },
+        {
+            id: "page2" as BuilderObjectId.PageID,
+            _type: "multi-select",
+            prefix: "page2-prefix",
+            tags: [tag3.tag],
+            mainText: {
+                text: "hello from test",
+                autoplay: false,
+                autoplayDelay: 0,
+                audioFile: false,
+            },
+            nextButton: {
+                id: "next-button-id-page2" as BuilderObjectId.QuestionOptionID,
+                label: "Neste",
+                value: -1,
+            },
+            defaultQuestion: {
+                id: "default-q" as BuilderObjectId.QuestionID,
+                prefix: "one-prefix",
+                _type: "select-one",
+                text: "q1",
+                options: [],
+            },
+            questions: [
+                {
+                    id: "q1" as BuilderObjectId.QuestionID,
+                    prefix: "one-prefix",
+                    _type: "select-one",
+                    text: "q1-text",
+                    options: [
+                        {
+                            id: "opt-nei" as BuilderObjectId.QuestionOptionID,
+                            value: 0,
+                            label: "Nei",
+                        },
+                        {
+                            id: "opt-ja" as BuilderObjectId.QuestionOptionID,
+                            value: 1,
+                            label: "Ja",
+                        },
+                        {
+                            id: "opt-vet-ikke" as BuilderObjectId.QuestionOptionID,
+                            value: 9,
+                            label: "Vet ikke",
+                        },
+                    ],
+                },
+            ],
+            autoplaySequence: [],
+        },
+    ],
+    rules: [],
+    prefix: "d1",
+};
+
+let builderSchema = BuilderSchema.create("a-id", "test", "a");
+
+beforeEach(() => {
+    builderSchema = BuilderSchema.create("a-id", "test-name", "a");
+});
+
+describe("Builder schema", () => {
+    test("Can add pages.", () => {
+        builderSchema.addPage("question");
+        builderSchema.addPage("info-page");
+        expect(builderSchema.pages.length).toBe(2);
+        const dto = builderSchema.compile().schema;
+        expect(dto.pages.length).toBe(2);
+        expect(dto.id).toBe(builderSchema.id);
+        expect(dto.prefix).toBe(builderSchema.prefix);
+        expect(dto.baseHeight).toBe(builderSchema.baseHeight);
+        expect(dto.baseWidth).toBe(builderSchema.baseWidth);
+        expect(dto.backgroundColor).toBe(builderSchema.backgroundColor);
+    });
+
+    test("Can delete page by passing reference", () => {
+        const p1 = builderSchema.addPage("question");
+        const p2 = builderSchema.addPage("question");
+        const p3 = builderSchema.addPage("info-page");
+        expect(builderSchema.pages.length).toBe(3);
+        const result = builderSchema.deletePage(p1);
+        expect(builderSchema.pages.length).toBe(2);
+        expect(result).toBe(true);
+        const result2 = builderSchema.deletePage(p2);
+        expect(result2).toBe(true);
+        expect(builderSchema.pages.length).toBe(1);
+        expect(builderSchema.pages[0]).toBe(p3);
+        const result3 = builderSchema.deletePage(p2);
+        expect(result3).toBe(false);
+        const result4 = builderSchema.deletePage(p3);
+        expect(result4).toBe(true);
+    });
+
+    test("Can create Schema from dto", () => {
+        const s = BuilderSchema.fromJson(schemaDto1);
+        expect(s.id).toBe(schemaDto1.id);
+        expect(s.prefix).toBe(schemaDto1.prefix);
+        expect(s.baseHeight).toBe(schemaDto1.baseHeight);
+        expect(s.baseWidth).toBe(schemaDto1.baseWidth);
+        expect(s.backgroundColor).toBe(schemaDto1.backgroundColor);
+        expect(s.pages.length).toBe(schemaDto1.pages.length);
+        const p1Dto = schemaDto1.pages[0];
+        expect(s.pages[0].id).toBe(p1Dto.id);
+        const defaultQuestion = s.pages[0].defaultQuestion;
+        expect(defaultQuestion).toBeDefined();
+        expect(defaultQuestion.id).toBe(p1Dto.defaultQuestion.id);
+        expect(defaultQuestion.options.length).toBe(p1Dto.defaultQuestion.options.length);
+        const options = defaultQuestion.options;
+        const nei = options[0];
+        const ja = options[1];
+        const vetIkke = options[2];
+        expect(nei.label).toBe("Nei");
+        expect(ja.label).toBe("Ja");
+        expect(vetIkke.label).toBe("Vet ikke");
+        expect(vetIkke.id).toBe(p1Dto.defaultQuestion.options[2].id);
+    });
+
+    test("fromJson === toJson", () => {
+        const s = BuilderSchema.fromJson(schemaDto1);
+        const json = s.toJson();
+        expect(schemaDto1).toStrictEqual(json);
+    });
+    test("Can add page at concrete index", () => {
+        const p1 = builderSchema.addPage("form");
+        expect(p1.pageType).toBe("form");
+        const p2 = builderSchema.addPage("multi-select", 0);
+        expect(p2.pageType).toBe("multi-select");
+        const pages = builderSchema.pages;
+        expect(pages[0].id).toBe(p2.id);
+        builderSchema.addPage("form");
+        builderSchema.addPage("form");
+        const last = builderSchema.addPage("form");
+        expect(builderSchema.pages[builderSchema.pages.length - 1]).toBe(last);
+        const p3 = builderSchema.addPage("info-page", 4);
+        expect(pages[4].id).toBe(p3.id);
+    });
+    test("Can move page up and down", () => {
+        const p1 = builderSchema.addPage("form");
+        const p2 = builderSchema.addPage("form");
+        const p3 = builderSchema.addPage("form");
+        const p4 = builderSchema.addPage("multi-select");
+        const last = builderSchema.addPage("form");
+        const pages = builderSchema.pages;
+        builderSchema.movePage(p2, 0);
+        expect(pages[0]).toBe(p2);
+        expect(pages[1]).toBe(p1);
+        expect(builderSchema.movePage(p4, 4)).toBeTruthy();
+        expect(builderSchema.movePage(p4, 5)).toBeFalsy();
+        expect(builderSchema.movePage(p4, 10)).toBeFalsy();
+
+        // expect(pages[0].id).toBe(p4.id);
+    });
+    test("Can clone a page and insert at index", () => {
+        const p1 = builderSchema.addPage("form");
+        const p2 = builderSchema.addPage("form");
+        const p3 = builderSchema.addPage("form");
+        const mainTextContent = "Hello from test";
+        const p4 = builderSchema.addPage("multi-select");
+        p3.mainText.text = mainTextContent;
+        const p1Clone = BuilderPage.fromJson(p1.clone());
+        const beforeLen = builderSchema.pages.length;
+        builderSchema.insertPage(p1Clone, 2);
+        const pages = builderSchema.pages;
+        expect(beforeLen + 1).toBe(pages.length);
+        expect(pages[2]).toBe(p1Clone);
+    });
+    test("Will not insert a page that is already in array.", () => {
+        const p1 = builderSchema.addPage("form");
+        const p2 = builderSchema.addPage("form");
+        const p3 = builderSchema.addPage("form");
+        const beforeLen = builderSchema.pages.length;
+        const result = builderSchema.insertPage(p1, 0);
+        const pages = builderSchema.pages;
+        expect(beforeLen).toBe(pages.length);
+        expect(result).toBe(false);
+    });
+
+    test("Can generate a info-page", () => {
+        const p1 = builderSchema.addPage("info-page");
+        const p2 = builderSchema.addPage("question");
+        p2.defaultQuestion.addOption("Ja", 1, 0);
+        p2.defaultQuestion.addOption("Nei", 0);
+        p1.nextButton.label = "Neste";
+        builderSchema.backgroundColor = "red";
+        builderSchema.baseHeight = 600;
+        builderSchema.baseWidth = 500;
+        builderSchema.prefix = "as";
+        builderSchema.name = "depressed";
+        const schema = builderSchema.compile().schema;
+        expect(schema.backgroundColor).toBe("red");
+        expect(schema.baseHeight).toBe(600);
+        expect(schema.baseWidth).toBe(500);
+        expect(schema.prefix).toBe("as");
+        expect(schema.pages.length).toBe(2);
+        const schemaP1 = schema.pages[0];
+        const schemaP2 = schema.pages[1];
+        expect(schemaP1.id).toBe(p1.id);
+        expect(schemaP2.id).toBe(p2.id);
+        expect(schemaP1.elements.length).toBe(2);
+
+        // Has Buttons
+        const options = p2.defaultQuestion.options;
+        expect(schemaP2.elements.length).toBe(options.length + 1);
+    });
+    test("Can get ruleInput!", () => {
+        const p0 = builderSchema.addPage("info-page");
+        p0.prefix = "info_page_prefix_";
+        const p1 = builderSchema.addPage("question");
+        p1.prefix = "p1_prefix_";
+        const p2 = builderSchema.addPage("question");
+        p2.prefix = "p2_prefix_";
+        p1.defaultQuestion.addOption("Ja", 1, 0);
+        p1.defaultQuestion.addOption("Nei", 0, 0);
+        p2.defaultQuestion.addOption("Ja", 1, 0);
+        p2.defaultQuestion.addOption("Nei", 0);
+        const ruleInput = builderSchema.getRuleInput();
+        expect(ruleInput.questionVars.length).toBe(2);
+        expect(ruleInput.jumpToPageActions.length).toBe(3);
+        // TODO add TAGS!!
+        expect(ruleInput.excludeByTagActions.length).toBe(0);
+        expect(ruleInput.excludeByPageIdActions.length).toBe(3);
+        const allPrefixes = new Set(ruleInput.jumpToPageActions.map((a) => a.pageId));
+        expect(allPrefixes.has(p0.prefix)).toBe(true);
+        expect(allPrefixes.has(p1.prefix)).toBe(true);
+        expect(allPrefixes.has(p2.prefix)).toBe(true);
+        ruleInput.questionVars.forEach((v) => {
+            expect(allPrefixes.has(v.varId)).toBe(true);
+        });
+        ruleInput.jumpToPageActions.forEach((v) => {
+            expect(allPrefixes.has(v.pageId)).toBe(true);
+        });
+    });
+});