@tinisoftin/tsdatagrid 1.0.0

package/dist/composables/useGrouping.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useGrouping.d.ts","sourceRoot":"","sources":["../../src/composables/useGrouping.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,eAAe,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAGtE,wBAAgB,WAAW,CAAC,IAAI,CAAC,EAAE,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mGA4Wiw8D,CAAC;;;;;;;;;;;;;;;;;;4CAAnw+B,GAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mGAA8v+B,CAAC;;;;;;;;;;;;;;;;;;4CAAnw+B,GAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mGAA8v+B,CAAC;;;;;;;;;;;;;;;;;;4CAAnw+B,GAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mGAA8v+B,CAAC;;;;;;;;;;;;;;;;;;4CAAnw+B,GAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAnWnh+B,MAAM,aAAY,OAAO,UAAiB,MAAM;yBA6B7C,MAAM;;0BAyCL,MAAM,YAAY,MAAM;qCAoBb,MAAM;gCAyBX,MAAM,KAAG,OAAO;4BAUpB,MAAM;8BAWJ,MAAM;mCAWD,UAAU,EAAE;qCAyBV,UAAU,EAAE;sBAyB3B,GAAG,EAAE,KAAG,UAAU,EAAE;kCAwFR,GAAG,EAAE,eAAe,GAAG,EAAE,KAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;oCAiC7C,UAAU,EAAE,KAAG,GAAG,EAAE;EAqC5D"}

package/dist/composables/useInfiniteScroll.d.ts

@@ -0,0 +1,49 @@
+import { GridEmit } from '../types';
+
+export interface InfiniteScrollConfig {
+    /** Items per page */
+    pageSize?: number;
+    /** Distance from bottom to trigger load (px) */
+    threshold?: number;
+    /** Enable infinite scroll */
+    enabled?: boolean;
+    /** Load first page automatically */
+    initialLoad?: boolean;
+    /** Use Intersection Observer instead of scroll event */
+    useIntersectionObserver?: boolean;
+    /** Debounce scroll events (ms) */
+    scrollDebounce?: number;
+    /** Auto-load more if content doesn't fill container */
+    autoLoadMore?: boolean;
+}
+export interface InfiniteScrollResult {
+    /** Loaded data */
+    data: any[];
+    /** Has more data to load */
+    hasMore: boolean;
+    /** Total count (optional) */
+    totalCount?: number;
+}
+export declare function useInfiniteScroll(loadMore: (page: number, pageSize: number) => Promise<InfiniteScrollResult>, config?: InfiniteScrollConfig, emit?: GridEmit): {
+    data: import('vue').Ref<any[], any[]>;
+    currentPage: import('vue').Ref<number, number>;
+    isLoading: import('vue').Ref<boolean, boolean>;
+    hasMore: import('vue').Ref<boolean, boolean>;
+    error: import('vue').Ref<Error | null, Error | null>;
+    canLoadMore: import('vue').ComputedRef<boolean>;
+    scrollContainer: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+    sentinelElement: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+    totalCount: import('vue').Ref<number, number>;
+    progress: import('vue').ComputedRef<number>;
+    isComplete: import('vue').ComputedRef<boolean>;
+    loadNextPage: () => Promise<void>;
+    reset: () => void;
+    reload: () => Promise<void>;
+    retry: () => Promise<void>;
+    attachScrollContainer: (element: HTMLElement | null) => void;
+    attachSentinel: (element: HTMLElement | null) => void;
+    checkAndLoadMore: () => void;
+    setupIntersectionObserver: () => void;
+    cleanupIntersectionObserver: () => void;
+};
+//# sourceMappingURL=useInfiniteScroll.d.ts.map

