@pie-players/pie-tool-answer-eliminator 0.3.5 → 0.3.8

package/dist/adapters/adapter-registry.js

@@ -0,0 +1,50 @@
+import { EBSRAdapter } from "./ebsr-adapter.js";
+import { InlineDropdownAdapter } from "./inline-dropdown-adapter.js";
+import { MultipleChoiceAdapter } from "./multiple-choice-adapter.js";
+/**
+ * Registry for choice adapters
+ * Automatically detects which adapter to use for different PIE elements
+ */
+export class AdapterRegistry {
+    adapters;
+    constructor() {
+        // Register adapters in priority order (higher priority first)
+        this.adapters = [
+            new MultipleChoiceAdapter(),
+            new EBSRAdapter(),
+            new InlineDropdownAdapter(),
+        ].sort((a, b) => b.priority - a.priority);
+    }
+    /**
+     * Find the appropriate adapter for an element
+     */
+    findAdapter(element) {
+        return this.adapters.find((adapter) => adapter.canHandle(element)) || null;
+    }
+    /**
+     * Find all choices with their adapters within a root element
+     */
+    findAllChoicesWithAdapters(root) {
+        const results = [];
+        const processedChoices = new Set();
+        // Try each adapter
+        for (const adapter of this.adapters) {
+            const choices = adapter.findChoices(root);
+            for (const choice of choices) {
+                // Avoid duplicates (in case adapters overlap)
+                if (processedChoices.has(choice))
+                    continue;
+                processedChoices.add(choice);
+                results.push({ choice, adapter });
+            }
+        }
+        return results;
+    }
+    /**
+     * Register a custom adapter
+     */
+    registerAdapter(adapter) {
+        this.adapters.push(adapter);
+        this.adapters.sort((a, b) => b.priority - a.priority);
+    }
+}

package/dist/adapters/choice-adapter.js

@@ -0,0 +1 @@
+export {};

package/dist/adapters/ebsr-adapter.js

@@ -0,0 +1,47 @@
+import { MultipleChoiceAdapter } from "./multiple-choice-adapter.js";
+/**
+ * Adapter for EBSR (Evidence-Based Selected Response) elements
+ *
+ * EBSR contains two multiple-choice questions (Part A and Part B),
+ * so we delegate to MultipleChoiceAdapter and prefix IDs with part identifier
+ */
+export class EBSRAdapter {
+    elementType = "ebsr";
+    priority = 95;
+    mcAdapter = new MultipleChoiceAdapter();
+    canHandle(element) {
+        return (element.tagName.toLowerCase() === "ebsr" ||
+            element.querySelector("ebsr-multiple-choice") !== null);
+    }
+    findChoices(root) {
+        // EBSR contains ebsr-multiple-choice elements
+        // Find choices in both Part A and Part B
+        const partA = root.querySelector('ebsr-multiple-choice[id="a"]');
+        const partB = root.querySelector('ebsr-multiple-choice[id="b"]');
+        const choices = [];
+        if (partA)
+            choices.push(...this.mcAdapter.findChoices(partA));
+        if (partB)
+            choices.push(...this.mcAdapter.findChoices(partB));
+        return choices;
+    }
+    // Delegate all other methods to MultipleChoiceAdapter
+    createChoiceRange(choice) {
+        return this.mcAdapter.createChoiceRange(choice);
+    }
+    getChoiceId(choice) {
+        // Prefix with part ID (a or b)
+        const part = choice.closest("ebsr-multiple-choice")?.id || "unknown";
+        const choiceId = this.mcAdapter.getChoiceId(choice);
+        return `${part}-${choiceId}`;
+    }
+    getChoiceLabel(choice) {
+        return this.mcAdapter.getChoiceLabel(choice);
+    }
+    canEliminate(choice) {
+        return this.mcAdapter.canEliminate(choice);
+    }
+    getButtonContainer(choice) {
+        return this.mcAdapter.getButtonContainer(choice);
+    }
+}

package/dist/adapters/inline-dropdown-adapter.js

