@longsightgroup/qti3-core 0.10.3 → 0.10.5

package/src/types.ts

@@ -339,6 +339,8 @@ export interface QtiTextContent {
 export interface QtiElementContent {
   kind: "element";
   qtiName: string;
+  /** Expanded XML namespace retained so consumers do not infer semantics from local names alone. */
+  namespaceUri?: string | undefined;
   attributes: Record<string, string>;
   children: QtiContentNode[];
   source?: QtiSourceLocation | undefined;

package/src/validation-primitives.ts

@@ -1,5 +1,6 @@
-import type { QtiBaseType, QtiCardinality, QtiDiagnostic } from "./types.js";
-import { parseFiniteNumber, parseXmlBoolean } from "./parser-values.js";
+import type { QtiBaseType, QtiCardinality, QtiDiagnostic, QtiScalarValue } from "./types.js";
+import { assertNever } from "./assert-never.js";
+import { parseFiniteNumber, parseInteger, parseQtiPair, parseXmlBoolean } from "./parser-values.js";
 
 export function requireIdentifier(
   qtiName: string,
@@ -42,7 +43,7 @@ export function isFiniteNumber(value: string): boolean {
 }
 
 export function isInteger(value: string): boolean {
-  return /^-?\d+$/.test(value);
+  return parseInteger(value) !== undefined;
 }
 
 export function isNonNegativeInteger(value: string): boolean {
@@ -67,3 +68,42 @@ export function isPair(value: string): boolean {
   const parts = value.trim().split(/\s+/);
   return parts.length === 2 && parts.every((part) => part.length > 0);
 }
+
+/** Parse and normalize a runtime scalar for a QTI base type. */
+export function parseQtiScalarForBaseType(
+  value: QtiScalarValue,
+  baseType: QtiBaseType,
+): QtiScalarValue | undefined {
+  switch (baseType) {
+    case "integer":
+      if (typeof value === "number") return Number.isInteger(value) ? value : undefined;
+      return typeof value === "string" ? parseInteger(value) : undefined;
+    case "float":
+      if (typeof value === "number") return Number.isFinite(value) ? value : undefined;
+      return typeof value === "string" ? parseFiniteNumber(value) : undefined;
+    case "boolean":
+      if (typeof value === "boolean") return value;
+      return typeof value === "string" ? parseXmlBoolean(value) : undefined;
+    case "point":
+      return typeof value === "string" && isPoint(value) ? value : undefined;
+    case "pair":
+    case "directedPair":
+      return typeof value === "string" ? parseQtiPair(value, baseType) : undefined;
+    case "identifier":
+      return typeof value === "string" && value.trim().length > 0 && !/\s/.test(value)
+        ? value
+        : undefined;
+    case "string":
+    case "duration":
+    case "file":
+    case "uri":
+      return typeof value === "string" ? value : undefined;
+    default:
+      return assertNever(baseType);
+  }
+}
+
+/** Check a runtime scalar against the value representation accepted for a QTI base type. */
+export function qtiScalarMatchesBaseType(value: QtiScalarValue, baseType: QtiBaseType): boolean {
+  return parseQtiScalarForBaseType(value, baseType) !== undefined;
+}

package/src/xml.ts

@@ -211,12 +211,21 @@ function openElement(
   const attributes: Record<string, string> = {};
   const inheritedNamespaces = state.namespaceStack.at(-1)?.namespaces ?? {};
   const namespaces: Record<string, string> = { ...inheritedNamespaces };
+  const uniqueAttributes: ParsedAttribute[] = [];
+  const qualifiedAttributeNames = new Set<string>();
   for (const attribute of parsedAttributes) {
+    if (qualifiedAttributeNames.has(attribute.name)) {
+      state.errors.push(new Error(`Duplicate XML attribute ${attribute.name}.`));
+      continue;
+    }
+    qualifiedAttributeNames.add(attribute.name);
+    uniqueAttributes.push(attribute);
     attributes[attribute.name] = attribute.value;
     if (attribute.name === "xmlns") namespaces[""] = attribute.value;
     else if (attribute.name.startsWith("xmlns:"))
       namespaces[attribute.name.slice(6)] = attribute.value;
   }
+  validateUniqueExpandedAttributeNames(uniqueAttributes, namespaces, state);
 
   const { prefix, localName } = splitQualifiedName(name);
   const path = nodePath(parent, localName);
@@ -497,6 +506,34 @@ function splitQualifiedName(name: string): {
   };
 }
 
+function validateUniqueExpandedAttributeNames(
+  attributes: readonly ParsedAttribute[],
+  namespaces: Readonly<Record<string, string>>,
+  state: ParserState,
+): void {
+  const expandedNames = new Map<string, string>();
+  for (const attribute of attributes) {
+    if (attribute.name === "xmlns" || attribute.name.startsWith("xmlns:")) continue;
+
+    const { prefix, localName } = splitQualifiedName(attribute.name);
+    const namespaceUri = prefix ? namespaces[prefix] : "";
+    if (namespaceUri === undefined) continue;
+
+    const expandedName = `${namespaceUri}\u0000${localName}`;
+    const previousName = expandedNames.get(expandedName);
+    if (previousName) {
+      const displayName = namespaceUri ? `{${namespaceUri}}${localName}` : localName;
+      state.errors.push(
+        new Error(
+          `XML attributes ${previousName} and ${attribute.name} have duplicate expanded name ${displayName}.`,
+        ),
+      );
+      continue;
+    }
+    expandedNames.set(expandedName, attribute.name);
+  }
+}
+
 function buildLineStarts(xml: string): number[] {
   const lineStarts = [0];
   for (let index = 0; index < xml.length; index += 1) {