package/dist/composables/useInfiniteScroll.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useInfiniteScroll.d.ts","sourceRoot":"","sources":["../../src/composables/useInfiniteScroll.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAExC,MAAM,WAAW,oBAAoB;IACnC,qBAAqB;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAA;IAEjB,gDAAgD;IAChD,SAAS,CAAC,EAAE,MAAM,CAAA;IAElB,6BAA6B;IAC7B,OAAO,CAAC,EAAE,OAAO,CAAA;IAEjB,oCAAoC;IACpC,WAAW,CAAC,EAAE,OAAO,CAAA;IAErB,wDAAwD;IACxD,uBAAuB,CAAC,EAAE,OAAO,CAAA;IAEjC,kCAAkC;IAClC,cAAc,CAAC,EAAE,MAAM,CAAA;IAEvB,uDAAuD;IACvD,YAAY,CAAC,EAAE,OAAO,CAAA;CACvB;AAED,MAAM,WAAW,oBAAoB;IACnC,kBAAkB;IAClB,IAAI,EAAE,GAAG,EAAE,CAAA;IAEX,4BAA4B;IAC5B,OAAO,EAAE,OAAO,CAAA;IAEhB,6BAA6B;IAC7B,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB;AAED,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,oBAAoB,CAAC,EAC3E,MAAM,GAAE,oBAAyB,EACjC,IAAI,CAAC,EAAE,QAAQ;;;;;;;;;;;;;;;;qCAwNyB,WAAW,GAAG,IAAI;8BA+BzB,WAAW,GAAG,IAAI;;;;EAsGpD"}

package/dist/composables/useKeyboardNavigation.d.ts

@@ -0,0 +1,47 @@
+import { KeyboardNavigationConfig, FocusPosition, KeyboardShortcut, KeyboardAction, ColumnDefinition, ColumnField, RowKey, GridEmit } from '../types';
+
+export declare function useKeyboardNavigation(columns: () => ColumnDefinition[], data: () => any[], keyField?: string, config?: KeyboardNavigationConfig, emit?: GridEmit): {
+    focusedPosition: import('vue').Ref<{
+        rowKey: RowKey;
+        columnField: ColumnField;
+        rowIndex: number;
+        columnIndex: number;
+    } | null, FocusPosition | {
+        rowKey: RowKey;
+        columnField: ColumnField;
+        rowIndex: number;
+        columnIndex: number;
+    } | null>;
+    focusVisible: import('vue').Ref<boolean, boolean>;
+    gridElement: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+    activeShortcuts: import('vue').ComputedRef<KeyboardShortcut[]>;
+    setFocus: (rowKey: any, columnField: string | ColumnField) => void;
+    clearFocus: () => void;
+    moveFocus: (direction: "up" | "down" | "left" | "right") => void;
+    moveToFirstCell: () => void;
+    moveToLastCell: () => void;
+    moveToFirstColumn: () => void;
+    moveToLastColumn: () => void;
+    moveToFirstRow: () => void;
+    moveToLastRow: () => void;
+    movePage: (direction: "up" | "down", pageSize?: number) => void;
+    attachGridElement: (element: HTMLElement | null) => void;
+    registerShortcut: (shortcut: KeyboardShortcut) => void;
+    unregisterShortcut: (action: KeyboardAction) => void;
+    getShortcutDescription: (action: KeyboardAction) => string | undefined;
+    getShortcutKeys: (action: KeyboardAction) => string | undefined;
+    getFocusedCellValue: () => any;
+    config: import('vue').ComputedRef<{
+        enabled: boolean;
+        cellNavigation: boolean;
+        rowNavigation: boolean;
+        editingShortcuts: boolean;
+        selectionShortcuts: boolean;
+        clipboardShortcuts: boolean;
+        customShortcuts: KeyboardShortcut[];
+        enterKeyAction: "startEdit" | "moveFocus" | "none";
+        enterKeyDirection: "down" | "right" | "none";
+        editOnKeyPress: boolean;
+    }>;
+};
+//# sourceMappingURL=useKeyboardNavigation.d.ts.map

