@qti-components/base 1.5.1 → 2.0.0

package/dist/context/types/item.types.d.ts

@@ -0,0 +1,12 @@
+import type { VariableDeclaration } from '../../lib/variables';
+export interface ItemContext {
+    identifier?: string;
+    href?: string;
+    variables?: ReadonlyArray<VariableDeclaration<string | string[] | null>>;
+    /**
+     * Optional per-interaction opaque state, keyed by responseIdentifier.
+     * Used for interactions that support state save/restore (e.g. PCI).
+     */
+    state?: Record<string, string | null>;
+}
+export declare const itemContextVariables: VariableDeclaration<string | string[]>[];

package/dist/context/types/item.types.js

@@ -0,0 +1,17 @@
+export const itemContextVariables = [
+    {
+        identifier: 'completionStatus',
+        cardinality: 'single',
+        baseType: 'string',
+        value: 'unknown',
+        type: 'outcome'
+    },
+    {
+        identifier: 'numAttempts',
+        cardinality: 'single',
+        baseType: 'integer',
+        value: '0',
+        type: 'response'
+    }
+];
+//# sourceMappingURL=item.types.js.map

package/dist/context/types/item.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"item.types.js","sourceRoot":"","sources":["../../../src/context/types/item.types.ts"],"names":[],"mappings":"AAaA,MAAM,CAAC,MAAM,oBAAoB,GAAG;IAClC;QACE,UAAU,EAAE,kBAAkB;QAC9B,WAAW,EAAE,QAAQ;QACrB,QAAQ,EAAE,QAAQ;QAClB,KAAK,EAAE,SAAS;QAChB,IAAI,EAAE,SAAS;KAChB;IACD;QACE,UAAU,EAAE,aAAa;QACzB,WAAW,EAAE,QAAQ;QACrB,QAAQ,EAAE,SAAS;QACnB,KAAK,EAAE,GAAG;QACV,IAAI,EAAE,UAAU;KACjB;CAC0C,CAAC","sourcesContent":["import type { VariableDeclaration } from '../../lib/variables';\n\nexport interface ItemContext {\n  identifier?: string;\n  href?: string;\n  variables?: ReadonlyArray<VariableDeclaration<string | string[] | null>>;\n  /**\n   * Optional per-interaction opaque state, keyed by responseIdentifier.\n   * Used for interactions that support state save/restore (e.g. PCI).\n   */\n  state?: Record<string, string | null>;\n}\n\nexport const itemContextVariables = [\n  {\n    identifier: 'completionStatus',\n    cardinality: 'single',\n    baseType: 'string',\n    value: 'unknown',\n    type: 'outcome'\n  },\n  {\n    identifier: 'numAttempts',\n    cardinality: 'single',\n    baseType: 'integer',\n    value: '0',\n    type: 'response'\n  }\n] as VariableDeclaration<string | string[]>[];\n"]}

package/dist/elements.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Custom elements this package registers into an application's registry.
+ *
+ * Empty, deliberately. `qti-base` is abstractions and context — it contributes no elements to a
+ * delivery application.
+ *
+ * The one entry that used to be here, `qti-config-test-provider`, is gone entirely. It was a
+ * TEST-ONLY wrapper that every consumer of `import '@qti-components/base'` registered transitively,
+ * and it carried `@customElement(...)` on top of this list — an UNGUARDED `customElements.define()`
+ * at module-evaluation time. A module graph holding two copies of this package (a workspace build
+ * alongside a published dist, which is what the editor resolves) evaluated it twice and the second
+ * threw `NotSupportedError: ... already been used with this registry`, aborting module evaluation
+ * and taking down every test file that imported it — 34 suites in the editor, none of which used
+ * the element. `register.ts` had the guard right all along; the decorator bypassed it.
+ *
+ * Config for a single interaction is a property binding now — see config.context.ts.
+ *
+ * The array and `register.ts` stay so the elements + guarded-register convention the other 30
+ * packages follow is already in place the day this package does own an element.
+ */
+export declare const qtiBaseElements: readonly {
+    tag: string;
+    ctor: CustomElementConstructor;
+}[];

package/dist/elements.js

@@ -0,0 +1,22 @@
+/**
+ * Custom elements this package registers into an application's registry.
+ *
+ * Empty, deliberately. `qti-base` is abstractions and context — it contributes no elements to a
+ * delivery application.
+ *
+ * The one entry that used to be here, `qti-config-test-provider`, is gone entirely. It was a
+ * TEST-ONLY wrapper that every consumer of `import '@qti-components/base'` registered transitively,
+ * and it carried `@customElement(...)` on top of this list — an UNGUARDED `customElements.define()`
+ * at module-evaluation time. A module graph holding two copies of this package (a workspace build
+ * alongside a published dist, which is what the editor resolves) evaluated it twice and the second
+ * threw `NotSupportedError: ... already been used with this registry`, aborting module evaluation
+ * and taking down every test file that imported it — 34 suites in the editor, none of which used
+ * the element. `register.ts` had the guard right all along; the decorator bypassed it.
+ *
+ * Config for a single interaction is a property binding now — see config.context.ts.
+ *
+ * The array and `register.ts` stay so the elements + guarded-register convention the other 30
+ * packages follow is already in place the day this package does own an element.
+ */
+export const qtiBaseElements = [];
+//# sourceMappingURL=elements.js.map