@@ -0,0 +1,35 @@
+/**
+ * Adapter for PIE inline-dropdown elements
+ *
+ * Works with dropdown menu items (role="option")
+ */
+export class InlineDropdownAdapter {
+    elementType = "inline-dropdown";
+    priority = 90;
+    canHandle(element) {
+        return (element.tagName.toLowerCase() === "inline-dropdown" ||
+            element.querySelector('[role="combobox"]') !== null);
+    }
+    findChoices(root) {
+        // Find dropdown menu items
+        return Array.from(root.querySelectorAll('[role="option"]'));
+    }
+    createChoiceRange(choice) {
+        const range = document.createRange();
+        range.selectNodeContents(choice);
+        return range;
+    }
+    getChoiceId(choice) {
+        return choice.id || choice.getAttribute("data-value") || "";
+    }
+    getChoiceLabel(choice) {
+        return choice.textContent?.trim() || "Unlabeled option";
+    }
+    canEliminate(choice) {
+        // Can't eliminate if already selected
+        return choice.getAttribute("aria-selected") !== "true";
+    }
+    getButtonContainer(choice) {
+        return choice;
+    }
+}

package/dist/adapters/multiple-choice-adapter.js

@@ -0,0 +1,97 @@
+/**
+ * Adapter for PIE multiple-choice elements
+ *
+ * Works with both single-select (radio) and multiple-select (checkbox) modes
+ * Detects PIE's corespring-checkbox and corespring-radio-button classes
+ */
+export class MultipleChoiceAdapter {
+    elementType = "multiple-choice";
+    priority = 100;
+    static CHOICE_HOOK_ATTR = "data-pie-answer-eliminator-choice";
+    static LABEL_HOOK_ATTR = "data-pie-answer-eliminator-label";
+    static ROOT_HOOK_ATTR = "data-pie-answer-eliminator-root";
+    static FEEDBACK_HOOK_ATTR = "data-pie-answer-eliminator-feedback-tick";
+    static CHOICE_SELECTOR = `[${MultipleChoiceAdapter.CHOICE_HOOK_ATTR}="true"], .corespring-checkbox, .corespring-radio-button`;
+    canHandle(element) {
+        return (element.tagName.toLowerCase() === "multiple-choice" ||
+            element.classList.contains("multiple-choice"));
+    }
+    findChoices(root) {
+        root.setAttribute(MultipleChoiceAdapter.ROOT_HOOK_ATTR, "true");
+        const choices = Array.from(root.querySelectorAll(MultipleChoiceAdapter.CHOICE_SELECTOR));
+        for (const choice of choices) {
+            this.annotateChoice(choice);
+        }
+        this.annotateFeedbackTicks(root);
+        return choices;
+    }
+    createChoiceRange(choice) {
+        // Create range covering the label content
+        // Try multiple possible selectors for the label
+        const labelElement = this.resolveLabelElement(choice);
+        if (!labelElement) {
+            return null;
+        }
+        const range = document.createRange();
+        range.selectNodeContents(labelElement);
+        return range;
+    }
+    getChoiceId(choice) {
+        // Get value from input element
+        const input = choice.querySelector('input[type="checkbox"], input[type="radio"]');
+        return (input?.getAttribute("value") ||
+            input?.id ||
+            this.generateFallbackId(choice));
+    }
+    getChoiceLabel(choice) {
+        const label = this.resolveLabelElement(choice);
+        return label?.textContent?.trim() || "Unlabeled choice";
+    }
+    canEliminate(choice) {
+        const input = choice.querySelector('input[type="checkbox"], input[type="radio"]');
+        if (!input)
+            return false;
+        // Can't eliminate if:
+        // 1. Already selected (checked)
+        if (input.getAttribute("aria-checked") === "true")
+            return false;
+        // 2. Disabled
+        if (input.disabled)
+            return false;
+        // 3. In evaluate/view mode (has feedback tick)
+        const root = choice.closest(`[${MultipleChoiceAdapter.ROOT_HOOK_ATTR}="true"]`) ||
+            choice.closest("multiple-choice");
+        if (root?.querySelector(`[${MultipleChoiceAdapter.FEEDBACK_HOOK_ATTR}="true"]`))
+            return false;
+        return true;
+    }
+    getButtonContainer(choice) {
+        // Return the choice-input container
+        return choice;
+    }
+    generateFallbackId(choice) {
+        // Generate stable ID based on choice position
+        const parent = choice.closest(`[${MultipleChoiceAdapter.ROOT_HOOK_ATTR}="true"]`) ||
+            choice.closest("multiple-choice");
+        const choices = parent?.querySelectorAll(`[${MultipleChoiceAdapter.CHOICE_HOOK_ATTR}="true"]`) || [];
+        const index = Array.from(choices).indexOf(choice);
+        return `choice-${index}`;
+    }
+    annotateChoice(choice) {
+        choice.setAttribute(MultipleChoiceAdapter.CHOICE_HOOK_ATTR, "true");
+        const label = this.resolveLabelElement(choice);
+        if (label) {
+            label.setAttribute(MultipleChoiceAdapter.LABEL_HOOK_ATTR, "true");
+        }
+    }
+    resolveLabelElement(choice) {
+        return (choice.querySelector(`[${MultipleChoiceAdapter.LABEL_HOOK_ATTR}="true"]`) ||
+            choice.querySelector("label") ||
+            choice.querySelector("span"));
+    }
+    annotateFeedbackTicks(root) {
+        for (const feedbackTick of root.querySelectorAll(".feedback-tick")) {
+            feedbackTick.setAttribute(MultipleChoiceAdapter.FEEDBACK_HOOK_ATTR, "true");
+        }
+    }
+}

