@citolab/qti-components 8.0.0 → 8.0.1

package/dist/elements.d.ts

@@ -1 +1,393 @@
-export * from '@qti-components/elements';
+import * as lit from 'lit';
+import { LitElement, CSSResultGroup, PropertyValueMap } from 'lit';
+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.
+ * @documentation https://www.imsglobal.org/spec/qti/v3p0/impl#h.dltnnj87l0yj
+ *
+ * @dependency qti-feedback
+ * @dependency qti-responseprocessing
+ *
+ * @event qti-item-context-updated - Emitted when through a user action the itemContext is updated,
+ * typically on interaction with the interactions, or calling response processing.
+ */
+declare class QtiAssessmentItem extends LitElement {
+    #private;
+    identifier: string;
+    adaptive: 'true' | 'false';
+    timeDependent: 'true' | 'false' | null;
+    get title(): string;
+    set title(value: string);
+    disabled: boolean;
+    protected _handleDisabledChange: (_: boolean, disabled: boolean) => void;
+    readonly: boolean;
+    protected _handleReadonlyChange: (_: boolean, readonly: boolean) => void;
+    private _context;
+    /**
+     * Sets the identifier for the assessment item reference if this item is in a test.
+     *
+     * @param identifier - The identifier for the assessment item reference.
+     */
+    set assessmentItemRefId(identifier: string);
+    get assessmentItemRefId(): string;
+    get variables(): VariableValue<string | string[] | null>[];
+    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;
+    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.
+     *
+     * @protected
+     *
+     * This method is intended for internal use within the class and subclasses.
+     * It should not be called externally by third parties.
+     *
+     * @param identifier - The identifier of the response variable to update.
+     * @param value - The new value for the response variable.
+     */
+    updateResponseVariable(identifier: string, value: string | string[] | undefined): void;
+    /**
+     * Updates the template variable with the specified identifier to the given value.
+     */
+    updateTemplateVariable(identifier: string, value: string | string[] | undefined): void;
+    /**
+     * Updates the correct response for the specified response variable.
+     */
+    updateCorrectResponse(identifier: string, value: string | string[] | undefined): void;
+    setOutcomeVariable(identifier: string, value: string | string[] | undefined): void;
+    /**
+     * Updates the outcome variable with the specified identifier to the given value.
+     *
+     * @protected
+     *
+     * This method is intended for internal use within the class and subclasses.
+     * It should not be called externally by third parties.
+     *
+     * @param identifier - The identifier of the response variable to update.
+     * @param value - The new value for the response variable.
+     */
+    updateOutcomeVariable(identifier: string, value: string | string[] | undefined): void;
+    validate(reportValidity?: boolean): boolean;
+    reportValidity(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-assessment-item': QtiAssessmentItem;
+    }
+}
+
+declare class QtiAssessmentStimulusRefConnectedEvent extends Event {
+    element: QtiAssessmentStimulusRef;
+    item: QtiAssessmentItem;
+    static eventName: string;
+    constructor(element: QtiAssessmentStimulusRef, item: QtiAssessmentItem);
+}
+/**
+ * Represents a custom element for referencing an assessment stimulus.
+ */
+declare class QtiAssessmentStimulusRef extends LitElement {
+    identifier: string;
+    href: string;
+    /**
+     * Lifecycle method called when the element is connected to the DOM.
+     * First checks if there's a data-stimulus-idref element. If found, loads the stimulus directly.
+     * If not found, delegates to the delivery platform via an event.
+     */
+    connectedCallback(): Promise<void>;
+    /**
+     * Loads and appends the stimulus to the specified element.
+     * @param stimulusRef - The element to which the stimulus will be appended.
+     */
+    updateStimulusRef(stimulusRef: Element): Promise<void>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-assessment-stimulus-ref': QtiAssessmentStimulusRef;
+    }
+}
+
+declare class QtiCompanionMaterialsInfo extends LitElement {
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-companion-materials-info': QtiCompanionMaterialsInfo;
+    }
+}
+
+/**
+ * https://www.imsglobal.org/spec/qti/v3p0/impl#h.fi29q8dubjgw
+ * <qti-custom-operator class="js.org">
+        <qti-base-value base-type="string"><![CDATA[
+          console.log(context.variables);
+          return 'B'
+          document.querySelector('qti-end-attempt-interaction').disabled = true;
+          ]]></qti-base-value>
+      </qti-custom-operator>
+    </qti-set-outcome-value>
+ */
+declare class QtiCustomOperator extends LitElement implements Calculate {
+    #private;
+    private _context?;
+    render(): lit.TemplateResult<1>;
+    handleSlotChange(): void;
+    calculate(): any;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-custom-operator': QtiCustomOperator;
+    }
+}
+
+declare class QtiFeedbackBlock extends QtiFeedback {
+    static styles: lit.CSSResult;
+    render(): lit.TemplateResult<1>;
+    connectedCallback(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-feedback-block': QtiFeedbackBlock;
+    }
+}
+
+declare class QtiFeedbackInline extends QtiFeedback {
+    static styles: lit.CSSResult;
+    render: () => lit.TemplateResult<1>;
+    connectedCallback(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-feedback-inline': QtiFeedbackInline;
+    }
+}
+
+declare class QtiModalFeedback extends QtiFeedback {
+    static styles: lit.CSSResult;
+    render(): lit.TemplateResult<1>;
+    openFeedback(): void;
+    closeFeedback(): void;
+    connectedCallback(): void;
+    protected updated(changedProperties: Map<string | number | symbol, unknown>): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-modal-feedback': QtiModalFeedback;
+    }
+}
+
+/**
+ * @summary The qti-item-body node contains the text, graphics, media objects and interactions that describe the item's content and information about how it is structured.
+ * @documentation https://www.imsglobal.org/spec/qti/v3p0/impl#h.sphpo6lu6zqi
+ * @status stable
+ * @since 4.0
+ *
+ * @slot - item body content.
+ * @slot qti-rubric-block - the qti rubric block is placed above the item
+ * @part qti-rubric-block - the qti rubric block part
+ */
+declare class QtiItemBody extends LitElement {
+    static styles: CSSResultGroup;
+    render(): lit.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-item-body': QtiItemBody;
+    }
+}
+
+declare class QtiContentBody extends LitElement {
+    #private;
+    protected context?: ItemContext;
+    render(): lit.TemplateResult<1>;
+    connectedCallback(): void;
+    protected updated(changedProperties: Map<string | number | symbol, unknown>): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-content-body': QtiContentBody;
+    }
+}
+
+declare class QtiRubricBlock extends LitElement {
+    id: string;
+    use: 'instructions' | 'scoring' | 'navigation';
+    view: 'author' | 'candidate' | 'proctor' | 'scorer' | 'testConstructor' | 'tutor';
+    classNames: string;
+    handleclassNamesChange(): void;
+    static styles: lit.CSSResult;
+    render(): lit.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-rubric-block': QtiRubricBlock;
+    }
+}
+
+declare class QtiStylesheet extends LitElement {
+    #private;
+    protected firstUpdated(_changedProperties: PropertyValueMap<any> | Map<PropertyKey, unknown>): void;
+    disconnectedCallback(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-stylesheet': QtiStylesheet;
+    }
+}
+
+declare class QtiResponseDeclaration extends QtiVariableDeclaration {
+    #private;
+    baseType: BaseType;
+    identifier: string;
+    cardinality: Cardinality;
+    itemContext?: ItemContext;
+    static styles: lit.CSSResult[];
+    render(): lit.TemplateResult<1>;
+    connectedCallback(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-response-declaration': QtiResponseDeclaration;
+    }
+}
+
+declare class QtiOutcomeDeclaration extends QtiVariableDeclaration {
+    baseType: BaseType;
+    externalScored: 'human' | 'externalMachine' | null;
+    identifier: string;
+    cardinality: Cardinality;
+    itemContext?: ItemContext;
+    static styles: lit.CSSResult[];
+    render(): lit.TemplateResult<1>;
+    get interpolationTable(): Map<number, number> | null;
+    connectedCallback(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-outcome-declaration': QtiOutcomeDeclaration;
+    }
+}
+
+declare class QtiResponseProcessing extends LitElement {
+    #private;
+    static styles: lit.CSSResult[];
+    render(): lit.TemplateResult<1>;
+    process(): void;
+    firstUpdated(_changedProperties: PropertyValueMap<any> | Map<PropertyKey, unknown>): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-response-processing': QtiResponseProcessing;
+    }
+}
+
+/**
+ * @summary The qti-template-declaration element declares template variables for item cloning.
+ * @documentation https://www.imsglobal.org/spec/qti/v3p0/impl#h.template-declaration
+ */
+declare class QtiTemplateDeclaration extends LitElement {
+    #private;
+    identifier: string;
+    cardinality: 'single' | 'multiple' | 'ordered' | 'record';
+    baseType: BaseType;
+    mathVariable: boolean;
+    paramVariable: boolean;
+    static styles: lit.CSSResult[];
+    render(): lit.TemplateResult<1>;
+    connectedCallback(): void;
+    /**
+     * Get the template variable definition
+     */
+    getTemplateVariable(): TemplateVariable;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-template-declaration': QtiTemplateDeclaration;
+    }
+}
+
+/**
+ * @summary The qti-template-processing element contains template processing rules.
+ * @documentation https://www.imsglobal.org/spec/qti/v3p0/impl#h.template-processing
+ */
+declare class QtiTemplateProcessing extends LitElement {
+    #private;
+    static styles: lit.CSSResult[];
+    render(): lit.TemplateResult<1>;
+    /**
+     * Process template rules to set template variable values
+     */
+    process(): void;
+    firstUpdated(_changedProperties: PropertyValueMap<any> | Map<PropertyKey, unknown>): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-template-processing': QtiTemplateProcessing;
+    }
+}
+
+/**
+ * @summary The qti-template-constraint element is a processing rule available only in Template Processing.
+ * @documentation https://www.imsglobal.org/spec/qti/v3p0/impl#h.template-constraint
+ *
+ * It terminates Template Processing and re-runs it from the beginning if the condition
+ * specified in the template constraint is not satisfied. This can be used to iterate
+ * the Template Processing with different randomly-generated values until a predetermined
+ * condition is satisfied.
+ */
+declare class QtiTemplateConstraint extends LitElement implements QtiRuleBase {
+    render(): lit.TemplateResult<1>;
+    /**
+     * Evaluates the constraint condition
+     * @returns true if constraint is satisfied, false if template processing should restart
+     */
+    calculate(): boolean;
+    /**
+     * Template constraints don't have sub-rules like conditions
+     */
+    getSubRules(): QtiRuleBase[];
+    /**
+     * Process the template constraint
+     * @returns true if constraint is satisfied, false if template processing should restart
+     */
+    process(): boolean;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-template-constraint': QtiTemplateConstraint;
+    }
+}
+
+/**
+ * @summary The qti-context-declaration element declares context variables for an item.
+ * @documentation https://www.imsglobal.org/spec/qti/v3p0/impl#h.qti-context-declaration
+ */
+declare class QtiContextDeclaration extends LitElement {
+    identifier: string;
+    cardinality: 'single' | 'multiple' | 'ordered' | 'record';
+    static styles: lit.CSSResult[];
+    render(): lit.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-context-declaration': QtiContextDeclaration;
+    }
+}
+
+export { QtiAssessmentItem, QtiAssessmentStimulusRef, QtiAssessmentStimulusRefConnectedEvent, QtiCompanionMaterialsInfo, QtiContentBody, QtiContextDeclaration, QtiCustomOperator, QtiFeedbackBlock, QtiFeedbackInline, QtiItemBody, QtiModalFeedback, QtiOutcomeDeclaration, QtiResponseDeclaration, QtiResponseProcessing, QtiRubricBlock, QtiStylesheet, QtiTemplateConstraint, QtiTemplateDeclaration, QtiTemplateProcessing };

