@longsightgroup/qti3-core 0.7.3 → 0.8.1

package/src/serializer-processing.fixtures.ts

@@ -0,0 +1,469 @@
+import type { QtiProcessingExpression } from "./types.js";
+
+const baseOne = {
+  type: "baseValue",
+  baseType: "integer",
+  value: 1,
+} satisfies QtiProcessingExpression;
+const baseTwo = {
+  type: "baseValue",
+  baseType: "integer",
+  value: 2,
+} satisfies QtiProcessingExpression;
+const variableScore = { type: "variable", identifier: "SCORE" } satisfies QtiProcessingExpression;
+const variableResponse = {
+  type: "variable",
+  identifier: "RESPONSE",
+} satisfies QtiProcessingExpression;
+
+export type ExpressionCoverage = {
+  [K in QtiProcessingExpression["type"]]: {
+    expression: Extract<QtiProcessingExpression, { type: K }>;
+    xml: string;
+  };
+};
+
+export const expressionCoverage = {
+  baseValue: {
+    expression: baseOne,
+    xml: '    <qti-base-value base-type="integer">1</qti-base-value>',
+  },
+  null: { expression: { type: "null" }, xml: "    <qti-null/>" },
+  isNull: {
+    expression: { type: "isNull", identifier: "RESPONSE" },
+    xml: [
+      "    <qti-is-null>",
+      '      <qti-variable identifier="RESPONSE"/>',
+      "    </qti-is-null>",
+    ].join("\n"),
+  },
+  matchCorrect: {
+    expression: {
+      type: "matchCorrect",
+      identifier: "RESPONSE",
+      correctIdentifier: "RESPONSE",
+    },
+    xml: [
+      "    <qti-match>",
+      '      <qti-variable identifier="RESPONSE"/>',
+      '      <qti-correct identifier="RESPONSE"/>',
+      "    </qti-match>",
+    ].join("\n"),
+  },
+  match: {
+    expression: { type: "match", left: variableResponse, right: baseOne },
+    xml: [
+      "    <qti-match>",
+      '      <qti-variable identifier="RESPONSE"/>',
+      '      <qti-base-value base-type="integer">1</qti-base-value>',
+      "    </qti-match>",
+    ].join("\n"),
+  },
+  correct: {
+    expression: { type: "correct", identifier: "RESPONSE" },
+    xml: '    <qti-correct identifier="RESPONSE"/>',
+  },
+  default: {
+    expression: { type: "default", identifier: "SCORE" },
+    xml: '    <qti-default identifier="SCORE"/>',
+  },
+  mapResponse: {
+    expression: { type: "mapResponse", identifier: "RESPONSE" },
+    xml: '    <qti-map-response identifier="RESPONSE"/>',
+  },
+  mapResponsePoint: {
+    expression: { type: "mapResponsePoint", identifier: "RESPONSE" },
+    xml: '    <qti-map-response-point identifier="RESPONSE"/>',
+  },
+  variable: {
+    expression: variableResponse,
+    xml: '    <qti-variable identifier="RESPONSE"/>',
+  },
+  randomInteger: {
+    expression: { type: "randomInteger", min: 1, max: 10, step: 1, attributes: {} },
+    xml: '    <qti-random-integer min="1" max="10" step="1"/>',
+  },
+  randomFloat: {
+    expression: { type: "randomFloat", min: 0, max: 1, attributes: {} },
+    xml: '    <qti-random-float min="0" max="1"/>',
+  },
+  random: {
+    expression: { type: "random", values: [baseOne, baseTwo] },
+    xml: [
+      "    <qti-random>",
+      '      <qti-base-value base-type="integer">1</qti-base-value>',
+      '      <qti-base-value base-type="integer">2</qti-base-value>',
+      "    </qti-random>",
+    ].join("\n"),
+  },
+  multiple: {
+    expression: { type: "multiple", expressions: [baseOne, baseTwo] },
+    xml: [
+      "    <qti-multiple>",
+      '      <qti-base-value base-type="integer">1</qti-base-value>',
+      '      <qti-base-value base-type="integer">2</qti-base-value>',
+      "    </qti-multiple>",
+    ].join("\n"),
+  },
+  ordered: {
+    expression: { type: "ordered", expressions: [baseOne, baseTwo] },
+    xml: [
+      "    <qti-ordered>",
+      '      <qti-base-value base-type="integer">1</qti-base-value>',
+      '      <qti-base-value base-type="integer">2</qti-base-value>',
+      "    </qti-ordered>",
+    ].join("\n"),
+  },
+  index: {
+    expression: { type: "index", expression: variableResponse, n: "1" },
+    xml: [
+      '    <qti-index n="1">',
+      '      <qti-variable identifier="RESPONSE"/>',
+      "    </qti-index>",
+    ].join("\n"),
+  },
+  containerSize: {
+    expression: { type: "containerSize", expression: variableResponse },
+    xml: [
+      "    <qti-container-size>",
+      '      <qti-variable identifier="RESPONSE"/>',
+      "    </qti-container-size>",
+    ].join("\n"),
+  },
+  sum: {
+    expression: { type: "sum", expressions: [baseOne, baseTwo] },
+    xml: [
+      "    <qti-sum>",
+      '      <qti-base-value base-type="integer">1</qti-base-value>',
+      '      <qti-base-value base-type="integer">2</qti-base-value>',
+      "    </qti-sum>",
+    ].join("\n"),
+  },
+  product: {
+    expression: { type: "product", expressions: [baseOne, baseTwo] },
+    xml: [
+      "    <qti-product>",
+      '      <qti-base-value base-type="integer">1</qti-base-value>',
+      '      <qti-base-value base-type="integer">2</qti-base-value>',
+      "    </qti-product>",
+    ].join("\n"),
+  },
+  min: {
+    expression: { type: "min", expressions: [baseOne, baseTwo] },
+    xml: [
+      "    <qti-min>",
+      '      <qti-base-value base-type="integer">1</qti-base-value>',
+      '      <qti-base-value base-type="integer">2</qti-base-value>',
+      "    </qti-min>",
+    ].join("\n"),
+  },
+  max: {
+    expression: { type: "max", expressions: [baseOne, baseTwo] },
+    xml: [
+      "    <qti-max>",
+      '      <qti-base-value base-type="integer">1</qti-base-value>',
+      '      <qti-base-value base-type="integer">2</qti-base-value>',
+      "    </qti-max>",
+    ].join("\n"),
+  },
+  subtract: {
+    expression: { type: "subtract", left: baseTwo, right: baseOne },
+    xml: [
+      "    <qti-subtract>",
+      '      <qti-base-value base-type="integer">2</qti-base-value>',
+      '      <qti-base-value base-type="integer">1</qti-base-value>',
+      "    </qti-subtract>",
+    ].join("\n"),
+  },
+  divide: {
+    expression: { type: "divide", left: baseTwo, right: baseOne },
+    xml: [
+      "    <qti-divide>",
+      '      <qti-base-value base-type="integer">2</qti-base-value>',
+      '      <qti-base-value base-type="integer">1</qti-base-value>',
+      "    </qti-divide>",
+    ].join("\n"),
+  },
+  power: {
+    expression: { type: "power", left: baseTwo, right: baseOne },
+    xml: [
+      "    <qti-power>",
+      '      <qti-base-value base-type="integer">2</qti-base-value>',
+      '      <qti-base-value base-type="integer">1</qti-base-value>',
+      "    </qti-power>",
+    ].join("\n"),
+  },
+  integerDivide: {
+    expression: { type: "integerDivide", left: baseTwo, right: baseOne },
+    xml: [
+      "    <qti-integer-divide>",
+      '      <qti-base-value base-type="integer">2</qti-base-value>',
+      '      <qti-base-value base-type="integer">1</qti-base-value>',
+      "    </qti-integer-divide>",
+    ].join("\n"),
+  },
+  integerModulus: {
+    expression: { type: "integerModulus", left: baseTwo, right: baseOne },
+    xml: [
+      "    <qti-integer-modulus>",
+      '      <qti-base-value base-type="integer">2</qti-base-value>',
+      '      <qti-base-value base-type="integer">1</qti-base-value>',
+      "    </qti-integer-modulus>",
+    ].join("\n"),
+  },
+  round: {
+    expression: { type: "round", expression: baseOne },
+    xml: [
+      "    <qti-round>",
+      '      <qti-base-value base-type="integer">1</qti-base-value>',
+      "    </qti-round>",
+    ].join("\n"),
+  },
+  roundTo: {
+    expression: {
+      type: "roundTo",
+      expression: baseOne,
+      roundingMode: "decimalPlaces",
+      figures: 1,
+    },
+    xml: [
+      '    <qti-round-to rounding-mode="decimalPlaces" figures="1">',
+      '      <qti-base-value base-type="integer">1</qti-base-value>',
+      "    </qti-round-to>",
+    ].join("\n"),
+  },
+  truncate: {
+    expression: { type: "truncate", expression: baseOne },
+    xml: [
+      "    <qti-truncate>",
+      '      <qti-base-value base-type="integer">1</qti-base-value>',
+      "    </qti-truncate>",
+    ].join("\n"),
+  },
+  integerToFloat: {
+    expression: { type: "integerToFloat", expression: baseOne },
+    xml: [
+      "    <qti-integer-to-float>",
+      '      <qti-base-value base-type="integer">1</qti-base-value>',
+      "    </qti-integer-to-float>",
+    ].join("\n"),
+  },
+  and: {
+    expression: { type: "and", expressions: [variableScore] },
+    xml: ["    <qti-and>", '      <qti-variable identifier="SCORE"/>', "    </qti-and>"].join("\n"),
+  },
+  anyN: {
+    expression: { type: "anyN", min: "1", max: "2", expressions: [variableScore] },
+    xml: [
+      '    <qti-any-n min="1" max="2">',
+      '      <qti-variable identifier="SCORE"/>',
+      "    </qti-any-n>",
+    ].join("\n"),
+  },
+  or: {
+    expression: { type: "or", expressions: [variableScore] },
+    xml: ["    <qti-or>", '      <qti-variable identifier="SCORE"/>', "    </qti-or>"].join("\n"),
+  },
+  not: {
+    expression: { type: "not", expression: variableScore },
+    xml: ["    <qti-not>", '      <qti-variable identifier="SCORE"/>', "    </qti-not>"].join("\n"),
+  },
+  equal: {
+    expression: { type: "equal", left: baseOne, right: baseOne },
+    xml: [
+      "    <qti-equal>",
+      '      <qti-base-value base-type="integer">1</qti-base-value>',
+      '      <qti-base-value base-type="integer">1</qti-base-value>',
+      "    </qti-equal>",
+    ].join("\n"),
+  },
+  equalRounded: {
+    expression: {
+      type: "equalRounded",
+      left: baseOne,
+      right: baseOne,
+      roundingMode: "decimalPlaces",
+      figures: 1,
+    },
+    xml: [
+      '    <qti-equal-rounded rounding-mode="decimalPlaces" figures="1">',
+      '      <qti-base-value base-type="integer">1</qti-base-value>',
+      '      <qti-base-value base-type="integer">1</qti-base-value>',
+      "    </qti-equal-rounded>",
+    ].join("\n"),
+  },
+  numericCompare: {
+    expression: { type: "numericCompare", operator: "gte", left: variableScore, right: baseOne },
+    xml: [
+      "    <qti-gte>",
+      '      <qti-variable identifier="SCORE"/>',
+      '      <qti-base-value base-type="integer">1</qti-base-value>',
+      "    </qti-gte>",
+    ].join("\n"),
+  },
+  durationCompare: {
+    expression: { type: "durationCompare", operator: "lt", left: variableScore, right: baseOne },
+    xml: [
+      "    <qti-duration-lt>",
+      '      <qti-variable identifier="SCORE"/>',
+      '      <qti-base-value base-type="integer">1</qti-base-value>',
+      "    </qti-duration-lt>",
+    ].join("\n"),
+  },
+  stringMatch: {
+    expression: {
+      type: "stringMatch",
+      left: variableResponse,
+      right: { type: "baseValue", baseType: "string", value: "A" },
+      caseSensitive: false,
+      substring: true,
+    },
+    xml: [
+      '    <qti-string-match case-sensitive="false" substring="true">',
+      '      <qti-variable identifier="RESPONSE"/>',
+      '      <qti-base-value base-type="string">A</qti-base-value>',
+      "    </qti-string-match>",
+    ].join("\n"),
+  },
+  substring: {
+    expression: {
+      type: "substring",
+      left: variableResponse,
+      right: { type: "baseValue", baseType: "string", value: "A" },
+      caseSensitive: true,
+    },
+    xml: [
+      '    <qti-substring case-sensitive="true">',
+      '      <qti-variable identifier="RESPONSE"/>',
+      '      <qti-base-value base-type="string">A</qti-base-value>',
+      "    </qti-substring>",
+    ].join("\n"),
+  },
+  patternMatch: {
+    expression: { type: "patternMatch", expression: variableResponse, pattern: "[A-Z]+" },
+    xml: [
+      '    <qti-pattern-match pattern="[A-Z]+">',
+      '      <qti-variable identifier="RESPONSE"/>',
+      "    </qti-pattern-match>",
+    ].join("\n"),
+  },
+  fieldValue: {
+    expression: { type: "fieldValue", fieldIdentifier: "candidate", expression: variableResponse },
+    xml: [
+      '    <qti-field-value field-identifier="candidate">',
+      '      <qti-variable identifier="RESPONSE"/>',
+      "    </qti-field-value>",
+    ].join("\n"),
+  },
+  member: {
+    expression: { type: "member", value: baseOne, collection: variableResponse },
+    xml: [
+      "    <qti-member>",
+      '      <qti-base-value base-type="integer">1</qti-base-value>',
+      '      <qti-variable identifier="RESPONSE"/>',
+      "    </qti-member>",
+    ].join("\n"),
+  },
+  delete: {
+    expression: { type: "delete", value: baseOne, collection: variableResponse },
+    xml: [
+      "    <qti-delete>",
+      '      <qti-base-value base-type="integer">1</qti-base-value>',
+      '      <qti-variable identifier="RESPONSE"/>',
+      "    </qti-delete>",
+    ].join("\n"),
+  },
+  contains: {
+    expression: { type: "contains", collection: variableResponse, values: baseOne },
+    xml: [
+      "    <qti-contains>",
+      '      <qti-variable identifier="RESPONSE"/>',
+      '      <qti-base-value base-type="integer">1</qti-base-value>',
+      "    </qti-contains>",
+    ].join("\n"),
+  },
+  gcd: {
+    expression: { type: "gcd", expressions: [baseOne, baseTwo] },
+    xml: [
+      "    <qti-gcd>",
+      '      <qti-base-value base-type="integer">1</qti-base-value>',
+      '      <qti-base-value base-type="integer">2</qti-base-value>',
+      "    </qti-gcd>",
+    ].join("\n"),
+  },
+  inside: {
+    expression: {
+      type: "inside",
+      shape: "circle",
+      coords: [10, 20, 5],
+      attributes: { coords: "0,0,0", shape: "rect", tolerance: "2" },
+      expression: variableResponse,
+    },
+    xml: [
+      '    <qti-inside shape="rect" coords="0,0,0" tolerance="2">',
+      '      <qti-variable identifier="RESPONSE"/>',
+      "    </qti-inside>",
+    ].join("\n"),
+  },
+  lcm: {
+    expression: { type: "lcm", expressions: [baseOne, baseTwo] },
+    xml: [
+      "    <qti-lcm>",
+      '      <qti-base-value base-type="integer">1</qti-base-value>',
+      '      <qti-base-value base-type="integer">2</qti-base-value>',
+      "    </qti-lcm>",
+    ].join("\n"),
+  },
+  mathConstant: {
+    expression: { type: "mathConstant", name: "pi" },
+    xml: '    <qti-math-constant name="pi"/>',
+  },
+  mathOperator: {
+    expression: { type: "mathOperator", name: "sin", expressions: [baseOne] },
+    xml: [
+      '    <qti-math-operator name="sin">',
+      '      <qti-base-value base-type="integer">1</qti-base-value>',
+      "    </qti-math-operator>",
+    ].join("\n"),
+  },
+  repeat: {
+    expression: { type: "repeat", numberRepeats: "2", expressions: [baseOne] },
+    xml: [
+      '    <qti-repeat number-repeats="2">',
+      '      <qti-base-value base-type="integer">1</qti-base-value>',
+      "    </qti-repeat>",
+    ].join("\n"),
+  },
+  statsOperator: {
+    expression: { type: "statsOperator", name: "mean", expression: variableResponse },
+    xml: [
+      '    <qti-stats-operator name="mean">',
+      '      <qti-variable identifier="RESPONSE"/>',
+      "    </qti-stats-operator>",
+    ].join("\n"),
+  },
+  customOperator: {
+    expression: {
+      type: "customOperator",
+      definition: "https://example.invalid/operator?a=1&b=2",
+      className: "demo",
+      attributes: { "data-extra": `"quoted"` },
+      expressions: [{ type: "null" }],
+    },
+    xml: [
+      '    <qti-custom-operator class="demo" data-extra="&quot;quoted&quot;" definition="https://example.invalid/operator?a=1&amp;b=2">',
+      "      <qti-null/>",
+      "    </qti-custom-operator>",
+    ].join("\n"),
+  },
+} satisfies ExpressionCoverage;
+
+export function expressionCoverageXml(expressionType: QtiProcessingExpression["type"]): string {
+  return [
+    "<qti-response-processing>",
+    '  <qti-set-outcome-value identifier="SCORE">',
+    expressionCoverage[expressionType].xml,
+    "  </qti-set-outcome-value>",
+    "</qti-response-processing>",
+  ].join("\n");
+}

