@hawsen-the-first/interactiv 0.0.1

package/dist/src/logger.d.ts

@@ -0,0 +1,11 @@
+import { Logger } from "../utils/logger";
+declare const logger: Logger;
+/**
+ * Configure the internal package logger
+ * This allows consuming projects to adjust logging levels without creating their own logger
+ * @param debugMode Enable debug mode (overrides minLogLevel)
+ * @param minLogLevel Minimum log level: 'none' | 'error' | 'warn' | 'trace'
+ */
+export declare function configureLogger(debugMode?: boolean, minLogLevel?: string): void;
+export { logger };
+//# sourceMappingURL=logger.d.ts.map

package/dist/src/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/logger.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAIzC,QAAA,MAAM,MAAM,QAA6B,CAAC;AAE1C;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,SAAS,GAAE,OAAe,EAAE,WAAW,GAAE,MAAgB,GAAG,IAAI,CAG/F;AAED,OAAO,EAAE,MAAM,EAAE,CAAC"}

package/dist/src/logger.js

@@ -0,0 +1,15 @@
+import { Logger } from "../utils/logger";
+// Centralized logger instance for internal package use
+// Default configuration: error-only logging for production builds
+const logger = new Logger(false, "error");
+/**
+ * Configure the internal package logger
+ * This allows consuming projects to adjust logging levels without creating their own logger
+ * @param debugMode Enable debug mode (overrides minLogLevel)
+ * @param minLogLevel Minimum log level: 'none' | 'error' | 'warn' | 'trace'
+ */
+export function configureLogger(debugMode = false, minLogLevel = "error") {
+    logger.debugMode = debugMode;
+    logger.minLoglevel = minLogLevel;
+}
+export { logger };

package/dist/src/navigationManager.d.ts

@@ -0,0 +1,105 @@
+import { EventOrchestrator } from "./eventBus";
+import { Page, View } from "./appBuilder";
+import { type StateSubscription } from "./stateManager";
+export interface TransitionConfig {
+    type: "slide" | "fade" | "scale" | "flip" | "snap" | "custom";
+    direction?: "left" | "right" | "up" | "down";
+    duration?: number;
+    easing?: string;
+    customCSS?: string;
+}
+export interface NavigationState {
+    currentPageId: string | null;
+    currentViewId: string | null;
+    isTransitioning: boolean;
+}
+/**
+ * NavigationManager - Singleton Service for Application Navigation
+ *
+ * **IMPORTANT: Only ONE instance of NavigationManager should exist per application.**
+ *
+ * This class manages page and view navigation using shared global state. Multiple instances
+ * would cause critical issues:
+ * - Conflicting global state (navigation.currentPageId, navigation.currentViewId, navigation.isTransitioning)
+ * - Event bus namespace collisions (all instances register as "navigation-manager")
+ * - Ambiguous page/view registration and navigation routing
+ *
+ * The NavigationManager is automatically instantiated by AppBuilder and should not be
+ * manually created elsewhere in the application.
+ *
+ * @example
+ * // ✅ Correct: Created once by AppBuilder
+ * class AppBuilder extends RenderableComponent {
+ *   private navigationManager: NavigationManager;
+ *   constructor(orchestrator: EventOrchestrator) {
+ *     this.navigationManager = new NavigationManager(orchestrator);
+ *   }
+ * }
+ *
+ * // ❌ Wrong: Creating additional instances
+ * const nav1 = new NavigationManager(orchestrator); // First instance - OK
+ * const nav2 = new NavigationManager(orchestrator); // ERROR: Will throw!
+ */
+export declare class NavigationManager {
+    private static instance;
+    private static isDestroyed;
+    private eventBus;
+    private orchestrator;
+    private pages;
+    private views;
+    private stateSubscriptions;
+    private activeTransitionCleanups;
+    /**
+     * Get the singleton instance of NavigationManager
+     * Returns null if no instance has been created yet
+     */
+    static getInstance(): NavigationManager | null;
+    constructor(orchestrator: EventOrchestrator);
+    private initializeGlobalState;
+    private setupEventListeners;
+    registerPage(page: Page): void;
+    registerView(view: View): void;
+    private setupPageContainer;
+    private setupViewContainer;
+    navigateToPage(pageId: string, config?: TransitionConfig, priority?: string): Promise<void>;
+    navigateToView(viewId: string, config?: TransitionConfig, priority?: string): Promise<void>;
+    private performPageNavigationInternal;
+    private performViewNavigationInternal;
+    private performPageTransition;
+    private performViewTransition;
+    private animateOut;
+    private animateIn;
+    private normalizeTransitionConfig;
+    private clearAnimationClasses;
+    private showPage;
+    private hidePage;
+    private showView;
+    private hideView;
+    private hideAllViews;
+    getCurrentPageId(): string | null;
+    getCurrentViewId(): string | null;
+    isTransitioning(): boolean;
+    getRegisteredPages(): string[];
+    getRegisteredViews(): string[];
+    subscribeToCurrentPage(callback: (pageId: string | null) => void): StateSubscription;
+    subscribeToCurrentView(callback: (viewId: string | null) => void): StateSubscription;
+    subscribeToTransitionState(callback: (isTransitioning: boolean) => void): StateSubscription;
+    /**
+     * Clean up any orphaned transition listeners
+     * This is a safety net for transitions that didn't complete properly
+     */
+    cleanupOrphanedTransitions(): void;
+    /**
+     * Get the count of active transitions
+     */
+    getActiveTransitionCount(): number;
+    /**
+     * Cleanup method for proper resource management
+     *
+     * Destroys the NavigationManager instance and clears the singleton reference.
+     * After calling destroy(), a new NavigationManager instance can be created if needed
+     * (though this is typically only necessary during application teardown/restart).
+     */
+    destroy(): void;
+}
+//# sourceMappingURL=navigationManager.d.ts.map

