@humanspeak/svelte-headless-table 6.0.1 → 6.0.3

package/dist/plugins/addSortBy.d.ts

@@ -1,46 +1,123 @@
 import { type Readable, type Writable } from 'svelte/store';
 import type { BodyRow } from '../bodyRows.js';
 import type { NewTablePropSet, TablePlugin } from '../types/TablePlugin.js';
+/**
+ * Configuration options for the addSortBy plugin.
+ */
 export interface SortByConfig {
+    /** Initial sort keys to apply on mount. */
     initialSortKeys?: SortKey[];
+    /** If true, prevents sorting by multiple columns. Defaults to false. */
     disableMultiSort?: boolean;
-    isMultiSortEvent?: (event: Event) => boolean;
+    /** Function to detect multi-sort events (e.g., shift+click). Defaults to isShiftClick. */
+    isMultiSortEvent?: (_event: Event) => boolean;
+    /** Custom toggle order cycle. Defaults to ['asc', 'desc', undefined]. */
     toggleOrder?: ('asc' | 'desc' | undefined)[];
+    /** If true, sorting is handled server-side and rows are returned as-is. */
     serverSide?: boolean;
 }
+/**
+ * State exposed by the addSortBy plugin.
+ *
+ * @template Item - The type of data items in the table.
+ */
 export interface SortByState<Item> {
+    /** Writable store containing the current sort keys. */
     sortKeys: WritableSortKeys;
+    /** Readable store containing the rows before sorting was applied. */
     preSortedRows: Readable<BodyRow<Item>[]>;
 }
+/**
+ * Per-column configuration options for sorting.
+ */
 export interface SortByColumnOptions {
+    /** If true, this column cannot be sorted. */
     disable?: boolean;
-    getSortValue?: (value: any) => string | number | (string | number)[];
-    compareFn?: (left: any, right: any) => number;
+    /** Custom function to extract the sortable value from the cell value. */
+    getSortValue?: (_value: any) => string | number | (string | number)[];
+    /** Custom comparison function for sorting. */
+    compareFn?: (_left: any, _right: any) => number;
+    /** If true, inverts the sort order for this column. */
     invert?: boolean;
 }
+/**
+ * Props added to table elements by the sort plugin.
+ */
 export type SortByPropSet = NewTablePropSet<{
     'thead.tr.th': {
+        /** Current sort order for this column. */
         order: 'asc' | 'desc' | undefined;
-        toggle: (event: Event) => void;
+        /** Function to toggle sorting on this column. */
+        toggle: (_event: Event) => void;
+        /** Function to clear sorting on this column. */
         clear: () => void;
+        /** Whether sorting is disabled for this column. */
         disabled: boolean;
     };
     'tbody.tr.td': {
+        /** Current sort order for this column. */
         order: 'asc' | 'desc' | undefined;
     };
 }>;
+/**
+ * Represents a single sort key with column ID and direction.
+ */
 export interface SortKey {
+    /** The column ID to sort by. */
     id: string;
+    /** The sort direction. */
     order: 'asc' | 'desc';
 }
+/**
+ * Creates a writable store for managing sort keys with toggle and clear methods.
+ *
+ * @param initKeys - Initial sort keys.
+ * @returns A WritableSortKeys store with toggle and clear functionality.
+ * @example
+ * ```typescript
+ * const sortKeys = createSortKeysStore([{ id: 'name', order: 'asc' }])
+ * sortKeys.toggleId('age') // Adds ascending sort by age
+ * sortKeys.clearId('name') // Removes sort by name
+ * ```
+ */
 export declare const createSortKeysStore: (initKeys: SortKey[]) => WritableSortKeys;
+/**
+ * Options for the toggleId method.
+ */
 interface ToggleOptions {
+    /** Whether to allow multiple sort keys. */
     multiSort?: boolean;
+    /** Custom toggle order cycle. */
     toggleOrder?: ('asc' | 'desc' | undefined)[];
 }
+/**
+ * A writable store for sort keys with additional toggle and clear methods.
+ */
 export type WritableSortKeys = Writable<SortKey[]> & {
-    toggleId: (id: string, options: ToggleOptions) => void;
-    clearId: (id: string) => void;
+    /** Toggles the sort state for a column ID. */
+    toggleId: (_id: string, _options: ToggleOptions) => void;
+    /** Clears the sort state for a column ID. */
+    clearId: (_id: string) => void;
 };
