@longsightgroup/qti3-core 0.1.1 → 0.2.0

package/dist/validation.js

@@ -1,3 +1,4 @@
+import { validateQtiDataSsmlMetadata } from "./tts.js";
 const BUILT_IN_COMPLETION_STATUS = "completionStatus";
 export function validateAssessmentItem(document) {
     const diagnostics = [];
@@ -9,6 +10,7 @@ export function validateAssessmentItem(document) {
     validateModalFeedback(item, diagnostics);
     validateCatalogInfo(item, diagnostics);
     validateStylesheets(item, diagnostics);
+    diagnostics.push(...validateQtiDataSsmlMetadata(item));
     validateProcessingReferences(item, diagnostics);
     return {
         ok: diagnostics.every((diagnostic) => diagnostic.severity !== "error"),
@@ -1141,7 +1143,9 @@ function validateInteractions(item, diagnostics) {
         validateInteractionChoices(interaction, diagnostics);
         validateInteractionChildren(interaction, diagnostics);
         validateInteractionRequiredAttributes(interaction, diagnostics);
+        validatePortableCustomInteraction(interaction, item, diagnostics);
         validateInteractionLimitAttributes(interaction, diagnostics);
+        validateGraphicHotspotObjectDimensions(interaction, diagnostics);
         validateCorrectResponseReferences(interaction, interaction.responseIdentifier
             ? responseDeclarations.get(interaction.responseIdentifier)
             : undefined, diagnostics);
@@ -1152,7 +1156,7 @@ function validateInteractions(item, diagnostics) {
 }
 function validateInteractionResponseReference(interaction, responseIdentifiers, diagnostics) {
     if (!interaction.responseIdentifier) {
-        if (interaction.type !== "endAttempt" && interaction.type !== "media") {
+        if (interaction.type !== "endAttempt") {
             diagnostics.push({
                 code: "interaction.responseIdentifier",
                 severity: "error",
@@ -1323,18 +1327,19 @@ function validateInteractionChildren(interaction, diagnostics) {
     }
 }
 function validateInteractionRequiredAttributes(interaction, diagnostics) {
-    if (requiresObject(interaction) && !interaction.object?.data) {
+    if (requiresObject(interaction) && !hasRequiredObjectAsset(interaction)) {
         diagnostics.push({
             code: "interaction.object.required",
             severity: "error",
-            message: `${interaction.qtiName} requires an object child with a data attribute.`,
+            message: interaction.type === "drawing"
+                ? `${interaction.qtiName} requires an object, img, or picture canvas with a data/src attribute.`
+                : `${interaction.qtiName} requires an object, img, audio, or video child with a data/src attribute or media sources.`,
             path: interaction.source?.path,
             source: interaction.source,
         });
     }
     if (interaction.type === "portableCustom") {
         requireInteractionAttribute(interaction, "custom-interaction-type-identifier", "interaction.portableCustom.typeIdentifier", diagnostics);
-        requireInteractionAttribute(interaction, "module", "interaction.portableCustom.module", diagnostics);
     }
     if (interaction.type === "slider") {
         const lower = interaction.attributes["lower-bound"];
@@ -1374,7 +1379,16 @@ function requiresObject(interaction) {
         interaction.type === "hotspot" ||
         interaction.type === "selectPoint" ||
         interaction.type === "positionObject" ||
-        interaction.type === "media");
+        interaction.type === "media" ||
+        interaction.type === "drawing");
+}
+function hasRequiredObjectAsset(interaction) {
+    if (interaction.type === "media") {
+        return Boolean(interaction.object?.data || interaction.object?.sources.some((source) => Boolean(source.src)));
+    }
+    if (interaction.type === "drawing")
+        return Boolean(interaction.object?.data);
+    return Boolean(interaction.object?.data);
 }
 function requireInteractionAttribute(interaction, attribute, code, diagnostics) {
     if (interaction.attributes[attribute])
@@ -1387,6 +1401,95 @@ function requireInteractionAttribute(interaction, attribute, code, diagnostics)
         source: interaction.source,
     });
 }
+function validatePortableCustomInteraction(interaction, item, diagnostics) {
+    if (interaction.type !== "portableCustom")
+        return;
+    const definition = interaction.portableCustom;
+    if (!definition)
+        return;
+    const configuredModules = definition.interactionModules?.modules ?? [];
+    const hasModuleAttribute = Boolean(definition.module?.trim());
+    const hasConfiguredModule = configuredModules.some((module) => Boolean(module.id?.trim()));
+    if (!hasModuleAttribute && !hasConfiguredModule) {
+        diagnostics.push({
+            code: "interaction.portableCustom.module",
+            severity: "error",
+            message: `${interaction.qtiName} requires a module attribute or at least one qti-interaction-module id.`,
+            path: interaction.source?.path,
+            source: interaction.source,
+        });
+    }
+    for (const module of configuredModules) {
+        if (!module.id?.trim()) {
+            diagnostics.push({
+                code: "interaction.portableCustom.moduleId",
+                severity: "error",
+                message: "qti-interaction-module requires a non-empty id.",
+                path: module.source?.path,
+                source: module.source,
+            });
+        }
+        warnExternalPortableCustomUrl(module.primaryPath, module.source, diagnostics);
+        warnExternalPortableCustomUrl(module.fallbackPath, module.source, diagnostics);
+    }
+    warnExternalPortableCustomUrl(definition.interactionModules?.primaryConfiguration, definition.interactionModules?.source, diagnostics);
+    warnExternalPortableCustomUrl(definition.interactionModules?.secondaryConfiguration, definition.interactionModules?.source, diagnostics);
+    const templateIdentifiers = new Set(item.templateDeclarations.map((declaration) => declaration.identifier));
+    for (const variable of definition.templateVariables) {
+        if (!variable.identifier?.trim()) {
+            diagnostics.push({
+                code: "interaction.portableCustom.templateVariable",
+                severity: "error",
+                message: "qti-template-variable requires template-identifier or identifier.",
+                path: variable.source?.path,
+                source: variable.source,
+            });
+            continue;
+        }
+        if (!templateIdentifiers.has(variable.identifier)) {
+            diagnostics.push({
+                code: "interaction.portableCustom.templateVariable.reference",
+                severity: "error",
+                message: `qti-template-variable references missing template declaration ${variable.identifier}.`,
+                path: variable.source?.path,
+                source: variable.source,
+            });
+        }
+    }
+    for (const variable of definition.contextVariables) {
+        if (variable.identifier?.trim())
+            continue;
+        diagnostics.push({
+            code: "interaction.portableCustom.contextVariable",
+            severity: "error",
+            message: "qti-context-variable requires identifier.",
+            path: variable.source?.path,
+            source: variable.source,
+        });
+    }
+    for (const stylesheet of definition.stylesheets) {
+        if (stylesheet.href.trim().length > 0)
+            continue;
+        diagnostics.push({
+            code: "stylesheet.href.required",
+            severity: "error",
+            message: "qti-stylesheet requires a non-empty href attribute.",
+            path: stylesheet.source?.path,
+            source: stylesheet.source,
+        });
+    }
+}
+function warnExternalPortableCustomUrl(url, source, diagnostics) {
+    if (!url || !/^https?:\/\//i.test(url))
+        return;
+    diagnostics.push({
+        code: "interaction.portableCustom.externalModuleUrl",
+        severity: "warning",
+        message: `Portable custom interaction module URL ${url} requires host delivery policy approval.`,
+        path: source?.path,
+        source,
+    });
+}
 function invalidNumber(interaction, attribute, value, diagnostics) {
     diagnostics.push({
         code: "interaction.numericAttribute",
@@ -1405,6 +1508,13 @@ function validateInteractionLimitAttributes(interaction, diagnostics) {
     validateNonNegativeIntegerAttribute(interaction, "expected-lines", diagnostics);
     validateMinMaxPair(interaction, "min-choices", "max-choices", diagnostics);
     validateMinMaxPair(interaction, "min-associations", "max-associations", 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, diagnostics) {
     if (requiresMatchMax(choice) && !choice.attributes["match-max"]) {
@@ -1482,6 +1592,89 @@ function validateHotspotGeometry(choice, diagnostics) {
         });
     }
 }
+function validateGraphicHotspotObjectDimensions(interaction, diagnostics) {
+    if (!usesGraphicHotspots(interaction))
+        return;
+    const hotspotChoices = interaction.choices.filter(isHotspotChoice);
+    if (hotspotChoices.length === 0)
+        return;
+    const width = positiveDimension(interaction.object?.width);
+    const height = positiveDimension(interaction.object?.height);
+    if (width === undefined || height === undefined) {
+        diagnostics.push({
+            code: "interaction.graphicObjectDimensions",
+            severity: "warning",
+            message: `${interaction.qtiName} should declare object width and height so hotspot coords map to the rendered image.`,
+            path: interaction.object?.source?.path ?? interaction.source?.path,
+            source: interaction.object?.source ?? interaction.source,
+        });
+        return;
+    }
+    for (const choice of hotspotChoices) {
+        const bounds = hotspotBounds(choice);
+        if (!bounds)
+            continue;
+        if (bounds.left >= 0 && bounds.top >= 0 && bounds.right <= width && bounds.bottom <= height) {
+            continue;
+        }
+        diagnostics.push({
+            code: "choice.coords.bounds",
+            severity: "warning",
+            message: `${choice.qtiName} ${choice.identifier} coords extend outside the ${width} by ${height} object image.`,
+            path: choice.source?.path,
+            source: choice.source,
+        });
+    }
+}
+function usesGraphicHotspots(interaction) {
+    return (interaction.type === "graphicOrder" ||
+        interaction.type === "graphicAssociate" ||
+        interaction.type === "graphicGapMatch" ||
+        interaction.type === "hotspot");
+}
+function isHotspotChoice(choice) {
+    return choice.qtiName === "qti-hotspot-choice" || choice.qtiName === "qti-associable-hotspot";
+}
+function positiveDimension(value) {
+    if (!value || value.trim().endsWith("%"))
+        return undefined;
+    const match = value.trim().match(/^(\d+(?:\.\d+)?|\.\d+)(?:px)?$/i);
+    if (!match?.[1])
+        return undefined;
+    const parsed = Number(match[1]);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
+}
+function hotspotBounds(choice) {
+    const shape = choice.attributes.shape;
+    const coords = choice.attributes.coords;
+    if (!shape || !coords || !isHotspotShape(shape) || !isNumericCsv(coords))
+        return undefined;
+    const values = numericCsv(coords);
+    if (!hasValidShapeCoordinateCount(shape, values))
+        return undefined;
+    if (shape === "default")
+        return undefined;
+    if (shape === "circle") {
+        const [x, y, radius] = values;
+        return { left: x - radius, top: y - radius, right: x + radius, bottom: y + radius };
+    }
+    if (shape === "ellipse") {
+        const [x, y, radiusX, radiusY] = values;
+        return { left: x - radiusX, top: y - radiusY, right: x + radiusX, bottom: y + radiusY };
+    }
+    if (shape === "rect") {
+        const [left, top, right, bottom] = values;
+        return { left, top, right, bottom };
+    }
+    const xs = values.filter((_, index) => index % 2 === 0);
+    const ys = values.filter((_, index) => index % 2 === 1);
+    return {
+        left: Math.min(...xs),
+        top: Math.min(...ys),
+        right: Math.max(...xs),
+        bottom: Math.max(...ys),
+    };
+}
 function isHotspotShape(value) {
     return (value === "circle" ||
         value === "default" ||
@@ -1528,6 +1721,18 @@ function validateNonNegativeIntegerAttribute(interaction, attribute, diagnostics
         source: interaction.source,
     });
 }
+function validateBooleanAttribute(interaction, attribute, diagnostics) {
+    const value = interaction.attributes[attribute];
+    if (value === undefined || isBooleanAttribute(value))
+        return;
+    diagnostics.push({
+        code: "interaction.booleanAttribute",
+        severity: "error",
+        message: `${interaction.qtiName} requires boolean ${attribute}, got ${value}.`,
+        path: interaction.source?.path,
+        source: interaction.source,
+    });
+}
 function validateChoiceNonNegativeIntegerAttribute(choice, attribute, diagnostics) {
     const value = choice.attributes[attribute];
     if (value === undefined || isNonNegativeInteger(value))
@@ -1615,13 +1820,20 @@ function allowedInteractionChildren(interaction) {
             return setOf(common, ["object", "img", "qti-position-object-stage"]);
         case "selectPoint":
         case "media":
-            return setOf(common, ["object", "img"]);
+            return setOf(common, ["audio", "video", "object", "img"]);
         case "drawing":
-            return setOf(common, ["object", "img"]);
+            return setOf(common, ["object", "img", "picture"]);
         case "extendedText":
             return new Set(common);
         case "portableCustom":
-            return setOf(common, ["qti-interaction-markup"]);
+            return setOf(common, [
+                "qti-interaction-markup",
+                "qti-interaction-modules",
+                "qti-template-variable",
+                "qti-context-variable",
+                "qti-stylesheet",
+                "qti-catalog-info",
+            ]);
         case "slider":
         case "textEntry":
         case "upload":
@@ -1662,6 +1874,9 @@ function isInteger(value) {
 function isNonNegativeInteger(value) {
     return /^\d+$/.test(value);
 }
+function isBooleanAttribute(value) {
+    return value === "true" || value === "false" || value === "1" || value === "0";
+}
 function isPoint(value) {
     const parts = value.trim().split(/\s+/);
     return parts.length === 2 && parts.every(isFiniteNumber);
@@ -1675,7 +1890,7 @@ function expectedResponseShape(interaction) {
         return { cardinalities: ["single"], baseTypes: ["boolean"] };
     }
     if (interaction.type === "media")
-        return undefined;
+        return { cardinalities: ["single"], baseTypes: ["integer"] };
     if (interaction.type === "custom")
         return undefined;
     if (interaction.type === "order" || interaction.type === "graphicOrder") {
@@ -1701,8 +1916,25 @@ function expectedResponseShape(interaction) {
     if (interaction.type === "textEntry" || interaction.type === "extendedText") {
         return { cardinalities: ["single"], baseTypes: ["string"] };
     }
-    if (interaction.type === "drawing" || interaction.type === "portableCustom") {
-        return { cardinalities: ["single"], baseTypes: ["string", "file", "uri"] };
+    if (interaction.type === "drawing")
+        return { cardinalities: ["single"], baseTypes: ["file"] };
+    if (interaction.type === "portableCustom") {
+        return {
+            cardinalities: ["single", "multiple", "ordered", "record"],
+            baseTypes: [
+                "identifier",
+                "boolean",
+                "integer",
+                "float",
+                "string",
+                "point",
+                "pair",
+                "directedPair",
+                "duration",
+                "file",
+                "uri",
+            ],
+        };
     }
     return { cardinalities: ["single", "multiple"], baseTypes: ["identifier"] };
 }