@lavalogic/scoria 0.17.2 → 0.18.0

package/dist/Components/Table/Types/Context/TableContext.svelte.js

@@ -1,5 +1,5 @@
 import { browser, dev } from '$app/environment';
-import { asyncAll, asyncFilterIndices, asyncForEach, asyncMap, asyncSleep, devCatch, getCanvasContext, getErrorMessage, } from '../../../../Helpers/Helpers.svelte.js';
+import { asyncAll, asyncForEach, asyncMap, asyncSleep, devCatch, getCanvasContext, } from '../../../../Helpers/Helpers.svelte.js';
 import { tick, untrack } from 'svelte';
 import { SvelteMap, SvelteSet } from 'svelte/reactivity';
 import { ColumnType } from '../Columns/ColumnType.js';
@@ -13,7 +13,6 @@ import { BubbleDef } from '../Columns/Definitions/Display/BubbleDef.svelte.js';
 import { DisplayDef } from '../Columns/Definitions/Display/DisplayDef.svelte.js';
 import { ProgressBarDef } from '../Columns/Definitions/Display/ProgressBarDef.svelte.js';
 import { RowSelectionDef } from '../Columns/Definitions/RowSelection/RowSelectionDef.svelte.js';
-import { allowedEmptyFilterModes } from '../DataRepository/LocalTableDataRepository.svelte.js';
 import { PaginationType } from '../Pagination/PaginationType.js';
 import { ToolbarPosition } from '../Toolbar/ToolbarPosition.js';
 const SORTING_ICON_WIDTH = 24;
@@ -71,6 +70,7 @@ export class TableContext {
         $effect(() => {
             void this.currentPageData;
             void this.selectedItems;
+            void this.paginationRepo?.paginationState.pageIndex;
             untrack(async () => {
                 await this.currentPageData;
                 if (this.paginationRepo?.paginationState.pageIndex != undefined) {
@@ -80,6 +80,62 @@ export class TableContext {
                 }
             }).catch(devCatch);
         });
+        let filteredIndicesAbortController = null;
+        $effect(() => {
+            (async () => {
+                void this.dataRepo.filtering;
+                void this.dataRepo.data;
+                void this.columnDefsById;
+                filteredIndicesAbortController?.abort();
+                const currentController = (filteredIndicesAbortController = new AbortController());
+                const data = this.dataRepo.data;
+                const columnDefsById = this.columnDefsById;
+                // if (!$effect.tracking()) {
+                // 	// console.warn(`filtered indices are not in a tracking context`);
+                // 	throw new Error(`filtered indices are not in a tracking context`);
+                // }
+                if (!this.dataRepo.filtering.length) {
+                    this._filteredIndices = data.map((_item, index) => {
+                        return index;
+                    });
+                }
+                else {
+                    await asyncSleep(300);
+                    const filtered = [];
+                    for (let index = 0; index < data.length; ++index) {
+                        if (currentController.signal.aborted) {
+                            if (dev) {
+                                console.log(`filtered indices have been aborted`);
+                            }
+                            return;
+                        }
+                        const item = data[index];
+                        const row = this.createRow(item, index, index);
+                        const x = await asyncAll(this.dataRepo.filtering, async (filter) => {
+                            if (currentController.signal.aborted) {
+                                return false;
+                            }
+                            const def = columnDefsById.get(filter.id);
+                            if (!def) {
+                                console.warn(`Could not find column def for filter with id ${filter.id}`);
+                                return false;
+                            }
+                            if (def.filterFn) {
+                                return await def.filterFn(row, filter.id, filter.value); //HACK how much parsing will be needed to be type safe?
+                            }
+                            if (this.debug) {
+                                console.warn(`column ${def.id} did not have a filter function`);
+                            }
+                            return false;
+                        });
+                        if (x) {
+                            filtered.push(index);
+                        }
+                    }
+                    this._filteredIndices = filtered;
+                }
+            })().catch(devCatch);
+        });
         if (defaultColumnDefs.remoteFilters) {
             this.remoteFilters = defaultColumnDefs.remoteFilters;
         }
@@ -153,110 +209,6 @@ export class TableContext {
             })
                 .catch(devCatch);
         }
