@urbicon-ui/table 6.1.4

package/dist/stores/TableStore.svelte.d.ts

@@ -0,0 +1,192 @@
+import { SvelteSet } from 'svelte/reactivity';
+import type { Column, Filter, FilterOperator, TableItem } from '..';
+import { findColumnById, getNestedValue, resolveColumnId, resolveColumnValue, resolveValueById } from '../utils';
+import type { TableState } from './concerns/types.js';
+/**
+ * Table context key (deprecated — kept for backwards compatibility).
+ * Prefer `setTableContext()`/`getTableContext()` directly; the value is
+ * no longer used internally now that the context goes through
+ * `createContext<T>()`.
+ * @deprecated Use `setTableContext`/`getTableContext` instead.
+ */
+export declare const TABLE_CONTEXT_KEY = "table";
+/**
+ * Column summary configuration.
+ * Defines which column to aggregate and how.
+ */
+export interface SummaryConfig {
+    /** Column key to aggregate */
+    column: string;
+    /** Aggregation type */
+    type: 'sum' | 'avg' | 'count' | 'min' | 'max';
+    /** Optional custom formatter for the aggregated value */
+    formatter?: (value: number) => string;
+}
+/**
+ * Configuration for table state persistence across reloads.
+ *
+ * Each `persist*` axis defaults to `true` — providing a `tableId` is
+ * enough to opt every view-state axis (filters, search, group, summary,
+ * sort, column visibility, column order) into persistence. Set
+ * individual flags to `false` to keep them volatile.
+ *
+ * Storage defaults to `localStorage` for every axis so reloads,
+ * tab-close-and-reopen, and full browser restarts all restore the view.
+ * Pass `storage: 'sessionStorage'` to limit persistence to the current
+ * tab. Pagination (current page) is never persisted — page 1 on
+ * navigation is intentional UX.
+ */
+export interface TablePersistenceConfig {
+    /** Unique identifier for this table — used as the storage-key suffix. */
+    tableId: string;
+    /** Storage type for every axis. Defaults to `localStorage`. */
+    storage?: 'localStorage' | 'sessionStorage';
+    /** Write debounce in ms. Defaults to 500. */
+    debounceMs?: number;
+    /** Persist `activeFilters`. Default `true`. */
+    persistFilters?: boolean;
+    /** Persist `searchTerm`. Default `true`. */
+    persistSearch?: boolean;
+    /** Persist `groupByKey`. Default `true`. */
+    persistGroupByKey?: boolean;
+    /** Persist `summaryConfigs`. Default `true`. */
+    persistSummaryConfigs?: boolean;
+    /** Persist `sortColumn` + `sortDirection`. Default `true`. */
+    persistSort?: boolean;
+    /** Persist hidden column ids. Default `true`. */
+    persistColumnVisibility?: boolean;
+    /** Persist column order. Default `true`. */
+    persistColumnOrder?: boolean;
+}
+/**
+ * Creates the table state by composing independent concerns.
+ *
+ * Derived chain: items → filteredItems → sortedItems → grouped → paginatedItems
+ *
+ * Each concern owns a slice of functionality (search, filtering, sorting, etc.)
+ * but all read from and write to a shared reactive state object.
+ *
+ * **Generic T erasure**: The consumer-facing `TableProps<T>` is generic, but the
+ * store operates on `TableItem` (`Record<string, unknown>`). This is intentional —
+ * Svelte's context system cannot carry generics, and the store concerns only need
+ * property access by string key. Type safety for row data is the consumer's
+ * responsibility at the `TableProps<T>` boundary.
+ */
+export declare function createTableState(persistenceConfig?: TablePersistenceConfig): {
+    state: TableState;
+    readonly filteredItems: TableItem[];
+    readonly sortedItems: TableItem[];
+    readonly paginatedItems: TableItem[];
+    readonly totalItems: number;
+    readonly totalPages: number;
+    readonly grouped: Record<string, TableItem[]>;
+    readonly summaryData: Record<string, number>;
+    readonly groupedSummaryData: Record<string, Record<string, number>>;
+    setItems: (newItems: TableItem[]) => void;
+    setColumns: (newColumns: Column[]) => void;
+    setLoading: (isLoading: boolean) => void;
+    setError: (errorMsg: string | null) => void;
+    setSearchTerm: (term: string) => void;
+    toggleAdvancedSearch: () => void;
+    addFilter: (filter: Filter) => void;
+    removeFilter: (index: number) => void;
+    removeFiltersByColumn: (column: string, operator?: FilterOperator, value?: string) => void;
+    clearAllFilters: () => void;
+    hasFilterForColumn: (column: string, operator?: FilterOperator, value?: string) => boolean;
+    handleSort: (column: string) => void;
+    setPage: (page: number) => void;
+    goToPage: (page: number) => void;
+    setItemsPerPage: (count: number) => void;
+    toggleExpand: (itemId: string | number) => void;
+    isItemExpanded: (itemId: string | number) => boolean;
+    toggleGroup: (groupName: string) => void;
+    toggleGroupExpand: (groupName: string) => void;
+    toggleAllGroups: () => void;
+    setGroupByKey: (key: string | null) => void;
+    setGroupOrder: (order: string[]) => void;
+    addSummaryConfig: (config: SummaryConfig) => void;
+    removeSummaryConfig: (column: string) => void;
+    toggleSummary: () => void;
+    setSummaryConfigs: (configs: SummaryConfig[]) => void;
+    getFormattedSummaryValue: (column: string, value: number) => string;
+    getNestedValue: typeof getNestedValue;
+    resolveColumnId: typeof resolveColumnId;
+    resolveColumnValue: typeof resolveColumnValue;
+    resolveValueById: typeof resolveValueById;
+    findColumnById: typeof findColumnById;
+    readonly allColumns: Column[];
+    readonly hiddenColumnKeys: SvelteSet<string>;
+    hideColumn: (id: string) => void;
+    showColumn: (id: string) => void;
+    toggleColumnVisibility: (id: string) => void;
+    showAllColumns: () => void;
+    readonly selectedItems: TableItem[];
+    readonly allSelected: boolean;
+    readonly someSelected: boolean;
+    selectItem: (id: string | number) => void;
+    deselectItem: (id: string | number) => void;
+    toggleItem: (id: string | number) => void;
+    selectAll: () => void;
+    deselectAll: () => void;
+    toggleAll: () => void;
+    isSelected: (id: string | number) => boolean;
+    setSelectedIds: (ids: Array<string | number>) => void;
+    readonly orderedColumns: Column[];
+    readonly columnOrder: string[];
+    initColumnOrder: (columns: Column[]) => void;
+    reorderColumn: (fromIndex: number, toIndex: number) => void;
+    resetColumnOrder: () => void;
+    getColumnIndex: (id: string) => number;
+    readonly focusedRowIndex: number;
+    resetFocus: () => void;
+    setFocusedRow: (index: number) => void;
+    moveFocus: (direction: import("./concerns/useFocusManagement.svelte.js").FocusDirection) => void;
+    isFocusedRow: (index: number) => boolean;
+    readonly query: import("..").TableQuery;
+    readonly queryKey: string;
+    setServerResult: (result: {
+        items: TableItem[];
+        totalItems: number;
+    }) => void;
+    setServerError: (error: string) => void;
+    setServerLoading: () => void;
+    readonly liveUpdateCounts: import("./concerns/useLiveUpdates.svelte.js").LiveUpdateCounts;
+    readonly hasPendingUpdates: boolean;
+    pushInsert: (item: TableItem) => void;
+    pushUpdate: (id: string | number, changes: Partial<TableItem>) => void;
+    pushDelete: (id: string | number) => void;
+    applyAllUpdates: () => void;
+    applyInserts: () => void;
+    applyUpdates: () => void;
+    applyDeletes: () => void;
+    dismissAllUpdates: () => void;
+    isRecentlyUpdated: (id: string | number) => boolean;
+    isPendingDelete: (id: string | number) => boolean;
+    clearPersistedFilters: () => void | undefined;
+    clearPersistedSearchTerm: () => void | undefined;
+    clearPersistedGroupByKey: () => void | undefined;
+    clearPersistedSummaryConfigs: () => void | undefined;
+    clearPersistedSortState: () => void | undefined;
+    clearPersistedHiddenColumns: () => void | undefined;
+    clearPersistedColumnOrder: () => void | undefined;
+    clearAllPersistentData: () => void;
+    forceSavePersistentData: () => void;
+};
+/**
+ * Creates and sets the table context.
+ * @param persistenceConfig - Optional persistence configuration for filters, search, grouping, and summaries.
+ */
+export declare function setTableContext(persistenceConfig?: TablePersistenceConfig): any;
+/**
+ * Retrieves the table context. Throws when called outside of a `<TableProvider>`
+ * — consumers within the table tree can rely on a defined return value. For the
+ * rare case where the absence of a provider must be detected, use
+ * `getTableContextRaw()` (internal) or `setTableContext()` (idempotent setter).
+ */
+export declare function getTableContext(): any;
+/**
+ * Set the table context to an externally-created `tableState`. Used by
+ * `<TableProvider>` so it can construct the state once and share it
+ * with the rest of the table tree.
+ */
+export declare function attachTableContext(tableState: ReturnType<typeof createTableState>): void;

