lazy-render-virtual-scroll 1.5.0 → 1.6.0

package/dist/cjs/svelte/core/SmartPrefetchAlgorithm.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Smart Prefetch Algorithm
+ * Recognizes scroll patterns and predicts data loading needs
+ */
+export interface ScrollPattern {
+    type: 'fast-scroll' | 'slow-scroll' | 'paused' | 'oscillating' | 'steady';
+    velocity: number;
+    acceleration: number;
+    direction: 'up' | 'down' | 'stationary';
+    confidence: number;
+}
+export interface PrefetchPrediction {
+    shouldPrefetch: boolean;
+    prefetchDistance: number;
+    batchSize: number;
+    priority: 'low' | 'normal' | 'high' | 'critical';
+    confidence: number;
+}
+export declare class SmartPrefetchAlgorithm {
+    private velocityHistory;
+    private directionHistory;
+    private readonly HISTORY_SIZE;
+    private lastPrefetchTime;
+    private prefetchCooldown;
+    /**
+     * Analyze scroll pattern
+     */
+    analyzeScrollPattern(velocity: number, acceleration: number, direction: 'up' | 'down' | 'stationary'): ScrollPattern;
+    /**
+     * Predict prefetch needs based on scroll pattern
+     */
+    predictPrefetchNeeds(pattern: ScrollPattern, visibleEnd: number, totalLoaded: number): PrefetchPrediction;
+    /**
+     * Track velocity history
+     */
+    private trackVelocity;
+    /**
+     * Track direction history
+     */
+    private trackDirection;
+    /**
+     * Get average velocity
+     */
+    private getAverageVelocity;
+    /**
+     * Get velocity variance
+     */
+    private getVelocityVariance;
+    /**
+     * Count direction changes
+     */
+    private countDirectionChanges;
+    /**
+     * Reset history
+     */
+    reset(): void;
+    /**
+     * Get prediction confidence
+     */
+    getConfidence(): number;
+}
+export default SmartPrefetchAlgorithm;
+//# sourceMappingURL=SmartPrefetchAlgorithm.d.ts.map

package/dist/cjs/svelte/core/SmartPrefetchAlgorithm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SmartPrefetchAlgorithm.d.ts","sourceRoot":"","sources":["../../src/core/SmartPrefetchAlgorithm.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,aAAa,GAAG,aAAa,GAAG,QAAQ,GAAG,aAAa,GAAG,QAAQ,CAAC;IAC1E,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,IAAI,GAAG,MAAM,GAAG,YAAY,CAAC;IACxC,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,kBAAkB;IACjC,cAAc,EAAE,OAAO,CAAC;IACxB,gBAAgB,EAAE,MAAM,CAAC;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,UAAU,CAAC;IACjD,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,qBAAa,sBAAsB;IACjC,OAAO,CAAC,eAAe,CAAgB;IACvC,OAAO,CAAC,gBAAgB,CAAwC;IAChE,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAM;IACnC,OAAO,CAAC,gBAAgB,CAAa;IACrC,OAAO,CAAC,gBAAgB,CAAe;IAEvC;;OAEG;IACH,oBAAoB,CAAC,QAAQ,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,SAAS,EAAE,IAAI,GAAG,MAAM,GAAG,YAAY,GAAG,aAAa;IAwDpH;;OAEG;IACH,oBAAoB,CAAC,OAAO,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,kBAAkB;IAqFzG;;OAEG;IACH,OAAO,CAAC,aAAa;IAOrB;;OAEG;IACH,OAAO,CAAC,cAAc;IAOtB;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAM1B;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAQ3B;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAa7B;;OAEG;IACH,KAAK,IAAI,IAAI;IAMb;;OAEG;IACH,aAAa,IAAI,MAAM;CAIxB;AAED,eAAe,sBAAsB,CAAC"}