package/dist/elements.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"elements.js","sourceRoot":"","sources":["../src/elements.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,CAAC,MAAM,eAAe,GAA+D,EAAE,CAAC","sourcesContent":["/**\n * Custom elements this package registers into an application's registry.\n *\n * Empty, deliberately. `qti-base` is abstractions and context — it contributes no elements to a\n * delivery application.\n *\n * The one entry that used to be here, `qti-config-test-provider`, is gone entirely. It was a\n * TEST-ONLY wrapper that every consumer of `import '@qti-components/base'` registered transitively,\n * and it carried `@customElement(...)` on top of this list — an UNGUARDED `customElements.define()`\n * at module-evaluation time. A module graph holding two copies of this package (a workspace build\n * alongside a published dist, which is what the editor resolves) evaluated it twice and the second\n * threw `NotSupportedError: ... already been used with this registry`, aborting module evaluation\n * and taking down every test file that imported it — 34 suites in the editor, none of which used\n * the element. `register.ts` had the guard right all along; the decorator bypassed it.\n *\n * Config for a single interaction is a property binding now — see config.context.ts.\n *\n * The array and `register.ts` stay so the elements + guarded-register convention the other 30\n * packages follow is already in place the day this package does own an element.\n */\nexport const qtiBaseElements: readonly { tag: string; ctor: CustomElementConstructor }[] = [];\n"]}

package/dist/index.d.ts

@@ -1,16 +1,24 @@
+import './register';
 export * from './context/computed-item.context';
+export * from './context/types/computed-item.types';
 export * from './context/computed.context';
+export * from './context/types/computed.types';
 export * from './context/config.context';
+export * from './context/interaction.context';
 export * from './context/item.context';
-export * from './context/qti-assessment-item.context';
+export * from './context/types/item.types';
 export * from './context/qti.context';
 export * from './context/session.context';
 export * from './context/test.context';
+export * from './styles/box-sizing.styles';
+export * from './styles/drop-region.styles';
+export * from './styles/validation-message.styles';
 export * from './abstract/interaction';
 export * from './abstract/qti-variable-declaration';
 export * from './abstract/qti-condition-expression';
 export * from './abstract/qti-feedback';
 export * from './abstract/qti-expression';
+export * from './lib/response';
 export * from './lib/expression-result';
 export * from './lib/interaction.interface';
 export * from './lib/variables';

package/dist/index.js

@@ -1,16 +1,24 @@
+import './register';
 export * from './context/computed-item.context';
+export * from './context/types/computed-item.types';
 export * from './context/computed.context';
+export * from './context/types/computed.types';
 export * from './context/config.context';
+export * from './context/interaction.context';
 export * from './context/item.context';
-export * from './context/qti-assessment-item.context';
+export * from './context/types/item.types';
 export * from './context/qti.context';
 export * from './context/session.context';
 export * from './context/test.context';
+export * from './styles/box-sizing.styles';
+export * from './styles/drop-region.styles';
+export * from './styles/validation-message.styles';
 export * from './abstract/interaction';
 export * from './abstract/qti-variable-declaration';
 export * from './abstract/qti-condition-expression';
 export * from './abstract/qti-feedback';
 export * from './abstract/qti-expression';
+export * from './lib/response';
 export * from './lib/expression-result';
 export * from './lib/interaction.interface';
 export * from './lib/variables';

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,iCAAiC,CAAC;AAChD,cAAc,4BAA4B,CAAC;AAC3C,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,uCAAuC,CAAC;AACtD,cAAc,uBAAuB,CAAC;AACtC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,wBAAwB,CAAC;AAEvC,cAAc,wBAAwB,CAAC;AACvC,cAAc,qCAAqC,CAAC;AACpD,cAAc,qCAAqC,CAAC;AACpD,cAAc,yBAAyB,CAAC;AACxC,cAAc,2BAA2B,CAAC;AAE1C,cAAc,yBAAyB,CAAC;AACxC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,iBAAiB,CAAC;AAChC,cAAc,qBAAqB,CAAC;AAEpC,cAAc,wBAAwB,CAAC;AACvC,cAAc,eAAe,CAAC","sourcesContent":["export * from './context/computed-item.context';\nexport * from './context/computed.context';\nexport * from './context/config.context';\nexport * from './context/item.context';\nexport * from './context/qti-assessment-item.context';\nexport * from './context/qti.context';\nexport * from './context/session.context';\nexport * from './context/test.context';\n\nexport * from './abstract/interaction';\nexport * from './abstract/qti-variable-declaration';\nexport * from './abstract/qti-condition-expression';\nexport * from './abstract/qti-feedback';\nexport * from './abstract/qti-expression';\n\nexport * from './lib/expression-result';\nexport * from './lib/interaction.interface';\nexport * from './lib/variables';\nexport * from './lib/qti-rule-base';\n\nexport * from './utils/scoring-helper';\nexport * from './utils/utils';\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,YAAY,CAAC;AAEpB,cAAc,iCAAiC,CAAC;AAChD,cAAc,qCAAqC,CAAC;AACpD,cAAc,4BAA4B,CAAC;AAC3C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,0BAA0B,CAAC;AACzC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,uBAAuB,CAAC;AACtC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,wBAAwB,CAAC;AAEvC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,oCAAoC,CAAC;AAEnD,cAAc,wBAAwB,CAAC;AACvC,cAAc,qCAAqC,CAAC;AACpD,cAAc,qCAAqC,CAAC;AACpD,cAAc,yBAAyB,CAAC;AACxC,cAAc,2BAA2B,CAAC;AAE1C,cAAc,gBAAgB,CAAC;AAC/B,cAAc,yBAAyB,CAAC;AACxC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,iBAAiB,CAAC;AAChC,cAAc,qBAAqB,CAAC;AAEpC,cAAc,wBAAwB,CAAC;AACvC,cAAc,eAAe,CAAC","sourcesContent":["import './register';\n\nexport * from './context/computed-item.context';\nexport * from './context/types/computed-item.types';\nexport * from './context/computed.context';\nexport * from './context/types/computed.types';\nexport * from './context/config.context';\nexport * from './context/interaction.context';\nexport * from './context/item.context';\nexport * from './context/types/item.types';\nexport * from './context/qti.context';\nexport * from './context/session.context';\nexport * from './context/test.context';\n\nexport * from './styles/box-sizing.styles';\nexport * from './styles/drop-region.styles';\nexport * from './styles/validation-message.styles';\n\nexport * from './abstract/interaction';\nexport * from './abstract/qti-variable-declaration';\nexport * from './abstract/qti-condition-expression';\nexport * from './abstract/qti-feedback';\nexport * from './abstract/qti-expression';\n\nexport * from './lib/response';\nexport * from './lib/expression-result';\nexport * from './lib/interaction.interface';\nexport * from './lib/variables';\nexport * from './lib/qti-rule-base';\n\nexport * from './utils/scoring-helper';\nexport * from './utils/utils';\n"]}

