lazy-render-virtual-scroll 1.4.0 → 1.6.0

package/dist/esm/angular/index.js

@@ -1296,6 +1296,380 @@ class GPUAccelerator {
     }
 }
 
+/**
+ * Batch Size Optimizer
+ * Dynamically adjusts batch size based on scroll speed, network, and performance
+ */
+class BatchSizeOptimizer {
+    constructor(config, networkDetector, performanceMonitor) {
+        this.scrollSpeedHistory = [];
+        this.renderTimeHistory = [];
+        this.HISTORY_SIZE = 10;
+        this.config = {
+            minBatchSize: (config === null || config === void 0 ? void 0 : config.minBatchSize) || 10,
+            maxBatchSize: (config === null || config === void 0 ? void 0 : config.maxBatchSize) || 100,
+            baseBatchSize: (config === null || config === void 0 ? void 0 : config.baseBatchSize) || 50,
+            scrollSpeedThreshold: (config === null || config === void 0 ? void 0 : config.scrollSpeedThreshold) || 1.0
+        };
+        this.currentBatchSize = this.config.baseBatchSize;
+        this.networkDetector = networkDetector || new NetworkSpeedDetector();
+        this.performanceMonitor = performanceMonitor || new DevicePerformanceMonitor();
+    }
+    /**
+     * Calculate optimal batch size based on all factors
+     */
+    async calculateOptimalBatchSize(scrollSpeed) {
+        // Track scroll speed history
+        this.trackScrollSpeed(scrollSpeed);
+        // Get network quality
+        const networkQuality = await this.networkDetector.assessConnectionQuality();
+        // Get performance score
+        const performanceScore = await this.performanceMonitor.assessPerformance();
+        // Calculate batch size based on scroll speed
+        const speedMultiplier = this.calculateSpeedMultiplier(scrollSpeed);
+        // Calculate batch size based on network
+        const networkMultiplier = this.calculateNetworkMultiplier(networkQuality);
+        // Calculate batch size based on performance
+        const performanceMultiplier = this.calculatePerformanceMultiplier(performanceScore);
+        // Calculate final batch size
+        const optimalBatchSize = Math.round(this.config.baseBatchSize * speedMultiplier * networkMultiplier * performanceMultiplier);
+        // Apply min/max bounds
+        this.currentBatchSize = Math.max(this.config.minBatchSize, Math.min(this.config.maxBatchSize, optimalBatchSize));
+        return this.currentBatchSize;
+    }
+    /**
+     * Calculate multiplier based on scroll speed
+     */
+    calculateSpeedMultiplier(scrollSpeed) {
+        const avgScrollSpeed = this.getAverageScrollSpeed();
+        // Fast scrolling = larger batches (preload more)
+        if (Math.abs(avgScrollSpeed) > this.config.scrollSpeedThreshold * 2) {
+            return 1.5; // 50% more items
+        }
+        else if (Math.abs(avgScrollSpeed) > this.config.scrollSpeedThreshold) {
+            return 1.2; // 20% more items
+        }
+        else if (Math.abs(avgScrollSpeed) < 0.3) {
+            return 0.8; // 20% fewer items (user reading carefully)
+        }
+        return 1.0; // Normal batch size
+    }
+    /**
+     * Calculate multiplier based on network quality
+     */
+    calculateNetworkMultiplier(quality) {
+        switch (quality) {
+            case 'excellent':
+                return 1.3; // Load more on fast network
+            case 'good':
+                return 1.1; // Slightly more
+            case 'poor':
+                return 0.6; // Load less on slow network
+            case 'offline':
+                return 0.3; // Minimal loading when offline
+            default:
+                return 1.0;
+        }
+    }
+    /**
+     * Calculate multiplier based on device performance
+     */
+    calculatePerformanceMultiplier(score) {
+        // score is 0-1 (0 = poor, 1 = excellent)
+        if (score > 0.8) {
+            return 1.2; // High-performance device
+        }
+        else if (score > 0.5) {
+            return 1.0; // Average device
+        }
+        else {
+            return 0.7; // Low-performance device
+        }
+    }
+    /**
+     * Track scroll speed for averaging
+     */
+    trackScrollSpeed(speed) {
+        this.scrollSpeedHistory.push(speed);
+        if (this.scrollSpeedHistory.length > this.HISTORY_SIZE) {
+            this.scrollSpeedHistory.shift();
+        }
+    }
+    /**
+     * Get average scroll speed
+     */
+    getAverageScrollSpeed() {
+        if (this.scrollSpeedHistory.length === 0)
+            return 0;
+        const sum = this.scrollSpeedHistory.reduce((a, b) => a + b, 0);
+        return sum / this.scrollSpeedHistory.length;
+    }
+    /**
+     * Track render time for performance monitoring
+     */
+    trackRenderTime(renderTime) {
+        this.renderTimeHistory.push(renderTime);
+        if (this.renderTimeHistory.length > this.HISTORY_SIZE) {
+            this.renderTimeHistory.shift();
+        }
+    }
+    /**
+     * Get average render time
+     */
+    getAverageRenderTime() {
+        if (this.renderTimeHistory.length === 0)
+            return 0;
+        const sum = this.renderTimeHistory.reduce((a, b) => a + b, 0);
+        return sum / this.renderTimeHistory.length;
+    }
+    /**
+     * Get current batch metrics
+     */
+    getMetrics() {
+        return {
+            currentBatchSize: this.currentBatchSize,
+            scrollSpeed: this.getAverageScrollSpeed(),
+            networkQuality: 'good', // Would need to cache this
+            performanceScore: 0.8, // Would need to cache this
+            avgRenderTime: this.getAverageRenderTime()
+        };
+    }
+    /**
+     * Get current batch size
+     */
+    getCurrentBatchSize() {
+        return this.currentBatchSize;
+    }
+    /**
+     * Reset optimizer
+     */
+    reset() {
+        this.scrollSpeedHistory = [];
+        this.renderTimeHistory = [];
+        this.currentBatchSize = this.config.baseBatchSize;
+    }
+    /**
+     * Get optimization statistics
+     */
+    getStats() {
+        return {
+            avgScrollSpeed: this.getAverageScrollSpeed(),
+            avgRenderTime: this.getAverageRenderTime(),
+            currentBatchSize: this.currentBatchSize,
+            totalAdjustments: this.scrollSpeedHistory.length
+        };
+    }
+}
+
+/**
+ * Request Deduplication
+ * Prevents duplicate requests from being sent
+ */
+class RequestDeduplicator {
+    constructor() {
+        this.pendingRequests = new Map();
+        this.requestCount = new Map();
+    }
+    /**
+     * Execute request with deduplication
+     * If same request is already pending, return existing promise
+     */
+    async request(key, requestFn, ttl = 5000 // Time to live in ms
+    ) {
+        // Check if same request is already pending
+        if (this.pendingRequests.has(key)) {
+            console.log(`[RequestDeduplicator] Deduplicating request: ${key}`);
+            return this.pendingRequests.get(key);
+        }
+        // Create new request
+        const promise = requestFn()
+            .then(result => {
+            this.pendingRequests.delete(key);
+            this.requestCount.delete(key);
+            return result;
+        })
+            .catch(error => {
+            this.pendingRequests.delete(key);
+            this.requestCount.delete(key);
+            throw error;
+        });
+        // Store pending request
+        this.pendingRequests.set(key, promise);
+        // Track request count for analytics
+        const count = this.requestCount.get(key) || 0;
+        this.requestCount.set(key, count + 1);
+        // Auto cleanup after TTL
+        setTimeout(() => {
+            if (this.pendingRequests.has(key)) {
+                this.pendingRequests.delete(key);
+            }
+        }, ttl);
+        return promise;
+    }
+    /**
+     * Clear specific request
+     */
+    clear(key) {
+        this.pendingRequests.delete(key);
+        this.requestCount.delete(key);
+    }
+    /**
+     * Clear all requests
+     */
+    clearAll() {
+        this.pendingRequests.clear();
+        this.requestCount.clear();
+    }
+    /**
+     * Get pending request count
+     */
+    getPendingCount() {
+        return this.pendingRequests.size;
+    }
+    /**
+     * Get request statistics
+     */
+    getStats() {
+        const totalRequests = Array.from(this.requestCount.values()).reduce((a, b) => a + b, 0);
+        const deduplicated = totalRequests - this.pendingRequests.size;
+        return {
+            pending: this.pendingRequests.size,
+            totalRequests,
+            deduplicationRate: totalRequests > 0 ? deduplicated / totalRequests : 0
+        };
+    }
+}
+
+/**
+ * Priority-based Request Queue
+ * Processes high-priority requests first
+ */
+var Priority;
+(function (Priority) {
+    Priority[Priority["LOW"] = 0] = "LOW";
+    Priority[Priority["NORMAL"] = 1] = "NORMAL";
+    Priority[Priority["HIGH"] = 2] = "HIGH";
+    Priority[Priority["CRITICAL"] = 3] = "CRITICAL";
+})(Priority || (Priority = {}));
+class PriorityRequestQueue {
+    constructor(maxConcurrent = 2) {
+        this.queues = new Map();
+        this.processing = false;
+        this.maxConcurrent = 2;
+        this.activeRequests = 0;
+        this.maxConcurrent = maxConcurrent;
+        // Initialize priority queues
+        Object.values(Priority).forEach(priority => {
+            if (typeof priority === 'number') {
+                this.queues.set(priority, []);
+            }
+        });
+    }
+    /**
+     * Add request with priority
+     */
+    add(requestFn, priority = Priority.NORMAL) {
+        return new Promise((resolve, reject) => {
+            const request = {
+                priority,
+                requestFn: () => requestFn(),
+                resolve,
+                reject,
+                timestamp: Date.now()
+            };
+            // Add to appropriate priority queue
+            const queue = this.queues.get(priority) || [];
+            queue.push(request);
+            this.queues.set(priority, queue);
+            // Start processing if not already processing
+            if (!this.processing) {
+                this.processQueue();
+            }
+        });
+    }
+    /**
+     * Process queue by priority
+     */
+    async processQueue() {
+        if (this.processing)
+            return;
+        this.processing = true;
+        while (this.hasPendingRequests() && this.activeRequests < this.maxConcurrent) {
+            // Get highest priority request
+            const request = this.getNextRequest();
+            if (!request)
+                break;
+            this.activeRequests++;
+            // Execute request
+            request.requestFn()
+                .then(request.resolve)
+                .catch(request.reject)
+                .finally(() => {
+                this.activeRequests--;
+                this.processQueue();
+            });
+        }
+        this.processing = false;
+    }
+    /**
+     * Get next request by priority
+     */
+    getNextRequest() {
+        // Process from highest priority to lowest
+        for (let priority = Priority.CRITICAL; priority >= Priority.LOW; priority--) {
+            const queue = this.queues.get(priority);
+            if (queue && queue.length > 0) {
+                return queue.shift() || null;
+            }
+        }
+        return null;
+    }
+    /**
+     * Check if there are pending requests
+     */
+    hasPendingRequests() {
+        for (const queue of this.queues.values()) {
+            if (queue.length > 0)
+                return true;
+        }
+        return false;
+    }
+    /**
+     * Get queue statistics
+     */
+    getStats() {
+        var _a, _b, _c, _d;
+        const byPriority = {
+            critical: ((_a = this.queues.get(Priority.CRITICAL)) === null || _a === void 0 ? void 0 : _a.length) || 0,
+            high: ((_b = this.queues.get(Priority.HIGH)) === null || _b === void 0 ? void 0 : _b.length) || 0,
+            normal: ((_c = this.queues.get(Priority.NORMAL)) === null || _c === void 0 ? void 0 : _c.length) || 0,
+            low: ((_d = this.queues.get(Priority.LOW)) === null || _d === void 0 ? void 0 : _d.length) || 0
+        };
+        return {
+            totalPending: Object.values(byPriority).reduce((a, b) => a + b, 0),
+            byPriority,
+            activeRequests: this.activeRequests
+        };
+    }
+    /**
+     * Clear all queues
+     */
+    clear() {
+        this.queues.forEach(queue => queue.length = 0);
+        this.processing = false;
+        this.activeRequests = 0;
+    }
+    /**
+     * Clear specific priority queue
+     */
+    clearPriority(priority) {
+        const queue = this.queues.get(priority);
+        if (queue) {
+            queue.length = 0;
+        }
+    }
+}
+
 class Engine {
     constructor(config) {
         this.fetchMoreCallback = null;
@@ -1314,6 +1688,9 @@ class Engine {
         this.performanceOptimizer = new PerformanceOptimizer();
         this.memoryManager = new MemoryManager(1000); // Cache up to 1000 items
         this.gpuAccelerator = new GPUAccelerator();
+        this.batchSizeOptimizer = new BatchSizeOptimizer();
+        this.requestDeduplicator = new RequestDeduplicator();
+        this.priorityRequestQueue = new PriorityRequestQueue(2);
         this.totalItems = this.config.totalItems || Number.MAX_SAFE_INTEGER;
         this.state = {
             scrollTop: 0,