+/**
+ * Creates a sort plugin that enables sorting table rows by one or more columns.
+ * Supports ascending, descending, and unsorted states with customizable toggle order.
+ *
+ * @template Item - The type of data items in the table.
+ * @param config - Configuration options for sorting behavior.
+ * @returns A TablePlugin that provides sorting functionality.
+ * @example
+ * ```typescript
+ * const table = createTable(data, {
+ *   sort: addSortBy({
+ *     initialSortKeys: [{ id: 'name', order: 'asc' }],
+ *     disableMultiSort: false
+ *   })
+ * })
+ *
+ * // Access sort state in your component
+ * const { sortKeys } = table.pluginStates.sort
+ * ```
+ */
 export declare const addSortBy: <Item>({ initialSortKeys, disableMultiSort, isMultiSortEvent, toggleOrder, serverSide }?: SortByConfig) => TablePlugin<Item, SortByState<Item>, SortByColumnOptions, SortByPropSet>;
 export {};

package/dist/plugins/addSortBy.js

@@ -2,6 +2,18 @@ import { derived, writable } from 'svelte/store';
 import { compare } from '../utils/compare.js';
 import { isShiftClick } from '../utils/event.js';
 const DEFAULT_TOGGLE_ORDER = ['asc', 'desc', undefined];
