@citolab/qti-components 7.28.1 → 8.0.1

package/dist/corrections.d.ts

@@ -0,0 +1,432 @@
+import { I as Interaction } from './interaction.d-D4MstYRz.js';
+import { R as ResponseValue } from './response.d-_8y4kjGP.js';
+import * as lit from 'lit';
+import { LitElement } from 'lit';
+import { QtiGapText } from '@qti-components/interactions-core/elements/qti-gap-text';
+import { QtiHotspotChoice } from '@qti-components/interactions-core/elements/qti-hotspot-choice';
+import { QtiHottext } from '@qti-components/interactions-core/elements/qti-hottext';
+import { QtiSimpleAssociableChoice } from '@qti-components/interactions-core/elements/qti-simple-associable-choice';
+import { QtiSimpleChoice } from '@qti-components/interactions-core/elements/qti-simple-choice';
+import { QtiAssessmentItem } from '@qti-components/elements/elements';
+import { QtiItem } from '@qti-components/item/elements';
+import { QtiTest, TestCheckItem, TestNavigation } from '@qti-components/test/elements';
+import { V as View, C as ComputedContext } from './computed.types.d-rKLSPvVG.js';
+import { QtiAssessmentItem as QtiAssessmentItem$1 } from './elements.js';
+import { C as ComputedItemContext } from './computed-item.types.d-BKZdSLLJ.js';
+import { QtiAssociateInteraction } from '@qti-components/associate-interaction/elements';
+import { QtiChoiceInteraction } from '@qti-components/choice-interaction/elements';
+import { QtiExtendedTextInteraction } from '@qti-components/extended-text-interaction/elements';
+import { QtiGapMatchInteraction } from '@qti-components/gap-match-interaction/elements';
+import { QtiGraphicAssociateInteraction } from '@qti-components/graphic-associate-interaction/elements';
+import { QtiGraphicGapMatchInteraction } from '@qti-components/graphic-gap-match-interaction/elements';
+import { QtiGraphicOrderInteraction } from '@qti-components/graphic-order-interaction/elements';
+import { Choice } from '@qti-components/interactions-core/mixins/choices/choices.mixin';
+import { QtiHotspotInteraction } from '@qti-components/hotspot-interaction/elements';
+import { QtiHottextInteraction } from '@qti-components/hottext-interaction/elements';
+import { QtiInlineChoiceInteraction } from '@qti-components/inline-choice-interaction/elements';
+import { QtiMatchInteraction } from '@qti-components/match-interaction/elements';
+import { QtiOrderInteraction } from '@qti-components/order-interaction/elements';
+import { QtiPortableCustomInteraction } from '@qti-components/portable-custom-interaction/elements';
+import { QtiSelectPointInteraction } from '@qti-components/select-point-interaction/elements';
+import { QtiSliderInteraction } from '@qti-components/slider-interaction/elements';
+import { QtiTextEntryInteraction } from '@qti-components/text-entry-interaction/elements';
+import './config.context.d-BvU9r-Mg.js';
+import './interaction.interface.d-CvjHM2bi.js';
+import './item.types.d-QU7LljEK.js';
+import './qti-feedback.d-DZbad0RN.js';
+import './qti-rule-base.d-ajOnfGXY.js';
+
+type AbstractConstructor$2<T = {}> = abstract new (...args: any[]) => T;
+declare enum Correctness {
+    Correct = "correct",
+    PartiallyCorrect = "partially-correct",
+    Incorrect = "incorrect"
+}
+/**
+ * Adds correct-response and full-correct-response behaviour
+ * on top of any `Interaction` subclass.
+ *
+ * Usage:
+ * ```ts
+ * export abstract class CorrectableInteraction extends CorrectResponseMixin(Interaction) {}
+ * ```
+ *
+ * Interactions that genuinely have no correct-response concept
+ * (extended-text, upload, media) should extend `Interaction` directly
+ * and omit this mixin.
+ */
+declare const CorrectResponseMixin: <T extends AbstractConstructor$2<Interaction>>(superClass: T) => AbstractConstructor$2<CorrectResponseInterface> & T;
+/** Public type surface exposed by `CorrectResponseMixin`. */
+interface CorrectResponseInterface {
+    correctResponseAttr: ResponseValue;
+    showCorrectResponse: boolean;
+    showFullCorrectResponse: boolean;
+    showCandidateCorrection: boolean;
+    isFullCorrectResponse: boolean;
+    correctResponse: Readonly<string | string[] | null>;
+    readonly correctness: Readonly<Correctness | null>;
+    readonly correctionPart: string;
+    toggleCorrectResponse(show: boolean): void;
+    toggleCandidateCorrection(show: boolean): void;
+    /** Protected at runtime; exposed here so subclasses can call `super.toggleInternalCorrectResponse()`. */
+    toggleInternalCorrectResponse(show: boolean): void;
+    /** Protected at runtime. */
+    toggleFullCorrectResponse(show: boolean): Promise<void>;
+    /** Protected at runtime; declared here so a subclass can `override` it. */
+    readonly withholdsFullCorrectResponseWhenCorrect: boolean;
+}
+
+/**
+ * The candidate-correction badge shared by correction-package elements.
+ *
+ * The component decides where the badge sits in the markup — last, after the label — and how big
+ * its box is. It decides nothing about how it looks. The disc, the tick, the cross, and whether it
+ * is lifted out of flow at all are the theme's, keyed on ::part(correction-correct) /
+ * ::part(correction-incorrect).
+ *
+ * It replaces six implementations of one idea: four ::after glyph blocks in kennisnet, an
+ * ::before/::after pair in order-interaction, and a .correct-option span that gap-match and match
+ * built in JavaScript with inline styles. Several of those set margin-left and width inside a
+ * :state(candidate-*) rule — a transient state doing layout, which is the bug this contract exists
+ * to prevent.
+ *
+ * Reachable everywhere. A chip has three homes, and inside a drop target's shadow root the document
+ * cannot see its badge: parts do not chain, so ::part(drag)::part(correction) is inert. A part
+ * token survives exportparts, so one bare ::part(correction-correct) reaches the badge in the drag
+ * bank, on the floating clone, and inside a gap. Verified in Chromium.
+ *
+ * Deliberately not anchored, and not absolutely positioned. Both were tried; both left
+ * qti-choice-interaction unable to reach layout stability, and the VRT stability detector spent 20
+ * seconds waiting before capturing a half-settled frame. A theme that wants a corner badge can
+ * position ::part(correction-correct) itself — it is a part, that is the point.
+ */
+declare const correctionPart: lit.CSSResult;
+
+type AbstractConstructor$1<T = {}> = abstract new (...args: any[]) => T;
+declare const CandidateCorrectionMixin: <T extends AbstractConstructor$1<Interaction>>(superClass: T) => AbstractConstructor$1<CorrectResponseInterface> & T;
+
+type AbstractConstructor<T = {}> = abstract new (...args: any[]) => T;
+type ChoicesCorrectionBase = Interaction & {
+    readonly response: string | string[] | null;
+    readonly internals: ElementInternals;
+};
+/** Adds per-choice candidate marking to interactions built on `ChoicesMixin`. */
+declare const ChoiceCorrectionMixin: <T extends AbstractConstructor<ChoicesCorrectionBase>>(superClass: T) => AbstractConstructor<CorrectResponseInterface> & T;
+
+/** Presentation policy understood by correction-capable elements. */
+type CorrectResponseMode = 'internal' | 'full';
+interface CorrectionConfig {
+    correctResponseMode?: CorrectResponseMode;
+    fullCorrectResponseOnlyWhenIncorrect?: boolean;
+}
+
+type CandidateCorrection = 'correct' | 'incorrect' | 'partially-correct' | null;
+interface ActiveElementCorrectionInterface {
+    candidateCorrection: CandidateCorrection;
+    readonly correctionPart: string;
+}
+
+declare const QtiGapTextCorrection_base: (abstract new (...args: any[]) => ActiveElementCorrectionInterface) & typeof QtiGapText;
+declare class QtiGapTextCorrection extends QtiGapTextCorrection_base {
+    static styles: lit.CSSResultGroup[];
+    render(): lit.TemplateResult<1>;
+}
+
+declare const QtiHotspotChoiceCorrection_base: (abstract new (...args: any[]) => ActiveElementCorrectionInterface) & typeof QtiHotspotChoice;
+declare class QtiHotspotChoiceCorrection extends QtiHotspotChoiceCorrection_base {
+    orderCorrect: number | null;
+}
+
+declare const QtiHottextCorrection_base: (abstract new (...args: any[]) => ActiveElementCorrectionInterface) & typeof QtiHottext;
+declare class QtiHottextCorrection extends QtiHottextCorrection_base {
+    static styles: lit.CSSResultGroup[];
+    render(): lit.TemplateResult<1>;
+}
+
+declare const QtiSimpleAssociableChoiceCorrection_base: (abstract new (...args: any[]) => ActiveElementCorrectionInterface) & typeof QtiSimpleAssociableChoice;
+declare class QtiSimpleAssociableChoiceCorrection extends QtiSimpleAssociableChoiceCorrection_base {
+    static styles: lit.CSSResultGroup[];
+    render(): lit.TemplateResult<1>;
+}
+
+declare const QtiSimpleChoiceCorrection_base: (abstract new (...args: any[]) => ActiveElementCorrectionInterface) & typeof QtiSimpleChoice;
+declare class QtiSimpleChoiceCorrection extends QtiSimpleChoiceCorrection_base {
+    static styles: lit.CSSResultGroup[];
+    render(): lit.TemplateResult<1>;
+}
+
+/** Assessment-item extension that coordinates correction-capable interactions. */
+declare class QtiAssessmentItemCorrection extends QtiAssessmentItem {
+    showCorrectResponse(show: boolean): void;
+    showCandidateCorrection(show: boolean): void;
+    protected afterResponseVariableUpdated(): void;
+    private updateControlState;
+}
+
+/** Item host extension that handles correction controls and mode changes. */
+declare class QtiItemCorrection extends QtiItem {
+    #private;
+    constructor();
+    private updateControlState;
+    disconnectedCallback(): void;
+}
+
+/** Test navigation extension that routes correction controls to the active item. */
+declare class TestNavigationCorrection extends TestNavigation {
+    #private;
+    constructor();
+    disconnectedCallback(): void;
+}
+/** Test host extension that shows correct responses in scorer view. */
+declare class QtiTestCorrection extends QtiTest {
+    updateAssessmentItemView(assessmentItem: QtiAssessmentItem$1, view: View): void;
+}
+/** Check-item extension that reveals the correct response after scoring. */
+declare class TestCheckItemCorrection extends TestCheckItem {
+    constructor();
+}
+
+declare class ItemCorrectResponseMode extends LitElement {
+    #private;
+    private itemContext;
+    label: string;
+    private _options;
+    render(): lit.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'item-correct-response-mode': ItemCorrectResponseMode;
+    }
+}
+
+declare class ItemShowCandidateCorrection extends LitElement {
+    #private;
+    computedContext?: ComputedItemContext;
+    static styles: lit.CSSResult;
+    shown: boolean;
+    disabled: boolean;
+    showCandidateCorrectionText: string;
+    hideCandidateCorrectionText: string;
+    noCorrectResponseText: string;
+    constructor();
+    updated(): void;
+    render(): lit.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'item-show-candidate-correction': ItemShowCandidateCorrection;
+    }
+}
+
+declare class ItemShowCorrectResponse extends LitElement {
+    #private;
+    computedContext?: ComputedItemContext;
+    static styles: lit.CSSResult;
+    shown: boolean;
+    disabled: boolean;
+    showCorrectText: string;
+    hideCorrectText: string;
+    noCorrectResponseText: string;
+    updated(): void;
+    render(): lit.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'item-show-correct-response': ItemShowCorrectResponse;
+    }
+}
+
+/**
+ * @deprecated test-show-correct-response is deprecated and will be removed in the future.
+ */
+declare class TestShowCorrectResponse extends LitElement {
+    #private;
+    computedContext?: ComputedContext;
+    static styles: lit.CSSResult;
+    shown: boolean;
+    disabled: boolean;
+    showCorrectText: string;
+    hideCorrectText: string;
+    noCorrectResponseText: string;
+    willUpdate(_changedProperties: Map<string | number | symbol, unknown>): void;
+    render(): lit.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'test-show-correct-response': TestShowCorrectResponse;
+    }
+}
+
+declare const QtiAssociateInteractionCorrection_base: (abstract new (...args: any[]) => CorrectResponseInterface) & typeof QtiAssociateInteraction;
+declare class QtiAssociateInteractionCorrection extends QtiAssociateInteractionCorrection_base {
+}
+
+declare const QtiChoiceInteractionCorrection_base: (abstract new (...args: any[]) => CorrectResponseInterface) & typeof QtiChoiceInteraction;
+/**
+ * Correction-capable `qti-choice-interaction` implementation.
+ *
+ * It is registered under the standard tag only inside a correction registry;
+ * the standard package constructor remains correction-free.
+ */
+declare class QtiChoiceInteractionCorrection extends QtiChoiceInteractionCorrection_base {
+}
+
+declare const QtiExtendedTextInteractionCorrection_base: (abstract new (...args: any[]) => ActiveElementCorrectionInterface) & typeof QtiExtendedTextInteraction;
+/**
+ * Extended-text, judged from OUTSIDE.
+ *
+ * Every other correction class in this folder derives its verdict: it is handed a `correct-response`
+ * and compares. Extended-text cannot — the response is free prose, there is nothing to compare it
+ * to, and that is exactly why the base component extends `Interaction` directly and carries no
+ * correction machinery (correct-response.mixin.ts says so for extended-text, upload and media).
+ *
+ * But an extended-text answer is still judged; just not here. A teacher, a marking service, or an app
+ * that already knows the score decides, and then has to tell the component. This class is that
+ * channel and nothing more: it computes no correctness, it only accepts one.
+ *
+ * Hence `ActiveElementCorrectionMixin` rather than `CandidateCorrectionMixin`. The two are otherwise
+ * the same bookkeeping — clear the three `candidate-*` states, add one, expose `correctionPart` — but
+ * `CandidateCorrectionMixin` sits on top of `CorrectResponseMixin` and drives everything off a
+ * computed `correctness` getter with no setter. `ActiveElementCorrectionMixin` is the settable one,
+ * written for chips whose parent interaction pushes a verdict into them. An externally-graded essay
+ * is the same shape: something else knows the answer.
+ *
+ * Two consequences worth knowing:
+ *
+ *   - The `item-show-candidate-correction` button will not drive this. It disables itself unless a
+ *     response variable declares a correctResponse / mapping / areaMapping, which a prose item never
+ *     does. Correct: the verdict comes from the host application, which sets the attribute.
+ *   - The verdict survives typing. It is a property, not the `showCandidateCorrection` toggle, so
+ *     `afterResponseVariableUpdated()` does not clear it. If a stale grade should be dropped when the
+ *     candidate edits their answer, that is an explicit decision for the host app to make.
+ */
+declare class QtiExtendedTextInteractionCorrection extends QtiExtendedTextInteractionCorrection_base {
+    static styles: lit.CSSResultGroup[];
+    /**
+     * The verdict, pushed in from outside: `correct`, `partially-correct`, `incorrect`, or absent.
+     *
+     * `noAccessor` because the mixin already owns the accessor — its setter is what writes the
+     * `:state(candidate-*)` custom states — and Lit would otherwise replace it with a generated one and
+     * silently drop that bookkeeping. Same pattern as the `response` attribute on
+     * qti-inline-choice-interaction and qti-slider-interaction.
+     */
+    candidateCorrection: CandidateCorrection;
+    /** The badge goes between the field and the validation message; everything else is the base's. */
+    render(): lit.TemplateResult<1>;
+}
+
+declare const QtiGapMatchInteractionCorrection_base: (abstract new (...args: any[]) => CorrectResponseInterface) & typeof QtiGapMatchInteraction;
+declare class QtiGapMatchInteractionCorrection extends QtiGapMatchInteractionCorrection_base {
+    toggleCandidateCorrection(show: boolean): void;
+}
+
+declare const QtiGraphicAssociateInteractionCorrection_base: (abstract new (...args: any[]) => CorrectResponseInterface) & typeof QtiGraphicAssociateInteraction;
+declare class QtiGraphicAssociateInteractionCorrection extends QtiGraphicAssociateInteractionCorrection_base {
+    #private;
+    toggleInternalCorrectResponse(show: boolean): void;
+    protected renderSupplementalLines(): unknown;
+}
+
+declare const QtiGraphicGapMatchInteractionCorrection_base: (abstract new (...args: any[]) => CorrectResponseInterface) & typeof QtiGraphicGapMatchInteraction;
+declare class QtiGraphicGapMatchInteractionCorrection extends QtiGraphicGapMatchInteractionCorrection_base {
+}
+
+type OrderedHotspot = Choice & {
+    order: number | null;
+};
+declare const QtiGraphicOrderInteractionCorrection_base: (abstract new (...args: any[]) => CorrectResponseInterface) & typeof QtiGraphicOrderInteraction;
+declare class QtiGraphicOrderInteractionCorrection extends QtiGraphicOrderInteractionCorrection_base {
+    protected resolvePinColor(choice: OrderedHotspot): string;
+    toggleInternalCorrectResponse(show: boolean): void;
+    toggleCandidateCorrection(show: boolean): void;
+}
+
+declare const QtiHotspotInteractionCorrection_base: (abstract new (...args: any[]) => CorrectResponseInterface) & typeof QtiHotspotInteraction;
+declare class QtiHotspotInteractionCorrection extends QtiHotspotInteractionCorrection_base {
+}
+
+declare const QtiHottextInteractionCorrection_base: (abstract new (...args: any[]) => CorrectResponseInterface) & typeof QtiHottextInteraction;
+declare class QtiHottextInteractionCorrection extends QtiHottextInteractionCorrection_base {
+}
+
+declare const QtiInlineChoiceInteractionCorrection_base: (abstract new (...args: any[]) => CorrectResponseInterface) & typeof QtiInlineChoiceInteraction;
+declare class QtiInlineChoiceInteractionCorrection extends QtiInlineChoiceInteractionCorrection_base {
+    static get styles(): (lit.CSSResult | lit.CSSResultGroup[])[];
+    /**
+     * Internal mode defers to the full correct response, exactly as text-entry does.
+     *
+     * There is no room beside a dropdown for an answer key: the interaction sits inside a line of
+     * running text, so a marker next to the field competes with the sentence around it, and when the
+     * candidate happened to pick the correct option it printed the same word twice. The full variant
+     * puts the key in a `div.full-correct-response-inline` after the field instead — one already-themed
+     * presentation for both inline interactions rather than a second one only these two use.
+     *
+     * `super` is deliberately not called: its `show-correct-response` host state paints the dashed
+     * outline in qti-states.css, and this element is no longer the thing presenting the key — the
+     * wrapper beside it is. Leaving the state off keeps internal mode looking identical to an item
+     * authored with `show-full-correct-response`.
+     *
+     * The guard stops the two entry points rendering two wrappers: `showFullCorrectResponse` has its
+     * own watcher, so with both flags set this would otherwise run a second time.
+     */
+    toggleInternalCorrectResponse(show: boolean): void;
+    /**
+     * The key is shown whether or not the candidate was right.
+     *
+     * The base withholds it from a correct candidate, on the reasoning that their answer already is
+     * the key. That reasoning does not survive contact with this element: asking for the correct
+     * response and being shown nothing is indistinguishable from the feature being broken, and it is
+     * the only inline interaction where the answer and the key are the same short phrase, so there is
+     * no visual clue either. Show it, and let the correctness badge say who was right.
+     */
+    get withholdsFullCorrectResponseWhenCorrect(): boolean;
+    /** The badge trails the validation message; everything else is the base's. */
+    render(): lit.TemplateResult<1>;
+}
+
+declare const QtiMatchInteractionCorrection_base: (abstract new (...args: any[]) => CorrectResponseInterface) & typeof QtiMatchInteraction;
+declare class QtiMatchInteractionCorrection extends QtiMatchInteractionCorrection_base {
+    #private;
+    toggleCandidateCorrection(show: boolean): void;
+    protected getCellStateVariant(value: string, checked: boolean): string;
+}
+
+declare const QtiOrderInteractionCorrection_base: (abstract new (...args: any[]) => CorrectResponseInterface) & typeof QtiOrderInteraction;
+declare class QtiOrderInteractionCorrection extends QtiOrderInteractionCorrection_base {
+    toggleCandidateCorrection(show: boolean): void;
+}
+
+declare const QtiPortableCustomInteractionCorrection_base: (abstract new (...args: any[]) => CorrectResponseInterface) & typeof QtiPortableCustomInteraction;
+declare class QtiPortableCustomInteractionCorrection extends QtiPortableCustomInteractionCorrection_base {
+    toggleInternalCorrectResponse(show: boolean): void;
+}
+
+declare const QtiSelectPointInteractionCorrection_base: (abstract new (...args: any[]) => CorrectResponseInterface) & typeof QtiSelectPointInteraction;
+declare class QtiSelectPointInteractionCorrection extends QtiSelectPointInteractionCorrection_base {
+    #private;
+    static styles: lit.CSSResultGroup[];
+    toggleCandidateCorrection(show: boolean): void;
+    toggleInternalCorrectResponse(show: boolean): void;
+    protected pointPart(_point: string, index: number): string;
+    protected renderSupplementalLayer(): unknown;
+    protected updated(changedProperties: Map<string | number | symbol, unknown>): void;
+}
+
+declare const QtiSliderInteractionCorrection_base: (abstract new (...args: any[]) => CorrectResponseInterface) & typeof QtiSliderInteraction;
+declare class QtiSliderInteractionCorrection extends QtiSliderInteractionCorrection_base {
+    #private;
+    static styles: lit.CSSResultGroup[];
+    toggleInternalCorrectResponse(show: boolean): void;
+    protected renderRailSupplement(): unknown;
+}
+
+declare const QtiTextEntryInteractionCorrection_base: (abstract new (...args: any[]) => CorrectResponseInterface) & typeof QtiTextEntryInteraction;
+declare class QtiTextEntryInteractionCorrection extends QtiTextEntryInteractionCorrection_base {
+    static styles: lit.CSSResultGroup[];
+    get correctness(): Readonly<Correctness | null>;
+    toggleInternalCorrectResponse(show: boolean): void;
+    /** The badge goes between the field and the validation message; everything else is the base's. */
+    render(): lit.TemplateResult<1>;
+}
+
+export { CandidateCorrectionMixin, ChoiceCorrectionMixin, type CorrectResponseInterface, CorrectResponseMixin, type CorrectResponseMode, type CorrectionConfig, Correctness, ItemCorrectResponseMode, ItemShowCandidateCorrection, ItemShowCorrectResponse, QtiAssessmentItemCorrection, QtiAssociateInteractionCorrection, QtiChoiceInteractionCorrection, QtiExtendedTextInteractionCorrection, QtiGapMatchInteractionCorrection, QtiGapTextCorrection, QtiGraphicAssociateInteractionCorrection, QtiGraphicGapMatchInteractionCorrection, QtiGraphicOrderInteractionCorrection, QtiHotspotChoiceCorrection, QtiHotspotInteractionCorrection, QtiHottextCorrection, QtiHottextInteractionCorrection, QtiInlineChoiceInteractionCorrection, QtiItemCorrection, QtiMatchInteractionCorrection, QtiOrderInteractionCorrection, QtiPortableCustomInteractionCorrection, QtiSelectPointInteractionCorrection, QtiSimpleAssociableChoiceCorrection, QtiSimpleChoiceCorrection, QtiSliderInteractionCorrection, QtiTestCorrection, QtiTextEntryInteractionCorrection, TestCheckItemCorrection, TestNavigationCorrection, TestShowCorrectResponse, correctionPart };