package/dist/index-CGqExkh0.js

@@ -0,0 +1,354 @@
+var v = Object.defineProperty;
+var T = (i, t, e) => t in i ? v(i, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : i[t] = e;
+var d = (i, t, e) => T(i, typeof t != "symbol" ? t + "" : t, e);
+const w = {
+  pie: 3e3,
+  custom: 3e3
+}, f = (i) => i.replace(/\/+$/, ""), m = (i) => i.transportMode === "custom" ? "custom" : i.transportMode === "pie" ? "pie" : i.provider === "custom" ? "custom" : "pie", y = (i, t) => i.endpointMode ? i.endpointMode : t === "custom" ? "rootPost" : "synthesizePath", S = (i, t) => i.endpointValidationMode ? i.endpointValidationMode : t === "custom" ? "none" : "voices", b = (i) => {
+  const t = i.providerOptions || {};
+  if (typeof t.speedRate == "string")
+    return t.speedRate;
+  const e = Number(i.rate ?? 1);
+  return !Number.isFinite(e) || e <= 0.95 ? "slow" : e >= 1.5 ? "fast" : "medium";
+}, A = (i) => {
+  const t = [];
+  let e = 0;
+  const s = i.split(`
+`).map((r) => r.trim()).filter(Boolean);
+  for (const r of s)
+    try {
+      const n = JSON.parse(r), h = typeof n.type == "string" ? n.type : "word", o = typeof n.time == "number" && Number.isFinite(n.time) ? n.time : 0, a = typeof n.value == "string" ? n.value : "", u = typeof n.start == "number" && Number.isFinite(n.start) ? n.start : null, p = typeof n.end == "number" && Number.isFinite(n.end) ? n.end : null, g = u ?? e, c = p ?? g + Math.max(1, a.length || String(n.value || "").length);
+      e = Math.max(c + 1, e), t.push({
+        time: o,
+        type: h,
+        start: g,
+        end: c,
+        value: a
+      });
+    } catch {
+    }
+  return t;
+}, k = {
+  id: "pie",
+  resolveSynthesisUrl: (i) => {
+    const t = y(i, "pie"), e = f(i.apiEndpoint);
+    return t === "rootPost" ? e : `${e}/synthesize`;
+  },
+  buildRequestBody: (i, t) => {
+    const e = t.providerOptions || {}, s = typeof t.engine == "string" ? t.engine : typeof e.engine == "string" ? e.engine : void 0, r = typeof e.sampleRate == "number" && Number.isFinite(e.sampleRate) ? e.sampleRate : void 0, n = e.format === "mp3" || e.format === "ogg" || e.format === "pcm" ? e.format : void 0, h = Array.isArray(e.speechMarkTypes) ? e.speechMarkTypes.filter((o) => o === "word" || o === "sentence" || o === "ssml") : void 0;
+    return {
+      text: i,
+      provider: t.provider || "polly",
+      voice: t.voice,
+      language: t.language,
+      rate: t.rate,
+      engine: s,
+      sampleRate: r,
+      format: n,
+      speechMarkTypes: h,
+      includeSpeechMarks: !0
+    };
+  },
+  parseResponse: async (i) => {
+    const t = await i.json();
+    return {
+      audio: {
+        kind: "base64",
+        data: t.audio,
+        contentType: t.contentType
+      },
+      speechMarks: Array.isArray(t.speechMarks) ? t.speechMarks : []
+    };
+  }
+}, R = {
+  id: "custom",
+  resolveSynthesisUrl: (i) => {
+    const t = y(i, "custom"), e = f(i.apiEndpoint);
+    return t === "synthesizePath" ? `${e}/synthesize` : e;
+  },
+  buildRequestBody: (i, t) => {
+    const e = t.providerOptions || {}, s = typeof e.lang_id == "string" ? e.lang_id : t.language || "en-US", r = typeof e.cache == "boolean" ? e.cache : !0;
+    return {
+      text: i,
+      speedRate: b(t),
+      lang_id: s,
+      cache: r
+    };
+  },
+  parseResponse: async (i, t, e, s) => {
+    const r = await i.json(), n = {};
+    if (t.includeAuthOnAssetFetch)
+      for (const [o, a] of Object.entries(e))
+        o.toLowerCase() === "authorization" && (n[o] = a);
+    let h = [];
+    if (typeof r.word == "string" && r.word.length > 0) {
+      const o = await fetch(r.word, {
+        headers: n,
+        signal: s
+      });
+      if (o.ok) {
+        const a = await o.text();
+        h = A(a);
+      }
+    }
+    return {
+      audio: {
+        kind: "url",
+        url: r.audioContent
+      },
+      speechMarks: h
+    };
+  }
+}, M = {
+  pie: k,
+  custom: R
+};
+class I {
+  constructor(t, e) {
+    d(this, "config");
+    d(this, "adapter");
+    d(this, "currentAudio", null);
+    d(this, "pausedState", !1);
+    d(this, "wordTimings", []);
+    d(this, "highlightInterval", null);
+    d(this, "intentionallyStopped", !1);
+    d(this, "activeSynthesisController", null);
+    d(this, "synthesisRunId", 0);
+    d(this, "onWordBoundary");
+    this.config = t, this.adapter = e;
+  }
+  async speak(t) {
+    this.stop(), this.intentionallyStopped = !1;
+    const e = ++this.synthesisRunId, s = new AbortController();
+    this.activeSynthesisController = s;
+    const { audioUrl: r, wordTimings: n } = await this.synthesizeSpeech(t, s.signal, e);
+    if (e !== this.synthesisRunId) {
+      URL.revokeObjectURL(r);
+      return;
+    }
+    const h = this.config.rate || 1;
+    return this.wordTimings = n.map((o) => ({
+      ...o,
+      time: o.time / h
+    })), new Promise((o, a) => {
+      const u = new Audio(r);
+      this.currentAudio = u, this.config.rate && (u.playbackRate = Math.max(0.25, Math.min(4, this.config.rate))), this.config.volume !== void 0 && (u.volume = Math.max(0, Math.min(1, this.config.volume))), u.onplay = () => {
+        this.pausedState = !1, this.onWordBoundary && this.wordTimings.length > 0 && this.startWordHighlighting();
+      }, u.onended = () => {
+        this.stopWordHighlighting(), URL.revokeObjectURL(r), this.currentAudio = null, this.wordTimings = [], o();
+      }, u.onerror = (p) => {
+        this.stopWordHighlighting(), URL.revokeObjectURL(r), this.currentAudio = null, this.wordTimings = [], this.intentionallyStopped ? o() : a(new Error("Failed to play audio from server"));
+      }, u.onpause = () => {
+        this.stopWordHighlighting(), this.pausedState = !0;
+      }, u.play().catch(a);
+    });
+  }
+  /**
+   * Call server API to synthesize speech
+   */
+  async synthesizeSpeech(t, e, s) {
+    const r = {
+      "Content-Type": "application/json",
+      ...this.config.headers
+    };
+    this.config.authToken && (r.Authorization = `Bearer ${this.config.authToken}`);
+    const n = this.adapter.resolveSynthesisUrl(this.config), h = this.adapter.buildRequestBody(t, this.config), o = await fetch(n, {
+      method: "POST",
+      headers: r,
+      body: JSON.stringify(h),
+      signal: e
+    });
+    if (!o.ok) {
+      const c = await o.json().catch(() => ({})), l = c.message || c.error?.message || `Server returned ${o.status}`;
+      throw new Error(l);
+    }
+    const a = await this.adapter.parseResponse(o, this.config, r, e);
+    if (s !== this.synthesisRunId || e.aborted)
+      throw new Error("Synthesis superseded by a newer request");
+    let u;
+    if (a.audio.kind === "base64")
+      u = this.base64ToBlob(a.audio.data, a.audio.contentType);
+    else {
+      const c = {};
+      this.config.includeAuthOnAssetFetch && this.config.authToken && (c.Authorization = `Bearer ${this.config.authToken}`);
+      const l = await fetch(a.audio.url, {
+        headers: c,
+        signal: e
+      });
+      if (!l.ok)
+        throw new Error(`Failed to download synthesized audio (${l.status})`);
+      u = await l.blob();
+    }
+    const p = URL.createObjectURL(u), g = this.parseSpeechMarks(a.speechMarks);
+    return { audioUrl: p, wordTimings: g };
+  }
+  /**
+   * Convert base64 to Blob
+   */
+  base64ToBlob(t, e) {
+    const s = atob(t), r = new Array(s.length);
+    for (let h = 0; h < s.length; h++)
+      r[h] = s.charCodeAt(h);
+    const n = new Uint8Array(r);
+    return new Blob([n], { type: e });
+  }
+  /**
+   * Parse speech marks into word timings
+   */
+  parseSpeechMarks(t) {
+    return t.filter((e) => e.type === "word").map((e, s) => ({
+      time: e.time,
+      wordIndex: s,
+      charIndex: e.start,
+      length: e.end - e.start
+    }));
+  }
+  /**
+   * Start word highlighting synchronized with audio playback
+   */
+  startWordHighlighting() {
+    if (this.stopWordHighlighting(), !this.currentAudio || !this.onWordBoundary || this.wordTimings.length === 0) {
+      console.log("[ServerTTSProvider] Cannot start highlighting:", {
+        hasAudio: !!this.currentAudio,
+        hasCallback: !!this.onWordBoundary,
+        wordTimingsCount: this.wordTimings.length
+      });
+      return;
+    }
+    console.log("[ServerTTSProvider] Starting word highlighting with", this.wordTimings.length, "word timings"), console.log("[ServerTTSProvider] Playback rate:", this.currentAudio.playbackRate), console.log("[ServerTTSProvider] First 3 timings:", this.wordTimings.slice(0, 3));
+    let t = -1;
+    this.highlightInterval = window.setInterval(() => {
+      if (!this.currentAudio) {
+        this.stopWordHighlighting();
+        return;
+      }
+      const e = this.currentAudio.currentTime * 1e3;
+      for (let s = 0; s < this.wordTimings.length; s++) {
+        const r = this.wordTimings[s];
+        if (e >= r.time && s > t) {
+          this.onWordBoundary && (console.log("[ServerTTSProvider] Highlighting word at charIndex:", r.charIndex, "length:", r.length, "time:", r.time, "currentTime:", e), this.onWordBoundary("", r.charIndex, r.length)), t = s;
+          break;
+        }
+      }
+    }, 50);
+  }
+  /**
+   * Stop word highlighting
+   */
+  stopWordHighlighting() {
+    this.highlightInterval !== null && (clearInterval(this.highlightInterval), this.highlightInterval = null);
+  }
+  pause() {
+    this.currentAudio && !this.pausedState && (this.currentAudio.pause(), this.stopWordHighlighting(), this.pausedState = !0);
+  }
+  resume() {
+    this.currentAudio && this.pausedState && (this.currentAudio.play(), this.pausedState = !1, this.onWordBoundary && this.wordTimings.length > 0 && this.startWordHighlighting());
+  }
+  stop() {
+    this.synthesisRunId += 1, this.activeSynthesisController && (this.activeSynthesisController.abort(), this.activeSynthesisController = null), this.stopWordHighlighting(), this.currentAudio && (this.intentionallyStopped = !0, this.currentAudio.pause(), this.currentAudio.src && URL.revokeObjectURL(this.currentAudio.src), this.currentAudio.src = "", this.currentAudio = null), this.pausedState = !1, this.wordTimings = [];
+  }
+  isPlaying() {
+    return this.currentAudio !== null && !this.pausedState;
+  }
+  isPaused() {
+    return this.pausedState;
+  }
+  /**
+   * Update settings dynamically (rate, pitch, voice)
+   * Note: Voice changes require resynthesis, so voice updates are stored but
+   * take effect on the next speak() call. Rate can be applied to current playback.
+   */
+  updateSettings(t) {
+    t.rate !== void 0 && (this.config.rate = t.rate, this.currentAudio && (this.currentAudio.playbackRate = Math.max(0.25, Math.min(4, t.rate)))), t.pitch !== void 0 && (this.config.pitch = t.pitch), t.voice !== void 0 && (this.config.voice = t.voice);
+  }
+}
+class B {
+  constructor() {
+    d(this, "providerId", "server-tts");
+    d(this, "providerName", "Server TTS");
+    d(this, "version", "1.0.0");
+    d(this, "config", null);
+    d(this, "adapter", null);
+  }
+  /**
+   * Initialize the server TTS provider.
+   *
+   * This is designed to be fast by default (no API calls).
+   * Set validateEndpoint: true in config to test API availability during initialization.
+   *
+   * @performance Default: <10ms, With validation: 100-500ms
+   */
+  async initialize(t) {
+    const e = t;
+    if (!e.apiEndpoint)
+      throw new Error("apiEndpoint is required for ServerTTSProvider");
+    this.config = e;
+    const s = m(e);
+    if (this.adapter = M[s], e.validateEndpoint && !await this.testAPIAvailability())
+      throw new Error(`Server TTS API not available at ${e.apiEndpoint}`);
+    return new I(e, this.adapter);
+  }
+  /**
+   * Test if API endpoint is available (with timeout).
+   *
+   * @performance 100-500ms depending on network
+   */
+  async testAPIAvailability() {
+    if (!this.config || !this.adapter)
+      return !1;
+    try {
+      const t = { ...this.config.headers };
+      this.config.authToken && (t.Authorization = `Bearer ${this.config.authToken}`);
+      const e = new AbortController(), s = setTimeout(() => e.abort(), 5e3), r = S(this.config, this.adapter.id);
+      if (r === "none")
+        return clearTimeout(s), !0;
+      const n = f(this.config.apiEndpoint), h = r === "voices" ? `${n}/voices` : this.adapter.resolveSynthesisUrl(this.config), o = r === "voices" ? "GET" : "OPTIONS";
+      try {
+        const a = await fetch(h, {
+          method: o,
+          headers: t,
+          signal: e.signal
+        });
+        return clearTimeout(s), a.ok || a.status === 405;
+      } catch {
+        return clearTimeout(s), !1;
+      }
+    } catch {
+      return !1;
+    }
+  }
+  supportsFeature(t) {
+    switch (t) {
+      case "pause":
+      case "resume":
+      case "wordBoundary":
+      case "voiceSelection":
+      case "rateControl":
+        return !0;
+      case "pitchControl":
+        return !1;
+      default:
+        return !1;
+    }
+  }
+  getCapabilities() {
+    const t = this.config ? m(this.config) : "pie";
+    return {
+      supportsPause: !0,
+      supportsResume: !0,
+      supportsWordBoundary: !0,
+      // ✅ Via speech marks from server
+      supportsVoiceSelection: !0,
+      supportsRateControl: !0,
+      supportsPitchControl: !1,
+      // Depends on server provider
+      maxTextLength: w[t]
+    };
+  }
+  destroy() {
+    this.config = null, this.adapter = null;
+  }
+}
+export {
+  B as ServerTTSProvider
+};