@longsightgroup/qti3-core 0.2.0 → 0.3.0

package/src/types.ts

@@ -416,7 +416,10 @@ export interface QtiAssessmentItem {
   title?: string | undefined;
   language?: string | undefined;
   adaptive: boolean;
+  timeDependent?: boolean | undefined;
+  attributes: Record<string, string>;
   prompt?: string | undefined;
+  itemBodySource?: QtiSourceLocation | undefined;
   responseDeclarations: QtiResponseDeclaration[];
   outcomeDeclarations: QtiOutcomeDeclaration[];
   templateDeclarations: QtiTemplateDeclaration[];

package/src/validation.ts

@@ -21,6 +21,7 @@ import type {
   QtiValidationResult,
 } from "./types.js";
 import { validateQtiDataSsmlMetadata } from "./tts.js";
+import { qtiValueToStringList } from "./value-format.js";
 
 const BUILT_IN_COMPLETION_STATUS = "completionStatus";
 
@@ -29,6 +30,8 @@ export function validateAssessmentItem(document: QtiDocument): QtiValidationResu
   const item = document.item;
 
   requireIdentifier("qti-assessment-item", item.identifier, diagnostics, item.source);
+  validateAssessmentItemRoot(item, diagnostics);
+  validateItemBody(item, diagnostics);
   validateDeclarationIdentifiers(item, diagnostics);
   validateOutcomeLookupTables(item, diagnostics);
   validateInteractions(item, diagnostics);
@@ -36,6 +39,7 @@ export function validateAssessmentItem(document: QtiDocument): QtiValidationResu
   validateCatalogInfo(item, diagnostics);
   validateStylesheets(item, diagnostics);
   diagnostics.push(...validateQtiDataSsmlMetadata(item));
+  validateResponseProcessingTemplate(item, diagnostics);
   validateProcessingReferences(item, diagnostics);
 
   return {
@@ -44,6 +48,152 @@ export function validateAssessmentItem(document: QtiDocument): QtiValidationResu
   };
 }
 