package/dist/composables/useKeyboardNavigation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useKeyboardNavigation.d.ts","sourceRoot":"","sources":["../../src/composables/useKeyboardNavigation.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EACL,wBAAwB,EACxB,aAAa,EACb,gBAAgB,EAEhB,cAAc,EACd,gBAAgB,EAChB,WAAW,EACX,MAAM,EACN,QAAQ,EACT,MAAM,UAAU,CAAA;AAEjB,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,MAAM,gBAAgB,EAAE,EACjC,IAAI,EAAE,MAAM,GAAG,EAAE,EACjB,QAAQ,GAAE,MAAa,EACvB,MAAM,GAAE,wBAA6B,EACrC,IAAI,CAAC,EAAE,QAAQ;;;;;;;;;;;;;;;uBA8DW,GAAG,eAAe,MAAM,GAAG,WAAW;;2BA6BlC,IAAI,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO;;;;;;;0BAkGjC,IAAI,GAAG,MAAM,aAAY,MAAM;iCAqLxB,WAAW,GAAG,IAAI;iCAmClB,gBAAgB;iCAOhB,cAAc;qCAQV,cAAc,KAAG,MAAM,GAAG,SAAS;8BAK1C,cAAc,KAAG,MAAM,GAAG,SAAS;+BAepC,GAAG;;;;;;;;;;;;;EAqCpC"}

package/dist/composables/useLoadingState.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @fileoverview Loading state composable
+ * @module composables/useLoadingState
+ */
+export interface LoadingOptions {
+    text?: string;
+    overlay?: boolean;
+    spinner?: boolean;
+    progress?: number;
+    cancellable?: boolean;
+}
+export declare function useLoadingState(): {
+    isLoading: import('vue').Ref<boolean, boolean>;
+    loadingText: import('vue').Ref<string, string>;
+    loadingProgress: import('vue').Ref<number, number>;
+    loadingOptions: import('vue').Ref<{
+        text?: string | undefined;
+        overlay?: boolean | undefined;
+        spinner?: boolean | undefined;
+        progress?: number | undefined;
+        cancellable?: boolean | undefined;
+    }, LoadingOptions | {
+        text?: string | undefined;
+        overlay?: boolean | undefined;
+        spinner?: boolean | undefined;
+        progress?: number | undefined;
+        cancellable?: boolean | undefined;
+    }>;
+    hasProgress: import('vue').ComputedRef<boolean>;
+    startLoading: (options?: LoadingOptions) => void;
+    stopLoading: () => void;
+    updateProgress: (progress: number, text?: string) => void;
+    updateText: (text: string) => void;
+    withLoading: <T>(operation: () => Promise<T>, options?: LoadingOptions) => Promise<T>;
+};
+//# sourceMappingURL=useLoadingState.d.ts.map

package/dist/composables/useLoadingState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLoadingState.d.ts","sourceRoot":"","sources":["../../src/composables/useLoadingState.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,MAAM,WAAW,cAAc;IAC7B,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,WAAW,CAAC,EAAE,OAAO,CAAA;CACtB;AAED,wBAAgB,eAAe;;;;;eAPtB,MAAM;kBACH,OAAO;kBACP,OAAO;mBACN,MAAM;sBACH,OAAO;;eAJd,MAAM;kBACH,OAAO;kBACP,OAAO;mBACN,MAAM;sBACH,OAAO;;;6BAcW,cAAc;;+BA2BZ,MAAM,SAAS,MAAM;uBAS7B,MAAM;kBAKL,CAAC,aACf,MAAM,OAAO,CAAC,CAAC,CAAC,YACjB,cAAc,KACvB,OAAO,CAAC,CAAC,CAAC;EAwBd"}

package/dist/composables/usePagination.d.ts

