@examplary/qti 1.0.1 → 1.3.0

package/README.md

@@ -20,8 +20,10 @@ const item = new QtiItem({
   title: "Sample Question",
 });
 
-item.addResponseDeclaration({ identifier: "RESPONSE" });
-item.addCorrectResponse("RESPONSE", ["4"]);
+item.addResponseDeclaration({
+  identifier: "RESPONSE",
+  correctResponse: ["4"],
+});
 
 item.addItemBodyFromHtml("<p>What is 2 + 2?</p>");
 item.addInteraction(

package/dist/index.d.ts

@@ -2,6 +2,8 @@ export * from "./ims/ims-manifest";
 export * from "./ims/ims-package";
 export * from "./qti/qti-element";
 export * from "./qti/qti-test";
+export * from "./qti/qti-test-part";
+export * from "./qti/qti-assessment-section";
 export * from "./qti/qti-item";
 export * from "./qti/interactions";
 export * from "./qti/types";

package/dist/index.js

@@ -18,6 +18,8 @@ __exportStar(require("./ims/ims-manifest"), exports);
 __exportStar(require("./ims/ims-package"), exports);
 __exportStar(require("./qti/qti-element"), exports);
 __exportStar(require("./qti/qti-test"), exports);
+__exportStar(require("./qti/qti-test-part"), exports);
+__exportStar(require("./qti/qti-assessment-section"), exports);
 __exportStar(require("./qti/qti-item"), exports);
 __exportStar(require("./qti/interactions"), exports);
 __exportStar(require("./qti/types"), exports);

package/dist/qti/interactions/index.d.ts

@@ -13,6 +13,7 @@ import { InlineChoiceInteraction } from "./inline-choice-interaction";
 import { MatchInteraction } from "./match-interaction";
 import { MediaInteraction } from "./media-interaction";
 import { OrderInteraction } from "./order-interaction";
+import { PortableCustomInteraction } from "./portable-custom-interaction";
 import { PositionObjectInteraction } from "./position-object-interaction";
 import { SelectPointInteraction } from "./select-point-interaction";
 import { SliderInteraction } from "./slider-interaction";
@@ -34,6 +35,7 @@ export * from "./interaction";
 export * from "./match-interaction";
 export * from "./media-interaction";
 export * from "./order-interaction";
+export * from "./portable-custom-interaction";
 export * from "./position-object-interaction";
 export * from "./select-point-interaction";
 export * from "./slider-interaction";
@@ -55,6 +57,7 @@ export declare const qtiInteractionTypes: {
     MatchInteraction: typeof MatchInteraction;
     MediaInteraction: typeof MediaInteraction;
     OrderInteraction: typeof OrderInteraction;
+    PortableCustomInteraction: typeof PortableCustomInteraction;
     PositionObjectInteraction: typeof PositionObjectInteraction;
     SelectPointInteraction: typeof SelectPointInteraction;
     SliderInteraction: typeof SliderInteraction;

package/dist/qti/interactions/index.js

@@ -30,6 +30,7 @@ const inline_choice_interaction_1 = require("./inline-choice-interaction");
 const match_interaction_1 = require("./match-interaction");
 const media_interaction_1 = require("./media-interaction");
 const order_interaction_1 = require("./order-interaction");
+const portable_custom_interaction_1 = require("./portable-custom-interaction");
 const position_object_interaction_1 = require("./position-object-interaction");
 const select_point_interaction_1 = require("./select-point-interaction");
 const slider_interaction_1 = require("./slider-interaction");
@@ -51,6 +52,7 @@ __exportStar(require("./interaction"), exports);
 __exportStar(require("./match-interaction"), exports);
 __exportStar(require("./media-interaction"), exports);
 __exportStar(require("./order-interaction"), exports);
+__exportStar(require("./portable-custom-interaction"), exports);
 __exportStar(require("./position-object-interaction"), exports);
 __exportStar(require("./select-point-interaction"), exports);
 __exportStar(require("./slider-interaction"), exports);
@@ -72,6 +74,7 @@ exports.qtiInteractionTypes = {
     MatchInteraction: match_interaction_1.MatchInteraction,
     MediaInteraction: media_interaction_1.MediaInteraction,
     OrderInteraction: order_interaction_1.OrderInteraction,
+    PortableCustomInteraction: portable_custom_interaction_1.PortableCustomInteraction,
     PositionObjectInteraction: position_object_interaction_1.PositionObjectInteraction,
     SelectPointInteraction: select_point_interaction_1.SelectPointInteraction,
     SliderInteraction: slider_interaction_1.SliderInteraction,

package/dist/qti/interactions/portable-custom-interaction.d.ts

@@ -0,0 +1,35 @@
+import { QtiPromptInteraction, QtiPromptInteractionOptions } from "./interaction";
+export type PortableCustomInteractionOptions = QtiPromptInteractionOptions & {
+    module: string;
+    customInteractionTypeIdentifier: string;
+    dataExamplarySettings?: string;
+    class?: string;
+    modules?: {
+        id: string;
+        primaryPath: string;
+        fallbackPath?: string;
+    }[];
+    markup?: string;
+    templateVariables?: {
+        templateIdentifier: string;
+    }[];
+    contextVariables?: {
+        identifier: string;
+    }[];
+};
+/**
+ * A custom QTI portable custom interaction (PCI), allowing you to load arbitrary
+ * HTML and JavaScript for rendering the interaction.
+ *
+ * @see https://www.imsglobal.org/spec/qti/v3p0/impl#h.98xaka8g51za
+ *
+ * @example
+ * const interaction = new PortableCustomInteraction({
+ *   responseIdentifier: "RESPONSE",
+ *   module: "single-line-text",
+ *   customInteractionTypeIdentifier: "urn:fdc:examplary.ai:pci:single-line-text",
+ * });
+ */
+export declare class PortableCustomInteraction extends QtiPromptInteraction {
+    constructor(options: PortableCustomInteractionOptions);
+}

package/dist/qti/interactions/portable-custom-interaction.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PortableCustomInteraction = void 0;
+const xmlbuilder2_1 = require("xmlbuilder2");
+const interaction_1 = require("./interaction");
+const html_1 = require("../../utils/html");
+/**
+ * A custom QTI portable custom interaction (PCI), allowing you to load arbitrary
+ * HTML and JavaScript for rendering the interaction.
+ *
+ * @see https://www.imsglobal.org/spec/qti/v3p0/impl#h.98xaka8g51za
+ *
+ * @example
+ * const interaction = new PortableCustomInteraction({
+ *   responseIdentifier: "RESPONSE",
+ *   module: "single-line-text",
+ *   customInteractionTypeIdentifier: "urn:fdc:examplary.ai:pci:single-line-text",
+ * });
+ */
+class PortableCustomInteraction extends interaction_1.QtiPromptInteraction {
+    constructor(options) {
+        super(options);
+        this.item = (0, xmlbuilder2_1.fragment)().ele("qti-portable-custom-interaction", {
+            "response-identifier": options.responseIdentifier,
+            label: options.label,
+            module: options.module,
+            "custom-interaction-type-identifier": options.customInteractionTypeIdentifier,
+            "data-examplary-settings": options.dataExamplarySettings,
+            class: options.class,
+        });
+        // Modules
+        if (options.modules?.length) {
+            const modules = this.item.ele("qti-interaction-modules");
+            for (const module of options.modules) {
+                modules.ele("qti-interaction-module", {
+                    id: module.id,
+                    "primary-path": module.primaryPath,
+                    "fallback-path": module.fallbackPath,
+                });
+            }
+        }
+        // Markup
+        (0, html_1.appendHtmlFragment)(options.markup || "", this.item.ele("qti-interaction-markup"));
+        // Template variables
+        if (options.templateVariables?.length) {
+            for (const variable of options.templateVariables) {
+                this.item.ele("qti-template-variable", {
+                    "template-identifier": variable.templateIdentifier,
+                });
+            }
+        }
+        // Context variables
+        if (options.contextVariables?.length) {
+            for (const variable of options.contextVariables) {
+                this.item.ele("qti-context-variable", {
+                    identifier: variable.identifier,
+                });
+            }
+        }
+    }
+}
+exports.PortableCustomInteraction = PortableCustomInteraction;

package/dist/qti/qti-assessment-section.d.ts

@@ -0,0 +1,26 @@
+export type QtiAssessmentSectionOptions = {
+    identifier: string;
+    title: string;
+    visible: boolean;
+    class?: string;
+    fixed?: boolean;
+    required?: boolean;
+    keepTogether?: boolean;
+};
+export type QtiItemReference = {
+    itemIdentifier: string;
+    href: string;
+};
+export declare class QtiAssessmentSection {
+    identifier: string;
+    title: string;
+    visible: boolean;
+    class?: string;
+    fixed?: boolean;
+    required?: boolean;
+    keepTogether?: boolean;
+    protected itemReferences: QtiItemReference[];
+    constructor(options: QtiAssessmentSectionOptions);
+    addItemReference(itemIdentifier: string, href: string): void;
+    getItemReferences(): QtiItemReference[];
+}

package/dist/qti/qti-assessment-section.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QtiAssessmentSection = void 0;
+class QtiAssessmentSection {
+    identifier;
+    title;
+    visible;
+    class;
+    fixed;
+    required;
+    keepTogether;
+    itemReferences = [];
+    constructor(options) {
+        this.identifier = options.identifier;
+        this.title = options.title;
+        this.visible = options.visible;
+        this.class = options.class;
+        this.fixed = options.fixed ?? false;
+        this.required = options.required ?? false;
+        this.keepTogether = options.keepTogether ?? true;
+    }
+    addItemReference(itemIdentifier, href) {
+        this.itemReferences.push({ itemIdentifier, href });
+    }
+    getItemReferences() {
+        return this.itemReferences;
+    }
+}
+exports.QtiAssessmentSection = QtiAssessmentSection;

package/dist/qti/qti-element.d.ts

@@ -2,10 +2,18 @@ import { XMLBuilder } from "xmlbuilder2/lib/interfaces";
 export type NamespacedElementContent = string | {
     [key: string]: NamespacedElementContent;
 } | NamespacedElementContent[];
+export type NamespacedElement = {
+    namespace: string;
+    elementName: string;
+    content: NamespacedElementContent;
+    attributes?: Record<string, string | undefined>;
+};
 export declare abstract class QtiElement {
-    protected abstract getRootElement(): XMLBuilder;
-    buildXml(): string;
+    protected namespaces: Record<string, string>;
+    protected namespaceElements: NamespacedElement[];
+    abstract buildXml(): string;
     registerNamespace(prefix: string, uri: string): void;
-    addNamespacedElement(namespace: string, elementName: string, content: NamespacedElementContent, attributes?: Record<string, string>): void;
+    addNamespacedElement(namespace: string, elementName: string, content: NamespacedElementContent, attributes?: Record<string, string | undefined>): void;
+    protected appendNamespacesAndElements(element: XMLBuilder): void;
     private appendContent;
 }

package/dist/qti/qti-element.js

@@ -2,15 +2,27 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QtiElement = void 0;
 class QtiElement {
-    buildXml() {
-        return this.getRootElement().end({ prettyPrint: true });
-    }
+    namespaces = {};
+    namespaceElements = [];
     registerNamespace(prefix, uri) {
-        this.getRootElement().att(`xmlns:${prefix}`, uri);
+        this.namespaces[prefix] = uri;
     }
     addNamespacedElement(namespace, elementName, content, attributes) {
-        const element = this.getRootElement().ele(`${namespace}:${elementName}`, attributes);
-        this.appendContent(element, namespace, content);
+        this.namespaceElements.push({
+            namespace,
+            elementName,
+            content,
+            attributes,
+        });
+    }
+    appendNamespacesAndElements(element) {
+        for (const [prefix, uri] of Object.entries(this.namespaces)) {
+            element.att(`xmlns:${prefix}`, uri);
+        }
+        for (const nsElement of this.namespaceElements) {
+            const child = element.ele(`${nsElement.namespace}:${nsElement.elementName}`, nsElement.attributes);
+            this.appendContent(child, nsElement.namespace, nsElement.content);
+        }
     }
     appendContent(element, namespace, content) {
         if (typeof content === "string") {

package/dist/qti/qti-item.d.ts

@@ -1,4 +1,3 @@
-import { XMLBuilder } from "xmlbuilder2/lib/interfaces";
 import { QtiInteraction } from "./interactions/interaction";
 import { QtiElement } from "./qti-element";
 import { QtiTest } from "./qti-test";
@@ -25,6 +24,7 @@ export type ResponseDeclaration = {
     identifier: string;
     cardinality?: QtiCardinality;
     baseType?: QtiBaseType;
+    correctResponse?: string[];
 };
 export type OutcomeDeclaration = {
     identifier: string;
@@ -38,6 +38,11 @@ export declare enum ResponseProcessingTemplate {
     MapResponse = "https://purl.imsglobal.org/spec/qti/v3p0/rptemplates/map_response.xml",
     MapResponsePoint = "https://purl.imsglobal.org/spec/qti/v3p0/rptemplates/map_response_point.xml"
 }
+export type ItemBodyElement = {
+    html: string;
+} | {
+    interaction: QtiInteraction;
+};
 export declare class QtiItem extends QtiElement {
     identifier: string;
     adaptive?: boolean;
@@ -47,19 +52,17 @@ export declare class QtiItem extends QtiElement {
     label?: string;
     toolName?: string;
     toolVersion?: string;
-    private item;
-    private itemBody?;
-    private responseDeclarations;
+    protected responseDeclarations: Map<string, ResponseDeclaration>;
+    protected responseProcessing: ResponseProcessingTemplate | null;
+    protected outcomeDeclarations: Map<string, OutcomeDeclaration>;
+    protected itemBodyElements: ItemBodyElement[];
     constructor(options?: QtiItemOptions);
+    buildXml(): string;
     addToPackage(pkg: ImsPackage): Promise<void>;
     addToTest(test: QtiTest): void;
-    private getOrCreateItemBody;
     addItemBodyFromHtml(html: string): void;
     addInteraction(interaction: QtiInteraction): void;
-    addPciInteraction(interaction: PciInteraction, externalModules?: boolean): void;
     addResponseDeclaration(responseDeclaration?: ResponseDeclaration): void;
-    addCorrectResponse(identifier: string, values: string[]): void;
     addResponseProcessing(template: ResponseProcessingTemplate): void;
     addOutcomeDeclaration(outcomeDeclaration?: OutcomeDeclaration): void;
-    protected getRootElement(): XMLBuilder;
 }

package/dist/qti/qti-item.js

@@ -20,9 +20,10 @@ class QtiItem extends qti_element_1.QtiElement {
     label;
     toolName;
     toolVersion;
-    item;
-    itemBody;
     responseDeclarations = new Map();
+    responseProcessing = null;
+    outcomeDeclarations = new Map();
+    itemBodyElements = [];
     constructor(options) {
         super();
         this.identifier = options?.identifier || "item-" + Date.now();
@@ -31,7 +32,11 @@ class QtiItem extends qti_element_1.QtiElement {
         this.title = options?.title;
         this.language = options?.language;
         this.label = options?.label;
-        this.item = (0, index_js_1.create)({ version: "1.0", encoding: "UTF-8" }).ele("qti-assessment-item", {
+        this.toolName = options?.toolName;
+        this.toolVersion = options?.toolVersion;
+    }
+    buildXml() {
+        const item = (0, index_js_1.create)({ version: "1.0", encoding: "UTF-8" }).ele("qti-assessment-item", {
             xmlns: "http://www.imsglobal.org/xsd/imsqtiasi_v3p0",
             "xmlns:m": "http://www.w3.org/1998/Math/MathML",
             "xmlns:xsi": "http://www.w3.org/2001/XMLSchema-instance",
@@ -46,6 +51,54 @@ class QtiItem extends qti_element_1.QtiElement {
             toolVersion: this.toolVersion || "1.0.0",
             "xml:lang": this.language,
         });
+        // Extensions
+        this.appendNamespacesAndElements(item);
+        // Response declaration
+        // Note: some implementations expect the response to be defined before the body
+        for (const responseDeclaration of this.responseDeclarations.values()) {
+            const response = item.ele("qti-response-declaration", {
+                identifier: responseDeclaration.identifier,
+                cardinality: responseDeclaration.cardinality || "single",
+                "base-type": responseDeclaration.baseType || "string",
+            });
+            if (responseDeclaration.correctResponse?.length) {
+                const correctResponse = response.ele("qti-correct-response");
+                for (const value of responseDeclaration.correctResponse) {
+                    correctResponse.ele("qti-value").txt(value);
+                }
+            }
+        }
+        // Outcome declaration
+        for (const outcomeDeclaration of this.outcomeDeclarations.values()) {
+            const outcome = item.ele("qti-outcome-declaration", {
+                "base-type": outcomeDeclaration.baseType,
+                cardinality: outcomeDeclaration.cardinality,
+                identifier: outcomeDeclaration.identifier,
+            });
+            if (outcomeDeclaration.defaultValue !== undefined) {
+                outcome
+                    .ele("qti-default-value")
+                    .ele("qti-value")
+                    .txt(outcomeDeclaration.defaultValue.toString());
+            }
+        }
+        // Item body
+        const itemBody = item.ele("qti-item-body");
+        for (const element of this.itemBodyElements) {
+            if ("html" in element) {
+                (0, html_1.appendHtmlFragment)(element.html, itemBody);
+            }
+            if ("interaction" in element) {
+                itemBody.import(element.interaction.getXmlBuilder());
+            }
+        }
+        // Response processing
+        if (this.responseProcessing) {
+            item.ele("qti-response-processing", {
+                template: this.responseProcessing,
+            });
+        }
+        return item.end({ prettyPrint: true });
     }
     async addToPackage(pkg) {
         await pkg.addResource({
@@ -61,78 +114,26 @@ class QtiItem extends qti_element_1.QtiElement {
     addToTest(test) {
         test.addItemReference(this.identifier, `item-${this.identifier}.xml`);
     }
-    getOrCreateItemBody() {
-        if (!this.itemBody) {
-            this.itemBody = this.item.ele("qti-item-body");
-        }
-        return this.itemBody;
-    }
     addItemBodyFromHtml(html) {
-        const content = `${this.title ? `<h1>${this.title}</h1>` : ""}${html}`;
-        (0, html_1.appendHtmlFragment)(content, this.getOrCreateItemBody());
+        this.itemBodyElements.push({ html });
     }
     addInteraction(interaction) {
-        this.getOrCreateItemBody().import(interaction.getXmlBuilder());
-    }
-    addPciInteraction(interaction, externalModules = false) {
-        const pci = this.getOrCreateItemBody().ele("qti-portable-custom-interaction", {
-            "response-identifier": interaction.responseIdentifier,
-            module: interaction.module,
-            "custom-interaction-type-identifier": interaction.customInteractionTypeIdentifier,
-            "data-examplary-settings": interaction.dataExamplarySettings,
-            class: interaction.class,
-        });
-        if (externalModules) {
-            // Use external PCI runtime and HTTP hosted module
-            const modules = pci.ele("qti-interaction-modules");
-            modules.ele("qti-interaction-module", {
-                id: "examplaryPciRuntime",
-                "primary-path": "https://unpkg.com/@examplary/pci-runtime@latest/public/dist/runtime",
-            });
-            modules.ele("qti-interaction-module", {
-                id: "single-line-text",
-                "primary-path": `https://api.examplary.ai/question-types/${interaction.module}/export/qti3-pci`,
-            });
-        }
-        pci.ele("qti-interaction-markup"); // empty markup
+        this.itemBodyElements.push({ interaction });
     }
     addResponseDeclaration(responseDeclaration = {
         identifier: "RESPONSE",
         cardinality: "single",
         baseType: "string",
     }) {
-        // TODO: some implementations expect the response to be defined before the body, so we should enforce order
-        if (this.responseDeclarations.has(responseDeclaration.identifier)) {
-            throw new Error(`Response declaration with identifier ${responseDeclaration.identifier} already exists.`);
-        }
-        const element = this.item.ele("qti-response-declaration", {
-            identifier: responseDeclaration.identifier,
-            cardinality: responseDeclaration.cardinality || "single",
-            "base-type": responseDeclaration.baseType || "string",
-        });
-        this.responseDeclarations.set(responseDeclaration.identifier, {
-            element,
-            responseDeclaration,
-        });
-    }
-    addCorrectResponse(identifier, values) {
-        const responseDecl = this.responseDeclarations.get(identifier);
-        if (!responseDecl) {
-            throw new Error(`Response declaration with identifier ${identifier} does not exist.`);
-        }
-        if (values.length > 1 &&
-            responseDecl.responseDeclaration.cardinality === "single") {
-            throw new Error(`Cannot add multiple correct responses to a single cardinality response declaration (${identifier}).`);
-        }
-        const correctResponse = responseDecl.element.ele("qti-correct-response");
-        for (const value of values) {
-            correctResponse.ele("qti-value").txt(value);
+        if (responseDeclaration.correctResponse &&
+            responseDeclaration.correctResponse?.length > 1 &&
+            responseDeclaration.cardinality === "single") {
+            throw new Error(`Cannot add multiple correct responses to a single cardinality response declaration (${responseDeclaration.identifier}).`);
         }
+        this.responseDeclarations.set(responseDeclaration.identifier, responseDeclaration);
     }
     addResponseProcessing(template) {
-        this.item.ele("qti-response-processing", {
-            template,
-        });
+        this.responseProcessing = template;
     }
     addOutcomeDeclaration(outcomeDeclaration = {
         identifier: "SCORE",
@@ -140,20 +141,7 @@ class QtiItem extends qti_element_1.QtiElement {
         baseType: "float",
         defaultValue: 0,
     }) {
-        const outcome = this.item.ele("qti-outcome-declaration", {
-            "base-type": outcomeDeclaration.baseType,
-            cardinality: outcomeDeclaration.cardinality,
-            identifier: outcomeDeclaration.identifier,
-        });
-        if (outcomeDeclaration.defaultValue !== undefined) {
-            outcome
-                .ele("qti-default-value")
-                .ele("qti-value")
-                .txt(outcomeDeclaration.defaultValue.toString());
-        }
-    }
-    getRootElement() {
-        return this.item;
+        this.outcomeDeclarations.set(outcomeDeclaration.identifier, outcomeDeclaration);
     }
 }
 exports.QtiItem = QtiItem;

package/dist/qti/qti-test-part.d.ts

@@ -0,0 +1,19 @@
+import { QtiAssessmentSection } from "./qti-assessment-section";
+export type QtiTestPartOptions = {
+    identifier: string;
+    title?: string;
+    class?: string;
+    navigationMode?: "linear" | "nonlinear";
+    submissionMode?: "individual" | "simultaneous";
+};
+export declare class QtiTestPart {
+    identifier: string;
+    title?: string;
+    class?: string;
+    navigationMode: "linear" | "nonlinear";
+    submissionMode: "individual" | "simultaneous";
+    protected sections: QtiAssessmentSection[];
+    constructor(options: QtiTestPartOptions);
+    addSection(section: QtiAssessmentSection): void;
+    getSections(): QtiAssessmentSection[];
+}

package/dist/qti/qti-test-part.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QtiTestPart = void 0;
+class QtiTestPart {
+    identifier;
+    title;
+    class;
+    navigationMode;
+    submissionMode;
+    sections = [];
+    constructor(options) {
+        this.identifier = options.identifier;
+        this.title = options.title;
+        this.class = options.class;
+        this.navigationMode = options.navigationMode ?? "linear";
+        this.submissionMode = options.submissionMode ?? "simultaneous";
+    }
+    addSection(section) {
+        this.sections.push(section);
+    }
+    getSections() {
+        return this.sections;
+    }
+}
+exports.QtiTestPart = QtiTestPart;

package/dist/qti/qti-test.d.ts

@@ -1,5 +1,6 @@
-import { XMLBuilder } from "xmlbuilder2/lib/interfaces";
 import { QtiElement } from "./qti-element";
+import { OutcomeDeclaration } from "./qti-item";
+import { QtiTestPart } from "./qti-test-part";
 import { ImsPackage } from "../ims/ims-package";
 type QtiTestOptions = {
     identifier?: string;
@@ -7,6 +8,7 @@ type QtiTestOptions = {
     language?: string;
     toolName?: string;
     toolVersion?: string;
+    addDefaultOutcomes?: boolean;
 };
 export declare class QtiTest extends QtiElement {
     identifier: string;
@@ -14,14 +16,16 @@ export declare class QtiTest extends QtiElement {
     language?: string;
     toolName?: string;
     toolVersion?: string;
-    private test;
-    private part;
-    private section;
-    private outcomeProcessing;
+    protected outcomeDeclarations: Map<string, OutcomeDeclaration>;
+    protected testParts: QtiTestPart[];
     constructor(options?: QtiTestOptions);
+    buildXml(): string;
     addToPackage(pkg: ImsPackage): Promise<void>;
+    addTestPart(testPart: QtiTestPart): void;
+    /**
+     * Convenience method to add an item reference to the first section of the first test part.
+     */
     addItemReference(itemIdentifier: string, href: string): void;
-    private addOutcomeDeclaration;
-    protected getRootElement(): XMLBuilder;
+    addOutcomeDeclaration(outcomeDeclaration: OutcomeDeclaration): void;
 }
 export {};

package/dist/qti/qti-test.js

@@ -2,7 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QtiTest = void 0;
 const index_js_1 = require("xmlbuilder2/lib/index.js");
+const qti_assessment_section_1 = require("./qti-assessment-section");
 const qti_element_1 = require("./qti-element");
+const qti_test_part_1 = require("./qti-test-part");
 const ims_manifest_1 = require("../ims/ims-manifest");
 class QtiTest extends qti_element_1.QtiElement {
     identifier;
@@ -10,10 +12,8 @@ class QtiTest extends qti_element_1.QtiElement {
     language;
     toolName;
     toolVersion;
-    test;
-    part; // currently, we only support one part per test
-    section; // currently, we only support one section per part
-    outcomeProcessing;
+    outcomeDeclarations = new Map();
+    testParts = [];
     constructor(options) {
         super();
         this.identifier = options?.identifier || "test-" + Date.now();
@@ -21,7 +21,23 @@ class QtiTest extends qti_element_1.QtiElement {
         this.language = options?.language;
         this.toolName = options?.toolName || "Examplary QTI Module";
         this.toolVersion = options?.toolVersion || "1.0.0";
-        this.test = (0, index_js_1.create)({ version: "1.0", encoding: "UTF-8" }).ele("qti-assessment-test", {
+        if (options?.addDefaultOutcomes !== false) {
+            this.addOutcomeDeclaration({
+                identifier: "SCORE",
+                cardinality: "single",
+                baseType: "float",
+                defaultValue: 0,
+            });
+            this.addOutcomeDeclaration({
+                identifier: "MAX_SCORE",
+                cardinality: "single",
+                baseType: "float",
+                defaultValue: 0,
+            });
+        }
+    }
+    buildXml() {
+        const test = (0, index_js_1.create)({ version: "1.0", encoding: "UTF-8" }).ele("qti-assessment-test", {
             xmlns: "http://www.imsglobal.org/xsd/imsqtiasi_v3p0",
             "xmlns:m": "http://www.w3.org/1998/Math/MathML",
             "xmlns:xsi": "http://www.w3.org/2001/XMLSchema-instance",
@@ -33,19 +49,64 @@ class QtiTest extends qti_element_1.QtiElement {
             toolVersion: this.toolVersion,
             "xml:lang": this.language,
         });
-        this.part = this.test.ele("qti-test-part", {
-            identifier: "TEST-PART",
-            "navigation-mode": "linear",
-            "submission-mode": "simultaneous",
-        });
-        this.section = this.part.ele("qti-assessment-section", {
-            identifier: "TEST-SECTION",
-            title: "Section 1",
-            visible: "true",
-        });
-        this.outcomeProcessing = this.test.ele("qti-outcome-processing");
-        this.addOutcomeDeclaration("SCORE");
-        this.addOutcomeDeclaration("MAX_SCORE");
+        // Extensions
+        this.appendNamespacesAndElements(test);
+        // Outcome declarations
+        for (const outcomeDeclaration of this.outcomeDeclarations.values()) {
+            const outcome = test.ele("qti-outcome-declaration", {
+                "base-type": outcomeDeclaration.baseType,
+                cardinality: outcomeDeclaration.cardinality,
+                identifier: outcomeDeclaration.identifier,
+            });
+            if (outcomeDeclaration.defaultValue !== undefined) {
+                outcome
+                    .ele("qti-default-value")
+                    .ele("qti-value")
+                    .txt(outcomeDeclaration.defaultValue.toString());
+            }
+        }
+        // Parts
+        for (const testPart of this.testParts) {
+            const part = test.ele("qti-test-part", {
+                identifier: testPart.identifier,
+                title: testPart.title,
+                "navigation-mode": testPart.navigationMode,
+                "submission-mode": testPart.submissionMode,
+                class: testPart.class,
+            });
+            // Sections
+            for (const section of testPart.getSections()) {
+                const sec = part.ele("qti-assessment-section", {
+                    identifier: section.identifier,
+                    title: section.title,
+                    class: section.class,
+                    visible: section.visible ? "true" : "false",
+                    fixed: section.fixed ? "true" : "false",
+                    required: section.required ? "true" : "false",
+                    keepTogether: section.keepTogether ? "true" : "false",
+                });
+                // Item references
+                for (const itemRef of section.getItemReferences()) {
+                    sec.ele("qti-assessment-item-ref", {
+                        identifier: itemRef.itemIdentifier,
+                        href: itemRef.href,
+                    });
+                }
+            }
+        }
+        // Outcome processing
+        const outcomeProcessing = test.ele("qti-outcome-processing");
+        for (const outcomeDeclaration of this.outcomeDeclarations.values()) {
+            outcomeProcessing
+                .ele("qti-set-outcome-value", {
+                identifier: outcomeDeclaration.identifier,
+            })
+                .ele("qti-sum")
+                .ele("qti-test-variables", {
+                "variable-identifier": outcomeDeclaration.identifier,
+            });
+        }
+        return test.end({ prettyPrint: true });
     }
     async addToPackage(pkg) {
         await pkg.addResource({
@@ -58,33 +119,27 @@ class QtiTest extends qti_element_1.QtiElement {
             },
         ]);
     }
-    addItemReference(itemIdentifier, href) {
-        this.section.ele("qti-assessment-item-ref", {
-            identifier: itemIdentifier,
-            href: href,
-        });
+    addTestPart(testPart) {
+        this.testParts.push(testPart);
     }
-    addOutcomeDeclaration(identifier) {
-        this.test
-            .ele("qti-outcome-declaration", {
-            identifier,
-            cardinality: "single",
-            baseType: "float",
-        })
-            .ele("qti-default-value")
-            .ele("qti-value")
-            .txt("0");
-        this.outcomeProcessing
-            .ele("qti-set-outcome-value", {
-            identifier,
-        })
-            .ele("qti-sum")
-            .ele("qti-test-variables", {
-            "variable-identifier": identifier,
-        });
+    /**
+     * Convenience method to add an item reference to the first section of the first test part.
+     */
+    addItemReference(itemIdentifier, href) {
+        if (!this.testParts.length) {
+            this.addTestPart(new qti_test_part_1.QtiTestPart({ identifier: "PART-1" }));
+        }
+        if (!this.testParts[0].getSections().length) {
+            this.testParts[0].addSection(new qti_assessment_section_1.QtiAssessmentSection({
+                identifier: "SECTION-1",
+                title: "Section 1",
+                visible: true,
+            }));
+        }
+        this.testParts[0].getSections()[0].addItemReference(itemIdentifier, href);
     }
-    getRootElement() {
-        return this.test;
+    addOutcomeDeclaration(outcomeDeclaration) {
+        this.outcomeDeclarations.set(outcomeDeclaration.identifier, outcomeDeclaration);
     }
 }
 exports.QtiTest = QtiTest;

package/package.json

@@ -2,7 +2,7 @@
   "name": "@examplary/qti",
   "description": "Utilities to generate QTI 3.0 assessment packages.",
   "packageManager": "yarn@4.5.3",
-  "version": "1.0.1",
+  "version": "1.3.0",
   "main": "dist/index.js",
   "types": "./dist/index.d.ts",
   "files": [
@@ -10,7 +10,7 @@
   ],
   "scripts": {
     "start": "yarn build --watch",
-    "test": "vitest run",
+    "test": "vitest",
     "release": "semantic-release -e semantic-release-monorepo",
     "build": "tsc"
   },