@longsightgroup/qti3-player 0.3.0 → 0.5.1

package/src/player-message-manifest.ts

@@ -0,0 +1,103 @@
+/**
+ * Single source of truth for player chrome message ids and resolver behavior.
+ * Default copy lives in `defaultPlayerMessageCatalog.strings`; hosts override via JSON catalogs.
+ */
+export type PlayerMessageResolverKind =
+  | "plain"
+  | "template"
+  | "plural"
+  | "typeLabel"
+  | "typeTemplate"
+  | "directionTemplate"
+  | "extendedTextCounter";
+
+export interface PlayerMessageManifestEntry {
+  readonly key: string;
+  readonly resolver: PlayerMessageResolverKind;
+  readonly params?: readonly string[];
+}
+
+export const PLAYER_MESSAGE_MANIFEST = [
+  { key: "remove", resolver: "plain" },
+  { key: "removePair", resolver: "template", params: ["label"] },
+  { key: "clearDrawing", resolver: "plain" },
+  { key: "clearPoints", resolver: "plain" },
+  { key: "endAttempt", resolver: "plain" },
+  { key: "uploadResponse", resolver: "plain" },
+  { key: "movableObject", resolver: "plain" },
+  { key: "placeObject", resolver: "plain" },
+  { key: "inlineChoicePrompt", resolver: "plain" },
+  { key: "extendedTextCounter", resolver: "extendedTextCounter", params: ["characters", "words"] },
+  { key: "hotspotSelectionSummary", resolver: "plural", params: ["selection", "count"] },
+  { key: "noPointSelected", resolver: "plain" },
+  { key: "noRegionSelected", resolver: "plain" },
+  { key: "noAssociationsMade", resolver: "plain" },
+  { key: "associationsMade", resolver: "plural", params: ["count"] },
+  { key: "associationPairLabel", resolver: "template", params: ["source", "target"] },
+  { key: "hotspotSelectedChooseAnother", resolver: "template", params: ["label"] },
+  { key: "moveChoice", resolver: "directionTemplate", params: ["label", "direction"] },
+  { key: "movePoint", resolver: "directionTemplate", params: ["direction"] },
+  { key: "moveObject", resolver: "directionTemplate", params: ["direction"] },
+  { key: "interactionType", resolver: "typeLabel", params: ["type"] },
+  { key: "matchSourcesBank", resolver: "plain" },
+  { key: "matchTargetsBank", resolver: "plain" },
+  { key: "matchSelectedPairsList", resolver: "plain" },
+  { key: "interactionSourcesBank", resolver: "typeTemplate", params: ["type"] },
+  { key: "interactionTargetsBank", resolver: "typeTemplate", params: ["type"] },
+  { key: "interactionSelectedPairsList", resolver: "typeTemplate", params: ["type"] },
+  { key: "associateFirstConceptRegion", resolver: "plain" },
+  { key: "associatePairWithRegion", resolver: "plain" },
+  { key: "matchPromptRegion", resolver: "plain" },
+  { key: "matchMatchRegion", resolver: "plain" },
+  { key: "genericSourceRegion", resolver: "plain" },
+  { key: "genericTargetRegion", resolver: "plain" },
+  { key: "interactionHotspots", resolver: "typeTemplate", params: ["type"] },
+  { key: "interactionImageAlt", resolver: "typeTemplate", params: ["type"] },
+  { key: "interactionCurrentOrderList", resolver: "typeTemplate", params: ["type"] },
+  { key: "interactionSelectedOrderList", resolver: "typeTemplate", params: ["type"] },
+  { key: "interactionChoicesBank", resolver: "typeTemplate", params: ["type"] },
+  { key: "interactionGapTargets", resolver: "typeTemplate", params: ["type"] },
+  { key: "interactionTargetImage", resolver: "typeTemplate", params: ["type"] },
+  { key: "interactionOptionsList", resolver: "typeTemplate", params: ["type"] },
+  { key: "interactionCoordinateResponse", resolver: "typeTemplate", params: ["type"] },
+  { key: "interactionCoordinateArea", resolver: "typeTemplate", params: ["type"] },
+  {
+    key: "interactionCoordinateAreaSelected",
+    resolver: "typeTemplate",
+    params: ["type", "coordinates"],
+  },
+  { key: "interactionPlacementResponse", resolver: "typeTemplate", params: ["type"] },
+  { key: "interactionPlacementStage", resolver: "typeTemplate", params: ["type"] },
+  { key: "interactionPlacementStageEmpty", resolver: "typeTemplate", params: ["type"] },
+  { key: "interactionPlacementStageAt", resolver: "typeTemplate", params: ["type", "coordinates"] },
+  { key: "interactionDrawingResponse", resolver: "typeTemplate", params: ["type"] },
+  { key: "drawingSurface", resolver: "plain" },
+  { key: "drawingSurfaceEmpty", resolver: "plain" },
+  { key: "drawingSurfaceStrokeCount", resolver: "plural", params: ["count"] },
+  { key: "drawingStatusEmpty", resolver: "plain" },
+  { key: "drawingStatusStrokeCount", resolver: "plural", params: ["count"] },
+  { key: "gapLabel", resolver: "template", params: ["index"] },
+  { key: "graphicGapTargetLabel", resolver: "template", params: ["index"] },
+  { key: "gapEmptyState", resolver: "template", params: ["label"] },
+  { key: "gapAssignedState", resolver: "template", params: ["label", "assigned"] },
+  { key: "gapLabelsPlacedCount", resolver: "plural", params: ["count"] },
+  { key: "gapNoLabelsPlaced", resolver: "plain" },
+  { key: "orderedItemAtPosition", resolver: "template", params: ["label", "position", "total"] },
+  { key: "orderedItemMovedOneStep", resolver: "directionTemplate", params: ["label", "direction"] },
+  {
+    key: "orderedItemMovedToPosition",
+    resolver: "template",
+    params: ["label", "position", "total"],
+  },
+  { key: "graphicOrderRegionsSelected", resolver: "plural", params: ["count"] },
+  { key: "graphicOrderNoRegionsSelected", resolver: "plain" },
+  { key: "objectNotPlaced", resolver: "plain" },
+  { key: "objectPositionedAt", resolver: "template", params: ["coordinates"] },
+  { key: "selectedPointAt", resolver: "template", params: ["coordinates"] },
+  { key: "selectedPointsSummary", resolver: "plural", params: ["count", "coordinates"] },
+  { key: "extendedTextResponseLabel", resolver: "plain" },
+  { key: "textResponseLabel", resolver: "plain" },
+  { key: "sliderResponseLabel", resolver: "plain" },
+] as const satisfies readonly PlayerMessageManifestEntry[];
+
+export type PlayerMessageKey = (typeof PLAYER_MESSAGE_MANIFEST)[number]["key"];

