@longsightgroup/qti3-core 0.7.3 → 0.8.0

package/src/parser-declarations.ts

@@ -0,0 +1,174 @@
+import {
+  coerceValue,
+  normalizeValueForCardinality,
+  parseCardinality,
+  parseCoords,
+  parseShape,
+} from "./parser-values.js";
+import type {
+  QtiBaseType,
+  QtiLookupTable,
+  QtiOutcomeDeclaration,
+  QtiResponseDeclaration,
+  QtiScalarValue,
+  QtiTemplateDeclaration,
+  QtiValue,
+} from "./types.js";
+import { childElements, textContent, type XmlNode } from "./xml.js";
+
+export function parseResponseDeclaration(node: XmlNode): QtiResponseDeclaration {
+  const cardinality = parseCardinality(node.attributes.cardinality);
+  const baseType = node.attributes["base-type"] as QtiResponseDeclaration["baseType"];
+  return {
+    kind: "response",
+    identifier: node.attributes.identifier ?? "",
+    cardinality,
+    baseType,
+    defaultValue: parseVariableValue(childElements(node, "qti-default-value")[0], baseType),
+    correctResponse: normalizeValueForCardinality(
+      parseVariableValue(childElements(node, "qti-correct-response")[0], baseType),
+      cardinality,
+    ),
+    mapping: parseMapping(childElements(node, "qti-mapping")[0]),
+    areaMapping: parseAreaMapping(childElements(node, "qti-area-mapping")[0]),
+    attributes: node.attributes,
+    source: node.source,
+  };
+}
+
+export function parseOutcomeDeclaration(node: XmlNode): QtiOutcomeDeclaration {
+  const baseType = node.attributes["base-type"] as QtiOutcomeDeclaration["baseType"];
+  return {
+    kind: "outcome",
+    identifier: node.attributes.identifier ?? "",
+    cardinality: parseCardinality(node.attributes.cardinality),
+    baseType,
+    defaultValue: parseVariableValue(childElements(node, "qti-default-value")[0], baseType),
+    lookupTable: parseLookupTable(node, baseType),
+    attributes: node.attributes,
+    source: node.source,
+  };
+}
+
+export function parseTemplateDeclaration(node: XmlNode): QtiTemplateDeclaration {
+  const baseType = node.attributes["base-type"] as QtiTemplateDeclaration["baseType"];
+  return {
+    kind: "template",
+    identifier: node.attributes.identifier ?? "",
+    cardinality: parseCardinality(node.attributes.cardinality),
+    baseType,
+    defaultValue: parseVariableValue(childElements(node, "qti-default-value")[0], baseType),
+    attributes: node.attributes,
+    source: node.source,
+  };
+}
+
+function parseVariableValue(
+  node: XmlNode | undefined,
+  baseType: QtiBaseType | undefined,
+): QtiValue {
+  if (!node) return null;
+  const valueNodes = childElements(node, "qti-value");
+  const entries = valueNodes.map((valueNode) => ({
+    fieldIdentifier: valueNode.attributes["field-identifier"],
+    value: coerceValue(textContent(valueNode), valueNode.attributes["base-type"] ?? baseType),
+  }));
+  const recordEntries = entries.filter(
+    (entry): entry is { fieldIdentifier: string; value: QtiScalarValue } =>
+      Boolean(entry.fieldIdentifier),
+  );
+  if (recordEntries.length > 0) {
+    return Object.fromEntries(recordEntries.map((entry) => [entry.fieldIdentifier, entry.value]));
+  }
+  if (entries.length === 0) {
+    const text = textContent(node);
+    return text.length > 0 ? coerceValue(text, baseType) : null;
+  }
+  if (entries.length === 1) return entries[0]?.value ?? null;
+  return entries.map((entry) => entry.value);
+}
+
+function parseMapping(node: XmlNode | undefined): QtiResponseDeclaration["mapping"] | undefined {
+  if (!node) return undefined;
+  return {
+    defaultValue: Number(node.attributes["default-value"] ?? 0),
+    attributes: node.attributes,
+    source: node.source,
+    entries: childElements(node, "qti-map-entry").map((entry) => ({
+      mapKey: entry.attributes["map-key"],
+      mappedValue: Number(entry.attributes["mapped-value"] ?? 0),
+      attributes: entry.attributes,
+      source: entry.source,
+    })),
+  };
+}
+
+function parseAreaMapping(
+  node: XmlNode | undefined,
+): QtiResponseDeclaration["areaMapping"] | undefined {
+  if (!node) return undefined;
+  return {
+    defaultValue: Number(node.attributes["default-value"] ?? 0),
+    attributes: node.attributes,
+    source: node.source,
+    entries: childElements(node, "qti-area-map-entry").map((entry) => ({
+      shape: parseShape(entry.attributes.shape),
+      coords: parseCoords(entry.attributes.coords),
+      mappedValue: Number(entry.attributes["mapped-value"] ?? 0),
+      attributes: entry.attributes,
+      source: entry.source,
+    })),
+  };
+}
+
+function parseLookupTable(
+  node: XmlNode,
+  baseType: QtiOutcomeDeclaration["baseType"],
+): QtiLookupTable | undefined {
+  const matchTable = childElements(node, "qti-match-table")[0];
+  if (matchTable) return parseMatchTable(matchTable, baseType);
+  const interpolationTable = childElements(node, "qti-interpolation-table")[0];
+  if (interpolationTable) return parseInterpolationTable(interpolationTable, baseType);
+  return undefined;
+}
+
+function parseMatchTable(
+  node: XmlNode,
+  baseType: QtiOutcomeDeclaration["baseType"],
+): QtiLookupTable {
+  return {
+    type: "match",
+    defaultValue: parseLookupValue(node.attributes["default-value"], baseType),
+    attributes: node.attributes,
+    source: node.source,
+    entries: childElements(node, "qti-match-table-entry").map((entry) => ({
+      sourceValue: Number(entry.attributes["source-value"]),
+      targetValue: parseLookupValue(entry.attributes["target-value"], baseType),
+      attributes: entry.attributes,
+      source: entry.source,
+    })),
+  };
+}
+
+function parseInterpolationTable(
+  node: XmlNode,
+  baseType: QtiOutcomeDeclaration["baseType"],
+): QtiLookupTable {
+  return {
+    type: "interpolation",
+    defaultValue: parseLookupValue(node.attributes["default-value"], baseType),
+    attributes: node.attributes,
+    source: node.source,
+    entries: childElements(node, "qti-interpolation-table-entry").map((entry) => ({
+      sourceValue: Number(entry.attributes["source-value"]),
+      targetValue: parseLookupValue(entry.attributes["target-value"], baseType),
+      includeBoundary: entry.attributes["include-boundary"] !== "false",
+      attributes: entry.attributes,
+      source: entry.source,
+    })),
+  };
+}
+
+function parseLookupValue(value: string | undefined, baseType: string | undefined): QtiValue {
+  return value === undefined ? null : coerceValue(value, baseType);
+}