@@ -0,0 +1,45 @@
+import { PaginationConfig, PaginationState, GridEmit } from '../types';
+
+export declare function usePagination(config?: PaginationConfig, emit?: GridEmit): {
+    currentPage: import('vue').Ref<number, number>;
+    pageSize: import('vue').Ref<number, number>;
+    totalItems: import('vue').Ref<number, number>;
+    totalPages: import('vue').ComputedRef<number>;
+    skip: import('vue').ComputedRef<number>;
+    take: import('vue').ComputedRef<number>;
+    startRecord: import('vue').ComputedRef<number>;
+    endRecord: import('vue').ComputedRef<number>;
+    canGoNext: import('vue').ComputedRef<boolean>;
+    canGoPrevious: import('vue').ComputedRef<boolean>;
+    canGoFirst: import('vue').ComputedRef<boolean>;
+    canGoLast: import('vue').ComputedRef<boolean>;
+    availablePageSizes: import('vue').ComputedRef<number[]>;
+    paginationState: import('vue').ComputedRef<PaginationState>;
+    paginationInfo: import('vue').ComputedRef<string>;
+    isFirstPage: import('vue').ComputedRef<boolean>;
+    isLastPage: import('vue').ComputedRef<boolean>;
+    hasPages: import('vue').ComputedRef<boolean>;
+    goToPage: (page: number) => boolean;
+    nextPage: () => boolean;
+    previousPage: () => boolean;
+    firstPage: () => boolean;
+    lastPage: () => boolean;
+    changePageSize: (size: number) => boolean;
+    reset: () => void;
+    getPageNumbers: (maxVisible?: number) => number[];
+    getPageNumbersWithEllipsis: (maxVisible?: number) => Array<number | "ellipsis">;
+    updateConfig: (newConfig: Partial<PaginationConfig>) => void;
+    setPage: (page: number) => void;
+    setPageSize: (size: number) => void;
+    setTotalItems: (total: number) => void;
+    getRangeInfo: () => {
+        start: number;
+        end: number;
+        total: number;
+    };
+    getPageInfo: () => string;
+    isPage: (page: number) => boolean;
+    canGoToPage: (page: number) => boolean;
+    getPaginatedData: <T>(data: T[]) => T[];
+};
+//# sourceMappingURL=usePagination.d.ts.map

package/dist/composables/usePagination.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usePagination.d.ts","sourceRoot":"","sources":["../../src/composables/usePagination.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAE3E,wBAAgB,aAAa,CAC3B,MAAM,GAAE,gBAKP,EACD,IAAI,CAAC,EAAE,QAAQ;;;;;;;;;;;;;;;;;;;qBA+FS,MAAM,KAAG,OAAO;oBAenB,OAAO;wBAQH,OAAO;qBAQV,OAAO;oBAKR,OAAO;2BAKE,MAAM,KAAG,OAAO;;kCAsCV,MAAM,KAAO,MAAM,EAAE;8CA6BT,MAAM,KAAO,KAAK,CAAC,MAAM,GAAG,UAAU,CAAC;8BA0EtD,OAAO,CAAC,gBAAgB,CAAC;oBAlBnC,MAAM;wBAMF,MAAM;2BAOH,MAAM;wBAkBX;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE;uBAS9C,MAAM;mBAcR,MAAM,KAAG,OAAO;wBAKX,MAAM,KAAG,OAAO;uBAKjB,CAAC,QAAQ,CAAC,EAAE,KAAG,CAAC,EAAE;EA+C7C"}

package/dist/composables/useRowExpansion.d.ts