package/src/player-message-overrides.ts

@@ -0,0 +1,38 @@
+import type { PlayerMessageKey } from "./player-message-manifest.js";
+import type {
+  PlayerMessageOverride,
+  PlayerMessageParams,
+  PlayerMessageResolver,
+  QtiPlayerMessageOverrides,
+} from "./player-message-resolver.js";
+
+class OverridePlayerMessageResolver implements PlayerMessageResolver {
+  constructor(
+    private readonly base: PlayerMessageResolver,
+    private readonly overrides: QtiPlayerMessageOverrides,
+  ) {}
+
+  message<K extends PlayerMessageKey>(key: K, params?: PlayerMessageParams<K>): string {
+    const override = this.overrides[key] as PlayerMessageOverride<K> | undefined;
+    if (override) {
+      if (params === undefined) {
+        return (override as () => string)();
+      }
+      return (override as (p: PlayerMessageParams<K>) => string)(params);
+    }
+    if (params === undefined) {
+      return (this.base.message as (messageKey: K) => string)(key);
+    }
+    return (this.base.message as (messageKey: K, p: PlayerMessageParams<K>) => string)(key, params);
+  }
+}
+
+export function applyPlayerMessageOverrides(
+  base: PlayerMessageResolver,
+  overrides: QtiPlayerMessageOverrides,
+): PlayerMessageResolver {
+  if (Object.keys(overrides).length === 0) {
+    return base;
+  }
+  return new OverridePlayerMessageResolver(base, overrides);
+}

package/src/player-message-resolver.ts

