@humanspeak/svelte-headless-table 6.0.8 → 6.0.9

package/dist/createViewModel.js

@@ -191,21 +191,35 @@ export const createViewModel = (table, columns, { rowDataId } = {}) => {
         rows = fn(rows);
     });
     const pluginEntries = Object.entries(pluginInstances);
+    const trHookEntries = [];
+    const tdHookEntries = [];
+    for (const [name, instance] of pluginEntries) {
+        const trHook = instance.hooks?.['tbody.tr'];
+        if (trHook !== undefined)
+            trHookEntries.push([name, trHook]);
+        const tdHook = instance.hooks?.['tbody.tr.td'];
+        if (tdHook !== undefined)
+            tdHookEntries.push([name, tdHook]);
+    }
+    // Hoisted out of the per-row loop so we don't allocate a fresh
+    // closure on every iteration. For rows-10k that's 10,000 fewer
+    // closure allocations per derivation pass.
+    const injectCellState = (cell) => cell.injectState(tableState);
     const injectedRows = derived(rows, ($rows) => {
         const _t0 = performance.now();
         derivationCalls.injectedRows++;
         $rows.forEach((row) => {
             row.injectState(tableState);
-            row.cells.forEach((cell) => cell.injectState(tableState));
-            for (const [pluginName, pluginInstance] of pluginEntries) {
-                const trHook = pluginInstance.hooks?.['tbody.tr'];
-                if (trHook !== undefined) {
-                    row.applyHook(pluginName, trHook(row));
-                }
-                const tdHook = pluginInstance.hooks?.['tbody.tr.td'];
-                if (tdHook !== undefined) {
-                    row.cells.forEach((cell) => cell.applyHook(pluginName, tdHook(cell)));
-                }
+            row.cells.forEach(injectCellState);
+            for (const [pluginName, trHook] of trHookEntries) {
+                row.applyHook(pluginName, trHook(row));
+            }
+            if (tdHookEntries.length > 0) {
+                row.cells.forEach((cell) => {
+                    for (const [pluginName, tdHook] of tdHookEntries) {
+                        cell.applyHook(pluginName, tdHook(cell));
+                    }
+                });
             }
         });
         _rows.set($rows);

package/dist/headerRows.js

@@ -215,7 +215,9 @@ export const getMergedRow = (cells) => {
     }
     const mergedCells = [];
     let startIdx = 0;
-    let endIdx = 1;
+    // endIdx is initialized inside the merge branch (line ~293) before
+    // it's read; declared here only so the inner-while loop can see it.
+    let endIdx;
     while (startIdx < cells.length) {
         const cell = cells[startIdx].clone();
         if (!cell.isGroup()) {

package/dist/plugins/addSortBy.js

@@ -1,3 +1,4 @@
+import { MemoryCache } from '@humanspeak/memory-cache';
 import { derived, writable } from 'svelte/store';
 import { compare } from '../utils/compare.js';
 import { isShiftClick } from '../utils/event.js';
@@ -169,6 +170,16 @@ export const addSortBy = ({ initialSortKeys = [], disableMultiSort = false, isMu
         });
     };
     const pluginState = { sortKeys, preSortedRows };
+    // The `tbody.tr.td` hook output only depends on `cell.id` (the
+    // column ID — closed-over) and the reactive `sortKeys` store.
+    // Two body cells in the same column produce identical Readables,
+    // so we can share one Readable per column ID across every row.
+    // For rows-10k × 8 cols that collapses 80,000 Readable allocations
+    // per cold mount into 8. LRU eviction means we stay bounded even
+    // if column IDs churn over the view-model's lifetime.
+    const tdPropsCache = new MemoryCache({
+        maxSize: 256
+    });
     return {
         pluginState,
         deriveRows,
@@ -204,12 +215,16 @@ export const addSortBy = ({ initialSortKeys = [], disableMultiSort = false, isMu
                 return { props };
             },
             'tbody.tr.td': (cell) => {
-                const props = derived(sortKeys, ($sortKeys) => {
-                    const key = $sortKeys.find((k) => k.id === cell.id);
-                    return {
-                        order: key?.order
-                    };
-                });
+                let props = tdPropsCache.get(cell.id);
+                if (props === undefined) {
+                    props = derived(sortKeys, ($sortKeys) => {
+                        const key = $sortKeys.find((k) => k.id === cell.id);
+                        return {
+                            order: key?.order
+                        };
+                    });
+                    tdPropsCache.set(cell.id, props);
+                }
                 return { props };
             }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@humanspeak/svelte-headless-table",
-  "version": "6.0.8",
+  "version": "6.0.9",
   "description": "A powerful, headless table library for Svelte that provides complete control over table UI while handling complex data operations like sorting, filtering, pagination, grouping, and row expansion. Build custom, accessible data tables with zero styling opinions.",
   "keywords": [
     "svelte",
@@ -69,15 +69,15 @@
     "@faker-js/faker": "^10.4.0",
     "@playwright/test": "^1.60.0",
     "@sveltejs/adapter-auto": "^7.0.1",
-    "@sveltejs/kit": "^2.60.1",
+    "@sveltejs/kit": "^2.61.1",
     "@sveltejs/package": "^2.5.7",
     "@sveltejs/vite-plugin-svelte": "^7.1.2",
     "@testing-library/jest-dom": "^6.9.1",
     "@testing-library/svelte": "^5.3.1",
     "@types/eslint": "9.6.1",
     "@types/node": "^25.9.1",
-    "@typescript-eslint/eslint-plugin": "^8.59.4",
-    "@typescript-eslint/parser": "^8.59.4",
+    "@typescript-eslint/eslint-plugin": "^8.60.0",
+    "@typescript-eslint/parser": "^8.60.0",
     "@vitest/coverage-v8": "^4.1.7",
     "eslint": "^10.4.0",
     "eslint-config-prettier": "10.1.8",
@@ -97,7 +97,7 @@
     "tslib": "^2.8.1",
     "type-fest": "^5.6.0",
     "typescript": "^6.0.3",
-    "typescript-eslint": "^8.59.4",
+    "typescript-eslint": "^8.60.0",
     "vite": "^8.0.14",
     "vitest": "^4.1.7"
   },