@citolab/qti-components 7.3.22 → 7.4.0

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

@@ -0,0 +1,593 @@
+import * as lit_html from 'lit-html';
+import { e as VariableValue, O as OutcomeVariable, V as VariableDeclaration } from '../variables-Vgyr6yyW.js';
+import * as lit from 'lit';
+import { LitElement, PropertyValues, nothing } from 'lit';
+import { T as TestContext, Q as QtiModalFeedback, c as QtiContext } from '../test.context-L609DNAz.js';
+export { I as INITIAL_TEST_CONTEXT, t as testContext } from '../test.context-L609DNAz.js';
+import { Q as QtiAssessmentItem } from '../qti-assessment-item-D77dJ1Ot.js';
+import { TemplateFunction } from '@heximal/templates';
+import { C as ComputedItemContext } from '../computed-item.context-DpK-sS0T.js';
+import { C as ConfigContext } from '../config.context-CmQ9L62n.js';
+import { ViewMode } from 'storybook/internal/types';
+
+type View = 'author' | 'candidate' | 'proctor' | 'scorer' | 'testConstructor' | 'tutor' | '';
+interface SessionContext {
+    navPartId?: string | null;
+    navSectionId?: string | null;
+    navItemRefId?: string | null;
+    navItemLoading?: boolean;
+    navTestLoading?: boolean;
+    view?: View;
+}
+
+declare class QtiAssessmentTest extends LitElement {
+    identifier: string;
+    get title(): string;
+    set title(value: string);
+    _testContext?: TestContext;
+    private _title;
+    connectedCallback(): Promise<void>;
+    render(): lit_html.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-assessment-test': QtiAssessmentTest;
+    }
+}
+
+declare abstract class TestBase extends LitElement {
+    testContext: Readonly<TestContext>;
+    sessionContext: Readonly<SessionContext>;
+    protected _testElement: QtiAssessmentTest;
+    updateItemVariables(itemRefID: string, variables: VariableValue<string | string[] | null>[]): void;
+    constructor();
+    private _updateItemVariablesInTestContext;
+    /**
+     * 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.
+     */
+    private _updateItemInTestContext;
+}
+
+declare class QtiAssessmentItemRef extends LitElement {
+    category?: string;
+    identifier?: string;
+    required?: boolean;
+    fixed?: boolean;
+    href?: string;
+    weigths: Map<string, number>;
+    xmlDoc: DocumentFragment;
+    protected createRenderRoot(): HTMLElement | DocumentFragment;
+    get assessmentItem(): QtiAssessmentItem | null;
+    myTemplate: TemplateFunction;
+    connectedCallback(): Promise<void>;
+    render(): unknown;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-assessment-item-ref': QtiAssessmentItemRef;
+    }
+}
+
+declare class QtiAssessmentSection extends LitElement {
+    identifier: string;
+    required: string;
+    fixed: boolean;
+    get title(): string;
+    set title(value: string);
+    visible: boolean;
+    keepTogether: boolean;
+    _testContext?: TestContext;
+    private _title;
+    connectedCallback(): Promise<void>;
+    render(): lit_html.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-assessment-section': QtiAssessmentSection;
+    }
+}
+
+declare class QtiTestPart extends LitElement {
+    identifier: string;
+    get title(): string;
+    set title(value: string);
+    class: string;
+    navigationMode: 'linear' | 'nonlinear';
+    submissionMode: 'individual' | 'simultaneous';
+    private _title;
+    connectedCallback(): Promise<void>;
+    render(): lit_html.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-test-part': QtiTestPart;
+    }
+}
+
+declare class QtiTestFeedback extends QtiModalFeedback {
+    static styles: lit.CSSResult;
+    render(): lit_html.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-test-feedback': QtiTestFeedback;
+    }
+}
+
+interface IQtiTest {
+    testContext: Readonly<TestContext>;
+    sessionContext: Readonly<SessionContext>;
+    updateItemVariables(itemRefID: string, variables: VariableValue<string | string[] | null>[]): void;
+}
+
+declare const QtiTest_base: (abstract new (...args: any[]) => {}) & (abstract new (...args: any[]) => {}) & (abstract new (...args: any[]) => {
+    updateOutcomeVariable(identifier: string, value: string | string[] | undefined): void;
+    getOutcome(identifier: string): Readonly<OutcomeVariable>;
+    getVariable(identifier: string): Readonly<VariableDeclaration<string | string[] | null>>;
+    outcomeProcessing(): boolean;
+}) & typeof TestBase;
+/**
+ * `<qti-test>` is a custom element designed for rendering and interacting with QTI (Question and Test Interoperability) tests.
+ *
+ * This component leverages several mixins to provide functionality for loading, navigating, processing, and displaying QTI test assessments.
+ *
+ * ### Example Usage
+ *
+ * Minimal example including navigation:
+ *
+ * ```html
+ * <qti-test>
+ *  <test-navigation>
+ *    <test-container test-url="./path/to/assessment.xml"></test-container>
+ *    <nav class="flex">
+ *      <test-prev></test-prev>
+ *      <test-next></test-next>
+ *    </nav>
+ *  </test-navigation>
+ * </qti-test>
+ * ```
+ *
+ * Use the following file structure
+ * A qti-test loads a QTI3.0 assessmenttest.xml file from a package folder.
+ *
+ * ```plaintext
+ * Root/
+ * ├── index.html
+ * └── /assets/api/examples/
+ *     ├── assessmenttest.xml
+ *     └── imsmanifest.xml
+ *
+ * ```
+ *
+ * ### Test components
+ *
+ * Use test components inside the qti-test component for added functionality.
+ * ### Test next
+ * `<test-next> | TestNext`
+ *
+ * ### Test prev
+ *
+ * `<test-prev> | TestPrev`
+ * ### Test components
+ *
+ * You can use normal class names to style the elements.
+ * And you can use the `test-prev` and `test-next` elements to navigate through the test.
+ *
+ */
+declare class QtiTest extends QtiTest_base implements IQtiTest {
+    /**
+     * Renders the component's template.
+     * Provides a default `<slot>` for content projection.
+     */
+    connectedCallback(): Promise<void>;
+    render(): lit_html.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-test': QtiTest;
+    }
+}
+
+type ComputedItem = ComputedItemContext & {
+    categories?: string[];
+    type?: 'info' | 'regular';
+    index?: number;
+    active?: boolean;
+};
+type ComputedContext = {
+    view: View;
+    identifier: string;
+    title: string;
+    testParts: {
+        active?: boolean;
+        identifier: string;
+        navigationMode: 'linear' | 'nonlinear';
+        submissionMode: 'individual' | 'simultaneous';
+        sections: {
+            active?: boolean;
+            identifier: string;
+            title: string;
+            completed?: boolean;
+            items: ComputedItem[];
+        }[];
+    }[];
+};
+
+type CustomEventMap = {
+    'test-end-attempt': CustomEvent;
+    'test-show-correct-response': CustomEvent<{
+        value: boolean;
+    }>;
+};
+declare global {
+    interface GlobalEventHandlersEventMap extends CustomEventMap {
+    }
+}
+declare class TestNavigation extends LitElement {
+    identifier: any;
+    initContext: {
+        identifier: string;
+        [key: string]: any;
+    }[];
+    qtiContext: QtiContext;
+    configContext: ConfigContext;
+    protected _testContext?: TestContext;
+    protected _sessionContext?: SessionContext;
+    protected computedContext: ComputedContext;
+    autoScoreItems: boolean;
+    private _testElement;
+    constructor();
+    /**
+     * Handles the 'test-end-attempt' event.
+     * @private
+     * @listens TestNavigation#test-end-attempt
+     * @param {CustomEvent} event - The custom event object.
+     */
+    private _handleTestEndAttempt;
+    /**
+     * Handles the 'test-show-correct-response' event.
+     * @private
+     * @listens TestNavigation#test-show-correct-response
+     * @param {CustomEvent} event - The custom event object.
+     */
+    private _handleTestShowCorrectResponse;
+    /**
+     * Handles the 'test-show-candidate-correction' event.
+     * @private
+     * @listens TestNavigation#test-show-candidate-correction
+     * @param {CustomEvent} event - The custom event object.
+     */
+    private _handleTestShowCandidateCorrection;
+    private _handleTestUpdateOutcomeVariable;
+    private _handleInteractionChanged;
+    render(): lit_html.TemplateResult<1>;
+    private _handleTestConnected;
+    /**
+     * Extract default values from a qti-context-declaration element
+     */
+    private _extractDefaultValues;
+    private _handleItemConnected;
+    protected willUpdate(_changedProperties: PropertyValues): void;
+}
+
+/**
+ * Represents a custom element for navigating to the next test item.
+ *
+ * @remarks
+ * This element provides functionality for navigating to the next test item.
+ *
+ * @example
+ * ```html
+ * <test-next></test-next>
+ * ```
+ */
+declare class TestNext extends LitElement {
+    _internalDisabled: boolean;
+    protected computedContext: ComputedContext;
+    sectionItems: ComputedItem[];
+    itemIndex: number;
+    _handleTestElementChange(_oldValue: ComputedContext, newValue: ComputedContext): void;
+    static styles: lit.CSSResult;
+    private _internals;
+    constructor();
+    connectedCallback(): void;
+    willUpdate(_changedProperties: Map<string | number | symbol, unknown>): void;
+    checkDisabled(): void;
+    protected _requestItem(identifier: string): void;
+    render(): lit_html.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'test-next': TestNext;
+    }
+}
+
+/**
+ * Represents a custom element for navigating to the previous test item.
+ *
+ * @remarks
+ * This element provides functionality for navigating to the previous test item.
+ *
+ * @example
+ * ```html
+ * <test-prev></test-prev>
+ * ```
+ */
+declare class TestPrev extends LitElement {
+    _internalDisabled: boolean;
+    private computedContext;
+    sectionItems: ComputedItem[];
+    itemIndex: number;
+    _handleTestElementChange(_oldValue: ComputedContext, newValue: ComputedContext): void;
+    static styles: lit.CSSResult;
+    constructor();
+    willUpdate(_changedProperties: Map<string | number | symbol, unknown>): void;
+    checkDisabled(): void;
+    protected _requestItem(identifier: string): void;
+    render(): lit_html.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'test-previous': TestPrev;
+    }
+}
+
+declare class TestView extends LitElement {
+    static DEFAULT_VIEW_OPTIONS: string[];
+    private sessionContext;
+    /** label accompanying the select view dropdown  */
+    label: string;
+    /** The options to display in the dropdown, default: ['author', 'candidate', 'proctor', 'scorer', 'testConstructor', 'tutor'] */
+    viewOptions: any;
+    protected _handleViewOptionsChange: () => void;
+    connectedCallback(): void;
+    private _viewOptions;
+    private updateViewOptions;
+    protected _switchView(view: string): void;
+    render(): lit_html.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'test-view': TestView;
+    }
+}
+
+declare class TestItemLink extends LitElement {
+    static styles: lit.CSSResult;
+    private itemId;
+    constructor();
+    protected _requestItem(identifier: string): void;
+    render(): lit_html.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'test-item-link': TestItemLink;
+    }
+}
+
+declare class TestEndAttempt extends LitElement {
+    static styles: lit.CSSResult;
+    constructor();
+    render(): lit_html.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'test-end-attempt': TestEndAttempt;
+    }
+}
+
+/**
+ * @deprecated test-show-correct-response is deprecated and will be removed in the future.
+ */
+declare class TestShowCorrectResponse extends LitElement {
+    computedContext?: ComputedContext;
+    static styles: lit.CSSResult;
+    shown: boolean;
+    disabled: boolean;
+    showCorrectText: string;
+    hideCorrectText: string;
+    noCorrectResponseText: string;
+    private _previousActiveItem?;
+    willUpdate(_changedProperties: Map<string | number | symbol, unknown>): void;
+    private _toggleState;
+    private _getDisplayedText;
+    render(): lit_html.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'test-show-correct-response': TestShowCorrectResponse;
+    }
+}
+
+/**
+ * @deprecated test-paging-buttons-stamp is deprecated and will be removed in the future.
+ */
+declare class TestPagingButtonsStamp extends LitElement {
+    private computedContext;
+    myTemplate: TemplateFunction;
+    private _internals;
+    protected createRenderRoot(): HTMLElement | DocumentFragment;
+    constructor();
+    connectedCallback(): void;
+    render(): lit_html.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'test-paging-buttons-stamp': TestPagingButtonsStamp;
+    }
+}
+
+/**
+ * `<test-container>` is a custom element designed for hosting the qti-assessment-item.
+ * The `qti-assessment-test` will be placed inside the shadow DOM of this element.
+ * The element loads the test from the provided URL and renders it inside the shadow DOM.
+ *
+ * ```html
+ * <qti-test>
+ *   <test-navigation>
+ *      <test-container class="m-4 bg-white" test-url="./path/to/assessmenttest.xml"></test-container>
+ *   </test-navigation>
+ * </qti-test>
+ * ```
+ */
+declare class TestContainer extends LitElement {
+    /** URL of the item to load */
+    testURL: string;
+    /** A parsed HTML document */
+    testDoc: DocumentFragment;
+    /** The raw XML string */
+    testXML: string;
+    /** Template content if provided */
+    private templateContent;
+    protected handleTestURLChange(): Promise<void>;
+    protected handleTestXMLChange(): void;
+    connectedCallback(): Promise<void>;
+    private initializeTemplateContent;
+    private applyStyles;
+    render(): lit_html.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'test-container': TestContainer;
+    }
+}
+
+declare class TestPrintVariables extends LitElement {
+    computedContext?: ComputedContext;
+    static styles: lit.CSSResult;
+    render(): lit_html.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'test-print-item-variables': TestPrintVariables;
+    }
+}
+
+/**
+ * @deprecated test-section-buttons-stamp is deprecated and will be removed in the future.
+ */
+declare class TestSectionButtonsStamp extends LitElement {
+    private computedContext;
+    myTemplate: TemplateFunction;
+    private _internals;
+    protected createRenderRoot(): HTMLElement | DocumentFragment;
+    constructor();
+    connectedCallback(): void;
+    render(): lit_html.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'test-section-buttons-stamp': TestSectionButtonsStamp;
+    }
+}
+
+declare class TestSectionLink extends LitElement {
+    static styles: lit.CSSResult;
+    private sectionId;
+    private _requestItem;
+    constructor();
+    render(): lit_html.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'test-section-link': TestSectionLink;
+    }
+}
+
+declare class TestPrintContext extends LitElement {
+    computedContext?: ComputedContext;
+    render(): lit_html.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'test-print-context': TestPrintContext;
+    }
+}
+
+/**
+ * A custom web component that renders a test stamp using the Lit framework.
+ * This component is deprecated and will be removed in the future.
+ * @customElement
+ * @extends {LitElement}
+ */
+declare class TestStamp extends LitElement {
+    /**
+     * Indicates whether the component is in debug mode.
+     * When set to `true`, the available objects and properties (i.e.: stampContext) is displayed.
+     */
+    debug: boolean;
+    private computedContext;
+    private stampContext;
+    myTemplate: TemplateFunction;
+    protected createRenderRoot(): HTMLElement | DocumentFragment;
+    connectedCallback(): void;
+    protected willUpdate(_changedProperties: PropertyValues): void;
+    render(): lit_html.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'test-stamp': TestStamp;
+    }
+}
+
+declare class TestScoringButtons extends LitElement {
+    view: string;
+    disabled: boolean;
+    myTemplate: TemplateFunction | null;
+    protected createRenderRoot(): HTMLElement | DocumentFragment;
+    connectedCallback(): void;
+    protected computedContext?: ComputedContext;
+    private _changeOutcomeScore;
+    render(): lit_html.TemplateResult<1> | typeof nothing;
+    constructor();
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'test-scoring-buttons': TestScoringButtons;
+    }
+}
+
+declare class TestViewToggle extends LitElement {
+    myTemplate: any;
+    protected createRenderRoot(): HTMLElement | DocumentFragment;
+    private sessionContext;
+    connectedCallback(): void;
+    _switchView(view: string): void;
+    protected firstUpdated(_changedProperties: PropertyValues): void;
+    render(): lit_html.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'test-view-toggle': TestViewToggle;
+    }
+}
+
+declare class TestScoringFeedback extends LitElement {
+    protected computedContext?: ComputedContext;
+    view: ViewMode;
+    render(): lit_html.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'test-scoring-feedback': TestScoringFeedback;
+    }
+}
+
+declare class TestCheckItem extends LitElement {
+    static styles: lit.CSSResult;
+    constructor();
+    render(): lit_html.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'test-check-item': TestCheckItem;
+    }
+}
+
+export { QtiAssessmentItemRef, QtiAssessmentSection, QtiAssessmentTest, QtiTest, QtiTestFeedback, QtiTestPart, TestCheckItem, TestContainer, TestContext, TestEndAttempt, TestItemLink, TestNavigation, TestNext, TestPagingButtonsStamp, TestPrev, TestPrintContext, TestPrintVariables, TestScoringButtons, TestScoringFeedback, TestSectionButtonsStamp, TestSectionLink, TestShowCorrectResponse, TestStamp, TestView, TestViewToggle };