@@ -0,0 +1,205 @@
+import { defaultPlayerMessageCatalog } from "./player-message-catalog-default.js";
+import {
+  formatPlayerMessage,
+  mergePlayerMessageCatalogs,
+  type PlayerMessageCatalog,
+} from "./player-message-catalog.js";
+import { warnPlayerMessageOnce } from "./player-dev.js";
+import {
+  PLAYER_MESSAGE_MANIFEST,
+  type PlayerMessageKey,
+  type PlayerMessageManifestEntry,
+  type PlayerMessageResolverKind,
+} from "./player-message-manifest.js";
+import type { QtiPlayerMovementDirection } from "./player-messages.js";
+
+type ManifestEntry = (typeof PLAYER_MESSAGE_MANIFEST)[number];
+
+const MANIFEST_BY_KEY = new Map(PLAYER_MESSAGE_MANIFEST.map((entry) => [entry.key, entry]));
+
+type NumericParamName = "count" | "characters" | "words" | "index" | "position" | "total";
+
+type ParamValue<Name extends string> = Name extends NumericParamName
+  ? number
+  : Name extends "direction"
+    ? QtiPlayerMovementDirection
+    : string;
+
+type ParamsFromManifestEntry<E extends PlayerMessageManifestEntry> =
+  E["params"] extends readonly string[]
+    ? { [K in E["params"][number]]: ParamValue<K> }
+    : Record<string, never>;
+
+export type { PlayerMessageKey } from "./player-message-manifest.js";
+
+export type PlayerMessageParams<K extends PlayerMessageKey> = ParamsFromManifestEntry<
+  Extract<ManifestEntry, { key: K }>
+>;
+
+type MessageParamsArg<K extends PlayerMessageKey> =
+  PlayerMessageParams<K> extends Record<string, never> ? never : PlayerMessageParams<K>;
+
+/** Typed override handler for a single manifest message id. */
+export type PlayerMessageOverride<K extends PlayerMessageKey> =
+  MessageParamsArg<K> extends never ? () => string : (params: PlayerMessageParams<K>) => string;
+
+/** Per-message function overrides keyed by manifest id (params match {@link PlayerMessageParams}). */
+export type QtiPlayerMessageOverrides = {
+  [K in PlayerMessageKey]?: PlayerMessageOverride<K>;
+};
+
+/** Key-driven player chrome messages (canonical runtime API). */
+export interface PlayerMessageResolver {
+  message<K extends PlayerMessageKey>(
+    key: K,
+    ...args: MessageParamsArg<K> extends never ? [] : [MessageParamsArg<K>]
+  ): string;
+}
+
+function readableTypeFallback(type: string): string {
+  return type
+    .replace(/[A-Z]/g, (letter) => ` ${letter.toLowerCase()}`)
+    .replace(/^./, (letter) => letter.toUpperCase());
+}
+
+function mergedCatalog(catalog: PlayerMessageCatalog): PlayerMessageCatalog {
+  return mergePlayerMessageCatalogs(defaultPlayerMessageCatalog, catalog);
+}
+
+function resolveCatalogTemplate(
+  strings: Record<string, string>,
+  key: string,
+  count?: number,
+): string | undefined {
+  if (count !== undefined) {
+    const pluralKey = count === 1 ? `${key}.one` : `${key}.other`;
+    const pluralTemplate = strings[pluralKey] ?? defaultPlayerMessageCatalog.strings[pluralKey];
+    if (pluralTemplate !== undefined) {
+      return pluralTemplate;
+    }
+  }
+  return strings[key] ?? defaultPlayerMessageCatalog.strings[key];
+}
+
+function catalogString(
+  strings: Record<string, string>,
+  key: string,
+  values: Record<string, string | number> = {},
+  count?: number,
+): string {
+  const template = resolveCatalogTemplate(strings, key, count);
+  if (template === undefined) {
+    warnPlayerMessageOnce(
+      `missing-message:${key}`,
+      `Missing player message catalog key "${key}"; showing the key as UI text.`,
+    );
+    return key;
+  }
+  return formatPlayerMessage(template, values);
+}
+
+function resolveUnit(
+  strings: Record<string, string>,
+  prefix: "character" | "word",
+  count: number,
+): string {
+  const one = strings[`${prefix}Unit.one`];
+  const other = strings[`${prefix}Unit.other`];
+  if (one && other) {
+    return count === 1 ? one : other;
+  }
+  return prefix;
+}
+
+type ResolverContext = {
+  strings: Record<string, string>;
+  typeName: (type: string) => string;
+  directionLabel: (direction: QtiPlayerMovementDirection) => string;
+};
+
+function resolveManifestEntry(
+  entry: PlayerMessageManifestEntry,
+  context: ResolverContext,
+  params: Record<string, string | number> = {},
+): string {
+  const { strings, typeName, directionLabel } = context;
+  const { key, resolver } = entry;
+
+  switch (resolver as PlayerMessageResolverKind) {
+    case "plain":
+      return catalogString(strings, key);
+    case "typeLabel":
+      return typeName(String(params.type ?? ""));
+    case "template":
+      return catalogString(strings, key, params);
+    case "plural": {
+      const count = Number(params.count);
+      return catalogString(strings, key, params, count);
+    }
+    case "typeTemplate":
+      return catalogString(strings, key, {
+        ...params,
+        typeName: typeName(String(params.type ?? "")),
+      });
+    case "directionTemplate":
+      return catalogString(strings, key, {
+        ...params,
+        direction: directionLabel(params.direction as QtiPlayerMovementDirection),
+      });
+    case "extendedTextCounter": {
+      const characters = Number(params.characters);
+      const words = Number(params.words);
+      const template =
+        resolveCatalogTemplate(strings, key) ??
+        defaultPlayerMessageCatalog.strings.extendedTextCounter ??
+        key;
+      return formatPlayerMessage(template, {
+        characters,
+        words,
+        characterUnit: resolveUnit(strings, "character", characters),
+        wordUnit: resolveUnit(strings, "word", words),
+      });
+    }
+    default:
+      return key;
+  }
+}
+
+class CatalogPlayerMessageResolver implements PlayerMessageResolver {
+  private readonly context: ResolverContext;
+
+  constructor(catalog: PlayerMessageCatalog) {
+    const merged = mergedCatalog(catalog);
+    const types = merged.interactionTypes ?? {};
+    const directions = merged.directions ?? defaultPlayerMessageCatalog.directions ?? {};
+    this.context = {
+      strings: merged.strings,
+      typeName: (type) => types[type] ?? readableTypeFallback(type),
+      directionLabel: (direction) => directions[direction] ?? direction,
+    };
+  }
+
+  message<K extends PlayerMessageKey>(
+    key: K,
+    ...args: MessageParamsArg<K> extends never ? [] : [MessageParamsArg<K>]
+  ): string {
+    const entry = MANIFEST_BY_KEY.get(key);
+    if (!entry) {
+      return key;
+    }
+    const params = ((args as readonly unknown[])[0] ?? {}) as Record<string, string | number>;
+    return resolveManifestEntry(entry, this.context, params);
+  }
+}
+
+/**
+ * Resolves player chrome from a host catalog using {@link PLAYER_MESSAGE_MANIFEST}.
+ * Missing string keys fall back to English defaults.
+ */
+export function createPlayerMessageResolver(catalog: PlayerMessageCatalog): PlayerMessageResolver {
+  return new CatalogPlayerMessageResolver(catalog);
+}
+
+export const defaultPlayerMessageResolver: PlayerMessageResolver = createPlayerMessageResolver(
+  defaultPlayerMessageCatalog,
+);

