@longsightgroup/qti3-core 0.9.9 → 0.9.10

package/src/qti-package-metadata.ts

@@ -1,12 +1,16 @@
 import type { QtiPackageXmlNode } from "./package-xml.js";
 import { parseXmlBoolean } from "./parser-values.js";
-import { packageDescendants } from "./qti-package-xml.js";
+import { pushPackageDiagnostic } from "./qti-package-paths.js";
+import { childPackageElements, packageDescendants } from "./qti-package-xml.js";
 import type {
   QtiAssessmentTestPackageModel,
   QtiPackageItem,
+  QtiItemSessionControl,
   QtiStandardAlignment,
+  QtiTimeLimits,
   QtiTimingMetadata,
 } from "./qti-package-types.js";
+import type { QtiDiagnostic } from "./types.js";
 
 /** Known QTI / IMS CP alignment element names plus attribute-driven manifest metadata. */
 const STANDARD_ALIGNMENT_ELEMENT_NAMES = new Set([
@@ -27,18 +31,78 @@ const STANDARD_ALIGNMENT_ATTRIBUTE_NAMES = new Set([
 export function parseTimingMetadata(
   root: QtiPackageXmlNode,
   sourcePath: string,
+  diagnostics: QtiDiagnostic[],
+  parsedTimeLimits?: QtiTimeLimits,
 ): QtiTimingMetadata | undefined {
-  const timeLimits = packageDescendants(root, "qti-time-limits")[0];
+  const timeLimitsNode = childPackageElements(root, "qti-time-limits")[0];
+  const timeLimits = parsedTimeLimits ?? parseTimeLimits(timeLimitsNode, sourcePath, diagnostics);
   const timeDependent = parseXmlBoolean(root.attributes["time-dependent"]);
-  if (!timeLimits && timeDependent === undefined) return undefined;
+  if (!timeLimitsNode && timeDependent === undefined) return undefined;
 
   return {
     sourcePath,
     timeDependent,
-    minTime: timeLimits?.attributes["min-time"],
-    maxTime: timeLimits?.attributes["max-time"],
-    allowLateSubmission: parseXmlBoolean(timeLimits?.attributes["allow-late-submission"]),
-    attributes: timeLimits ? { ...timeLimits.attributes } : {},
+    minTime: timeLimitsNode?.attributes["min-time"],
+    maxTime: timeLimitsNode?.attributes["max-time"],
+    allowLateSubmission: timeLimits?.allowLateSubmission,
+    attributes: timeLimitsNode ? { ...timeLimitsNode.attributes } : {},
+  };
+}
+
+export function parseTimeLimits(
+  node: QtiPackageXmlNode | undefined,
+  sourcePath: string,
+  diagnostics: QtiDiagnostic[],
+): QtiTimeLimits | undefined {
+  if (!node) return undefined;
+
+  const minTimeSeconds = parseNonNegativeNumberAttribute(node, "min-time", sourcePath, diagnostics);
+  const maxTimeSeconds = parseNonNegativeNumberAttribute(node, "max-time", sourcePath, diagnostics);
+  const allowLateSubmission = parseBooleanAttribute(
+    node,
+    "allow-late-submission",
+    sourcePath,
+    diagnostics,
+  );
+
+  if (
+    minTimeSeconds !== undefined &&
+    maxTimeSeconds !== undefined &&
+    minTimeSeconds > maxTimeSeconds
+  ) {
+    pushPackageDiagnostic(
+      diagnostics,
+      "package.timing.range.invalid",
+      "error",
+      `qti-time-limits min-time ${minTimeSeconds} exceeds max-time ${maxTimeSeconds}.`,
+      sourcePath,
+    );
+  }
+
+  return {
+    minTimeSeconds,
+    maxTimeSeconds,
+    allowLateSubmission,
+    attributes: { ...node.attributes },
+  };
+}
+
+export function parseItemSessionControl(
+  node: QtiPackageXmlNode | undefined,
+  sourcePath: string,
+  diagnostics: QtiDiagnostic[],
+): QtiItemSessionControl | undefined {
+  if (!node) return undefined;
+
+  return {
+    maxAttempts: parseNonNegativeNumberAttribute(node, "max-attempts", sourcePath, diagnostics),
+    showFeedback: parseBooleanAttribute(node, "show-feedback", sourcePath, diagnostics),
+    allowReview: parseBooleanAttribute(node, "allow-review", sourcePath, diagnostics),
+    showSolution: parseBooleanAttribute(node, "show-solution", sourcePath, diagnostics),
+    allowComment: parseBooleanAttribute(node, "allow-comment", sourcePath, diagnostics),
+    allowSkipping: parseBooleanAttribute(node, "allow-skipping", sourcePath, diagnostics),
+    validateResponses: parseBooleanAttribute(node, "validate-responses", sourcePath, diagnostics),
+    attributes: { ...node.attributes },
   };
 }
 
@@ -76,6 +140,52 @@ export function parseStandardAlignments(
       attributes: { ...node.attributes },
     });
   }
+  alignments.push(...parseCurriculumStandardsMetadata(root, sourcePath));
+  return alignments;
+}
+
+function parseCurriculumStandardsMetadata(
+  root: QtiPackageXmlNode,
+  sourcePath: string,
+): QtiStandardAlignment[] {
+  const alignments: QtiStandardAlignment[] = [];
+  for (const metadataSet of packageDescendants(root, "curriculumStandardsMetadataSet")) {
+    const resourceLabel = firstAttribute(metadataSet, ["resourceLabel"]);
+    const resourcePartIdentifier = firstAttribute(metadataSet, ["resourcePartId"]);
+    const weight = optionalFiniteNumber(firstAttribute(metadataSet, ["weight"]));
+
+    for (const metadata of childPackageElements(metadataSet, "curriculumStandardsMetadata")) {
+      const providerIdentifier = firstAttribute(metadata, [
+        "providerId",
+        "providerID",
+        "domainId",
+        "domainID",
+      ]);
+      for (const labelledGuid of packageDescendants(metadata, "labelledGUID")) {
+        const identifier = childText(labelledGuid, "GUID");
+        const targetName = childText(labelledGuid, "label");
+        const targetUrl =
+          childText(labelledGuid, "caseItemURI") ??
+          childText(labelledGuid, "uri") ??
+          childText(labelledGuid, "URI");
+        if (!identifier && !targetName && !targetUrl) continue;
+
+        alignments.push({
+          sourcePath,
+          qtiName: "curriculumStandardsMetadata",
+          identifier,
+          targetName,
+          targetUrl,
+          text: targetName,
+          providerIdentifier,
+          resourceLabel,
+          resourcePartIdentifier,
+          weight,
+          attributes: { ...metadataSet.attributes, ...metadata.attributes },
+        });
+      }
+    }
+  }
   return alignments;
 }
 
@@ -106,6 +216,10 @@ export function uniqueStandards(
       standard.targetName ?? "",
       standard.targetUrl ?? "",
       standard.text ?? "",
+      standard.providerIdentifier ?? "",
+      standard.resourceLabel ?? "",
+      standard.resourcePartIdentifier ?? "",
+      standard.weight?.toString() ?? "",
     ].join("\u0000");
     if (seen.has(key)) continue;
     seen.add(key);
@@ -114,6 +228,59 @@ export function uniqueStandards(
   return unique;
 }
 
+function parseNonNegativeNumberAttribute(
+  node: QtiPackageXmlNode,
+  name: string,
+  sourcePath: string,
+  diagnostics: QtiDiagnostic[],
+): number | undefined {
+  const raw = node.attributes[name];
+  if (raw === undefined) return undefined;
+  const value = Number(raw);
+  if (Number.isFinite(value) && value >= 0) return value;
+
+  pushPackageDiagnostic(
+    diagnostics,
+    `package.attribute.${name}.number`,
+    "error",
+    `${node.localName} ${name} must be a non-negative number, found ${raw}.`,
+    sourcePath,
+  );
+  return undefined;
+}
+
+function parseBooleanAttribute(
+  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;
+}
+
+function childText(node: QtiPackageXmlNode, localName: string): string | undefined {
+  const text = childPackageElements(node, localName)[0]?.text.trim();
+  return text ? text : undefined;
+}
+
+function optionalFiniteNumber(raw: string | undefined): number | undefined {
+  if (raw === undefined) return undefined;
+  const value = Number(raw);
+  return Number.isFinite(value) ? value : undefined;
+}
+
 export function primaryTiming(
   assessmentTest: QtiAssessmentTestPackageModel | undefined,
   items: readonly QtiPackageItem[],

package/src/qti-package-types.ts

@@ -1,4 +1,5 @@
 import type { QtiDiagnostic, QtiDocument } from "./types.js";
+import type { QtiPackageEntry } from "./qti-package-zip.js";
 
 export type {
   QtiPackageInflateContext,
@@ -31,6 +32,7 @@ export interface QtiManifestResource {
   readonly href?: string | undefined;
   readonly files: readonly QtiManifestFile[];
   readonly dependencies: readonly string[];
+  readonly standards: readonly QtiStandardAlignment[];
   readonly attributes: Record<string, string>;
 }
 
@@ -44,6 +46,32 @@ export interface QtiTimingMetadata {
   readonly attributes: Record<string, string>;
 }
 
+/** Parsed qti-time-limits attributes for one assessment-test structure node. */
+export interface QtiTimeLimits {
+  readonly minTimeSeconds?: number | undefined;
+  readonly maxTimeSeconds?: number | undefined;
+  readonly allowLateSubmission?: boolean | undefined;
+  readonly attributes: Record<string, string>;
+}
+
+/** Parsed qti-item-session-control attributes for an assessment item reference. */
+export interface QtiItemSessionControl {
+  readonly maxAttempts?: number | undefined;
+  readonly showFeedback?: boolean | undefined;
+  readonly allowReview?: boolean | undefined;
+  readonly showSolution?: boolean | undefined;
+  readonly allowComment?: boolean | undefined;
+  readonly allowSkipping?: boolean | undefined;
+  readonly validateResponses?: boolean | undefined;
+  readonly attributes: Record<string, string>;
+}
+
+/** Navigation mode declared by a QTI assessment-test part. */
+export type QtiTestPartNavigationMode = "linear" | "nonlinear";
+
+/** Submission mode declared by a QTI assessment-test part. */
+export type QtiTestPartSubmissionMode = "individual" | "simultaneous";
+
 /** Neutral standard-alignment metadata discovered in package XML. */
 export interface QtiStandardAlignment {
   readonly sourcePath: string;
@@ -53,6 +81,10 @@ export interface QtiStandardAlignment {
   readonly targetName?: string | undefined;
   readonly targetUrl?: string | undefined;
   readonly text?: string | undefined;
+  readonly providerIdentifier?: string | undefined;
+  readonly resourceLabel?: string | undefined;
+  readonly resourcePartIdentifier?: string | undefined;
+  readonly weight?: number | undefined;
   readonly attributes: Record<string, string>;
 }
 
@@ -60,6 +92,33 @@ export interface QtiStandardAlignment {
 export interface QtiAssessmentTestItemRef {
   readonly identifier?: string | undefined;
   readonly href: string;
+  readonly testPartIdentifier?: string | undefined;
+  readonly sectionIdentifier?: string | undefined;
+  readonly timeLimits?: QtiTimeLimits | undefined;
+  readonly itemSessionControl?: QtiItemSessionControl | undefined;
+  readonly attributes: Record<string, string>;
+}
+
+/** Parsed assessment section, including nested sections and directly owned item references. */
+export interface QtiAssessmentSectionPackageModel {
+  readonly identifier: string;
+  readonly title?: string | undefined;
+  readonly visible?: boolean | undefined;
+  readonly testPartIdentifier: string;
+  readonly parentSectionIdentifier?: string | undefined;
+  readonly timeLimits?: QtiTimeLimits | undefined;
+  readonly itemRefs: readonly QtiAssessmentTestItemRef[];
+  readonly sections: readonly QtiAssessmentSectionPackageModel[];
+  readonly attributes: Record<string, string>;
+}
+
+/** Parsed QTI assessment-test part and its section hierarchy. */
+export interface QtiTestPartPackageModel {
+  readonly identifier: string;
+  readonly navigationMode?: QtiTestPartNavigationMode | undefined;
+  readonly submissionMode?: QtiTestPartSubmissionMode | undefined;
+  readonly timeLimits?: QtiTimeLimits | undefined;
+  readonly sections: readonly QtiAssessmentSectionPackageModel[];
   readonly attributes: Record<string, string>;
 }
 
@@ -70,7 +129,9 @@ export interface QtiAssessmentTestPackageModel {
   readonly title?: string | undefined;
   readonly manifestResourceIdentifier?: string | undefined;
   readonly itemRefs: readonly QtiAssessmentTestItemRef[];
+  readonly testParts: readonly QtiTestPartPackageModel[];
   readonly timing?: QtiTimingMetadata | undefined;
+  readonly timeLimits?: QtiTimeLimits | undefined;
   readonly standards: readonly QtiStandardAlignment[];
   readonly assetHrefs: readonly string[];
   readonly diagnostics: readonly QtiDiagnostic[];
@@ -88,6 +149,7 @@ export interface QtiPackageItem {
   readonly title?: string | undefined;
   readonly document?: QtiDocument | undefined;
   readonly timing?: QtiTimingMetadata | undefined;
+  readonly timeLimits?: QtiTimeLimits | undefined;
   readonly standards: readonly QtiStandardAlignment[];
   readonly assetHrefs: readonly string[];
   readonly diagnostics: readonly QtiDiagnostic[];
@@ -102,10 +164,17 @@ export interface QtiPackageAsset {
   readonly referencedBy: readonly string[];
 }
 
+/** Package-local asset references discovered in one XML document. */
+export interface QtiPackageContentAssetDiscovery {
+  readonly hrefs: readonly string[];
+  readonly diagnostics: readonly QtiDiagnostic[];
+}
+
 /** Parsed QTI package manifest/resource graph and item/test projection. */
 export interface QtiPackageParseResult {
   readonly ok: boolean;
   readonly title: string;
+  readonly entries: readonly QtiPackageEntry[];
   readonly packageShape: QtiPackageShape;
   readonly items: readonly QtiPackageItem[];
   readonly assets: readonly QtiPackageAsset[];

package/src/qti-package-xml.ts

@@ -88,7 +88,8 @@ export function scopeDiagnosticToPackagePath(
   diagnostic: QtiDiagnostic,
 ): QtiDiagnostic {
   const localPath = diagnostic.path ?? diagnostic.source?.path;
-  const path = localPath ? joinPackagePath(packagePath, localPath) : packagePath;
+  const path =
+    !localPath || localPath === packagePath ? packagePath : joinPackagePath(packagePath, localPath);
   return {
     ...diagnostic,
     path,

package/src/qti-package.ts

@@ -36,22 +36,30 @@ import {
 import type { QtiDiagnostic } from "./types.js";
 
 export { decodeUtf8, readQtiPackageZipEntries };
+export { discoverQtiPackageContentAssets } from "./qti-package-assets.js";
 export { normalizePackagePath } from "./qti-package-paths.js";
 export { QTI_ITEM_RESOURCE_TYPE, QTI_PACKAGE_MANIFEST_PATH } from "./qti-package-manifest.js";
 export type { QtiPackageEntry };
 
 export type {
+  QtiAssessmentSectionPackageModel,
   QtiAssessmentTestItemRef,
   QtiAssessmentTestPackageModel,
   QtiManifestFile,
   QtiManifestResource,
   QtiPackageAsset,
+  QtiPackageContentAssetDiscovery,
   QtiPackageAssetSource,
   QtiPackageItem,
   QtiPackageItemSource,
   QtiPackageParseResult,
   QtiPackageShape,
+  QtiItemSessionControl,
   QtiStandardAlignment,
+  QtiTestPartNavigationMode,
+  QtiTestPartPackageModel,
+  QtiTestPartSubmissionMode,
+  QtiTimeLimits,
   QtiTimingMetadata,
 } from "./qti-package-types.js";
 
@@ -159,6 +167,7 @@ function parseQtiPackageEntries(
   return {
     ok: diagnostics.every((diagnostic) => diagnostic.severity !== "error"),
     title,
+    entries,
     packageShape,
     items,
     assets,

package/src/types.ts

@@ -494,6 +494,8 @@ export interface QtiResponseProcessing {
   template?: string | undefined;
   rules: QtiResponseRule[];
   conditions: QtiResponseCondition[];
+  /** Direct processing expressions retained even when they are not wrapped in a response rule. */
+  expressions?: QtiProcessingExpression[] | undefined;
 }
 
 export interface QtiResponseCondition {