@longsightgroup/qti3-core 0.9.9 → 0.9.10

package/src/index.ts

@@ -52,31 +52,40 @@ export {
 } from "./package-xml.js";
 export {
   decodeUtf8,
+  discoverQtiPackageContentAssets,
   normalizePackagePath,
   QTI_ITEM_RESOURCE_TYPE,
   QTI_PACKAGE_MANIFEST_PATH,
   parseQtiPackage,
   readQtiPackageZipEntries,
+  type QtiAssessmentSectionPackageModel,
   type QtiAssessmentTestItemRef,
   type QtiAssessmentTestPackageModel,
   type QtiManifestFile,
   type QtiManifestResource,
   type QtiPackageAsset,
+  type QtiPackageContentAssetDiscovery,
   type QtiPackageAssetSource,
   type QtiPackageEntry,
   type QtiPackageInflateContext,
   type QtiPackageInflateRaw,
+  type QtiItemSessionControl,
   type QtiPackageItem,
   type QtiPackageItemSource,
   type QtiPackageParseOptions,
   type QtiPackageParseResult,
   type QtiPackageShape,
   type QtiStandardAlignment,
+  type QtiTestPartNavigationMode,
+  type QtiTestPartPackageModel,
+  type QtiTestPartSubmissionMode,
+  type QtiTimeLimits,
   type QtiTimingMetadata,
 } from "./qti-package.js";
 export { detectPackageMediaType } from "./qti-package-assets.js";
 export { parseQtiXml } from "./parser.js";
 export { numericTuple3, numericTuple4 } from "./parser-values.js";
+export { collectQtiResponseProcessingExpressions } from "./processing-expression-collection.js";
 export { isConformanceParseDiagnostic } from "./parse-diagnostics.js";
 export {
   scoreQtiItemServerSide,

package/src/parser-processing.ts

@@ -21,6 +21,10 @@ export function parseResponseProcessing(
     template: node.attributes.template,
     rules,
     conditions: responseConditionsFromRules(rules),
+    expressions: node.children.flatMap((child) => {
+      const expression = parseExpression(child);
+      return expression ? [expression] : [];
+    }),
   };
 }
 

package/src/processing-expression-collection.ts

@@ -0,0 +1,57 @@
+import { expressionChildren } from "./processing-expression-children.js";
+import type {
+  QtiProcessingExpression,
+  QtiResponseCondition,
+  QtiResponseProcessing,
+  QtiResponseRule,
+} from "./types.js";
+
+/** Collect every processing expression in a parsed response-processing tree. */
+export function collectQtiResponseProcessingExpressions(
+  processing: QtiResponseProcessing | undefined,
+): QtiProcessingExpression[] {
+  if (!processing) return [];
+  const expressions: QtiProcessingExpression[] = [];
+  for (const expression of processing.expressions ?? []) collectExpression(expression, expressions);
+  collectRules(processing.rules, expressions);
+  for (const condition of processing.conditions) collectCondition(condition, expressions);
+  return expressions;
+}
+
+function collectRules(
+  rules: readonly QtiResponseRule[],
+  expressions: QtiProcessingExpression[],
+): void {
+  for (const rule of rules) {
+    if (rule.type === "setOutcomeValue" || rule.type === "lookupOutcomeValue") {
+      collectExpression(rule.expression, expressions);
+      continue;
+    }
+    if (rule.type === "responseCondition") {
+      collectCondition(rule.condition, expressions);
+      continue;
+    }
+    if (rule.type === "responseProcessingFragment") collectRules(rule.rules, expressions);
+  }
+}
+
+function collectCondition(
+  condition: QtiResponseCondition,
+  expressions: QtiProcessingExpression[],
+): void {
+  if (condition.ifExpression) collectExpression(condition.ifExpression, expressions);
+  collectRules(condition.thenRules, expressions);
+  for (const branch of condition.elseIfs) {
+    if (branch.expression) collectExpression(branch.expression, expressions);
+    collectRules(branch.rules, expressions);
+  }
+  collectRules(condition.elseRules, expressions);
+}
+
+function collectExpression(
+  expression: QtiProcessingExpression,
+  expressions: QtiProcessingExpression[],
+): void {
+  expressions.push(expression);
+  for (const child of expressionChildren(expression)) collectExpression(child, expressions);
+}

package/src/qti-package-assets.ts

@@ -1,9 +1,11 @@
 import { pushPackageDiagnostic } from "./qti-package-paths.js";