package/src/player-messages.ts

@@ -1,31 +1 @@
-export interface QtiPlayerRemoveMessageParams {
-  label: string;
-}
-
-export interface QtiPlayerAssociationPairLabelParams {
-  source: string;
-  target: string;
-}
-
 export type QtiPlayerMovementDirection = "up" | "down" | "left" | "right";
-
-export interface QtiPlayerMessages {
-  remove: () => string;
-  removePair: (params: QtiPlayerRemoveMessageParams) => string;
-  clearDrawing: () => string;
-  clearPoints: () => string;
-  endAttempt: () => string;
-  uploadResponse: () => string;
-  movableObject: () => string;
-  placeObject: () => string;
-  inlineChoicePrompt: () => string;
-  noPointSelected: () => string;
-  noRegionSelected: () => string;
-  noAssociationsMade: () => string;
-  associationsMade: (params: { count: number }) => string;
-  associationPairLabel: (params: QtiPlayerAssociationPairLabelParams) => string;
-  hotspotSelectedChooseAnother: (params: { label: string }) => string;
-  moveChoice: (params: { label: string; direction: QtiPlayerMovementDirection }) => string;
-  movePoint: (params: { direction: QtiPlayerMovementDirection }) => string;
-  moveObject: (params: { direction: QtiPlayerMovementDirection }) => string;
-}