package/dist/cjs/svelte/core/VariableHeightManager.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Variable Height Manager
+ * Manages variable height items with efficient position calculations
+ */
+import { VisibleRange } from './types';
+export interface VariableHeightConfig {
+    estimatedHeight: number;
+    minHeight: number;
+    maxHeight: number;
+    bufferSize: number;
+}
+export interface ItemPosition {
+    index: number;
+    offset: number;
+    height: number;
+}
+export declare class VariableHeightManager {
+    private heightCache;
+    private config;
+    private totalItems;
+    private lastMeasuredIndex;
+    constructor(config?: Partial<VariableHeightConfig>);
+    /**
+     * Set total number of items
+     */
+    setTotalItems(total: number): void;
+    /**
+     * Measure item height from DOM element
+     */
+    measureElement(index: number, element: HTMLElement | null): number;
+    /**
+     * Get item position (offset and height)
+     */
+    getItemPosition(index: number): ItemPosition;
+    /**
+     * Calculate visible range for variable heights
+     */
+    calculateVisibleRange(scrollTop: number, viewportHeight: number): VisibleRange;
+    /**
+     * Get total height of all items
+     */
+    getTotalHeight(): number;
+    /**
+     * Scroll to specific item index
+     */
+    scrollToIndex(index: number): number;
+    /**
+     * Get items to render for current viewport
+     */
+    getItemsToRender(scrollTop: number, viewportHeight: number): {
+        items: ItemPosition[];
+        totalHeight: number;
+    };
+    /**
+     * Handle height change (when item height changes dynamically)
+     */
+    onHeightChange(index: number, newHeight: number): void;
+    /**
+     * Get cache statistics
+     */
+    getCacheStats(): import("./HeightMeasurementCache").HeightCacheStats;
+    /**
+     * Clear cache for specific range
+     */
+    clearRange(startIndex: number, endIndex: number): void;
+    /**
+     * Clear entire cache
+     */
+    clearCache(): void;
+    /**
+     * Get last measured index
+     */
+    getLastMeasuredIndex(): number;
+    /**
+     * Check if item is measured
+     */
+    isItemMeasured(index: number): boolean;
+    /**
+     * Get measured items count
+     */
+    getMeasuredCount(): number;
+}
+export default VariableHeightManager;
+//# sourceMappingURL=VariableHeightManager.d.ts.map

package/dist/cjs/svelte/core/VariableHeightManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VariableHeightManager.d.ts","sourceRoot":"","sources":["../../src/core/VariableHeightManager.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAEvC,MAAM,WAAW,oBAAoB;IACnC,eAAe,EAAE,MAAM,CAAC;IACxB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,qBAAa,qBAAqB;IAChC,OAAO,CAAC,WAAW,CAAyB;IAC5C,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,iBAAiB,CAAc;gBAE3B,MAAM,CAAC,EAAE,OAAO,CAAC,oBAAoB,CAAC;IAWlD;;OAEG;IACH,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAIlC;;OAEG;IACH,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,GAAG,IAAI,GAAG,MAAM;IAmBlE;;OAEG;IACH,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,YAAY;IAW5C;;OAEG;IACH,qBAAqB,CAAC,SAAS,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,GAAG,YAAY;IAwB9E;;OAEG;IACH,cAAc,IAAI,MAAM;IAIxB;;OAEG;IACH,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAKpC;;OAEG;IACH,gBAAgB,CACd,SAAS,EAAE,MAAM,EACjB,cAAc,EAAE,MAAM,GACrB;QAAE,KAAK,EAAE,YAAY,EAAE,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE;IAcjD;;OAEG;IACH,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI;IActD;;OAEG;IACH,aAAa;IAIb;;OAEG;IACH,UAAU,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI;IAMtD;;OAEG;IACH,UAAU,IAAI,IAAI;IAKlB;;OAEG;IACH,oBAAoB,IAAI,MAAM;IAI9B;;OAEG;IACH,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAItC;;OAEG;IACH,gBAAgB,IAAI,MAAM;CAG3B;AAED,eAAe,qBAAqB,CAAC"}

