@citolab/qti-components 7.1.6 → 7.2.0

package/dist/chunks/chunk-7T5WVG7T.js

@@ -0,0 +1,853 @@
+import {
+  INITIAL_SESSION_CONTEXT,
+  sessionContext
+} from "./chunk-UZ4QB5IO.js";
+import {
+  INITIAL_TEST_CONTEXT,
+  testContext
+} from "./chunk-CJADUWEC.js";
+import {
+  QtiModalFeedback
+} from "./chunk-VAYGVW5R.js";
+import {
+  qtiTransformItem
+} from "./chunk-XKQP4R6O.js";
+import {
+  __decorateClass
+} from "./chunk-H2JE6IVU.js";
+
+// src/lib/qti-test/core/qti-test.ts
+import { html } from "lit";
+import { customElement } from "lit/decorators.js";
+
+// src/lib/qti-test/core/mixins/test-navigation.mixin.ts
+import { property } from "lit/decorators.js";
+var NavigationErrorType = /* @__PURE__ */ ((NavigationErrorType2) => {
+  NavigationErrorType2["ITEM_NOT_FOUND"] = "item-not-found";
+  NavigationErrorType2["SECTION_NOT_FOUND"] = "section-not-found";
+  NavigationErrorType2["LOAD_ERROR"] = "load-error";
+  NavigationErrorType2["NETWORK_ERROR"] = "network-error";
+  NavigationErrorType2["TIMEOUT_ERROR"] = "timeout-error";
+  return NavigationErrorType2;
+})(NavigationErrorType || {});
+var TestNavigationMixin = (superClass) => {
+  class TestNavigationClass extends superClass {
+    constructor(...args) {
+      super(...args);
+      this.navigate = null;
+      this.cacheTransform = false;
+      this.requestTimeout = 3e4;
+      this.showLoadingIndicators = true;
+      this._activeRequests = [];
+      this._navigationInProgress = false;
+      this._lastError = null;
+      this._lastNavigationRequestId = null;
+      this._targetNavigation = null;
+      this.addEventListener(
+        "qti-request-navigation",
+        async ({ detail }) => {
+          if (!detail?.id) return;
+          const navigationRequestId = `nav_${Date.now()}_${Math.random()}`;
+          this._lastNavigationRequestId = navigationRequestId;
+          try {
+            this._navigationInProgress = true;
+            this._lastError = null;
+            this._dispatchStatusEvent({ loading: true, type: detail.type, id: detail.id });
+            this._cancelActiveRequests();
+            this._targetNavigation = { type: detail.type, id: detail.id };
+            if (detail.type === "item") {
+              await this._navigateToItem(detail.id);
+            } else if (detail.type === "section") {
+              await this._navigateToSection(detail.id);
+            }
+            if (this._lastNavigationRequestId !== navigationRequestId) {
+              console.log("Navigation was superseded by a newer request");
+              return;
+            }
+          } catch (error) {
+            if (this._lastNavigationRequestId === navigationRequestId) {
+              const navError = this._normalizeError(error, detail.type, detail.id);
+              this._lastError = navError;
+              this._dispatchErrorEvent(navError);
+              console.error(`Navigation error (${navError.type}):`, navError.message, navError.details);
+            }
+          } finally {
+            if (this._lastNavigationRequestId === navigationRequestId) {
+              this._navigationInProgress = false;
+              this._dispatchStatusEvent({ loading: false, type: detail.type, id: detail.id });
+            }
+          }
+        }
+      );
+      this.addEventListener("qti-assessment-test-connected", (e) => {
+        this._testElement = e.detail;
+        this._initializeNavigation();
+      });
+    }
+    /**
+     * Initialize navigation when test is first connected
+     */
+    _initializeNavigation() {
+      let id;
+      if (this.navigate === "section") {
+        id = this._testElement.querySelector("qti-assessment-section")?.identifier;
+      }
+      if (this.navigate === "item") {
+        id = this.sessionContext.navItemId ?? this._testElement.querySelector("qti-assessment-item-ref")?.identifier;
+      }
+      if (id) {
+        this.dispatchEvent(
+          new CustomEvent("qti-request-navigation", {
+            detail: { type: this.navigate === "section" ? "section" : "item", id },
+            bubbles: true,
+            composed: true
+          })
+        );
+      }
+    }
+    /**
+     * Navigates to a specific item
+     */
+    async _navigateToItem(itemId) {
+      const itemRefEl = this._testElement?.querySelector(
+        `qti-assessment-item-ref[identifier="${itemId}"]`
+      );
+      if (!itemRefEl) {
+        throw {
+          type: "item-not-found" /* ITEM_NOT_FOUND */,
+          message: `Item with identifier "${itemId}" not found.`,
+          itemId
+        };
+      }
+      const navPartId = itemRefEl.closest("qti-test-part")?.identifier;
+      const navSectionId = itemRefEl.closest("qti-assessment-section")?.identifier;
+      this.sessionContext = {
+        ...this.sessionContext,
+        navPartId,
+        navSectionId,
+        navItemId: itemId,
+        navItemLoading: true
+      };
+      console.log("Navigating to item:", itemId);
+      try {
+        await this._loadItems([itemId]);
+      } finally {
+        this.sessionContext = {
+          ...this.sessionContext,
+          navItemLoading: false
+        };
+      }
+    }
+    /**
+     * Navigates to a specific section
+     */
+    async _navigateToSection(sectionId) {
+      const sectionRefEl = this._testElement?.querySelector(
+        `qti-assessment-section[identifier="${sectionId}"]`
+      );
+      if (!sectionRefEl) {
+        throw {
+          type: "section-not-found" /* SECTION_NOT_FOUND */,
+          message: `Section with identifier "${sectionId}" not found.`,
+          sectionId
+        };
+      }
+      const navPartId = sectionRefEl.closest("qti-test-part")?.identifier;
+      this.sessionContext = {
+        ...this.sessionContext,
+        navPartId,
+        navSectionId: sectionId,
+        navItemId: null,
+        navItemLoading: true
+      };
+      try {
+        const itemIds = this._getSectionItemIds(sectionId);
+        await this._loadItems(itemIds);
+      } finally {
+        this.sessionContext = {
+          ...this.sessionContext,
+          navItemLoading: false
+        };
+      }
+    }
+    /**
+     * Normalize different error types into a consistent NavigationError format
+     */
+    _normalizeError(error, navigationType, id) {
+      if (error && error.type && Object.values(NavigationErrorType).includes(error.type)) {
+        return error;
+      }
+      if (error instanceof DOMException && error.name === "AbortError") {
+        return {
+          type: "network-error" /* NETWORK_ERROR */,
+          message: "Navigation was cancelled because a new navigation was requested.",
+          details: error
+        };
+      }
+      if (error.name === "TimeoutError" || error.message && error.message.includes("timeout")) {
+        return {
+          type: "timeout-error" /* TIMEOUT_ERROR */,
+          message: "Request timed out. Please check your network connection.",
+          details: error
+        };
+      }
+      if (error instanceof TypeError && error.message.includes("network")) {
+        return {
+          type: "network-error" /* NETWORK_ERROR */,
+          message: "A network error occurred. Please check your connection.",
+          details: error
+        };
+      }
+      return {
+        type: "load-error" /* LOAD_ERROR */,
+        message: `Failed to load ${navigationType}: ${id}`,
+        details: error,
+        itemId: navigationType === "item" ? id : void 0,
+        sectionId: navigationType === "section" ? id : void 0
+      };
+    }
+    /**
+     * Dispatch error event to notify the UI
+     */
+    _dispatchErrorEvent(error) {
+      this.dispatchEvent(
+        new CustomEvent("qti-navigation-error", {
+          detail: error,
+          bubbles: true,
+          composed: true
+        })
+      );
+    }
+    /**
+     * Dispatch status event to indicate loading state
+     */
+    _dispatchStatusEvent(status) {
+      if (this.showLoadingIndicators) {
+        this.dispatchEvent(
+          new CustomEvent("qti-navigation-status", {
+            detail: status,
+            bubbles: true,
+            composed: true
+          })
+        );
+      }
+    }
+    /**
+     * Cancels all active HTTP requests
+     */
+    _cancelActiveRequests() {
+      if (this._activeRequests.length > 0) {
+        console.info(`Cancelling ${this._activeRequests.length} pending requests`);
+        this._activeRequests.forEach((request) => {
+          if (request && request.readyState !== 4) {
+            request.abort();
+          }
+        });
+        this._activeRequests = [];
+      }
+    }
+    /**
+     * Load items with improved error handling and timeout
+     */
+    async _loadItems(itemIds) {
+      if (!this._testElement || itemIds.length === 0) return;
+      const itemRefEls = itemIds.map(
+        (id) => this._testElement.querySelector(`qti-assessment-item-ref[identifier="${id}"]`)
+      );
+      const missingItems = itemRefEls.reduce((missing, el, index) => {
+        if (!el) missing.push(itemIds[index]);
+        return missing;
+      }, []);
+      if (missingItems.length > 0) {
+        const error = {
+          type: "item-not-found" /* ITEM_NOT_FOUND */,
+          message: `One or more items not found: ${missingItems.join(", ")}`,
+          details: { missingItems }
+        };
+        throw error;
+      }
+      this._clearLoadedItems();
+      const itemLoadPromises = itemRefEls.map(async (itemRef) => {
+        if (!itemRef) return null;
+        const timeoutPromise = new Promise((_, reject) => {
+          setTimeout(() => {
+            reject({
+              name: "TimeoutError",
+              message: `Request for item ${itemRef.identifier} timed out after ${this.requestTimeout}ms`
+            });
+          }, this.requestTimeout);
+        });
+        try {
+          const { promise, request } = qtiTransformItem(this.cacheTransform).load(itemRef.href);
+          if (request instanceof XMLHttpRequest) {
+            this._activeRequests.push(request);
+          }
+          const apiResult = await Promise.race([promise, timeoutPromise]);
+          return {
+            itemRef,
+            doc: apiResult.htmlDoc(),
+            request
+          };
+        } catch (error) {
+          if (error instanceof DOMException && error.name === "AbortError" || error && error.name === "TimeoutError") {
+            console.log(
+              `Request for item ${itemRef.identifier} was ${error.name === "TimeoutError" ? "timed out" : "aborted"}`
+            );
+            return null;
+          }
+          error.itemId = itemRef.identifier;
+          throw error;
+        }
+      });
+      try {
+        const results = await Promise.all(itemLoadPromises);
+        const validResults = results.filter((result) => result !== null);
+        validResults.forEach(({ itemRef, doc }) => {
+          if (itemRef && doc) itemRef.xmlDoc = doc;
+        });
+        this._activeRequests = [];
+        requestAnimationFrame(() => {
+          this.dispatchEvent(
+            new CustomEvent("qti-test-loaded", {
+              detail: validResults.map(({ itemRef }) => ({
+                identifier: itemRef?.identifier,
+                element: itemRef
+              })),
+              bubbles: true,
+              composed: true
+            })
+          );
+        });
+        if (validResults.length === 0 && itemIds.length > 0) {
+          throw {
+            type: "load-error" /* LOAD_ERROR */,
+            message: "All item requests failed to load",
+            details: { itemIds }
+          };
+        }
+        return validResults;
+      } catch (error) {
+        console.error("Error loading items:", error);
+        throw error;
+      }
+    }
+    /**
+     * Gets all item IDs in a section
+     */
+    _getSectionItemIds(navSectionId) {
+      const sectionRefEl = this._testElement?.querySelector(
+        `qti-assessment-section[identifier="${navSectionId}"]`
+      );
+      if (!sectionRefEl) {
+        throw {
+          type: "section-not-found" /* SECTION_NOT_FOUND */,
+          message: `Section with identifier "${navSectionId}" not found.`,
+          sectionId: navSectionId
+        };
+      }
+      return Array.from(
+        this._testElement.querySelectorAll(
+          `qti-assessment-section[identifier="${navSectionId}"] > qti-assessment-item-ref`
+        )
+      ).map((itemRef) => itemRef.identifier);
+    }
+    /**
+     * Clears all loaded items
+     */
+    _clearLoadedItems() {
+      const itemRefEls = this._testElement?.querySelectorAll(
+        `qti-assessment-test qti-assessment-item-ref`
+      );
+      Array.from(itemRefEls || []).forEach((itemElement) => {
+        itemElement.xmlDoc = null;
+      });
+    }
+    /**
+     * Retry the last failed navigation
+     */
+    retryNavigation() {
+      if (this._lastError) {
+        const type = this._lastError.itemId ? "item" : "section";
+        const id = this._lastError.itemId || this._lastError.sectionId;
+        if (id) {
+          this.dispatchEvent(
+            new CustomEvent("qti-request-navigation", {
+              detail: { type, id },
+              bubbles: true,
+              composed: true
+            })
+          );
+        }
+      } else if (this._targetNavigation) {
+        this.dispatchEvent(
+          new CustomEvent("qti-request-navigation", {
+            detail: this._targetNavigation,
+            bubbles: true,
+            composed: true
+          })
+        );
+      }
+    }
+  }
+  __decorateClass([
+    property({ type: String })
+  ], TestNavigationClass.prototype, "navigate", 2);
+  __decorateClass([
+    property({ type: Boolean, attribute: "cache-transform" })
+  ], TestNavigationClass.prototype, "cacheTransform", 2);
+  __decorateClass([
+    property({ type: Number })
+  ], TestNavigationClass.prototype, "requestTimeout", 2);
+  __decorateClass([
+    property({ type: Boolean })
+  ], TestNavigationClass.prototype, "showLoadingIndicators", 2);
+  return TestNavigationClass;
+};
+
+// src/lib/qti-test/core/mixins/test-view.mixin.ts
+var TestViewMixin = (superClass) => {
+  class TestViewClass extends superClass {
+    constructor(...args) {
+      super(...args);
+      this.sessionContext = { ...this.sessionContext, view: "candidate" };
+      this.addEventListener("on-test-switch-view", (e) => {
+        this.sessionContext = { ...this.sessionContext, view: e.detail };
+        this._updateElementView();
+      });
+      this.addEventListener("qti-assessment-test-connected", () => {
+        this._updateElementView();
+      });
+      this.addEventListener("qti-assessment-item-connected", (e) => {
+        this._updateElementView();
+        this._setCorrectResponseVisibility(e.detail);
+      });
+    }
+    willUpdate(changedProperties) {
+      super.willUpdate(changedProperties);
+      if (changedProperties.has("sessionContext")) {
+        this._updateElementView();
+      }
+    }
+    // Method to handle view updates for elements based on the current context view
+    _updateElementView() {
+      if (this._testElement) {
+        const viewElements = Array.from(this._testElement.querySelectorAll("[view]"));
+        viewElements.forEach((element) => {
+          element.classList.toggle("show", element.getAttribute("view") === this.sessionContext.view);
+        });
+        const assessmentItem = this._testElement.querySelector(
+          `qti-assessment-item[identifier="${this.sessionContext.navItemId}"]`
+        );
+        if (assessmentItem) {
+          assessmentItem.showCorrectResponse(this.sessionContext.view === "scorer");
+        }
+      }
+    }
+    // Event handler for connected QTI assessment items
+    _setCorrectResponseVisibility(assessmentItem) {
+      assessmentItem.showCorrectResponse(this.sessionContext.view === "scorer");
+    }
+  }
+  return TestViewClass;
+};
+
+// src/lib/qti-test/core/test-base.ts
+import { provide } from "@lit/context";
+import { LitElement } from "lit";
+import { property as property2 } from "lit/decorators.js";
+var TestBase = class extends LitElement {
+  constructor() {
+    super();
+    this.testContext = INITIAL_TEST_CONTEXT;
+    this.sessionContext = INITIAL_SESSION_CONTEXT;
+    /**
+     * Updates the variables of an assessment item in the test context.
+     * - Matches the assessment item with the corresponding test context item.
+     * - If the item is not found, logs a warning.
+     * - Updates variables in the test context if exactly one variable exists.
+     * - Otherwise, syncs the assessment item's variables with the test context.
+     *
+     * @param assessmentItem - The assessment item to update.
+     */
+    this._updateItemInTestContext = (assessmentItem) => {
+      const context = assessmentItem._context;
+      const identifier = context.identifier;
+      const fullVariables = context.variables;
+      const itemContext = this.testContext.items.find((i) => i?.identifier === identifier);
+      if (!itemContext) {
+        console.warn(`Item IDs between assessment.xml and item.xml should match: ${identifier} is not found!`);
+        return;
+      }
+      if (itemContext.variables?.length === 1) {
+        this._updateItemVariablesInTestContext(identifier, fullVariables);
+      } else {
+        assessmentItem.variables = [...itemContext.variables || []];
+      }
+    };
+    this.addEventListener("qti-assessment-test-connected", (e) => {
+      this.testContext = INITIAL_TEST_CONTEXT;
+      this.sessionContext = INITIAL_SESSION_CONTEXT;
+      if (this.testContext && this.testContext.items.length > 0) return;
+      this._testElement = e.detail;
+      const items = Array.from(this._testElement.querySelectorAll("qti-assessment-item-ref")).map((itemRef) => {
+        return {
+          href: itemRef.href,
+          identifier: itemRef.identifier,
+          category: itemRef.category,
+          variables: [
+            {
+              identifier: "completionStatus",
+              value: "not_attempted",
+              type: "outcome"
+            }
+          ]
+        };
+      });
+      this.testContext = { ...this.testContext, items };
+    });
+    this.addEventListener("qti-assessment-item-connected", (e) => {
+      const assessmentItem = e.detail;
+      const assessmentRefId = assessmentItem.closest("qti-assessment-item-ref")?.identifier;
+      if (assessmentRefId) {
+        assessmentItem.assessmentItemRefId = assessmentRefId;
+      }
+      this._updateItemInTestContext(e.detail);
+    });
+    this.addEventListener("qti-item-context-updated", (e) => {
+      this._updateItemVariablesInTestContext(e.detail.itemContext.identifier, e.detail.itemContext.variables);
+    });
+  }
+  _updateItemVariablesInTestContext(identifier, variables) {
+    this.testContext = {
+      ...this.testContext,
+      // Spread existing test context properties
+      items: this.testContext.items.map((itemContext) => {
+        if (itemContext.identifier !== identifier) {
+          return itemContext;
+        }
+        return {
+          ...itemContext,
+          // Keep other properties of the item context
+          variables: variables.map((variable) => {
+            const matchingVariable = itemContext.variables.find((v) => v.identifier === variable.identifier);
+            return matchingVariable ? { ...matchingVariable, ...variable } : variable;
+          })
+        };
+      })
+    };
+    this.dispatchEvent(
+      new CustomEvent("qti-test-context-updated", { detail: this.testContext, bubbles: false, composed: false })
+    );
+  }
+};
+__decorateClass([
+  property2({ attribute: false, type: Object }),
+  provide({ context: testContext })
+], TestBase.prototype, "testContext", 2);
+__decorateClass([
+  property2({ attribute: false, type: Object }),
+  provide({ context: sessionContext })
+], TestBase.prototype, "sessionContext", 2);
+
+// src/lib/qti-test/core/mixins/test-processing.mixin.ts
+var TestProcessingMixin = (superClass) => {
+  class TestProcessingElement extends superClass {
+    constructor(...args) {
+      super(...args);
+      this.addEventListener("qti-register-variable", (e) => {
+        this.testContext = {
+          ...this.testContext,
+          testOutcomeVariables: [...this.testContext.testOutcomeVariables || [], e.detail.variable]
+        };
+        e.stopPropagation();
+      });
+      this.addEventListener(
+        "qti-set-outcome-value",
+        (e) => {
+          const { outcomeIdentifier, value } = e.detail;
+          this.updateOutcomeVariable(outcomeIdentifier, value);
+          e.stopPropagation();
+        }
+      );
+    }
+    outcomeProcessing() {
+      const outcomeProcessor = this.querySelector("qti-outcome-processing");
+      if (!outcomeProcessor) return false;
+      outcomeProcessor?.process();
+      return true;
+    }
+    /* --------------------------- ENABLED WHEN UNIT TESTING OUTCOME PROCESSING ------------------------------------ */
+    updateOutcomeVariable(identifier, value) {
+      const outcomeVariable = this.getOutcome(identifier);
+      if (!outcomeVariable) {
+        console.warn(`Can not set qti-outcome-identifier: ${identifier}, it is not available`);
+        return;
+      }
+      this.testContext = {
+        ...this.testContext,
+        testOutcomeVariables: this.testContext.testOutcomeVariables?.map((v) => {
+          if (v.identifier !== identifier) {
+            return v;
+          }
+          return {
+            ...v,
+            value: outcomeVariable.cardinality === "single" ? value : [...v.value, value]
+          };
+        })
+      };
+    }
+    getOutcome(identifier) {
+      return this.getVariable(identifier);
+    }
+    getVariable(identifier) {
+      return this.testContext.testOutcomeVariables?.find((v) => v.identifier === identifier) || null;
+    }
+    /* --------------------------- ENABLED WHEN UNIT TESTING OUTCOME PROCESSING ------------------------------------ */
+  }
+  return TestProcessingElement;
+};
+
+// src/lib/qti-test/core/qti-test.ts
+var QtiTest = class extends TestNavigationMixin(TestViewMixin(TestProcessingMixin(TestBase))) {
+  // export class QtiTest extends TestLoaderMixin(TestNavigationMixin(TestViewMixin(TestBase))) {
+  /**
+   * Renders the component's template.
+   * Provides a default `<slot>` for content projection.
+   */
+  async connectedCallback() {
+    super.connectedCallback();
+    await this.updateComplete;
+    this.dispatchEvent(new CustomEvent("qti-test-connected", { detail: this }));
+  }
+  render() {
+    return html`<slot></slot>`;
+  }
+};
+QtiTest = __decorateClass([
+  customElement("qti-test")
+], QtiTest);
+
+// src/lib/qti-test/core/qti-assessment-test/qti-assessment-item-ref.ts
+import { LitElement as LitElement2 } from "lit";
+import { property as property3 } from "lit/decorators.js";
+import { prepareTemplate } from "stampino";
+var stringToBooleanConverter = {
+  fromAttribute(value) {
+    return value === "true";
+  },
+  toAttribute(value) {
+    return value ? "true" : "false";
+  }
+};
+var QtiAssessmentItemRef = class extends LitElement2 {
+  constructor() {
+    super(...arguments);
+    // @consume({ context: computedContext, subscribe: true })
+    // private computedContext: ComputedContext;
+    this.weigths = /* @__PURE__ */ new Map();
+  }
+  // the XMLDocument
+  createRenderRoot() {
+    return this;
+  }
+  get assessmentItem() {
+    return this.renderRoot?.querySelector("qti-assessment-item");
+  }
+  async connectedCallback() {
+    super.connectedCallback();
+    const templateElement = this.getRootNode().host.closest("qti-test").querySelector("template[item-ref]");
+    if (templateElement) this.myTemplate = prepareTemplate(templateElement);
+    await this.updateComplete;
+    this.dispatchEvent(
+      new CustomEvent("qti-assessment-item-ref-connected", {
+        bubbles: true,
+        composed: true,
+        detail: { identifier: this.identifier, href: this.href, category: this.category }
+      })
+    );
+  }
+  render() {
+    return this.myTemplate ? this.myTemplate({ xmlDoc: this.xmlDoc }) : this.xmlDoc;
+  }
+};
+__decorateClass([
+  property3({ type: String })
+], QtiAssessmentItemRef.prototype, "category", 2);
+__decorateClass([
+  property3({ type: String })
+], QtiAssessmentItemRef.prototype, "identifier", 2);
+__decorateClass([
+  property3({ type: Boolean, converter: stringToBooleanConverter })
+], QtiAssessmentItemRef.prototype, "required", 2);
+__decorateClass([
+  property3({ type: Boolean, converter: stringToBooleanConverter })
+], QtiAssessmentItemRef.prototype, "fixed", 2);
+__decorateClass([
+  property3({ type: String })
+], QtiAssessmentItemRef.prototype, "href", 2);
+__decorateClass([
+  property3({ type: Object, attribute: false })
+], QtiAssessmentItemRef.prototype, "xmlDoc", 2);
+if (!customElements.get("qti-assessment-item-ref")) {
+  customElements.define("qti-assessment-item-ref", QtiAssessmentItemRef);
+}
+
+// src/lib/qti-test/core/qti-assessment-test/qti-assessment-section.ts
+import { consume } from "@lit/context";
+import { html as html2, LitElement as LitElement3 } from "lit";
+import { property as property4 } from "lit/decorators.js";
+var stringToBooleanConverter2 = {
+  fromAttribute(value) {
+    return value === "true";
+  },
+  toAttribute(value) {
+    return value ? "true" : "false";
+  }
+};
+var QtiAssessmentSection = class extends LitElement3 {
+  async connectedCallback() {
+    super.connectedCallback();
+    await this.updateComplete;
+    this.dispatchEvent(
+      new Event("qti-assessment-section-connected", {
+        bubbles: true,
+        composed: true
+      })
+    );
+  }
+  render() {
+    return html2`<slot name="qti-rubric-block"></slot><slot></slot>`;
+  }
+};
+__decorateClass([
+  property4({ type: String })
+], QtiAssessmentSection.prototype, "identifier", 2);
+__decorateClass([
+  property4({ type: String })
+], QtiAssessmentSection.prototype, "required", 2);
+__decorateClass([
+  property4({ type: Boolean, converter: stringToBooleanConverter2 })
+], QtiAssessmentSection.prototype, "fixed", 2);
+__decorateClass([
+  property4({ type: String })
+], QtiAssessmentSection.prototype, "title", 2);
+__decorateClass([
+  property4({ type: Boolean, converter: stringToBooleanConverter2 })
+], QtiAssessmentSection.prototype, "visible", 2);
+__decorateClass([
+  property4({ type: Boolean, converter: stringToBooleanConverter2, attribute: "keep-together" })
+], QtiAssessmentSection.prototype, "keepTogether", 2);
+__decorateClass([
+  consume({ context: testContext, subscribe: true })
+], QtiAssessmentSection.prototype, "_testContext", 2);
+if (!customElements.get("qti-assessment-section")) {
+  customElements.define("qti-assessment-section", QtiAssessmentSection);
+}
+
+// src/lib/qti-test/core/qti-assessment-test/qti-assessment-test.ts
+import { consume as consume2 } from "@lit/context";
+import { html as html3, LitElement as LitElement4 } from "lit";
+import { customElement as customElement2, property as property5 } from "lit/decorators.js";
+var QtiAssessmentTest = class extends LitElement4 {
+  async connectedCallback() {
+    super.connectedCallback();
+    await this.updateComplete;
+    this.dispatchEvent(
+      new CustomEvent("qti-assessment-test-connected", {
+        detail: this,
+        bubbles: true,
+        composed: true
+      })
+    );
+  }
+  render() {
+    return html3` <slot></slot>`;
+  }
+};
+__decorateClass([
+  property5({ type: String })
+], QtiAssessmentTest.prototype, "identifier", 2);
+__decorateClass([
+  property5({ type: String })
+], QtiAssessmentTest.prototype, "title", 2);
+__decorateClass([
+  consume2({ context: testContext, subscribe: true })
+], QtiAssessmentTest.prototype, "_testContext", 2);
+QtiAssessmentTest = __decorateClass([
+  customElement2("qti-assessment-test")
+], QtiAssessmentTest);
+
+// src/lib/qti-test/core/qti-assessment-test/qti-test-part.ts
+import { html as html4, LitElement as LitElement5 } from "lit";
+import { customElement as customElement3, property as property6 } from "lit/decorators.js";
+var QtiTestPart = class extends LitElement5 {
+  constructor() {
+    super(...arguments);
+    this.identifier = "";
+    this.title = "";
+    this.class = "";
+    this.NavigationMode = "nonlinear";
+    this.submissionMode = "individual";
+  }
+  async connectedCallback() {
+    super.connectedCallback();
+    await this.updateComplete;
+    this.dispatchEvent(
+      new Event("qti-test-part-connected", {
+        bubbles: true,
+        composed: true
+      })
+    );
+  }
+  render() {
+    return html4` <slot></slot>`;
+  }
+};
+__decorateClass([
+  property6({ type: String })
+], QtiTestPart.prototype, "identifier", 2);
+__decorateClass([
+  property6({ type: String })
+], QtiTestPart.prototype, "title", 2);
+__decorateClass([
+  property6({ type: String })
+], QtiTestPart.prototype, "class", 2);
+__decorateClass([
+  property6({ type: String, attribute: "navigation-mode" })
+], QtiTestPart.prototype, "NavigationMode", 2);
+__decorateClass([
+  property6({ type: String, attribute: "submission-mode" })
+], QtiTestPart.prototype, "submissionMode", 2);
+QtiTestPart = __decorateClass([
+  customElement3("qti-test-part")
+], QtiTestPart);
+if (!customElements.get("qti-test-part")) {
+  customElements.define("qti-test-part", QtiTestPart);
+}
+
+// src/lib/qti-test/core/qti-assessment-test/qti-test-feedback.ts
+import { customElement as customElement4 } from "lit/decorators.js";
+import { css, html as html5 } from "lit";
+var QtiTestFeedback = class extends QtiModalFeedback {
+  render() {
+    return html5``;
+  }
+};
+QtiTestFeedback.styles = css`
+    :host {
+      color: gray;
+    }
+  `;
+QtiTestFeedback = __decorateClass([
+  customElement4("qti-test-feedback")
+], QtiTestFeedback);
+
+export {
+  QtiTest,
+  QtiAssessmentItemRef,
+  QtiAssessmentSection,
+  QtiAssessmentTest,
+  QtiTestPart,
+  QtiTestFeedback
+};
+//# sourceMappingURL=chunk-7T5WVG7T.js.map