package/dist/corrections.js

@@ -0,0 +1,84 @@
+import {
+  CandidateCorrectionMixin,
+  ChoiceCorrectionMixin,
+  CorrectResponseMixin,
+  Correctness,
+  ItemCorrectResponseMode,
+  ItemShowCandidateCorrection,
+  ItemShowCorrectResponse,
+  QtiAssessmentItemCorrection,
+  QtiAssociateInteractionCorrection,
+  QtiChoiceInteractionCorrection,
+  QtiExtendedTextInteractionCorrection,
+  QtiGapMatchInteractionCorrection,
+  QtiGapTextCorrection,
+  QtiGraphicAssociateInteractionCorrection,
+  QtiGraphicGapMatchInteractionCorrection,
+  QtiGraphicOrderInteractionCorrection,
+  QtiHotspotChoiceCorrection,
+  QtiHotspotInteractionCorrection,
+  QtiHottextCorrection,
+  QtiHottextInteractionCorrection,
+  QtiInlineChoiceInteractionCorrection,
+  QtiItemCorrection,
+  QtiMatchInteractionCorrection,
+  QtiOrderInteractionCorrection,
+  QtiPortableCustomInteractionCorrection,
+  QtiSelectPointInteractionCorrection,
+  QtiSimpleAssociableChoiceCorrection,
+  QtiSimpleChoiceCorrection,
+  QtiSliderInteractionCorrection,
+  QtiTestCorrection,
+  QtiTextEntryInteractionCorrection,
+  TestCheckItemCorrection,
+  TestNavigationCorrection,
+  TestShowCorrectResponse,
+  correctionPart
+} from "./chunk-XU7HNT4F.js";
+import "./chunk-RXGDQDOV.js";
+import "./chunk-WVVMNF74.js";
+import "./chunk-F4BNJWYN.js";
+import "./chunk-X3E5HXG2.js";
+import "./chunk-QECOPVPO.js";
+import "./chunk-7HC5SMCU.js";
+import "./chunk-64XSIBGO.js";
+import "./chunk-IJD53WY6.js";
+import "./chunk-H3J7LFRO.js";
+export {
+  CandidateCorrectionMixin,
+  ChoiceCorrectionMixin,
+  CorrectResponseMixin,
+  Correctness,
+  ItemCorrectResponseMode,
+  ItemShowCandidateCorrection,
+  ItemShowCorrectResponse,
+  QtiAssessmentItemCorrection,
+  QtiAssociateInteractionCorrection,
+  QtiChoiceInteractionCorrection,
+  QtiExtendedTextInteractionCorrection,
+  QtiGapMatchInteractionCorrection,
+  QtiGapTextCorrection,
+  QtiGraphicAssociateInteractionCorrection,
+  QtiGraphicGapMatchInteractionCorrection,
+  QtiGraphicOrderInteractionCorrection,
+  QtiHotspotChoiceCorrection,
+  QtiHotspotInteractionCorrection,
+  QtiHottextCorrection,
+  QtiHottextInteractionCorrection,
+  QtiInlineChoiceInteractionCorrection,
+  QtiItemCorrection,
+  QtiMatchInteractionCorrection,
+  QtiOrderInteractionCorrection,
+  QtiPortableCustomInteractionCorrection,
+  QtiSelectPointInteractionCorrection,
+  QtiSimpleAssociableChoiceCorrection,
+  QtiSimpleChoiceCorrection,
+  QtiSliderInteractionCorrection,
+  QtiTestCorrection,
+  QtiTextEntryInteractionCorrection,
+  TestCheckItemCorrection,
+  TestNavigationCorrection,
+  TestShowCorrectResponse,
+  correctionPart
+};
+//# sourceMappingURL=corrections.js.map