@@ -0,0 +1,47 @@
+import { GridEmit } from '../types';
+
+export interface RowExpansionConfig {
+    /** Allow multiple rows to be expanded simultaneously */
+    allowMultiple?: boolean;
+    /** Expand row when clicking anywhere on the row */
+    expandOnRowClick?: boolean;
+    /** Auto-collapse other rows when expanding a new one */
+    autoCollapse?: boolean;
+    /** Default expanded state for all rows */
+    defaultExpanded?: boolean;
+}
+export interface RowExpansionState {
+    /** Set of expanded row keys */
+    expandedRows: Set<any>;
+    /** Count of expanded rows */
+    expandedCount: number;
+    /** Has any expanded rows */
+    hasExpandedRows: boolean;
+}
+export declare function useRowExpansion(keyField?: string, config?: RowExpansionConfig, emit?: GridEmit): {
+    expandedRows: import('vue').Ref<Set<any> & Omit<Set<any>, keyof Set<any>>, Set<any> | (Set<any> & Omit<Set<any>, keyof Set<any>>)>;
+    expandedCount: import('vue').ComputedRef<number>;
+    hasExpandedRows: import('vue').ComputedRef<boolean>;
+    config: import('vue').ComputedRef<{
+        allowMultiple: boolean;
+        expandOnRowClick: boolean;
+        autoCollapse: boolean;
+        defaultExpanded: boolean;
+    }>;
+    isExpanded: (row: any) => boolean;
+    isExpandedByKey: (key: any) => boolean;
+    toggleExpansion: (row: any, rowIndex?: number) => void;
+    expand: (row: any, rowIndex?: number) => void;
+    collapse: (row: any, rowIndex?: number) => void;
+    expandAll: (rows: any[]) => void;
+    collapseAll: () => void;
+    setExpandedRows: (keys: any[]) => void;
+    getExpandedRows: () => any[];
+    expandByKey: (key: any) => void;
+    collapseByKey: (key: any) => void;
+    toggleByKey: (key: any) => void;
+    getExpansionState: () => RowExpansionState;
+    restoreExpansionState: (state: RowExpansionState) => void;
+    reset: () => void;
+};
+//# sourceMappingURL=useRowExpansion.d.ts.map

package/dist/composables/useRowExpansion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRowExpansion.d.ts","sourceRoot":"","sources":["../../src/composables/useRowExpansion.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAU,MAAM,UAAU,CAAA;AAEhD,MAAM,WAAW,kBAAkB;IACjC,wDAAwD;IACxD,aAAa,CAAC,EAAE,OAAO,CAAA;IAEvB,mDAAmD;IACnD,gBAAgB,CAAC,EAAE,OAAO,CAAA;IAE1B,wDAAwD;IACxD,YAAY,CAAC,EAAE,OAAO,CAAA;IAEtB,0CAA0C;IAC1C,eAAe,CAAC,EAAE,OAAO,CAAA;CAC1B;AAED,MAAM,WAAW,iBAAiB;IAChC,+BAA+B;IAC/B,YAAY,EAAE,GAAG,CAAC,GAAG,CAAC,CAAA;IAEtB,6BAA6B;IAC7B,aAAa,EAAE,MAAM,CAAA;IAErB,4BAA4B;IAC5B,eAAe,EAAE,OAAO,CAAA;CACzB;AAED,wBAAgB,eAAe,CAC7B,QAAQ,GAAE,MAAa,EACvB,MAAM,GAAE,kBAAuB,EAC/B,IAAI,CAAC,EAAE,QAAQ;;;;;uBA1BC,OAAO;0BAGJ,OAAO;sBAGX,OAAO;yBAGJ,OAAO;;sBAkCA,GAAG,KAAG,OAAO;2BAOR,GAAG,KAAG,OAAO;2BAKb,GAAG,aAAY,MAAM;kBAW9B,GAAG,aAAY,MAAM;oBAkCnB,GAAG,aAAY,MAAM;sBA6BnB,GAAG,EAAE;;4BAwCC,GAAG,EAAE;2BAYR,GAAG,EAAE;uBAKP,GAAG;yBAkBD,GAAG;uBAcL,GAAG;6BASC,iBAAiB;mCAST,iBAAiB;;EAkCxD"}

package/dist/composables/useSearch.d.ts