package/dist/index.d.ts

@@ -1,9 +1,58 @@
-export * from '@qti-components/test';
-export * from '@qti-components/item';
-export * from '@qti-components/elements';
-export * from '@qti-components/interactions';
-export * from '@qti-components/transformers';
-export * from '@qti-components/loader';
-export * from '@qti-components/base';
-export * from '@qti-components/processing';
-export * from '@qti-components/corrections';
+export { IMyQtiTest, IQtiTest, ITestNavigationMixin, ITestProcessingMixin, QtiAssessmentItemRef, QtiAssessmentSection, QtiAssessmentTest, QtiOutcomeProcessing, QtiOutcomeProcessingProcessor, QtiTest, QtiTestFeedback, QtiTestPart, QtiTestVariables, QtiTestVariablesExpression, SpeechState, TestCheckItem, TestContainer, TestEndAttempt, TestItemLink, TestItemToSpeech, TestNavigation, TestNext, TestPagingButtonsStamp, TestPrev, TestPrintContext, TestPrintVariables, TestScoringButtons, TestScoringFeedback, TestSectionButtonsStamp, TestSectionLink, TestStamp, TestTtsNext, TestTtsPause, TestTtsPlay, TestTtsPrev, TestTtsResume, TestTtsStop, TestView, TestViewToggle, TtsContext, ttsContext } from './test.js';
+export { ItemContainer, ItemPrintVariables, QtiItem } from './item.js';
+export { QtiAssessmentItem, QtiAssessmentStimulusRef, QtiAssessmentStimulusRefConnectedEvent, QtiCompanionMaterialsInfo, QtiContentBody, QtiContextDeclaration, QtiCustomOperator, QtiFeedbackBlock, QtiFeedbackInline, QtiItemBody, QtiModalFeedback, QtiOutcomeDeclaration, QtiResponseDeclaration, QtiResponseProcessing, QtiRubricBlock, QtiStylesheet, QtiTemplateConstraint, QtiTemplateDeclaration, QtiTemplateProcessing } from './elements.js';
+export { Orientation, QtiAssociateInteraction, QtiChoiceInteraction, QtiCustomInteraction, QtiEndAttemptInteraction, QtiExtendedTextInteraction, QtiGapMatchInteraction, QtiGraphicAssociateInteraction, QtiGraphicGapMatchInteraction, QtiGraphicOrderInteraction, QtiHotspotInteraction, QtiHottextInteraction, QtiInlineChoiceInteraction, QtiMatchInteraction, QtiMediaInteraction, QtiOrderInteraction, QtiPortableCustomInteraction, QtiPositionObjectInteraction, QtiPositionObjectStage, QtiSelectPointInteraction, QtiSliderInteraction, QtiTextEntryInteraction, QtiUploadInteraction, qtiInteractionElements } from './interactions.js';
+export * from '@qti-components/interactions-core/elements/qti-gap-img';
+export * from '@qti-components/interactions-core/elements/qti-gap-text';
+export * from '@qti-components/interactions-core/elements/qti-gap';
+export * from '@qti-components/interactions-core/elements/qti-inline-choice';
+export * from '@qti-components/interactions-core/elements/qti-hottext';
+export * from '@qti-components/interactions-core/elements/qti-simple-associable-choice';
+export * from '@qti-components/interactions-core/elements/qti-simple-choice';
+export * from '@qti-components/interactions-core/elements/qti-hotspot-choice';
+export * from '@qti-components/interactions-core/elements/qti-associable-hotspot';
+export * from '@qti-components/interactions-core/elements/qti-prompt';
+export { M as ModuleResolutionConfig, q as qtiTransformItem, a as qtiTransformTest, t as transformItemApi, b as transformTestApi } from './qti-transform-test.d-BL7GGFJj.js';
+export { qtiTransformManifest } from './transformers.js';
+export { ManifestInfo, getItemByUri, getManifestInfo } from './loader.js';
+export { IsNullOrUndefined, ScoringHelper, boxSizing, computedContext, computedItemContext, convertNumberToUniversalFormat, decimalSeparator, dropRegion, itemContext, removeDoubleSlashes, validationMessage } from './base.js';
+export { C as ComputedItemContext } from './computed-item.types.d-BKZdSLLJ.js';
+export { C as ComputedContext, a as ComputedItem, I as INITIAL_SESSION_CONTEXT, S as SessionContext, V as View, s as sessionContext } from './computed.types.d-rKLSPvVG.js';
+export { C as ConfigContext, V as ValidationDisplayMode, c as configContext } from './config.context.d-BvU9r-Mg.js';
+export { C as ChoiceRole, I as Interaction, a as InteractionContext, i as interactionContext } from './interaction.d-D4MstYRz.js';
+export { B as BaseType, C as Calculate, a as Cardinality, I as ItemContext, M as Multiple, O as Ordered, b as OutcomeVariable, Q as QtiAreaMapEntry, c as QtiAreaMapping, d as QtiMapEntry, e as QtiMapping, R as ResponseInteraction, f as ResponseVariable, T as TemplateVariable, V as VariableDeclaration, g as VariableValue, h as areaShape, i as directedPair, j as float, k as integer, l as itemContextVariables } from './item.types.d-QU7LljEK.js';
+export { Q as QtiContext, a as QtiContextType, S as Seed, b as asSeed, i as isSeed, q as qtiContext } from './qti.context.d-CejJMlfZ.js';
+export { I as INITIAL_TEST_CONTEXT, Q as QtiExpression, a as QtiExpressionBase, T as TestContext, t as testContext } from './qti-expression.d-BietT_8b.js';
+export { Q as QtiFeedback, a as QtiVariableDeclaration } from './qti-feedback.d-DZbad0RN.js';
+export { Q as QtiConditionExpression } from './qti-condition-expression.d-aMvBvpc6.js';
+export { D as DirectedPair, I as Identifier, P as Point, R as ResponseValue, i as iterResponseValues, p as parsePair, a as parsePoint, b as parseResponseAttribute, r as responseAttributeConverter, s as serializePair, c as serializePoint, d as serializeResponseAttribute } from './response.d-_8y4kjGP.js';
+export { F as FormAssociatedInteraction, I as IInteraction, R as ReadonlyInteraction, a as RegisteredInteraction, b as ResettableInteraction, c as ResponseIdentifiedInteraction, d as ResponseInteractionElement, V as ValidatableInteraction } from './interaction.interface.d-CvjHM2bi.js';
+export { Q as QtiRuleBase, a as QtiRuleElement } from './qti-rule-base.d-ajOnfGXY.js';
+export { QtiAnd, QtiAnyN, QtiBaseValue, QtiContainerSize, QtiContains, QtiCorrect, QtiDefault, QtiDelete, QtiDivide, QtiDurationGte, QtiDurationLt, QtiEqual, QtiEqualRounded, QtiFieldValue, QtiGcd, QtiGt, QtiGte, QtiIndex, QtiInside, QtiIntegerDivide, QtiIntegerModulus, QtiIntegerToFloat, QtiIsNull, QtiLcm, QtiLookupOutcomeValue, QtiLt, QtiLte, QtiMapResponse, QtiMapResponsePoint, QtiMatch, QtiMathOperator, QtiMax, QtiMember, QtiMin, QtiMultiple, QtiNot, QtiNull, QtiOr, QtiOrdered, QtiPatternMatch, QtiPower, QtiPrintedVariable, QtiProduct, QtiRandom, QtiRandomInteger, QtiRepeat, QtiResponseCondition, QtiResponseElse, QtiResponseElseIf, QtiResponseIf, QtiRound, QtiRoundTo, QtiSetCorrectResponse, QtiSetCorrectResponseRule, QtiSetOutcomeValue, QtiSetOutcomeValueRule, QtiSetTemplateValue, QtiSetTemplateValueRule, QtiStatsOperator, QtiStringMatch, QtiSubstring, QtiSubtract, QtiSum, QtiSumExpression, QtiTruncate, QtiVariable, qtiAndMixin, qtiSubtractMixin } from './processing.js';
+export { CandidateCorrectionMixin, ChoiceCorrectionMixin, CorrectResponseInterface, CorrectResponseMixin, CorrectResponseMode, 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 } from './corrections.js';
+import 'lit';
+import '@heximal/templates';
+import '@qti-components/elements/elements';
+import 'lit/directives/ref.js';
+import '@qti-components/portable-custom-interaction/qti-portable-custom-test-interaction.js';
+import '@qti-components/interactions-core/mixins/drag-drop-observables';
+import '@qti-components/interactions-core/mixins/menu-auto-size';
+import '@qti-components/interactions-core/mixins/choices/choices.mixin';
+import '@qti-components/item/elements';
+import '@qti-components/test/elements';
+import '@qti-components/associate-interaction/elements';
+import '@qti-components/choice-interaction/elements';
+import '@qti-components/extended-text-interaction/elements';
+import '@qti-components/gap-match-interaction/elements';
+import '@qti-components/graphic-associate-interaction/elements';
+import '@qti-components/graphic-gap-match-interaction/elements';
+import '@qti-components/graphic-order-interaction/elements';
+import '@qti-components/hotspot-interaction/elements';
+import '@qti-components/hottext-interaction/elements';
+import '@qti-components/inline-choice-interaction/elements';
+import '@qti-components/match-interaction/elements';
+import '@qti-components/order-interaction/elements';
+import '@qti-components/portable-custom-interaction/elements';
+import '@qti-components/select-point-interaction/elements';
+import '@qti-components/slider-interaction/elements';
+import '@qti-components/text-entry-interaction/elements';

