@longsightgroup/qti3-core 0.10.2 → 0.10.4

package/src/parser-declarations.ts

@@ -4,11 +4,13 @@ import {
   parseBaseType,
   parseCardinality,
   parseCoords,
+  parseFiniteNumber,
   parseShape,
   parseXmlBoolean,
 } from "./parser-values.js";
 import type {
   QtiBaseType,
+  QtiDiagnostic,
   QtiLookupTable,
   QtiOutcomeDeclaration,
   QtiResponseDeclaration,
@@ -16,9 +18,17 @@ import type {
   QtiTemplateDeclaration,
   QtiValue,
 } from "./types.js";
+import {
+  validateAreaMapEntryAttributes,
+  validateLookupTableEntryAttributes,
+  validateMapEntryAttributes,
+} from "./validation-declaration-entries.js";
 import { childElements, textContent, type XmlNode } from "./xml.js";
 
-export function parseResponseDeclaration(node: XmlNode): QtiResponseDeclaration {
+export function parseResponseDeclaration(
+  node: XmlNode,
+  diagnostics: QtiDiagnostic[],
+): QtiResponseDeclaration {
   const cardinality = parseCardinality(node.attributes.cardinality);
   const baseType = parseBaseType(node.attributes["base-type"]);
   return {
@@ -26,40 +36,66 @@ export function parseResponseDeclaration(node: XmlNode): QtiResponseDeclaration
     identifier: node.attributes.identifier ?? "",
     cardinality,
     baseType,
-    defaultValue: parseVariableValue(childElements(node, "qti-default-value")[0], baseType),
+    defaultValue: parseVariableValue(
+      childElements(node, "qti-default-value")[0],
+      baseType,
+      diagnostics,
+    ),
     correctResponse: normalizeValueForCardinality(
-      parseVariableValue(childElements(node, "qti-correct-response")[0], baseType),
+      parseVariableValue(childElements(node, "qti-correct-response")[0], baseType, diagnostics),
       cardinality,
     ),
-    mapping: parseMapping(childElements(node, "qti-mapping")[0]),
-    areaMapping: parseAreaMapping(childElements(node, "qti-area-mapping")[0]),
+    mapping: parseMapping(
+      childElements(node, "qti-mapping")[0],
+      node.attributes.identifier ?? "",
+      diagnostics,
+    ),
+    areaMapping: parseAreaMapping(
+      childElements(node, "qti-area-mapping")[0],
+      node.attributes.identifier ?? "",
+      diagnostics,
+    ),
     attributes: node.attributes,
     source: node.source,
   };
 }
 
-export function parseOutcomeDeclaration(node: XmlNode): QtiOutcomeDeclaration {
+export function parseOutcomeDeclaration(
+  node: XmlNode,
+  diagnostics: QtiDiagnostic[],
+): QtiOutcomeDeclaration {
   const baseType = parseBaseType(node.attributes["base-type"]);
   return {
     kind: "outcome",
     identifier: node.attributes.identifier ?? "",
     cardinality: parseCardinality(node.attributes.cardinality),
     baseType,
-    defaultValue: parseVariableValue(childElements(node, "qti-default-value")[0], baseType),
-    lookupTable: parseLookupTable(node, baseType),
+    defaultValue: parseVariableValue(
+      childElements(node, "qti-default-value")[0],
+      baseType,
+      diagnostics,
+    ),
+    lookupTable: parseLookupTable(node, baseType, diagnostics),
     attributes: node.attributes,
     source: node.source,
   };
 }
 
-export function parseTemplateDeclaration(node: XmlNode): QtiTemplateDeclaration {
+export function parseTemplateDeclaration(
+  node: XmlNode,
+  diagnostics: QtiDiagnostic[],
+): QtiTemplateDeclaration {
   const baseType = parseBaseType(node.attributes["base-type"]);
   return {
     kind: "template",
     identifier: node.attributes.identifier ?? "",
     cardinality: parseCardinality(node.attributes.cardinality),
     baseType,
-    defaultValue: parseVariableValue(childElements(node, "qti-default-value")[0], baseType),
+    defaultValue: parseVariableValue(
+      childElements(node, "qti-default-value")[0],
+      baseType,
+      diagnostics,
+    ),
     attributes: node.attributes,
     source: node.source,
   };
@@ -68,6 +104,7 @@ export function parseTemplateDeclaration(node: XmlNode): QtiTemplateDeclaration
 function parseVariableValue(
   node: XmlNode | undefined,
   baseType: QtiBaseType | undefined,
+  diagnostics: QtiDiagnostic[],
 ): QtiValue {
   if (!node) return null;
   const valueNodes = childElements(node, "qti-value");
@@ -79,6 +116,16 @@ function parseVariableValue(
     (entry): entry is { fieldIdentifier: string; value: QtiScalarValue } =>
       Boolean(entry.fieldIdentifier),
   );
+  const fieldedEntryCount = entries.filter((entry) => entry.fieldIdentifier !== undefined).length;
+  if (fieldedEntryCount > 0 && fieldedEntryCount < entries.length) {
+    diagnostics.push({
+      code: "declaration.value.fieldIdentifier.mixed",
+      severity: "error",
+      message: `${node.localName} must not mix qti-value children with and without field-identifier.`,
+      path: node.source.path,
+      source: node.source,
+    });
+  }
   if (recordEntries.length > 0) {
     return Object.fromEntries(recordEntries.map((entry) => [entry.fieldIdentifier, entry.value]));
   }
@@ -90,87 +137,134 @@ function parseVariableValue(
   return entries.map((entry) => entry.value);
 }
 
-function parseMapping(node: XmlNode | undefined): QtiResponseDeclaration["mapping"] | undefined {
+function parseMapping(
+  node: XmlNode | undefined,
+  declarationIdentifier: string,
+  diagnostics: QtiDiagnostic[],
+): QtiResponseDeclaration["mapping"] | undefined {
   if (!node) return undefined;
-  return {
-    defaultValue: Number(node.attributes["default-value"] ?? 0),
-    attributes: node.attributes,
-    source: node.source,
-    entries: childElements(node, "qti-map-entry").map((entry) => ({
+  const defaultValue = parseFiniteNumber(node.attributes["default-value"]);
+  const entries: NonNullable<QtiResponseDeclaration["mapping"]>["entries"] = [];
+  for (const entry of childElements(node, "qti-map-entry")) {
+    const mappedValue = parseFiniteNumber(entry.attributes["mapped-value"]);
+    if (mappedValue === undefined) {
+      validateMapEntryAttributes(declarationIdentifier, entry, diagnostics);
+      continue;
+    }
+    entries.push({
       mapKey: entry.attributes["map-key"],
-      mappedValue: Number(entry.attributes["mapped-value"] ?? 0),
+      mappedValue,
       attributes: entry.attributes,
       source: entry.source,
-    })),
+    });
+  }
+  return {
+    defaultValue: defaultValue ?? 0,
+    attributes: node.attributes,
+    source: node.source,
+    entries,
   };
 }
 
 function parseAreaMapping(
   node: XmlNode | undefined,
+  declarationIdentifier: string,
+  diagnostics: QtiDiagnostic[],
 ): QtiResponseDeclaration["areaMapping"] | undefined {
   if (!node) return undefined;
-  return {
-    defaultValue: Number(node.attributes["default-value"] ?? 0),
-    attributes: node.attributes,
-    source: node.source,
-    entries: childElements(node, "qti-area-map-entry").map((entry) => ({
+  const defaultValue = parseFiniteNumber(node.attributes["default-value"]);
+  const entries: NonNullable<QtiResponseDeclaration["areaMapping"]>["entries"] = [];
+  for (const entry of childElements(node, "qti-area-map-entry")) {
+    const mappedValue = parseFiniteNumber(entry.attributes["mapped-value"]);
+    if (mappedValue === undefined) {
+      validateAreaMapEntryAttributes(declarationIdentifier, entry, diagnostics);
+      continue;
+    }
+    entries.push({
       shape: parseShape(entry.attributes.shape),
       coords: parseCoords(entry.attributes.coords),
-      mappedValue: Number(entry.attributes["mapped-value"] ?? 0),
+      mappedValue,
       attributes: entry.attributes,
       source: entry.source,
-    })),
+    });
+  }
+  return {
+    defaultValue: defaultValue ?? 0,
+    attributes: node.attributes,
+    source: node.source,
+    entries,
   };
 }
 
 function parseLookupTable(
   node: XmlNode,
   baseType: QtiOutcomeDeclaration["baseType"],
+  diagnostics: QtiDiagnostic[],
 ): QtiLookupTable | undefined {
   const matchTable = childElements(node, "qti-match-table")[0];
-  if (matchTable) return parseMatchTable(matchTable, baseType);
+  if (matchTable) return parseMatchTable(matchTable, baseType, diagnostics);
   const interpolationTable = childElements(node, "qti-interpolation-table")[0];
-  if (interpolationTable) return parseInterpolationTable(interpolationTable, baseType);
+  if (interpolationTable) return parseInterpolationTable(interpolationTable, baseType, diagnostics);
   return undefined;
 }
 
 function parseMatchTable(
   node: XmlNode,
   baseType: QtiOutcomeDeclaration["baseType"],
+  diagnostics: QtiDiagnostic[],
 ): QtiLookupTable {
   return {
     type: "match",
     defaultValue: parseLookupValue(node.attributes["default-value"], baseType),
     attributes: node.attributes,
     source: node.source,
-    entries: childElements(node, "qti-match-table-entry").map((entry) => ({
-      sourceValue: Number(entry.attributes["source-value"]),
-      targetValue: parseLookupValue(entry.attributes["target-value"], baseType),
-      attributes: entry.attributes,
-      source: entry.source,
-    })),
+    entries: parseLookupEntries(node, "match", baseType, diagnostics),
   };
 }
 
 function parseInterpolationTable(
   node: XmlNode,
   baseType: QtiOutcomeDeclaration["baseType"],
+  diagnostics: QtiDiagnostic[],
 ): QtiLookupTable {
   return {
     type: "interpolation",
     defaultValue: parseLookupValue(node.attributes["default-value"], baseType),
     attributes: node.attributes,
     source: node.source,
-    entries: childElements(node, "qti-interpolation-table-entry").map((entry) => ({
-      sourceValue: Number(entry.attributes["source-value"]),
-      targetValue: parseLookupValue(entry.attributes["target-value"], baseType),
-      includeBoundary: parseXmlBoolean(entry.attributes["include-boundary"]) ?? true,
-      attributes: entry.attributes,
-      source: entry.source,
-    })),
+    entries: parseLookupEntries(node, "interpolation", baseType, diagnostics),
   };
 }
 
 function parseLookupValue(value: string | undefined, baseType: string | undefined): QtiValue {
   return value === undefined ? null : coerceValue(value, baseType);
 }
+
+function parseLookupEntries(
+  node: XmlNode,
+  tableType: QtiLookupTable["type"],
+  baseType: QtiOutcomeDeclaration["baseType"],
+  diagnostics: QtiDiagnostic[],
+): QtiLookupTable["entries"] {
+  const entryName =
+    tableType === "match" ? "qti-match-table-entry" : "qti-interpolation-table-entry";
+  const entries: QtiLookupTable["entries"] = [];
+  for (const entry of childElements(node, entryName)) {
+    const sourceValue = parseFiniteNumber(entry.attributes["source-value"]);
+    if (sourceValue === undefined) {
+      validateLookupTableEntryAttributes(tableType, entry, diagnostics);
+      continue;
+    }
+    entries.push({
+      sourceValue,
+      targetValue: parseLookupValue(entry.attributes["target-value"], baseType),
+      includeBoundary:
+        tableType === "interpolation"
+          ? (parseXmlBoolean(entry.attributes["include-boundary"]) ?? true)
+          : undefined,
+      attributes: entry.attributes,
+      source: entry.source,
+    });
+  }
+  return entries;
+}

package/src/parser-item-metadata.ts

@@ -19,6 +19,7 @@ import {
   type ParsedCompanionMaterialChildQtiName,
   pushCompanionMaterialParseWarning,
 } from "./companion-materials.js";
+import { visibleTextContent } from "./content-text.js";
 import { parseXmlBoolean } from "./parser-values.js";
 import { childElements, descendants, textContent, type XmlNode } from "./xml.js";
 
@@ -75,7 +76,7 @@ export function parseModalFeedback(node: XmlNode): QtiModalFeedback {
     identifier: node.attributes.identifier ?? "",
     outcomeIdentifier: node.attributes["outcome-identifier"] ?? "",
     showHide,
-    text: textContent(node),
+    text: visibleTextContent(node),
     source: node.source,
   };
 }
@@ -119,7 +120,7 @@ function parseCatalogCardEntry(node: XmlNode): QtiCatalogCardEntry {
 function parseCatalogHtmlContent(node: XmlNode | undefined): QtiCatalogHtmlContent | undefined {
   if (!node) return undefined;
   return {
-    text: textContent(node),
+    text: visibleTextContent(node),
     children: parseCatalogHtmlChildren(node),
     attributes: node.attributes,
     source: node.source,
@@ -136,6 +137,7 @@ function parseCatalogHtmlChildren(node: XmlNode): QtiContentNode[] {
     content.push({
       kind: "element",
       qtiName: entry.localName,
+      namespaceUri: entry.uri,
       attributes: entry.attributes,
       children: parseCatalogHtmlChildren(entry),
       source: entry.source,
@@ -202,7 +204,7 @@ function parsePhysicalMaterial(
   node: XmlNode,
   diagnostics: QtiDiagnostic[],
 ): QtiPhysicalMaterial | undefined {
-  const text = textContent(node).trim();
+  const text = visibleTextContent(node);
   if (text.length === 0) {
     return pushCompanionMaterialParseWarning(
       diagnostics,

package/src/parser-processing.ts

@@ -646,15 +646,16 @@ function parseExpression(node: XmlNode): QtiProcessingExpression | undefined {
   }
 
   if (node.localName === "qti-stats-operator") {
-    const expression = parseFirstExpression(node);
-    if (expression) {
-      return {
-        type: "statsOperator",
-        name: node.attributes.name ?? "",
-        expression,
-        source: node.source,
-      };
-    }
+    const expressions = childElements(node)
+      .map(parseExpression)
+      .filter((expression): expression is QtiProcessingExpression => expression !== undefined);
+    return {
+      type: "statsOperator",
+      name: node.attributes.name ?? "",
+      expression: expressions[0] ?? { type: "null", source: node.source },
+      expressions,
+      source: node.source,
+    };
   }
 
   if (node.localName === "qti-custom-operator") {

package/src/parser-values.ts

@@ -20,6 +20,7 @@ const QTI_BASE_TYPES = new Set<string>([
   "file",
   "uri",
 ]);
+const QTI_FINITE_FLOAT_PATTERN = /^[+-]?(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+)(?:[Ee][+-]?[0-9]+)?$/;
 
 export function isQtiBaseType(value: string): value is QtiBaseType {
   return QTI_BASE_TYPES.has(value);
@@ -43,8 +44,11 @@ export function numericTuple4(values: number[]): [number, number, number, number
 }
 
 export function coerceValue(value: string, baseType: string | undefined): QtiScalarValue {
-  if (baseType === "integer") return Number.parseInt(value, 10);
-  if (baseType === "float") return Number.parseFloat(value);
+  if (baseType === "integer") return parseInteger(value) ?? value;
+  if (baseType === "float") return parseFiniteNumber(value) ?? value;
+  if (baseType === "pair" || baseType === "directedPair") {
+    return parseQtiPair(value, baseType) ?? value;
+  }
   if (baseType === "boolean") {
     const parsed = parseXmlBoolean(value);
     if (parsed !== undefined) return parsed;
@@ -53,6 +57,26 @@ export function coerceValue(value: string, baseType: string | undefined): QtiSca
   return value;
 }
 
+/** Parse and canonicalize a QTI pair while preserving directed-pair endpoint order. */
+export function parseQtiPair(
+  value: string | undefined,
+  baseType: "pair" | "directedPair",
+): string | undefined {
+  if (value === undefined) return undefined;
+  const parts = value.trim().split(/\s+/);
+  if (parts.length !== 2 || parts.some((part) => part.length === 0)) return undefined;
+  return (baseType === "pair" ? parts.toSorted() : parts).join(" ");
+}
+
+/** Parse a complete integer lexical value without accepting a numeric prefix. */
+export function parseInteger(value: string | undefined): number | undefined {
+  if (value === undefined) return undefined;
+  const normalized = value.trim();
+  if (!/^-?\d+$/.test(normalized)) return undefined;
+  const parsed = Number(normalized);
+  return Number.isInteger(parsed) ? parsed : undefined;
+}
+
 export function parseCardinality(value: string | undefined): QtiCardinality {
   if (value === "multiple" || value === "ordered" || value === "record") return value;
   return "single";
@@ -66,6 +90,15 @@ export function parseXmlBoolean(value: string | undefined): boolean | undefined
   return undefined;
 }
 
+/** Parse the finite subset of the XML Schema float lexical space used by QTI values. */
+export function parseFiniteNumber(value: string | undefined): number | undefined {
+  if (value === undefined) return undefined;
+  const normalized = value.trim();
+  if (!QTI_FINITE_FLOAT_PATTERN.test(normalized)) return undefined;
+  const parsed = Number(normalized);
+  return Number.isFinite(parsed) ? parsed : undefined;
+}
+
 export function normalizeValueForCardinality(
   value: QtiValue,
   cardinality: QtiCardinality,