lazy-render-virtual-scroll 1.4.0 → 1.6.0

package/dist/esm/adapters/react/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,
@@ -1514,5 +1891,1360 @@ const LazyList = forwardRef((props, ref) => {
 });
 LazyList.displayName = 'LazyList';
 
-export { LazyList, useLazyList };
+/**
+ * Smart Prefetch Algorithm
+ * Recognizes scroll patterns and predicts data loading needs
+ */
+class SmartPrefetchAlgorithm {
+    constructor() {
+        this.velocityHistory = [];
+        this.directionHistory = [];
+        this.HISTORY_SIZE = 20;
+        this.lastPrefetchTime = 0;
+        this.prefetchCooldown = 500; // ms
+    }
+    /**
+     * Analyze scroll pattern
+     */
+    analyzeScrollPattern(velocity, acceleration, direction) {
+        this.trackVelocity(velocity);
+        this.trackDirection(direction);
+        const avgVelocity = this.getAverageVelocity();
+        const velocityVariance = this.getVelocityVariance();
+        const directionChanges = this.countDirectionChanges();
+        // Determine pattern type
+        let pattern;
+        if (Math.abs(avgVelocity) > 2.0) {
+            pattern = {
+                type: 'fast-scroll',
+                velocity: avgVelocity,
+                acceleration,
+                direction,
+                confidence: 0.9
+            };
+        }
+        else if (Math.abs(avgVelocity) < 0.3) {
+            pattern = {
+                type: 'paused',
+                velocity: avgVelocity,
+                acceleration,
+                direction: 'stationary',
+                confidence: 0.95
+            };
+        }
+        else if (directionChanges > 5) {
+            pattern = {
+                type: 'oscillating',
+                velocity: avgVelocity,
+                acceleration,
+                direction,
+                confidence: 0.85
+            };
+        }
+        else if (velocityVariance < 0.5) {
+            pattern = {
+                type: 'steady',
+                velocity: avgVelocity,
+                acceleration,
+                direction,
+                confidence: 0.9
+            };
+        }
+        else {
+            pattern = {
+                type: 'slow-scroll',
+                velocity: avgVelocity,
+                acceleration,
+                direction,
+                confidence: 0.8
+            };
+        }
+        return pattern;
+    }
+    /**
+     * Predict prefetch needs based on scroll pattern
+     */
+    predictPrefetchNeeds(pattern, visibleEnd, totalLoaded) {
+        const now = Date.now();
+        // Check cooldown
+        if (now - this.lastPrefetchTime < this.prefetchCooldown) {
+            return {
+                shouldPrefetch: false,
+                prefetchDistance: 0,
+                batchSize: 0,
+                priority: 'low',
+                confidence: 1.0
+            };
+        }
+        let prediction;
+        switch (pattern.type) {
+            case 'fast-scroll':
+                prediction = {
+                    shouldPrefetch: true,
+                    prefetchDistance: 1500, // Far ahead for fast scrolling
+                    batchSize: 30, // Large batch
+                    priority: 'critical',
+                    confidence: pattern.confidence
+                };
+                break;
+            case 'steady':
+                prediction = {
+                    shouldPrefetch: visibleEnd >= totalLoaded - 800,
+                    prefetchDistance: 800,
+                    batchSize: 20,
+                    priority: 'high',
+                    confidence: pattern.confidence
+                };
+                break;
+            case 'slow-scroll':
+                prediction = {
+                    shouldPrefetch: visibleEnd >= totalLoaded - 400,
+                    prefetchDistance: 400,
+                    batchSize: 10,
+                    priority: 'normal',
+                    confidence: pattern.confidence
+                };
+                break;
+            case 'oscillating':
+                prediction = {
+                    shouldPrefetch: visibleEnd >= totalLoaded - 600,
+                    prefetchDistance: 600,
+                    batchSize: 15,
+                    priority: 'normal',
+                    confidence: pattern.confidence * 0.8 // Lower confidence for oscillating
+                };
+                break;
+            case 'paused':
+                prediction = {
+                    shouldPrefetch: false, // User paused, no need to prefetch
+                    prefetchDistance: 0,
+                    batchSize: 0,
+                    priority: 'low',
+                    confidence: pattern.confidence
+                };
+                break;
+            default:
+                prediction = {
+                    shouldPrefetch: visibleEnd >= totalLoaded - 500,
+                    prefetchDistance: 500,
+                    batchSize: 15,
+                    priority: 'normal',
+                    confidence: 0.7
+                };
+        }
+        // Update last prefetch time if prefetching
+        if (prediction.shouldPrefetch) {
+            this.lastPrefetchTime = now;
+        }
+        return prediction;
+    }
+    /**
+     * Track velocity history
+     */
+    trackVelocity(velocity) {
+        this.velocityHistory.push(velocity);
+        if (this.velocityHistory.length > this.HISTORY_SIZE) {
+            this.velocityHistory.shift();
+        }
+    }
+    /**
+     * Track direction history
+     */
+    trackDirection(direction) {
+        this.directionHistory.push(direction);
+        if (this.directionHistory.length > this.HISTORY_SIZE) {
+            this.directionHistory.shift();
+        }
+    }
+    /**
+     * Get average velocity
+     */
+    getAverageVelocity() {
+        if (this.velocityHistory.length === 0)
+            return 0;
+        const sum = this.velocityHistory.reduce((a, b) => a + b, 0);
+        return sum / this.velocityHistory.length;
+    }
+    /**
+     * Get velocity variance
+     */
+    getVelocityVariance() {
+        if (this.velocityHistory.length < 2)
+            return 0;
+        const avg = this.getAverageVelocity();
+        const squaredDiffs = this.velocityHistory.map(v => Math.pow(v - avg, 2));
+        const avgSquaredDiff = squaredDiffs.reduce((a, b) => a + b, 0) / squaredDiffs.length;
+        return Math.sqrt(avgSquaredDiff);
+    }
+    /**
+     * Count direction changes
+     */
+    countDirectionChanges() {
+        if (this.directionHistory.length < 2)
+            return 0;
+        let changes = 0;
+        for (let i = 1; i < this.directionHistory.length; i++) {
+            if (this.directionHistory[i] !== this.directionHistory[i - 1] &&
+                this.directionHistory[i] !== 'stationary' &&
+                this.directionHistory[i - 1] !== 'stationary') {
+                changes++;
+            }
+        }
+        return changes;
+    }
+    /**
+     * Reset history
+     */
+    reset() {
+        this.velocityHistory = [];
+        this.directionHistory = [];
+        this.lastPrefetchTime = 0;
+    }
+    /**
+     * Get prediction confidence
+     */
+    getConfidence() {
+        if (this.velocityHistory.length < 5)
+            return 0.5; // Not enough data
+        return Math.min(this.velocityHistory.length / this.HISTORY_SIZE, 1.0);
+    }
+}
+
+/**
+ * Preemptive Caching
+ * Caches data before it's needed based on predictions
+ */
+class PreemptiveCache {
+    constructor(config) {
+        this.cache = new Map();
+        this.accessHistory = [];
+        this.config = {
+            maxSize: (config === null || config === void 0 ? void 0 : config.maxSize) || 1000,
+            defaultTTL: (config === null || config === void 0 ? void 0 : config.defaultTTL) || 300000, // 5 minutes
+            cleanupThreshold: (config === null || config === void 0 ? void 0 : config.cleanupThreshold) || 800
+        };
+    }
+    /**
+     * Preemptively cache data with priority
+     */
+    preemptiveCache(index, data, priority = 'normal') {
+        // Check if we need to cleanup
+        if (this.cache.size >= this.config.cleanupThreshold) {
+            this.cleanup();
+        }
+        const entry = {
+            data,
+            timestamp: Date.now(),
+            priority,
+            accessCount: 0,
+            expiry: Date.now() + this.config.defaultTTL
+        };
+        this.cache.set(index, entry);
+    }
+    /**
+     * Get cached data
+     */
+    get(index) {
+        const entry = this.cache.get(index);
+        if (!entry) {
+            return null;
+        }
+        // Check expiry
+        if (Date.now() > entry.expiry) {
+            this.cache.delete(index);
+            return null;
+        }
+        // Update access count
+        entry.accessCount++;
+        this.trackAccess(index);
+        return entry.data;
+    }
+    /**
+     * Check if data is cached
+     */
+    has(index) {
+        const entry = this.cache.get(index);
+        if (!entry)
+            return false;
+        // Check expiry
+        if (Date.now() > entry.expiry) {
+            this.cache.delete(index);
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Get cached data for range
+     */
+    getRange(startIndex, endIndex) {
+        const results = [];
+        for (let i = startIndex; i <= endIndex; i++) {
+            const data = this.get(i);
+            if (data !== null) {
+                results.push(data);
+            }
+        }
+        return results;
+    }
+    /**
+     * Delete cached data
+     */
+    delete(index) {
+        return this.cache.delete(index);
+    }
+    /**
+     * Clear cache
+     */
+    clear() {
+        this.cache.clear();
+        this.accessHistory = [];
+    }
+    /**
+     * Cleanup old/low-priority entries
+     */
+    cleanup() {
+        const now = Date.now();
+        const toDelete = [];
+        // First pass: remove expired entries
+        this.cache.forEach((entry, index) => {
+            if (now > entry.expiry) {
+                toDelete.push(index);
+            }
+        });
+        // Second pass: remove low-priority entries if still over limit
+        if (this.cache.size - toDelete.length > this.config.maxSize) {
+            const sortedByPriority = Array.from(this.cache.entries())
+                .filter(([index]) => !toDelete.includes(index))
+                .sort((a, b) => {
+                const priorityOrder = { critical: 4, high: 3, normal: 2, low: 1 };
+                return priorityOrder[a[1].priority] - priorityOrder[b[1].priority];
+            });
+            // Remove lowest priority entries
+            const toRemove = Math.ceil(sortedByPriority.length * 0.2); // Remove 20%
+            for (let i = 0; i < toRemove; i++) {
+                toDelete.push(sortedByPriority[i][0]);
+            }
+        }
+        // Delete marked entries
+        toDelete.forEach(index => this.cache.delete(index));
+    }
+    /**
+     * Track access for analytics
+     */
+    trackAccess(index) {
+        this.accessHistory.push(index);
+        if (this.accessHistory.length > 100) {
+            this.accessHistory.shift();
+        }
+    }
+    /**
+     * Get cache statistics
+     */
+    getStats() {
+        const byPriority = {
+            critical: 0,
+            high: 0,
+            normal: 0,
+            low: 0
+        };
+        let totalAccessCount = 0;
+        this.cache.forEach(entry => {
+            byPriority[entry.priority]++;
+            totalAccessCount += entry.accessCount;
+        });
+        return {
+            size: this.cache.size,
+            maxSize: this.config.maxSize,
+            hitRate: this.accessHistory.length > 0 ?
+                this.accessHistory.filter(i => this.has(i)).length / this.accessHistory.length : 0,
+            avgAccessCount: this.cache.size > 0 ? totalAccessCount / this.cache.size : 0,
+            byPriority
+        };
+    }
+    /**
+     * Get all cached indices
+     */
+    getCachedIndices() {
+        return Array.from(this.cache.keys());
+    }
+    /**
+     * Preemptively cache range
+     */
+    cacheRange(startIndex, endIndex, dataFetcher, priority) {
+        for (let i = startIndex; i <= endIndex; i++) {
+            if (!this.has(i)) {
+                const data = dataFetcher(i);
+                this.preemptiveCache(i, data, priority);
+            }
+        }
+    }
+    /**
+     * Get memory usage estimate
+     */
+    getMemoryUsage() {
+        // Rough estimate based on cache size
+        return this.cache.size * 1024; // Assume ~1KB per entry
+    }
+}
+
+/**
+ * Intelligent Pagination
+ * Adaptive page size with cursor-based pagination
+ */
+class IntelligentPagination {
+    constructor() {
+        this.currentPage = 1;
+        this.basePageSize = 50;
+        this.adaptivePageSize = 50;
+        this.totalItems = 0;
+        this.loadHistory = [];
+        this.MIN_PAGE_SIZE = 20;
+        this.MAX_PAGE_SIZE = 200;
+    }
+    /**
+     * Get current pagination state
+     */
+    getState() {
+        const totalPages = Math.ceil(this.totalItems / this.adaptivePageSize);
+        const hasMore = this.currentPage < totalPages;
+        return {
+            currentPage: this.currentPage,
+            pageSize: this.adaptivePageSize,
+            totalItems: this.totalItems,
+            totalPages,
+            hasMore,
+            cursor: this.createCursor(this.currentPage),
+            nextCursor: hasMore ? this.createCursor(this.currentPage + 1) : undefined,
+            prevCursor: this.currentPage > 1 ? this.createCursor(this.currentPage - 1) : undefined
+        };
+    }
+    /**
+     * Set total items
+     */
+    setTotalItems(total) {
+        this.totalItems = total;
+    }
+    /**
+     * Go to next page
+     */
+    nextPage() {
+        const state = this.getState();
+        if (state.hasMore) {
+            this.currentPage++;
+        }
+        return this.getState();
+    }
+    /**
+     * Go to previous page
+     */
+    prevPage() {
+        if (this.currentPage > 1) {
+            this.currentPage--;
+        }
+        return this.getState();
+    }
+    /**
+     * Go to specific page
+     */
+    goToPage(page) {
+        const totalPages = Math.ceil(this.totalItems / this.adaptivePageSize);
+        this.currentPage = Math.max(1, Math.min(page, totalPages));
+        return this.getState();
+    }
+    /**
+     * Record load time for adaptive sizing
+     */
+    recordLoadTime(page, loadTimeMs) {
+        this.loadHistory.push({ page, loadTime: loadTimeMs });
+        // Keep last 10 load times
+        if (this.loadHistory.length > 10) {
+            this.loadHistory.shift();
+        }
+        // Adjust page size based on load time
+        this.adaptPageSize();
+    }
+    /**
+     * Adapt page size based on performance
+     */
+    adaptPageSize() {
+        if (this.loadHistory.length < 3)
+            return;
+        const avgLoadTime = this.loadHistory.reduce((a, b) => a.loadTime + b.loadTime, 0) / this.loadHistory.length;
+        // Target: 100-300ms load time
+        if (avgLoadTime < 100) {
+            // Fast loads - increase page size
+            this.adaptivePageSize = Math.min(this.MAX_PAGE_SIZE, Math.round(this.adaptivePageSize * 1.2));
+        }
+        else if (avgLoadTime > 300) {
+            // Slow loads - decrease page size
+            this.adaptivePageSize = Math.max(this.MIN_PAGE_SIZE, Math.round(this.adaptivePageSize * 0.8));
+        }
+        // Optimal load time - keep current size
+    }
+    /**
+     * Create cursor for page
+     */
+    createCursor(page) {
+        const cursorData = {
+            page,
+            limit: this.adaptivePageSize,
+            timestamp: Date.now()
+        };
+        // Add checksum for validation
+        cursorData.checksum = this.calculateChecksum(cursorData);
+        return Buffer.from(JSON.stringify(cursorData)).toString('base64');
+    }
+    /**
+     * Decode cursor
+     */
+    decodeCursor(cursor) {
+        try {
+            const decoded = JSON.parse(Buffer.from(cursor, 'base64').toString('utf-8'));
+            // Validate checksum
+            if (decoded.checksum && !this.validateChecksum(decoded)) {
+                return null;
+            }
+            return decoded;
+        }
+        catch (_a) {
+            return null;
+        }
+    }
+    /**
+     * Go to page from cursor
+     */
+    goToCursor(cursor) {
+        const decoded = this.decodeCursor(cursor);
+        if (decoded) {
+            this.currentPage = decoded.page;
+            this.adaptivePageSize = decoded.limit;
+        }
+        return this.getState();
+    }
+    /**
+     * Calculate checksum for cursor validation
+     */
+    calculateChecksum(data) {
+        const str = `${data.page}-${data.limit}-${data.timestamp}`;
+        let hash = 0;
+        for (let i = 0; i < str.length; i++) {
+            const char = str.charCodeAt(i);
+            hash = ((hash << 5) - hash) + char;
+            hash = hash & hash; // Convert to 32-bit integer
+        }
+        return hash.toString(36);
+    }
+    /**
+     * Validate cursor checksum
+     */
+    validateChecksum(data) {
+        if (!data.checksum)
+            return false;
+        const { checksum, ...rest } = data;
+        return this.calculateChecksum(rest) === checksum;
+    }
+    /**
+     * Get items to fetch for current page
+     */
+    getFetchRange() {
+        return {
+            skip: (this.currentPage - 1) * this.adaptivePageSize,
+            limit: this.adaptivePageSize
+        };
+    }
+    /**
+     * Reset pagination
+     */
+    reset() {
+        this.currentPage = 1;
+        this.adaptivePageSize = this.basePageSize;
+        this.loadHistory = [];
+    }
+    /**
+     * Get load history for analytics
+     */
+    getLoadHistory() {
+        return [...this.loadHistory];
+    }
+    /**
+     * Get average load time
+     */
+    getAverageLoadTime() {
+        if (this.loadHistory.length === 0)
+            return 0;
+        return this.loadHistory.reduce((a, b) => a + b.loadTime, 0) / this.loadHistory.length;
+    }
+    /**
+     * Set base page size
+     */
+    setBasePageSize(size) {
+        this.basePageSize = Math.max(this.MIN_PAGE_SIZE, Math.min(this.MAX_PAGE_SIZE, size));
+        this.adaptivePageSize = this.basePageSize;
+    }
+    /**
+     * Get current page size
+     */
+    getPageSize() {
+        return this.adaptivePageSize;
+    }
+    /**
+     * Get current page number
+     */
+    getCurrentPage() {
+        return this.currentPage;
+    }
+}
+
+const useIntelligentScroll = (config) => {
+    const { itemHeight = 50, viewportHeight = 400, bufferSize = 5, fetchMore, enablePrefetch = true, enableCache = true, cacheSize = 1000 } = config;
+    const engineRef = useRef(null);
+    const prefetchAlgoRef = useRef(null);
+    const cacheRef = useRef(null);
+    const paginationRef = useRef(null);
+    const containerRef = useRef(null);
+    const [state, setState] = useState({
+        visibleRange: { start: 0, end: 0 },
+        isLoading: false,
+        scrollVelocity: 0,
+        scrollDirection: 'stationary',
+        scrollPattern: 'paused',
+        prefetchConfidence: 0,
+        cacheHitRate: 0,
+        totalItems: 0
+    });
+    // Initialize intelligent scroll system
+    useEffect(() => {
+        engineRef.current = new Engine({
+            itemHeight,
+            viewportHeight,
+            bufferSize
+        });
+        engineRef.current.setFetchMoreCallback(fetchMore);
+        prefetchAlgoRef.current = new SmartPrefetchAlgorithm();
+        if (enableCache) {
+            cacheRef.current = new PreemptiveCache({ maxSize: cacheSize });
+        }
+        paginationRef.current = new IntelligentPagination();
+        return () => {
+            if (engineRef.current) {
+                engineRef.current.cleanup();
+            }
+            if (cacheRef.current) {
+                cacheRef.current.clear();
+            }
+        };
+    }, []);
+    // Handle scroll events with intelligent analysis
+    const handleScroll = useCallback((scrollTop) => {
+        if (!engineRef.current || !prefetchAlgoRef.current)
+            return;
+        // Update engine
+        engineRef.current.updateScrollPosition(scrollTop);
+        const engineState = engineRef.current.getState();
+        // Analyze scroll pattern
+        const velocity = scrollTop - (engineState.scrollTop || 0);
+        const direction = velocity > 0 ? 'down' : velocity < 0 ? 'up' : 'stationary';
+        const pattern = prefetchAlgoRef.current.analyzeScrollPattern(velocity, 0, // acceleration (would need more tracking)
+        direction);
+        // Update cache stats
+        let cacheHitRate = 0;
+        if (cacheRef.current) {
+            const stats = cacheRef.current.getStats();
+            cacheHitRate = stats.hitRate;
+        }
+        // Update state
+        setState(prev => ({
+            ...prev,
+            visibleRange: engineState.visibleRange,
+            isLoading: engineState.isLoading,
+            scrollVelocity: velocity,
+            scrollDirection: direction,
+            scrollPattern: pattern.type,
+            prefetchConfidence: pattern.confidence,
+            cacheHitRate
+        }));
+        // Predict and prefetch if needed
+        if (enablePrefetch && prefetchAlgoRef.current) {
+            const prediction = prefetchAlgoRef.current.predictPrefetchNeeds(pattern, engineState.visibleRange.end, engineState.loadedItems);
+            if (prediction.shouldPrefetch && cacheRef.current) {
+                // Preemptive caching would happen here
+                console.log('Prefetching with priority:', prediction.priority);
+            }
+        }
+    }, [enablePrefetch]);
+    // Set container reference
+    const setContainerRef = useCallback((element) => {
+        containerRef.current = element;
+        if (element) {
+            const scrollHandler = () => {
+                handleScroll(element.scrollTop);
+            };
+            element.addEventListener('scroll', scrollHandler, { passive: true });
+            return () => {
+                element.removeEventListener('scroll', scrollHandler);
+            };
+        }
+    }, [handleScroll]);
+    // Get cached data
+    const getCachedData = useCallback((index) => {
+        if (cacheRef.current) {
+            return cacheRef.current.get(index);
+        }
+        return null;
+    }, []);
+    // Cache data
+    const cacheData = useCallback((index, data, priority = 'normal') => {
+        if (cacheRef.current) {
+            cacheRef.current.preemptiveCache(index, data, priority);
+        }
+    }, []);
+    // Get pagination state
+    const getPaginationState = useCallback(() => {
+        if (paginationRef.current) {
+            return paginationRef.current.getState();
+        }
+        return null;
+    }, []);
+    return {
+        visibleRange: state.visibleRange,
+        isLoading: state.isLoading,
+        scrollVelocity: state.scrollVelocity,
+        scrollDirection: state.scrollDirection,
+        scrollPattern: state.scrollPattern,
+        prefetchConfidence: state.prefetchConfidence,
+        cacheHitRate: state.cacheHitRate,
+        totalItems: state.totalItems,
+        setContainerRef,
+        getCachedData,
+        cacheData,
+        getPaginationState,
+        refresh: () => {
+            if (containerRef.current) {
+                handleScroll(containerRef.current.scrollTop);
+            }
+        }
+    };
+};
+
+const useAdaptiveLoading = (config) => {
+    const { initialBatchSize = 50, minBatchSize = 20, maxBatchSize = 200, fetchMore, enableNetworkAdaptation = true, enablePerformanceAdaptation = true } = config;
+    const batchSizeOptimizerRef = useRef(null);
+    const networkDetectorRef = useRef(null);
+    const performanceMonitorRef = useRef(null);
+    const [state, setState] = useState({
+        currentBatchSize: initialBatchSize,
+        networkQuality: 'good',
+        performanceScore: 0.8,
+        isLoading: false,
+        loadedItems: 0,
+        avgLoadTime: 0,
+        adaptationCount: 0
+    });
+    const loadTimeHistoryRef = useRef([]);
+    // Initialize adaptive loading system
+    useEffect(() => {
+        if (enableNetworkAdaptation) {
+            networkDetectorRef.current = new NetworkSpeedDetector();
+        }
+        if (enablePerformanceAdaptation) {
+            performanceMonitorRef.current = new DevicePerformanceMonitor();
+        }
+        batchSizeOptimizerRef.current = new BatchSizeOptimizer({
+            minBatchSize,
+            maxBatchSize,
+            baseBatchSize: initialBatchSize
+        });
+        return () => {
+            batchSizeOptimizerRef.current = null;
+            networkDetectorRef.current = null;
+            performanceMonitorRef.current = null;
+        };
+    }, []);
+    // Load data with adaptive batch size
+    const loadMore = useCallback(async () => {
+        if (!batchSizeOptimizerRef.current || state.isLoading)
+            return [];
+        const startTime = performance.now();
+        setState(prev => ({ ...prev, isLoading: true }));
+        try {
+            // Calculate optimal batch size
+            let optimalBatchSize = state.currentBatchSize;
+            if (enableNetworkAdaptation && networkDetectorRef.current) {
+                const networkQuality = await networkDetectorRef.current.assessConnectionQuality();
+                setState(prev => ({ ...prev, networkQuality }));
+            }
+            if (enablePerformanceAdaptation && performanceMonitorRef.current) {
+                const perfScore = await performanceMonitorRef.current.assessPerformance();
+                setState(prev => ({ ...prev, performanceScore: perfScore }));
+            }
+            // Get optimized batch size
+            optimalBatchSize = await batchSizeOptimizerRef.current.calculateOptimalBatchSize(state.loadedItems / 1000 // Rough scroll speed estimate
+            );
+            // Fetch data
+            const newData = await fetchMore();
+            const loadTime = performance.now() - startTime;
+            loadTimeHistoryRef.current.push(loadTime);
+            // Keep last 10 load times
+            if (loadTimeHistoryRef.current.length > 10) {
+                loadTimeHistoryRef.current.shift();
+            }
+            const avgLoadTime = loadTimeHistoryRef.current.reduce((a, b) => a + b, 0) / loadTimeHistoryRef.current.length;
+            // Record load time for future optimization
+            batchSizeOptimizerRef.current.trackRenderTime(loadTime);
+            setState(prev => ({
+                ...prev,
+                isLoading: false,
+                loadedItems: prev.loadedItems + newData.length,
+                avgLoadTime,
+                adaptationCount: prev.adaptationCount + 1
+            }));
+            return newData;
+        }
+        catch (error) {
+            console.error('Adaptive loading error:', error);
+            setState(prev => ({ ...prev, isLoading: false }));
+            return [];
+        }
+    }, [state.isLoading, state.currentBatchSize, state.loadedItems, enableNetworkAdaptation, enablePerformanceAdaptation]);
+    // Get current batch size
+    const getCurrentBatchSize = useCallback(() => {
+        if (batchSizeOptimizerRef.current) {
+            return batchSizeOptimizerRef.current.getCurrentBatchSize();
+        }
+        return state.currentBatchSize;
+    }, [state.currentBatchSize]);
+    // Get loading statistics
+    const getStats = useCallback(() => {
+        return {
+            currentBatchSize: state.currentBatchSize,
+            networkQuality: state.networkQuality,
+            performanceScore: state.performanceScore,
+            avgLoadTime: state.avgLoadTime,
+            adaptationCount: state.adaptationCount,
+            loadedItems: state.loadedItems
+        };
+    }, [state]);
+    // Reset adaptive loading
+    const reset = useCallback(() => {
+        loadTimeHistoryRef.current = [];
+        setState(prev => ({
+            ...prev,
+            currentBatchSize: initialBatchSize,
+            loadedItems: 0,
+            avgLoadTime: 0,
+            adaptationCount: 0
+        }));
+        if (batchSizeOptimizerRef.current) {
+            batchSizeOptimizerRef.current.reset();
+        }
+    }, [initialBatchSize]);
+    return {
+        ...state,
+        loadMore,
+        getCurrentBatchSize,
+        getStats,
+        reset
+    };
+};
+
+const useSmartPagination = (config = {}) => {
+    const { initialPage = 1, initialPageSize = 50, minPageSize = 20, maxPageSize = 200, enableAdaptation = true } = config;
+    const paginationRef = useRef(null);
+    const [state, setState] = useState({
+        currentPage: initialPage,
+        pageSize: initialPageSize,
+        totalItems: 0,
+        totalPages: 0,
+        hasMore: false,
+        cursor: undefined,
+        nextCursor: undefined,
+        prevCursor: undefined,
+        avgLoadTime: 0,
+        isAdapting: false
+    });
+    const loadTimeHistoryRef = useRef([]);
+    // Initialize pagination
+    useEffect(() => {
+        paginationRef.current = new IntelligentPagination();
+        if (initialPageSize) {
+            paginationRef.current.setBasePageSize(initialPageSize);
+        }
+        return () => {
+            paginationRef.current = null;
+        };
+    }, []);
+    // Update pagination state
+    const updateState = useCallback(() => {
+        if (!paginationRef.current)
+            return;
+        const paginationState = paginationRef.current.getState();
+        setState(prev => ({
+            ...prev,
+            currentPage: paginationState.currentPage,
+            pageSize: paginationState.pageSize,
+            totalItems: paginationState.totalItems,
+            totalPages: paginationState.totalPages,
+            hasMore: paginationState.hasMore,
+            cursor: paginationState.cursor,
+            nextCursor: paginationState.nextCursor,
+            prevCursor: paginationState.prevCursor
+        }));
+    }, []);
+    // Set total items
+    const setTotalItems = useCallback((total) => {
+        if (paginationRef.current) {
+            paginationRef.current.setTotalItems(total);
+            updateState();
+        }
+    }, [updateState]);
+    // Go to next page
+    const nextPage = useCallback(async (loadDataFn) => {
+        if (!paginationRef.current || !state.hasMore)
+            return;
+        const startTime = performance.now();
+        setState(prev => ({ ...prev, isAdapting: true }));
+        try {
+            paginationRef.current.nextPage();
+            if (loadDataFn) {
+                await loadDataFn();
+            }
+            const loadTime = performance.now() - startTime;
+            // Record load time for adaptation
+            if (enableAdaptation && paginationRef.current) {
+                paginationRef.current.recordLoadTime(state.currentPage, loadTime);
+                loadTimeHistoryRef.current.push({ page: state.currentPage, time: loadTime });
+                // Keep last 10 load times
+                if (loadTimeHistoryRef.current.length > 10) {
+                    loadTimeHistoryRef.current.shift();
+                }
+                const avgLoadTime = loadTimeHistoryRef.current.reduce((a, b) => a + b.time, 0) / loadTimeHistoryRef.current.length;
+                setState(prev => ({
+                    ...prev,
+                    avgLoadTime,
+                    isAdapting: false
+                }));
+            }
+            updateState();
+        }
+        catch (error) {
+            console.error('Next page error:', error);
+            setState(prev => ({ ...prev, isAdapting: false }));
+        }
+    }, [state.hasMore, state.currentPage, enableAdaptation, updateState]);
+    // Go to previous page
+    const prevPage = useCallback(() => {
+        if (!paginationRef.current)
+            return;
+        paginationRef.current.prevPage();
+        updateState();
+    }, [updateState]);
+    // Go to specific page
+    const goToPage = useCallback((page) => {
+        if (!paginationRef.current)
+            return;
+        paginationRef.current.goToPage(page);
+        updateState();
+    }, [updateState]);
+    // Go to cursor
+    const goToCursor = useCallback((cursor) => {
+        if (!paginationRef.current)
+            return;
+        paginationRef.current.goToCursor(cursor);
+        updateState();
+    }, [updateState]);
+    // Get fetch range
+    const getFetchRange = useCallback(() => {
+        if (!paginationRef.current)
+            return { skip: 0, limit: state.pageSize };
+        return paginationRef.current.getFetchRange();
+    }, [state.pageSize]);
+    // Get current cursor
+    const getCurrentCursor = useCallback(() => {
+        if (!paginationRef.current)
+            return state.cursor;
+        return paginationRef.current.getState().cursor;
+    }, [state.cursor]);
+    // Get pagination statistics
+    const getStats = useCallback(() => {
+        if (!paginationRef.current)
+            return null;
+        return {
+            currentPage: state.currentPage,
+            pageSize: state.pageSize,
+            totalItems: state.totalItems,
+            totalPages: state.totalPages,
+            hasMore: state.hasMore,
+            avgLoadTime: state.avgLoadTime,
+            currentCursor: state.cursor,
+            loadHistory: loadTimeHistoryRef.current
+        };
+    }, [state]);
+    // Reset pagination
+    const reset = useCallback(() => {
+        if (paginationRef.current) {
+            paginationRef.current.reset();
+            loadTimeHistoryRef.current = [];
+            updateState();
+        }
+    }, [updateState]);
+    return {
+        ...state,
+        nextPage,
+        prevPage,
+        goToPage,
+        goToCursor,
+        setTotalItems,
+        getFetchRange,
+        getCurrentCursor,
+        getStats,
+        reset
+    };
+};
+
+const IntelligentLazyList = ({ items, itemHeight, viewportHeight, fetchMore, renderItem, bufferSize = 5, enablePrefetch = true, enableCache = true, className = '', style = {} }) => {
+    const containerRef = useRef(null);
+    const { visibleRange, isLoading, scrollVelocity, scrollDirection, scrollPattern, prefetchConfidence, cacheHitRate, setContainerRef, getCachedData, cacheData } = useIntelligentScroll({
+        itemHeight,
+        viewportHeight,
+        bufferSize,
+        fetchMore,
+        enablePrefetch,
+        enableCache
+    });
+    // Cache items as they load
+    useEffect(() => {
+        if (enableCache) {
+            items.forEach((item, index) => {
+                if (index >= visibleRange.start && index <= visibleRange.end) {
+                    cacheData(index, item, 'high');
+                }
+            });
+        }
+    }, [items, visibleRange, enableCache, cacheData]);
+    // Calculate total height
+    const totalHeight = items.length * itemHeight;
+    const topPadding = visibleRange.start * itemHeight;
+    const bottomPadding = Math.max(0, totalHeight - ((visibleRange.end + 1) * itemHeight));
+    // Get visible items
+    const visibleItems = items.slice(visibleRange.start, visibleRange.end + 1);
+    return (React.createElement("div", { ref: (el) => {
+            containerRef.current = el;
+            setContainerRef(el);
+        }, className: `intelligent-lazy-list ${className}`, style: {
+            height: `${viewportHeight}px`,
+            overflowY: 'auto',
+            position: 'relative',
+            ...style
+        } },
+        React.createElement("div", { style: { height: `${topPadding}px` } }),
+        visibleItems.map((item, index) => {
+            const cachedData = getCachedData(visibleRange.start + index);
+            return (React.createElement("div", { key: visibleRange.start + index, style: {
+                    height: `${itemHeight}px`,
+                    position: 'relative'
+                }, className: "intelligent-lazy-item" }, renderItem(cachedData || item, visibleRange.start + index)));
+        }),
+        React.createElement("div", { style: { height: `${bottomPadding}px` } }),
+        isLoading && (React.createElement("div", { className: "intelligent-lazy-loading", style: {
+                position: 'absolute',
+                bottom: '10px',
+                left: '50%',
+                transform: 'translateX(-50%)',
+                background: 'rgba(0, 0, 0, 0.7)',
+                color: 'white',
+                padding: '8px 16px',
+                borderRadius: '4px',
+                fontSize: '12px'
+            } },
+            "Loading... (Pattern: ",
+            scrollPattern,
+            ", Confidence: ",
+            (prefetchConfidence * 100).toFixed(0),
+            "%)")),
+        React.createElement("div", { className: "intelligent-lazy-debug", style: {
+                position: 'absolute',
+                top: '10px',
+                right: '10px',
+                background: 'rgba(0, 0, 0, 0.7)',
+                color: 'white',
+                padding: '8px',
+                borderRadius: '4px',
+                fontSize: '11px',
+                pointerEvents: 'none'
+            } },
+            React.createElement("div", null,
+                "Velocity: ",
+                scrollVelocity.toFixed(2)),
+            React.createElement("div", null,
+                "Direction: ",
+                scrollDirection),
+            React.createElement("div", null,
+                "Pattern: ",
+                scrollPattern),
+            React.createElement("div", null,
+                "Cache Hit: ",
+                (cacheHitRate * 100).toFixed(0),
+                "%"),
+            React.createElement("div", null,
+                "Visible: ",
+                visibleRange.start,
+                "-",
+                visibleRange.end))));
+};
+
+const AdaptiveScrollView = ({ children, fetchMore, initialBatchSize = 50, minBatchSize = 20, maxBatchSize = 200, enableNetworkAdaptation = true, enablePerformanceAdaptation = true, className = '', style = {}, onLoadMore }) => {
+    const containerRef = useRef(null);
+    const loadMoreRef = useRef(null);
+    const observerRef = useRef(null);
+    const { currentBatchSize, networkQuality, performanceScore, isLoading, loadedItems, avgLoadTime, adaptationCount, loadMore, getStats } = useAdaptiveLoading({
+        initialBatchSize,
+        minBatchSize,
+        maxBatchSize,
+        fetchMore,
+        enableNetworkAdaptation,
+        enablePerformanceAdaptation
+    });
+    // Setup intersection observer for infinite scroll
+    useEffect(() => {
+        const options = {
+            root: containerRef.current,
+            rootMargin: '100px',
+            threshold: 0
+        };
+        observerRef.current = new IntersectionObserver((entries) => {
+            const entry = entries[0];
+            if (entry.isIntersecting && !isLoading) {
+                loadMore().then((items) => {
+                    if (onLoadMore) {
+                        onLoadMore(items);
+                    }
+                });
+            }
+        }, options);
+        if (loadMoreRef.current) {
+            observerRef.current.observe(loadMoreRef.current);
+        }
+        return () => {
+            if (observerRef.current) {
+                observerRef.current.disconnect();
+            }
+        };
+    }, [isLoading, loadMore, onLoadMore]);
+    // Get network quality color
+    const getNetworkQualityColor = () => {
+        switch (networkQuality) {
+            case 'excellent': return '#4CAF50';
+            case 'good': return '#8BC34A';
+            case 'poor': return '#FF9800';
+            case 'offline': return '#F44336';
+            default: return '#9E9E9E';
+        }
+    };
+    return (React.createElement("div", { ref: containerRef, className: `adaptive-scroll-view ${className}`, style: {
+            overflowY: 'auto',
+            height: '100%',
+            ...style
+        } },
+        React.createElement("div", { className: "adaptive-scroll-content" }, children),
+        React.createElement("div", { ref: loadMoreRef, style: {
+                padding: '20px',
+                textAlign: 'center',
+                opacity: isLoading ? 0.5 : 1
+            } }, isLoading ? (React.createElement("div", { className: "adaptive-loading" },
+            React.createElement("div", { style: {
+                    display: 'inline-block',
+                    width: '20px',
+                    height: '20px',
+                    border: '2px solid #f3f3f3',
+                    borderTop: '2px solid #3498db',
+                    borderRadius: '50%',
+                    animation: 'spin 1s linear infinite'
+                } }),
+            React.createElement("span", { style: { marginLeft: '8px' } },
+                "Loading ",
+                currentBatchSize,
+                " items..."))) : (React.createElement("div", { className: "adaptive-ready" }, "Scroll for more"))),
+        React.createElement("div", { style: {
+                position: 'fixed',
+                bottom: '10px',
+                right: '10px',
+                background: 'rgba(0, 0, 0, 0.8)',
+                color: 'white',
+                padding: '12px',
+                borderRadius: '8px',
+                fontSize: '11px',
+                fontFamily: 'monospace',
+                zIndex: 1000
+            } },
+            React.createElement("div", { style: { marginBottom: '8px', fontWeight: 'bold' } }, "Adaptive Loading Stats"),
+            React.createElement("div", { style: { display: 'grid', gridTemplateColumns: 'auto auto', gap: '4px' } },
+                React.createElement("span", null, "Batch Size:"),
+                React.createElement("span", null, currentBatchSize),
+                React.createElement("span", null, "Network:"),
+                React.createElement("span", { style: { color: getNetworkQualityColor() } }, networkQuality.toUpperCase()),
+                React.createElement("span", null, "Performance:"),
+                React.createElement("span", null,
+                    (performanceScore * 100).toFixed(0),
+                    "%"),
+                React.createElement("span", null, "Loaded:"),
+                React.createElement("span", null,
+                    loadedItems,
+                    " items"),
+                React.createElement("span", null, "Avg Load:"),
+                React.createElement("span", null,
+                    avgLoadTime.toFixed(0),
+                    "ms"),
+                React.createElement("span", null, "Adaptations:"),
+                React.createElement("span", null, adaptationCount))),
+        React.createElement("style", null, `
+        @keyframes spin {
+          0% { transform: rotate(0deg); }
+          100% { transform: rotate(360deg); }
+        }
+      `)));
+};
+
+const SmartInfiniteScroll = ({ fetchMore, renderItem, initialPageSize = 50, minPageSize = 20, maxPageSize = 200, enableAdaptation = true, className = '', style = {}, emptyMessage = 'No more items' }) => {
+    const containerRef = useRef(null);
+    const loadMoreRef = useRef(null);
+    const observerRef = useRef(null);
+    const { currentPage, pageSize, totalItems, totalPages, hasMore, cursor, nextPage, setTotalItems, getFetchRange } = useSmartPagination({
+        initialPage: 1,
+        initialPageSize,
+        minPageSize,
+        maxPageSize,
+        enableAdaptation
+    });
+    const { isLoading, loadedItems, avgLoadTime, loadMore, getStats } = useAdaptiveLoading({
+        initialBatchSize: pageSize,
+        minBatchSize: minPageSize,
+        maxBatchSize: maxPageSize,
+        fetchMore: async () => {
+            const range = getFetchRange();
+            const items = await fetchMore(currentPage, range.limit);
+            setTotalItems(totalItems + items.length);
+            return items;
+        },
+        enableNetworkAdaptation: enableAdaptation,
+        enablePerformanceAdaptation: enableAdaptation
+    });
+    // Setup intersection observer
+    useEffect(() => {
+        const options = {
+            root: containerRef.current,
+            rootMargin: '200px',
+            threshold: 0
+        };
+        observerRef.current = new IntersectionObserver((entries) => {
+            const entry = entries[0];
+            if (entry.isIntersecting && !isLoading && hasMore) {
+                nextPage(async () => {
+                    await loadMore();
+                });
+            }
+        }, options);
+        if (loadMoreRef.current) {
+            observerRef.current.observe(loadMoreRef.current);
+        }
+        return () => {
+            if (observerRef.current) {
+                observerRef.current.disconnect();
+            }
+        };
+    }, [isLoading, hasMore, nextPage, loadMore]);
+    // Get pagination stats
+    getStats();
+    return (React.createElement("div", { ref: containerRef, className: `smart-infinite-scroll ${className}`, style: {
+            overflowY: 'auto',
+            height: '100%',
+            ...style
+        } },
+        React.createElement("div", { className: "smart-infinite-content" }, loadedItems === 0 && (React.createElement("div", { className: "smart-infinite-empty", style: {
+                padding: '40px',
+                textAlign: 'center',
+                color: '#999'
+            } }, emptyMessage))),
+        React.createElement("div", { ref: loadMoreRef, style: {
+                padding: '30px',
+                textAlign: 'center'
+            } }, isLoading ? (React.createElement("div", { className: "smart-infinite-loading" },
+            React.createElement("div", { style: {
+                    display: 'inline-block',
+                    width: '24px',
+                    height: '24px',
+                    border: '3px solid #f3f3f3',
+                    borderTop: '3px solid #3498db',
+                    borderRadius: '50%',
+                    animation: 'smart-spin 1s linear infinite'
+                } }),
+            React.createElement("div", { style: { marginTop: '12px', color: '#666' } },
+                "Loading page ",
+                currentPage + 1,
+                " of ",
+                totalPages,
+                "..."),
+            React.createElement("div", { style: { fontSize: '11px', color: '#999', marginTop: '4px' } },
+                "Batch size: ",
+                pageSize,
+                " \u2022 Avg: ",
+                avgLoadTime.toFixed(0),
+                "ms"))) : hasMore ? (React.createElement("div", { className: "smart-infinite-ready", style: {
+                color: '#999',
+                fontSize: '13px'
+            } }, "Scroll for more items")) : (React.createElement("div", { className: "smart-infinite-end", style: {
+                color: '#999',
+                fontSize: '13px'
+            } }, emptyMessage))),
+        React.createElement("div", { style: {
+                position: 'fixed',
+                bottom: '10px',
+                right: '10px',
+                background: 'linear-gradient(135deg, #667eea 0%, #764ba2 100%)',
+                color: 'white',
+                padding: '16px',
+                borderRadius: '12px',
+                fontSize: '11px',
+                fontFamily: 'monospace',
+                boxShadow: '0 4px 6px rgba(0, 0, 0, 0.1)',
+                zIndex: 1000,
+                minWidth: '200px'
+            } },
+            React.createElement("div", { style: { marginBottom: '8px', fontWeight: 'bold', fontSize: '13px' } }, "\uD83D\uDE80 Smart Infinite Scroll"),
+            React.createElement("div", { style: { display: 'grid', gridTemplateColumns: 'auto auto', gap: '6px' } },
+                React.createElement("span", null, "Page:"),
+                React.createElement("span", null,
+                    currentPage,
+                    " / ",
+                    totalPages),
+                React.createElement("span", null, "Page Size:"),
+                React.createElement("span", null,
+                    pageSize,
+                    " (adaptive)"),
+                React.createElement("span", null, "Loaded:"),
+                React.createElement("span", null,
+                    loadedItems,
+                    " items"),
+                React.createElement("span", null, "Avg Load:"),
+                React.createElement("span", null,
+                    avgLoadTime.toFixed(0),
+                    "ms"),
+                React.createElement("span", null, "Cursor:"),
+                React.createElement("span", { style: {
+                        fontSize: '9px',
+                        wordBreak: 'break-all',
+                        maxWidth: '120px',
+                        overflow: 'hidden',
+                        textOverflow: 'ellipsis'
+                    } }, cursor ? cursor.substring(0, 20) + '...' : 'N/A'),
+                React.createElement("span", null, "Has More:"),
+                React.createElement("span", { style: { color: hasMore ? '#4CAF50' : '#F44336' } }, hasMore ? 'Yes' : 'No'))),
+        React.createElement("style", null, `
+        @keyframes smart-spin {
+          0% { transform: rotate(0deg); }
+          100% { transform: rotate(360deg); }
+        }
+      `)));
+};
+
+export { AdaptiveScrollView, IntelligentLazyList, LazyList, SmartInfiniteScroll, useAdaptiveLoading, useIntelligentScroll, useLazyList, useSmartPagination };
 //# sourceMappingURL=index.js.map