@longsightgroup/qti3-core 0.10.2 → 0.10.4

package/src/validation-interactions.ts

@@ -9,6 +9,8 @@ import type {
 } from "./types.js";
 import { assertNever } from "./assert-never.js";
 import { isValidQtiPatternMask } from "./pattern-mask.js";
+import { parseQtiMediaDefinition } from "./media-definition.js";
+import { parseQtiSliderDefinition } from "./slider-definition.js";
 import { validateInteractionSharedVocabulary } from "./shared-vocabulary-interaction-validation.js";
 import { qtiValueToStringList } from "./value-format.js";
 import {
@@ -17,7 +19,6 @@ import {
 } from "./validation-geometry.js";
 import {
   isBooleanAttribute,
-  isFiniteNumber,
   isNonNegativeInteger,
   requireIdentifier,
 } from "./validation-primitives.js";
@@ -104,7 +105,11 @@ function validateInteractionResponseShape(
     });
   }
 
-  if (interaction.responseBaseType && !expected.baseTypes.includes(interaction.responseBaseType)) {
+  if (
+    interaction.type !== "slider" &&
+    interaction.responseBaseType &&
+    !expected.baseTypes.includes(interaction.responseBaseType)
+  ) {
     diagnostics.push({
       code: "interaction.baseType",
       severity: "error",
@@ -305,46 +310,13 @@ function validateInteractionRequiredAttributes(
   }
 
   if (interaction.type === "slider") {
-    const lower = interaction.attributes["lower-bound"];
-    const upper = interaction.attributes["upper-bound"];
-    requireInteractionAttribute(
-      interaction,
-      "lower-bound",
-      "interaction.slider.lowerBound",
-      diagnostics,
-    );
-    requireInteractionAttribute(
-      interaction,
-      "upper-bound",
-      "interaction.slider.upperBound",
-      diagnostics,
-    );
-    if (lower !== undefined && !isFiniteNumber(lower)) {
-      invalidNumber(interaction, "lower-bound", lower, diagnostics);
-    }
-    if (upper !== undefined && !isFiniteNumber(upper)) {
-      invalidNumber(interaction, "upper-bound", upper, diagnostics);
-    }
-    if (
-      lower !== undefined &&
-      upper !== undefined &&
-      isFiniteNumber(lower) &&
-      isFiniteNumber(upper)
-    ) {
-      if (Number(lower) >= Number(upper)) {
-        diagnostics.push({
-          code: "interaction.slider.bounds",
-          severity: "error",
-          message: `${interaction.qtiName} requires lower-bound to be less than upper-bound.`,
-          path: interaction.source?.path,
-          source: interaction.source,
-        });
-      }
-    }
-    const step = interaction.attributes.step;
-    if (step !== undefined && (!isFiniteNumber(step) || Number(step) <= 0)) {
-      invalidNumber(interaction, "step", step, diagnostics);
-    }
+    const definition = parseQtiSliderDefinition(interaction);
+    if (!definition.ok) diagnostics.push(...definition.diagnostics);
+  }
+
+  if (interaction.type === "media") {
+    const definition = parseQtiMediaDefinition(interaction);
+    if (!definition.ok) diagnostics.push(...definition.diagnostics);
   }
 }
 
@@ -497,21 +469,6 @@ function warnExternalPortableCustomUrl(
   });
 }
 
-function invalidNumber(
-  interaction: QtiInteraction,
-  attribute: string,
-  value: string,
-  diagnostics: QtiDiagnostic[],
-): void {
-  diagnostics.push({
-    code: "interaction.numericAttribute",
-    severity: "error",
-    message: `${interaction.qtiName} requires numeric ${attribute}, got ${value}.`,
-    path: interaction.source?.path,
-    source: interaction.source,
-  });
-}
-
 function validatePatternMaskAttribute(
   interaction: QtiInteraction,
   diagnostics: QtiDiagnostic[],
@@ -542,13 +499,6 @@ function validateInteractionLimitAttributes(
   validateMinMaxPair(interaction, "min-choices", "max-choices", diagnostics);
   validateMinMaxPair(interaction, "min-associations", "max-associations", diagnostics);
   validateBooleanAttribute(interaction, "required", diagnostics);
-  if (interaction.type === "media") {
-    validateNonNegativeIntegerAttribute(interaction, "max-plays", diagnostics);
-    validateNonNegativeIntegerAttribute(interaction, "min-plays", diagnostics);
-    validateBooleanAttribute(interaction, "autostart", diagnostics);
-    validateBooleanAttribute(interaction, "loop", diagnostics);
-    validateMinMaxPair(interaction, "min-plays", "max-plays", diagnostics);
-  }
 }
 
 function validateChoiceLimitAttributes(choice: QtiChoice, diagnostics: QtiDiagnostic[]): void {

package/src/validation-primitives.ts

@@ -1,5 +1,6 @@
-import type { QtiBaseType, QtiCardinality, QtiDiagnostic } from "./types.js";
-import { parseXmlBoolean } from "./parser-values.js";
+import type { QtiBaseType, QtiCardinality, QtiDiagnostic, QtiScalarValue } from "./types.js";
+import { assertNever } from "./assert-never.js";
+import { parseFiniteNumber, parseInteger, parseQtiPair, parseXmlBoolean } from "./parser-values.js";
 
 export function requireIdentifier(
   qtiName: string,
@@ -38,11 +39,11 @@ export function isBaseType(value: string): value is QtiBaseType {
 }
 
 export function isFiniteNumber(value: string): boolean {
-  return Number.isFinite(Number(value));
+  return parseFiniteNumber(value) !== undefined;
 }
 
 export function isInteger(value: string): boolean {
-  return /^-?\d+$/.test(value);
+  return parseInteger(value) !== undefined;
 }
 
 export function isNonNegativeInteger(value: string): boolean {
@@ -67,3 +68,42 @@ export function isPair(value: string): boolean {
   const parts = value.trim().split(/\s+/);
   return parts.length === 2 && parts.every((part) => part.length > 0);
 }
+
+/** Parse and normalize a runtime scalar for a QTI base type. */
+export function parseQtiScalarForBaseType(
+  value: QtiScalarValue,
+  baseType: QtiBaseType,
+): QtiScalarValue | undefined {
+  switch (baseType) {
+    case "integer":
+      if (typeof value === "number") return Number.isInteger(value) ? value : undefined;
+      return typeof value === "string" ? parseInteger(value) : undefined;
+    case "float":
+      if (typeof value === "number") return Number.isFinite(value) ? value : undefined;
+      return typeof value === "string" ? parseFiniteNumber(value) : undefined;
+    case "boolean":
+      if (typeof value === "boolean") return value;
+      return typeof value === "string" ? parseXmlBoolean(value) : undefined;
+    case "point":
+      return typeof value === "string" && isPoint(value) ? value : undefined;
+    case "pair":
+    case "directedPair":
+      return typeof value === "string" ? parseQtiPair(value, baseType) : undefined;
+    case "identifier":
+      return typeof value === "string" && value.trim().length > 0 && !/\s/.test(value)
+        ? value
+        : undefined;
+    case "string":
+    case "duration":
+    case "file":
+    case "uri":
+      return typeof value === "string" ? value : undefined;
+    default:
+      return assertNever(baseType);
+  }
+}
+
+/** Check a runtime scalar against the value representation accepted for a QTI base type. */
+export function qtiScalarMatchesBaseType(value: QtiScalarValue, baseType: QtiBaseType): boolean {
+  return parseQtiScalarForBaseType(value, baseType) !== undefined;
+}

package/src/validation-processing.ts

@@ -8,6 +8,7 @@ import type {
   QtiTemplateRule,
 } from "./types.js";
 import { expressionChildren } from "./processing-expression-children.js";
+import { MAX_QTI_REPEAT_RESULT_ELEMENTS } from "./processing-limits.js";
 import { MATH_OPERATOR_NAMES, STATS_OPERATOR_NAMES } from "./processing-operators.js";
 import {
   responseProcessingTemplateKind,
@@ -450,6 +451,11 @@ function validateExpressionReferences(
     );
   }
 
+  if (expression.type === "anyN") {
+    validateAnyNBound("min", expression.min, responses, variables, diagnostics, expression.source);
+    validateAnyNBound("max", expression.max, responses, variables, diagnostics, expression.source);
+  }
+
   if (expression.type === "mathConstant" && !mathConstantNames.has(expression.name)) {
     diagnostics.push({
       code: "processing.mathConstant.name",
@@ -480,6 +486,35 @@ function validateExpressionReferences(
     });
   }
 
+  if (
+    (expression.type === "sum" ||
+      expression.type === "product" ||
+      expression.type === "min" ||
+      expression.type === "max") &&
+    expression.expressions.length === 0
+  ) {
+    diagnostics.push({
+      code: "processing.numeric.arity",
+      severity: "error",
+      message: `qti-${expression.type} requires at least one child expression.`,
+      path: expression.source?.path,
+      source: expression.source,
+    });
+  }
+
+  if (
+    expression.type === "statsOperator" &&
+    (expression.expressions ?? [expression.expression]).length !== 1
+  ) {
+    diagnostics.push({
+      code: "processing.statsOperator.arity",
+      severity: "error",
+      message: "qti-stats-operator requires exactly one child expression.",
+      path: expression.source?.path,
+      source: expression.source,
+    });
+  }
+
   if (expression.type === "repeat") {
     validateRepeatExpression(expression, variables, diagnostics);
   }
@@ -540,7 +575,31 @@ function validateRepeatExpression(
   variables: Set<string>,
   diagnostics: QtiDiagnostic[],
 ): void {
-  if (isInteger(expression.numberRepeats)) return;
+  if (isInteger(expression.numberRepeats)) {
+    const repeats = BigInt(expression.numberRepeats);
+    if (repeats < 0n) {
+      diagnostics.push(repeatCountDiagnostic(expression));
+      return;
+    }
+    const minimumPerRepeat = minimumProducedElements(expression.expressions);
+    if (
+      repeats > BigInt(MAX_QTI_REPEAT_RESULT_ELEMENTS) ||
+      repeats * BigInt(minimumPerRepeat) > BigInt(MAX_QTI_REPEAT_RESULT_ELEMENTS)
+    ) {
+      diagnostics.push({
+        code: "processing.repeat.limit",
+        severity: "error",
+        message: `qti-repeat cannot exceed ${MAX_QTI_REPEAT_RESULT_ELEMENTS} iterations or produced elements.`,
+        path: expression.source?.path,
+        source: expression.source,
+      });
+    }
+    return;
+  }
+  if (Number.isFinite(Number(expression.numberRepeats))) {
+    diagnostics.push(repeatCountDiagnostic(expression));
+    return;
+  }
   validateProcessingIdentifier(
     expression.numberRepeats,
     "processing.repeat.numberRepeats",
@@ -558,6 +617,91 @@ function validateRepeatExpression(
   }
 }
 
+function validateAnyNBound(
+  attribute: "min" | "max",
+  value: string,
+  responses: Set<string>,
+  variables: Set<string>,
+  diagnostics: QtiDiagnostic[],
+  source: QtiDiagnostic["source"],
+): void {
+  if (value.length === 0) {
+    diagnostics.push({
+      code: `processing.anyN.${attribute}.required`,
+      severity: "error",
+      message: `qti-any-n requires ${attribute}.`,
+      path: source?.path,
+      source,
+    });
+    return;
+  }
+  if (isInteger(value)) return;
+  if (Number.isFinite(Number(value))) {
+    diagnostics.push({
+      code: `processing.anyN.${attribute}.integer`,
+      severity: "error",
+      message: `qti-any-n ${attribute} must be an integer or a declared variable.`,
+      path: source?.path,
+      source,
+    });
+    return;
+  }
+  if (!variables.has(value) || responses.has(value)) {
+    diagnostics.push({
+      code: `processing.anyN.${attribute}.reference`,
+      severity: "error",
+      message: `qti-any-n ${attribute} references missing template or outcome variable ${value}.`,
+      path: source?.path,
+      source,
+    });
+  }
+}
+
+function repeatCountDiagnostic(
+  expression: Extract<QtiProcessingExpression, { type: "repeat" }>,
+): QtiDiagnostic {
+  return {
+    code: "processing.repeat.numberRepeats",
+    severity: "error",
+    message: "qti-repeat requires a non-negative integer or a declared variable.",
+    path: expression.source?.path,
+    source: expression.source,
+  };
+}
+
+function minimumProducedElements(expressions: QtiProcessingExpression[]): number {
+  let total = 0;
+  for (const expression of expressions) {
+    total = cappedElementCount(total + minimumExpressionElements(expression));
+  }
+  return total;
+}
+
+function minimumExpressionElements(expression: QtiProcessingExpression): number {
+  if (expression.type === "baseValue") return 1;
+  if (expression.type === "multiple" || expression.type === "ordered") {
+    return minimumProducedElements(expression.expressions);
+  }
+  if (expression.type === "random") {
+    if (expression.values.length === 0) return 0;
+    let minimum = MAX_QTI_REPEAT_RESULT_ELEMENTS + 1;
+    for (const value of expression.values) {
+      minimum = Math.min(minimum, minimumExpressionElements(value));
+    }
+    return minimum;
+  }
+  if (expression.type !== "repeat" || !/^\d+$/.test(expression.numberRepeats)) return 0;
+  const perRepeat = minimumProducedElements(expression.expressions);
+  const projected = BigInt(expression.numberRepeats) * BigInt(perRepeat);
+  return projected > BigInt(MAX_QTI_REPEAT_RESULT_ELEMENTS)
+    ? MAX_QTI_REPEAT_RESULT_ELEMENTS + 1
+    : Number(projected);
+}
+
+function cappedElementCount(value: number): number {
+  return Math.min(value, MAX_QTI_REPEAT_RESULT_ELEMENTS + 1);
+}
+
 function validateInsideExpression(
   expression: Extract<QtiProcessingExpression, { type: "inside" }>,
   diagnostics: QtiDiagnostic[],

package/src/validation.ts

@@ -16,11 +16,10 @@ import { assertNever } from "./assert-never.js";
 import { validateQtiDataSsmlMetadata } from "./tts.js";
 import { validateCompanionMaterials } from "./validation-companion-materials.js";
 import {
-  hasValidShapeCoordinateCount,
-  isAreaShape,
-  isNumericCsv,
-  numericCsv,
-} from "./validation-geometry.js";
+  validateAreaMapEntryAttributes,
+  validateLookupTableEntryAttributes,
+  validateMapEntryAttributes,
+} from "./validation-declaration-entries.js";
 import {
   isBaseType,
   isBooleanAttribute,
@@ -237,7 +236,8 @@ function isValidDeclarationBaseValue(value: string, baseType: QtiBaseType): bool
 function validateMapping(declaration: QtiResponseDeclaration, diagnostics: QtiDiagnostic[]): void {
   const mapping = declaration.mapping;
   if (!mapping) return;
-  if (!Number.isFinite(mapping.defaultValue)) {
+  const defaultValue = mapping.attributes["default-value"];
+  if (defaultValue !== undefined && !isFiniteNumber(defaultValue)) {
     diagnostics.push({
       code: "mapping.defaultValue",
       severity: "error",
@@ -249,42 +249,7 @@ function validateMapping(declaration: QtiResponseDeclaration, diagnostics: QtiDi
   validateMappingBounds(declaration, mapping.attributes, mapping.source, "mapping", diagnostics);
 
   for (const entry of mapping.entries) {
-    validateMapEntry(declaration, entry, diagnostics);
-  }
-}
-
-function validateMapEntry(
-  declaration: QtiResponseDeclaration,
-  entry: NonNullable<QtiResponseDeclaration["mapping"]>["entries"][number],
-  diagnostics: QtiDiagnostic[],
-): void {
-  if (!entry.attributes["map-key"]) {
-    diagnostics.push({
-      code: "mapEntry.mapKey.required",
-      severity: "error",
-      message: `Response declaration ${declaration.identifier} map entry requires map-key.`,
-      path: entry.source?.path,
-      source: entry.source,
-    });
-  }
-
-  const mappedValue = entry.attributes["mapped-value"];
-  if (mappedValue === undefined) {
-    diagnostics.push({
-      code: "mapEntry.mappedValue.required",
-      severity: "error",
-      message: `Response declaration ${declaration.identifier} map entry requires mapped-value.`,
-      path: entry.source?.path,
-      source: entry.source,
-    });
-  } else if (!isFiniteNumber(mappedValue)) {
-    diagnostics.push({
-      code: "mapEntry.mappedValue",
-      severity: "error",
-      message: `Response declaration ${declaration.identifier} map entry requires numeric mapped-value.`,
-      path: entry.source?.path,
-      source: entry.source,
-    });
+    validateMapEntryAttributes(declaration.identifier, entry, diagnostics);
   }
 }
 
@@ -294,7 +259,8 @@ function validateAreaMapping(
 ): void {
   const areaMapping = declaration.areaMapping;
   if (!areaMapping) return;
-  if (!Number.isFinite(areaMapping.defaultValue)) {
+  const defaultValue = areaMapping.attributes["default-value"];
+  if (defaultValue !== undefined && !isFiniteNumber(defaultValue)) {
     diagnostics.push({
       code: "areaMapping.defaultValue",
       severity: "error",
@@ -312,7 +278,7 @@ function validateAreaMapping(
   );
 
   for (const entry of areaMapping.entries) {
-    validateAreaMapEntry(declaration, entry, diagnostics);
+    validateAreaMapEntryAttributes(declaration.identifier, entry, diagnostics);
   }
 }
 
@@ -360,82 +326,6 @@ function validateMappingBounds(
   }
 }
 
-function validateAreaMapEntry(
-  declaration: QtiResponseDeclaration,
-  entry: NonNullable<QtiResponseDeclaration["areaMapping"]>["entries"][number],
-  diagnostics: QtiDiagnostic[],
-): void {
-  const shape = entry.attributes.shape;
-  const coords = entry.attributes.coords;
-  const mappedValue = entry.attributes["mapped-value"];
-
-  if (!shape) {
-    diagnostics.push({
-      code: "areaMapEntry.shape.required",
-      severity: "error",
-      message: `Response declaration ${declaration.identifier} area map entry requires shape.`,
-      path: entry.source?.path,
-      source: entry.source,
-    });
-  } else if (!isAreaShape(shape)) {
-    diagnostics.push({
-      code: "areaMapEntry.shape",
-      severity: "error",
-      message: `Response declaration ${declaration.identifier} area map entry has unsupported shape ${shape}.`,
-      path: entry.source?.path,
-      source: entry.source,
-    });
-  }
-
-  if (!coords) {
-    diagnostics.push({
-      code: "areaMapEntry.coords.required",
-      severity: "error",
-      message: `Response declaration ${declaration.identifier} area map entry requires coords.`,
-      path: entry.source?.path,
-      source: entry.source,
-    });
-  } else if (!isNumericCsv(coords)) {
-    diagnostics.push({
-      code: "areaMapEntry.coords",
-      severity: "error",
-      message: `Response declaration ${declaration.identifier} area map entry requires comma-separated numeric coords.`,
-      path: entry.source?.path,
-      source: entry.source,
-    });
-  } else if (
-    shape &&
-    isAreaShape(shape) &&
-    !hasValidShapeCoordinateCount(shape, numericCsv(coords))
-  ) {
-    diagnostics.push({
-      code: "areaMapEntry.coords.shape",
-      severity: "error",
-      message: `Response declaration ${declaration.identifier} area map entry shape ${shape} has invalid coords arity.`,
-      path: entry.source?.path,
-      source: entry.source,
-    });
-  }
-
-  if (mappedValue === undefined) {
-    diagnostics.push({
-      code: "areaMapEntry.mappedValue.required",
-      severity: "error",
-      message: `Response declaration ${declaration.identifier} area map entry requires mapped-value.`,
-      path: entry.source?.path,
-      source: entry.source,
-    });
-  } else if (!isFiniteNumber(mappedValue)) {
-    diagnostics.push({
-      code: "areaMapEntry.mappedValue",
-      severity: "error",
-      message: `Response declaration ${declaration.identifier} area map entry requires numeric mapped-value.`,
-      path: entry.source?.path,
-      source: entry.source,
-    });
-  }
-}
-
 function validateDeclarationRequiredAttributes(
   declaration: QtiResponseDeclaration | QtiOutcomeDeclaration | QtiTemplateDeclaration,
   diagnostics: QtiDiagnostic[],
@@ -502,37 +392,7 @@ function validateOutcomeLookupTables(item: QtiAssessmentItem, diagnostics: QtiDi
       });
     }
     for (const entry of lookupTable.entries) {
-      if (!isFiniteNumber(entry.attributes["source-value"] ?? "")) {
-        diagnostics.push({
-          code: "lookupTable.entry.sourceValue",
-          severity: "error",
-          message: "Lookup table entry requires numeric source-value.",
-          path: entry.source?.path,
-          source: entry.source,
-        });
-      }
-      if (entry.attributes["target-value"] === undefined) {
-        diagnostics.push({
-          code: "lookupTable.entry.targetValue",
-          severity: "error",
-          message: "Lookup table entry requires target-value.",
-          path: entry.source?.path,
-          source: entry.source,
-        });
-      }
-      if (
-        lookupTable.type === "match" &&
-        entry.attributes["source-value"] !== undefined &&
-        !isInteger(entry.attributes["source-value"])
-      ) {
-        diagnostics.push({
-          code: "lookupTable.match.sourceValue",
-          severity: "error",
-          message: "qti-match-table-entry source-value must be an integer.",
-          path: entry.source?.path,
-          source: entry.source,
-        });
-      }
+      validateLookupTableEntryAttributes(lookupTable.type, entry, diagnostics);
     }
   }
 }

package/src/xml.ts

@@ -190,10 +190,9 @@ export function descendants(node: XmlNode, predicate: (node: XmlNode) => boolean
 }
 
 export function textContent(node: XmlNode): string {
-  const parts = node.content.map((entry) =>
-    typeof entry === "string" ? entry : textContent(entry),
-  );
-  return parts.join(" ").replace(/\s+/g, " ").trim();
+  return node.content
+    .map((entry) => (typeof entry === "string" ? entry : textContent(entry)))
+    .join("");
 }
 
 function openElement(
@@ -212,12 +211,21 @@ function openElement(
   const attributes: Record<string, string> = {};
   const inheritedNamespaces = state.namespaceStack.at(-1)?.namespaces ?? {};
   const namespaces: Record<string, string> = { ...inheritedNamespaces };
+  const uniqueAttributes: ParsedAttribute[] = [];
+  const qualifiedAttributeNames = new Set<string>();
   for (const attribute of parsedAttributes) {
+    if (qualifiedAttributeNames.has(attribute.name)) {
+      state.errors.push(new Error(`Duplicate XML attribute ${attribute.name}.`));
+      continue;
+    }
+    qualifiedAttributeNames.add(attribute.name);
+    uniqueAttributes.push(attribute);
     attributes[attribute.name] = attribute.value;
     if (attribute.name === "xmlns") namespaces[""] = attribute.value;
     else if (attribute.name.startsWith("xmlns:"))
       namespaces[attribute.name.slice(6)] = attribute.value;
   }
+  validateUniqueExpandedAttributeNames(uniqueAttributes, namespaces, state);
 
   const { prefix, localName } = splitQualifiedName(name);
   const path = nodePath(parent, localName);
@@ -498,6 +506,34 @@ function splitQualifiedName(name: string): {
   };
 }
 
+function validateUniqueExpandedAttributeNames(
+  attributes: readonly ParsedAttribute[],
+  namespaces: Readonly<Record<string, string>>,
+  state: ParserState,
+): void {
+  const expandedNames = new Map<string, string>();
+  for (const attribute of attributes) {
+    if (attribute.name === "xmlns" || attribute.name.startsWith("xmlns:")) continue;
+
+    const { prefix, localName } = splitQualifiedName(attribute.name);
+    const namespaceUri = prefix ? namespaces[prefix] : "";
+    if (namespaceUri === undefined) continue;
+
+    const expandedName = `${namespaceUri}\u0000${localName}`;
+    const previousName = expandedNames.get(expandedName);
+    if (previousName) {
+      const displayName = namespaceUri ? `{${namespaceUri}}${localName}` : localName;
+      state.errors.push(
+        new Error(
+          `XML attributes ${previousName} and ${attribute.name} have duplicate expanded name ${displayName}.`,
+        ),
+      );
+      continue;
+    }
+    expandedNames.set(expandedName, attribute.name);
+  }
+}
+
 function buildLineStarts(xml: string): number[] {
   const lineStarts = [0];
   for (let index = 0; index < xml.length; index += 1) {