@hawsen-the-first/interactiv 0.0.1

package/dist/src/eventManager.js

@@ -0,0 +1,455 @@
+import { logger } from "./logger";
+const log = logger;
+export class EventManager {
+    shadowRoot;
+    abortController;
+    eventListeners = [];
+    selectorListeners = new Map(); // Track listeners by selector+method
+    dragStates = new Map();
+    swipeStates = new Map();
+    longPressTimers = new Map();
+    componentId;
+    constructor(shadowRoot, componentId) {
+        this.shadowRoot = shadowRoot;
+        this.componentId = componentId;
+        this.abortController = new AbortController();
+    }
+    /**
+     * Unified point interaction - handles both click and tap
+     */
+    point(selector, callback) {
+        log.trace(`EventManager.point() called for selector: ${selector} in component: ${this.componentId}`);
+        // Check if we already have listeners for this selector+method combination
+        const key = `point:${selector}`;
+        const existing = this.selectorListeners.get(key);
+        if (existing) {
+            const currentElements = Array.from(this.shadowRoot.querySelectorAll(selector));
+            const elementsChanged = existing.elements.length !== currentElements.length ||
+                existing.elements.some((el, i) => el !== currentElements[i]);
+            if (!elementsChanged) {
+                log.trace(`Point listeners already exist for selector: ${selector}, elements unchanged, skipping duplicate`);
+                return;
+            }
+            else {
+                log.trace(`DOM elements changed for selector: ${selector}, clearing old listeners and re-attaching`);
+                // Elements changed, clear old listeners
+                this.clearSelectorListeners(selector, "point");
+            }
+        }
+        const elements = this.shadowRoot.querySelectorAll(selector);
+        log.trace(`Found ${elements.length} elements for selector: ${selector}`);
+        // Store the selector listener mapping
+        this.selectorListeners.set(key, {
+            selector,
+            method: "point",
+            callback,
+            elements: Array.from(elements),
+        });
+        elements.forEach((element) => {
+            // Handle mouse click
+            this.addEventListenerWithTracking(element, "click", (e) => {
+                const mouseEvent = e;
+                mouseEvent.preventDefault();
+                const data = this.createPointerEventData(mouseEvent, "mouse");
+                callback(data);
+            }, undefined, selector, "point");
+            // Handle touch tap (short touch)
+            let touchStartTime = 0;
+            let pixelStartX, pixelStartY;
+            this.addEventListenerWithTracking(element, "touchstart", (e) => {
+                log.trace("Touch event ", e);
+                const touchEvent = e;
+                pixelStartX = touchEvent.changedTouches[0]?.clientX;
+                pixelStartY = touchEvent.changedTouches[0]?.clientY;
+                touchStartTime = Date.now();
+            }, { passive: true }, selector, "point");
+            this.addEventListenerWithTracking(element, "touchend", (e) => {
+                const touchEvent = e;
+                const touchDuration = Date.now() - touchStartTime;
+                log.trace("Touch event ", e);
+                if (touchDuration < 300 &&
+                    !this.movementThresholdMet(pixelStartX, pixelStartY, touchEvent.changedTouches[0].clientX, touchEvent.changedTouches[0].clientY)) {
+                    // Short tap
+                    touchEvent.preventDefault();
+                    const data = this.createPointerEventData(touchEvent, "touch");
+                    callback(data);
+                }
+            }, undefined, selector, "point");
+        });
+        log.trace(`Point listeners added for selector: ${selector}`, {
+            componentId: this.componentId,
+        });
+    }
+    /**
+     * Un-point interaction - handles touch and click events on the background to de-select an active element
+     */
+    unpoint(selector, callback) {
+        const body = document.querySelector("body");
+        const key = `unpoint:${selector}`;
+        // Store the selector listener mapping
+        this.selectorListeners.set(key, {
+            selector,
+            method: "unpoint",
+            callback,
+            elements: [body],
+        });
+        this.addEventListenerWithTracking(body, "click", (e) => {
+            const mouseEvent = e;
+            mouseEvent.preventDefault();
+            const data = this.createPointerEventData(mouseEvent, "mouse");
+            callback(data);
+        }, { once: true }, selector, "point");
+        // Handle touch tap (short touch)
+        let touchStartTime = 0;
+        this.addEventListenerWithTracking(body, "touchstart", (_) => {
+            touchStartTime = Date.now();
+        }, { passive: true, once: true }, selector, "point");
+        this.addEventListenerWithTracking(body, "touchend", (e) => {
+            const touchEvent = e;
+            const touchDuration = Date.now() - touchStartTime;
+            if (touchDuration < 300) {
+                // Short tap
+                touchEvent.preventDefault();
+                const data = this.createPointerEventData(touchEvent, "touch");
+                callback(data);
+            }
+        }, { once: true }, selector, "point");
+        log.trace(`Un-Point listeners added for selector: ${selector}`, {
+            componentId: this.componentId,
+        });
+    }
+    /**
+     * Drag interaction - handles both mouse drag and touch drag
+     */
+    drag(selector, callbacks) {
+        const elements = this.shadowRoot.querySelectorAll(selector);
+        elements.forEach((element) => {
+            // Mouse drag
+            this.addEventListener(element, "mousedown", (e) => {
+                this.startDrag(element, e, "mouse", callbacks);
+            });
+            // Touch drag
+            this.addEventListener(element, "touchstart", (e) => {
+                this.startDrag(element, e, "touch", callbacks);
+            }, { passive: false });
+        });
+        // Global mouse move and up listeners
+        this.addEventListener(document, "mousemove", (e) => {
+            this.handleDragMove(e, "mouse");
+        });
+        this.addEventListener(document, "mouseup", (e) => {
+            this.handleDragEnd(e, "mouse");
+        });
+        // Global touch move and end listeners
+        this.addEventListener(document, "touchmove", (e) => {
+            this.handleDragMove(e, "touch");
+        }, { passive: false });
+        this.addEventListener(document, "touchend", (e) => {
+            this.handleDragEnd(e, "touch");
+        });
+        log.trace(`Drag listeners added for selector: ${selector}`, {
+            componentId: this.componentId,
+        });
+    }
+    /**
+     * Hover interaction - mouse enter/leave with touch fallback
+     */
+    hover(selector, callbacks) {
+        // Check if we already have listeners for this selector+method combination
+        const key = `hover:${selector}`;
+        if (this.selectorListeners.has(key)) {
+            log.trace(`Hover listeners already exist for selector: ${selector}, skipping duplicate`, {
+                componentId: this.componentId,
+            });
+            return;
+        }
+        const elements = this.shadowRoot.querySelectorAll(selector);
+        // Store the selector listener mapping
+        this.selectorListeners.set(key, {
+            selector,
+            method: "hover",
+            callback: callbacks,
+            elements: Array.from(elements),
+        });
+        elements.forEach((element) => {
+            this.addEventListenerWithTracking(element, "mouseenter", (e) => {
+                if (callbacks.enter) {
+                    const data = this.createPointerEventData(e, "mouse");
+                    callbacks.enter(data);
+                }
+            }, undefined, selector, "hover");
+            this.addEventListenerWithTracking(element, "mouseleave", (e) => {
+                if (callbacks.leave) {
+                    const data = this.createPointerEventData(e, "mouse");
+                    callbacks.leave(data);
+                }
+            }, undefined, selector, "hover");
+            // Touch fallback - simulate hover with touch
+            this.addEventListenerWithTracking(element, "touchstart", (e) => {
+                if (callbacks.enter) {
+                    const data = this.createPointerEventData(e, "touch");
+                    callbacks.enter(data);
+                }
+            }, { passive: true }, selector, "hover");
+        });
+        log.trace(`Hover listeners added for selector: ${selector}`, {
+            componentId: this.componentId,
+        });
+    }
+    /**
+     * Long press interaction - works for both mouse and touch
+     */
+    longPress(selector, callback, duration = 500) {
+        const elements = this.shadowRoot.querySelectorAll(selector);
+        elements.forEach((element) => {
+            // Mouse long press
+            this.addEventListener(element, "mousedown", (e) => {
+                this.startLongPress(element, e, "mouse", callback, duration);
+            });
+            this.addEventListener(element, "mouseup", () => {
+                this.cancelLongPress(element);
+            });
+            this.addEventListener(element, "mouseleave", () => {
+                this.cancelLongPress(element);
+            });
+            // Touch long press
+            this.addEventListener(element, "touchstart", (e) => {
+                this.startLongPress(element, e, "touch", callback, duration);
+            }, { passive: true });
+            this.addEventListener(element, "touchend", () => {
+                this.cancelLongPress(element);
+            });
+            this.addEventListener(element, "touchcancel", () => {
+                this.cancelLongPress(element);
+            });
+        });
+        log.trace(`Long press listeners added for selector: ${selector}`, {
+            componentId: this.componentId,
+        });
+    }
+    /**
+     * Swipe gesture detection
+     */
+    swipe(selector, callbacks, threshold = 50) {
+        const elements = this.shadowRoot.querySelectorAll(selector);
+        elements.forEach((element) => {
+            // Touch swipe
+            this.addEventListener(element, "touchstart", (e) => {
+                this.startSwipe(element, e, callbacks);
+            }, { passive: true });
+            this.addEventListener(element, "touchend", (e) => {
+                this.endSwipe(element, e, callbacks, threshold);
+            });
+            // Mouse swipe (drag-based)
+            this.addEventListener(element, "mousedown", (e) => {
+                this.startSwipe(element, e, callbacks);
+            });
+            this.addEventListener(document, "mouseup", (e) => {
+                this.endSwipe(element, e, callbacks, threshold);
+            });
+        });
+        log.trace(`Swipe listeners added for selector: ${selector}`, {
+            componentId: this.componentId,
+        });
+    }
+    /**
+     * Add a custom event listener with automatic cleanup
+     */
+    addEventListener(element, type, listener, options) {
+        const finalOptions = {
+            ...options,
+            signal: this.abortController.signal,
+        };
+        element.addEventListener(type, listener, finalOptions);
+        this.eventListeners.push({
+            element: element,
+            type,
+            listener,
+            options: finalOptions,
+        });
+    }
+    /**
+     * Add an event listener with tracking for selector and method
+     */
+    addEventListenerWithTracking(element, type, listener, options, selector, method) {
+        const finalOptions = {
+            ...options,
+            signal: this.abortController.signal,
+        };
+        element.addEventListener(type, listener, finalOptions);
+        this.eventListeners.push({
+            element: element,
+            type,
+            listener,
+            options: finalOptions,
+            selector,
+            method,
+        });
+    }
+    /**
+     * Remove a specific event listener
+     */
+    removeEventListener(element, type, listener) {
+        element.removeEventListener(type, listener);
+        const index = this.eventListeners.findIndex((record) => record.element === element && record.type === type && record.listener === listener);
+        if (index !== -1) {
+            this.eventListeners.splice(index, 1);
+        }
+    }
+    /**
+     * Clean up listeners for a specific selector and method
+     */
+    clearSelectorListeners(selector, method) {
+        const key = `${method}:${selector}`;
+        if (this.selectorListeners.has(key)) {
+            // Remove from tracking
+            this.selectorListeners.delete(key);
+            // Remove actual event listeners for this selector+method
+            this.eventListeners = this.eventListeners.filter((record) => {
+                if (record.selector === selector && record.method === method) {
+                    // Remove the actual event listener
+                    record.element.removeEventListener(record.type, record.listener);
+                    return false; // Remove from array
+                }
+                return true; // Keep in array
+            });
+            log.trace(`Cleared listeners for selector: ${selector}, method: ${method}`, { componentId: this.componentId });
+        }
+    }
+    /**
+     * Clean up all event listeners
+     */
+    destroy() {
+        this.abortController.abort();
+        this.eventListeners.length = 0;
+        this.selectorListeners.clear();
+        this.dragStates.clear();
+        this.swipeStates.clear();
+        // Clear any pending long press timers
+        this.longPressTimers.forEach((timerId) => clearTimeout(timerId));
+        this.longPressTimers.clear();
+        log.trace(`EventManager destroyed for component: ${this.componentId}`);
+    }
+    // Private helper methods
+    createPointerEventData(event, type) {
+        let x, y;
+        if (type === "touch" && "touches" in event) {
+            const touch = event.touches[0] || event.changedTouches[0];
+            x = touch.clientX;
+            y = touch.clientY;
+        }
+        else if ("clientX" in event) {
+            x = event.clientX;
+            y = event.clientY;
+        }
+        else {
+            x = 0;
+            y = 0;
+        }
+        return {
+            x,
+            y,
+            target: event.target,
+            originalEvent: event,
+            type,
+        };
+    }
+    startDrag(element, event, type, callbacks) {
+        const data = this.createPointerEventData(event, type);
+        const dragState = {
+            isDragging: true,
+            startX: data.x,
+            startY: data.y,
+            element,
+            callbacks,
+        };
+        this.dragStates.set(element, dragState);
+        if (callbacks.start) {
+            callbacks.start(data);
+        }
+        event.preventDefault();
+    }
+    handleDragMove(event, type) {
+        this.dragStates.forEach((dragState, _) => {
+            if (dragState.isDragging && dragState.callbacks.move) {
+                const data = this.createPointerEventData(event, type);
+                dragState.callbacks.move(data);
+            }
+        });
+    }
+    handleDragEnd(event, type) {
+        this.dragStates.forEach((dragState, element) => {
+            if (dragState.isDragging) {
+                dragState.isDragging = false;
+                if (dragState.callbacks.end) {
+                    const data = this.createPointerEventData(event, type);
+                    dragState.callbacks.end(data);
+                }
+                this.dragStates.delete(element);
+            }
+        });
+    }
+    movementThresholdMet(startX, startY, endX, endY) {
+        const movementThreshold = 5; // Default movement threshold in pixels
+        const distance = Math.sqrt(Math.pow(endX - startX, 2) + Math.pow(endY - startY, 2));
+        return distance > movementThreshold;
+    }
+    startLongPress(element, event, type, callback, duration) {
+        this.cancelLongPress(element); // Cancel any existing timer
+        const timerId = window.setTimeout(() => {
+            const data = this.createPointerEventData(event, type);
+            callback(data);
+            this.longPressTimers.delete(element);
+        }, duration);
+        this.longPressTimers.set(element, timerId);
+    }
+    cancelLongPress(element) {
+        const timerId = this.longPressTimers.get(element);
+        if (timerId) {
+            clearTimeout(timerId);
+            this.longPressTimers.delete(element);
+        }
+    }
+    startSwipe(element, event, callbacks) {
+        const data = this.createPointerEventData(event, "touch");
+        const swipeState = {
+            startX: data.x,
+            startY: data.y,
+            startTime: Date.now(),
+            element,
+            callbacks,
+        };
+        this.swipeStates.set(element, swipeState);
+    }
+    endSwipe(element, event, callbacks, threshold) {
+        const swipeState = this.swipeStates.get(element);
+        if (!swipeState)
+            return;
+        const data = this.createPointerEventData(event, "touch");
+        const deltaX = data.x - swipeState.startX;
+        const deltaY = data.y - swipeState.startY;
+        const deltaTime = Date.now() - swipeState.startTime;
+        // Only consider it a swipe if it was fast enough (< 300ms) and moved enough
+        if (deltaTime < 300 && (Math.abs(deltaX) > threshold || Math.abs(deltaY) > threshold)) {
+            if (Math.abs(deltaX) > Math.abs(deltaY)) {
+                // Horizontal swipe
+                if (deltaX > 0 && callbacks.right) {
+                    callbacks.right(data);
+                }
+                else if (deltaX < 0 && callbacks.left) {
+                    callbacks.left(data);
+                }
+            }
+            else {
+                // Vertical swipe
+                if (deltaY > 0 && callbacks.down) {
+                    callbacks.down(data);
+                }
+                else if (deltaY < 0 && callbacks.up) {
+                    callbacks.up(data);
+                }
+            }
+        }
+        this.swipeStates.delete(element);
+    }
+}