package/dist/stores/TableStore.svelte.js

@@ -0,0 +1,362 @@
+import { createOptionalContext } from '@urbicon-ui/blocks';
+import { SvelteSet } from 'svelte/reactivity';
+import { findColumnById, getNestedValue, normalizeItems, resolveColumnId, resolveColumnValue, resolveValueById } from '../utils';
+import { useColumnOrder } from './concerns/useColumnOrder.svelte.js';
+import { useColumnVisibility } from './concerns/useColumnVisibility.svelte.js';
+import { useExpansion } from './concerns/useExpansion.svelte.js';
+import { useFiltering } from './concerns/useFiltering.svelte.js';
+import { useFocusManagement } from './concerns/useFocusManagement.svelte.js';
+import { useGrouping } from './concerns/useGrouping.svelte.js';
+import { useLiveUpdates } from './concerns/useLiveUpdates.svelte.js';
+import { usePagination } from './concerns/usePagination.svelte.js';
+import { usePersistence } from './concerns/usePersistence.svelte.js';
+import { useRemoteData } from './concerns/useRemoteData.svelte.js';
+import { useSearch } from './concerns/useSearch.svelte.js';
+import { useSelection } from './concerns/useSelection.svelte.js';
+import { useSorting } from './concerns/useSorting.svelte.js';
+import { useSummary } from './concerns/useSummary.svelte.js';
+/**
+ * Table context key (deprecated — kept for backwards compatibility).
+ * Prefer `setTableContext()`/`getTableContext()` directly; the value is
+ * no longer used internally now that the context goes through
+ * `createContext<T>()`.
+ * @deprecated Use `setTableContext`/`getTableContext` instead.
+ */
+export const TABLE_CONTEXT_KEY = 'table';
+/**
+ * Creates the table state by composing independent concerns.
+ *
+ * Derived chain: items → filteredItems → sortedItems → grouped → paginatedItems
+ *
+ * Each concern owns a slice of functionality (search, filtering, sorting, etc.)
+ * but all read from and write to a shared reactive state object.
+ *
+ * **Generic T erasure**: The consumer-facing `TableProps<T>` is generic, but the
+ * store operates on `TableItem` (`Record<string, unknown>`). This is intentional —
+ * Svelte's context system cannot carry generics, and the store concerns only need
+ * property access by string key. Type safety for row data is the consumer's
+ * responsibility at the `TableProps<T>` boundary.
+ */
+export function createTableState(persistenceConfig) {
+    // ── Shared reactive state ──
+    const state = $state({
+        items: [],
+        columns: [],
+        loading: false,
+        error: null,
+        searchTerm: '',
+        activeFilters: [],
+        showAdvancedSearch: false,
+        currentPage: 1,
+        itemsPerPage: 10,
+        sortColumn: '',
+        sortDirection: 'asc',
+        expandedItemId: null,
+        expandedItemIds: new SvelteSet(),
+        multiExpand: false,
+        groupByKey: null,
+        collapsedGroups: new SvelteSet(),
+        allGroupsExpanded: true,
+        groupOrder: [],
+        summaryConfigs: [],
+        showSummary: false,
+        selectionMode: 'none',
+        selectedIds: new SvelteSet(),
+        mode: 'client',
+        serverTotalItems: 0
+    });
+    // ── Persistence (initializes state from storage) ──
+    const persistence = usePersistence(state, persistenceConfig);
+    // ── Concerns (composed in derived-chain order) ──
+    const search = useSearch(state);
+    const filtering = useFiltering(state);
+    const sorting = useSorting(state, () => filtering.filteredItems);
+    const grouping = useGrouping(state, () => sorting.sortedItems);
+    const pagination = usePagination(state, () => filtering.filteredItems, () => sorting.sortedItems);
+    const expansion = useExpansion(state);
+    const columnVisibility = useColumnVisibility(state);
+    const summary = useSummary(state, () => sorting.sortedItems, () => grouping.grouped);
+    const selection = useSelection(state, () => filtering.filteredItems);
+    const columnOrder = useColumnOrder(state);
+    const focus = useFocusManagement(state, () => pagination.paginatedItems.length);
+    const remoteData = useRemoteData(state);
+    const liveUpdates = useLiveUpdates(state);
+    // ── Apply persisted snapshots that live inside concerns ──
+    // `state.columns` is still empty at this point; the consumer's
+    // `columns` prop reaches `setColumns` after construction. Filtering by
+    // the persisted hidden ids happens there.
+    if (persistence.initialHiddenColumnIds.length > 0) {
+        columnVisibility.setHiddenIds(persistence.initialHiddenColumnIds);
+    }
+    if (persistence.initialColumnOrder.length > 0) {
+        columnOrder.applyOrder(persistence.initialColumnOrder);
+    }
+    // ── Thin wrappers that add persistence syncing ──
+    function setItems(newItems) {
+        state.items = normalizeItems(newItems);
+    }
+    function setLoading(isLoading) {
+        state.loading = isLoading;
+    }
+    function setError(errorMsg) {
+        state.error = errorMsg;
+    }
+    function setSearchTerm(term) {
+        search.setSearchTerm(term);
+        persistence.syncSearch();
+    }
+    function addFilter(filter) {
+        filtering.addFilter(filter);
+        persistence.syncFilters();
+    }
+    function removeFilter(index) {
+        filtering.removeFilter(index);
+        persistence.syncFilters();
+    }
+    function removeFiltersByColumn(column, operator, value) {
+        filtering.removeFiltersByColumn(column, operator, value);
+        persistence.syncFilters();
+    }
+    function clearAllFilters() {
+        filtering.clearAllFilters();
+        persistence.syncFilters();
+    }
+    function setGroupByKey(key) {
+        grouping.setGroupByKey(key);
+        persistence.syncGroupByKey();
+    }
+    function addSummaryConfig(config) {
+        summary.addSummaryConfig(config);
+        persistence.syncSummaryConfigs();
+    }
+    function removeSummaryConfig(column) {
+        summary.removeSummaryConfig(column);
+        persistence.syncSummaryConfigs();
+    }
+    function setSummaryConfigs(configs) {
+        summary.setSummaryConfigs(configs);
+        persistence.syncSummaryConfigs();
+    }
+    function handleSort(column) {
+        sorting.handleSort(column);
+        persistence.syncSortState();
+    }
+    function hideColumn(id) {
+        columnVisibility.hideColumn(id);
+        persistence.syncHiddenColumns([...columnVisibility.hiddenColumnKeys]);
+    }
+    function showColumn(id) {
+        columnVisibility.showColumn(id);
+        persistence.syncHiddenColumns([...columnVisibility.hiddenColumnKeys]);
+    }
+    function toggleColumnVisibility(id) {
+        columnVisibility.toggleColumnVisibility(id);
+        persistence.syncHiddenColumns([...columnVisibility.hiddenColumnKeys]);
+    }
+    function showAllColumns() {
+        columnVisibility.showAllColumns();
+        persistence.syncHiddenColumns([]);
+    }
+    function reorderColumn(fromIndex, toIndex) {
+        columnOrder.reorderColumn(fromIndex, toIndex);
+        persistence.syncColumnOrder(columnOrder.columnOrder);
+    }
+    function resetColumnOrder() {
+        columnOrder.resetColumnOrder();
+        persistence.syncColumnOrder([]);
+    }
+    // ── Public API ──
+    // `state` is exposed for internal sub-components that need direct reads.
+    // External consumers should prefer the wrapper methods (setSearchTerm,
+    // addFilter, handleSort, etc.) which enforce persistence sync and side effects.
+    return {
+        state,
+        // Derived getters
+        get filteredItems() {
+            return filtering.filteredItems;
+        },
+        get sortedItems() {
+            return sorting.sortedItems;
+        },
+        get paginatedItems() {
+            return pagination.paginatedItems;
+        },
+        get totalItems() {
+            return pagination.totalItems;
+        },
+        get totalPages() {
+            return pagination.totalPages;
+        },
+        get grouped() {
+            return grouping.grouped;
+        },
+        get summaryData() {
+            return summary.summaryData;
+        },
+        get groupedSummaryData() {
+            return summary.groupedSummaryData;
+        },
+        // Data management
+        setItems,
+        setColumns: columnVisibility.setColumns,
+        setLoading,
+        setError,
+        // Search
+        setSearchTerm,
+        toggleAdvancedSearch: search.toggleAdvancedSearch,
+        // Filtering
+        addFilter,
+        removeFilter,
+        removeFiltersByColumn,
+        clearAllFilters,
+        hasFilterForColumn: filtering.hasFilterForColumn,
+        // Sorting
+        handleSort,
+        // Pagination
+        setPage: pagination.setPage,
+        goToPage: pagination.goToPage,
+        setItemsPerPage: pagination.setItemsPerPage,
+        // Expansion
+        toggleExpand: expansion.toggleExpand,
+        isItemExpanded: expansion.isItemExpanded,
+        // Grouping
+        toggleGroup: grouping.toggleGroup,
+        toggleGroupExpand: grouping.toggleGroup,
+        toggleAllGroups: grouping.toggleAllGroups,
+        setGroupByKey,
+        setGroupOrder: grouping.setGroupOrder,
+        // Summary
+        addSummaryConfig,
+        removeSummaryConfig,
+        toggleSummary: summary.toggleSummary,
+        setSummaryConfigs,
+        getFormattedSummaryValue: summary.getFormattedSummaryValue,
+        // Utilities
+        getNestedValue,
+        resolveColumnId,
+        resolveColumnValue,
+        resolveValueById,
+        findColumnById,
+        // Column visibility
+        get allColumns() {
+            return columnVisibility.allColumns;
+        },
+        get hiddenColumnKeys() {
+            return columnVisibility.hiddenColumnKeys;
+        },
+        hideColumn,
+        showColumn,
+        toggleColumnVisibility,
+        showAllColumns,
+        // Selection
+        get selectedItems() {
+            return selection.selectedItems;
+        },
+        get allSelected() {
+            return selection.allSelected;
+        },
+        get someSelected() {
+            return selection.someSelected;
+        },
+        selectItem: selection.selectItem,
+        deselectItem: selection.deselectItem,
+        toggleItem: selection.toggleItem,
+        selectAll: selection.selectAll,
+        deselectAll: selection.deselectAll,
+        toggleAll: selection.toggleAll,
+        isSelected: selection.isSelected,
+        setSelectedIds: selection.setSelectedIds,
+        // Column order
+        get orderedColumns() {
+            return columnOrder.orderedColumns;
+        },
+        get columnOrder() {
+            return columnOrder.columnOrder;
+        },
+        initColumnOrder: columnOrder.initOrder,
+        reorderColumn,
+        resetColumnOrder,
+        getColumnIndex: columnOrder.getColumnIndex,
+        // Focus management
+        get focusedRowIndex() {
+            return focus.focusedRowIndex;
+        },
+        resetFocus: focus.resetFocus,
+        setFocusedRow: focus.setFocusedRow,
+        moveFocus: focus.moveFocus,
+        isFocusedRow: focus.isFocusedRow,
+        // Remote data
+        get query() {
+            return remoteData.query;
+        },
+        get queryKey() {
+            return remoteData.queryKey;
+        },
+        setServerResult: remoteData.setServerResult,
+        setServerError: remoteData.setServerError,
+        setServerLoading: remoteData.setServerLoading,
+        // Live updates
+        get liveUpdateCounts() {
+            return liveUpdates.counts;
+        },
+        get hasPendingUpdates() {
+            return liveUpdates.hasPending;
+        },
+        pushInsert: liveUpdates.pushInsert,
+        pushUpdate: liveUpdates.pushUpdate,
+        pushDelete: liveUpdates.pushDelete,
+        applyAllUpdates: liveUpdates.applyAll,
+        applyInserts: liveUpdates.applyInserts,
+        applyUpdates: liveUpdates.applyUpdates,
+        applyDeletes: liveUpdates.applyDeletes,
+        dismissAllUpdates: liveUpdates.dismissAll,
+        isRecentlyUpdated: liveUpdates.isRecentlyUpdated,
+        isPendingDelete: liveUpdates.isPendingDelete,
+        // Persistence
+        clearPersistedFilters: persistence.clearPersistedFilters,
+        clearPersistedSearchTerm: persistence.clearPersistedSearchTerm,
+        clearPersistedGroupByKey: persistence.clearPersistedGroupByKey,
+        clearPersistedSummaryConfigs: persistence.clearPersistedSummaryConfigs,
+        clearPersistedSortState: persistence.clearPersistedSortState,
+        clearPersistedHiddenColumns: persistence.clearPersistedHiddenColumns,
+        clearPersistedColumnOrder: persistence.clearPersistedColumnOrder,
+        clearAllPersistentData: persistence.clearAllPersistentData,
+        forceSavePersistentData: persistence.forceSavePersistentData
+    };
+}
+// Optional — setTableContext returns the existing context if any, so the
+// raw getter must be permissive (returns undefined when unset).
+const [getTableContextRaw, setTableContextRaw] = createOptionalContext();
+/**
+ * Creates and sets the table context.
+ * @param persistenceConfig - Optional persistence configuration for filters, search, grouping, and summaries.
+ */
+export function setTableContext(persistenceConfig) {
+    const existing = getTableContextRaw();
+    if (existing)
+        return existing;
+    const tableState = createTableState(persistenceConfig);
+    setTableContextRaw(tableState);
+    return tableState;
+}
+/**
+ * Retrieves the table context. Throws when called outside of a `<TableProvider>`
+ * — consumers within the table tree can rely on a defined return value. For the
+ * rare case where the absence of a provider must be detected, use
+ * `getTableContextRaw()` (internal) or `setTableContext()` (idempotent setter).
+ */
+export function getTableContext() {
+    const ctx = getTableContextRaw();
+    if (!ctx) {
+        throw new Error('`getTableContext()` was called outside of a `<TableProvider>`. Wrap the consuming component in `<TableProvider>` or use `setTableContext()` first.');
+    }
+    return ctx;
+}
+/**
+ * Set the table context to an externally-created `tableState`. Used by
+ * `<TableProvider>` so it can construct the state once and share it
+ * with the rest of the table tree.
+ */
+export function attachTableContext(tableState) {
+    setTableContextRaw(tableState);
+}

