@citolab/qti-components 8.0.0 → 8.0.2

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

@@ -0,0 +1,126 @@
+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.
+     *
+     * The parameter is `PropertyValues`, matching LitElement, and NOT `PropertyValues<this>`.
+     * The polymorphic `this` narrowed the parameter per subclass, which made every interaction
+     * class structurally incompatible with `LitElement` — so `Constructor<LitElement>`, the
+     * standard constraint for a Lit mixin, rejected all of them and consumers could not wrap an
+     * interaction in a mixin without casting. `this` buys nothing in a parameter position and
+     * costs contravariant compatibility with the base class.
+     *
+     * Still optional, so subclasses that ignore the argument can override with `firstUpdated()`.
+     */
+    protected firstUpdated(_changedProperties?: PropertyValues): void;
+}
+
+export { type ChoiceRole as C, Interaction as I, type InteractionContext as a, interactionContext as i };

package/dist/interaction.interface.d-CvjHM2bi.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Smallest shared contract for any form-associated custom element.
+ *
+ * Keep this intentionally tiny and platform-aligned. QTI-specific concerns
+ * such as response identifiers, readonly handling, and validation
+ * should be layered via separate capability interfaces below.
+ */
+interface FormAssociatedInteraction extends HTMLElement {
+    disabled: boolean;
+    readonly internals: ElementInternals;
+    formResetCallback(): void;
+}
+/** QTI response identity capability. */
+interface ResponseIdentifiedInteraction {
+    responseIdentifier: string;
+}
+/** Optional readonly capability used by many QTI interactions. */
+interface ReadonlyInteraction {
+    readonly: boolean;
+}
+/** Optional reset capability beyond the platform form reset callback. */
+interface ResettableInteraction {
+    reset(): void;
+}
+/** Interaction that publishes and stores a response value. */
+interface ResponseInteractionElement extends FormAssociatedInteraction {
+    responseIdentifier: string;
+    response: string | string[] | null;
+    saveResponse(value: string | string[], state?: string | null): void;
+}
+/** Interaction that participates in validity reporting. */
+interface ValidatableInteraction extends FormAssociatedInteraction {
+    validate(): boolean;
+    reportValidity(): boolean;
+}
+/**
+ * Common contract expected by item containers when tracking registered interactions.
+ */
+interface RegisteredInteraction extends ResponseInteractionElement, ValidatableInteraction, ReadonlyInteraction, ResettableInteraction {
+}
+/**
+ * @deprecated Prefer `RegisteredInteraction` for new code.
+ */
+type IInteraction = RegisteredInteraction;
+
+export type { FormAssociatedInteraction as F, IInteraction as I, ReadonlyInteraction as R, ValidatableInteraction as V, RegisteredInteraction as a, ResettableInteraction as b, ResponseIdentifiedInteraction as c, ResponseInteractionElement as d };

package/dist/interactions.d.ts