+/**
+ * Creates a writable store for managing sort keys with toggle and clear methods.
+ *
+ * @param initKeys - Initial sort keys.
+ * @returns A WritableSortKeys store with toggle and clear functionality.
+ * @example
+ * ```typescript
+ * const sortKeys = createSortKeysStore([{ id: 'name', order: 'asc' }])
+ * sortKeys.toggleId('age') // Adds ascending sort by age
+ * sortKeys.clearId('name') // Removes sort by name
+ * ```
+ */
 export const createSortKeysStore = (initKeys) => {
     const { subscribe, update, set } = writable(initKeys);
     const toggleId = (id, { multiSort = true, toggleOrder = DEFAULT_TOGGLE_ORDER } = {}) => {
@@ -48,18 +60,35 @@ export const createSortKeysStore = (initKeys) => {
         clearId
     };
 };
+/**
+ * Sorts rows based on the provided sort keys and column options.
+ * Recursively sorts subRows as well.
+ *
+ * @template Item - The type of data items.
+ * @template Row - The row type.
+ * @param rows - The rows to sort.
+ * @param sortKeys - The sort keys to apply.
+ * @param columnOptions - Per-column sort configuration.
+ * @returns A new array of sorted rows.
+ * @internal
+ */
 const getSortedRows = (rows, sortKeys, columnOptions) => {
+    // Pre-compute sort config for each key to avoid repeated lookups during comparison
+    const sortConfig = sortKeys.map((key) => ({
+        id: key.id,
+        order: key.order,
+        invert: columnOptions[key.id]?.invert ?? false,
+        compareFn: columnOptions[key.id]?.compareFn,
+        getSortValue: columnOptions[key.id]?.getSortValue,
+        orderFactor: (key.order === 'desc' ? -1 : 1) * (columnOptions[key.id]?.invert ? -1 : 1)
+    }));
     // Shallow clone to prevent sort affecting `preSortedRows`.
     const $sortedRows = [...rows];
     $sortedRows.sort((a, b) => {
-        for (const key of sortKeys) {
-            const invert = columnOptions[key.id]?.invert ?? false;
+        for (const config of sortConfig) {
             // TODO check why cellForId returns `undefined`.
-            const cellA = a.cellForId[key.id];
-            const cellB = b.cellForId[key.id];
-            let order = 0;
-            const compareFn = columnOptions[key.id]?.compareFn;
-            const getSortValue = columnOptions[key.id]?.getSortValue;
+            const cellA = a.cellForId[config.id];
+            const cellB = b.cellForId[config.id];
             // Only need to check properties of `cellA` as both should have the same
             // properties.
             if (!cellA.isData()) {
@@ -67,12 +96,13 @@ const getSortedRows = (rows, sortKeys, columnOptions) => {
             }
             const valueA = cellA.value;
             const valueB = cellB.value;
-            if (compareFn !== undefined) {
-                order = compareFn(valueA, valueB);
+            let order = 0;
+            if (config.compareFn !== undefined) {
+                order = config.compareFn(valueA, valueB);
             }
-            else if (getSortValue !== undefined) {
-                const sortValueA = getSortValue(valueA);
-                const sortValueB = getSortValue(valueB);
+            else if (config.getSortValue !== undefined) {
+                const sortValueA = config.getSortValue(valueA);
+                const sortValueB = config.getSortValue(valueB);
                 order = compare(sortValueA, sortValueB);
             }
             else if (typeof valueA === 'string' || typeof valueA === 'number') {
@@ -85,17 +115,7 @@ const getSortedRows = (rows, sortKeys, columnOptions) => {
                 order = compare(sortValueA, sortValueB);
             }
             if (order !== 0) {
-                let orderFactor = 1;
-                // If the current key order is `'desc'`, reverse the order.
-                if (key.order === 'desc') {
-                    orderFactor *= -1;
-                }
-                // If `invert` is `true`, we want to invert the sort without
-                // affecting the view model's indication.
-                if (invert) {
-                    orderFactor *= -1;
-                }
-                return order * orderFactor;
+                return order * config.orderFactor;
             }
         }
         return 0;
@@ -112,6 +132,26 @@ const getSortedRows = (rows, sortKeys, columnOptions) => {
     }
     return $sortedRows;
 };
+/**
+ * Creates a sort plugin that enables sorting table rows by one or more columns.
+ * Supports ascending, descending, and unsorted states with customizable toggle order.
+ *
+ * @template Item - The type of data items in the table.
+ * @param config - Configuration options for sorting behavior.
+ * @returns A TablePlugin that provides sorting functionality.
+ * @example
+ * ```typescript
+ * const table = createTable(data, {
+ *   sort: addSortBy({
+ *     initialSortKeys: [{ id: 'name', order: 'asc' }],
+ *     disableMultiSort: false
+ *   })
+ * })
+ *
+ * // Access sort state in your component
+ * const { sortKeys } = table.pluginStates.sort
+ * ```
+ */
 export const addSortBy = ({ initialSortKeys = [], disableMultiSort = false, isMultiSortEvent = isShiftClick, toggleOrder, serverSide = false } = {}) => ({ columnOptions }) => {
     const disabledSortIds = Object.entries(columnOptions)
         .filter(([, option]) => option.disable === true)
@@ -121,7 +161,8 @@ export const addSortBy = ({ initialSortKeys = [], disableMultiSort = false, isMu
     const deriveRows = (rows) => {
         return derived([rows, sortKeys], ([$rows, $sortKeys]) => {
             preSortedRows.set($rows);
-            if (serverSide) {
+            // Early return if no sorting needed
+            if (serverSide || $sortKeys.length === 0) {
                 return $rows;
             }
             return getSortedRows($rows, $sortKeys, columnOptions);

package/dist/plugins/addSubRows.d.ts

@@ -1,9 +1,47 @@
 import type { NewTablePropSet, TablePlugin } from '../types/TablePlugin.js';
+/**
+ * Utility type that extracts keys from Item whose values are arrays of Item.
+ * Used to infer valid children property keys.
+ *
+ * @template Item - The type of data items.
+ */
 export type ValidChildrenKey<Item> = {
     [Key in keyof Item]: Item[Key] extends Item[] ? Key : never;
 }[keyof Item];
-export type ValidChildrenFn<Item> = (item: Item) => Item[] | undefined;
+/**
+ * Function type for extracting child items from a parent item.
+ *
+ * @template Item - The type of data items.
+ */
+export type ValidChildrenFn<Item> = (_item: Item) => Item[] | undefined;
+/**
+ * Configuration options for the addSubRows plugin.
+ *
+ * @template Item - The type of data items.
+ */
 export interface SubRowsConfig<Item> {
+    /** Property key or function to extract child items from each item. */
     children: ValidChildrenKey<Item> | ValidChildrenFn<Item>;
 }
+/**
+ * Creates a sub-rows plugin that enables hierarchical data display.
+ * Extracts child items from each row using the specified children accessor.
+ *
+ * @template Item - The type of data items in the table.
+ * @param config - Configuration with the children accessor.
+ * @returns A TablePlugin that creates hierarchical row structure.
+ * @example
+ * ```typescript
+ * interface Employee {
+ *   name: string
+ *   directReports?: Employee[]
+ * }
+ *
+ * const table = createTable(data, {
+ *   subRows: addSubRows({
+ *     children: 'directReports' // or: (item) => item.directReports
+ *   })
+ * })
+ * ```
+ */
 export declare const addSubRows: <Item>({ children }: SubRowsConfig<Item>) => TablePlugin<Item, Record<string, never>, Record<string, never>, NewTablePropSet<never>>;

package/dist/plugins/addSubRows.js

@@ -1,5 +1,9 @@
 import { derived } from 'svelte/store';
 import { DataBodyRow, getSubRows } from '../bodyRows.js';
+/**
+ * Recursively adds sub-rows to a row based on the children accessor.
+ * @internal
+ */
 const withSubRows = (row, getChildren) => {
     const subItems = getChildren(row.original);
     if (subItems === undefined) {
@@ -9,6 +13,27 @@ const withSubRows = (row, getChildren) => {
     row.subRows = subRows.map((row) => withSubRows(row, getChildren));
     return row;
 };
+/**
+ * Creates a sub-rows plugin that enables hierarchical data display.
+ * Extracts child items from each row using the specified children accessor.
+ *
+ * @template Item - The type of data items in the table.
+ * @param config - Configuration with the children accessor.
+ * @returns A TablePlugin that creates hierarchical row structure.
+ * @example
+ * ```typescript
+ * interface Employee {
+ *   name: string
+ *   directReports?: Employee[]
+ * }
+ *
+ * const table = createTable(data, {
+ *   subRows: addSubRows({
+ *     children: 'directReports' // or: (item) => item.directReports
+ *   })
+ * })
+ * ```
+ */
 export const addSubRows = ({ children }) => () => {
     const getChildren = children instanceof Function ? children : (item) => item[children];
     const deriveRows = (rows) => {

package/dist/plugins/addTableFilter.d.ts

@@ -1,28 +1,112 @@
 import { type Readable, type Writable } from 'svelte/store';
 import type { BodyRow } from '../bodyRows.js';
 import type { NewTablePropSet, TablePlugin } from '../types/TablePlugin.js';
+/**
+ * Configuration options for the addTableFilter plugin.
+ */
 export interface TableFilterConfig {
+    /** Custom filter function. Defaults to textPrefixFilter. */
     fn?: TableFilterFn;
+    /** Initial filter value. Defaults to empty string. */
     initialFilterValue?: string;
+    /** Whether to include hidden columns in the filter. Defaults to false. */
     includeHiddenColumns?: boolean;
+    /** If true, filtering is handled server-side and all rows are returned. Defaults to false. */
     serverSide?: boolean;
 }
+/**
+ * State exposed by the addTableFilter plugin.
+ *
+ * @template Item - The type of data items in the table.
+ */
 export interface TableFilterState<Item> {
+    /** Writable store containing the current filter value. */
     filterValue: Writable<string>;
+    /** Readable store containing the rows before filtering was applied. */
     preFilteredRows: Readable<BodyRow<Item>[]>;
 }
-export interface TableFilterColumnOptions<Item> {
+/**
+ * Per-column configuration options for the table filter.
+ *
+ * @template _Item - The type of data items (unused but required for type inference).
+ */
+export interface TableFilterColumnOptions<_Item> {
+    /** If true, this column is excluded from filtering. */
     exclude?: boolean;
-    getFilterValue?: (value: any) => string;
+    /** Custom function to extract the filter value from the cell value. */
+    getFilterValue?: (_value: any) => string;
 }
-export type TableFilterFn = (props: TableFilterFnProps) => boolean;
+/**
+ * Function type for custom filter implementations.
+ *
+ * @param props - The filter function props containing the filter value and cell value.
+ * @returns True if the value matches the filter.
+ */
+export type TableFilterFn = (_props: TableFilterFnProps) => boolean;
+/**
+ * Props passed to a TableFilterFn.
+ */
 export type TableFilterFnProps = {
+    /** The current filter value entered by the user. */
     filterValue: string;
+    /** The string value of the cell being tested. */
     value: string;
 };
+/**
+ * Props added to tbody.tr.td elements by the table filter plugin.
+ */
 export type TableFilterPropSet = NewTablePropSet<{
     'tbody.tr.td': {
+        /** True if this cell matches the current filter. */
         matches: boolean;
     };
 }>;
+/**
+ * Options for the rowMatchesFilter function.
+ *
+ * @template Item - The type of data items in the table.
+ */
+export interface RowMatchesFilterOptions<Item> {
+    /** Per-column filter configuration. */
+    columnOptions: Record<string, TableFilterColumnOptions<Item>>;
+    /** The current filter value. */
+    filterValue: string;
+    /** The filter function to use. */
+    fn: TableFilterFn;
+    /** Whether to include hidden columns in filtering. */
+    includeHiddenColumns: boolean;
+    /** Record to track which cells matched the filter. */
+    tableCellMatches: Record<string, boolean>;
+}
+/**
+ * Checks if a row matches the filter criteria.
+ * Uses O(1) Set-based lookups for visibility checks instead of O(m) array searches.
+ *
+ * @template Item - The type of data items in the table.
+ * @param row - The row to check.
+ * @param options - The filter options.
+ * @returns True if any cell in the row matches the filter, or if the row has subRows.
+ */
+export declare const rowMatchesFilter: <Item>(row: BodyRow<Item>, options: RowMatchesFilterOptions<Item>) => boolean;
+/**
+ * Creates a table filter plugin that enables filtering rows by text search across columns.
+ *
+ * @template Item - The type of data items in the table.
+ * @param config - Configuration options for the filter.
+ * @returns A TablePlugin that provides filtering functionality.
+ * @example
+ * ```typescript
+ * const table = createTable(data, {
+ *   filter: addTableFilter({
+ *     fn: ({ filterValue, value }) => value.toLowerCase().includes(filterValue.toLowerCase()),
+ *     initialFilterValue: '',
+ *     includeHiddenColumns: false
+ *   })
+ * })
+ *
+ * // Access the filter state
+ * const { filterValue } = table.pluginStates.filter
+ * filterValue.set('search term')
+ * ```
+ */
 export declare const addTableFilter: <Item>({ fn, initialFilterValue, includeHiddenColumns, serverSide }?: TableFilterConfig) => TablePlugin<Item, TableFilterState<Item>, TableFilterColumnOptions<Item>, TableFilterPropSet>;

package/dist/plugins/addTableFilter.js

@@ -1,7 +1,65 @@
 import { derived, writable } from 'svelte/store';
 import { recordSetStore } from '../utils/store.js';
 import { textPrefixFilter } from './addColumnFilters.js';
-const getFilteredRows = (rows, filterValue, columnOptions, { tableCellMatches, fn, includeHiddenColumns }) => {
+/**
+ * Checks if a row matches the filter criteria.
+ * Uses O(1) Set-based lookups for visibility checks instead of O(m) array searches.
+ *
+ * @template Item - The type of data items in the table.
+ * @param row - The row to check.
+ * @param options - The filter options.
+ * @returns True if any cell in the row matches the filter, or if the row has subRows.
+ */
+export const rowMatchesFilter = (row, options) => {
+    const { columnOptions, filterValue, fn, includeHiddenColumns, tableCellMatches } = options;
+    // Parent rows with children are always included
+    if ((row.subRows?.length ?? 0) !== 0) {
+        return true;
+    }
+    // Pre-compute visible cell IDs once per row - O(m)
+    // This is the optimization: uses Set.has() which is O(1) instead of .find() which is O(m)
+    const visibleCellIds = new Set(row.cells.map((c) => c.id));
+    const rowCellMatches = Object.values(row.cellForId).map((cell) => {
+        const cellOptions = columnOptions[cell.id];
+        if (cellOptions?.exclude === true) {
+            return false;
+        }
+        // O(1) lookup instead of O(m) .find()
+        const isHidden = !visibleCellIds.has(cell.id);
+        if (isHidden && !includeHiddenColumns) {
+            return false;
+        }
+        if (!cell.isData()) {
+            return false;
+        }
+        let value = cell.value;
+        if (cellOptions?.getFilterValue !== undefined) {
+            value = cellOptions.getFilterValue(value);
+        }
+        const matches = fn({ value: String(value), filterValue });
+        if (matches) {
+            const dataRowColId = cell.dataRowColId();
+            if (dataRowColId !== undefined) {
+                tableCellMatches[dataRowColId] = matches;
+            }
+        }
+        return matches;
+    });
+    return rowCellMatches.includes(true);
+};
+/**
+ * Recursively filters rows and their subRows based on the filter criteria.
+ *
+ * @template Item - The type of data items in the table.
+ * @template Row - The row type.
+ * @param rows - The rows to filter.
+ * @param filterValue - The current filter value.
+ * @param options - The filter options.
+ * @returns The filtered rows array.
+ * @internal
+ */
+const getFilteredRows = (rows, filterValue, options) => {
+    const { columnOptions, tableCellMatches, fn, includeHiddenColumns } = options;
     const $filteredRows = rows
         // Filter `subRows`
         .map((row) => {
@@ -9,50 +67,41 @@ const getFilteredRows = (rows, filterValue, columnOptions, { tableCellMatches, f
         if (subRows === undefined) {
             return row;
         }
-        const filteredSubRows = getFilteredRows(subRows, filterValue, columnOptions, {
-            tableCellMatches,
-            fn,
-            includeHiddenColumns
-        });
+        const filteredSubRows = getFilteredRows(subRows, filterValue, options);
         const clonedRow = row.clone();
         clonedRow.subRows = filteredSubRows;
         return clonedRow;
     })
-        .filter((row) => {
-        if ((row.subRows?.length ?? 0) !== 0) {
-            return true;
-        }
-        // An array of booleans, true if the cell matches the filter.
-        const rowCellMatches = Object.values(row.cellForId).map((cell) => {
-            const options = columnOptions[cell.id];
-            if (options?.exclude === true) {
-                return false;
-            }
-            const isHidden = row.cells.find((c) => c.id === cell.id) === undefined;
-            if (isHidden && !includeHiddenColumns) {
-                return false;
-            }
-            if (!cell.isData()) {
-                return false;
-            }
-            let value = cell.value;
-            if (options?.getFilterValue !== undefined) {
-                value = options?.getFilterValue(value);
-            }
-            const matches = fn({ value: String(value), filterValue });
-            if (matches) {
-                const dataRowColId = cell.dataRowColId();
-                if (dataRowColId !== undefined) {
-                    tableCellMatches[dataRowColId] = matches;
-                }
-            }
-            return matches;
-        });
-        // If any cell matches, include in the filtered results.
-        return rowCellMatches.includes(true);
-    });
+        .filter((row) => rowMatchesFilter(row, {
+        columnOptions,
+        filterValue,
+        fn,
+        includeHiddenColumns,
+        tableCellMatches
+    }));
     return $filteredRows;
 };
+/**
+ * Creates a table filter plugin that enables filtering rows by text search across columns.
+ *
+ * @template Item - The type of data items in the table.
+ * @param config - Configuration options for the filter.
+ * @returns A TablePlugin that provides filtering functionality.
+ * @example
+ * ```typescript
+ * const table = createTable(data, {
+ *   filter: addTableFilter({
+ *     fn: ({ filterValue, value }) => value.toLowerCase().includes(filterValue.toLowerCase()),
+ *     initialFilterValue: '',
+ *     includeHiddenColumns: false
+ *   })
+ * })
+ *
+ * // Access the filter state
+ * const { filterValue } = table.pluginStates.filter
+ * filterValue.set('search term')
+ * ```
+ */
 export const addTableFilter = ({ fn = textPrefixFilter, initialFilterValue = '', includeHiddenColumns = false, serverSide = false } = {}) => ({ columnOptions }) => {
     const filterValue = writable(initialFilterValue);
     const preFilteredRows = writable([]);
@@ -63,7 +112,8 @@ export const addTableFilter = ({ fn = textPrefixFilter, initialFilterValue = '',
             preFilteredRows.set($rows);
             tableCellMatches.clear();
             const $tableCellMatches = {};
-            const $filteredRows = getFilteredRows($rows, $filterValue, columnOptions, {
+            const $filteredRows = getFilteredRows($rows, $filterValue, {
+                columnOptions,
                 tableCellMatches: $tableCellMatches,
                 fn,
                 includeHiddenColumns

package/dist/plugins/cacheConfig.d.ts

@@ -0,0 +1,7 @@
+import type { CacheOptions } from '@humanspeak/memory-cache';
+/**
+ * Default configuration for row state LRU caches used by plugins.
+ * Provides automatic eviction to prevent unbounded memory growth
+ * when row identities change.
+ */
+export declare const DEFAULT_ROW_STATE_CACHE_CONFIG: CacheOptions;

package/dist/plugins/cacheConfig.js

@@ -0,0 +1,11 @@
+/**
+ * Default configuration for row state LRU caches used by plugins.
+ * Provides automatic eviction to prevent unbounded memory growth
+ * when row identities change.
+ */
+export const DEFAULT_ROW_STATE_CACHE_CONFIG = {
+    /** Maximum number of row state entries before LRU eviction */
+    maxSize: 1000,
+    /** Time-to-live in milliseconds (5 minutes) */
+    ttl: 5 * 60 * 1000
+};