package/src/player-types.ts

@@ -9,8 +9,6 @@ import type {
   QtiScoreResult,
   QtiValue,
 } from "@longsightgroup/qti3-core";
-import type { QtiPlayerMessages } from "./player-messages.js";
-
 export interface QtiPlayerSessionControl {
   validateResponses?: boolean | undefined;
   showFeedback?: boolean | undefined;
@@ -31,8 +29,6 @@ export interface QtiPlayerLoadOptions {
   resolveAsset?: QtiPlayerResolveAsset | undefined;
 }
 
-export type QtiPlayerMessageOverrides = Partial<QtiPlayerMessages>;
-
 export interface QtiReadyEventDetail {
   item: QtiAssessmentItem;
 }
@@ -77,6 +73,18 @@ export interface QtiEndAttemptEventDetail {
   state: QtiAttemptStateV1;
 }
 
+export interface QtiDiagnosticsEventDetail {
+  diagnostics: QtiDiagnostic[];
+}
+
+export interface QtiResetEventDetail {
+  state?: QtiAttemptStateV1 | undefined;
+}
+
+export interface QtiRestoreEventDetail {
+  state?: QtiAttemptStateV1 | undefined;
+}
+
 export interface QtiAssessmentItemPlayerEventDetailMap {
   "qti-ready": QtiReadyEventDetail;
   "qti-statechange": QtiStateChangeEventDetail;
@@ -86,6 +94,9 @@ export interface QtiAssessmentItemPlayerEventDetailMap {
   "qti-validation": QtiValidationEventDetail;
   "qti-suspend": QtiSuspendEventDetail;
   "qti-endattempt": QtiEndAttemptEventDetail;
+  "qti-diagnostics": QtiDiagnosticsEventDetail;
+  "qti-reset": QtiResetEventDetail;
+  "qti-restore": QtiRestoreEventDetail;
 }
 
 export type QtiAssessmentItemPlayerEventName = keyof QtiAssessmentItemPlayerEventDetailMap;

package/src/reorder/a11y.ts

@@ -1,4 +1,5 @@
 import { choiceSelector } from "../interaction-support.js";
+import type { PlayerMessageResolver } from "../player-message-resolver.js";
 
 export function createSelectionSummary(): HTMLParagraphElement {
   const summary = document.createElement("p");
@@ -7,32 +8,46 @@ export function createSelectionSummary(): HTMLParagraphElement {
   return summary;
 }
 
-export function orderedItemAccessibleName(label: string, index: number, total: number): string {
-  return `${label}, position ${index + 1} of ${total}`;
+export function orderedItemAccessibleName(
+  messages: PlayerMessageResolver,
+  label: string,
+  index: number,
+  total: number,
+): string {
+  return messages.message("orderedItemAtPosition", { label, position: index + 1, total });
 }
 
 export function announceOrderedItemMove(
   summary: HTMLElement,
+  messages: PlayerMessageResolver,
   label: string,
   to: number,
   total: number,
   from?: number,
 ): void {
   if (from !== undefined && Math.abs(to - from) === 1) {
-    summary.textContent = `${label} moved ${to < from ? "up" : "down"}.`;
+    summary.textContent = messages.message("orderedItemMovedOneStep", {
+      label,
+      direction: to < from ? "up" : "down",
+    });
     return;
   }
-  summary.textContent = `${label} moved to position ${to + 1} of ${total}.`;
+  summary.textContent = messages.message("orderedItemMovedToPosition", {
+    label,
+    position: to + 1,
+    total,
+  });
 }
 
 export function announceOrderedSelectionCount(
   summary: HTMLElement,
+  messages: PlayerMessageResolver,
   count: number,
-  singular: string,
-  plural: string,
 ): void {
   summary.textContent =
-    count > 0 ? `${count} ${count === 1 ? singular : plural}.` : `No ${plural}.`;
+    count > 0
+      ? messages.message("graphicOrderRegionsSelected", { count })
+      : messages.message("graphicOrderNoRegionsSelected");
 }
 
 export function focusReorderControl(container: ParentNode, identifier: string): void {

package/src/reorder/graphic-order-interaction.ts

@@ -12,12 +12,11 @@ import {
   objectHeight,
   objectWidth,
   placeHotspotButton,
-  readableType,
   responseGroup,
   valueToStrings,
 } from "../interaction-support.js";
 import { movementButton } from "../movement.js";
-import type { QtiPlayerMessages } from "../player-messages.js";
+import type { PlayerMessageResolver } from "../player-message-resolver.js";
 import {
   announceOrderedItemMove,
   announceOrderedSelectionCount,
@@ -30,7 +29,7 @@ export function renderGraphicOrderResponse(
   interaction: QtiInteraction,
   update: (value: QtiValue) => void,
   currentValue: QtiValue,
-  messages: QtiPlayerMessages,
+  messages: PlayerMessageResolver,
 ): HTMLElement {
   const group = responseGroup();
   const width = objectWidth(interaction);
@@ -47,14 +46,17 @@ export function renderGraphicOrderResponse(
   const surface = document.createElement("div");
   applyGraphicSurfaceLayout(surface, width, height, "qti3-graphic-order-surface");
   surface.role = "group";
-  surface.setAttribute("aria-label", `${readableType(interaction.type)} hotspots`);
+  surface.setAttribute(
+    "aria-label",
+    messages.message("interactionHotspots", { type: interaction.type }),
+  );
 
   const object = interaction.object;
   if (object) {
     appendGraphicObjectImage(
       surface,
       object,
-      object.text || `${readableType(interaction.type)} image`,
+      object.text || messages.message("interactionImageAlt", { type: interaction.type }),
     );
   }
 
@@ -82,7 +84,10 @@ export function renderGraphicOrderResponse(
   const summary = createSelectionSummary();
   const list = document.createElement("ol");
   list.className = "qti3-graphic-order-list";
-  list.setAttribute("aria-label", `${readableType(interaction.type)} selected order`);
+  list.setAttribute(
+    "aria-label",
+    messages.message("interactionSelectedOrderList", { type: interaction.type }),
+  );
 
   const orderedChoices = () =>
     orderedIdentifiers
@@ -90,12 +95,7 @@ export function renderGraphicOrderResponse(
       .filter((choice): choice is QtiChoice => Boolean(choice));
   const commit = () => update([...orderedIdentifiers]);
   const updateSelectionCountSummary = () => {
-    announceOrderedSelectionCount(
-      summary,
-      orderedIdentifiers.length,
-      "region ordered",
-      "regions ordered",
-    );
+    announceOrderedSelectionCount(summary, messages, orderedIdentifiers.length);
   };
   const focusHotspot = (identifier: string) => {
     surface
@@ -135,7 +135,14 @@ export function renderGraphicOrderResponse(
     if (!entry) return;
     orderedIdentifiers.splice(targetIndex, 0, entry);
     renderState();
-    announceOrderedItemMove(summary, choiceLabel, targetIndex, orderedIdentifiers.length, index);
+    announceOrderedItemMove(
+      summary,
+      messages,
+      choiceLabel,
+      targetIndex,
+      orderedIdentifiers.length,
+      index,
+    );
     commit();
     focusReorderControl(list, identifier);
   };
@@ -182,7 +189,7 @@ export function renderGraphicOrderResponse(
         label.textContent = `${index + 1}. ${choiceLabel}`;
         label.setAttribute(
           "aria-label",
-          orderedItemAccessibleName(choiceLabel, index, currentChoices.length),
+          orderedItemAccessibleName(messages, choiceLabel, index, currentChoices.length),
         );
         label.addEventListener("click", () => focusHotspot(choice.identifier));
         label.addEventListener("keydown", (event) => {
@@ -200,14 +207,14 @@ export function renderGraphicOrderResponse(
 
         const up = movementButton(
           "up",
-          messages.moveChoice({ label: choiceLabel, direction: "up" }),
+          messages.message("moveChoice", { label: choiceLabel, direction: "up" }),
           () => moveHotspot(choice.identifier, -1),
         );
         up.disabled = index === 0;
 
         const down = movementButton(
           "down",
-          messages.moveChoice({ label: choiceLabel, direction: "down" }),
+          messages.message("moveChoice", { label: choiceLabel, direction: "down" }),
           () => moveHotspot(choice.identifier, 1),
         );
         down.disabled = index === currentChoices.length - 1;

package/src/reorder/list-controls.ts

@@ -1,5 +1,5 @@
 import { movementButton } from "../movement.js";
-import type { QtiPlayerMessages } from "../player-messages.js";
+import type { PlayerMessageResolver } from "../player-message-resolver.js";
 import { orderedItemAccessibleName } from "./a11y.js";
 
 export interface ReorderHandleOptions {
@@ -9,7 +9,7 @@ export interface ReorderHandleOptions {
   total: number;
   handleClassName: string;
   visibleText: string;
-  messages: QtiPlayerMessages;
+  messages: PlayerMessageResolver;
   onMoveBy: (delta: number) => void;
 }
 
@@ -25,7 +25,7 @@ export function createReorderHandleControls(options: ReorderHandleOptions): {
   handle.type = "button";
   handle.className = handleClassName;
   handle.dataset.choiceIdentifier = identifier;
-  handle.setAttribute("aria-label", orderedItemAccessibleName(label, index, total));
+  handle.setAttribute("aria-label", orderedItemAccessibleName(messages, label, index, total));
   handle.textContent = visibleText;
   handle.addEventListener("keydown", (event) => {
     if (event.key === "ArrowUp" || event.key === "ArrowLeft") {
@@ -37,13 +37,15 @@ export function createReorderHandleControls(options: ReorderHandleOptions): {
     }
   });
 
-  const up = movementButton("up", messages.moveChoice({ label, direction: "up" }), () =>
+  const up = movementButton("up", messages.message("moveChoice", { label, direction: "up" }), () =>
     onMoveBy(-1),
   );
   up.disabled = index === 0;
 
-  const down = movementButton("down", messages.moveChoice({ label, direction: "down" }), () =>
-    onMoveBy(1),
+  const down = movementButton(
+    "down",
+    messages.message("moveChoice", { label, direction: "down" }),
+    () => onMoveBy(1),
   );
   down.disabled = index === total - 1;
 

package/src/reorder/order-interaction.ts

@@ -1,10 +1,9 @@
 import type { QtiInteraction, QtiValue } from "@longsightgroup/qti3-core";
-import type { QtiPlayerMessages } from "../player-messages.js";
+import type { PlayerMessageResolver } from "../player-message-resolver.js";
 import {
   interactionChoices,
   missingChoicesMessage,
   orderChoicesFromValue,
-  readableType,
   responseGroup,
 } from "../interaction-support.js";
 import { announceOrderedItemMove, createSelectionSummary, focusReorderControl } from "./a11y.js";
@@ -18,7 +17,7 @@ export function renderOrderedResponse(
   interaction: QtiInteraction,
   update: (value: QtiValue) => void,
   currentValue: QtiValue,
-  messages: QtiPlayerMessages,
+  messages: PlayerMessageResolver,
 ): HTMLElement {
   const group = responseGroup();
   const choices = interactionChoices(interaction).filter((choice) => choice.role !== "gap");
@@ -29,7 +28,10 @@ export function renderOrderedResponse(
   const ordered = orderChoicesFromValue(choices, currentValue);
   const list = document.createElement("ol");
   list.className = "qti3-reorder-list";
-  list.setAttribute("aria-label", `${readableType(interaction.type)} current order`);
+  list.setAttribute(
+    "aria-label",
+    messages.message("interactionCurrentOrderList", { type: interaction.type }),
+  );
   const summary = createSelectionSummary();
   const dragState: OrderDragState = {};
 
@@ -42,7 +44,7 @@ export function renderOrderedResponse(
     if (!choice) return;
     ordered.splice(to, 0, choice);
     renderList();
-    announceOrderedItemMove(summary, choice.text, to, ordered.length, from);
+    announceOrderedItemMove(summary, messages, choice.text, to, ordered.length, from);
     commit();
     focusReorderControl(list, choice.identifier);
   };