+import { parseQtiPackageXmlTree } from "./package-xml.js";
 import type {
   QtiAssessmentTestPackageModel,
   QtiManifestResource,
   QtiPackageAsset,
   QtiPackageAssetSource,
+  QtiPackageContentAssetDiscovery,
   QtiPackageItem,
 } from "./qti-package-types.js";
 import {
@@ -21,6 +23,27 @@ interface PendingAssetReference {
   readonly referencedBy: string;
 }
 
+/** Discover and resolve package-local asset references in one QTI XML document. */
+export function discoverQtiPackageContentAssets(
+  xml: string,
+  sourcePath: string,
+): QtiPackageContentAssetDiscovery {
+  const parsed = parseQtiPackageXmlTree(xml);
+  const diagnostics: QtiDiagnostic[] = [];
+  for (const message of parsed.errors) {
+    pushPackageDiagnostic(diagnostics, "xml.parse", "error", message, sourcePath);
+  }
+  if (!parsed.root) return { hrefs: [], diagnostics };
+
+  return {
+    hrefs: discoverContentAssetHrefs(
+      { path: sourcePath, xml, root: parsed.root, errors: parsed.errors },
+      diagnostics,
+    ),
+    diagnostics,
+  };
+}
+
 type PackageAssetRefSpec =
   | { readonly kind: "attribute"; readonly localName: string; readonly attribute: string }
   | { readonly kind: "text"; readonly localName: string };
@@ -232,6 +255,8 @@ export function detectPackageMediaType(href: string): string | undefined {
       return "image/jpeg";
     case "mp3":
       return "audio/mpeg";
+    case "m4a":
+      return "audio/mp4";
     case "mp4":
       return "video/mp4";
     case "ogg":
@@ -250,6 +275,11 @@ export function detectPackageMediaType(href: string): string | undefined {
       return "image/webp";
     case "xml":
       return "application/xml";
+    case "html":
+    case "htm":
+      return "text/html";
+    case "json":
+      return "application/json";
     default:
       return undefined;
   }

package/src/qti-package-items.ts

@@ -1,19 +1,31 @@
 import type { QtiPackageXmlNode } from "./package-xml.js";
 import { parseQtiXml } from "./parser.js";
+import { parseXmlBoolean } from "./parser-values.js";
 import { pushPackageDiagnostic } from "./qti-package-paths.js";
 import { discoverContentAssetHrefs } from "./qti-package-assets.js";
 import { QTI_PACKAGE_MANIFEST_PATH } from "./qti-package-manifest.js";
-import { parseStandardAlignments, parseTimingMetadata } from "./qti-package-metadata.js";
+import {
+  parseItemSessionControl,
+  parseStandardAlignments,
+  parseTimeLimits,
+  parseTimingMetadata,
+  uniqueStandards,
+} from "./qti-package-metadata.js";
 import type {
+  QtiAssessmentSectionPackageModel,
   QtiAssessmentTestItemRef,
   QtiAssessmentTestPackageModel,
   QtiManifestResource,
   QtiPackageItem,
   QtiPackageItemSource,
   QtiPackageShape,
+  QtiStandardAlignment,
+  QtiTestPartNavigationMode,
+  QtiTestPartPackageModel,
+  QtiTestPartSubmissionMode,
 } from "./qti-package-types.js";
 import {
-  packageDescendants,
+  childPackageElements,
   parsePackageXml,
   pushXmlDiagnostics,
   resolvePackageHref,
@@ -28,6 +40,7 @@ export interface PackageItemReference {
   readonly source: QtiPackageItemSource;
   readonly manifestResourceIdentifier?: string | undefined;
   readonly assessmentItemRefIdentifier?: string | undefined;
+  readonly standards: readonly QtiStandardAlignment[];
 }
 
 export function parseAssessmentTestPackageModel(
@@ -81,8 +94,13 @@ export function parseAssessmentTestPackageModel(
     );
   }
 
-  const itemRefs = root ? parseAssessmentTestItemRefs(root, href, testDiagnostics) : [];
+  const testParts = root ? parseAssessmentTestParts(root, href, testDiagnostics) : [];
+  const itemRefs = testParts.flatMap(flattenTestPartItemRefs);
   const assetHrefs = root ? discoverContentAssetHrefs(xmlFile, testDiagnostics) : [];
+  const timeLimits = root
+    ? parseTimeLimits(childPackageElements(root, "qti-time-limits")[0], href, testDiagnostics)
+    : undefined;
+  const timing = root ? parseTimingMetadata(root, href, testDiagnostics, timeLimits) : undefined;
   const scopedDiagnostics = testDiagnostics.map((diagnostic) =>
     scopeDiagnosticToPackagePath(href, diagnostic),
   );
@@ -94,7 +112,9 @@ export function parseAssessmentTestPackageModel(
     title: root?.attributes.title,
     manifestResourceIdentifier: firstResource.identifier,
     itemRefs,
-    timing: root ? parseTimingMetadata(root, href) : undefined,
+    testParts,
+    timing,
+    timeLimits,
     standards: root ? parseStandardAlignments(root, href) : [],
     assetHrefs,
     diagnostics: scopedDiagnostics,
@@ -103,34 +123,158 @@ export function parseAssessmentTestPackageModel(
   };
 }
 
-function parseAssessmentTestItemRefs(
+function parseAssessmentTestParts(
   root: QtiPackageXmlNode,
   sourcePath: string,
   diagnostics: QtiDiagnostic[],
-): QtiAssessmentTestItemRef[] {
-  const itemRefs: QtiAssessmentTestItemRef[] = [];
-  for (const refNode of packageDescendants(root, "qti-assessment-item-ref")) {
-    const rawHref = refNode.attributes.href;
-    if (!rawHref) {
-      pushPackageDiagnostic(
-        diagnostics,
-        "package.assessmentTest.itemRef.href.missing",
-        "error",
-        "qti-assessment-item-ref is missing href.",
+): QtiTestPartPackageModel[] {
+  return childPackageElements(root, "qti-test-part").map((partNode) => {
+    const identifier = partNode.attributes.identifier ?? "";
+    return {
+      identifier,
+      navigationMode: parseNavigationMode(partNode, sourcePath, diagnostics),
+      submissionMode: parseSubmissionMode(partNode, sourcePath, diagnostics),
+      timeLimits: parseTimeLimits(
+        childPackageElements(partNode, "qti-time-limits")[0],
         sourcePath,
-      );
-      continue;
-    }
+        diagnostics,
+      ),
+      sections: childPackageElements(partNode, "qti-assessment-section").map((sectionNode) =>
+        parseAssessmentSection(sectionNode, identifier, undefined, sourcePath, diagnostics),
+      ),
+      attributes: { ...partNode.attributes },
+    };
+  });
+}
 
-    const href = resolvePackageHref(sourcePath, rawHref, diagnostics);
-    if (!href) continue;
-    itemRefs.push({
-      identifier: refNode.attributes.identifier,
-      href,
-      attributes: { ...refNode.attributes },
-    });
-  }
-  return itemRefs;
+function parseAssessmentSection(
+  sectionNode: QtiPackageXmlNode,
+  testPartIdentifier: string,
+  parentSectionIdentifier: string | undefined,
+  sourcePath: string,
+  diagnostics: QtiDiagnostic[],
+): QtiAssessmentSectionPackageModel {
+  const identifier = sectionNode.attributes.identifier ?? "";
+  const visible = parseOptionalXmlBoolean(sectionNode, "visible", sourcePath, diagnostics);
+  const itemRefs = childPackageElements(sectionNode, "qti-assessment-item-ref").flatMap(
+    (refNode) => {
+      const rawHref = refNode.attributes.href;
+      if (!rawHref) {
+        pushPackageDiagnostic(
+          diagnostics,
+          "package.assessmentTest.itemRef.href.missing",
+          "error",
+          "qti-assessment-item-ref is missing href.",
+          sourcePath,
+        );
+        return [];
+      }
+
+      const href = resolvePackageHref(sourcePath, rawHref, diagnostics);
+      if (!href) return [];
+      return [
+        {
+          identifier: refNode.attributes.identifier,
+          href,
+          testPartIdentifier,
+          sectionIdentifier: identifier,
+          timeLimits: parseTimeLimits(
+            childPackageElements(refNode, "qti-time-limits")[0],
+            sourcePath,
+            diagnostics,
+          ),
+          itemSessionControl: parseItemSessionControl(
+            childPackageElements(refNode, "qti-item-session-control")[0],
+            sourcePath,
+            diagnostics,
+          ),
+          attributes: { ...refNode.attributes },
+        },
+      ];
+    },
+  );
+
+  return {
+    identifier,
+    title: sectionNode.attributes.title,
+    visible,
+    testPartIdentifier,
+    parentSectionIdentifier,
+    timeLimits: parseTimeLimits(
+      childPackageElements(sectionNode, "qti-time-limits")[0],
+      sourcePath,
+      diagnostics,
+    ),
+    itemRefs,
+    sections: childPackageElements(sectionNode, "qti-assessment-section").map((child) =>
+      parseAssessmentSection(child, testPartIdentifier, identifier, sourcePath, diagnostics),
+    ),
+    attributes: { ...sectionNode.attributes },
+  };
+}
+
+function flattenTestPartItemRefs(part: QtiTestPartPackageModel): QtiAssessmentTestItemRef[] {
+  return part.sections.flatMap(flattenSectionItemRefs);
+}
+
+function flattenSectionItemRefs(
+  section: QtiAssessmentSectionPackageModel,
+): QtiAssessmentTestItemRef[] {
+  return [...section.itemRefs, ...section.sections.flatMap(flattenSectionItemRefs)];
+}
+
+function parseNavigationMode(
+  node: QtiPackageXmlNode,
+  sourcePath: string,
+  diagnostics: QtiDiagnostic[],
+): QtiTestPartNavigationMode | undefined {
+  const raw = node.attributes["navigation-mode"];
+  if (raw === "linear" || raw === "nonlinear") return raw;
+  pushPackageDiagnostic(
+    diagnostics,
+    "package.testPart.navigationMode.invalid",
+    "error",
+    `qti-test-part navigation-mode must be linear or nonlinear, found ${raw ?? "(missing)"}.`,
+    sourcePath,
+  );
+  return undefined;
+}
+
+function parseSubmissionMode(
+  node: QtiPackageXmlNode,
+  sourcePath: string,
+  diagnostics: QtiDiagnostic[],
+): QtiTestPartSubmissionMode | undefined {
+  const raw = node.attributes["submission-mode"];
+  if (raw === "individual" || raw === "simultaneous") return raw;
+  pushPackageDiagnostic(
+    diagnostics,
+    "package.testPart.submissionMode.invalid",
+    "error",
+    `qti-test-part submission-mode must be individual or simultaneous, found ${raw ?? "(missing)"}.`,
+    sourcePath,
+  );
+  return undefined;
+}
+
+function parseOptionalXmlBoolean(
+  node: QtiPackageXmlNode,
+  name: string,
+  sourcePath: string,
+  diagnostics: QtiDiagnostic[],
+): boolean | undefined {
+  const raw = node.attributes[name];
+  if (raw === undefined) return undefined;
+  const value = parseXmlBoolean(raw);
+  if (value !== undefined) return value;
+  pushPackageDiagnostic(
+    diagnostics,
+    `package.attribute.${name}.boolean`,
+    "error",
+    `${node.localName} ${name} must be an XML boolean, found ${raw}.`,
+    sourcePath,
+  );
+  return undefined;
 }
 
 export function itemReferencesForPackageShape(
@@ -144,6 +288,7 @@ export function itemReferencesForPackageShape(
       href: itemRef.href,
       source: "assessment-test",
       assessmentItemRefIdentifier: itemRef.identifier,
+      standards: assessmentTest?.standards ?? [],
     }));
   }
 
@@ -169,6 +314,7 @@ export function itemReferencesForPackageShape(
       href,
       source: "manifest",
       manifestResourceIdentifier: resource.identifier,
+      standards: resource.standards,
     });
   }
   return references;