package/dist/index.js

@@ -1,4 +1,4 @@
-import "./chunk-MGF5F3S2.js";
+import "./chunk-CAO4JRLY.js";
 import {
   CandidateCorrectionMixin,
   ChoiceCorrectionMixin,
@@ -35,14 +35,18 @@ import {
   TestNavigationCorrection,
   TestShowCorrectResponse,
   correctionPart
-} from "./chunk-KYEZRYO6.js";
+} from "./chunk-XU7HNT4F.js";
 import {
   QtiAssessmentItemRef,
   QtiAssessmentSection,
   QtiAssessmentTest,
+  QtiOutcomeProcessing,
+  QtiOutcomeProcessingProcessor,
   QtiTest,
   QtiTestFeedback,
   QtiTestPart,
+  QtiTestVariables,
+  QtiTestVariablesExpression,
   TestCheckItem,
   TestContainer,
   TestEndAttempt,
@@ -68,7 +72,7 @@ import {
   TestView,
   TestViewToggle,
   ttsContext
-} from "./chunk-LZJHHZQ2.js";
+} from "./chunk-RXGDQDOV.js";
 import "./chunk-V5G7X53Y.js";
 import {
   QtiAssessmentItem,
@@ -104,7 +108,7 @@ import {
   QtiPrompt,
   QtiUploadInteraction,
   qtiInteractionElements
-} from "./chunk-5QYII4OZ.js";
+} from "./chunk-LVBIQDPM.js";
 import {
   QtiAssociateInteraction,
   QtiChoiceInteraction,
@@ -127,15 +131,15 @@ import {
   QtiSimpleChoice,
   QtiSliderInteraction,
   QtiTextEntryInteraction
-} from "./chunk-5SJS36BI.js";
+} from "./chunk-F4BNJWYN.js";
 import "./chunk-X3E5HXG2.js";
