Sorting optimizations fix

Author: JasonHoku

resources/logic_pipeline.js

@@ -7,31 +7,20 @@
 const ASYNC_PIPELINE_THRESHOLD = 500;
 
 // RESTORED: Helper to update index map
-// OPTIMIZED: Avoid creating a full sorted copy for large datasets
+// Maps each item's ID to its sequential position (1-based) when sorted by ID.
+// This provides a stable "original order" number for each card regardless of
+// current sort/filter, used for "Go To Card #" and the #N tag on cards.
 function refreshIndices() {
     if (!activeData) return;
-
-    if (activeData.length > ASYNC_PIPELINE_THRESHOLD) {
-        // For large datasets, build the map by finding min ID and computing offsets
-        // Since IDs are sequential integers, we can avoid sorting entirely
-        let minId = Infinity;
-        for (let i = 0; i < activeData.length; i++) {
-            if (activeData[i].id < minId) minId = activeData[i].id;
-        }
-        idToIndexMap = new Map();
-        for (let i = 0; i < activeData.length; i++) {
-            idToIndexMap.set(activeData[i].id, activeData[i].id - minId + 1);
-        }
-    } else {
-        const sorted = activeData.slice().sort((a, b) => a.id - b.id);
-        idToIndexMap = new Map(sorted.map((item, index) => [item.id, index + 1]));
-    }
+    const sorted = activeData.slice().sort((a, b) => a.id - b.id);
+    idToIndexMap = new Map(sorted.map((item, index) => [item.id, index + 1]));
 }
 
 // Generate cache key from current filters
 function getFilterKey() {
     const parts = [
         currentSort,
+        currentSecondarySort,
         topFilters.showFavorites ? '1' : '0',
         topFilters.showNonFavorited ? '1' : '0',
         topFilters.showRejected ? '1' : '0',
@@ -323,48 +312,25 @@ function executePipeline() {
         return true;
     });
 
-    // For large datasets, use async sorting to avoid blocking the UI
-    if (processedData.length > ASYNC_PIPELINE_THRESHOLD) {
-        // Cancel any previous async sort
-        const thisRunId = ++pipelineAbortId;
-
-        // For "oldest" and "newest" sorts, we can use a fast path since items from
-        // activeData are already ordered by insertion (id order)
-        if ((currentSort === 'oldest' || currentSort === 'newest') && currentSecondarySort === 'none') {
-            // Fast path: items from activeData are already in insertion order
-            // For oldest: a.id - b.id (natural order from activeData)
-            // For newest: reverse
-            if (currentSort === 'newest') {
-                processedData.reverse();
-            }
-            // No expensive sort needed!
-        } else {
-            // Async sort: sort in a yielding fashion to keep UI responsive
-            runMultiSort(processedData);
-        }
-
-        const elapsed = (performance.now() - startTime).toFixed(1);
-        console.log(`[Pipeline] Processed ${processedData.length} items in ${elapsed}ms (large dataset mode)`);
-        updateJSONs(processedData);
-
-        if (filtersChanged) {
-            if(typeof renderDOM === 'function') renderDOM();
-        } else {
-            if (typeof updateVisibleItems === 'function') updateVisibleItems();
+    // Apply sorting
+    // Fast path: for oldest/newest with no secondary sort, items from activeData.filter()
+    // are already in ID order — just reverse for newest
+    if ((currentSort === 'oldest' || currentSort === 'newest') && currentSecondarySort === 'none') {
+        if (currentSort === 'newest') {
+            processedData.reverse();
         }
     } else {
-        // Small dataset: synchronous sort (fast enough)
         runMultiSort(processedData);
+    }
 
-        const elapsed = (performance.now() - startTime).toFixed(1);
-        console.log(`[Pipeline] Processed ${processedData.length} items in ${elapsed}ms`);
-        updateJSONs(processedData);
+    const elapsed = (performance.now() - startTime).toFixed(1);
+    console.log(`[Pipeline] Processed ${processedData.length} items in ${elapsed}ms`);
+    updateJSONs(processedData);
 
-        if (filtersChanged) {
-            if(typeof renderDOM === 'function') renderDOM();
-        } else {
-            if (typeof updateVisibleItems === 'function') updateVisibleItems();
-        }
+    if (filtersChanged) {
+        if(typeof renderDOM === 'function') renderDOM();
+    } else {
+        if (typeof updateVisibleItems === 'function') updateVisibleItems();
     }
 }
 

resources/logic_virtual.js

@@ -242,6 +242,7 @@ function renderVisibleItems(forcePositionUpdate = false) {
 
     itemsToShow.forEach((data, offsetIndex) => {
         const globalIndex = visibleRange.start + offsetIndex;
+        const displayNumber = globalIndex + 1; // 1-based position in current sorted view
 
         const row = Math.floor(globalIndex / columnsCount);
         const col = globalIndex % columnsCount;
@@ -258,6 +259,10 @@ function renderVisibleItems(forcePositionUpdate = false) {
             card.style.width = `${itemWidth - 10}px`;
             card.style.zIndex = globalIndex;
 
+            // Update card number to reflect sorted position
+            const indexTag = card.querySelector('.index-tag');
+            if (indexTag) indexTag.textContent = `#${displayNumber}`;
+
             nodeMap.set(data.id, card);
             fragment.appendChild(card);
             newCardsAdded++;
@@ -278,6 +283,10 @@ function renderVisibleItems(forcePositionUpdate = false) {
                 card.style.top = `${y}px`;
                 card.style.zIndex = globalIndex;
                 positionsUpdated++;
+
+                // Update card number when position changes (sort/filter changed)
+                const indexTag = card.querySelector('.index-tag');
+                if (indexTag) indexTag.textContent = `#${displayNumber}`;
             }
         }
     });
@@ -434,19 +443,15 @@ function goToImage(imageNumber) {
     let targetItem = null;
     let targetIndex = -1;
 
-    for (let i = 0; i < processedData.length; i++) {
-        const item = processedData[i];
-        const itemIndex = idToIndexMap.get(item.id) || 0;
-        if (itemIndex === imageNumber) {
-            targetItem = item;
-            targetIndex = i;
-            break;
-        }
+    // Card numbers reflect sorted position (1-based), so #N = processedData[N-1]
+    if (imageNumber >= 1 && imageNumber <= processedData.length) {
+        targetIndex = imageNumber - 1;
+        targetItem = processedData[targetIndex];
     }
 
     if (!targetItem || targetIndex === -1) {
         console.log(`[Grid] Image #${imageNumber} not found`);
-        alert(`Image #${imageNumber} not found in current view`);
+        alert(`Image #${imageNumber} not found in current view (${processedData.length} items visible)`);
         return;
     }