package/dist/stores/concerns/index.d.ts

@@ -0,0 +1,15 @@
+export type { TableState } from './types.js';
+export { useColumnOrder } from './useColumnOrder.svelte.js';
+export { useColumnVisibility } from './useColumnVisibility.svelte.js';
+export { useExpansion } from './useExpansion.svelte.js';
+export { useFiltering } from './useFiltering.svelte.js';
+export { useFocusManagement } from './useFocusManagement.svelte.js';
+export { useGrouping } from './useGrouping.svelte.js';
+export { useLiveUpdates } from './useLiveUpdates.svelte.js';
+export { usePagination } from './usePagination.svelte.js';
+export { usePersistence } from './usePersistence.svelte.js';
+export { useRemoteData } from './useRemoteData.svelte.js';
+export { useSearch } from './useSearch.svelte.js';
+export { useSelection } from './useSelection.svelte.js';
+export { useSorting } from './useSorting.svelte.js';
+export { useSummary } from './useSummary.svelte.js';

package/dist/stores/concerns/index.js

@@ -0,0 +1,14 @@
+export { useColumnOrder } from './useColumnOrder.svelte.js';
+export { useColumnVisibility } from './useColumnVisibility.svelte.js';
+export { useExpansion } from './useExpansion.svelte.js';
+export { useFiltering } from './useFiltering.svelte.js';
+export { useFocusManagement } from './useFocusManagement.svelte.js';
+export { useGrouping } from './useGrouping.svelte.js';
+export { useLiveUpdates } from './useLiveUpdates.svelte.js';
+export { usePagination } from './usePagination.svelte.js';
+export { usePersistence } from './usePersistence.svelte.js';
+export { useRemoteData } from './useRemoteData.svelte.js';
+export { useSearch } from './useSearch.svelte.js';
+export { useSelection } from './useSelection.svelte.js';
+export { useSorting } from './useSorting.svelte.js';
+export { useSummary } from './useSummary.svelte.js';