package/dist/elements.d.ts

@@ -1,9 +1,9 @@
 import * as lit from 'lit';
 import { LitElement, CSSResultGroup, PropertyValueMap } from 'lit';
-import { g as VariableValue, R as ResponseInteraction, f as ResponseVariable, b as OutcomeVariable, V as VariableDeclaration, C as Calculate, B as BaseType, a as Cardinality, T as TemplateVariable } from './variables-CMYcDbyW.js';
-import { I as ItemContext } from './item.context-CkUeDcaO.js';
-import { Q as QtiFeedback, a as QtiVariableDeclaration } from './qti-feedback-ChmXhZuf.js';
-import { Q as QtiRuleBase } from './qti-rule-base-ajOnfGXY.js';
+import { g as VariableValue, I as ItemContext, R as ResponseInteraction, f as ResponseVariable, b as OutcomeVariable, V as VariableDeclaration, C as Calculate, B as BaseType, a as Cardinality, T as TemplateVariable } from './item.types.d-QU7LljEK.js';
+import { a as RegisteredInteraction } from './interaction.interface.d-CvjHM2bi.js';
+import { Q as QtiFeedback, a as QtiVariableDeclaration } from './qti-feedback.d-DZbad0RN.js';
+import { Q as QtiRuleBase } from './qti-rule-base.d-ajOnfGXY.js';
 
 /**
  * @summary The qti-assessment-item element contains all the other QTI 3 item structures.
@@ -38,26 +38,20 @@ declare class QtiAssessmentItem extends LitElement {
     set variables(value: VariableValue<string | string[] | null>[]);
     get state(): ItemContext['state'];
     set state(value: ItemContext['state']);
+    /** Registered candidate-input interactions. Correction packages may extend their presentation behavior. */
+    protected interactionElements: RegisteredInteraction[];
     /** @deprecated use variables property instead */
     set responses(myResponses: ResponseInteraction[]);
     render(): lit.TemplateResult<1>;
     connectedCallback(): void;
     disconnectedCallback(): void;
