No workers match your filter criteria
`);
return;
}
// Performance optimization for large lists
if (filteredWorkers.length > 200) {
// For very large lists, render in batches
const workerBatch = 100;
const totalBatches = Math.ceil(filteredWorkers.length / workerBatch);
console.log(`Rendering ${filteredWorkers.length} workers in ${totalBatches} batches`);
// Render first batch immediately
renderWorkerBatch(filteredWorkers.slice(0, workerBatch), workerGrid);
// Render remaining batches with setTimeout to avoid UI freezing
for (let i = 1; i < totalBatches; i++) {
const start = i * workerBatch;
const end = Math.min(start + workerBatch, filteredWorkers.length);
setTimeout(() => {
renderWorkerBatch(filteredWorkers.slice(start, end), workerGrid);
// Update "loading more" message with progress
const loadingMsg = workerGrid.find('.loading-more-workers');
if (loadingMsg.length) {
if (i === totalBatches - 1) {
loadingMsg.remove();
} else {
loadingMsg.text(`Loading more workers... ${Math.min((i + 1) * workerBatch, filteredWorkers.length)}/${filteredWorkers.length}`);
}
}
}, i * 50); // 50ms delay between batches
}
// Add "loading more" indicator at the bottom
if (totalBatches > 1) {
workerGrid.append(`Loading more workers... ${workerBatch}/${filteredWorkers.length}
`);
}
} else {
// For smaller lists, render all at once
renderWorkerBatch(filteredWorkers, workerGrid);
}
}
// Render a batch of workers efficiently
function renderWorkerBatch(workers, container) {
// Create a document fragment for better performance
const fragment = document.createDocumentFragment();
// Calculate max hashrate once for this batch
const maxHashrate = calculateMaxHashrate();
workers.forEach(worker => {
const card = createWorkerCard(worker, maxHashrate);
fragment.appendChild(card[0]);
});
container.append(fragment);
}
// Calculate max hashrate once to avoid recalculating for each worker
function calculateMaxHashrate() {
let maxHashrate = 125; // Default fallback
// First check if global hashrate data is available
if (workerData && workerData.hashrate_24hr) {
const globalHashrate = normalizeHashrate(workerData.hashrate_24hr, workerData.hashrate_24hr_unit || 'th/s');
if (globalHashrate > 0) {
return Math.max(5, globalHashrate * 1.2);
}
}
// If no global data, calculate from workers efficiently
if (workerData && workerData.workers && workerData.workers.length > 0) {
const onlineWorkers = workerData.workers.filter(w => w.status === 'online');
if (onlineWorkers.length > 0) {
let maxWorkerHashrate = 0;
// Find maximum hashrate without logging every worker
onlineWorkers.forEach(w => {
const hashrateValue = w.hashrate_24hr || w.hashrate_3hr || 0;
const hashrateUnit = w.hashrate_24hr ?
(w.hashrate_24hr_unit || 'th/s') :
(w.hashrate_3hr_unit || 'th/s');
const normalizedRate = normalizeHashrate(hashrateValue, hashrateUnit);
if (normalizedRate > maxWorkerHashrate) {
maxWorkerHashrate = normalizedRate;
}
});
if (maxWorkerHashrate > 0) {
return Math.max(5, maxWorkerHashrate * 1.2);
}
}
}
// Fallback to total hashrate
if (workerData && workerData.total_hashrate) {
const totalHashrate = normalizeHashrate(workerData.total_hashrate, workerData.hashrate_unit || 'th/s');
if (totalHashrate > 0) {
return Math.max(5, totalHashrate * 1.2);
}
}
return maxHashrate;
}
// Optimized worker card creation (removed debug logging)
function createWorkerCard(worker, maxHashrate) {
const card = $('