@citolab/qti-components 8.0.1 → 8.1.0

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

@@ -0,0 +1,702 @@
+import * as lit from 'lit';
+import { LitElement, PropertyValues, nothing } from 'lit';
+import { t as transformItemApi, b as transformTestApi } from './qti-transform-test.d-BL7GGFJj.js';
+import { QtiAssessmentItem, QtiModalFeedback } from './elements.js';
+import { TemplateFunction } from '@heximal/templates';
+import { T as TestContext, Q as QtiExpression, a as QtiExpressionBase } from './qti-expression.d-BietT_8b.js';
+import { g as VariableValue, b as OutcomeVariable, V as VariableDeclaration } from './item.types.d-QU7LljEK.js';
+import { S as SessionContext, C as ComputedContext, a as ComputedItem, V as View } from './computed.types.d-DpKIYO6e.js';
+import { C as ConfigContext } from './config.context.d-BvU9r-Mg.js';
+import { Q as QtiRuleBase } from './qti-rule-base.d-ajOnfGXY.js';
+import { Q as QtiContext } from './qti.context.d-CejJMlfZ.js';
+
+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 {
+    #private;
+    identifier: string;
+    required: string;
+    fixed: boolean;
+    get title(): string;
+    set title(value: string);
+    visible: boolean;
+    keepTogether: boolean;
+    navigationMode?: 'linear' | 'nonlinear';
+    submissionMode?: 'individual' | 'simultaneous';
+    _testContext?: TestContext;
+    connectedCallback(): Promise<void>;
+    render(): lit.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-assessment-section': QtiAssessmentSection;
+    }
+}
+
+declare class QtiAssessmentTest extends LitElement {
+    #private;
+    identifier: string;
+    get title(): string;
+    set title(value: string);
+    _testContext?: TestContext;
+    connectedCallback(): Promise<void>;
+    render(): lit.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-assessment-test': QtiAssessmentTest;
+    }
+}
+
+declare class QtiOutcomeProcessing extends LitElement {
+    static styles: lit.CSSResult[];
+    render(): lit.TemplateResult<1>;
+    process(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-outcome-processing': QtiOutcomeProcessing;
+    }
+}
+declare class QtiOutcomeProcessingProcessor {
+    process(rules: QtiRuleBase[]): void;
+}
+
+declare class QtiTestFeedback extends QtiModalFeedback {
+    static styles: lit.CSSResult;
+    render(): lit.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-test-feedback': QtiTestFeedback;
+    }
+}
+
+declare class QtiTestPart extends LitElement {
+    #private;
+    identifier: string;
+    get title(): string;
+    set title(value: string);
+    class: string;
+    navigationMode: 'linear' | 'nonlinear';
+    submissionMode: 'individual' | 'simultaneous';
+    connectedCallback(): Promise<void>;
+    render(): lit.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-test-part': QtiTestPart;
+    }
+}
+
+declare class QtiTestVariables extends QtiExpression<number> {
+    #private;
+    _testContext?: TestContext;
+    constructor();
+    getResult(): number;
+    calculate(): number;
+}
+declare class QtiTestVariablesExpression implements QtiExpressionBase<number> {
+    private testContext;
+    private itemVariable;
+    private includedItems;
+    constructor(testContext: TestContext, itemVariable: string, includedItems: {
+        item: string;
+        weight: number;
+    }[]);
+    calculate(): number;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-test-variables': QtiTestVariables;
+    }
+}
+
+interface TestBaseInterface extends LitElement {
+    testContext: Readonly<TestContext>;
+    sessionContext: Readonly<SessionContext>;
+    configContext?: Readonly<ConfigContext>;
+    _testElement: QtiAssessmentTest;
+    updateItemVariables(itemRefID: string, variables: VariableValue<string | string[] | null>[]): void;
+}
+
+type PostLoadTransformCallback = (transformer: transformItemApi, itemRef: QtiAssessmentItemRef) => transformItemApi | Promise<transformItemApi>;
+type PostLoadTestTransformCallback = (transformer: transformTestApi, testElement: QtiAssessmentTest) => transformTestApi | Promise<transformTestApi>;
+/**
+ * Exactly what this mixin adds. `IQtiTest` composes it (see ../types/iqti-test, which
+ * re-exports it), and `TestNavigationClass` below `implements` it, so the interface and the
+ * class cannot drift apart.
+ *
+ * This was `declare class TestNavigationInterface {}` — EMPTY — so the returned
+ * `Constructor<TestNavigationInterface> & T` added nothing and every member the mixin
+ * contributes was erased from the public type. `QtiTest` looked as though it had no
+ * `navigate` or `postLoadTransformCallback`, and consumers had to intersect the class with
+ * `IQtiTest` by hand to describe one element.
+ *
+ * `showLoadingIndicators` and `retryNavigation` used to be listed on the `IQtiTest` side with
+ * no implementation anywhere in the repo, so calling `retryNavigation()` would have thrown.
+ * They are gone rather than stubbed: there was no behaviour to preserve.
+ */
+interface ITestNavigationMixin {
+    navigate: 'item' | 'section' | null;
+    requestTimeout: number;
+    postLoadTransformCallback: PostLoadTransformCallback | null;
+    postLoadTestTransformCallback: PostLoadTestTransformCallback | null;
+    navigateTo(type: 'item' | 'section', id?: string): void;
+    getLoadingProgress(): {
+        expectedItems: number;
+        connectedItems: number;
+        expectedStimulus: number;
+        loadedStimulus: number;
+        isComplete: boolean;
+    };
+}
+
+type CustomEventMap = {
+    'test-end-attempt': CustomEvent;
+};
+declare global {
+    interface GlobalEventHandlersEventMap extends CustomEventMap {
+    }
+}
+declare class TestNavigation extends LitElement {
+    #private;
+    identifier: string | undefined;
+    initContext: {
+        identifier: string;
+        [key: string]: any;
+    }[];
+    qtiContext: QtiContext;
+    configContext: ConfigContext;
+    protected _testContext?: TestContext;
+    protected _sessionContext?: SessionContext;
+    protected computedContext: ComputedContext;
+    autoScoreItems: boolean;
+    constructor();
+    /** The currently active assessment item, exposed for optional presentation extensions. */
+    protected get activeAssessmentItem(): QtiAssessmentItem | undefined;
+    render(): lit.TemplateResult<1>;
+    protected willUpdate(_changedProperties: PropertyValues): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'test-navigation': TestNavigation;
+    }
+}
+
+/**
+ * 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 {
+    #private;
+    _internalDisabled: boolean;
+    protected computedContext: ComputedContext;
+    sectionItems: ComputedItem[];
+    itemIndex: number;
+    _handleTestElementChange(_oldValue: ComputedContext, newValue: ComputedContext): void;
+    static styles: lit.CSSResult;
+    constructor();
+    connectedCallback(): void;
+    willUpdate(_changedProperties: Map<string | number | symbol, unknown>): void;
+    checkDisabled(): void;
+    protected _requestItem(identifier: string): void;
+    render(): lit.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.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'test-prev': TestPrev;
+    }
+}
+
+declare class TestView extends LitElement {
+    #private;
+    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: string;
+    protected _handleViewOptionsChange: () => void;
+    connectedCallback(): void;
+    private _viewOptions;
+    protected _switchView(view: string): void;
+    render(): lit.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.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'test-item-link': TestItemLink;
+    }
+}
+
+declare class TestEndAttempt extends LitElement {
+    static styles: lit.CSSResult;
+    constructor();
+    render(): lit.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'test-end-attempt': TestEndAttempt;
+    }
+}
+
+/**
+ * @deprecated test-paging-buttons-stamp is deprecated and will be removed in the future.
+ */
+declare class TestPagingButtonsStamp extends LitElement {
+    #private;
+    private computedContext;
+    myTemplate: TemplateFunction;
+    protected createRenderRoot(): HTMLElement | DocumentFragment;
+    constructor();
+    connectedCallback(): void;
+    render(): lit.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 {
+    #private;
+    /** Scoped registry used by the test shadow root. Must be set before connection. */
+    customElementRegistry: CustomElementRegistry | null;
+    /** URL of the item to load */
+    testURL: string | null;
+    /** A parsed HTML document */
+    testDoc: DocumentFragment | null;
+    /** The raw XML string */
+    testXML: string | null;
+    protected qtiContext: QtiContext;
+    protected createRenderRoot(): HTMLElement | DocumentFragment;
+    /** Callback function to transform the test after loading */
+    protected handleTestURLChange(): Promise<void>;
+    protected handleTestXMLChange(): void;
+    connectedCallback(): Promise<void>;
+    render(): lit.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'test-container': TestContainer;
+    }
+}
+
+declare class TestPrintVariables extends LitElement {
+    computedContext?: ComputedContext;
+    static styles: lit.CSSResult;
+    render(): lit.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;
+    private computedContext;
+    myTemplate: TemplateFunction;
+    protected createRenderRoot(): HTMLElement | DocumentFragment;
+    constructor();
+    connectedCallback(): void;
+    render(): lit.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'test-section-buttons-stamp': TestSectionButtonsStamp;
+    }
+}
+
+declare class TestSectionLink extends LitElement {
+    #private;
+    static styles: lit.CSSResult;
+    private sectionId;
+    constructor();
+    render(): lit.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'test-section-link': TestSectionLink;
+    }
+}
+
+declare class TestPrintContext extends LitElement {
+    computedContext?: ComputedContext;
+    render(): lit.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.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'test-stamp': TestStamp;
+    }
+}
+
+declare class TestScoringButtons extends LitElement {
+    #private;
+    view: string;
+    disabled: boolean;
+    myTemplate: TemplateFunction | null;
+    protected createRenderRoot(): HTMLElement | DocumentFragment;
+    connectedCallback(): void;
+    protected computedContext?: ComputedContext;
+    render(): lit.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.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'test-view-toggle': TestViewToggle;
+    }
+}
+
+declare class TestScoringFeedback extends LitElement {
+    protected computedContext?: ComputedContext;
+    view: View;
+    render(): lit.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'test-scoring-feedback': TestScoringFeedback;
+    }
+}
+
+declare class TestCheckItem extends LitElement {
+    static styles: lit.CSSResult;
+    constructor();
+    render(): lit.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'test-check-item': TestCheckItem;
+    }
+}
+
+type SpeechState = 'idle' | 'playing' | 'paused';
+interface TtsContext {
+    state: SpeechState;
+    /** Index of the currently highlighted reading element (0-based). */
+    currentElementIndex: number;
+    /** Total number of navigable reading elements in the current item. */
+    elementCount: number;
+    play(): void;
+    pause(): void;
+    resume(): void;
+    stop(): void;
+    prevElement(): void;
+    nextElement(): void;
+}
+
+declare const ttsContext: {
+    __context__: TtsContext;
+};
+/**
+ * Base class shared by all TTS control elements. Consumes `ttsContext` and
+ * mirrors the current speech state onto CSS custom states so each child can
+ * be styled with `:state(playing)`, `:state(paused)`, `:state(idle)`.
+ */
+declare abstract class TtsButtonBase extends LitElement {
+    #private;
+    static styles: lit.CSSResult;
+    protected _tts?: TtsContext;
+    updated(changed: PropertyValues): void;
+}
+/**
+ * `<test-item-to-speech>` is the controller and context provider. It manages
+ * speech synthesis, word highlighting, and item element lookup. Compose your
+ * own player by placing control elements as children.
+ *
+ * @example
+ * ```html
+ * <test-item-to-speech language="nl-NL">
+ *   <test-tts-play></test-tts-play>
+ *   <test-tts-prev>◀◀</test-tts-prev>
+ *   <test-tts-next>▶▶</test-tts-next>
+ *   <test-tts-stop>■</test-tts-stop>
+ * </test-item-to-speech>
+ * ```
+ *
+ * @cssstate idle    - No speech active
+ * @cssstate playing - Speech is playing
+ * @cssstate paused  - Speech is paused
+ */
+declare class TestItemToSpeech extends LitElement {
+    #private;
+    language: string;
+    protected _sessionContext?: SessionContext;
+    _ttsContext: TtsContext;
+    constructor();
+    willUpdate(changed: PropertyValues): void;
+    updated(_changed: PropertyValues): void;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    render(): lit.TemplateResult<1>;
+}
+/**
+ * Play/pause/resume toggle button — always enabled, cycles through states.
+ * Use named slots `play` and `pause` to customise the icons/labels independently.
+ *
+ * @example
+ * ```html
+ * <test-tts-play>
+ *   <span slot="play">▶ Play</span>
+ *   <span slot="pause">⏸ Pause</span>
+ * </test-tts-play>
+ * ```
+ *
+ * @cssstate idle / playing / paused
+ * @csspart button
+ */
+declare class TestTtsPlay extends TtsButtonBase {
+    #private;
+    render(): lit.TemplateResult<1>;
+}
+/**
+ * Pause button — enabled only when playing.
+ * @cssstate idle / playing / paused
+ * @csspart button
+ */
+declare class TestTtsPause extends TtsButtonBase {
+    render(): lit.TemplateResult<1>;
+}
+/**
+ * Resume button — enabled only when paused.
+ * @cssstate idle / playing / paused
+ * @csspart button
+ */
+declare class TestTtsResume extends TtsButtonBase {
+    render(): lit.TemplateResult<1>;
+}
+/**
+ * Stop button — enabled when playing or paused.
+ * @cssstate idle / playing / paused
+ * @csspart button
+ */
+declare class TestTtsStop extends TtsButtonBase {
+    render(): lit.TemplateResult<1>;
+}
+/**
+ * Prev-element button — moves cursor to the previous reading element and pauses.
+ * Disabled at the first element or when no elements are loaded.
+ * @cssstate idle / playing / paused
+ * @csspart button
+ */
+declare class TestTtsPrev extends TtsButtonBase {
+    render(): lit.TemplateResult<1>;
+}
+/**
+ * Next-element button — moves cursor to the next reading element and pauses.
+ * Disabled at the last element or when no elements are loaded.
+ * @cssstate idle / playing / paused
+ * @csspart button
+ */
+declare class TestTtsNext extends TtsButtonBase {
+    render(): lit.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'test-item-to-speech': TestItemToSpeech;
+        'test-tts-play': TestTtsPlay;
+        'test-tts-pause': TestTtsPause;
+        'test-tts-resume': TestTtsResume;
+        'test-tts-stop': TestTtsStop;
+        'test-tts-prev': TestTtsPrev;
+        'test-tts-next': TestTtsNext;
+    }
+}
+
+declare const QtiTest_base: (abstract new (...args: any[]) => ITestNavigationMixin) & (abstract new (...args: any[]) => {
+    updateAssessmentItemView(assessmentItem: QtiAssessmentItem, view: View): void;
+}) & (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;
+}) & (abstract new (...args: any[]) => TestBaseInterface) & typeof LitElement;
+/**
+ * `<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 {
+    configContext: ConfigContext;
+    /**
+     * Renders the component's template.
+     * Provides a default `<slot>` for content projection.
+     */
+    connectedCallback(): Promise<void>;
+    render(): lit.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-test': QtiTest;
+    }
+}
+
+export { TestTtsPlay as A, TestTtsPrev as B, TestTtsResume as C, TestTtsStop as D, TestView as E, TestViewToggle as F, type TtsContext as G, ttsContext as H, type ITestNavigationMixin as I, QtiAssessmentItemRef as Q, type SpeechState as S, TestCheckItem as T, QtiAssessmentSection as a, QtiAssessmentTest as b, QtiOutcomeProcessing as c, QtiOutcomeProcessingProcessor as d, QtiTest as e, QtiTestFeedback as f, QtiTestPart as g, QtiTestVariables as h, QtiTestVariablesExpression as i, TestContainer as j, TestEndAttempt as k, TestItemLink as l, TestItemToSpeech as m, TestNavigation as n, TestNext as o, TestPagingButtonsStamp as p, TestPrev as q, TestPrintContext as r, TestPrintVariables as s, TestScoringButtons as t, TestScoringFeedback as u, TestSectionButtonsStamp as v, TestSectionLink as w, TestStamp as x, TestTtsNext as y, TestTtsPause as z };