bootstrap-vue-next/dist/composables/useTableHelpers.d.mts

Seamless integration of Vue 3, Bootstrap 5, and TypeScript for modern, type-safe UI development

import { MaybeRef, MaybeRefOrGetter, Ref } from 'vue';
import { BTableInitialSortDirection, BTableProvider, BTableSortBy, TableField, TableFieldRaw } from '../types';
import { BTableFilterFunction, BTableSelectMode, BTableSortByComparerFunction, NoProviderTypes, TablePrimaryKey, TableSelectedReturn } from '../types/TableTypes';
import { StackedProps } from '../utils/tableUtils';
export declare const useTableMapper: <Item>({ fields, items, stackedProps, provider, events, pagination, }: {
    items: MaybeRefOrGetter<readonly Item[]>;
    fields: MaybeRefOrGetter<readonly TableFieldRaw<Item>[]>;
    stackedProps: {
        stacked: MaybeRefOrGetter<StackedProps["stacked"]>;
        labelStacked: MaybeRefOrGetter<StackedProps["labelStacked"]>;
    };
    pagination: {
        perPage: MaybeRefOrGetter<number>;
        currentPage: Ref<number>;
        sort: {
            iconLeft: MaybeRefOrGetter<boolean>;
            isSortable: MaybeRefOrGetter<boolean>;
            sortCompare: MaybeRef<BTableSortByComparerFunction<Item> | undefined>;
            by: MaybeRefOrGetter<readonly BTableSortBy[] | undefined>;
            noLocalSorting: MaybeRefOrGetter<boolean>;
        };
        filter: {
            filterFunction: MaybeRef<BTableFilterFunction<Item> | undefined>;
            filter: MaybeRefOrGetter<string | undefined>;
            filterable: MaybeRefOrGetter<readonly string[] | undefined>;
        };
    };
    provider: {
        noProviderSorting: MaybeRefOrGetter<boolean>;
        noProviderPaging: MaybeRefOrGetter<boolean>;
        noProviderFiltering: MaybeRefOrGetter<boolean>;
        usesProvider: MaybeRefOrGetter<boolean>;
    };
    events: {
        onChange: (items: readonly Item[]) => void;
    };
}) => {
    items: import('vue').ComputedRef<Item[]>;
    displayItems: import('vue').ComputedRef<Item[]>;
    getStringValue: (ob: Item, key: string) => string;
    fields: import('vue').ComputedRef<TableField<Item>[]>;
    isFilterableTable: import('vue').ComputedRef<boolean>;
};
export declare const useTableKeyboardNavigationInjector: ({ isSortable, selectable, noSelectOnClick, }: {
    selectable: MaybeRefOrGetter<boolean>;
    noSelectOnClick: MaybeRefOrGetter<boolean>;
    isSortable: MaybeRefOrGetter<boolean>;
}) => void;
export declare const useTableSelectedItems: <Item>({ selectable, selectMode, selectedItems, events, primaryKey, allItems, }: {
    allItems: MaybeRefOrGetter<readonly Item[]>;
    selectable: MaybeRefOrGetter<boolean>;
    selectMode: MaybeRefOrGetter<BTableSelectMode>;
    primaryKey: MaybeRef<TablePrimaryKey<Item> | undefined>;
    selectedItems: Ref<readonly unknown[]>;
    events: {
        onRowSelected: (item: unknown) => void;
        onRowUnselected: (item: unknown) => void;
    };
}) => TableSelectedReturn<Item>;
export declare const useTableProvider: <Item>({ items, provider, busy, currentPage, debounce, perPage, noProvider, noProviderFiltering, noProviderPaging, noProviderSorting, filter, sortBy, events, }: {
    items: Ref<readonly Item[]>;
    sortBy: MaybeRefOrGetter<readonly BTableSortBy[] | undefined>;
    currentPage: MaybeRefOrGetter<number>;
    perPage: MaybeRefOrGetter<number>;
    filter: MaybeRefOrGetter<string | undefined>;
    busy: Ref<boolean>;
    provider: MaybeRef<BTableProvider<Item> | undefined>;
    debounce: {
        wait: MaybeRefOrGetter<number>;
        maxWait: MaybeRefOrGetter<number>;
    };
    noProvider: MaybeRefOrGetter<readonly NoProviderTypes[] | undefined>;
    noProviderPaging: MaybeRefOrGetter<boolean>;
    noProviderSorting: MaybeRefOrGetter<boolean>;
    noProviderFiltering: MaybeRefOrGetter<boolean>;
    events: {
        onFiltered: () => void;
    };
}) => {
    usesProvider: import('vue').ComputedRef<boolean>;
    callItemsProvider: () => Promise<void>;
};
export declare const useTableSort: <Item>({ fields, sortBy, initialSortDirection, multisort, mustSort, events, }: {
    fields: MaybeRefOrGetter<readonly TableFieldRaw<Item>[]>;
    sortBy: Ref<readonly BTableSortBy[] | undefined>;
    initialSortDirection: MaybeRefOrGetter<BTableInitialSortDirection>;
    mustSort: MaybeRefOrGetter<boolean | readonly string[]>;
    multisort: MaybeRefOrGetter<boolean>;
    events: {
        onSorted: (sortBy: BTableSortBy) => void;
    };
}) => {
    isSortable: import('vue').ComputedRef<boolean>;
    handleFieldSorting: (field: TableField<Item>) => void;
};