package/dist/src/garbageCollector.d.ts

@@ -0,0 +1,68 @@
+import type { EventOrchestrator } from "./eventBus";
+import type { AnimationManager } from "./animationBus";
+export interface GarbageCollectionStats {
+    timestamp: number;
+    animationsCleaned: number;
+    expiredEventsCleaned: number;
+    orphanedTransitionsCleaned: number;
+    totalListeners: number;
+    queueSize: number;
+    activeAnimations: number;
+    activeTransitions: number;
+}
+export declare class GarbageCollector {
+    private orchestrator;
+    private animationManager?;
+    private cleanupInterval;
+    private stats;
+    private readonly MAX_STATS_HISTORY;
+    constructor(orchestrator: EventOrchestrator, animationManager?: AnimationManager);
+    /**
+     * Start automatic garbage collection at specified interval
+     * @param intervalMinutes - How often to run cleanup (default: 5 minutes)
+     */
+    startAutoCleanup(intervalMinutes?: number): void;
+    /**
+     * Stop automatic garbage collection
+     */
+    stopAutoCleanup(): void;
+    /**
+     * Manually trigger a garbage collection run
+     */
+    runCleanup(): GarbageCollectionStats;
+    /**
+     * Get statistics from previous cleanup runs
+     */
+    getStats(): GarbageCollectionStats[];
+    /**
+     * Get the most recent cleanup stats
+     */
+    getLatestStats(): GarbageCollectionStats | null;
+    /**
+     * Get a summary report of memory usage trends
+     */
+    getMemoryReport(): {
+        averageAnimations: number;
+        averageListeners: number;
+        averageQueueSize: number;
+        averageTransitions: number;
+        totalCleanups: number;
+        totalItemsCleaned: number;
+    };
+    /**
+     * Clear all stats history
+     */
+    clearStats(): void;
+    /**
+     * Destroy the garbage collector and stop auto cleanup
+     */
+    destroy(): void;
+}
+/**
+ * Create and configure a garbage collector instance
+ *
+ * Note: NavigationManager is automatically retrieved via singleton pattern
+ * when needed during cleanup operations.
+ */
+export declare function createGarbageCollector(orchestrator: EventOrchestrator, animationManager?: AnimationManager, autoStart?: boolean, intervalMinutes?: number): GarbageCollector;
+//# sourceMappingURL=garbageCollector.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"garbageCollector.d.ts","sourceRoot":"","sources":["../../src/garbageCollector.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AACpD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAKvD,MAAM,WAAW,sBAAsB;IACrC,SAAS,EAAE,MAAM,CAAC;IAClB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,oBAAoB,EAAE,MAAM,CAAC;IAC7B,0BAA0B,EAAE,MAAM,CAAC;IACnC,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,gBAAgB,EAAE,MAAM,CAAC;IACzB,iBAAiB,EAAE,MAAM,CAAC;CAC3B;AAED,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,YAAY,CAAoB;IACxC,OAAO,CAAC,gBAAgB,CAAC,CAAmB;IAC5C,OAAO,CAAC,eAAe,CAAuB;IAC9C,OAAO,CAAC,KAAK,CAAgC;IAC7C,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAM;gBAGtC,YAAY,EAAE,iBAAiB,EAC/B,gBAAgB,CAAC,EAAE,gBAAgB;IAMrC;;;OAGG;IACI,gBAAgB,CAAC,eAAe,GAAE,MAAU,GAAG,IAAI;IAiB1D;;OAEG;IACI,eAAe,IAAI,IAAI;IAQ9B;;OAEG;IACI,UAAU,IAAI,sBAAsB;IAqE3C;;OAEG;IACI,QAAQ,IAAI,sBAAsB,EAAE;IAI3C;;OAEG;IACI,cAAc,IAAI,sBAAsB,GAAG,IAAI;IAItD;;OAEG;IACI,eAAe,IAAI;QACxB,iBAAiB,EAAE,MAAM,CAAC;QAC1B,gBAAgB,EAAE,MAAM,CAAC;QACzB,gBAAgB,EAAE,MAAM,CAAC;QACzB,kBAAkB,EAAE,MAAM,CAAC;QAC3B,aAAa,EAAE,MAAM,CAAC;QACtB,iBAAiB,EAAE,MAAM,CAAC;KAC3B;IAiCD;;OAEG;IACI,UAAU,IAAI,IAAI;IAIzB;;OAEG;IACI,OAAO,IAAI,IAAI;CAKvB;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,YAAY,EAAE,iBAAiB,EAC/B,gBAAgB,CAAC,EAAE,gBAAgB,EACnC,SAAS,GAAE,OAAc,EACzB,eAAe,GAAE,MAAU,GAC1B,gBAAgB,CAQlB"}

