@pie-players/pie-assessment-toolkit 0.2.7 → 0.2.9

package/dist/player/AssessmentPlayer.js

@@ -1,974 +0,0 @@
-/**
- * AssessmentPlayer
- *
- * Reference implementation showing how to wire PIE Assessment Toolkit services
- * together for a complete assessment player.
- *
- * This implementation provides:
- * - Navigation through assessment items (linear or nonlinear)
- * - QTI navigation model (testParts/sections/questionRefs)
- * - Section awareness and rubric block support
- * - Event-driven architecture using TypedEventBus
- * - Session state management
- * - TTS integration via TTSService
- * - Theme support via ThemeProvider
- * - Tool coordination (optional)
- *
- * Products can use this as-is, extend it, or use it as a pattern for their own implementation.
- */
-import { createNewTestSession, createTestSessionIdentifier, getBrowserLocalStorage, loadTestSession, saveTestSession, setCurrentPosition, upsertItemSessionFromPieSessionChange, upsertVisitedItem, } from "../attempt/TestSession.js";
-import { HighlightCoordinator, I18nService, ThemeProvider, ToolCoordinator, TTSService, TypedEventBus, } from "../index.js";
-import { AssessmentAuthoringService } from "../services/AssessmentAuthoringService.js";
-import { ContextVariableStore } from "../services/ContextVariableStore.js";
-import { PNPToolResolver, } from "../services/PNPToolResolver.js";
-import { createDefaultToolRegistry } from "../services/createDefaultToolRegistry.js";
-import { BrowserTTSProvider } from "../services/tts/browser-provider.js";
-import { DesmosCalculatorProvider, TICalculatorProvider, } from "../tools/client.js";
-import { buildNavigationStructure, detectAssessmentFormat, getAllQuestionRefs, } from "./qti-navigation.js";
-export class AssessmentPlayer {
-    // Toolkit services
-    eventBus;
-    ttsService;
-    themeProvider = null;
-    toolCoordinator;
-    highlightCoordinator = null;
-    i18nService;
-    desmosProvider;
-    tiProvider;
-    authoringService = null;
-    // Configuration
-    config;
-    // PNP-based tool resolution
-    pnpResolver;
-    currentTools = [];
-    // QTI 3.0 Context Variables
-    contextStore;
-    // Assessment format and navigation
-    assessmentFormat;
-    questionRefs;
-    navigationStructure;
-    navigationMode;
-    // State
-    currentItemIndex = -1;
-    currentItem = null;
-    isLoadingItem = false;
-    sessionState = { id: "", data: [] };
-    // QTI-like attempt (client-only)
-    attemptStorage = null;
-    testSession = null;
-    // TTS state
-    ttsInitialized = false;
-    ttsSpeaking = false;
-    ttsPaused = false;
-    ttsRootElement = null;
-    // State change listeners
-    navigationListeners = new Set();
-    itemListeners = new Set();
-    loadingListeners = new Set();
-    sessionListeners = new Set();
-    ttsStateListeners = new Set();
-    constructor(config) {
-        this.config = config;
-        // Detect assessment format and build navigation structure
-        this.assessmentFormat = detectAssessmentFormat(config.assessment);
-        this.questionRefs = getAllQuestionRefs(config.assessment);
-        this.navigationStructure = buildNavigationStructure(config.assessment);
-        // Initialize/load QTI-like TestSession (client-only)
-        this.attemptStorage = config.attemptStorage || getBrowserLocalStorage();
-        this.initializeOrLoadTestSession();
-        // Determine navigation mode
-        // Priority: explicit config > QTI testPart setting > default to nonlinear
-        if (config.navigationMode) {
-            this.navigationMode = config.navigationMode;
-        }
-        else {
-            const qtiAssessment = config.assessment;
-            this.navigationMode =
-                qtiAssessment.testParts?.[0]?.navigationMode || "nonlinear";
-        }
-        // Initialize toolkit services (with dependency injection support)
-        this.eventBus =
-            config.services?.eventBus ?? new TypedEventBus();
-        this.ttsService = config.services?.ttsService ?? new TTSService();
-        this.toolCoordinator =
-            config.services?.toolCoordinator ?? new ToolCoordinator();
-        this.i18nService = config.services?.i18nService ?? new I18nService();
-        this.desmosProvider =
-            config.services?.desmosProvider ?? new DesmosCalculatorProvider();
-        this.tiProvider = config.services?.tiProvider ?? new TICalculatorProvider();
-        // Initialize PNP resolver with default tool registry
-        const toolRegistry = createDefaultToolRegistry(config.toolRegistryOptions);
-        this.pnpResolver = new PNPToolResolver(toolRegistry);
-        this.initializeTools();
-        this.applyAssessmentTheme();
-        this.autoActivateTools();
-        // Initialize context variable store from QTI 3.0 contextDeclarations
-        this.contextStore = new ContextVariableStore(config.assessment.contextDeclarations);
-        this.restoreContextVariables();
-        // Initialize highlight coordinator
-        // Use injected coordinator, or create new one if supported
-        if (config.services?.highlightCoordinator) {
-            this.highlightCoordinator = config.services.highlightCoordinator;
-        }
-        else {
-            const tempCoordinator = new HighlightCoordinator();
-            if (tempCoordinator.isSupported()) {
-                this.highlightCoordinator = tempCoordinator;
-            }
-        }
-        // Connect highlight coordinator to TTS service for word highlighting
-        if (this.highlightCoordinator) {
-            this.ttsService.setHighlightCoordinator(this.highlightCoordinator);
-        }
-        // Initialize authoring service if in author mode
-        if (config.mode === "author" && config.authoringCallbacks) {
-            this.authoringService = new AssessmentAuthoringService(config.assessment, config.authoringCallbacks);
-        }
-        // Set up event listeners
-        this.setupEventListeners();
-        // Initialize TTS if enabled via PNP
-        if (this.isToolEnabled("textToSpeech")) {
-            this.initializeTTS();
-        }
-    }
-    initializeOrLoadTestSession() {
-        if (!this.attemptStorage) {
-            return;
-        }
-        const assessmentId = this.config.assessment?.id ||
-            this.config.assessment?._id;
-        if (!assessmentId) {
-            return;
-        }
-        const { testSessionIdentifier, seed } = createTestSessionIdentifier({
-            assessmentId,
-            assignmentId: this.config.assignmentId,
-            userId: this.config.userId,
-            storage: this.attemptStorage,
-        });
-        const existing = loadTestSession(this.attemptStorage, testSessionIdentifier);
-        const currentItemIdentifiers = this.questionRefs.map((q) => q.identifier);
-        if (existing) {
-            // Keep existing runtime state, but make sure realized order matches current definition
-            // (for now we don't implement selection/shuffle, so realization is the current flat order).
-            const needsUpdate = !existing.realization?.itemIdentifiers ||
-                existing.realization.itemIdentifiers.length !==
-                    currentItemIdentifiers.length;
-            this.testSession = needsUpdate
-                ? {
-                    ...existing,
-                    realization: {
-                        ...existing.realization,
-                        seed: existing.realization?.seed || seed,
-                        itemIdentifiers: currentItemIdentifiers,
-                    },
-                }
-                : existing;
-        }
-        else {
-            this.testSession = createNewTestSession({
-                testSessionIdentifier,
-                assessmentId,
-                seed,
-                itemIdentifiers: currentItemIdentifiers,
-            });
-        }
-        // Persist immediately to ensure updatedAt/version exists
-        if (this.testSession) {
-            saveTestSession(this.attemptStorage, this.testSession);
-        }
-    }
-    /**
-     * Set up internal event listeners
-     */
-    setupEventListeners() {
-        // Listen to player events
-        this.eventBus.on("player:session-changed", async (e) => {
-            const { id, ...sessionData } = e.detail;
-            if (id) {
-                const existingEntry = this.sessionState.data.find((d) => d.id === id);
-                if (existingEntry) {
-                    Object.assign(existingEntry, sessionData);
-                }
-                else {
-                    this.sessionState.data.push({ id, ...sessionData });
-                }
-            }
-            // Notify session listeners
-            this.notifySessionListeners();
-            // Call product callback
-            if (this.config.onSessionChanged) {
-                await this.config.onSessionChanged(this.sessionState);
-            }
-        });
-        this.eventBus.on("nav:item-changed", async (e) => {
-            if (this.config.onItemChanged) {
-                await this.config.onItemChanged(e.detail.currentItemId, e.detail.itemIndex);
-            }
-        });
-        this.eventBus.on("nav:next-requested", async (e) => {
-            await this.navigateNext();
-        });
-        this.eventBus.on("nav:previous-requested", async (e) => {
-            await this.navigatePrevious();
-        });
-    }
-    /**
-     * Initialize TTS service
-     */
-    async initializeTTS() {
-        try {
-            // Initialize TTS with browser provider
-            const provider = new BrowserTTSProvider();
-            await this.ttsService.initialize(provider, {
-                organizationId: this.config.organizationId || undefined,
-            });
-            this.ttsInitialized = true;
-            // Listen to TTS state changes
-            this.ttsService.onStateChange("reference-player", (state) => {
-                this.ttsSpeaking = state === "playing";
-                this.ttsPaused = state === "paused";
-                this.notifyTTSStateListeners();
-            });
-        }
-        catch (error) {
-            console.error("[AssessmentPlayer] Failed to initialize TTS:", error);
-        }
-    }
-    /**
-     * Get event bus for external listeners
-     */
-    getEventBus() {
-        return this.eventBus;
-    }
-    /**
-     * Get current navigation state
-     */
-    getNavigationState() {
-        const totalItems = this.questionRefs.length;
-        // Find current section if we have navigation structure
-        let currentSection;
-        let totalSections = 0;
-        if (this.navigationStructure.length > 0 && this.currentItemIndex >= 0) {
-            // Count sections (filter out non-section nodes like testParts)
-            const sections = this.flattenSections(this.navigationStructure);
-            totalSections = sections.length;
-            // Find which section contains the current question
-            if (totalSections > 0) {
-                const currentQuestion = this.questionRefs[this.currentItemIndex];
-                if (currentQuestion) {
-                    for (let i = 0; i < sections.length; i++) {
-                        const section = sections[i];
-                        // Check if this section contains the current question
-                        if (this.sectionContainsQuestion(section, currentQuestion.identifier)) {
-                            currentSection = {
-                                id: section.id,
-                                title: section.title,
-                                index: i,
-                            };
-                            break;
-                        }
-                    }
-                }
-            }
-        }
-        return {
-            currentIndex: this.currentItemIndex,
-            totalItems,
-            canNext: this.currentItemIndex < totalItems - 1,
-            canPrevious: this.currentItemIndex > 0,
-            isLoading: this.isLoadingItem,
-            currentSection,
-            totalSections: totalSections > 0 ? totalSections : undefined,
-        };
-    }
-    /**
-     * Flatten navigation structure to get all sections
-     */
-    flattenSections(nodes) {
-        const sections = [];
-        for (const node of nodes) {
-            if (node.type === "section") {
-                sections.push(node);
-            }
-            if (node.children) {
-                sections.push(...this.flattenSections(node.children));
-            }
-        }
-        return sections;
-    }
-    /**
-     * Check if a section contains a specific question
-     */
-    sectionContainsQuestion(section, questionIdentifier) {
-        if (!section.children) {
-            return false;
-        }
-        for (const child of section.children) {
-            if (child.type === "question" &&
-                child.identifier === questionIdentifier) {
-                return true;
-            }
-            // Check nested sections
-            if (child.type === "section" &&
-                this.sectionContainsQuestion(child, questionIdentifier)) {
-                return true;
-            }
-        }
-        return false;
-    }
-    /**
-     * Get current item
-     */
-    getCurrentItem() {
-        return this.currentItem;
-    }
-    /**
-     * Get current item config
-     */
-    getCurrentItemConfig() {
-        return this.currentItem?.config;
-    }
-    /**
-     * Get session state
-     */
-    getSessionState() {
-        return this.sessionState;
-    }
-    /**
-     * Get the client-side QTI-like TestSession (attempt) state.
-     */
-    getTestSession() {
-        return this.testSession;
-    }
-    /**
-     * Get player environment
-     */
-    getEnv() {
-        return {
-            mode: this.config.mode || "gather",
-        };
-    }
-    /**
-     * Get ToolCoordinator for tool management
-     */
-    getToolCoordinator() {
-        return this.toolCoordinator;
-    }
-    /**
-     * Get HighlightCoordinator for annotation/TTS highlighting
-     */
-    getHighlightCoordinator() {
-        return this.highlightCoordinator;
-    }
-    /**
-     * Get TTSService for text-to-speech functionality
-     */
-    getTTSService() {
-        return this.ttsService;
-    }
-    /**
-     * Get ThemeProvider for accessibility theming
-     */
-    getThemeProvider() {
-        return this.themeProvider;
-    }
-    /**
-     * Get I18nService for internationalization
-     */
-    getI18nService() {
-        return this.i18nService;
-    }
-    /**
-     * Get Desmos calculator provider
-     */
-    getDesmosProvider() {
-        return this.desmosProvider;
-    }
-    /**
-     * Get TI calculator provider
-     */
-    getTIProvider() {
-        return this.tiProvider;
-    }
-    /**
-     * Navigate to specific item index
-     */
-    async navigate(index) {
-        if (index < 0 || index >= this.questionRefs.length) {
-            return;
-        }
-        // Stop TTS when navigating
-        if (this.ttsSpeaking) {
-            this.stopTTS();
-        }
-        this.isLoadingItem = true;
-        this.notifyLoadingListeners(true);
-        const previousItemId = this.currentItem?.id || null;
-        this.currentItemIndex = index;
-        const questionRef = this.questionRefs[index];
-        // Persist attempt navigation immediately (even if item fetch fails)
-        this.persistAttemptNavigation(questionRef?.identifier, index);
-        if (questionRef && questionRef.itemVId) {
-            try {
-                this.currentItem = await this.config.loadItem(questionRef.itemVId, {
-                    organizationId: this.config.organizationId ?? null,
-                });
-                // Emit item-changed event - use questionRef.itemVId for bookmarkability
-                this.eventBus.emit("nav:item-changed", {
-                    previousItemId,
-                    currentItemId: questionRef.itemVId, // Use itemVId from assessment question for URL bookmarking
-                    itemIndex: index,
-                    totalItems: this.questionRefs.length,
-                    timestamp: Date.now(),
-                });
-                // Notify item listeners
-                this.notifyItemListeners();
-                this.notifyNavigationListeners();
-            }
-            catch (error) {
-                console.error("[AssessmentPlayer] Error fetching item:", error);
-                this.currentItem = null;
-            }
-        }
-        else {
-            this.currentItem = null;
-        }
-        this.isLoadingItem = false;
-        this.notifyLoadingListeners(false);
-        this.notifyItemListeners();
-        this.notifyNavigationListeners();
-    }
-    /**
-     * Navigate to next item
-     */
-    async navigateNext() {
-        if (this.currentItemIndex < this.questionRefs.length - 1) {
-            // In linear mode, prevent skipping items
-            // (No additional restrictions needed here - just move to next)
-            await this.navigate(this.currentItemIndex + 1);
-        }
-    }
-    /**
-     * Navigate to previous item
-     */
-    async navigatePrevious() {
-        // In linear mode, allow going back to previous items
-        if (this.currentItemIndex > 0) {
-            await this.navigate(this.currentItemIndex - 1);
-        }
-    }
-    /**
-     * Start assessment (navigate to first item)
-     */
-    async start() {
-        const startIndexRaw = this.testSession?.navigationState?.currentItemIndex ?? 0;
-        const startIndex = startIndexRaw >= 0 ? startIndexRaw : 0;
-        await this.navigate(startIndex);
-        this.eventBus.emit("assessment:started", {
-            assessmentId: this.config.assessment.id || "",
-            studentId: "current-student", // TODO: Get from auth context
-            timestamp: Date.now(),
-        });
-    }
-    /**
-     * TTS: Read current question
-     */
-    async readQuestion(rootElement) {
-        if (!this.ttsInitialized)
-            return;
-        this.ttsRootElement = rootElement;
-        // Get the question prompt
-        const promptElement = rootElement.querySelector(".pie-question-prompt, [data-pie-prompt], .prompt");
-        if (!promptElement)
-            return;
-        // Extract text (using same extraction as existing implementation)
-        const text = this.extractText(promptElement);
-        if (!text.trim())
-            return;
-        try {
-            this.ttsSpeaking = true;
-            this.ttsPaused = false;
-            this.notifyTTSStateListeners();
-            // Set root for highlighting
-            this.ttsService.setRootElement?.(promptElement);
-            await this.ttsService.speak(text);
-            this.ttsSpeaking = false;
-            this.ttsPaused = false;
-            this.notifyTTSStateListeners();
-        }
-        catch (error) {
-            console.error("[AssessmentPlayer] TTS error:", error);
-            this.ttsSpeaking = false;
-            this.ttsPaused = false;
-            this.notifyTTSStateListeners();
-        }
-    }
-    /**
-     * TTS: Toggle play/pause
-     */
-    toggleTTS(rootElement) {
-        if (!this.ttsInitialized)
-            return;
-        if (this.ttsSpeaking) {
-            if (this.ttsPaused) {
-                this.ttsService.resume();
-            }
-            else {
-                this.ttsService.pause();
-            }
-        }
-        else if (rootElement) {
-            this.readQuestion(rootElement);
-        }
-    }
-    /**
-     * TTS: Stop reading
-     */
-    stopTTS() {
-        if (this.ttsSpeaking) {
-            this.ttsService.stop();
-            this.ttsSpeaking = false;
-            this.ttsPaused = false;
-            this.notifyTTSStateListeners();
-        }
-    }
-    /**
-     * TTS: Get state
-     */
-    getTTSState() {
-        return {
-            initialized: this.ttsInitialized,
-            speaking: this.ttsSpeaking,
-            paused: this.ttsPaused,
-        };
-    }
-    /**
-     * Apply theme
-     */
-    applyTheme(theme) {
-        if (!this.themeProvider) {
-            this.themeProvider = new ThemeProvider();
-        }
-        this.themeProvider.applyTheme(theme);
-    }
-    /**
-     * Handle PIE player session-changed event
-     * Call this from your component when you receive session-changed from pie-iife-player
-     */
-    handlePieSessionChanged(detail) {
-        this.eventBus.emit("player:session-changed", {
-            itemId: this.currentItem?.id || "",
-            component: detail.component || "",
-            complete: detail.complete || false,
-            session: this.sessionState,
-            timestamp: Date.now(),
-        });
-        // Update/persist TestSession itemSessions mapping (QTI item identifier -> PIE session id)
-        const pieSessionId = detail?.id;
-        const currentQuestion = this.questionRefs[this.currentItemIndex];
-        if (this.attemptStorage &&
-            this.testSession &&
-            currentQuestion?.identifier &&
-            pieSessionId) {
-            this.testSession = upsertItemSessionFromPieSessionChange(this.testSession, {
-                itemIdentifier: currentQuestion.identifier,
-                pieSessionId,
-                isCompleted: !!detail.complete,
-            });
-            saveTestSession(this.attemptStorage, this.testSession);
-        }
-    }
-    persistAttemptNavigation(itemIdentifier, index) {
-        if (!this.attemptStorage || !this.testSession || !itemIdentifier) {
-            return;
-        }
-        const currentSectionIdentifier = this.findSectionIdentifierForQuestion(itemIdentifier) || undefined;
-        this.testSession = setCurrentPosition(upsertVisitedItem(this.testSession, itemIdentifier), {
-            currentItemIndex: index,
-            currentSectionIdentifier,
-        });
-        saveTestSession(this.attemptStorage, this.testSession);
-    }
-    findSectionIdentifierForQuestion(questionIdentifier) {
-        const sections = this.flattenSections(this.navigationStructure);
-        for (const section of sections) {
-            if (this.sectionContainsQuestion(section, questionIdentifier)) {
-                return section.identifier;
-            }
-        }
-        return null;
-    }
-    /**
-     * Subscribe to navigation state changes
-     */
-    onNavigationChange(listener) {
-        this.navigationListeners.add(listener);
-        return () => this.navigationListeners.delete(listener);
-    }
-    /**
-     * Subscribe to item changes
-     */
-    onItemChange(listener) {
-        this.itemListeners.add(listener);
-        return () => this.itemListeners.delete(listener);
-    }
-    /**
-     * Subscribe to loading state changes
-     */
-    onLoadingChange(listener) {
-        this.loadingListeners.add(listener);
-        return () => this.loadingListeners.delete(listener);
-    }
-    /**
-     * Subscribe to session changes
-     */
-    onSessionChange(listener) {
-        this.sessionListeners.add(listener);
-        return () => this.sessionListeners.delete(listener);
-    }
-    /**
-     * Subscribe to TTS state changes
-     */
-    onTTSStateChange(listener) {
-        this.ttsStateListeners.add(listener);
-        return () => this.ttsStateListeners.delete(listener);
-    }
-    /**
-     * Notify listeners
-     */
-    notifyNavigationListeners() {
-        const state = this.getNavigationState();
-        this.navigationListeners.forEach((listener) => listener(state));
-    }
-    notifyItemListeners() {
-        this.itemListeners.forEach((listener) => listener(this.currentItem));
-    }
-    notifyLoadingListeners(isLoading) {
-        this.loadingListeners.forEach((listener) => listener(isLoading));
-    }
-    notifySessionListeners() {
-        this.sessionListeners.forEach((listener) => listener(this.sessionState));
-    }
-    notifyTTSStateListeners() {
-        this.ttsStateListeners.forEach((listener) => listener(this.ttsSpeaking, this.ttsPaused));
-    }
-    /**
-     * Extract text from element (simplified)
-     * Production would use extractTextFromElement from tts/utils
-     */
-    extractText(element) {
-        // This is simplified - production should use the actual extraction logic
-        return element.textContent || "";
-    }
-    /**
-     * Get current section's rubric blocks (passages, instructions)
-     */
-    getCurrentSectionRubricBlocks() {
-        const navState = this.getNavigationState();
-        if (!navState.currentSection || this.navigationStructure.length === 0) {
-            return [];
-        }
-        // Find the current section node
-        const sections = this.flattenSections(this.navigationStructure);
-        const currentSectionNode = sections[navState.currentSection.index];
-        if (!currentSectionNode) {
-            return [];
-        }
-        // Extract rubric blocks from the assessment structure
-        // This requires accessing the original assessment data
-        return this.extractRubricBlocksForSection(currentSectionNode.identifier);
-    }
-    /**
-     * Extract rubric blocks for a specific section identifier
-     */
-    extractRubricBlocksForSection(sectionIdentifier) {
-        const format = this.assessmentFormat;
-        if (format === "qti") {
-            // Type assertion needed for QTI fields
-            const qtiAssessment = this.config.assessment;
-            if (!qtiAssessment.testParts) {
-                return [];
-            }
-            // Search through testParts and sections
-            for (const testPart of qtiAssessment.testParts) {
-                const rubricBlocks = this.findRubricBlocksInSections(testPart.sections, sectionIdentifier);
-                if (rubricBlocks.length > 0) {
-                    return rubricBlocks;
-                }
-            }
-        }
-        return [];
-    }
-    /**
-     * Recursively search for rubric blocks in sections
-     */
-    findRubricBlocksInSections(sections, targetIdentifier) {
-        if (!sections) {
-            return [];
-        }
-        for (const section of sections) {
-            if (section.identifier === targetIdentifier && section.rubricBlocks) {
-                return section.rubricBlocks;
-            }
-            // Check nested sections
-            if (section.sections) {
-                const rubricBlocks = this.findRubricBlocksInSections(section.sections, targetIdentifier);
-                if (rubricBlocks.length > 0) {
-                    return rubricBlocks;
-                }
-            }
-        }
-        return [];
-    }
-    /**
-     * Navigate to a specific section (goes to first item in section)
-     */
-    async navigateToSection(sectionIndex) {
-        if (!this.config.allowSectionNavigation &&
-            this.config.allowSectionNavigation !== undefined) {
-            console.warn("[AssessmentPlayer] Section navigation is disabled");
-            return;
-        }
-        const sections = this.flattenSections(this.navigationStructure);
-        if (sectionIndex < 0 || sectionIndex >= sections.length) {
-            return;
-        }
-        const targetSection = sections[sectionIndex];
-        // Find the first question in this section
-        const firstQuestionInSection = this.findFirstQuestionInSection(targetSection);
-        if (firstQuestionInSection !== -1) {
-            await this.navigate(firstQuestionInSection);
-        }
-    }
-    /**
-     * Find the index of the first question in a section
-     */
-    findFirstQuestionInSection(section) {
-        if (!section.children) {
-            return -1;
-        }
-        // Look for first question node
-        for (const child of section.children) {
-            if (child.type === "question") {
-                // Find this question's index in questionRefs
-                const index = this.questionRefs.findIndex((q) => q.identifier === child.identifier);
-                if (index !== -1) {
-                    return index;
-                }
-            }
-            // Check nested sections
-            if (child.type === "section") {
-                const index = this.findFirstQuestionInSection(child);
-                if (index !== -1) {
-                    return index;
-                }
-            }
-        }
-        return -1;
-    }
-    /**
-     * Get navigation mode (linear or nonlinear)
-     */
-    getNavigationMode() {
-        return this.navigationMode;
-    }
-    /**
-     * Get all sections for display (e.g., in a section menu)
-     */
-    getAllSections() {
-        const sections = this.flattenSections(this.navigationStructure);
-        return sections.map((section, index) => ({
-            id: section.id,
-            title: section.title,
-            index,
-        }));
-    }
-    /**
-     * Get the authoring service (only available in author mode)
-     */
-    getAuthoringService() {
-        return this.authoringService;
-    }
-    /**
-     * Enable or disable authoring mode
-     */
-    setAuthoringMode(enabled) {
-        if (enabled && !this.authoringService) {
-            this.authoringService = new AssessmentAuthoringService(this.config.assessment, this.config.authoringCallbacks || {});
-            this.config.mode = "author";
-        }
-        else if (!enabled && this.authoringService) {
-            this.authoringService = null;
-            this.config.mode = "gather";
-        }
-    }
-    // ===== PROFILE-BASED CONFIGURATION =====
-    /**
-     * Apply an assessment context profile
-     */
-    /**
-     * Initialize tools from assessment PNP
-     */
-    initializeTools() {
-        const assessment = this.config.assessment;
-        // Resolve tools from PNP + settings
-        this.currentTools = this.pnpResolver.resolveTools(assessment);
-        // Register tools with coordinator
-        for (const tool of this.currentTools) {
-            if (tool.enabled) {
-                this.toolCoordinator.registerTool(tool.id, this.humanizeName(tool.id));
-                // Configure tool-specific settings
-                if (tool.id === "calculator" && tool.settings) {
-                    this.configureCalculator(tool.settings);
-                }
-            }
-        }
-    }
-    /**
-     * Apply theme from assessment settings
-     */
-    applyAssessmentTheme() {
-        const settings = this.config.assessment.settings;
-        const themeConfig = settings?.themeConfig;
-        if (themeConfig) {
-            this.themeProvider =
-                this.config.services?.themeProvider ?? new ThemeProvider();
-            this.themeProvider.applyTheme(themeConfig);
-        }
-    }
-    /**
-     * Auto-activate tools marked in PNP
-     */
-    autoActivateTools() {
-        const autoActivate = this.pnpResolver.getAutoActivateTools(this.config.assessment);
-        for (const toolId of autoActivate) {
-            this.toolCoordinator.showTool(toolId);
-        }
-    }
-    /**
-     * Configure calculator with settings
-     */
-    configureCalculator(settings) {
-        // Calculator configuration logic
-        // (existing logic would be here)
-    }
-    /**
-     * Convert tool ID to human-readable name
-     */
-    humanizeName(toolId) {
-        return toolId
-            .replace(/^pie-tool-/, "")
-            .replace(/([a-z])([A-Z])/g, "$1 $2")
-            .replace(/-/g, " ")
-            .replace(/\b\w/g, (c) => c.toUpperCase());
-    }
-    /**
-     * Get available tools (resolved from PNP)
-     */
-    getAvailableTools() {
-        return this.currentTools;
-    }
-    /**
-     * Check if a specific tool is enabled
-     */
-    isToolEnabled(toolId) {
-        return this.currentTools.some((t) => t.id === toolId && t.enabled);
-    }
-    /**
-     * Check if a specific tool is required
-     */
-    isToolRequired(toolId) {
-        const tool = this.currentTools.find((t) => t.id === toolId);
-        return tool?.required || tool?.alwaysAvailable || false;
-    }
-    /**
-     * Get configuration for a specific tool
-     */
-    getToolConfig(toolId) {
-        return this.currentTools.find((t) => t.id === toolId)?.settings;
-    }
-    /**
-     * Get layout preferences from settings
-     */
-    getLayoutPreferences() {
-        return this.config.assessment.settings?.themeConfig || {};
-    }
-    // ============================================================================
-    // Context Variables (QTI 3.0 Context Declarations)
-    // ============================================================================
-    /**
-     * Get context variable value
-     *
-     * @param identifier Variable identifier
-     * @returns Variable value or undefined
-     */
-    getContextVariable(identifier) {
-        return this.contextStore.get(identifier);
-    }
-    /**
-     * Set context variable value
-     *
-     * @param identifier Variable identifier
-     * @param value New value
-     */
-    setContextVariable(identifier, value) {
-        this.contextStore.set(identifier, value);
-        this.persistContextVariables();
-    }
-    /**
-     * Get all context variables as object
-     *
-     * @returns Object containing all context variables
-     */
-    getContextVariables() {
-        return this.contextStore.toObject();
-    }
-    /**
-     * Reset context variables to default values
-     */
-    resetContextVariables() {
-        this.contextStore.reset();
-        this.persistContextVariables();
-    }
-    /**
-     * Restore context variables from session storage
-     */
-    restoreContextVariables() {
-        if (this.testSession?.contextVariables) {
-            this.contextStore.fromObject(this.testSession.contextVariables);
-        }
-    }
-    /**
-     * Persist context variables to session storage
-     */
-    persistContextVariables() {
-        if (this.testSession && this.attemptStorage) {
-            this.testSession = {
-                ...this.testSession,
-                contextVariables: this.contextStore.toObject(),
-            };
-            saveTestSession(this.attemptStorage, this.testSession);
-        }
-    }
-    /**
-     * Cleanup
-     */
-    destroy() {
-        if (this.ttsInitialized) {
-            this.ttsService.offStateChange("reference-player", () => { });
-        }
-        if (this.themeProvider) {
-            this.themeProvider.destroy();
-        }
-        if (this.highlightCoordinator) {
-            this.highlightCoordinator.destroy();
-        }
-        this.navigationListeners.clear();
-        this.itemListeners.clear();
-        this.loadingListeners.clear();
-        this.sessionListeners.clear();
-        this.ttsStateListeners.clear();
-    }
-}
-//# sourceMappingURL=AssessmentPlayer.js.map