package/dist/src/navigationManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"navigationManager.d.ts","sourceRoot":"","sources":["../../src/navigationManager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,iBAAiB,EAAE,MAAM,YAAY,CAAC;AACzD,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAgB,KAAK,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAKtE,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,OAAO,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,QAAQ,CAAC;IAC9D,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,MAAM,CAAC;IAC7C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,eAAe;IAC9B,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,eAAe,EAAE,OAAO,CAAC;CAC1B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAkC;IACzD,OAAO,CAAC,MAAM,CAAC,WAAW,CAAkB;IAE5C,OAAO,CAAC,QAAQ,CAAW;IAC3B,OAAO,CAAC,YAAY,CAAoB;IACxC,OAAO,CAAC,KAAK,CAAgC;IAC7C,OAAO,CAAC,KAAK,CAAgC;IAC7C,OAAO,CAAC,kBAAkB,CAA2B;IACrD,OAAO,CAAC,wBAAwB,CAA2C;IAE3E;;;OAGG;WACW,WAAW,IAAI,iBAAiB,GAAG,IAAI;gBAIzC,YAAY,EAAE,iBAAiB;IA4B3C,OAAO,CAAC,qBAAqB;IAa7B,OAAO,CAAC,mBAAmB;IAsBpB,YAAY,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI;IAa9B,YAAY,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI;IAQrC,OAAO,CAAC,kBAAkB;IAM1B,OAAO,CAAC,kBAAkB;IAMb,cAAc,CACzB,MAAM,EAAE,MAAM,EACd,MAAM,GAAE,gBAAmC,EAC3C,QAAQ,GAAE,MAAoB,GAC7B,OAAO,CAAC,IAAI,CAAC;IAYH,cAAc,CACzB,MAAM,EAAE,MAAM,EACd,MAAM,GAAE,gBAAmC,EAC3C,QAAQ,GAAE,MAAoB,GAC7B,OAAO,CAAC,IAAI,CAAC;YAYF,6BAA6B;YA6B7B,6BAA6B;YAgC7B,qBAAqB;YAmBrB,qBAAqB;YAqBrB,UAAU;YAuEV,SAAS;IA2FvB,OAAO,CAAC,yBAAyB;IAkBjC,OAAO,CAAC,qBAAqB;IAwB7B,OAAO,CAAC,QAAQ;IAUhB,OAAO,CAAC,QAAQ;IAchB,OAAO,CAAC,QAAQ;IAgBhB,OAAO,CAAC,QAAQ;IAUhB,OAAO,CAAC,YAAY;IAQb,gBAAgB,IAAI,MAAM,GAAG,IAAI;IAIjC,gBAAgB,IAAI,MAAM,GAAG,IAAI;IAIjC,eAAe,IAAI,OAAO;IAI1B,kBAAkB,IAAI,MAAM,EAAE;IAI9B,kBAAkB,IAAI,MAAM,EAAE;IAK9B,sBAAsB,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,GAAG,iBAAiB;IAIpF,sBAAsB,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,GAAG,iBAAiB;IAIpF,0BAA0B,CAAC,QAAQ,EAAE,CAAC,eAAe,EAAE,OAAO,KAAK,IAAI,GAAG,iBAAiB;IAIlG;;;OAGG;IACI,0BAA0B,IAAI,IAAI;IAezC;;OAEG;IACI,wBAAwB,IAAI,MAAM;IAIzC;;;;;;OAMG;IACI,OAAO,IAAI,IAAI;CAoBvB"}