package/dist/qti-test/index.js

@@ -0,0 +1,62 @@
+import {
+  QtiAssessmentItemRef,
+  QtiAssessmentSection,
+  QtiAssessmentTest,
+  QtiTest,
+  QtiTestFeedback,
+  QtiTestPart,
+  TestCheckItem,
+  TestContainer,
+  TestEndAttempt,
+  TestItemLink,
+  TestNavigation,
+  TestNext,
+  TestPagingButtonsStamp,
+  TestPrev,
+  TestPrintContext,
+  TestPrintVariables,
+  TestScoringButtons,
+  TestScoringFeedback,
+  TestSectionButtonsStamp,
+  TestSectionLink,
+  TestShowCorrectResponse,
+  TestStamp,
+  TestView,
+  TestViewToggle
+} from "../chunks/chunk-TJ6ZOT7A.js";
+import "../chunks/chunk-LSEB52SP.js";
+import {
+  INITIAL_TEST_CONTEXT,
+  testContext
+} from "../chunks/chunk-GUDRSXIP.js";
+import "../chunks/chunk-O5N4DCU6.js";
+import "../chunks/chunk-JDY5GL7E.js";
+export {
+  INITIAL_TEST_CONTEXT,
+  QtiAssessmentItemRef,
+  QtiAssessmentSection,
+  QtiAssessmentTest,
+  QtiTest,
+  QtiTestFeedback,
+  QtiTestPart,
+  TestCheckItem,
+  TestContainer,
+  TestEndAttempt,
+  TestItemLink,
+  TestNavigation,
+  TestNext,
+  TestPagingButtonsStamp,
+  TestPrev,
+  TestPrintContext,
+  TestPrintVariables,
+  TestScoringButtons,
+  TestScoringFeedback,
+  TestSectionButtonsStamp,
+  TestSectionLink,
+  TestShowCorrectResponse,
+  TestStamp,
+  TestView,
+  TestViewToggle,
+  testContext
+};
+//# sourceMappingURL=index.js.map