+function validateResponseProcessingTemplate(
+  item: QtiAssessmentItem,
+  diagnostics: QtiDiagnostic[],
+): void {
+  const template = item.responseProcessing?.template;
+  if (!template) return;
+  const templateKind = responseProcessingTemplateKind(template);
+  if (templateKind) {
+    validateBuiltInResponseProcessingTemplate(item, templateKind, diagnostics);
+    return;
+  }
+  diagnostics.push({
+    code: "processing.template.unsupported",
+    severity: "error",
+    message: `qti-response-processing template ${template} is not currently supported.`,
+    path: item.source?.path,
+    source: item.source,
+  });
+}
+
+function responseProcessingTemplateKind(
+  template: string,
+): "matchCorrect" | "mapResponse" | "mapResponsePoint" | undefined {
+  const path = template.split(/[?#]/, 1)[0] ?? "";
+  const name = path.slice(path.lastIndexOf("/") + 1).replace(/\.xml$/i, "");
+  if (name === "match_correct") return "matchCorrect";
+  if (name === "map_response") return "mapResponse";
+  if (name === "map_response_point") return "mapResponsePoint";
+  return undefined;
+}
+
+function validateAssessmentItemRoot(item: QtiAssessmentItem, diagnostics: QtiDiagnostic[]): void {
+  if (!item.attributes.title?.trim()) {
+    diagnostics.push({
+      code: "assessmentItem.title.required",
+      severity: "error",
+      message: "qti-assessment-item requires a non-empty title attribute.",
+      path: item.source?.path,
+      source: item.source,
+    });
+  }
+  const timeDependent = item.attributes["time-dependent"];
+  if (timeDependent === undefined || timeDependent.trim() === "") {
+    diagnostics.push({
+      code: "assessmentItem.timeDependent.required",
+      severity: "error",
+      message: "qti-assessment-item requires a time-dependent attribute.",
+      path: item.source?.path,
+      source: item.source,
+    });
+  } else if (!isXmlBoolean(timeDependent)) {
+    diagnostics.push({
+      code: "assessmentItem.timeDependent.boolean",
+      severity: "error",
+      message: `qti-assessment-item time-dependent must be an XML boolean, found ${timeDependent}.`,
+      path: item.source?.path,
+      source: item.source,
+    });
+  }
+}
+
+function validateBuiltInResponseProcessingTemplate(
+  item: QtiAssessmentItem,
+  templateKind: "matchCorrect" | "mapResponse" | "mapResponsePoint",
+  diagnostics: QtiDiagnostic[],
+): void {
+  const response = item.responseDeclarations.find(
+    (declaration) => declaration.identifier === "RESPONSE",
+  );
+  const score = item.outcomeDeclarations.find((declaration) => declaration.identifier === "SCORE");
+  if (!response) {
+    diagnostics.push({
+      code: "processing.template.responseIdentifier",
+      severity: "error",
+      message:
+        "Built-in response-processing templates require a response declaration named RESPONSE.",
+      path: item.source?.path,
+      source: item.source,
+    });
+  }
+  if (!score) {
+    diagnostics.push({
+      code: "processing.template.scoreIdentifier",
+      severity: "error",
+      message: "Built-in response-processing templates require an outcome declaration named SCORE.",
+      path: item.source?.path,
+      source: item.source,
+    });
+  } else if (score.cardinality !== "single" || score.baseType !== "float") {
+    diagnostics.push({
+      code: "processing.template.scoreDeclaration",
+      severity: "error",
+      message:
+        "Built-in response-processing templates require SCORE to be single cardinality with base-type float.",
+      path: score.source?.path,
+      source: score.source,
+    });
+  }
+  const responseInteractions = item.interactions.filter(
+    (interaction) => interaction.responseIdentifier === "RESPONSE",
+  );
+  if (responseInteractions.length !== 1 || item.interactions.length !== 1) {
+    diagnostics.push({
+      code: "processing.template.singleInteraction",
+      severity: "error",
+      message:
+        "Built-in response-processing templates require a single interaction bound to RESPONSE.",
+      path: item.source?.path,
+      source: item.source,
+    });
+  }
+  if (templateKind === "mapResponse" && response && !response.mapping) {
+    diagnostics.push({
+      code: "processing.template.mapping",
+      severity: "error",
+      message: "The map_response template requires RESPONSE to define qti-mapping.",
+      path: response.source?.path,
+      source: response.source,
+    });
+  }
+  if (templateKind === "mapResponsePoint" && response && !response.areaMapping) {
+    diagnostics.push({
+      code: "processing.template.areaMapping",
+      severity: "error",
+      message: "The map_response_point template requires RESPONSE to define qti-area-mapping.",
+      path: response.source?.path,
+      source: response.source,
+    });
+  }
+}
+
+function isXmlBoolean(value: string): boolean {
+  return value === "true" || value === "false" || value === "1" || value === "0";
+}
+
+function validateItemBody(item: QtiAssessmentItem, diagnostics: QtiDiagnostic[]): void {
+  if (item.itemBodySource) return;
+  diagnostics.push({
+    code: "itemBody.required",
+    severity: "error",
+    message: "qti-assessment-item requires a qti-item-body.",
+    path: item.source?.path,
+    source: item.source,
+  });
+}
+
 function requireIdentifier(
   elementName: string,
   identifier: string | undefined,
@@ -1599,8 +1749,7 @@ function validateCorrectResponseReferences(
 }
 
 function responseValues(value: QtiResponseDeclaration["correctResponse"]): string[] {
-  if (Array.isArray(value)) return value.map(String);
-  return [String(value)];
+  return qtiValueToStringList(value);
 }
 
 function invalidCorrectResponseReference(

package/src/value-format.ts

@@ -0,0 +1,39 @@
+import type { QtiScalarValue, QtiValue } from "./types.js";
+
+export function qtiScalarToString(value: QtiScalarValue): string {
+  return String(value);
+}
+
+export function qtiValueToString(value: QtiValue): string {
+  if (value === null) return "";
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return qtiScalarToString(value);
+  }
+  if (Array.isArray(value)) return value.map(qtiScalarToString).join(" ");
+  return JSON.stringify(value);
+}
+
+export function qtiValueToStringList(value: QtiValue): string[] {
+  if (value === null) return [""];
+  if (Array.isArray(value)) return value.map(qtiScalarToString);
+  if (typeof value === "object") return [JSON.stringify(value)];
+  return [qtiScalarToString(value)];
+}
+
+export function qtiValueToIdentifierList(value: QtiValue): string[] {
+  if (value === null) return [];
+  if (Array.isArray(value)) return value.map(qtiScalarToString);
+  if (typeof value === "object") return [JSON.stringify(value)];
+  return [qtiScalarToString(value)];
+}
+
+export function unknownToDisplayString(value: unknown): string {
+  if (value === undefined || value === null) return "";
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  if (typeof value === "bigint" || typeof value === "symbol") return String(value);
+  if (Array.isArray(value)) return value.map(unknownToDisplayString).join(", ");
+  if (typeof value === "object") return JSON.stringify(value);
+  return JSON.stringify(value);
+}

package/src/xml.ts

@@ -3,6 +3,8 @@ import { StaxXmlParserSync, XmlEventType } from "stax-xml";
 export interface XmlNode {
   name: string;
   localName: string;
+  prefix?: string | undefined;
+  uri?: string | undefined;
   attributes: Record<string, string>;
   children: XmlNode[];
   content: Array<string | XmlNode>;
@@ -40,6 +42,8 @@ export function parseXmlTree(xml: string): { root: XmlNode | undefined; errors:
       const node: XmlNode = {
         name: event.name,
         localName: event.localName ?? event.name,
+        prefix: event.prefix,
+        uri: event.uri,
         attributes: event.attributes,
         children: [],
         content: [],