-    /**
-     * Toggles the display of correct responses for all interactions.
-     * @param show - A boolean indicating whether to show or hide correct responses.
-     */
-    showCorrectResponse(show: boolean): void;
-    /**
-     * Toggles the display of the candidate correction for all interactions.
-     * @param show - A boolean indicating whether to show or hide candidate correction.
-     */
-    showCandidateCorrection(show: boolean): void;
     processResponse(countNumAttempts?: boolean, reportValidityAfterScoring?: boolean): boolean;
     resetResponses(): void;
     protected getResponse(identifier: string): Readonly<ResponseVariable>;
     getOutcome(identifier: string): Readonly<OutcomeVariable>;
     protected getVariable(identifier: string): Readonly<VariableDeclaration<string | string[] | null>>;
+    /** Extension point for presentation packages reacting to a candidate response change. */
+    protected afterResponseVariableUpdated(): void;
     /**
      * Updates the response variable with the specified identifier to the given value.
      *

package/dist/elements.js

@@ -1,3 +1,4 @@
+import "./chunk-V5G7X53Y.js";
 import {
   QtiAssessmentItem,
   QtiAssessmentStimulusRef,
@@ -18,11 +19,11 @@ import {
   QtiTemplateConstraint,
   QtiTemplateDeclaration,
   QtiTemplateProcessing
-} from "./chunk-WDO2TRFM.js";
-import "./chunk-FLJAKWXL.js";
-import "./chunk-3WBG257S.js";
-import "./chunk-3XV26R5M.js";
-import "./chunk-QXBXORM3.js";
+} from "./chunk-WVVMNF74.js";
+import "./chunk-X3E5HXG2.js";
+import "./chunk-64XSIBGO.js";
+import "./chunk-IJD53WY6.js";
+import "./chunk-H3J7LFRO.js";
 export {
   QtiAssessmentItem,
   QtiAssessmentStimulusRef,