@longsightgroup/qti3-core 0.10.2 → 0.10.3

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(