package/dist/lib/interaction.interface.d.ts

@@ -1,20 +1,44 @@
-export interface IInteraction {
-    /** The correct response for this interaction */
-    correctResponse: Readonly<string | string[] | null>;
-    /** Shows which choices are correct with inline indicators */
-    showCorrectResponse: boolean;
-    /** Shows a cloned interaction with the correct answers filled in */
-    showFullCorrectResponse: boolean;
-    /** Shows feedback on candidate's selections compared to correct response */
-    showCandidateCorrection: boolean;
-    response: string | string[];
-    responseIdentifier: string;
+/**
+ * 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.
+ */
+export interface FormAssociatedInteraction extends HTMLElement {
     disabled: boolean;
+    readonly internals: ElementInternals;
+    formResetCallback(): void;
+}
+/** QTI response identity capability. */
+export interface ResponseIdentifiedInteraction {
+    responseIdentifier: string;
+}
+/** Optional readonly capability used by many QTI interactions. */
+export interface ReadonlyInteraction {
     readonly: boolean;
+}
+/** Optional reset capability beyond the platform form reset callback. */
+export interface ResettableInteraction {
+    reset(): void;
+}
+/** Interaction that publishes and stores a response value. */
+export interface ResponseInteractionElement extends FormAssociatedInteraction {
+    responseIdentifier: string;
+    response: string | string[] | null;
+    saveResponse(value: string | string[], state?: string | null): void;
+}
+/** Interaction that participates in validity reporting. */
+export interface ValidatableInteraction extends FormAssociatedInteraction {
     validate(): boolean;
     reportValidity(): boolean;
-    reset(): void;
-    saveResponse(value: string | string[]): void;
-    toggleCorrectResponse(show: boolean): void;
-    toggleCandidateCorrection(show: boolean): void;
 }
+/**
+ * Common contract expected by item containers when tracking registered interactions.
+ */
+export interface RegisteredInteraction extends ResponseInteractionElement, ValidatableInteraction, ReadonlyInteraction, ResettableInteraction {
+}
+/**
+ * @deprecated Prefer `RegisteredInteraction` for new code.
+ */
+export type IInteraction = RegisteredInteraction;

package/dist/lib/interaction.interface.js.map

@@ -1 +1 @@
-{"version":3,"file":"interaction.interface.js","sourceRoot":"","sources":["../../src/lib/interaction.interface.ts"],"names":[],"mappings":"","sourcesContent":["export interface IInteraction {\n  /** The correct response for this interaction */\n  correctResponse: Readonly<string | string[] | null>;\n  /** Shows which choices are correct with inline indicators */\n  showCorrectResponse: boolean;\n  /** Shows a cloned interaction with the correct answers filled in */\n  showFullCorrectResponse: boolean;\n  /** Shows feedback on candidate's selections compared to correct response */\n  showCandidateCorrection: boolean;\n  // value: string;\n  response: string | string[];\n  responseIdentifier: string;\n  disabled: boolean;\n  readonly: boolean;\n  validate(): boolean;\n  reportValidity(): boolean;\n  reset(): void;\n  saveResponse(value: string | string[]): void;\n  toggleCorrectResponse(show: boolean): void;\n  toggleCandidateCorrection(show: boolean): void;\n}\n"]}
+{"version":3,"file":"interaction.interface.js","sourceRoot":"","sources":["../../src/lib/interaction.interface.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Smallest shared contract for any form-associated custom element.\n *\n * Keep this intentionally tiny and platform-aligned. QTI-specific concerns\n * such as response identifiers, readonly handling, and validation\n * should be layered via separate capability interfaces below.\n */\nexport interface FormAssociatedInteraction extends HTMLElement {\n  disabled: boolean;\n  readonly internals: ElementInternals;\n  formResetCallback(): void;\n}\n\n/** QTI response identity capability. */\nexport interface ResponseIdentifiedInteraction {\n  responseIdentifier: string;\n}\n\n/** Optional readonly capability used by many QTI interactions. */\nexport interface ReadonlyInteraction {\n  readonly: boolean;\n}\n\n/** Optional reset capability beyond the platform form reset callback. */\nexport interface ResettableInteraction {\n  reset(): void;\n}\n\n/** Interaction that publishes and stores a response value. */\nexport interface ResponseInteractionElement extends FormAssociatedInteraction {\n  responseIdentifier: string;\n  response: string | string[] | null;\n  saveResponse(value: string | string[], state?: string | null): void;\n}\n\n/** Interaction that participates in validity reporting. */\nexport interface ValidatableInteraction extends FormAssociatedInteraction {\n  validate(): boolean;\n  reportValidity(): boolean;\n}\n\n/**\n * Common contract expected by item containers when tracking registered interactions.\n */\nexport interface RegisteredInteraction\n  extends ResponseInteractionElement,\n    ValidatableInteraction,\n    ReadonlyInteraction,\n    ResettableInteraction {}\n\n/**\n * @deprecated Prefer `RegisteredInteraction` for new code.\n */\nexport type IInteraction = RegisteredInteraction;\n"]}

package/dist/lib/response.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Canonical `response="..."` / `correct-response="..."` attribute codec.
+ *
+ * Authors put a single string on an interaction element. This module is the
+ * single source of truth for how that string parses into the runtime's
+ * internal value AND how an editor serializes the internal value back to the
+ * attribute. Both `@qti-components/*` interactions and `@citolab/prose-qti`
+ * (the editor) import from here — no per-codebase parsers, no drift.
+ *
+ * The two attributes share the same grammar; the codec is agnostic about
+ * which of them is being parsed.
+ *
+ * ---
+ *
+ * Format reference (per interaction):
+ *
+ * | Interaction          | base-type     | cardinality          | attribute value           |
+ * |----------------------|---------------|----------------------|---------------------------|
+ * | choice               | identifier    | single / multiple    | "A"  /  "A,B,C"           |
+ * | inline-choice        | identifier    | single               | "Y"                       |
+ * | hottext              | identifier    | single / multiple    | "h1"  /  "h1,h2"          |
+ * | hotspot              | identifier    | single / multiple    | "spot1"  /  "spot1,spot2" |
+ * | order                | identifier    | ordered              | "a,b,c"  (order matters)  |
+ * | graphic-order        | identifier    | ordered              | "spot1,spot2,spot3"       |
+ * | match                | directedPair  | multiple             | "src1 tgt1,src2 tgt2"     |
+ * | associate            | directedPair  | multiple             | "A B,C D"                 |
+ * | gap-match            | directedPair  | multiple             | "gtext1 gap1,..."         |
+ * | graphic-associate    | directedPair  | multiple             | "spot1 spot2,..."         |
+ * | graphic-gap-match    | directedPair  | multiple             | "gimg1 spot1,..."         |
+ * | select-point         | point         | single / multiple    | "100 150"  /  "100 150,…" |
+ * | slider               | integer       | single               | "50"                      |
+ * | text-entry           | string        | single               | "paris"                   |
+ *
+ * Rules:
+ *  - Comma `,` separates VALUES (different identifiers / pairs / points).
+ *  - Space ` ` separates PARTS within one value (pair members or point coords).
+ *  - Each value is trimmed on parse.
+ *  - No escape mechanism. Identifiers that contain commas cannot round-trip.
+ */
+/** Canonical parsed value of a `response` / `correct-response` attribute. */
+export type ResponseValue = string | string[] | null;
+/** Identifier literal — opaque QTI identifier (e.g. `"choice1"`). */
+export type Identifier = string;
+/** Directed pair literal — `"sourceId targetId"`. Used by match / associate / gap-match. */
+export type DirectedPair = `${string} ${string}`;
+/** Point literal — `"x y"` integer coordinates. Used by select-point / graphic-*. */
+export type Point = `${number} ${number}`;
+/**
+ * Parse a raw `response` / `correct-response` attribute string into the
+ * canonical value.
+ *
+ *  - `null` / `undefined` / empty → `null`
+ *  - no comma                     → trimmed string
+ *  - one or more commas           → trimmed array (single-element collapses to a string)
+ */
+export declare function parseResponseAttribute(raw: string | null | undefined): ResponseValue;
+/**
+ * Serialize a canonical value back to the attribute string. Returns `null` for
+ * empty inputs so a Lit `@property({ reflect: true })` drops the attribute.
+ */
+export declare function serializeResponseAttribute(value: ResponseValue): string | null;
+/**
+ * Iterate over the comma-separated entries in a response value, regardless of
+ * whether the caller has the raw string, the parsed string, or a string[].
+ * Yields trimmed non-empty entries.
+ */
+export declare function iterResponseValues(raw: ResponseValue): Generator<string>;
+/** Parse a directed-pair value into `{ source, target }`. Throws on malformed input. */
+export declare function parsePair(value: string): {
+    source: string;
+    target: string;
+};
+/** Serialize a directed pair to canonical `"source target"` form. */
+export declare function serializePair(source: string, target: string): DirectedPair;
+/** Parse a point value into `{ x, y }`. Throws on malformed input. */
+export declare function parsePoint(value: string): {
+    x: number;
+    y: number;
+};
+/** Serialize a point to canonical `"x y"` form. */
+export declare function serializePoint(x: number, y: number): Point;
+/**
+ * Ready-to-use Lit `converter` for `response` / `correct-response` attributes.
+ * Assign to the `converter` option:
+ *
+ *   @property({ attribute: 'response', converter: responseAttributeConverter({ emptyAs: [] }) })
+ *
+ * `emptyAs` picks the sentinel returned when the attribute is absent / blank.
+ * Three sentinels exist across the codebase — match the one your call site
+ * already uses. Future work may normalize to a single sentinel.
+ *
+ *   - '' (empty string)   — ChoicesMixin convention
+ *   - []                  — DragDropSlottedMixin / graphic-associate convention
+ *   - null                — base interaction / select-point convention
+ *
+ * On the serialize side, the `emptyAs` value roundtrips back to `null` so a
+ * `reflect: true` property drops the attribute rather than emitting `""`.
+ */
+export declare function responseAttributeConverter<E extends '' | null | readonly unknown[]>(opts: {
+    emptyAs: E;
+}): {
+    fromAttribute: (value: string | null) => ResponseValue | E;
+    toAttribute: (value: ResponseValue | E) => string | null;
+};

package/dist/lib/response.js

@@ -0,0 +1,168 @@
+/**
+ * Canonical `response="..."` / `correct-response="..."` attribute codec.
+ *
+ * Authors put a single string on an interaction element. This module is the
+ * single source of truth for how that string parses into the runtime's
+ * internal value AND how an editor serializes the internal value back to the
+ * attribute. Both `@qti-components/*` interactions and `@citolab/prose-qti`
+ * (the editor) import from here — no per-codebase parsers, no drift.
+ *
+ * The two attributes share the same grammar; the codec is agnostic about
+ * which of them is being parsed.
+ *
+ * ---
+ *
+ * Format reference (per interaction):
+ *
+ * | Interaction          | base-type     | cardinality          | attribute value           |
+ * |----------------------|---------------|----------------------|---------------------------|
+ * | choice               | identifier    | single / multiple    | "A"  /  "A,B,C"           |
+ * | inline-choice        | identifier    | single               | "Y"                       |
+ * | hottext              | identifier    | single / multiple    | "h1"  /  "h1,h2"          |
+ * | hotspot              | identifier    | single / multiple    | "spot1"  /  "spot1,spot2" |
+ * | order                | identifier    | ordered              | "a,b,c"  (order matters)  |
+ * | graphic-order        | identifier    | ordered              | "spot1,spot2,spot3"       |
+ * | match                | directedPair  | multiple             | "src1 tgt1,src2 tgt2"     |
+ * | associate            | directedPair  | multiple             | "A B,C D"                 |
+ * | gap-match            | directedPair  | multiple             | "gtext1 gap1,..."         |
+ * | graphic-associate    | directedPair  | multiple             | "spot1 spot2,..."         |
+ * | graphic-gap-match    | directedPair  | multiple             | "gimg1 spot1,..."         |
+ * | select-point         | point         | single / multiple    | "100 150"  /  "100 150,…" |
+ * | slider               | integer       | single               | "50"                      |
+ * | text-entry           | string        | single               | "paris"                   |
+ *
+ * Rules:
+ *  - Comma `,` separates VALUES (different identifiers / pairs / points).
+ *  - Space ` ` separates PARTS within one value (pair members or point coords).
+ *  - Each value is trimmed on parse.
+ *  - No escape mechanism. Identifiers that contain commas cannot round-trip.
+ */
+// ─── attribute-level parser / serializer ─────────────────────────────────────
+/**
+ * Parse a raw `response` / `correct-response` attribute string into the
+ * canonical value.
+ *
+ *  - `null` / `undefined` / empty → `null`
+ *  - no comma                     → trimmed string
+ *  - one or more commas           → trimmed array (single-element collapses to a string)
+ */
+export function parseResponseAttribute(raw) {
+    if (raw == null)
+        return null;
+    if (!raw.includes(',')) {
+        const trimmed = raw.trim();
+        return trimmed.length > 0 ? trimmed : null;
+    }
+    const tokens = raw
+        .split(',')
+        .map(token => token.trim())
+        .filter(token => token.length > 0);
+    if (tokens.length === 0)
+        return null;
+    if (tokens.length === 1)
+        return tokens[0];
+    return tokens;
+}
+/**
+ * Serialize a canonical value back to the attribute string. Returns `null` for
+ * empty inputs so a Lit `@property({ reflect: true })` drops the attribute.
+ */
+export function serializeResponseAttribute(value) {
+    if (value == null)
+        return null;
+    if (Array.isArray(value)) {
+        const tokens = value.map(token => token.trim()).filter(token => token.length > 0);
+        return tokens.length > 0 ? tokens.join(',') : null;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+// ─── value-shape helpers (per interaction type) ──────────────────────────────
+/**
+ * Iterate over the comma-separated entries in a response value, regardless of
+ * whether the caller has the raw string, the parsed string, or a string[].
+ * Yields trimmed non-empty entries.
+ */
+export function* iterResponseValues(raw) {
+    if (raw == null)
+        return;
+    if (Array.isArray(raw)) {
+        for (const v of raw) {
+            const t = v.trim();
+            if (t)
+                yield t;
+        }
+        return;
+    }
+    if (!raw.includes(',')) {
+        const t = raw.trim();
+        if (t)
+            yield t;
+        return;
+    }
+    for (const v of raw.split(',')) {
+        const t = v.trim();
+        if (t)
+            yield t;
+    }
+}
+/** Parse a directed-pair value into `{ source, target }`. Throws on malformed input. */
+export function parsePair(value) {
+    const [source, target, ...rest] = value.trim().split(/\s+/);
+    if (!source || !target || rest.length > 0) {
+        throw new Error(`malformed directed-pair value: "${value}" (expected "source target")`);
+    }
+    return { source, target };
+}
+/** Serialize a directed pair to canonical `"source target"` form. */
+export function serializePair(source, target) {
+    return `${source} ${target}`;
+}
+/** Parse a point value into `{ x, y }`. Throws on malformed input. */
+export function parsePoint(value) {
+    const [xStr, yStr, ...rest] = value.trim().split(/\s+/);
+    const x = Number(xStr);
+    const y = Number(yStr);
+    if (!Number.isFinite(x) || !Number.isFinite(y) || rest.length > 0) {
+        throw new Error(`malformed point value: "${value}" (expected "x y" numeric coords)`);
+    }
+    return { x, y };
+}
+/** Serialize a point to canonical `"x y"` form. */
+export function serializePoint(x, y) {
+    return `${x} ${y}`;
+}
+// ─── Lit converter factory ───────────────────────────────────────────────────
+/**
+ * Ready-to-use Lit `converter` for `response` / `correct-response` attributes.
+ * Assign to the `converter` option:
+ *
+ *   @property({ attribute: 'response', converter: responseAttributeConverter({ emptyAs: [] }) })
+ *
+ * `emptyAs` picks the sentinel returned when the attribute is absent / blank.
+ * Three sentinels exist across the codebase — match the one your call site
+ * already uses. Future work may normalize to a single sentinel.
+ *
+ *   - '' (empty string)   — ChoicesMixin convention
+ *   - []                  — DragDropSlottedMixin / graphic-associate convention
+ *   - null                — base interaction / select-point convention
+ *
+ * On the serialize side, the `emptyAs` value roundtrips back to `null` so a
+ * `reflect: true` property drops the attribute rather than emitting `""`.
+ */
+export function responseAttributeConverter(opts) {
+    const { emptyAs } = opts;
+    const isEmptySentinel = (value) => value === emptyAs || value == null || value === '' || (Array.isArray(value) && value.length === 0);
+    return {
+        fromAttribute: (value) => {
+            const parsed = parseResponseAttribute(value);
+            return parsed === null ? emptyAs : parsed;
+        },
+        toAttribute: (value) => {
+            if (isEmptySentinel(value))
+                return null;
+            return serializeResponseAttribute(value);
+        }
+    };
+}
+//# sourceMappingURL=response.js.map

package/dist/lib/response.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"response.js","sourceRoot":"","sources":["../../src/lib/response.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Canonical `response=\"...\"` / `correct-response=\"...\"` attribute codec.\n *\n * Authors put a single string on an interaction element. This module is the\n * single source of truth for how that string parses into the runtime's\n * internal value AND how an editor serializes the internal value back to the\n * attribute. Both `@qti-components/*` interactions and `@citolab/prose-qti`\n * (the editor) import from here — no per-codebase parsers, no drift.\n *\n * The two attributes share the same grammar; the codec is agnostic about\n * which of them is being parsed.\n *\n * ---\n *\n * Format reference (per interaction):\n *\n * | Interaction          | base-type     | cardinality          | attribute value           |\n * |----------------------|---------------|----------------------|---------------------------|\n * | choice               | identifier    | single / multiple    | \"A\"  /  \"A,B,C\"           |\n * | inline-choice        | identifier    | single               | \"Y\"                       |\n * | hottext              | identifier    | single / multiple    | \"h1\"  /  \"h1,h2\"          |\n * | hotspot              | identifier    | single / multiple    | \"spot1\"  /  \"spot1,spot2\" |\n * | order                | identifier    | ordered              | \"a,b,c\"  (order matters)  |\n * | graphic-order        | identifier    | ordered              | \"spot1,spot2,spot3\"       |\n * | match                | directedPair  | multiple             | \"src1 tgt1,src2 tgt2\"     |\n * | associate            | directedPair  | multiple             | \"A B,C D\"                 |\n * | gap-match            | directedPair  | multiple             | \"gtext1 gap1,...\"         |\n * | graphic-associate    | directedPair  | multiple             | \"spot1 spot2,...\"         |\n * | graphic-gap-match    | directedPair  | multiple             | \"gimg1 spot1,...\"         |\n * | select-point         | point         | single / multiple    | \"100 150\"  /  \"100 150,…\" |\n * | slider               | integer       | single               | \"50\"                      |\n * | text-entry           | string        | single               | \"paris\"                   |\n *\n * Rules:\n *  - Comma `,` separates VALUES (different identifiers / pairs / points).\n *  - Space ` ` separates PARTS within one value (pair members or point coords).\n *  - Each value is trimmed on parse.\n *  - No escape mechanism. Identifiers that contain commas cannot round-trip.\n */\n\n// ─── parsed shape ────────────────────────────────────────────────────────────\n\n/** Canonical parsed value of a `response` / `correct-response` attribute. */\nexport type ResponseValue = string | string[] | null;\n\n// ─── per-shape branded types (advisory at compile time) ──────────────────────\n\n/** Identifier literal — opaque QTI identifier (e.g. `\"choice1\"`). */\nexport type Identifier = string;\n\n/** Directed pair literal — `\"sourceId targetId\"`. Used by match / associate / gap-match. */\nexport type DirectedPair = `${string} ${string}`;\n\n/** Point literal — `\"x y\"` integer coordinates. Used by select-point / graphic-*. */\nexport type Point = `${number} ${number}`;\n\n// ─── attribute-level parser / serializer ─────────────────────────────────────\n\n/**\n * Parse a raw `response` / `correct-response` attribute string into the\n * canonical value.\n *\n *  - `null` / `undefined` / empty → `null`\n *  - no comma                     → trimmed string\n *  - one or more commas           → trimmed array (single-element collapses to a string)\n */\nexport function parseResponseAttribute(raw: string | null | undefined): ResponseValue {\n  if (raw == null) return null;\n  if (!raw.includes(',')) {\n    const trimmed = raw.trim();\n    return trimmed.length > 0 ? trimmed : null;\n  }\n  const tokens = raw\n    .split(',')\n    .map(token => token.trim())\n    .filter(token => token.length > 0);\n  if (tokens.length === 0) return null;\n  if (tokens.length === 1) return tokens[0];\n  return tokens;\n}\n\n/**\n * Serialize a canonical value back to the attribute string. Returns `null` for\n * empty inputs so a Lit `@property({ reflect: true })` drops the attribute.\n */\nexport function serializeResponseAttribute(value: ResponseValue): string | null {\n  if (value == null) return null;\n  if (Array.isArray(value)) {\n    const tokens = value.map(token => token.trim()).filter(token => token.length > 0);\n    return tokens.length > 0 ? tokens.join(',') : null;\n  }\n  const trimmed = value.trim();\n  return trimmed.length > 0 ? trimmed : null;\n}\n\n// ─── value-shape helpers (per interaction type) ──────────────────────────────\n\n/**\n * Iterate over the comma-separated entries in a response value, regardless of\n * whether the caller has the raw string, the parsed string, or a string[].\n * Yields trimmed non-empty entries.\n */\nexport function* iterResponseValues(raw: ResponseValue): Generator<string> {\n  if (raw == null) return;\n  if (Array.isArray(raw)) {\n    for (const v of raw) {\n      const t = v.trim();\n      if (t) yield t;\n    }\n    return;\n  }\n  if (!raw.includes(',')) {\n    const t = raw.trim();\n    if (t) yield t;\n    return;\n  }\n  for (const v of raw.split(',')) {\n    const t = v.trim();\n    if (t) yield t;\n  }\n}\n\n/** Parse a directed-pair value into `{ source, target }`. Throws on malformed input. */\nexport function parsePair(value: string): { source: string; target: string } {\n  const [source, target, ...rest] = value.trim().split(/\\s+/);\n  if (!source || !target || rest.length > 0) {\n    throw new Error(`malformed directed-pair value: \"${value}\" (expected \"source target\")`);\n  }\n  return { source, target };\n}\n\n/** Serialize a directed pair to canonical `\"source target\"` form. */\nexport function serializePair(source: string, target: string): DirectedPair {\n  return `${source} ${target}`;\n}\n\n/** Parse a point value into `{ x, y }`. Throws on malformed input. */\nexport function parsePoint(value: string): { x: number; y: number } {\n  const [xStr, yStr, ...rest] = value.trim().split(/\\s+/);\n  const x = Number(xStr);\n  const y = Number(yStr);\n  if (!Number.isFinite(x) || !Number.isFinite(y) || rest.length > 0) {\n    throw new Error(`malformed point value: \"${value}\" (expected \"x y\" numeric coords)`);\n  }\n  return { x, y };\n}\n\n/** Serialize a point to canonical `\"x y\"` form. */\nexport function serializePoint(x: number, y: number): Point {\n  return `${x} ${y}`;\n}\n\n// ─── Lit converter factory ───────────────────────────────────────────────────\n\n/**\n * Ready-to-use Lit `converter` for `response` / `correct-response` attributes.\n * Assign to the `converter` option:\n *\n *   @property({ attribute: 'response', converter: responseAttributeConverter({ emptyAs: [] }) })\n *\n * `emptyAs` picks the sentinel returned when the attribute is absent / blank.\n * Three sentinels exist across the codebase — match the one your call site\n * already uses. Future work may normalize to a single sentinel.\n *\n *   - '' (empty string)   — ChoicesMixin convention\n *   - []                  — DragDropSlottedMixin / graphic-associate convention\n *   - null                — base interaction / select-point convention\n *\n * On the serialize side, the `emptyAs` value roundtrips back to `null` so a\n * `reflect: true` property drops the attribute rather than emitting `\"\"`.\n */\nexport function responseAttributeConverter<E extends '' | null | readonly unknown[]>(opts: {\n  emptyAs: E;\n}): {\n  fromAttribute: (value: string | null) => ResponseValue | E;\n  toAttribute: (value: ResponseValue | E) => string | null;\n} {\n  const { emptyAs } = opts;\n  const isEmptySentinel = (value: unknown): boolean =>\n    value === emptyAs || value == null || value === '' || (Array.isArray(value) && value.length === 0);\n\n  return {\n    fromAttribute: (value: string | null): ResponseValue | E => {\n      const parsed = parseResponseAttribute(value);\n      return parsed === null ? emptyAs : parsed;\n    },\n    toAttribute: (value: ResponseValue | E): string | null => {\n      if (isEmptySentinel(value)) return null;\n      return serializeResponseAttribute(value as ResponseValue);\n    }\n  };\n}\n"]}

package/dist/register.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/register.js

@@ -0,0 +1,7 @@
+import { qtiBaseElements } from './elements';
+for (const { tag, ctor } of qtiBaseElements) {
+    if (!customElements.get(tag)) {
+        customElements.define(tag, ctor);
+    }
+}
+//# sourceMappingURL=register.js.map

package/dist/register.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"register.js","sourceRoot":"","sources":["../src/register.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAE7C,KAAK,MAAM,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,eAAe,EAAE,CAAC;IAC5C,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;QAC7B,cAAc,CAAC,MAAM,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;IACnC,CAAC;AACH,CAAC","sourcesContent":["import { qtiBaseElements } from './elements';\n\nfor (const { tag, ctor } of qtiBaseElements) {\n  if (!customElements.get(tag)) {\n    customElements.define(tag, ctor);\n  }\n}\n"]}

package/dist/styles/box-sizing.styles.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The border-box reset, for shadow trees.
+ *
+ * `modern-normalize` applies `*, ::before, ::after { box-sizing: border-box }` to the document,
+ * but a universal selector never crosses a shadow boundary: every shadow root starts over at
+ * the UA default, `content-box`. So each component has to opt in, and until now 15 of them did
+ * so ad hoc — one of them with `content-box`, one with `!important`.
+ *
+ * Why this matters beyond tidiness: under `content-box`, padding and border are *size*. A rule
+ * that only means to repaint a chip — `:state(dragging) { border: none }` — silently shrinks it
+ * by two pixels per axis, the drag bank rewraps, and a drop target slides out from under the
+ * user's pointer mid-drag. Border-box is what makes "a state may repaint but never re-lay-out"
+ * a rule the CSS can actually keep.
+ *
+ * `:host` is set explicitly and descendants inherit, so a component that genuinely needs
+ * `content-box` for a subtree (an image map, say) can opt out at one node and have it hold for
+ * everything below it.
+ */
+export declare const boxSizing: import("lit").CSSResult;

package/dist/styles/box-sizing.styles.js

@@ -0,0 +1,31 @@
+import { css } from 'lit';
+/**
+ * The border-box reset, for shadow trees.
+ *
+ * `modern-normalize` applies `*, ::before, ::after { box-sizing: border-box }` to the document,
+ * but a universal selector never crosses a shadow boundary: every shadow root starts over at
+ * the UA default, `content-box`. So each component has to opt in, and until now 15 of them did
+ * so ad hoc — one of them with `content-box`, one with `!important`.
+ *
+ * Why this matters beyond tidiness: under `content-box`, padding and border are *size*. A rule
+ * that only means to repaint a chip — `:state(dragging) { border: none }` — silently shrinks it
+ * by two pixels per axis, the drag bank rewraps, and a drop target slides out from under the
+ * user's pointer mid-drag. Border-box is what makes "a state may repaint but never re-lay-out"
+ * a rule the CSS can actually keep.
+ *
+ * `:host` is set explicitly and descendants inherit, so a component that genuinely needs
+ * `content-box` for a subtree (an image map, say) can opt out at one node and have it hold for
+ * everything below it.
+ */
+export const boxSizing = css `
+  :host {
+    box-sizing: border-box;
+  }
+
+  *,
+  *::before,
+  *::after {
+    box-sizing: inherit;
+  }
+`;
+//# sourceMappingURL=box-sizing.styles.js.map

package/dist/styles/box-sizing.styles.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"box-sizing.styles.js","sourceRoot":"","sources":["../../src/styles/box-sizing.styles.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,KAAK,CAAC;AAE1B;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,GAAG,CAAA;;;;;;;;;;CAU3B,CAAC","sourcesContent":["import { css } from 'lit';\n\n/**\n * The border-box reset, for shadow trees.\n *\n * `modern-normalize` applies `*, ::before, ::after { box-sizing: border-box }` to the document,\n * but a universal selector never crosses a shadow boundary: every shadow root starts over at\n * the UA default, `content-box`. So each component has to opt in, and until now 15 of them did\n * so ad hoc — one of them with `content-box`, one with `!important`.\n *\n * Why this matters beyond tidiness: under `content-box`, padding and border are *size*. A rule\n * that only means to repaint a chip — `:state(dragging) { border: none }` — silently shrinks it\n * by two pixels per axis, the drag bank rewraps, and a drop target slides out from under the\n * user's pointer mid-drag. Border-box is what makes \"a state may repaint but never re-lay-out\"\n * a rule the CSS can actually keep.\n *\n * `:host` is set explicitly and descendants inherit, so a component that genuinely needs\n * `content-box` for a subtree (an image map, say) can opt out at one node and have it hold for\n * everything below it.\n */\nexport const boxSizing = css`\n  :host {\n    box-sizing: border-box;\n  }\n\n  *,\n  *::before,\n  *::after {\n    box-sizing: inherit;\n  }\n`;\n"]}