package/dist/src/navigationManager.js

@@ -0,0 +1,533 @@
+import { stateManager } from "./stateManager";
+import { logger } from "./logger";
+const log = logger;
+/**
+ * NavigationManager - Singleton Service for Application Navigation
+ *
+ * **IMPORTANT: Only ONE instance of NavigationManager should exist per application.**
+ *
+ * This class manages page and view navigation using shared global state. Multiple instances
+ * would cause critical issues:
+ * - Conflicting global state (navigation.currentPageId, navigation.currentViewId, navigation.isTransitioning)
+ * - Event bus namespace collisions (all instances register as "navigation-manager")
+ * - Ambiguous page/view registration and navigation routing
+ *
+ * The NavigationManager is automatically instantiated by AppBuilder and should not be
+ * manually created elsewhere in the application.
+ *
+ * @example
+ * // ✅ Correct: Created once by AppBuilder
+ * class AppBuilder extends RenderableComponent {
+ *   private navigationManager: NavigationManager;
+ *   constructor(orchestrator: EventOrchestrator) {
+ *     this.navigationManager = new NavigationManager(orchestrator);
+ *   }
+ * }
+ *
+ * // ❌ Wrong: Creating additional instances
+ * const nav1 = new NavigationManager(orchestrator); // First instance - OK
+ * const nav2 = new NavigationManager(orchestrator); // ERROR: Will throw!
+ */
+export class NavigationManager {
+    static instance = null;
+    static isDestroyed = false;
+    eventBus;
+    orchestrator;
+    pages = new Map();
+    views = new Map();
+    stateSubscriptions = [];
+    activeTransitionCleanups = new Map();
+    /**
+     * Get the singleton instance of NavigationManager
+     * Returns null if no instance has been created yet
+     */
+    static getInstance() {
+        return NavigationManager.instance;
+    }
+    constructor(orchestrator) {
+        // Enforce singleton pattern - only one instance allowed
+        if (NavigationManager.instance !== null) {
+            const errorMsg = "NavigationManager instance already exists! Only one NavigationManager should be created per application. " +
+                "The NavigationManager is automatically created by AppBuilder and should not be instantiated manually.";
+            const error = new Error(errorMsg);
+            log.error(errorMsg, error);
+            throw error;
+        }
+        if (NavigationManager.isDestroyed) {
+            log.warn("Creating new NavigationManager instance after previous instance was destroyed.");
+            NavigationManager.isDestroyed = false;
+        }
+        // Register this as the singleton instance
+        NavigationManager.instance = this;
+        log.trace("NavigationManager singleton instance created");
+        this.orchestrator = orchestrator;
+        this.eventBus = orchestrator.registerEventBus("navigation-manager");
+        // Initialize global navigation state
+        this.initializeGlobalState();
+        this.setupEventListeners();
+    }
+    initializeGlobalState() {
+        // Initialize navigation state in global store if not already present
+        if (!stateManager.has("navigation.currentPageId")) {
+            stateManager.set("navigation.currentPageId", null);
+        }
+        if (!stateManager.has("navigation.currentViewId")) {
+            stateManager.set("navigation.currentViewId", null);
+        }
+        if (!stateManager.has("navigation.isTransitioning")) {
+            stateManager.set("navigation.isTransitioning", false);
+        }
+    }
+    setupEventListeners() {
+        this.eventBus.on("navigate-to-page", (e) => {
+            const { pageId, config } = e.detail;
+            this.performPageNavigationInternal(pageId, config);
+        });
+        this.eventBus.on("navigate-to-view", (e) => {
+            const { viewId, config } = e.detail;
+            this.performViewNavigationInternal(viewId, config);
+        });
+        this.eventBus.on("register-page", (e) => {
+            const { page } = e.detail;
+            this.registerPage(page);
+        });
+        this.eventBus.on("register-view", (e) => {
+            const { view } = e.detail;
+            this.registerView(view);
+        });
+    }
+    registerPage(page) {
+        this.pages.set(page.componentId, page);
+        this.setupPageContainer(page);
+        // If this is the first page, make it active
+        if (!stateManager.get("navigation.currentPageId")) {
+            stateManager.set("navigation.currentPageId", page.componentId);
+            this.showPage(page.componentId);
+        }
+        else {
+            this.hidePage(page.componentId);
+        }
+    }
+    registerView(view) {
+        this.views.set(view.componentId, view);
+        this.setupViewContainer(view);
+        // Hide all views by default - they will be shown when navigated to
+        this.hideView(view.componentId);
+    }
+    setupPageContainer(page) {
+        const hostElement = page.getHostElement();
+        hostElement.classList.add("nav-item", "nav-page");
+        hostElement.setAttribute("data-page-id", page.componentId);
+    }
+    setupViewContainer(view) {
+        const hostElement = view.getHostElement();
+        hostElement.classList.add("nav-item", "nav-view");
+        hostElement.setAttribute("data-view-id", view.componentId);
+    }
+    async navigateToPage(pageId, config = { type: "snap" }, priority = "immediate") {
+        // Use EventOrchestrator queue for navigation requests
+        if (stateManager.get("navigation.isTransitioning")) {
+            // Queue the navigation through the orchestrator
+            this.orchestrator.enqueue("navigate-to-page", "navigation-manager", priority, { pageId, config });
+            return;
+        }
+        // Direct navigation if not transitioning
+        this.orchestrator.enqueue("navigate-to-page", "navigation-manager", priority, { pageId, config });
+    }
+    async navigateToView(viewId, config = { type: "snap" }, priority = "immediate") {
+        // Use EventOrchestrator queue for navigation requests
+        if (stateManager.get("navigation.isTransitioning")) {
+            // Queue the navigation through the orchestrator
+            this.orchestrator.enqueue("navigate-to-view", "navigation-manager", priority, { viewId, config });
+            return;
+        }
+        // Direct navigation if not transitioning
+        this.orchestrator.enqueue("navigate-to-view", "navigation-manager", priority, { viewId, config });
+    }
+    async performPageNavigationInternal(pageId, config) {
+        if (!this.pages.has(pageId)) {
+            throw new Error(`Page with id "${pageId}" not found`);
+        }
+        if (stateManager.get("navigation.currentPageId") === pageId) {
+            return; // Already on this page
+        }
+        const previousPageId = stateManager.get("navigation.currentPageId");
+        stateManager.set("navigation.isTransitioning", true);
+        try {
+            await this.performPageTransition(pageId, config);
+            stateManager.set("navigation.currentPageId", pageId);
+            stateManager.set("navigation.currentViewId", null); // Reset view when changing pages
+            // Hide all views when navigating to a page to ensure clean state
+            this.hideAllViews();
+            this.eventBus.emit("page-changed", {
+                newPageId: pageId,
+                previousPageId,
+            });
+        }
+        finally {
+            stateManager.set("navigation.isTransitioning", false);
+        }
+    }
+    async performViewNavigationInternal(viewId, config) {
+        if (!this.views.has(viewId)) {
+            throw new Error(`View with id "${viewId}" not found`);
+        }
+        if (stateManager.get("navigation.currentViewId") === viewId) {
+            log.trace(`Already on view ${viewId}, emitting re-entry event`);
+            //this.eventBus.emit("view-re-entered", { viewId });
+            return; // Already on this view
+        }
+        const previousViewId = stateManager.get("navigation.currentViewId");
+        log.trace(`Starting navigation from ${previousViewId} to ${viewId}`);
+        stateManager.set("navigation.isTransitioning", true);
+        try {
+            await this.performViewTransition(viewId, config);
+            stateManager.set("navigation.currentViewId", viewId);
+            this.eventBus.emit("view-changed", {
+                newViewId: viewId,
+                previousViewId,
+            });
+            log.trace(`Navigation to ${viewId} completed successfully`);
+        }
+        catch (error) {
+            log.error(`Navigation to ${viewId} failed:`, error);
+            throw error;
+        }
+        finally {
+            stateManager.set("navigation.isTransitioning", false);
+        }
+    }
+    async performPageTransition(targetPageId, config) {
+        const currentPageId = stateManager.get("navigation.currentPageId");
+        const currentPage = currentPageId ? this.pages.get(currentPageId) : null;
+        const targetPage = this.pages.get(targetPageId);
+        // Validate and normalize config
+        const normalizedConfig = this.normalizeTransitionConfig(config);
+        // Show target page first (but invisible)
+        this.showPage(targetPageId);
+        if (currentPage) {
+            await this.animateOut(currentPage.getHostElement(), normalizedConfig);
+            this.hidePage(currentPage.componentId);
+        }
+        await this.animateIn(targetPage.getHostElement(), normalizedConfig);
+    }
+    async performViewTransition(targetViewId, config) {
+        const currentViewId = stateManager.get("navigation.currentViewId");
+        const currentView = currentViewId ? this.views.get(currentViewId) : null;
+        const targetView = this.views.get(targetViewId);
+        // Validate and normalize config
+        const normalizedConfig = this.normalizeTransitionConfig(config);
+        // Show target view first (before animation)
+        this.showView(targetViewId, normalizedConfig.type !== "snap");
+        // Animate if needed
+        if (currentView) {
+            await this.animateOut(currentView.getHostElement(), normalizedConfig);
+            // Hide current view after animation completes
+            this.hideView(currentViewId);
+        }
+        await this.animateIn(targetView.getHostElement(), normalizedConfig);
+    }
+    async animateOut(element, config) {
+        // Handle snap navigation - immediate hide with no animation
+        if (config.type === "snap") {
+            element.style.transition = "none";
+            element.style.opacity = "0";
+            element.style.visibility = "hidden";
+            return Promise.resolve();
+        }
+        return new Promise((resolve) => {
+            const duration = config.duration || 300;
+            element.style.transition = `all ${duration}ms ${config.easing || "ease-in-out"}`;
+            let transitionendFired = false;
+            let fallbackTimerId = null;
+            const cleanup = () => {
+                if (transitionendFired)
+                    return; // Prevent double execution
+                transitionendFired = true;
+                // Clean up both the event listener and timeout
+                element.removeEventListener("transitionend", transitionendHandler);
+                if (fallbackTimerId !== null) {
+                    clearTimeout(fallbackTimerId);
+                    fallbackTimerId = null;
+                }
+                // Remove from active transitions map
+                this.activeTransitionCleanups.delete(element);
+                resolve();
+            };
+            const transitionendHandler = () => {
+                cleanup();
+            };
+            element.addEventListener("transitionend", transitionendHandler, { once: true });
+            // Store cleanup function for this element
+            this.activeTransitionCleanups.set(element, cleanup);
+            // Apply exit animation
+            switch (config.type) {
+                case "slide":
+                    element.classList.add(`slide-out-${config.direction || "left"}`);
+                    break;
+                case "fade":
+                    element.classList.add("fade-out");
+                    break;
+                case "scale":
+                    element.classList.add("scale-out");
+                    break;
+                case "flip":
+                    element.classList.add("flip-out");
+                    break;
+                case "custom":
+                    if (config.customCSS) {
+                        element.style.cssText += config.customCSS;
+                    }
+                    break;
+            }
+            // Fallback timeout
+            fallbackTimerId = window.setTimeout(() => {
+                log.trace("Transition fallback timeout triggered for animateOut");
+                cleanup();
+            }, duration + 50);
+        });
+    }
+    async animateIn(element, config) {
+        // Handle snap navigation - immediate show with no animation
+        if (config.type === "snap") {
+            element.style.transition = "none";
+            element.style.opacity = "1";
+            element.style.visibility = "visible";
+            element.style.transform = "none";
+            this.clearAnimationClasses(element);
+            return Promise.resolve();
+        }
+        return new Promise((resolve) => {
+            const duration = config.duration || 300;
+            element.style.transition = `all ${duration}ms ${config.easing || "ease-in-out"}`;
+            let transitionendFired = false;
+            let fallbackTimerId = null;
+            const cleanup = () => {
+                if (transitionendFired)
+                    return; // Prevent double execution
+                transitionendFired = true;
+                // Clean up both the event listener and timeout
+                element.removeEventListener("transitionend", transitionendHandler);
+                if (fallbackTimerId !== null) {
+                    clearTimeout(fallbackTimerId);
+                    fallbackTimerId = null;
+                }
+                // Remove from active transitions map
+                this.activeTransitionCleanups.delete(element);
+                this.clearAnimationClasses(element);
+                resolve();
+            };
+            const transitionendHandler = () => {
+                cleanup();
+            };
+            element.addEventListener("transitionend", transitionendHandler, { once: true });
+            // Store cleanup function for this element
+            this.activeTransitionCleanups.set(element, cleanup);
+            // Set initial state
+            switch (config.type) {
+                case "slide":
+                    element.classList.add(`slide-in-${config.direction || "right"}`);
+                    break;
+                case "fade":
+                    element.classList.add("fade-in");
+                    break;
+                case "scale":
+                    element.classList.add("scale-in");
+                    break;
+                case "flip":
+                    element.classList.add("flip-in");
+                    break;
+            }
+            // Animate to active state
+            requestAnimationFrame(() => {
+                switch (config.type) {
+                    case "slide":
+                        element.classList.remove(`slide-in-${config.direction || "right"}`);
+                        element.classList.add("slide-active");
+                        break;
+                    case "fade":
+                        element.classList.remove("fade-in");
+                        element.classList.add("fade-active");
+                        break;
+                    case "scale":
+                        element.classList.remove("scale-in");
+                        element.classList.add("scale-active");
+                        break;
+                    case "flip":
+                        element.classList.remove("flip-in");
+                        element.classList.add("flip-active");
+                        break;
+                }
+            });
+            // Fallback timeout
+            fallbackTimerId = window.setTimeout(() => {
+                log.trace("Transition fallback timeout triggered for animateIn");
+                cleanup();
+            }, duration + 50);
+        });
+    }
+    normalizeTransitionConfig(config) {
+        // If config is missing or invalid, fallback to snap
+        if (!config || !config.type) {
+            log.warn("Invalid transition config, falling back to snap navigation");
+            return { type: "snap" };
+        }
+        // For animated transitions, ensure duration is set
+        if (config.type !== "snap" && config.type !== "custom") {
+            if (!config.duration || config.duration <= 0) {
+                log.warn(`Invalid duration for ${config.type} transition, falling back to snap navigation`);
+                return { type: "snap" };
+            }
+        }
+        return config;
+    }
+    clearAnimationClasses(element) {
+        const animationClasses = [
+            "slide-out-left",
+            "slide-out-right",
+            "slide-out-up",
+            "slide-out-down",
+            "slide-in-left",
+            "slide-in-right",
+            "slide-in-up",
+            "slide-in-down",
+            "slide-active",
+            "fade-out",
+            "fade-in",
+            "fade-active",
+            "scale-out",
+            "scale-in",
+            "scale-active",
+            "flip-out",
+            "flip-in",
+            "flip-active",
+        ];
+        element.classList.remove(...animationClasses);
+    }
+    showPage(pageId) {
+        const page = this.pages.get(pageId);
+        if (page) {
+            const element = page.getHostElement();
+            element.style.display = ""; // Clear the inline display:none
+            element.classList.remove("nav-hidden", "out");
+            element.classList.add("in");
+        }
+    }
+    hidePage(pageId) {
+        const page = this.pages.get(pageId);
+        if (page) {
+            const element = page.getHostElement();
+            element.classList.add("nav-hidden");
+            // Set display none after a short delay to allow animation to complete
+            setTimeout(() => {
+                if (element.classList.contains("nav-hidden")) {
+                    element.style.display = "none";
+                }
+            }, 50);
+        }
+    }
+    showView(viewId, animate = true) {
+        const view = this.views.get(viewId);
+        if (view) {
+            const element = view.getHostElement();
+            element.style.display = "block";
+            element.classList.remove("nav-hidden");
+            element.style.visibility = "visible";
+            if (!animate) {
+                element.style.opacity = "1";
+                element.style.transform = "none";
+            }
+            // When animating, let CSS animation classes control opacity entirely
+            // Don't set inline opacity as it would override CSS classes
+        }
+    }
+    hideView(viewId) {
+        const view = this.views.get(viewId);
+        if (view) {
+            const element = view.getHostElement();
+            element.classList.add("nav-hidden");
+            element.style.display = "none";
+            element.style.visibility = "hidden";
+        }
+    }
+    hideAllViews() {
+        // Hide all registered views to ensure clean state
+        this.views.forEach((_, viewId) => {
+            this.hideView(viewId);
+        });
+        log.trace("All views hidden");
+    }
+    getCurrentPageId() {
+        return stateManager.get("navigation.currentPageId");
+    }
+    getCurrentViewId() {
+        return stateManager.get("navigation.currentViewId");
+    }
+    isTransitioning() {
+        return stateManager.get("navigation.isTransitioning");
+    }
+    getRegisteredPages() {
+        return Array.from(this.pages.keys());
+    }
+    getRegisteredViews() {
+        return Array.from(this.views.keys());
+    }
+    // Convenience methods for external components to subscribe to navigation state
+    subscribeToCurrentPage(callback) {
+        return stateManager.subscribe("navigation.currentPageId", callback);
+    }
+    subscribeToCurrentView(callback) {
+        return stateManager.subscribe("navigation.currentViewId", callback);
+    }
+    subscribeToTransitionState(callback) {
+        return stateManager.subscribe("navigation.isTransitioning", callback);
+    }
+    /**
+     * Clean up any orphaned transition listeners
+     * This is a safety net for transitions that didn't complete properly
+     */
+    cleanupOrphanedTransitions() {
+        const orphanedCount = this.activeTransitionCleanups.size;
+        if (orphanedCount > 0) {
+            log.trace(`Cleaning up ${orphanedCount} orphaned transition(s)`);
+            this.activeTransitionCleanups.forEach((cleanup, element) => {
+                try {
+                    cleanup();
+                }
+                catch (error) {
+                    log.error(`Error cleaning up orphaned transition for element with ID ${element.id}:`, error);
+                }
+            });
+            this.activeTransitionCleanups.clear();
+        }
+    }
+    /**
+     * Get the count of active transitions
+     */
+    getActiveTransitionCount() {
+        return this.activeTransitionCleanups.size;
+    }
+    /**
+     * Cleanup method for proper resource management
+     *
+     * Destroys the NavigationManager instance and clears the singleton reference.
+     * After calling destroy(), a new NavigationManager instance can be created if needed
+     * (though this is typically only necessary during application teardown/restart).
+     */
+    destroy() {
+        // Clean up any active transitions
+        this.cleanupOrphanedTransitions();
+        // Clean up any state subscriptions
+        this.stateSubscriptions.forEach((subscription) => {
+            subscription.unsubscribe();
+        });
+        this.stateSubscriptions.length = 0;
+        // Clear local maps
+        this.pages.clear();
+        this.views.clear();
+        // Clear the singleton instance reference to allow new instance creation
+        NavigationManager.instance = null;
+        NavigationManager.isDestroyed = true;
+        log.trace("NavigationManager singleton instance destroyed and cleared");
+    }
+}