@@ -0,0 +1,97 @@
+import { ColumnDefinition, RowKey, SearchConfig, SearchResult, SearchState, GridEmit } from '../types';
+
+export declare function useSearch<T = any>(data: () => T[], columns: () => ColumnDefinition[], config?: SearchConfig, emit?: GridEmit<T>, getRowKey?: (row: T) => RowKey | string | number): {
+    searchTerm: import('vue').Ref<string, string>;
+    results: import('vue').Ref<{
+        row: import('vue').UnwrapRef<T>;
+        rowKey: any;
+        score: number;
+        matches: {
+            field: string;
+            value: any;
+            match: string;
+            startIndex: number;
+            endIndex: number;
+            score?: number | undefined;
+        }[];
+        highlightedRow?: import('vue').UnwrapRef<T> | undefined;
+    }[], SearchResult<T>[] | {
+        row: import('vue').UnwrapRef<T>;
+        rowKey: any;
+        score: number;
+        matches: {
+            field: string;
+            value: any;
+            match: string;
+            startIndex: number;
+            endIndex: number;
+            score?: number | undefined;
+        }[];
+        highlightedRow?: import('vue').UnwrapRef<T> | undefined;
+    }[]>;
+    loading: import('vue').Ref<boolean, boolean>;
+    highlightedRows: import('vue').Ref<Set<any> & Omit<Set<any>, keyof Set<any>>, Set<any> | (Set<any> & Omit<Set<any>, keyof Set<any>>)>;
+    searchState: import('vue').ComputedRef<SearchState>;
+    hasResults: import('vue').ComputedRef<boolean>;
+    hasSearchTerm: import('vue').ComputedRef<boolean>;
+    isSearching: import('vue').ComputedRef<boolean>;
+    activeMatchIndex: import('vue').Ref<number | undefined, number | undefined>;
+    search: (term: string) => void;
+    executeSearch: () => void;
+    clearSearch: () => void;
+    getHighlightedValue: (row: T, field: string) => string;
+    isRowHighlighted: (row: T) => boolean;
+    getMatchCount: (row: T) => number;
+    getMatchesForRow: (row: T) => {
+        field: string;
+        value: any;
+        match: string;
+        startIndex: number;
+        endIndex: number;
+        score?: number | undefined;
+    }[];
+    searchWithFilters: (term: string, filters: Record<string, any>) => void;
+    navigateToNextMatch: () => void;
+    navigateToPreviousMatch: () => void;
+    getActiveMatch: () => {
+        result: {
+            row: import('vue').UnwrapRef<T>;
+            rowKey: any;
+            score: number;
+            matches: {
+                field: string;
+                value: any;
+                match: string;
+                startIndex: number;
+                endIndex: number;
+                score?: number | undefined;
+            }[];
+            highlightedRow?: import('vue').UnwrapRef<T> | undefined;
+        };
+        match: {
+            field: string;
+            value: any;
+            match: string;
+            startIndex: number;
+            endIndex: number;
+            score?: number | undefined;
+        };
+    } | null;
+    getSearchableFields: () => string[];
+    updateConfig: (newConfig: Partial<SearchConfig>) => void;
+    updateHighlightConfig: (highlightClass?: string) => void;
+    getStats: () => {
+        resultCount: number;
+        totalMatches: number;
+        hasResults: boolean;
+        term: string;
+        activeMatchIndex: number | undefined;
+        cacheSize: number;
+        searchableFields: number;
+        indexSize: number;
+    };
+    clearCache: () => void;
+    enabled: import('vue').ComputedRef<boolean>;
+    totalMatches: import('vue').ComputedRef<number>;
+};
+//# sourceMappingURL=useSearch.d.ts.map