package/dist/cjs/svelte/index.d.ts

@@ -12,6 +12,15 @@ export { ContentComplexityAnalyzer } from './core/ContentComplexityAnalyzer';
 export { PerformanceOptimizer } from './core/PerformanceOptimizer';
 export { MemoryManager } from './core/MemoryManager';
 export { GPUAccelerator } from './core/GPUAccelerator';
+export { BatchSizeOptimizer } from './core/BatchSizeOptimizer';
+export { RequestDeduplicator } from './core/RequestDeduplicator';
+export { PriorityRequestQueue, Priority } from './core/PriorityRequestQueue';
+export { HeightMeasurementCache } from './core/HeightMeasurementCache';
+export { VariableHeightManager } from './core/VariableHeightManager';
+export { DynamicHeightEngine } from './core/DynamicHeightEngine';
+export { SmartPrefetchAlgorithm } from './core/SmartPrefetchAlgorithm';
+export { PreemptiveCache } from './core/PreemptiveCache';
+export { IntelligentPagination } from './core/IntelligentPagination';
 export type { EngineConfig, VisibleRange, FetchMoreCallback, EngineState, ScrollAnalysis } from './core/types';
 export { ScrollObserver } from './platform/browser/ScrollObserver';
 export { useLazyList } from './adapters/react/useLazyList';

package/dist/cjs/svelte/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACvC,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACrD,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACzD,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,yBAAyB,EAAE,MAAM,kCAAkC,CAAC;AAC7E,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AACnE,OAAO,EAAE,2BAA2B,EAAE,MAAM,oCAAoC,CAAC;AACjF,OAAO,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAC3E,OAAO,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAC3E,OAAO,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAC3E,OAAO,EAAE,yBAAyB,EAAE,MAAM,kCAAkC,CAAC;AAC7E,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AACnE,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACrD,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,iBAAiB,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAG/G,OAAO,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAC;AAGnE,OAAO,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAC3D,OAAO,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAC;AAGrD,OAAO,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAK7E,cAAM,sBAAsB;;IAE1B,QAAQ,CAAC,KAAK,EAAE,GAAG,EAAE;IACrB,OAAO;IACP,eAAe;;;;IACf,MAAM,CAAC,eAAe;CACvB;AAGD,QAAA,MAAM,iBAAiB,+BAEG,CAAC;AAE3B,OAAO,EAAE,iBAAiB,EAAE,CAAC;AAG7B,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAC5C,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACvC,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACrD,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACzD,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,yBAAyB,EAAE,MAAM,kCAAkC,CAAC;AAC7E,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AACnE,OAAO,EAAE,2BAA2B,EAAE,MAAM,oCAAoC,CAAC;AACjF,OAAO,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAC3E,OAAO,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAC3E,OAAO,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAC3E,OAAO,EAAE,yBAAyB,EAAE,MAAM,kCAAkC,CAAC;AAC7E,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AACnE,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACrD,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAC/D,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,EAAE,oBAAoB,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AAC7E,OAAO,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AACvE,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AACrE,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AACvE,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACzD,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AACrE,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,iBAAiB,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAG/G,OAAO,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAC;AAGnE,OAAO,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAC3D,OAAO,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAC;AAGrD,OAAO,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAK7E,cAAM,sBAAsB;;IAE1B,QAAQ,CAAC,KAAK,EAAE,GAAG,EAAE;IACrB,OAAO;IACP,eAAe;;;;IACf,MAAM,CAAC,eAAe;CACvB;AAGD,QAAA,MAAM,iBAAiB,+BAEG,CAAC;AAE3B,OAAO,EAAE,iBAAiB,EAAE,CAAC;AAG7B,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAC5C,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/cjs/svelte/index.js

@@ -1236,6 +1236,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;
@@ -1254,6 +1628,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,