package/dist/stores/concerns/types.d.ts

@@ -0,0 +1,31 @@
+import type { Column, Filter, TableItem } from '../../types/tableTypes';
+import type { SummaryConfig } from '../TableStore.svelte';
+/**
+ * Shared reactive table state. All concerns read from and write to this object.
+ */
+export interface TableState {
+    items: TableItem[];
+    columns: Column[];
+    loading: boolean;
+    error: string | null;
+    searchTerm: string;
+    activeFilters: Filter[];
+    showAdvancedSearch: boolean;
+    currentPage: number;
+    itemsPerPage: number;
+    sortColumn: string;
+    sortDirection: 'asc' | 'desc';
+    expandedItemId: string | number | null;
+    expandedItemIds: Set<string | number>;
+    multiExpand: boolean;
+    groupByKey: string | null;
+    collapsedGroups: Set<string>;
+    allGroupsExpanded: boolean;
+    groupOrder: string[];
+    summaryConfigs: SummaryConfig[];
+    showSummary: boolean;
+    selectionMode: 'none' | 'single' | 'multi';
+    selectedIds: Set<string | number>;
+    mode: 'client' | 'server';
+    serverTotalItems: number;
+}

package/dist/stores/concerns/types.js

@@ -0,0 +1 @@
+export {};

package/dist/stores/concerns/useColumnOrder.svelte.d.ts

@@ -0,0 +1,16 @@
+import type { Column } from '../../types/tableTypes';
+import type { TableState } from './types';
+/**
+ * Column order concern: manages column reordering.
+ * Maintains an ordered list of column ids and provides reorder operations.
+ * @param state - Shared table state (reads `columns` for initial order).
+ */
+export declare function useColumnOrder(state: TableState): {
+    readonly orderedColumns: Column[];
+    readonly columnOrder: string[];
+    initOrder: (columns: Column[]) => void;
+    reorderColumn: (fromIndex: number, toIndex: number) => void;
+    resetColumnOrder: () => void;
+    applyOrder: (order: string[]) => void;
+    getColumnIndex: (id: string) => number;
+};