package/dist/composables/useSearch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSearch.d.ts","sourceRoot":"","sources":["../../src/composables/useSearch.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AACxD,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AACvE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAGxC,wBAAgB,SAAS,CAAC,CAAC,GAAG,GAAG,EAC/B,IAAI,EAAE,MAAM,CAAC,EAAE,EACf,OAAO,EAAE,MAAM,gBAAgB,EAAE,EACjC,MAAM,GAAE,YAA6D,EACrE,IAAI,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,EAClB,SAAS,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,MAAM,GAAG,MAAM,GAAG,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBA+F1B,MAAM;;;+BAgBM,CAAC,SAAS,MAAM,KAAG,MAAM;4BAiB5B,CAAC,KAAG,OAAO;yBAMd,CAAC,KAAG,MAAM;4BAMP,CAAC;;;;;;;;8BAKC,MAAM,WAAW,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAsErC,MAAM,EAAE;8BAKP,OAAO,CAAC,YAAY,CAAC;6CA2BN,MAAM;;;;;;;;;;;;;;EA2EvD"}

package/dist/composables/useSelection.d.ts

@@ -0,0 +1,32 @@
+import { SelectionMode, SelectionState, GridEmit } from '../types';
+
+export declare function useSelection<T>(mode?: SelectionMode, keyField?: string, emit?: GridEmit<T>): {
+    selectedKeys: import('vue').Ref<Set<any> & Omit<Set<any>, keyof Set<any>>, Set<any> | (Set<any> & Omit<Set<any>, keyof Set<any>>)>;
+    selectedCount: import('vue').ComputedRef<number>;
+    hasSelection: import('vue').ComputedRef<boolean>;
+    selectionState: import('vue').ComputedRef<SelectionState>;
+    isSelected: (item: T) => boolean;
+    toggleSelection: (item: T, index?: number, shiftKey?: boolean) => void;
+    selectRange: (startIndex: number, endIndex: number, items: T[]) => void;
+    selectAll: (items: T[], allData?: boolean) => void;
+    deselectAll: () => void;
+    select: (item: T) => void;
+    deselect: (item: T) => void;
+    selectByKey: (key: any) => void;
+    deselectByKey: (key: any) => void;
+    selectByKeys: (keys: any[]) => void;
+    deselectByKeys: (keys: any[]) => void;
+    isAllSelected: (items: T[]) => boolean;
+    isSomeSelected: (items: T[]) => boolean;
+    toggleSelectAll: (items: T[]) => void;
+    getSelectedItems: (allItems: T[]) => T[];
+    getSelectedKeys: () => any[];
+    setSelectedKeys: (keys: any[]) => void;
+    clearSelection: () => void;
+    invertSelection: (allItems: T[]) => void;
+    selectFiltered: (filteredItems: T[]) => void;
+    saveSelectionToStorage: () => void;
+    loadSelectionFromStorage: () => void;
+    clearSelectionFromStorage: () => void;
+};
+//# sourceMappingURL=useSelection.d.ts.map

package/dist/composables/useSelection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSelection.d.ts","sourceRoot":"","sources":["../../src/composables/useSelection.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,aAAa,EACb,cAAc,EAIf,MAAM,UAAU,CAAA;AACjB,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAExC,wBAAgB,YAAY,CAAC,CAAC,EAC5B,IAAI,GAAE,aAAsE,EAC5E,QAAQ,GAAE,MAAa,EACvB,IAAI,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC;;;;;uBAgBQ,CAAC,KAAG,OAAO;4BAMN,CAAC,UAAU,MAAM,aAAY,OAAO;8BA8ClC,MAAM,YAAY,MAAM,SAAS,CAAC,EAAE;uBAmB3C,CAAC,EAAE,YAAW,OAAO;;mBA8BzB,CAAC;qBAkBC,CAAC;uBAWC,GAAG;yBAeD,GAAG;yBAQH,GAAG,EAAE;2BAwBH,GAAG,EAAE;2BAgBL,CAAC,EAAE,KAAG,OAAO;4BAMZ,CAAC,EAAE,KAAG,OAAO;6BAKZ,CAAC,EAAE;iCAWC,CAAC,EAAE,KAAG,CAAC,EAAE;2BAKjB,GAAG,EAAE;4BAKF,GAAG,EAAE;;gCAgBD,CAAC,EAAE;oCAeC,CAAC,EAAE;;;;EA+G3C"}