@pie-players/pie-tool-answer-eliminator 0.3.59 → 0.3.60

package/dist/adapters/choice-adapter.d.ts

@@ -30,11 +30,24 @@ export interface ChoiceAdapter {
      * Get human-readable label (for screen readers)
      */
     getChoiceLabel(choice: HTMLElement): string;
+    /**
+     * Check if the choice is currently selected by the student
+     * (radio/checkbox checked). Optional: adapters that support hiding the
+     * eliminate control on a selected choice implement this.
+     */
+    isSelected?(choice: HTMLElement): boolean;
     /**
      * Check if choice can be eliminated
      * (not already selected, not in evaluate mode, etc.)
      */
     canEliminate(choice: HTMLElement): boolean;
+    /**
+     * Enable or disable the student's ability to select this choice.
+     * A struck-through choice is made non-selectable (grayed out) so a
+     * student cannot pick an answer they have eliminated. Optional: only
+     * adapters backed by a real input (radio/checkbox) implement this.
+     */
+    setSelectable?(choice: HTMLElement, selectable: boolean): void;
     /**
      * Get the container element to attach elimination button
      */

package/dist/adapters/ebsr-adapter.d.ts

@@ -14,6 +14,8 @@ export declare class EBSRAdapter implements ChoiceAdapter {
     createChoiceRange(choice: HTMLElement): Range | null;
     getChoiceId(choice: HTMLElement): string;
     getChoiceLabel(choice: HTMLElement): string;
+    isSelected(choice: HTMLElement): boolean;
     canEliminate(choice: HTMLElement): boolean;
+    setSelectable(choice: HTMLElement, selectable: boolean): void;
     getButtonContainer(choice: HTMLElement): HTMLElement | null;
 }

package/dist/adapters/ebsr-adapter.js

@@ -59,9 +59,15 @@ export class EBSRAdapter {
     getChoiceLabel(choice) {
         return this.mcAdapter.getChoiceLabel(choice);
     }
+    isSelected(choice) {
+        return this.mcAdapter.isSelected(choice);
+    }
     canEliminate(choice) {
         return this.mcAdapter.canEliminate(choice);
     }
+    setSelectable(choice, selectable) {
+        this.mcAdapter.setSelectable(choice, selectable);
+    }
     getButtonContainer(choice) {
         return this.mcAdapter.getButtonContainer(choice);
     }

package/dist/adapters/multiple-choice-adapter.d.ts

@@ -13,12 +13,16 @@ export declare class MultipleChoiceAdapter implements ChoiceAdapter {
     private static readonly ROOT_HOOK_ATTR;
     private static readonly FEEDBACK_HOOK_ATTR;
     private static readonly CHOICE_SELECTOR;
+    private static readonly MUI_BUTTON_SELECTOR;
+    private static readonly MUI_DISABLED_CLASS;
     canHandle(element: HTMLElement): boolean;
     findChoices(root: HTMLElement): HTMLElement[];
     createChoiceRange(choice: HTMLElement): Range | null;
     getChoiceId(choice: HTMLElement): string;
     getChoiceLabel(choice: HTMLElement): string;
+    isSelected(choice: HTMLElement): boolean;
     canEliminate(choice: HTMLElement): boolean;
+    setSelectable(choice: HTMLElement, selectable: boolean): void;
     getButtonContainer(choice: HTMLElement): HTMLElement | null;
     private generateFallbackId;
     private annotateChoice;

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

@@ -12,6 +12,11 @@ export class MultipleChoiceAdapter {
     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`;
+    // Material-UI radio/checkbox controls gray out via the `Mui-disabled`
+    // class on the button root; toggling the native `disabled` alone doesn't
+    // restyle them.
+    static MUI_BUTTON_SELECTOR = ".MuiButtonBase-root, .MuiRadio-root, .MuiCheckbox-root";
+    static MUI_DISABLED_CLASS = "Mui-disabled";
     canHandle(element) {
         return (element.tagName.toLowerCase() === "multiple-choice" ||
             element.classList.contains("multiple-choice"));
@@ -47,13 +52,21 @@ export class MultipleChoiceAdapter {
         const label = this.resolveLabelElement(choice);
         return label?.textContent?.trim() || "Unlabeled choice";
     }
+    isSelected(choice) {
+        const input = choice.querySelector('input[type="checkbox"], input[type="radio"]');
+        if (!input)
+            return false;
+        // Prefer the live `checked` property (works for radio and checkbox);
+        // fall back to the aria-checked attribute for custom/ARIA widgets.
+        return input.checked || input.getAttribute("aria-checked") === "true";
+    }
     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")
+        if (this.isSelected(choice))
             return false;
         // 2. Disabled
         if (input.disabled)
@@ -65,6 +78,26 @@ export class MultipleChoiceAdapter {
             return false;
         return true;
     }
+    setSelectable(choice, selectable) {
+        const input = choice.querySelector('input[type="checkbox"], input[type="radio"]');
+        if (!input)
+            return;
+        // Native `disabled` makes the control non-selectable and grays it out;
+        // aria-disabled keeps the state exposed to assistive tech.
+        input.disabled = !selectable;
+        if (selectable) {
+            input.removeAttribute("aria-disabled");
+        }
+        else {
+            input.setAttribute("aria-disabled", "true");
+        }
+        // If the input lives inside a Material-UI control, mirror MUI's own
+        // disabled styling by toggling `Mui-disabled` on the button root.
+        const muiButton = input.closest(MultipleChoiceAdapter.MUI_BUTTON_SELECTOR);
+        if (muiButton) {
+            muiButton.classList.toggle(MultipleChoiceAdapter.MUI_DISABLED_CLASS, !selectable);
+        }
+    }
     getButtonContainer(choice) {
         // Return the choice-input container
         return choice;

package/dist/answer-eliminator-core.d.ts

@@ -14,6 +14,11 @@ export declare class AnswerEliminatorCore {
     private choiceAdapters;
     private buttonAlignment;
     private shouldRestoreState;
+    private active;
+    private questionRoot;
+    private selectionChangeHandler;
+    private selectionObserver;
+    private selectionRefreshFrame;
     private storeIntegration;
     constructor(strategyType?: "strikethrough" | "mask" | "gray", buttonAlignment?: "left" | "right" | "inline");
     private createStrategy;
@@ -63,6 +68,56 @@ export declare class AnswerEliminatorCore {
      * Restore state from ElementToolStateStore
      */
     private restoreState;
+    /**
+     * Re-enable selection for every currently-tracked struck choice.
+     * Must run before the element/adapter maps are cleared, otherwise the
+     * inputs would be left disabled after the tool is turned off.
+     */
+    private restoreAllSelectable;
+    /**
+     * Show or hide a choice's strikethrough button, preserving the visible
+     * `display` value chosen by the alignment configuration.
+     */
+    private setButtonHidden;
+    /**
+     * The single rule for whether a choice's eliminate button should be hidden:
+     * - A struck-through choice always keeps its button (so it can be undone),
+     *   even when the feature is toggled off.
+     * - When the feature is off, a non-struck choice hides its button.
+     * - When the feature is on, a non-struck choice hides its button only while
+     *   it is selected (a selected answer must not be eliminable).
+     */
+    private shouldHideButton;
+    /**
+     * Re-apply the visibility rule to a single choice's button.
+     */
+    private updateButtonVisibility;
+    /**
+     * Re-evaluate button visibility for every tracked choice. Driven by live
+     * selection changes and by toggling the feature on/off.
+     */
+    private refreshSelectionState;
+    /**
+     * Schedule a selection refresh on the next frame. Deliberately does NOT
+     * cancel-and-reschedule: a burst of mutations coalesces into one pending
+     * refresh, and mutations in later frames each get their own refresh, so a
+     * multi-render commit settles instead of being starved by continuous
+     * churn (e.g. ripple animations).
+     */
+    private scheduleSelectionRefresh;
+    /**
+     * Track live selection changes on the question root so button visibility
+     * follows the selection even when no full re-render occurs.
+     *
+     * Controlled widgets (PIE multiple-choice) update the input's `checked`
+     * *property* on their own render — invisible to a MutationObserver and
+     * later than the native `change` event — so we observe every DOM change
+     * the widget makes (childList + attributes) and re-read on the next frame,
+     * by which point the property has settled. Mutations caused by our own
+     * buttons are ignored so the refresh can't loop.
+     */
+    private attachSelectionListener;
+    private detachSelectionListener;
     /**
      * Cleanup buttons from previous element
      */
@@ -80,9 +135,13 @@ export declare class AnswerEliminatorCore {
      */
     disableStateRestoration(): void;
     /**
-     * Cleanup when tool is turned off (but don't destroy strategy)
-     * Hides elimination buttons AND clears all visual eliminations
-     * Note: State is preserved in localStorage for when tool is turned back on
+     * Turn the feature off at the question level.
+     *
+     * Struck-through choices stay struck: their strikethrough, their disabled
+     * (non-selectable) input, and a visible/usable eliminate button all remain
+     * so the student can still undo them. Only the eliminate buttons for
+     * choices that are NOT struck through are hidden. Nothing is destroyed, so
+     * toggling the feature back on simply re-reveals the hidden buttons.
      */
     cleanup(): void;
     /**