-import "./chunk-MJVPNN7W.js";
+import "./chunk-3AJOQCDU.js";
 import {
   ItemContainer,
   ItemPrintVariables,
   QtiItem
-} from "./chunk-W4QZPCNC.js";
-import "./chunk-WCQ26LV7.js";
+} from "./chunk-QECOPVPO.js";
+import "./chunk-7HC5SMCU.js";
 import "./chunk-64XSIBGO.js";
 import {
   getItemByUri,
@@ -364,6 +368,8 @@ export {
   QtiOrderInteractionCorrection,
   QtiOrdered,
   QtiOutcomeDeclaration,
+  QtiOutcomeProcessing,
+  QtiOutcomeProcessingProcessor,
   QtiPatternMatch,
   QtiPortableCustomInteraction,
   QtiPortableCustomInteractionCorrection,
@@ -414,6 +420,8 @@ export {
   QtiTestCorrection,
   QtiTestFeedback,
   QtiTestPart,
+  QtiTestVariables,
+  QtiTestVariablesExpression,
   QtiTextEntryInteraction,
   QtiTextEntryInteractionCorrection,
   QtiTruncate,

package/dist/interaction.d-D4MstYRz.d.ts

@@ -0,0 +1,115 @@
+import { LitElement, PropertyValues } from 'lit';
+import { C as ConfigContext, V as ValidationDisplayMode } from './config.context.d-BvU9r-Mg.js';
+import { V as ValidatableInteraction } from './interaction.interface.d-CvjHM2bi.js';
+import { f as ResponseVariable } from './item.types.d-QU7LljEK.js';
+
+/**
+ * What a choice element should render and behave as. The same element — `qti-simple-choice`,
+ * `qti-hottext` — is a radio in one interaction and a checkbox in another. It cannot know this
+ * by itself.
+ *
+ * Note "drag" is deliberately *not* a choiceRole. In `qti-match-interaction` the same element
+ * type is a drag in one match-set and a drop target in the other, so draggability is positional,
+ * not a property of the interaction. It is derived from `draggablesSelector` instead. It is also
+ * not a valid ARIA role, so it may only ever be a custom state.
+ */
+type ChoiceRole = 'radio' | 'checkbox';
+/**
+ * State an interaction publishes to the choice elements inside it.
+ *
+ * Provided by the `qti-*-interaction`, never by `qti-assessment-item`: interactions must work
+ * standalone — in a plain form, in a story, in a vendor's app — with no QTI ancestor. Consumers
+ * must therefore tolerate its absence and fall back to a sensible default:
+ *
+ *   const role = this.interactionContext?.choiceRole ?? null;
+ */
+interface InteractionContext {
+    /** `null` when the interaction assigns no particular role to its choices. */
+    choiceRole: ChoiceRole | null;
+    /**
+     * The selector this interaction uses to recognise its draggable chips. An element tests
+     * itself with `this.matches(draggablesSelector)` and takes `:state(chip)` if it matches.
+     *
+     * Published rather than pushed because draggability can be positional: match-interaction's
+     * selector distinguishes the source match-set from the target one, so two elements of the
+     * same tag get different answers.
+     */
+    draggablesSelector: string | null;
+}
+declare const interactionContext: {
+    __context__: Readonly<InteractionContext>;
+};
+
+/**
+ * Shared QTI interaction base. Formative correction behavior is supplied by the
+ * `@qti-components/corrections` package.
+ */
+declare abstract class Interaction extends LitElement implements ValidatableInteraction {
+    #private;
+    private _context;
+    /**
+     * Delivery configuration, from the nearest provider — `qti-test` or `qti-item`.
+     *
+     * **Public so it can be assigned directly, which is the development-time route.** An interaction
+     * has to work standalone, and in a story or a spec there is usually no provider above it — so
+     * setting the field is all that is needed:
+     *
+     *     orderInteraction.configContext = { allowReorder: false, validationDisplayMode: 'none' };
+     *
+     * With no provider, nothing ever overwrites it. That is the whole contract, and its limit: where a
+     * provider DOES exist it re-emits on its next update and wins, because `@consume` writes this same
+     * field. There is no merging — set the value on the provider in that case.
+     *
+     * In a lit-html template, bind it as a property rather than assigning after the fact:
+     *
+     *     html`<qti-order-interaction .configContext=${{ allowReorder: false }}>…`
+     *
+     * The binding is committed on the detached template clone, before the fragment is inserted, so it
+     * is in place by `connectedCallback` — which matters for anything that reads config on connect.
+     *
+     * It was `protected`, which fooled nobody: every caller reached it anyway through an
+     * `as any` / `as { configContext?: … }` cast. Public says what was already true and removes the
+     * casts, rather than pretending at an encapsulation the type system was the only thing enforcing.
+     */
+    configContext: ConfigContext;
+    protected _interactionContext: Readonly<InteractionContext>;
+    static formAssociated: boolean;
+    protected _internals: ElementInternals;
+    get internals(): ElementInternals;
+    responseIdentifier: string;
+    disabled: boolean;
+    readonly: boolean;
+    name: any;
+    /** Extension point used by wrappers that should not register as candidate inputs. */
+    protected get registersWithItem(): boolean;
+    get isInline(): boolean;
+    get responseVariable(): ResponseVariable | undefined;
+    abstract validate(): boolean;
+    get value(): string | null;
+    set value(val: string | null);
+    abstract get response(): string | string[] | null;
+    abstract set response(val: string | string[] | null);
+    reportValidity(): boolean;
+    protected get validationDisplayMode(): ValidationDisplayMode;
+    protected resolveAllowReorder(options?: {
+        defaultWhenUnset?: boolean;
+    }): boolean;
+    protected resolveDisableAfterMaxReached(options?: {
+        defaultWhenUnset?: boolean;
+    }): boolean;
+    protected setInteractionValidity(isValid: boolean, validityMessage?: string, anchor?: HTMLElement | null, options?: {
+        suppressInline?: boolean;
+    }): void;
+    protected updateInlineValidationMessage(): void;
+    protected clearInlineValidationMessage(): void;
+    protected getValidationMessageElement(): HTMLElement | null;
+    reset(): void;
+    formResetCallback(): void;
+    connectedCallback(): void;
+    saveResponse(value: string | string[], state?: string | null): void;
+    constructor();
+    /** Optional lifecycle bridge for interaction subclasses that do not need changed-property data. */
+    protected firstUpdated(_changedProperties?: PropertyValues<this>): void;
+}
+
+export { type ChoiceRole as C, Interaction as I, type InteractionContext as a, interactionContext as i };