package/dist/qti-transformers/index.d.ts

@@ -1,4 +1,40 @@
-export { M as ModuleResolutionConfig, q as qtiTransformItem, t as transformItemApi } from '../qti-transform-item-C9WtMeDR.js';
+interface ModuleResolutionConfig {
+    waitSeconds?: number;
+    context?: string;
+    catchError?: boolean;
+    urlArgs?: string;
+    paths: {
+        [key: string]: string | string[];
+    };
+    shim?: {
+        [key: string]: {
+            deps?: string[];
+            exports?: string;
+        };
+    };
+}
+type transformItemApi = {
+    load: (uri: string) => {
+        promise: Promise<transformItemApi>;
+        request: XMLHttpRequest | null;
+    };
+    parse: (xmlString: string) => transformItemApi;
+    path: (location: string) => transformItemApi;
+    fn: (fn: (xmlFragment: XMLDocument) => void) => transformItemApi;
+    pciHooks: (uri: string) => transformItemApi;
+    configurePci: (baseUrl: string, getModuleResolutionConfig: (baseUrl: string, fileUrl: string) => Promise<ModuleResolutionConfig>, selector?: string) => Promise<transformItemApi>;
+    extendElementName: (elementName: string, extend: string) => transformItemApi;
+    extendElementsWithClass: (param?: string) => transformItemApi;
+    customInteraction: (baseRef: string, baseItem: string) => transformItemApi;
+    convertCDATAtoComment: () => transformItemApi;
+    shuffleInteractions: () => transformItemApi;
+    stripStyleSheets: () => transformItemApi;
+    html: () => string;
+    xml: () => string;
+    htmlDoc: () => DocumentFragment;
+    xmlDoc: () => XMLDocument;
+};
+declare const qtiTransformItem: (cache?: boolean) => transformItemApi;
 
 declare const qtiTransformManifest: () => {
     load: (uri: string) => Promise<{
@@ -42,4 +78,4 @@ type transformTestApi = {
 };
 declare const qtiTransformTest: () => transformTestApi;
 
-export { qtiTransformManifest, qtiTransformTest, type transformTestApi };
+export { type ModuleResolutionConfig, qtiTransformItem, qtiTransformManifest, qtiTransformTest, type transformItemApi, type transformTestApi };

package/dist/qti-transformers/index.js

@@ -2,8 +2,7 @@ import {
   qtiTransformItem,
   qtiTransformManifest,
   qtiTransformTest
-} from "../chunks/chunk-WFUXZ4UT.js";
-import "../chunks/chunk-H2JE6IVU.js";
+} from "../chunks/chunk-JDY5GL7E.js";
 export {
   qtiTransformItem,
   qtiTransformManifest,