@pie-players/pie-assessment-toolkit 0.2.0

package/dist/player/AssessmentPlayer.js

@@ -0,0 +1,965 @@
+/**
+ * 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";
+import { HighlightCoordinator, I18nService, ThemeProvider, ToolCoordinator, TTSService, TypedEventBus, } from "../index";
+import { AssessmentAuthoringService } from "../services/AssessmentAuthoringService";
+import { ContextVariableStore } from "../services/ContextVariableStore";
+import { PNPToolResolver, } from "../services/PNPToolResolver";
+import { BrowserTTSProvider } from "../services/tts/browser-provider";
+import { DesmosCalculatorProvider, TICalculatorProvider, } from "../tools/client";
+import { buildNavigationStructure, detectAssessmentFormat, getAllQuestionRefs, } from "./qti-navigation";
+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 and tools from assessment
+        this.pnpResolver = new PNPToolResolver();
+        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("pie-tool-text-to-speech")) {
+            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 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 === "pie-tool-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(/-/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