package/src/parser-item-metadata.ts

@@ -0,0 +1,194 @@
+import type {
+  QtiCatalogCard,
+  QtiCatalogCardEntry,
+  QtiCatalogFileHref,
+  QtiCatalogHtmlContent,
+  QtiCatalogInfo,
+  QtiCatalogReference,
+  QtiCompanionMaterialsInfo,
+  QtiCompanionMaterialsUnparsedChild,
+  QtiContentNode,
+  QtiDiagnostic,
+  QtiModalFeedback,
+  QtiPhysicalMaterial,
+  QtiStylesheet,
+} from "./types.js";
+import { childElements, descendants, textContent, type XmlNode } from "./xml.js";
+
+export function firstChildElement(
+  parent: XmlNode,
+  childName: string,
+  diagnostics: QtiDiagnostic[],
+  duplicateCode: string,
+): XmlNode | undefined {
+  const matches = childElements(parent, childName);
+  if (matches.length > 1) {
+    diagnostics.push({
+      code: duplicateCode,
+      severity: "error",
+      message: `${parent.localName} allows at most one ${childName} child.`,
+      path: matches[1]?.source?.path ?? parent.source?.path,
+      source: matches[1]?.source ?? parent.source,
+    });
+  }
+  return matches[0];
+}
+
+export function parseStylesheet(node: XmlNode): QtiStylesheet {
+  return {
+    href: node.attributes.href ?? "",
+    type: node.attributes.type,
+    media: node.attributes.media,
+    title: node.attributes.title,
+    attributes: node.attributes,
+    source: node.source,
+  };
+}
+
+export function parseCatalogReferences(node: XmlNode): QtiCatalogReference[] {
+  const references = [
+    ...(node.attributes["data-catalog-idref"] ? [node] : []),
+    ...descendants(node, (child) => Boolean(child.attributes["data-catalog-idref"])),
+  ];
+  return references.map((reference) => ({
+    idref: reference.attributes["data-catalog-idref"] ?? "",
+    source: reference.source,
+  }));
+}
+
+export function parseModalFeedback(node: XmlNode): QtiModalFeedback {
+  const showHide = node.attributes["show-hide"] === "hide" ? "hide" : "show";
+  return {
+    identifier: node.attributes.identifier ?? "",
+    outcomeIdentifier: node.attributes["outcome-identifier"] ?? "",
+    showHide,
+    text: textContent(node),
+    source: node.source,
+  };
+}
+
+export function parseCatalogInfo(node: XmlNode | undefined): QtiCatalogInfo | undefined {
+  if (!node) return undefined;
+  return {
+    catalogs: childElements(node, "qti-catalog").map((catalog) => ({
+      id: catalog.attributes.id ?? "",
+      attributes: catalog.attributes,
+      cards: childElements(catalog, "qti-card").map(parseCatalogCard),
+      source: catalog.source,
+    })),
+    source: node.source,
+  };
+}
+
+function parseCatalogCard(node: XmlNode): QtiCatalogCard {
+  return {
+    support: node.attributes.support ?? "",
+    htmlContent: parseCatalogHtmlContent(childElements(node, "qti-html-content")[0]),
+    fileHrefs: childElements(node, "qti-file-href").map(parseCatalogFileHref),
+    entries: childElements(node, "qti-card-entry").map(parseCatalogCardEntry),
+    attributes: node.attributes,
+    source: node.source,
+  };
+}
+
+function parseCatalogCardEntry(node: XmlNode): QtiCatalogCardEntry {
+  return {
+    language: node.attributes["xml:lang"] ?? node.attributes.lang,
+    default: node.attributes.default === "true",
+    htmlContent: parseCatalogHtmlContent(childElements(node, "qti-html-content")[0]),
+    fileHrefs: childElements(node, "qti-file-href").map(parseCatalogFileHref),
+    attributes: node.attributes,
+    source: node.source,
+  };
+}
+
+function parseCatalogHtmlContent(node: XmlNode | undefined): QtiCatalogHtmlContent | undefined {
+  if (!node) return undefined;
+  return {
+    text: textContent(node),
+    children: parseCatalogHtmlChildren(node),
+    attributes: node.attributes,
+    source: node.source,
+  };
+}
+
+function parseCatalogHtmlChildren(node: XmlNode): QtiContentNode[] {
+  const content: QtiContentNode[] = [];
+  for (const entry of node.content) {
+    if (typeof entry === "string") {
+      if (entry.length > 0) content.push({ kind: "text", text: entry, source: node.source });
+      continue;
+    }
+    content.push({
+      kind: "element",
+      qtiName: entry.localName,
+      attributes: entry.attributes,
+      children: parseCatalogHtmlChildren(entry),
+      source: entry.source,
+    });
+  }
+  return content;
+}
+
+function parseCatalogFileHref(node: XmlNode): QtiCatalogFileHref {
+  return {
+    href: textContent(node).trim(),
+    mimeType: node.attributes["mime-type"],
+    attributes: node.attributes,
+    source: node.source,
+  };
+}
+
+export function parseCompanionMaterialsInfo(
+  node: XmlNode | undefined,
+  diagnostics: QtiDiagnostic[],
+): QtiCompanionMaterialsInfo | undefined {
+  if (!node) return undefined;
+
+  const physicalMaterials: QtiPhysicalMaterial[] = [];
+  const unparsedChildren: QtiCompanionMaterialsUnparsedChild[] = [];
+
+  for (const child of childElements(node)) {
+    if (child.localName === "qti-physical-material") {
+      const material = parsePhysicalMaterial(child, diagnostics);
+      if (material) physicalMaterials.push(material);
+      continue;
+    }
+
+    unparsedChildren.push({ qtiName: child.localName, source: child.source });
+    diagnostics.push({
+      code: "companionMaterials.child.unsupported",
+      severity: "warning",
+      message: `${child.localName} is not currently modeled in companion materials parsing.`,
+      path: child.source?.path,
+      source: child.source,
+    });
+  }
+
+  return {
+    physicalMaterials,
+    unparsedChildren,
+    source: node.source,
+  };
+}
+
+function parsePhysicalMaterial(
+  node: XmlNode,
+  diagnostics: QtiDiagnostic[],
+): QtiPhysicalMaterial | undefined {
+  const text = textContent(node).trim();
+  if (text.length === 0) {
+    diagnostics.push({
+      code: "companionMaterials.physicalMaterial.empty",
+      severity: "warning",
+      message: "qti-physical-material requires non-empty text content.",
+      path: node.source?.path,
+      source: node.source,
+    });
+    return undefined;
+  }
+  return {
+    text,
+    source: node.source,
+  };
+}