@longsightgroup/qti3-core 0.7.1 → 0.7.3

package/src/parser.ts

@@ -1,3 +1,4 @@
+import { flatTextFromContent } from "./content-text.js";
 import { getInteractionSupport, interactionNameToType, processingSupport } from "./support.js";
 import type {
   QtiAssessmentItem,
@@ -480,13 +481,22 @@ function parseInteraction(
               (child) => child.localName === "object" || child.localName === "img",
             )[0];
 
+  const promptContent = prompt
+    ? parseContentChildren(prompt, diagnostics, responseDeclarationMap, [])
+    : undefined;
+
   return {
     type: interactionType ?? "custom",
     qtiName: node.localName,
     responseIdentifier,
     responseCardinality: responseDeclaration?.cardinality,
     responseBaseType: responseDeclaration?.baseType,
-    prompt: prompt ? textContent(prompt) : undefined,
+    prompt: promptContent
+      ? flatTextFromContent(promptContent, { excludeAnnotations: true }) || undefined
+      : prompt
+        ? textContent(prompt)
+        : undefined,
+    promptContent: promptContent && promptContent.length > 0 ? promptContent : undefined,
     promptAttributes: prompt?.attributes,
     promptSource: prompt?.source,
     contextText: inlineInteractionContext(node, interactionType),
@@ -499,7 +509,7 @@ function parseInteraction(
       interactionType === "portableCustom"
         ? parsePortableCustomDefinition(node, diagnostics)
         : undefined,
-    choices: parseChoices(node),
+    choices: parseChoices(node, diagnostics, responseDeclarationMap),
     hottextSegments: interactionType === "hottext" ? parseHottextSegments(node) : undefined,
     gapMatchSegments:
       interactionType === "gapMatch" || interactionType === "graphicGapMatch"
@@ -965,7 +975,11 @@ function assetTypeFromData(data: string | undefined): string | undefined {
   return undefined;
 }
 
-function parseChoices(node: XmlNode): QtiChoice[] {
+function parseChoices(
+  node: XmlNode,
+  diagnostics: QtiDiagnostic[],
+  responseDeclarationMap: Map<string, QtiResponseDeclaration>,
+): QtiChoice[] {
   const choiceNames = new Set([
     "qti-simple-choice",
     "qti-simple-associable-choice",
@@ -981,14 +995,20 @@ function parseChoices(node: XmlNode): QtiChoice[] {
   return descendants(node, (child) => choiceNames.has(child.localName)).map((choice, index) => {
     const identifier = choice.attributes.identifier ?? "";
     const asset = parseChoiceAsset(choice);
+    const content = parseContentChildren(choice, diagnostics, responseDeclarationMap, []);
+    const flatChoiceText =
+      content.length > 0
+        ? flatTextFromContent(content, { excludeAnnotations: true })
+        : textContent(choice);
     return {
       identifier,
       text:
-        textContent(choice) ||
+        flatChoiceText ||
         choice.attributes["object-label"] ||
         asset?.text ||
         identifier ||
         `Choice ${index + 1}`,
+      content: content.length > 0 ? content : undefined,
       asset,
       role: choiceRole(choice),
       qtiName: choice.localName,

package/src/pattern-mask.ts

@@ -0,0 +1,20 @@
+/** Compiles a QTI pattern-mask attribute value for full-string matching. */
+export function compileQtiPatternMask(patternMask: string | undefined): RegExp | undefined {
+  if (patternMask === undefined) return undefined;
+  let mask = patternMask.trim();
+  if (mask.length === 0) return undefined;
+
+  mask = mask.startsWith("^") ? mask.slice(1) : mask;
+  mask = mask.endsWith("$") ? mask.slice(0, -1) : mask;
+  if (mask.length === 0) return undefined;
+
+  try {
+    return new RegExp(`^(?:${mask.replaceAll("/", "\\/")})$`);
+  } catch {
+    return undefined;
+  }
+}
+
+export function isValidQtiPatternMask(patternMask: string): boolean {
+  return compileQtiPatternMask(patternMask) !== undefined;
+}

package/src/shared-vocabulary-generated-families.ts

@@ -237,7 +237,7 @@ export const sharedVocabularyMatrixCoverageFamilies: SharedVocabularyMatrixCover
     levels: ["stylesheet"],
     coveredBy: ["qti-writing-orientation-vertical-rl"],
     rationale:
-      "Choice writing-orientation classes share the vertical choice layout path; vertical-rl covers the orientation rule and upright labels.",
+      "Choice and inline-choice writing-orientation classes share vertical rendering paths; vertical-rl covers the representative orientation rule.",
     matches: (className) => choiceWritingOrientationPattern.test(className),
   },
 ];

package/src/shared-vocabulary-support.ts

@@ -39,7 +39,10 @@ const browserBehaviorTests = [
   "tests/browser/player-dom-behavior.spec.ts",
   ...sharedVocabularyMatrixTests,
 ];
-const graphicBrowserTests = ["tests/browser/player-graphic.spec.ts"];
+const graphicBrowserTests = [
+  "tests/browser/player-graphic.spec.ts",
+  "tests/browser/player-graphic-gap-match.spec.ts",
+];
 const mediaBrowserTests = ["tests/browser/player.spec.ts", ...sharedVocabularyMatrixTests];
 const mediaPlayerFixture =
   "packages/fixtures/packages/sv-matrix/items/media-controls-and-pause.xml";
@@ -226,7 +229,7 @@ export const sharedVocabularyClassSupport: SharedVocabularyClassSupport[] = [
   ...SHARED_VOCABULARY_CHOICE_WRITING_ORIENTATIONS.map((orientation) =>
     interactionStylesheetEntry(
       `qti-writing-orientation-${orientation}`,
-      ["choice"],
+      ["choice", "inlineChoice"],
       [...browserBehaviorTests],
     ),
   ),

package/src/shared-vocabulary-validation.ts

@@ -97,6 +97,7 @@ export function validateSharedVocabularyInputWidth(
 export interface SharedVocabularyExtendedTextValidationOptions {
   classNames: string[];
   subjectQtiName: string;
+  expectedLength?: string | undefined;
   path?: string | undefined;
   source?: QtiSourceLocation | undefined;
 }
@@ -122,7 +123,7 @@ export function validateSharedVocabularyExtendedTextHeightLines(
 export function validateSharedVocabularyExtendedTextCounter(
   options: SharedVocabularyExtendedTextValidationOptions,
 ): QtiDiagnostic[] {
-  const { classNames, subjectQtiName, path, source } = options;
+  const { classNames, subjectQtiName, expectedLength, path, source } = options;
   const diagnostics: QtiDiagnostic[] = [];
   const counterClasses = supportedExtendedTextCounterClassNames(classNames);
   if (new Set(counterClasses).size > 1) {
@@ -135,6 +136,16 @@ export function validateSharedVocabularyExtendedTextCounter(
     });
   }
 
+  if (counterClasses.length > 0 && !expectedLength) {
+    diagnostics.push({
+      code: "interaction.sharedVocabulary.extendedTextCounterExpectedLength",
+      severity: "warning",
+      message: `${subjectQtiName} uses ${[...new Set(counterClasses)].join(", ")} but does not define expected-length; qti-counter-* shared vocabulary depends on expected-length.`,
+      path,
+      source,
+    });
+  }
+
   for (const className of classNames) {
     if (!className.startsWith("qti-counter-")) continue;
     if (isSupportedExtendedTextCounterClassName(className)) continue;

package/src/shared-vocabulary.ts

@@ -106,6 +106,47 @@ export function extendedTextCounterPosition(
   return extendedTextCounterPositionFromAttributes(interaction.attributes);
 }
 
+export function extendedTextExpectedLengthFromAttributes(
+  attributes: Record<string, string>,
+): number | undefined {
+  const raw = attributes["expected-length"];
+  if (raw === undefined) return undefined;
+  const length = Number(raw);
+  if (!Number.isFinite(length) || length < 0) return undefined;
+  return length;
+}
+
+export interface ExtendedTextCounterState {
+  position: SharedVocabularyExtendedTextCounterPosition;
+  expectedLength: number;
+}
+
+/** Counter chrome is authored only when both qti-counter-* and a valid expected-length are present. */
+export function extendedTextCounterStateFromAttributes(
+  attributes: Record<string, string>,
+): ExtendedTextCounterState | undefined {
+  const position = extendedTextCounterPositionFromAttributes(attributes);
+  if (position === undefined) return undefined;
+  const expectedLength = extendedTextExpectedLengthFromAttributes(attributes);
+  if (expectedLength === undefined) return undefined;
+  return { position, expectedLength };
+}
+
+export function extendedTextCounterState(
+  interaction: QtiInteraction,
+): ExtendedTextCounterState | undefined {
+  return extendedTextCounterStateFromAttributes(interaction.attributes);
+}
+
+export function extendedTextCounterValues(
+  position: SharedVocabularyExtendedTextCounterPosition,
+  valueLength: number,
+  expectedLength: number,
+): { count: number; expectedLength: number } {
+  const count = position === "down" ? Math.max(0, expectedLength - valueLength) : valueLength;
+  return { count, expectedLength };
+}
+
 export function supportedInputWidthClassNames(classNames: string[]): string[] {
   return classNames.filter((className) => {
     const value = inputWidthClassPattern.exec(className)?.[1];

package/src/support.ts

@@ -10,7 +10,7 @@ export const interactionSupport: QtiInteractionElementSupport[] = [
   entry("qti-choice-interaction", "choice"),
   entry("qti-drawing-interaction", "drawing"),
   entry("qti-end-attempt-interaction", "endAttempt"),
-  entry("qti-extended-text-interaction", "extendedText"),
+  extendedTextInteractionEntry(),
   entry("qti-gap-match-interaction", "gapMatch"),
   entry("qti-graphic-associate-interaction", "graphicAssociate"),
   entry("qti-graphic-gap-match-interaction", "graphicGapMatch"),
@@ -25,7 +25,7 @@ export const interactionSupport: QtiInteractionElementSupport[] = [
   pciEntry(),
   entry("qti-select-point-interaction", "selectPoint"),
   entry("qti-slider-interaction", "slider"),
-  entry("qti-text-entry-interaction", "textEntry"),
+  textEntryInteractionEntry(),
   entry("qti-upload-interaction", "upload"),
 ];
 
@@ -225,6 +225,46 @@ function entry(qtiName: string, interactionType: QtiInteractionType): QtiInterac
   };
 }
 
+function extendedTextInteractionEntry(): QtiInteractionElementSupport {
+  return {
+    ...entry("qti-extended-text-interaction", "extendedText"),
+    fixtures: [
+      "packages/fixtures/xml/extendedText-reference.xml",
+      "packages/fixtures/packages/sv-matrix/items/extended-text-pattern-mask.xml",
+      "packages/fixtures/packages/sv-matrix/items/extended-text-xhtml.xml",
+    ],
+    tests: [
+      "packages/fixtures/src/fixtures.test.ts",
+      "packages/conformance/src/conformance.test.ts",
+      "packages/a11y/src/a11y.test.ts",
+      "packages/core/src/pattern-mask.test.ts",
+      "tests/browser/player.spec.ts",
+      "tests/browser/player-dom-behavior.spec.ts",
+      "tests/browser/player-extended-text-xhtml.spec.ts",
+    ],
+    notes: "Supports plain and format=xhtml extended text.",
+  };
+}
+
+function textEntryInteractionEntry(): QtiInteractionElementSupport {
+  return {
+    ...entry("qti-text-entry-interaction", "textEntry"),
+    fixtures: [
+      "packages/fixtures/xml/textEntry-reference.xml",
+      "packages/fixtures/packages/sv-matrix/items/text-entry-pattern-mask-inline.xml",
+    ],
+    tests: [
+      "packages/fixtures/src/fixtures.test.ts",
+      "packages/conformance/src/conformance.test.ts",
+      "packages/a11y/src/a11y.test.ts",
+      "packages/core/src/pattern-mask.test.ts",
+      "tests/browser/player.spec.ts",
+      "tests/browser/player-dom-behavior.spec.ts",
+    ],
+    notes: "Supports placeholder-text and pattern-mask on text-entry controls.",
+  };
+}
+
 function pciEntry(): QtiInteractionElementSupport {
   return {
     ...entry("qti-portable-custom-interaction", "portableCustom"),

package/src/types.ts

@@ -138,7 +138,10 @@ export interface QtiTemplateDeclaration extends QtiVariableDeclaration {
 
 export interface QtiChoice {
   identifier: string;
+  /** Plain-text fallback used for speech, TTS, diagnostics, and native controls. */
   text: string;
+  /** Parsed visual content for renderers that can display rich choice markup such as MathML. */
+  content?: QtiContentNode[] | undefined;
   asset?: QtiObjectAsset | undefined;
   role: QtiChoiceRole;
   qtiName: string;
@@ -192,7 +195,10 @@ export interface QtiInteraction {
   responseIdentifier?: string | undefined;
   responseCardinality?: QtiCardinality | undefined;
   responseBaseType?: QtiBaseType | undefined;
+  /** Flat accessibility/fallback label derived from prompt content with annotations stripped. */
   prompt?: string | undefined;
+  /** Structured prompt content for visual rendering. When present, block headings render this instead of prompt. */
+  promptContent?: QtiContentNode[] | undefined;
   promptAttributes?: Record<string, string> | undefined;
   promptSource?: QtiSourceLocation | undefined;
   contextText?: string | undefined;

package/src/validation.ts

@@ -26,6 +26,7 @@ import {
   validateSharedVocabularyInputWidth,
   validateSharedVocabularyMediaPlayerControls,
 } from "./shared-vocabulary-validation.js";
+import { isValidQtiPatternMask } from "./pattern-mask.js";
 import { validateQtiDataSsmlMetadata } from "./tts.js";
 import { qtiValueToStringList } from "./value-format.js";
 
@@ -1672,6 +1673,7 @@ function validateInteractions(item: QtiAssessmentItem, diagnostics: QtiDiagnosti
     validateInteractionRequiredAttributes(interaction, diagnostics);
     validatePortableCustomInteraction(interaction, item, diagnostics);
     validateInteractionLimitAttributes(interaction, diagnostics);
+    validatePatternMaskAttribute(interaction, diagnostics);
     validateGraphicHotspotObjectDimensions(interaction, diagnostics);
     validateCorrectResponseReferences(
       interaction,
@@ -1724,6 +1726,7 @@ function validateInteractionSharedVocabulary(
       ...validateSharedVocabularyExtendedText({
         classNames,
         subjectQtiName: interaction.qtiName,
+        expectedLength: interaction.attributes["expected-length"],
         path: interaction.source?.path,
         source: interaction.source,
       }),
@@ -2526,6 +2529,22 @@ function invalidNumber(
   });
 }
 
+function validatePatternMaskAttribute(
+  interaction: QtiInteraction,
+  diagnostics: QtiDiagnostic[],
+): void {
+  if (interaction.type !== "textEntry" && interaction.type !== "extendedText") return;
+  const patternMask = interaction.attributes["pattern-mask"];
+  if (patternMask === undefined || isValidQtiPatternMask(patternMask)) return;
+  diagnostics.push({
+    code: "interaction.patternMask.invalid",
+    severity: "error",
+    message: `${interaction.qtiName} pattern-mask is not a valid regular expression.`,
+    path: interaction.source?.path,
+    source: interaction.source,
+  });
+}
+
 function validateInteractionLimitAttributes(
   interaction: QtiInteraction,
   diagnostics: QtiDiagnostic[],

package/src/xml.ts

@@ -142,6 +142,12 @@ const inlineMixedContentChildNames = new Set([
   "i",
   "kbd",
   "mark",
+  "math",
+  "mi",
+  "mn",
+  "mo",
+  "mrow",
+  "msup",
   "q",
   "rp",
   "rt",
@@ -174,6 +180,8 @@ function restoreMixedContentFromSource(xml: string, node: XmlNode): void {
     if (typeof entry !== "string") restoreMixedContentFromSource(xml, entry);
   }
 
+  restoreLeafTextFromSource(xml, node);
+
   if (!shouldRestoreMixedContentWhitespace(node)) return;
 
   const contentEndOffset = node.endSource?.offset ?? node.sourceRange.endOffset;
@@ -203,11 +211,26 @@ function restoreMixedContentFromSource(xml: string, node: XmlNode): void {
   node.text = restored.filter((entry): entry is string => typeof entry === "string").join("");
 }
 
+function restoreLeafTextFromSource(xml: string, node: XmlNode): void {
+  if (node.children.length > 0) return;
+  const contentEndOffset = node.endSource?.offset ?? node.sourceRange.endOffset;
+  if (node.sourceRange.startTagEndOffset < 0 || contentEndOffset === undefined) return;
+  const raw = xml.slice(node.sourceRange.startTagEndOffset + 1, contentEndOffset);
+  if (raw.includes("<![CDATA[")) return;
+  const decoded = decodeXmlCharacterData(stripNonCharacterMarkup(raw));
+  node.text = decoded;
+  node.content = decoded.length > 0 ? [decoded] : [];
+}
+
 function appendDecodedTextSegment(content: Array<string | XmlNode>, raw: string): void {
-  const decoded = decodeXmlCharacterData(raw);
+  const decoded = decodeXmlCharacterData(stripNonCharacterMarkup(raw));
   if (decoded.length > 0) content.push(decoded);
 }
 
+function stripNonCharacterMarkup(value: string): string {
+  return value.replace(/<!--[\s\S]*?-->/g, "").replace(/<\?[\s\S]*?\?>/g, "");
+}
+
 const predefinedXmlEntities: Record<string, string> = {
   amp: "&",
   apos: "'",