-        $effect(() => {
-            void this.paginationRepo?.paginationType;
-            void this.dataRepo.filtering;
-            void this.dataRepo.filterModes;
-            void this.dataRepo.data;
-            void this.paginationRepo?.paginationState;
-            // console.log('massive effect start');
-            (async () => {
-                const startTime = Date.now();
-                let currentTimer;
-                const abortController = new AbortController();
-                try {
-                    if (this.paginationRepo?.paginationType == PaginationType.Local) {
-                        // eslint-disable-next-line svelte/prefer-svelte-reactivity
-                        const checkedIds = new Set();
-                        const filterState = this.dataRepo.filtering.filter((filter) => {
-                            const snapshot = $state.snapshot(filter.value);
-                            checkedIds.add(filter.id);
-                            const filterMode = this.dataRepo.filterModes.get(filter.id);
-                            return ((snapshot !== '' &&
-                                snapshot != null &&
-                                (!Array.isArray(snapshot) || !!snapshot[0])) ||
-                                (!!filterMode && allowedEmptyFilterModes.has(filterMode)));
-                        });
-                        const data = this.dataRepo.data;
-                        currentTimer = ++this.filterTimer;
-                        await asyncSleep(150);
-                        if (currentTimer != this.filterTimer) {
-                            throw new Error('stale filter');
-                        }
-                        if (!filterState.length) {
-                            if (dev) {
-                                console.log('no filter state was found');
-                            }
-                            this.filteredIndices = data.map((_item, index) => {
-                                return index;
-                            });
-                        }
-                        else {
-                            this.dataRepo.isLoading = true;
-                            if (this.debug) {
-                                console.log('getting filter promise');
-                            }
-                            const settled = $state({ value: false });
-                            const filterPromise = asyncFilterIndices(data, async (item, index) => {
-                                const row = this.createRow(item, index, index);
-                                return asyncAll(filterState, async (filter) => {
-                                    abortController.signal.throwIfAborted();
-                                    const def = this.columnDefsById.get(filter.id);
-                                    if (!def) {
-                                        console.warn(`Could not find column def for filter with id ${filter.id}`);
-                                        return false;
-                                    }
-                                    if (def.filterFn) {
-                                        return def.filterFn(row, filter.id, filter.value); //HACK how much parsing will be needed to be type safe?
-                                    }
-                                    if (this.debug) {
-                                        console.warn(`column ${def.id} did not have a filter function`);
-                                    }
-                                    return false;
-                                });
-                            });
-                            filterPromise
-                                .then((indices) => {
-                                if (this.debug) {
-                                    console.log(`iteration ${currentTimer}: got indices from filter promise:`, indices);
-                                }
-                                this.filteredIndices = indices;
-                            })
-                                .catch((e) => {
-                                if (this.debug) {
-                                    console.log(`caught filter rejection:`, e);
-                                    console.log(`iteration ${currentTimer} cancelled after ${Date.now() - startTime}ms`);
-                                }
-                            })
-                                .finally(() => {
-                                if (this.debug) {
-                                    console.log(`timer ${currentTimer} is settled`);
-                                }
-                                settled.value = true;
-                                if (currentTimer === this.filterTimer) {
-                                    this.dataRepo.isLoading = false;
-                                }
-                                else if (this.debug) {
-                                    console.warn(`skipping disabling load overlay because current timer is ${currentTimer} but newest is ${this.filterTimer}`);
-                                }
-                            });
-                            await this.filteringLoop(currentTimer, abortController, settled, startTime);
-                        }
-                    }
-                }
-                catch (e) {
-                    if (dev) {
-                        const message = getErrorMessage(e);
-                        if (!message.toLocaleLowerCase().startsWith('stale')) {
-                            console.error(`Iteration ${currentTimer}`, e);
-                        }
-                        else {
-                            console.log(`iteration ${currentTimer} cancelled after ${Date.now() - startTime}ms`);
-                        }
-                    }
-                }
-            })().catch(devCatch);
-        });
     }
     // #endregion
     // #region stores