@@ -1 +1,281 @@
-export * from '@qti-components/interactions';
+import * as lit from 'lit';
+import { CSSResultGroup, LitElement, PropertyValueMap } from 'lit';
+import { I as Interaction } from './interaction.d-CJiMv8H7.js';
+import { Q as QtiAssociableHotspot, d as QtiGap, e as QtiGapImg, g as QtiGapText, k as QtiHotspotChoice, m as QtiHottext, o as QtiInlineChoice, t as QtiPrompt, v as QtiSimpleAssociableChoice, w as QtiSimpleChoice, a as QtiAssociateInteraction, b as QtiChoiceInteraction, c as QtiExtendedTextInteraction, f as QtiGapMatchInteraction, h as QtiGraphicAssociateInteraction, i as QtiGraphicGapMatchInteraction, j as QtiGraphicOrderInteraction, l as QtiHotspotInteraction, n as QtiHottextInteraction, p as QtiInlineChoiceInteraction, q as QtiMatchInteraction, r as QtiOrderInteraction, s as QtiPortableCustomInteraction, z as QtiPortableCustomInteractionTest, u as QtiSelectPointInteraction, x as QtiSliderInteraction, y as QtiTextEntryInteraction } from './qti-text-entry-interaction.d-BGdfV9qG.js';
+export { O as Orientation } from './qti-text-entry-interaction.d-BGdfV9qG.js';
+import './config.context.d-BvU9r-Mg.js';
+import './interaction.interface.d-CvjHM2bi.js';
+import './item.types.d-QU7LljEK.js';
+import './qti.context.d-CejJMlfZ.js';
+import 'lit/directives/ref.js';
+
+/**
+ * Upload interaction: candidates attach a file as their response.
+ *
+ * @slot prompt - The prompt shown above the file input.
+ */
+declare class QtiUploadInteraction extends Interaction {
+    #private;
+    static styles: CSSResultGroup;
+    reset(): void;
+    validate(): boolean;
+    get response(): string | null;
+    set response(base64: string | null);
+    static get properties(): {
+        [key: string]: lit.PropertyDeclaration<unknown, unknown>;
+    };
+    render(): lit.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-upload-interaction': QtiUploadInteraction;
+    }
+}
+
+/**
+ * Position-object interaction: candidates place draggable objects onto a stage image.
+ *
+ * @slot - Default slot for the object choices and stage.
+ */
+declare class QtiPositionObjectInteraction extends LitElement {
+    static styles: CSSResultGroup;
+    render(): lit.TemplateResult<1>;
+}
+
+declare class QtiPositionObjectStage extends LitElement {
+    static styles: CSSResultGroup;
+    choiceOrdering: boolean;
+    startX: any;
+    startY: any;
+    dragElement: any;
+    render(): lit.TemplateResult<1>;
+    constructor();
+    dragElementHandler(event: MouseEvent): void;
+    firstUpdated(a: PropertyValueMap<any>): void;
+    removeMoveListener(): void;
+    disconnectedCallback(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-position-object-stage': QtiPositionObjectStage;
+    }
+}
+
+/**
+ * Media interaction: wraps an embedded media object (audio/video) and tracks play events.
+ *
+ * @slot prompt - The prompt shown above the media element.
+ * @slot - Default slot for the embedded media element.
+ */
+declare class QtiMediaInteraction extends Interaction {
+    #private;
+    static styles: CSSResultGroup;
+    reset(): void;
+    validate(): boolean;
+    get response(): string | null;
+    set response(val: string | null);
+    static get properties(): {
+        step: {
+            type: NumberConstructor;
+            attribute: string;
+            default: number;
+        };
+    };
+    render(): lit.TemplateResult<1>;
+    constructor();
+    connectedCallback(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-media-interaction': QtiMediaInteraction;
+    }
+}
+
+/**
+ * A button that ends the current attempt.
+ *
+ * @csspart button - The end-attempt button element.
+ */
+declare class QtiEndAttemptInteraction extends LitElement {
+    static styles: CSSResultGroup;
+    responseIdentifier: string;
+    disabled: boolean;
+    /** Defines the number of attempts that a user can make using the 'endAttemptInteraction' mechanism (this can be used to limit the number of hints, etc.). [More information](https://www.imsglobal.org/sites/default/files/spec/qti/v3/info/index.html#DataCharacteristic_EndAttemptInteraction.Attr_count-attempt) */
+    countAttempt: 'true' | 'false' | null;
+    title: string;
+    render(): lit.TemplateResult<1>;
+    endAttempt(_: Event): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-end-attempt-interaction': QtiEndAttemptInteraction;
+    }
+}
+
+/**
+ * QTI Custom Interaction component for legacy CES-based interactions.
+ *
+ * This component implements support for custom interactions originally built for the CES
+ * (Custom Element Standard) player - the predecessor to FACET and the Trifork QTI Player.
+ *
+ * @remarks
+ * The interaction workflow:
+ * 1. Fetch the CI manifest (JSON file with script, style, media references)
+ * 2. Check if bootstrap.js uses the CES API
+ * 3. If CES is used:
+ *    - Fetch index.html from main window (where service worker/fetch works)
+ *    - Inject registerCES proxy script for postMessage-based communication
+ *    - Create blob URL and pass it to ciBootstrap
+ * 4. Create pciContainer iframe with style and bootstrap script
+ * 5. Handle postMessage events for getMedia, getResponse, setResponse, getBlobUrl
+ *
+ * The postMessage bridge is necessary because:
+ * - Iframes created via document.write() have about:blank origin
+ * - They cannot access the parent's global CES object (cross-origin)
+ * - Service workers don't control about:blank documents
+ *
+ * Messages are sent to all parent windows to support embedding scenarios like Storybook
+ * where window.top might not be the actual host application.
+ */
+declare class QtiCustomInteraction extends Interaction {
+    #private;
+    static styles: CSSResultGroup;
+    constructor();
+    data: string;
+    baseItemUrl: string;
+    baseRefUrl: string;
+    id: string;
+    private _errorMessage;
+    manifest: {
+        script: string[];
+        style: string[];
+        media: string[];
+    };
+    connectedCallback(): void;
+    /**
+     * Sets up the CES custom interaction by creating the iframe structure and
+     * handling the CES API communication via postMessage.
+     *
+     * For interactions that use CES, this method:
+     * 1. Fetches the original bootstrap.js and checks if it uses CES
+     * 2. If CES is used, fetches index.html and injects the registerCES proxy
+     * 3. Creates a blob URL for the modified HTML (stored in _contentBlobUrl)
+     * 4. Replaces bootstrap.js with ciBootstrap that loads the blob URL
+     * 5. Sets up postMessage listeners for CES API calls
+     */
+    setupCES(): Promise<void>;
+    handlePostMessage(event: MessageEvent): void;
+    validate(): boolean;
+    get response(): string | string[] | null;
+    set response(val: string | string[] | null);
+    disconnectedCallback(): void;
+    render(): lit.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qti-custom-interaction': QtiCustomInteraction;
+    }
+}
+
+declare const qtiInteractionElements: readonly [{
+    readonly tag: "qti-associable-hotspot";
+    readonly ctor: typeof QtiAssociableHotspot;
+}, {
+    readonly tag: "qti-gap";
+    readonly ctor: typeof QtiGap;
+}, {
+    readonly tag: "qti-gap-img";
+    readonly ctor: typeof QtiGapImg;
+}, {
+    readonly tag: "qti-gap-text";
+    readonly ctor: typeof QtiGapText;
+}, {
+    readonly tag: "qti-hotspot-choice";
+    readonly ctor: typeof QtiHotspotChoice;
+}, {
+    readonly tag: "qti-hottext";
+    readonly ctor: typeof QtiHottext;
+}, {
+    readonly tag: "qti-inline-choice";
+    readonly ctor: typeof QtiInlineChoice;
+}, {
+    readonly tag: "qti-prompt";
+    readonly ctor: typeof QtiPrompt;
+}, {
+    readonly tag: "qti-simple-associable-choice";
+    readonly ctor: typeof QtiSimpleAssociableChoice;
+}, {
+    readonly tag: "qti-simple-choice";
+    readonly ctor: typeof QtiSimpleChoice;
+}, {
+    readonly tag: "qti-associate-interaction";
+    readonly ctor: typeof QtiAssociateInteraction;
+}, {
+    readonly tag: "qti-choice-interaction";
+    readonly ctor: typeof QtiChoiceInteraction;
+}, {
+    readonly tag: "qti-custom-interaction";
+    readonly ctor: typeof QtiCustomInteraction;
+}, {
+    readonly tag: "qti-end-attempt-interaction";
+    readonly ctor: typeof QtiEndAttemptInteraction;
+}, {
+    readonly tag: "qti-extended-text-interaction";
+    readonly ctor: typeof QtiExtendedTextInteraction;
+}, {
+    readonly tag: "qti-gap-match-interaction";
+    readonly ctor: typeof QtiGapMatchInteraction;
+}, {
+    readonly tag: "qti-graphic-associate-interaction";
+    readonly ctor: typeof QtiGraphicAssociateInteraction;
+}, {
+    readonly tag: "qti-graphic-gap-match-interaction";
+    readonly ctor: typeof QtiGraphicGapMatchInteraction;
+}, {
+    readonly tag: "qti-graphic-order-interaction";
+    readonly ctor: typeof QtiGraphicOrderInteraction;
+}, {
+    readonly tag: "qti-hotspot-interaction";
+    readonly ctor: typeof QtiHotspotInteraction;
+}, {
+    readonly tag: "qti-hottext-interaction";
+    readonly ctor: typeof QtiHottextInteraction;
+}, {
+    readonly tag: "qti-inline-choice-interaction";
+    readonly ctor: typeof QtiInlineChoiceInteraction;
+}, {
+    readonly tag: "qti-match-interaction";
+    readonly ctor: typeof QtiMatchInteraction;
+}, {
+    readonly tag: "qti-media-interaction";
+    readonly ctor: typeof QtiMediaInteraction;
+}, {
+    readonly tag: "qti-order-interaction";
+    readonly ctor: typeof QtiOrderInteraction;
+}, {
+    readonly tag: "qti-portable-custom-interaction";
+    readonly ctor: typeof QtiPortableCustomInteraction;
+}, {
+    readonly tag: "qti-portable-custom-interaction-test";
+    readonly ctor: typeof QtiPortableCustomInteractionTest;
+}, {
+    readonly tag: "qti-position-object-interaction";
+    readonly ctor: typeof QtiPositionObjectInteraction;
+}, {
+    readonly tag: "qti-position-object-stage";
+    readonly ctor: typeof QtiPositionObjectStage;
+}, {
+    readonly tag: "qti-select-point-interaction";
+    readonly ctor: typeof QtiSelectPointInteraction;
+}, {
+    readonly tag: "qti-slider-interaction";
+    readonly ctor: typeof QtiSliderInteraction;
+}, {
+    readonly tag: "qti-text-entry-interaction";
+    readonly ctor: typeof QtiTextEntryInteraction;
+}, {
+    readonly tag: "qti-upload-interaction";
+    readonly ctor: typeof QtiUploadInteraction;
+}];
+
+export { QtiAssociableHotspot, QtiAssociateInteraction, QtiChoiceInteraction, QtiCustomInteraction, QtiEndAttemptInteraction, QtiExtendedTextInteraction, QtiGap, QtiGapImg, QtiGapMatchInteraction, QtiGapText, QtiGraphicAssociateInteraction, QtiGraphicGapMatchInteraction, QtiGraphicOrderInteraction, QtiHotspotChoice, QtiHotspotInteraction, QtiHottext, QtiHottextInteraction, QtiInlineChoice, QtiInlineChoiceInteraction, QtiMatchInteraction, QtiMediaInteraction, QtiOrderInteraction, QtiPortableCustomInteraction, QtiPositionObjectInteraction, QtiPositionObjectStage, QtiPrompt, QtiSelectPointInteraction, QtiSimpleAssociableChoice, QtiSimpleChoice, QtiSliderInteraction, QtiTextEntryInteraction, QtiUploadInteraction, qtiInteractionElements };

package/dist/interactions.js

@@ -11,7 +11,7 @@ import {
   QtiPrompt,
   QtiUploadInteraction,
   qtiInteractionElements
-} from "./chunk-5QYII4OZ.js";
+} from "./chunk-CK7AV2UJ.js";
 import {
   QtiAssociateInteraction,
   QtiChoiceInteraction,
@@ -34,10 +34,9 @@ import {
   QtiSimpleChoice,
   QtiSliderInteraction,
   QtiTextEntryInteraction
-} from "./chunk-5SJS36BI.js";
-import "./chunk-X3E5HXG2.js";
-import "./chunk-64XSIBGO.js";
-import "./chunk-H3J7LFRO.js";
+} from "./chunk-TWPXES3S.js";
+import "./chunk-4DB4SC5K.js";
+import "./chunk-HQESINXH.js";
 export {
   QtiAssociableHotspot,
   QtiAssociateInteraction,