@@ -219,6 +365,13 @@ export function parsePackageItems(
     const assetHrefs = xmlFile.root ? discoverContentAssetHrefs(xmlFile, diagnostics) : [];
     const root = xmlFile.root?.localName === "qti-assessment-item" ? xmlFile.root : undefined;
     const item = parsed.document?.item;
+    const timeLimits = root
+      ? parseTimeLimits(
+          childPackageElements(root, "qti-time-limits")[0],
+          reference.href,
+          diagnostics,
+        )
+      : undefined;
 
     items.push({
       href: reference.href,
@@ -228,8 +381,16 @@ export function parsePackageItems(
       identifier: item?.identifier,
       title: item?.title,
       document: parsed.document,
-      timing: root ? parseTimingMetadata(root, reference.href) : undefined,
-      standards: root ? parseStandardAlignments(root, reference.href) : [],
+      timing: root ? parseTimingMetadata(root, reference.href, diagnostics, timeLimits) : undefined,
+      timeLimits,
+      standards: uniqueStandards([
+        ...reference.standards.filter(
+          (standard) =>
+            standard.resourcePartIdentifier === undefined ||
+            standard.resourcePartIdentifier === item?.identifier,
+        ),
+        ...(root ? parseStandardAlignments(root, reference.href) : []),
+      ]),
       assetHrefs,
       diagnostics: itemDiagnostics,
       xml: xmlFile.xml,

package/src/qti-package-manifest.ts

@@ -1,5 +1,6 @@
 import type { QtiPackageXmlNode } from "./package-xml.js";
 import { normalizePackagePath, pushPackageDiagnostic } from "./qti-package-paths.js";
+import { parseStandardAlignments } from "./qti-package-metadata.js";
 import type { QtiManifestFile, QtiManifestResource, QtiPackageShape } from "./qti-package-types.js";
 import { childPackageElements, packageDescendants, stripHrefSuffix } from "./qti-package-xml.js";
 import type { QtiPackageEntry } from "./qti-package-zip.js";
@@ -56,6 +57,7 @@ export function parseManifestResources(
       href,
       files,
       dependencies,
+      standards: parseStandardAlignments(node, QTI_PACKAGE_MANIFEST_PATH),
       attributes: { ...node.attributes },
     });
   }