@@ -346,24 +298,52 @@ export class TableContext {
     set selectedPreset(v) {
         this._selectedPreset = v;
     }
-    _focusedRowIndexIds = $state(new SvelteSet());
-    get focusedRowIndexIds() {
-        return this._focusedRowIndexIds;
-    }
-    set focusedRowIndexIds(v) {
-        this._focusedRowIndexIds = v;
-    }
+    _pageColData = $derived.by(async () => {
+        if (!this.focusStart || !this.focusEnd) {
+            return { indices: new SvelteSet(), affectedColumns: new SvelteSet() };
+        }
+        const { row: startRowIndexId, column: startColumnIndex } = this.focusStart;
+        const { row: endRowIndexId, column: endColumnIndex } = this.focusEnd;
+        const model = await this.sortedRowModel;
+        const startRowIndex = model.rows.findIndex((row) => row.visibleIndex === startRowIndexId);
+        const endRowIndex = model.rows.findIndex((row) => row.visibleIndex === endRowIndexId);
+        if (startRowIndex == -1 || endRowIndex == -1) {
+            return { indices: new SvelteSet(), affectedColumns: new SvelteSet() };
+        }
+        const minRowIndex = Math.min(startRowIndex, endRowIndex);
+        const maxRowIndex = Math.max(startRowIndex, endRowIndex);
+        const minColumnIndex = Math.min(startColumnIndex, endColumnIndex);
+        const maxColumnIndex = Math.max(startColumnIndex, endColumnIndex);
+        const affectedColumns = new SvelteSet();
+        const visibility = this.columnVisibility;
+        this.columnDefs
+            .filter((it) => 'index' in it &&
+            visibility[it.id] !== false &&
+            // TODO handle pinning behaviour
+            // !columnPinning.left?.includes(it.id) &&
+            // !columnPinning.right?.includes(it.id) &&
+            // (!('columnType' in it) || it.columnType === undefined || it.columnType === 'Accessor') &&
+            it.index >= minColumnIndex &&
+            it.index <= maxColumnIndex)
+            .forEach((it) => affectedColumns.add(it.id));
+        const indices = new SvelteSet();
+        for (let i = minRowIndex; i <= maxRowIndex; i++) {
+            indices.add(parseInt(model.rows[i].id));
+        }
+        return { indices, affectedColumns };
+    });
+    focusedRowIndices = $derived.by(async () => {
+        void this._pageColData;
+        return (await this._pageColData).indices;
+    });
     _highlightedItems = $state(new SvelteMap());
     get highlightedItems() {
         return this._highlightedItems;
     }
-    _focusedColumnIds = $state(new SvelteSet());
-    get focusedColumnIds() {
-        return this._focusedColumnIds;
-    }
-    set focusedColumnIds(v) {
-        this._focusedColumnIds = v;
-    }
+    focusedColumnIds = $derived.by(async () => {
+        void this._pageColData;
+        return (await this._pageColData).affectedColumns;
+    });
     _isMousingDown = $state(false);
     get isMousingDown() {
         return this._isMousingDown;
@@ -377,7 +357,6 @@ export class TableContext {
     }
     set focusStart(v) {
         this._focusStart = v;
-        this._recalculateFocusedElements().catch(devCatch);
     }
     _focusStartIsBeingEdited = $state(false);
     get focusStartIsBeingEdited() {
@@ -392,7 +371,6 @@ export class TableContext {
     }
     set focusEnd(v) {
         this._focusEnd = v;
-        this._recalculateFocusedElements().catch(devCatch);
     }
     _singleClickEditing = $state(false);
     get singleClickEditing() {
@@ -534,9 +512,6 @@ export class TableContext {
     get selectedItems() {
         return this._selectedItems;
     }
-    set selectedItems(v) {
-        this._selectedItems = v;
-    }
     _invalidValues = $state(new SvelteMap());
     get invalidValues() {
         return this._invalidValues;
@@ -552,8 +527,7 @@ export class TableContext {
         this._hasInvalidSelectedItems = v;
     }
     // FIXME decide
-    // eslint-disable-next-line svelte/prefer-svelte-reactivity
-    columnDefsById = $derived(new Map(this.columnDefs.map((it) => [it.id, it])));
+    columnDefsById = $derived(new SvelteMap(this.columnDefs.map((it) => [it.id, it])));
     getSortingFn = (id, desc) => {
         if (this.dataRepo.data.length == 0) {
             return undefined;
@@ -582,60 +556,66 @@ export class TableContext {
         // }
         return comparableSortingFn(id, desc);
     };
-    // private _filterTimer: ReturnType<typeof setTimeout> | undefined;
-    _filterTimer = 1;
-    get filterTimer() {
-        return this._filterTimer;
-    }
-    set filterTimer(v) {
-        this._filterTimer = v;
-    }
     _filteredIndices = $state([]);
     get filteredIndices() {
         return this._filteredIndices;
     }
-    set filteredIndices(v) {
-        if (this.debug) {
-            console.log('updating filtered indices');
-        }
-        this._filteredIndices = v;
-    }
-    filteredData = $derived.by(() => {
+    filteredData = $derived.by(async () => {
         void this.dataRepo.data;
         void this.filteredIndices;
         void this.showSelectedOnly;
-        const dataRepo = this.dataRepo;
+        void this.selectedItems.size;
         if (this.paginationRepo?.paginationType == PaginationType.Local) {
             const data = this.showSelectedOnly
                 ? // FIXME this will show the selected items by order of insertion to the selectedItems map.
                     [...this.selectedItems.values()]
                 : this.filteredIndices.map((index) => {
-                    return dataRepo.data[index];
+                    return this.dataRepo.data[index];
                 });
             return data;
         }
         if (this.debug) {
             console.log(`updating filtered data. Selected only: ${this.showSelectedOnly}`);
         }
-        return this.showSelectedOnly ? [...this.selectedItems.values()] : dataRepo.data;
+        return this.showSelectedOnly ? [...this.selectedItems.values()] : this.dataRepo.data;
     });
-    // eslint-disable-next-line @typescript-eslint/require-await
+    sortedDataAbortController = null;
     sortedData = $derived.by(async () => {
+        // if (!$effect.tracking()) {
+        // 	throw new Error(`sorted data is not in a tracking context`);
+        // }
+        void this.filteredData;
+        void this.dataRepo.sorting;
+        this.sortedDataAbortController?.abort();
+        const currentController = (this.sortedDataAbortController = new AbortController());
         if (this.debug) {
             console.log('sorted data');
         }
-        const fd = this.filteredData;
-        const sorting = this.dataRepo.sorting;
         if (this.paginationRepo?.paginationType == PaginationType.Local) {
-            const dataToSort = fd.concat();
+            const data = await this.filteredData;
+            if (currentController.signal.aborted) {
+                return [];
+            }
+            const dataToSort = data.concat();
             dataToSort.sort((a, b) => {
-                const end = sorting.length;
+                if (currentController.signal.aborted) {
+                    return 0;
+                }
+                const end = this.dataRepo.sorting.length;
                 for (let i = 0; i < end; i++) {
-                    const { id, desc } = sorting[i];
+                    const { id, desc } = this.dataRepo.sorting[i];
                     const sortingFn = this.getSortingFn(id, desc);
                     if (sortingFn) {
+                        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                        if (currentController.signal.aborted) {
+                            return 0;
+                        }
                         const result = sortingFn(a, b);
                         if (result != 0) {
+                            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                            if (currentController.signal.aborted) {
+                                return 0;
+                            }
                             return result;
                         }
                     }
@@ -647,11 +627,14 @@ export class TableContext {
             });
             return dataToSort;
         }
-        return fd;
+        return this.filteredData;
     });
     sortedRowModel = $derived.by(async () => {
         void this.originalRowIndices;
         void this.sortedData;
+        // if (!$effect.tracking()) {
+        // 	throw new Error(`filtered indices are not in a tracking context`);
+        // }
         const sd = await this.sortedData;
         const ori = await this.originalRowIndices;
         const rows = await asyncMap(sd, async (item, index) => {
@@ -662,54 +645,110 @@ export class TableContext {
             }
             return this.createRow(item, index, unsortedIndex);
         });
+        const rowsById = $derived(new SvelteMap(rows.map((it, index) => [index.toString(), it]))); //FIXME should this be by sorted id or by original id?
         return {
-            rows,
-            // eslint-disable-next-line svelte/prefer-svelte-reactivity
-            rowsById: new Map(rows.map((it, index) => [index.toString(), it])), //FIXME should this be by sorted id or by original id?
+            get rows() {
+                return rows;
+            },
+            get rowsById() {
+                return rowsById;
+            },
         };
     });
+    CurrentPageDataAbortController = null;
     currentPageData = $derived.by(async () => {
+        // void this.originalRowIndices;
         void this.sortedData;
-        const dataRepo = this.dataRepo;
+        void this.dataRepo.pageStartIndex;
+        void this.dataRepo.pageEndIndexExclusive;
+        // if (!$effect.tracking()) {
+        // 	throw new Error(`Current Page Data is not in a tracking context`);
+        // }
+        this.CurrentPageDataAbortController?.abort();
+        const currentController = (this.CurrentPageDataAbortController = new AbortController());
         const sd = await this.sortedData;
-        if (dataRepo.paginationType != PaginationType.Local) {
+        if (currentController.signal.aborted) {
+            return [];
+        }
+        if (this.dataRepo.paginationType != PaginationType.Local) {
             return sd;
         }
-        const x = sd.slice(dataRepo.pageStartIndex, dataRepo.pageEndIndexExclusive);
-        return x;
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        if (currentController.signal.aborted) {
+            return [];
+        }
+        return sd.slice(this.dataRepo.pageStartIndex, this.dataRepo.pageEndIndexExclusive);
     });
-    // FIXME this is most likely the cuplrit for add pod not working on receipt. It may be one tick behind the other values
+    // FIXME this is most likely the cuplrit for add pod not working on receipt.
+    // Tracking changes in a promise of a map is a problem
+    // worst case fix: turn it into a map of promises
     originalRowIndices = $derived.by(async () => {
         const dataRepo = this.dataRepo;
         const awaited = await asyncMap(dataRepo.data, async (item, index) => [await this.selectionExtractor(item), index]);
-        // eslint-disable-next-line svelte/prefer-svelte-reactivity
-        return new Map(awaited);
+        return new SvelteMap(awaited);
     });
-    paginationRowModel = $derived.by(async () => {
-        void this.originalRowIndices;
+    rowsPromiseAbortController = null;
+    rowsPromise = $derived.by(async () => {
+        // void this.originalRowIndices;
         void this.currentPageData;
-        void this.columnDefsById;
+        // void this.columnDefsById;
         void this.columnVisibility;
         void this.paginationRepo?.sorting;
         void this.columnPinning;
+        this.rowsPromiseAbortController?.abort();
+        const currentController = (this.rowsPromiseAbortController = new AbortController());
         const currentPageData = await this.currentPageData;
-        const rows = await asyncMap(currentPageData, async (item, index) => {
-            const unsortedIndex = (await this.originalRowIndices).get(item) ?? index;
-            const row = {
-                getValue: async (key) => {
+        if (currentController.signal.aborted) {
+            return [];
+        }
+        const indices = await this.originalRowIndices;
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        if (currentController.signal.aborted) {
+            return [];
+        }
+        return currentPageData.map((item, index) => {
+            const unsortedIndex = indices.get(item) ?? index;
+            const getValue = $derived.by(() => {
+                void item;
+                void index;
+                return async (key) => {
+                    void item;
+                    void index;
+                    // if (!$effect.tracking()) {
+                    // 	throw new Error(`filtered indices are not in a tracking context`);
+                    // }
                     const gotValue = await this.columnDefsById.get(key)?.accessorFn?.(item, index);
                     if (gotValue !== undefined) {
                         return gotValue;
                     }
                     return item[key];
+                };
+            });
+            const row = {
+                get getValue() {
+                    return getValue;
+                },
+                get original() {
+                    return item;
+                },
+                get visibleIndex() {
+                    return index;
+                },
+                get originalIndex() {
+                    return unsortedIndex;
+                },
+                get id() {
+                    return index.toString();
+                },
+                get getLeftVisibleCells() {
+                    return () => leftVisibleCells;
+                },
+                get getRightVisibleCells() {
+                    return () => rightVisibleCells;
+                },
+                get getCenterVisibleCells() {
+                    return () => centerVisibleCells;
                 },
-                original: item,
-                visibleIndex: index,
-                originalIndex: unsortedIndex,
-                id: index.toString(),
-                getLeftVisibleCells: () => leftVisibleCells,
-                getRightVisibleCells: () => rightVisibleCells,
-                getCenterVisibleCells: () => centerVisibleCells,
             };
             const makeRow = (def) => {
                 const isSorted = $derived.by(() => {
@@ -723,24 +762,43 @@ export class TableContext {
                     return 'asc';
                 });
                 const isVisible = $derived(this.columnVisibility[def.id] != false);
+                const getToggleSortingHandler = $derived(() => def.allowSorting ? this.getToggleSortingHandler(def) : undefined);
                 return {
                     column: {
-                        columnDef: def,
-                        getCanSort: () => def.allowSorting,
-                        getIsResizing: () => def.isResizing,
-                        getIsSorted: () => isSorted,
-                        getIsVisible: () => isVisible,
-                        getToggleSortingHandler: () => def.allowSorting ? this.getToggleSortingHandler(def) : undefined,
-                        id: def.id,
+                        get columnDef() {
+                            return def;
+                        },
+                        get getCanSort() {
+                            return () => def.allowSorting;
+                        },
+                        get getIsResizing() {
+                            return () => def.isResizing;
+                        },
+                        get getIsSorted() {
+                            return () => isSorted;
+                        },
+                        get getIsVisible() {
+                            return () => isVisible;
+                        },
+                        get id() {
+                            return def.id;
+                        },
+                        get getToggleSortingHandler() {
+                            return getToggleSortingHandler;
+                        },
                     },
                     id: `${index}_${def.id}`,
-                    row: row,
-                    getValue: () => {
-                        const gotValue = def.accessorFn?.(item, index);
-                        if (gotValue !== undefined) {
-                            return gotValue;
-                        }
-                        return item[def.id];
+                    get row() {
+                        return row;
+                    },
+                    get getValue() {
+                        return () => {
+                            const gotValue = def.accessorFn?.(item, index);
+                            if (gotValue !== undefined) {
+                                return gotValue;
+                            }
+                            return item[def.id];
+                        };
                     },
                 };
             };
@@ -760,19 +818,30 @@ export class TableContext {
                 .map(makeRow));
             return row;
         });
+    });
+    paginationRowModel = $derived.by(async () => {
+        void this.rowsPromise;
+        const rows = await this.rowsPromise;
         return {
             rows,
-            // eslint-disable-next-line svelte/prefer-svelte-reactivity
-            rowsById: new Map(rows.map((it, index) => [index.toString(), it])), //FIXME should this be by sorted id or by original id?
+            rowsById: new SvelteMap(rows.map((it, index) => [index.toString(), it])), //FIXME should this be by sorted id or by original id?
         };
     });
     // #endregion
     // #region public methods
     selectionContains = async (item) => {
+        void item;
+        void this.isSelectable;
+        void this.selectedItems.size;
+        // if (!$effect.tracking()) {
+        // 	throw new Error(`selectionContains is not ran in a tracking context`);
+        // }
         if (!this.isSelectable) {
             return true;
         }
-        return this.selectedItems.has(await this.selectionExtractor(item));
+        const identity = await this.selectionExtractor(item);
+        const has = this.selectedItems.has(identity);
+        return has;
     };
     addInvalidValue = async (item) => {
         this.invalidValues.set(await this.selectionExtractor(item), item);
@@ -795,7 +864,16 @@ export class TableContext {
     resetHighlightedRows = () => {
         this.highlightedItems.clear();
     };
-    toggleSelected = async (item, selected) => {
+    toggleSelected = async (item) => {
+        const key = await this.selectionExtractor(item);
+        if (this.selectedItems.has(key)) {
+            this.selectedItems.delete(key);
+        }
+        else {
+            this.selectedItems.set(key, item);
+        }
+    };
+    setSelected = async (item, selected) => {
         const key = await this.selectionExtractor(item);
         if (selected) {
             this.selectedItems.set(key, item);
@@ -805,7 +883,7 @@ export class TableContext {
         }
     };
     setSelectionMap = (set) => {
-        this.selectedItems = set;
+        this._selectedItems = set;
     };
     updateSelectedItems = async () => {
         const pageStartIndex = this.paginationRepo ? this.paginationRepo.pageStartIndex : 0;
@@ -1133,14 +1211,13 @@ export class TableContext {
         }
         // this.forceVisibilityUpdate();
     };
-    updateColumnSizing = (stateOrCallback) => {
-        if (typeof stateOrCallback == 'function') {
-            this.columnSizing = stateOrCallback(this.columnSizing);
-        }
-        else {
-            this.columnSizing = stateOrCallback;
-        }
-    };
+    // public updateColumnSizing: OnChangeFn<ColumnSizingState> = (stateOrCallback) => {
+    // 	if (typeof stateOrCallback == 'function') {
+    // 		this.columnSizing = stateOrCallback(this.columnSizing);
+    // 	} else {
+    // 		this.columnSizing = stateOrCallback;
+    // 	}
+    // };
     table = $derived(generateTableOptions(this));
     // private _rowModel = $derived<RowModel<T> | undefined>(this.dataRepo?.data && this.table.rowModel);
     // public get rowModel() {
@@ -1275,8 +1352,7 @@ export class TableContext {
     _performRowCopy = async ({ items, indicesByItem, focusedElementData, affectedColumns, }) => {
         const focusedColumnIds = affectedColumns.map((it) => encapsulate(typeof it.header === 'string' ? it.header : it.id));
         const value = await (async () => {
-            // eslint-disable-next-line svelte/prefer-svelte-reactivity
-            const selectColumns = new Map();
+            const selectColumns = new SvelteMap();
             for (let i = affectedColumns.length - 1; i > -1; i--) {
                 const columnDef = affectedColumns[i];
                 if (columnDef instanceof SelectDef) {
@@ -1788,6 +1864,9 @@ export class TableContext {
             console.warn('no focusEnd found');
             return;
         }
+        // if (!$effect.tracking()) {
+        // 	throw new Error(`_moveFocusEndRow is not in a tracking context.`);
+        // }
         const focusEnd = this.focusEnd;
         const rows = (await this.paginationRowModel).rows;
         const endRowIndex = rows.findIndex((row) => row.visibleIndex === focusEnd.row);
@@ -1809,47 +1888,9 @@ export class TableContext {
         })();
         this.moveFocus({ ...this.focusStart, row: newEndRowIndex });
     }
-    async _recalculateFocusedElements() {
-        if (!this.focusStart || !this.focusEnd) {
-            this.focusedRowIndexIds = new SvelteSet();
-            this.focusedColumnIds = new SvelteSet();
-            return;
-        }
-        const { row: startRowIndexId, column: startColumnIndex } = this.focusStart;
-        const { row: endRowIndexId, column: endColumnIndex } = this.focusEnd;
-        const model = await this.sortedRowModel;
-        const startRowIndex = model.rows.findIndex((row) => row.visibleIndex === startRowIndexId);
-        const endRowIndex = model.rows.findIndex((row) => row.visibleIndex === endRowIndexId);
-        if (startRowIndex == -1 || endRowIndex == -1) {
-            return;
-        }
-        const minRowIndex = Math.min(startRowIndex, endRowIndex);
-        const maxRowIndex = Math.max(startRowIndex, endRowIndex);
-        const minColumnIndex = Math.min(startColumnIndex, endColumnIndex);
-        const maxColumnIndex = Math.max(startColumnIndex, endColumnIndex);
-        const affectedColumns = new SvelteSet();
-        const visibility = this.columnVisibility;
-        this.columnDefs
-            .filter((it) => 'index' in it &&
-            visibility[it.id] !== false &&
-            // TODO handle pinning behaviour
-            // !columnPinning.left?.includes(it.id) &&
-            // !columnPinning.right?.includes(it.id) &&
-            // (!('columnType' in it) || it.columnType === undefined || it.columnType === 'Accessor') &&
-            it.index >= minColumnIndex &&
-            it.index <= maxColumnIndex)
-            .forEach((it) => affectedColumns.add(it.id));
-        const indices = new SvelteSet();
-        for (let i = minRowIndex; i <= maxRowIndex; i++) {
-            indices.add(parseInt(model.rows[i].id));
-        }
-        this.focusedRowIndexIds = indices;
-        this.focusedColumnIds = affectedColumns;
-    }
     async getHighlightedRowData() {
         const affectedColumns = this.columnDefs.filter(this.columnDefReturnsTextValue);
-        // eslint-disable-next-line svelte/prefer-svelte-reactivity
-        const indices = new Map();
+        const indices = new SvelteMap();
         const selectedRows = [...this.highlightedItems.values()];
         const sortedData = await this.sortedData;
         for (const item of selectedRows) {
@@ -1924,8 +1965,7 @@ export class TableContext {
                     this.columnDefReturnsTextValue(it));
             });
             const selectedRows = [];
-            // eslint-disable-next-line svelte/prefer-svelte-reactivity
-            const indices = new Map();
+            const indices = new SvelteMap();
             for (let i = minRowIndex; i <= maxRowIndex; i++) {
                 const row = model.rows[i];
                 const item = row.original;
@@ -1977,8 +2017,12 @@ export class TableContext {
                 affectedColumns,
             };
         }
-        // eslint-disable-next-line svelte/prefer-svelte-reactivity
-        return { items: [], indicesByItem: new Map(), focusedElementData: [], affectedColumns: [] };
+        return {
+            items: [],
+            indicesByItem: new SvelteMap(),
+            focusedElementData: [],
+            affectedColumns: [],
+        };
     }
     updateDefsBasedOnPinning = () => {
         const leftDefs = [];
@@ -2005,8 +2049,7 @@ export class TableContext {
         return allDefs;
     };
     assertNoDuplicateIds() {
-        // eslint-disable-next-line svelte/prefer-svelte-reactivity
-        const foundIds = new Set();
+        const foundIds = new SvelteSet();
         this.defaultColumnDefs.defs.forEach((def) => {
             if (foundIds.has(def.id)) {
                 throw new Error(`Duplicate Column Definition ID ${def.id} in table ${this.tableName}`);
@@ -2180,15 +2223,13 @@ export class TableContext {
     }
     _setNewPinningState() {
         this.columnPinning = {
-            // eslint-disable-next-line svelte/prefer-svelte-reactivity
-            left: new Map(this.columnPinning.left &&
+            left: new SvelteMap(this.columnPinning.left &&
                 this.columnDefs
                     .filter((col) => {
                     return this.columnPinning.left?.has(col.id);
                 })
                     .map((col, index) => [col.id, index])),
-            // eslint-disable-next-line svelte/prefer-svelte-reactivity
-            right: new Map(this.columnPinning.right &&
+            right: new SvelteMap(this.columnPinning.right &&
                 this.columnDefs
                     .filter((col) => this.columnPinning.right?.has(col.id))
                     .map((col, index) => [col.id, index])),
@@ -2238,22 +2279,6 @@ export class TableContext {
             };
         });
     }
-    async filteringLoop(currentTimer, abortController, settled, startTime) {
-        for (;;) {
-            if (currentTimer !== this.filterTimer) {
-                if (this.debug) {
-                    console.log(`aborting due to stale data`);
-                }
-                abortController.abort('stale data');
-                return;
-            }
-            if (settled.value) {
-                console.log(`iteration ${currentTimer} finished ${Date.now() - startTime}ms`);
-                return;
-            }
-            await tick();
-        }
-    }
 }
 // #region static functions
 function areDefsEquivalent(newColumnDefs, oldColumnDefs) {
@@ -2283,8 +2308,7 @@ function areDefsEquivalent(newColumnDefs, oldColumnDefs) {
     });
 }
 function columnDefsToMap(defs) {
-    // eslint-disable-next-line svelte/prefer-svelte-reactivity
-    const map = new Map();
+    const map = new SvelteMap();
     defs.forEach((def) => {
         map.set(def.id, def);
     });
@@ -2450,9 +2474,9 @@ function generateTableOptions(contextObj) {
         get onColumnVisibilityChange() {
             return contextObj.updateVisibility;
         },
-        get onColumnSizingChange() {
-            return contextObj.updateColumnSizing;
-        },
+        // get onColumnSizingChange() {
+        // 	return contextObj.updateColumnSizing;
+        // },
         get onColumnFiltersChange() {
             return contextObj.updateFilters;
         },