@longsightgroup/qti3-player 0.4.0 → 0.5.4

package/src/player-element.ts

@@ -26,7 +26,12 @@ import {
   collectEmbeddedInteractionDiagnostics,
   collectInteractionRenderDiagnostics,
 } from "./interactions/interaction-diagnostics.js";
+import type { PlayerMessageCatalog } from "./player-message-catalog.js";
 import { defaultPlayerLocale, normalizedLocale, resolvePlayerMessages } from "./player-locale.js";
+import type {
+  PlayerMessageResolver,
+  QtiPlayerMessageOverrides,
+} from "./player-message-resolver.js";
 import { syncAttemptAvailability } from "./player/attempt-availability.js";
 import {
   currentTemplateValue,
@@ -48,7 +53,6 @@ import type {
   QtiAssessmentItemPlayerEventDetailMap,
   QtiAssessmentItemPlayerEventName,
   QtiPlayerLoadOptions,
-  QtiPlayerMessageOverrides,
   QtiPlayerResolveAsset,
   QtiPlayerSessionControl,
   QtiScoreAttemptOptions,
@@ -80,11 +84,14 @@ export class QtiAssessmentItemPlayer extends HTMLElementBase {
   private validationMessages: QtiDiagnostic[] = [];
   private authoringDiagnostics: QtiDiagnostic[] = [];
   private languageOfInterfaceOverride: string | undefined;
+  private messageCatalogOverride: PlayerMessageCatalog | undefined;
   private messageOverrides: QtiPlayerMessageOverrides = {};
+  private resolvedMessagesCache: PlayerMessageResolver | undefined;
   private sessionControl: Required<QtiPlayerSessionControl> = {
     validateResponses: true,
     showFeedback: true,
   };
+  private loadGeneration = 0;
 
   get languageOfInterface(): string {
     return (
@@ -97,6 +104,7 @@ export class QtiAssessmentItemPlayer extends HTMLElementBase {
 
   set languageOfInterface(value: string | undefined) {
     this.languageOfInterfaceOverride = normalizedLocale(value);
+    this.invalidatePlayerMessages();
     this.rerenderIfLoaded();
   }
 
@@ -114,6 +122,17 @@ export class QtiAssessmentItemPlayer extends HTMLElementBase {
 
   set messages(value: QtiPlayerMessageOverrides | undefined) {
     this.messageOverrides = value ?? {};
+    this.invalidatePlayerMessages();
+    this.rerenderIfLoaded();
+  }
+
+  get messageCatalog(): PlayerMessageCatalog | undefined {
+    return this.messageCatalogOverride;
+  }
+
+  set messageCatalog(value: PlayerMessageCatalog | undefined) {
+    this.messageCatalogOverride = value;
+    this.invalidatePlayerMessages();
     this.rerenderIfLoaded();
   }
 
@@ -121,15 +140,59 @@ export class QtiAssessmentItemPlayer extends HTMLElementBase {
     if ((name !== "language-of-interface" && name !== "locale") || oldValue === newValue) {
       return;
     }
+    this.invalidatePlayerMessages();
     this.rerenderIfLoaded();
   }
 
+  private invalidatePlayerMessages(): void {
+    this.resolvedMessagesCache = undefined;
+  }
+
+  /** Clears the loaded item. Does not emit player events; declarative hosts control this via `xml`. */
+  clearItem(): void {
+    this.loadGeneration += 1;
+    delete this.documentModel;
+    delete this.session;
+    this.validationMessages = [];
+    this.authoringDiagnostics = [];
+    this.replaceChildren();
+  }
+
   async loadXml(xml: string, options: QtiPlayerLoadOptions = {}): Promise<void> {
+    const generation = this.beginLoad();
+    await this.applyLoadedXml(generation, xml, options);
+  }
+
+  async loadUrl(url: string, options: QtiPlayerLoadOptions = {}): Promise<void> {
+    const generation = this.beginLoad();
+    const fetchXml = options.fetchXml ?? defaultFetchXml;
+    const xml = await fetchXml(url);
+    if (!this.isCurrentLoad(generation)) return;
+    await this.applyLoadedXml(generation, xml, options);
+  }
+
+  private beginLoad(): number {
+    this.loadGeneration += 1;
+    return this.loadGeneration;
+  }
+
+  private isCurrentLoad(generation: number): boolean {
+    return generation === this.loadGeneration;
+  }
+
+  private async applyLoadedXml(
+    generation: number,
+    xml: string,
+    options: QtiPlayerLoadOptions,
+  ): Promise<void> {
+    if (!this.isCurrentLoad(generation)) return;
+
     this.sessionControl = {
       validateResponses: options.sessionControl?.validateResponses ?? true,
       showFeedback: options.sessionControl?.showFeedback ?? true,
     };
     this.resolveAsset = options.resolveAsset;
+
     const result = parseQtiXml(xml);
     const playerDiagnostics = result.document
       ? [
@@ -137,6 +200,8 @@ export class QtiAssessmentItemPlayer extends HTMLElementBase {
           ...collectEmbeddedInteractionDiagnostics(result.document.item),
         ]
       : [];
+    if (!this.isCurrentLoad(generation)) return;
+
     this.dispatchEvent(
       new CustomEvent("qti-diagnostics", {
         detail: { diagnostics: [...result.diagnostics, ...playerDiagnostics] },
@@ -146,10 +211,13 @@ export class QtiAssessmentItemPlayer extends HTMLElementBase {
       playerDiagnostics.filter((diagnostic) => diagnostic.severity === "error"),
     );
     if (!result.document) {
+      if (!this.isCurrentLoad(generation)) return;
       this.replaceChildren(errorView("Unable to parse QTI item."));
       return;
     }
 
+    if (!this.isCurrentLoad(generation)) return;
+
     this.documentModel = result.document;
     this.session = createItemSession(result.document, options.state);
     this.validationMessages = cloneDiagnostics(
@@ -163,11 +231,6 @@ export class QtiAssessmentItemPlayer extends HTMLElementBase {
     this.emitStateChange();
   }
 
-  async loadUrl(url: string, options: QtiPlayerLoadOptions = {}): Promise<void> {
-    const fetchXml = options.fetchXml ?? defaultFetchXml;
-    await this.loadXml(await fetchXml(url), options);
-  }
-
   scoreAttempt(options: QtiScoreAttemptOptions = {}): QtiScoreResult | undefined {
     const session = this.session;
     if (!session) return undefined;
@@ -288,8 +351,15 @@ export class QtiAssessmentItemPlayer extends HTMLElementBase {
     this.dispatchEvent(new CustomEvent<QtiAssessmentItemPlayerEventDetailMap[T]>(type, { detail }));
   }
 
-  private playerMessages() {
-    return resolvePlayerMessages(this.languageOfInterface, this.messageOverrides);
+  private playerMessages(): PlayerMessageResolver {
+    if (!this.resolvedMessagesCache) {
+      this.resolvedMessagesCache = resolvePlayerMessages(
+        this.languageOfInterface,
+        this.messageOverrides,
+        this.messageCatalogOverride,
+      );
+    }
+    return this.resolvedMessagesCache;
   }
 
   private rerenderIfLoaded(): void {

package/src/player-locale.ts

@@ -1,206 +1,35 @@
-import type { QtiPlayerMessages } from "./player-messages.js";
-import type { QtiPlayerMessageOverrides } from "./player-types.js";
-
-type QtiPlayerMessageCatalog = Readonly<Partial<QtiPlayerMessages>>;
-
-const defaultEnglishPlayerMessages: QtiPlayerMessages = {
-  remove: () => "Remove",
-  removePair: ({ label }) => `Remove ${label}`,
-  clearDrawing: () => "Clear drawing",
-  clearPoints: () => "Clear points",
-  endAttempt: () => "End attempt",
-  uploadResponse: () => "Upload response",
-  movableObject: () => "Movable object",
-  placeObject: () => "Place",
-  inlineChoicePrompt: () => "Choose...",
-  noPointSelected: () => "No point selected",
-  noRegionSelected: () => "No region selected",
-  noAssociationsMade: () => "No associations made",
-  associationsMade: ({ count }) => `${count} ${count === 1 ? "association" : "associations"} made.`,
-  associationPairLabel: ({ source, target }) => `${source} to ${target}`,
-  hotspotSelectedChooseAnother: ({ label }) => `${label} selected. Choose another hotspot.`,
-  moveChoice: ({ label, direction }) => `Move ${label} ${direction}`,
-  movePoint: ({ direction }) => `Move point ${direction}`,
-  moveObject: ({ direction }) => `Move object ${direction}`,
-};
-
-const playerMessages = {
-  defaultEnglish: defaultEnglishPlayerMessages,
-  spanish: {
-    remove: () => "Quitar",
-    removePair: ({ label }) => `Quitar ${label}`,
-    clearDrawing: () => "Borrar dibujo",
-    clearPoints: () => "Borrar puntos",
-    endAttempt: () => "Finalizar intento",
-    uploadResponse: () => "Subir respuesta",
-    movableObject: () => "Objeto movible",
-    placeObject: () => "Colocar",
-    inlineChoicePrompt: () => "Elija...",
-    noPointSelected: () => "Ningun punto seleccionado",
-    noRegionSelected: () => "Ninguna region seleccionada",
-    noAssociationsMade: () => "Ninguna asociacion realizada",
-    associationsMade: ({ count }) =>
-      `${count} ${count === 1 ? "asociacion realizada" : "asociaciones realizadas"}.`,
-    associationPairLabel: ({ source, target }) => `${source} con ${target}`,
-    hotspotSelectedChooseAnother: ({ label }) => `${label} seleccionado. Elija otro punto activo.`,
-    moveChoice: ({ label, direction }) => `Mover ${label} ${spanishDirection(direction)}`,
-    movePoint: ({ direction }) => `Mover punto ${spanishDirection(direction)}`,
-    moveObject: ({ direction }) => `Mover objeto ${spanishDirection(direction)}`,
-  },
-  swedish: {
-    remove: () => "Ta bort",
-    removePair: ({ label }) => `Ta bort ${label}`,
-    clearDrawing: () => "Rensa ritning",
-    clearPoints: () => "Rensa punkter",
-    endAttempt: () => "Avsluta forsok",
-    uploadResponse: () => "Ladda upp svar",
-    movableObject: () => "Flyttbart objekt",
-    placeObject: () => "Placera",
-    inlineChoicePrompt: () => "Valj...",
-    noPointSelected: () => "Ingen punkt vald",
-    noRegionSelected: () => "Ingen region vald",
-    noAssociationsMade: () => "Inga associationer gjorda",
-    associationsMade: ({ count }) =>
-      `${count} ${count === 1 ? "association gjord" : "associationer gjorda"}.`,
-    associationPairLabel: ({ source, target }) => `${source} med ${target}`,
-    hotspotSelectedChooseAnother: ({ label }) => `${label} valt. Valj en annan hotspot.`,
-    moveChoice: ({ label, direction }) => `Flytta ${label} ${swedishDirection(direction)}`,
-    movePoint: ({ direction }) => `Flytta punkt ${swedishDirection(direction)}`,
-    moveObject: ({ direction }) => `Flytta objekt ${swedishDirection(direction)}`,
-  },
-  german: {
-    remove: () => "Entfernen",
-    removePair: ({ label }) => `${label} entfernen`,
-    clearDrawing: () => "Zeichnung loeschen",
-    clearPoints: () => "Punkte loeschen",
-    endAttempt: () => "Versuch beenden",
-    uploadResponse: () => "Antwort hochladen",
-    movableObject: () => "Bewegliches Objekt",
-    placeObject: () => "Platzieren",
-    inlineChoicePrompt: () => "Waehlen...",
-    noPointSelected: () => "Kein Punkt ausgewaehlt",
-    noRegionSelected: () => "Keine Region ausgewaehlt",
-    noAssociationsMade: () => "Keine Zuordnungen erstellt",
-    associationsMade: ({ count }) =>
-      `${count} ${count === 1 ? "Zuordnung erstellt" : "Zuordnungen erstellt"}.`,
-    associationPairLabel: ({ source, target }) => `${source} mit ${target}`,
-    hotspotSelectedChooseAnother: ({ label }) =>
-      `${label} ausgewaehlt. Waehlen Sie einen weiteren Hotspot.`,
-    moveChoice: ({ label, direction }) => `${label} ${germanDirection(direction)} bewegen`,
-    movePoint: ({ direction }) => `Punkt ${germanDirection(direction)} bewegen`,
-    moveObject: ({ direction }) => `Objekt ${germanDirection(direction)} bewegen`,
-  },
-  portuguese: {
-    remove: () => "Remover",
-    removePair: ({ label }) => `Remover ${label}`,
-    clearDrawing: () => "Limpar desenho",
-    clearPoints: () => "Limpar pontos",
-    endAttempt: () => "Finalizar tentativa",
-    uploadResponse: () => "Enviar resposta",
-    movableObject: () => "Objeto movel",
-    placeObject: () => "Posicionar",
-    inlineChoicePrompt: () => "Escolha...",
-    noPointSelected: () => "Nenhum ponto selecionado",
-    noRegionSelected: () => "Nenhuma regiao selecionada",
-    noAssociationsMade: () => "Nenhuma associacao feita",
-    associationsMade: ({ count }) =>
-      `${count} ${count === 1 ? "associacao feita" : "associacoes feitas"}.`,
-    associationPairLabel: ({ source, target }) => `${source} com ${target}`,
-    hotspotSelectedChooseAnother: ({ label }) => `${label} selecionado. Escolha outro ponto ativo.`,
-    moveChoice: ({ label, direction }) => `Mover ${label} ${portugueseDirection(direction)}`,
-    movePoint: ({ direction }) => `Mover ponto ${portugueseDirection(direction)}`,
-    moveObject: ({ direction }) => `Mover objeto ${portugueseDirection(direction)}`,
-  },
-  french: {
-    remove: () => "Supprimer",
-    removePair: ({ label }) => `Supprimer ${label}`,
-    clearDrawing: () => "Effacer le dessin",
-    clearPoints: () => "Effacer les points",
-    endAttempt: () => "Terminer la tentative",
-    uploadResponse: () => "Televerser la reponse",
-    movableObject: () => "Objet mobile",
-    placeObject: () => "Placer",
-    inlineChoicePrompt: () => "Choisir...",
-    noPointSelected: () => "Aucun point selectionne",
-    noRegionSelected: () => "Aucune region selectionnee",
-    noAssociationsMade: () => "Aucune association effectuee",
-    associationsMade: ({ count }) =>
-      `${count} ${count === 1 ? "association effectuee" : "associations effectuees"}.`,
-    associationPairLabel: ({ source, target }) => `${source} avec ${target}`,
-    hotspotSelectedChooseAnother: ({ label }) =>
-      `${label} selectionne. Choisissez un autre point actif.`,
-    moveChoice: ({ label, direction }) => `Deplacer ${label} vers ${frenchDirection(direction)}`,
-    movePoint: ({ direction }) => `Deplacer le point vers ${frenchDirection(direction)}`,
-    moveObject: ({ direction }) => `Deplacer l'objet vers ${frenchDirection(direction)}`,
-  },
-} satisfies Record<string, QtiPlayerMessageCatalog>;
-
-const builtInPlayerMessageCatalogs: ReadonlyMap<string, QtiPlayerMessageCatalog> = new Map([
-  ["en", playerMessages.defaultEnglish],
-  ["es", playerMessages.spanish],
-  ["es-es", playerMessages.spanish],
-  ["es-mx", playerMessages.spanish],
-  ["sv", playerMessages.swedish],
-  ["sv-se", playerMessages.swedish],
-  ["de", playerMessages.german],
-  ["de-de", playerMessages.german],
-  ["pt", playerMessages.portuguese],
-  ["pt-br", playerMessages.portuguese],
-  ["pt-pt", playerMessages.portuguese],
-  ["fr", playerMessages.french],
-  ["fr-ca", playerMessages.french],
-  ["fr-fr", playerMessages.french],
-]);
-
+import type { PlayerMessageCatalog } from "./player-message-catalog.js";
+import { applyPlayerMessageOverrides } from "./player-message-overrides.js";
+import {
+  createPlayerMessageResolver,
+  defaultPlayerMessageResolver,
+  type PlayerMessageResolver,
+} from "./player-message-resolver.js";
+import { warnPlayerMessageOnce } from "./player-dev.js";
+import type { QtiPlayerMessageOverrides } from "./player-message-resolver.js";
+
+function isEnglishLocale(locale: string): boolean {
+  const normalized = normalizedLocale(locale) ?? locale;
+  return normalized.toLowerCase().startsWith("en");
+}
+
+/**
+ * Resolves player chrome messages: catalog (or English defaults) merged with overrides.
+ * `locale` does not select built-in catalogs; use `catalog` via `player.messageCatalog`.
+ */
 export function resolvePlayerMessages(
   locale: string,
   overrides: QtiPlayerMessageOverrides,
-): QtiPlayerMessages {
-  const catalog = builtInPlayerMessageCatalog(locale);
-  return { ...defaultEnglishPlayerMessages, ...catalog, ...overrides };
-}
-
-function spanishDirection(direction: "up" | "down" | "left" | "right"): string {
-  return { up: "arriba", down: "abajo", left: "a la izquierda", right: "a la derecha" }[direction];
-}
-
-function swedishDirection(direction: "up" | "down" | "left" | "right"): string {
-  return { up: "upp", down: "ned", left: "vanster", right: "hoger" }[direction];
-}
-
-function germanDirection(direction: "up" | "down" | "left" | "right"): string {
-  return { up: "nach oben", down: "nach unten", left: "nach links", right: "nach rechts" }[
-    direction
-  ];
-}
-
-function portugueseDirection(direction: "up" | "down" | "left" | "right"): string {
-  return { up: "para cima", down: "para baixo", left: "para a esquerda", right: "para a direita" }[
-    direction
-  ];
-}
-
-function frenchDirection(direction: "up" | "down" | "left" | "right"): string {
-  return { up: "le haut", down: "le bas", left: "la gauche", right: "la droite" }[direction];
-}
-
-function builtInPlayerMessageCatalog(locale: string): QtiPlayerMessageCatalog | undefined {
-  for (const candidate of localeFallbacks(locale)) {
-    const catalog = builtInPlayerMessageCatalogs.get(candidate);
-    if (catalog) return catalog;
-  }
-  return undefined;
-}
-
-function localeFallbacks(locale: string): string[] {
-  const normalized = normalizedLocale(locale)?.toLowerCase();
-  if (!normalized) return ["en"];
-  const parts = normalized.split("-");
-  const fallbacks: string[] = [];
-  for (let length = parts.length; length > 0; length -= 1) {
-    fallbacks.push(parts.slice(0, length).join("-"));
+  catalog?: PlayerMessageCatalog,
+): PlayerMessageResolver {
+  if (!catalog && !isEnglishLocale(locale) && Object.keys(overrides).length === 0) {
+    warnPlayerMessageOnce(
+      `locale-without-catalog:${locale}`,
+      `language-of-interface is "${locale}" but no player.messageCatalog was set; chrome stays English. Load a locale file and assign player.messageCatalog.`,
+    );
   }
-  return fallbacks.includes("en") ? fallbacks : [...fallbacks, "en"];
+  const base = catalog ? createPlayerMessageResolver(catalog) : defaultPlayerMessageResolver;
+  return applyPlayerMessageOverrides(base, overrides);
 }
 
 export function normalizedLocale(value: string | undefined | null): string | undefined {

package/src/player-message-catalog-default.ts

@@ -0,0 +1,119 @@
+import type { PlayerMessageCatalog } from "./player-message-catalog.js";
+
+/** English player chrome catalog (JSON-serializable). Hosts copy this shape for locale files. */
+export const defaultPlayerMessageCatalog: PlayerMessageCatalog = {
+  locale: "en",
+  directions: {
+    up: "up",
+    down: "down",
+    left: "left",
+    right: "right",
+  },
+  interactionTypes: {
+    associate: "Associate",
+    choice: "Choice",
+    drawing: "Drawing",
+    endAttempt: "End attempt",
+    extendedText: "Extended text",
+    gapMatch: "Gap match",
+    graphicAssociate: "Graphic associate",
+    graphicGapMatch: "Graphic gap match",
+    graphicOrder: "Graphic order",
+    hottext: "Hot text",
+    hotspot: "Hotspot",
+    inlineChoice: "Inline choice",
+    match: "Match",
+    media: "Media",
+    order: "Order",
+    pair: "Pair",
+    portableCustom: "Portable custom",
+    positionObject: "Position object",
+    selectPoint: "Select point",
+    slider: "Slider",
+    textEntry: "Text entry",
+    upload: "Upload",
+  },
+  strings: {
+    remove: "Remove",
+    removePair: "Remove {label}",
+    clearDrawing: "Clear drawing",
+    clearPoints: "Clear points",
+    endAttempt: "End attempt",
+    uploadResponse: "Upload response",
+    movableObject: "Movable object",
+    placeObject: "Place",
+    inlineChoicePrompt: "Choose...",
+    extendedTextCounter: "{characters} {characterUnit}, {words} {wordUnit}",
+    "characterUnit.one": "character",
+    "characterUnit.other": "characters",
+    "wordUnit.one": "word",
+    "wordUnit.other": "words",
+    hotspotSelectionSummary: "Selected {selection}",
+    noPointSelected: "No point selected",
+    noRegionSelected: "No region selected",
+    noAssociationsMade: "No associations made",
+    "associationsMade.one": "{count} association made.",
+    "associationsMade.other": "{count} associations made.",
+    associationPairLabel: "{source} to {target}",
+    hotspotSelectedChooseAnother: "{label} selected. Choose another hotspot.",
+    moveChoice: "Move {label} {direction}",
+    movePoint: "Move point {direction}",
+    moveObject: "Move object {direction}",
+    matchSourcesBank: "Match sources",
+    matchTargetsBank: "Match targets",
+    matchSelectedPairsList: "Match selected pairs",
+    interactionSourcesBank: "{typeName} sources",
+    interactionTargetsBank: "{typeName} targets",
+    interactionSelectedPairsList: "{typeName} selected pairs",
+    associateFirstConceptRegion: "First concept",
+    associatePairWithRegion: "Pair with",
+    matchPromptRegion: "Prompt",
+    matchMatchRegion: "Match",
+    genericSourceRegion: "Source",
+    genericTargetRegion: "Target",
+    interactionHotspots: "{typeName} hotspots",
+    interactionImageAlt: "{typeName} image",
+    interactionCurrentOrderList: "{typeName} current order",
+    interactionSelectedOrderList: "{typeName} selected order",
+    interactionChoicesBank: "{typeName} choices",
+    interactionGapTargets: "{typeName} targets",
+    interactionTargetImage: "{typeName} target image",
+    interactionOptionsList: "{typeName} options",
+    interactionCoordinateResponse: "{typeName} coordinate response",
+    interactionCoordinateArea: "{typeName} coordinate area",
+    interactionCoordinateAreaSelected: "{typeName} coordinate area, selected {coordinates}",
+    interactionPlacementResponse: "{typeName} object placement response",
+    interactionPlacementStage: "{typeName} placement stage",
+    interactionPlacementStageEmpty: "{typeName} placement stage, object not placed",
+    interactionPlacementStageAt: "{typeName} placement stage, object at {coordinates}",
+    interactionDrawingResponse: "{typeName} response",
+    drawingSurface: "Drawing response surface",
+    drawingSurfaceEmpty: "Drawing response surface, no strokes",
+    "drawingSurfaceStrokeCount.one": "Drawing response surface, {count} stroke",
+    "drawingSurfaceStrokeCount.other": "Drawing response surface, {count} strokes",
+    drawingStatusEmpty: "No drawing strokes.",
+    "drawingStatusStrokeCount.one": "{count} drawing stroke.",
+    "drawingStatusStrokeCount.other": "{count} drawing strokes.",
+    gapLabel: "Gap {index}",
+    graphicGapTargetLabel: "Target {index}",
+    gapEmptyState: "{label}, empty",
+    gapAssignedState: "{label}, assigned {assigned}",
+    "gapLabelsPlacedCount.one": "{count} label placed.",
+    "gapLabelsPlacedCount.other": "{count} labels placed.",
+    gapNoLabelsPlaced: "No labels placed.",
+    orderedItemAtPosition: "{label}, position {position} of {total}",
+    orderedItemMovedOneStep: "{label} moved {direction}.",
+    orderedItemMovedToPosition: "{label} moved to position {position} of {total}.",
+    "graphicOrderRegionsSelected.one": "{count} region ordered.",
+    "graphicOrderRegionsSelected.other": "{count} regions ordered.",
+    graphicOrderNoRegionsSelected: "No regions ordered.",
+    objectNotPlaced: "Object not placed",
+    objectPositionedAt: "Object positioned at {coordinates}",
+    selectedPointAt: "Selected point {coordinates}",
+    "selectedPointsSummary.one": "{count} selected point: {coordinates}",
+    "selectedPointsSummary.other": "{count} selected points: {coordinates}",
+    extendedTextResponseLabel: "Extended text response",
+    textResponseLabel: "Text response",
+    sliderResponseLabel: "Slider response",
+  },
+};