package/dist/src/garbageCollector.js

@@ -0,0 +1,169 @@
+import { logger } from "./logger";
+import { NavigationManager } from "./navigationManager";
+const log = logger;
+export class GarbageCollector {
+    orchestrator;
+    animationManager;
+    cleanupInterval = null;
+    stats = [];
+    MAX_STATS_HISTORY = 50; // Keep last 50 cleanup runs
+    constructor(orchestrator, animationManager) {
+        this.orchestrator = orchestrator;
+        this.animationManager = animationManager;
+    }
+    /**
+     * Start automatic garbage collection at specified interval
+     * @param intervalMinutes - How often to run cleanup (default: 5 minutes)
+     */
+    startAutoCleanup(intervalMinutes = 5) {
+        if (this.cleanupInterval !== null) {
+            log.warn("Auto cleanup already running");
+            return;
+        }
+        const intervalMs = intervalMinutes * 60 * 1000;
+        log.trace(`Starting automatic garbage collection every ${intervalMinutes} minute(s)`);
+        this.cleanupInterval = window.setInterval(() => {
+            this.runCleanup();
+        }, intervalMs);
+        // Run initial cleanup
+        this.runCleanup();
+    }
+    /**
+     * Stop automatic garbage collection
+     */
+    stopAutoCleanup() {
+        if (this.cleanupInterval !== null) {
+            clearInterval(this.cleanupInterval);
+            this.cleanupInterval = null;
+            log.trace("Automatic garbage collection stopped");
+        }
+    }
+    /**
+     * Manually trigger a garbage collection run
+     */
+    runCleanup() {
+        const startTime = Date.now();
+        log.trace("Running garbage collection...");
+        const stats = {
+            timestamp: startTime,
+            animationsCleaned: 0,
+            expiredEventsCleaned: 0,
+            orphanedTransitionsCleaned: 0,
+            totalListeners: 0,
+            queueSize: 0,
+            activeAnimations: 0,
+            activeTransitions: 0,
+        };
+        // Clean up stale animations
+        if (this.animationManager) {
+            const beforeAnimations = this.animationManager.getActiveAnimationCount();
+            this.animationManager.cleanupStaleAnimations();
+            const afterAnimations = this.animationManager.getActiveAnimationCount();
+            stats.animationsCleaned = beforeAnimations - afterAnimations;
+            stats.activeAnimations = afterAnimations;
+        }
+        // Clean up expired events from queue
+        const expiredEvents = this.orchestrator.cleanupExpiredEvents();
+        stats.expiredEventsCleaned = expiredEvents;
+        stats.queueSize = this.orchestrator.getQueueSize();
+        stats.totalListeners = this.orchestrator.getTotalListenerCount();
+        // Clean up orphaned navigation transitions - get singleton instance
+        const navigationManager = NavigationManager.getInstance();
+        if (navigationManager) {
+            const beforeTransitions = navigationManager.getActiveTransitionCount();
+            navigationManager.cleanupOrphanedTransitions();
+            const afterTransitions = navigationManager.getActiveTransitionCount();
+            stats.orphanedTransitionsCleaned = beforeTransitions - afterTransitions;
+            stats.activeTransitions = afterTransitions;
+        }
+        const duration = Date.now() - startTime;
+        // Log summary
+        const totalCleaned = stats.animationsCleaned + stats.expiredEventsCleaned + stats.orphanedTransitionsCleaned;
+        if (totalCleaned > 0) {
+            log.trace(`Garbage collection complete in ${duration}ms. Cleaned: ${stats.animationsCleaned} animations, ` +
+                `${stats.expiredEventsCleaned} expired events, ${stats.orphanedTransitionsCleaned} transitions. ` +
+                `Active: ${stats.activeAnimations} animations, ${stats.activeTransitions} transitions, ` +
+                `${stats.totalListeners} listeners, queue size: ${stats.queueSize}`);
+        }
+        else {
+            log.trace(`Garbage collection complete in ${duration}ms. Nothing to clean. ` +
+                `Active: ${stats.activeAnimations} animations, ${stats.activeTransitions} transitions, ` +
+                `${stats.totalListeners} listeners, queue size: ${stats.queueSize}`);
+        }
+        // Store stats
+        this.stats.push(stats);
+        if (this.stats.length > this.MAX_STATS_HISTORY) {
+            this.stats.shift(); // Remove oldest
+        }
+        return stats;
+    }
+    /**
+     * Get statistics from previous cleanup runs
+     */
+    getStats() {
+        return [...this.stats];
+    }
+    /**
+     * Get the most recent cleanup stats
+     */
+    getLatestStats() {
+        return this.stats.length > 0 ? this.stats[this.stats.length - 1] : null;
+    }
+    /**
+     * Get a summary report of memory usage trends
+     */
+    getMemoryReport() {
+        if (this.stats.length === 0) {
+            return {
+                averageAnimations: 0,
+                averageListeners: 0,
+                averageQueueSize: 0,
+                averageTransitions: 0,
+                totalCleanups: 0,
+                totalItemsCleaned: 0,
+            };
+        }
+        const sum = this.stats.reduce((acc, stat) => ({
+            animations: acc.animations + stat.activeAnimations,
+            listeners: acc.listeners + stat.totalListeners,
+            queueSize: acc.queueSize + stat.queueSize,
+            transitions: acc.transitions + stat.activeTransitions,
+            cleaned: acc.cleaned + stat.animationsCleaned + stat.expiredEventsCleaned + stat.orphanedTransitionsCleaned,
+        }), { animations: 0, listeners: 0, queueSize: 0, transitions: 0, cleaned: 0 });
+        return {
+            averageAnimations: sum.animations / this.stats.length,
+            averageListeners: sum.listeners / this.stats.length,
+            averageQueueSize: sum.queueSize / this.stats.length,
+            averageTransitions: sum.transitions / this.stats.length,
+            totalCleanups: this.stats.length,
+            totalItemsCleaned: sum.cleaned,
+        };
+    }
+    /**
+     * Clear all stats history
+     */
+    clearStats() {
+        this.stats = [];
+    }
+    /**
+     * Destroy the garbage collector and stop auto cleanup
+     */
+    destroy() {
+        this.stopAutoCleanup();
+        this.clearStats();
+        log.trace("GarbageCollector destroyed");
+    }
+}
+/**
+ * Create and configure a garbage collector instance
+ *
+ * Note: NavigationManager is automatically retrieved via singleton pattern
+ * when needed during cleanup operations.
+ */
+export function createGarbageCollector(orchestrator, animationManager, autoStart = true, intervalMinutes = 5) {
+    const gc = new GarbageCollector(orchestrator, animationManager);
+    if (autoStart) {
+        gc.startAutoCleanup(intervalMinutes);
+    }
+    return gc;
+}