package/src/serializer-processing.ts

@@ -0,0 +1,196 @@
+import { responseConditionsFromRules } from "./processing-rules.js";
+import { serializeExpression } from "./serializer-processing-expressions.js";
+import {
+  addSerializerDiagnostic,
+  renderElement,
+  type SerializationContext,
+  type XmlAttribute,
+} from "./serializer-processing-xml.js";
+import type {
+  QtiDiagnostic,
+  QtiResponseBranch,
+  QtiResponseCondition,
+  QtiResponseProcessing,
+  QtiResponseRule,
+} from "./types.js";
+
+export interface QtiSerializeResponseProcessingResult {
+  ok: boolean;
+  xml?: string | undefined;
+  diagnostics: QtiDiagnostic[];
+}
+
+export function serializeResponseProcessing(
+  processing: QtiResponseProcessing,
+): QtiSerializeResponseProcessingResult {
+  const context: SerializationContext = { diagnostics: [] };
+  const rules = responseProcessingRules(processing, context);
+
+  const attrs: XmlAttribute[] = [];
+  if (processing.template !== undefined) attrs.push(["template", processing.template]);
+
+  const body = rules.flatMap((rule) => serializeResponseRule(rule, context, 1));
+  const hasErrors = context.diagnostics.some((diagnostic) => diagnostic.severity === "error");
+
+  if (hasErrors) {
+    return { ok: false, diagnostics: context.diagnostics };
+  }
+
+  return {
+    ok: true,
+    xml: renderElement("qti-response-processing", attrs, body, 0).join("\n"),
+    diagnostics: context.diagnostics,
+  };
+}
+
+function responseProcessingRules(
+  processing: QtiResponseProcessing,
+  context: SerializationContext,
+): QtiResponseRule[] {
+  if (processing.conditions.length === 0) return processing.rules;
+
+  const flattened = responseConditionsFromRules(processing.rules);
+  if (sameConditionReferences(flattened, processing.conditions)) return processing.rules;
+
+  if (processing.rules.length === 0) {
+    return processing.conditions.map((condition) => ({ type: "responseCondition", condition }));
+  }
+
+  addSerializerDiagnostic(context, "responseProcessing.serialize.conditions", {
+    message:
+      "QtiResponseProcessing.conditions must be represented as responseCondition rules when rules are present.",
+  });
+  return processing.rules;
+}
+
+function sameConditionReferences(
+  left: QtiResponseCondition[],
+  right: QtiResponseCondition[],
+): boolean {
+  if (left.length !== right.length) return false;
+  return left.every((condition, index) => condition === right[index]);
+}
+
+function serializeResponseRule(
+  rule: QtiResponseRule,
+  context: SerializationContext,
+  indent: number,
+): string[] {
+  switch (rule.type) {
+    case "setOutcomeValue": {
+      const expressionXml = serializeExpression(rule.expression, context, indent + 1);
+      if (!requireRuleIdentifier(rule.identifier, "qti-set-outcome-value", rule.source, context)) {
+        return [];
+      }
+      return renderElement(
+        "qti-set-outcome-value",
+        [["identifier", rule.identifier]],
+        expressionXml,
+        indent,
+      );
+    }
+    case "lookupOutcomeValue": {
+      const expressionXml = serializeExpression(rule.expression, context, indent + 1);
+      if (
+        !requireRuleIdentifier(rule.identifier, "qti-lookup-outcome-value", rule.source, context)
+      ) {
+        return [];
+      }
+      return renderElement(
+        "qti-lookup-outcome-value",
+        [["identifier", rule.identifier]],
+        expressionXml,
+        indent,
+      );
+    }
+    case "exitResponse":
+      return renderElement("qti-exit-response", [], [], indent);
+    case "responseCondition":
+      return serializeResponseCondition(rule.condition, context, indent);
+    case "responseProcessingFragment":
+      return renderElement(
+        "qti-response-processing-fragment",
+        [],
+        rule.rules.flatMap((child) => serializeResponseRule(child, context, indent + 1)),
+        indent,
+      );
+  }
+}
+
+function serializeResponseCondition(
+  condition: QtiResponseCondition,
+  context: SerializationContext,
+  indent: number,
+): string[] {
+  if (condition.ifExpression === undefined) {
+    addSerializerDiagnostic(context, "responseProcessing.serialize.missingExpression", {
+      message: "qti-response-condition requires an if expression.",
+    });
+    return [];
+  }
+
+  const children: string[] = [
+    ...renderElement(
+      "qti-response-if",
+      [],
+      [
+        ...serializeExpression(condition.ifExpression, context, indent + 2),
+        ...condition.thenRules.flatMap((rule) => serializeResponseRule(rule, context, indent + 2)),
+      ],
+      indent + 1,
+    ),
+  ];
+
+  for (const branch of condition.elseIfs) {
+    children.push(...serializeResponseBranch(branch, context, indent + 1));
+  }
+
+  if (condition.elseRules.length > 0) {
+    children.push(
+      ...renderElement(
+        "qti-response-else",
+        [],
+        condition.elseRules.flatMap((rule) => serializeResponseRule(rule, context, indent + 2)),
+        indent + 1,
+      ),
+    );
+  }
+
+  return renderElement("qti-response-condition", [], children, indent);
+}
+
+function serializeResponseBranch(
+  branch: QtiResponseBranch,
+  context: SerializationContext,
+  indent: number,
+): string[] {
+  if (branch.expression === undefined) {
+    addSerializerDiagnostic(context, "responseProcessing.serialize.missingExpression", {
+      message: "qti-response-else-if requires an expression.",
+    });
+    return [];
+  }
+  return renderElement(
+    "qti-response-else-if",
+    [],
+    [
+      ...serializeExpression(branch.expression, context, indent + 1),
+      ...branch.rules.flatMap((rule) => serializeResponseRule(rule, context, indent + 1)),
+    ],
+    indent,
+  );
+}
+
+function requireRuleIdentifier(
+  identifier: string,
+  tagName: string,
+  source: QtiResponseRule["source"],
+  context: SerializationContext,
+): boolean {
+  if (identifier !== "") return true;
+  addSerializerDiagnostic(context, "responseProcessing.serialize.invalidAttribute", {
+    message: `${tagName} requires a non-empty identifier.`,
+    source,
+  });
+  return false;
+}