nuxt-ui-tools 0.1.0

package/dist/runtime/table/types/layout.d.ts

@@ -0,0 +1,60 @@
+import type { TableColumnCollection } from './columns.js';
+import type { GenericObject, TableDefaultSort, TableGridSortOption, TableLayout, TableRowRenderParams, TableSortKey } from './utils.js';
+export interface TablePersistenceOptions {
+    state?: boolean;
+    preferences?: boolean;
+}
+export type TableLayoutControl<TLayout extends TableLayout = TableLayout> = boolean | string | Partial<Record<TLayout, boolean | string>> | (() => boolean | Partial<Record<TLayout, boolean | string>>);
+export interface TableControlsSchema {
+    refresh?: TableLayoutControl;
+    layout?: TableLayoutControl;
+    columns?: TableLayoutControl;
+    filters?: TableLayoutControl;
+    sort?: TableLayoutControl;
+    actions?: TableLayoutControl;
+}
+export interface TableSelectionSchema {
+    mode?: false | true | 'auto';
+    scope?: 'page' | 'all';
+}
+export type PaginationConfig = {
+    sizeOptions?: Array<number> | {
+        [key in TableLayout]: Array<number>;
+    };
+    defaultSize?: number | {
+        [key in TableLayout]: number;
+    };
+    showPageSizePicker?: boolean;
+    showPagesList?: boolean;
+    showPagesCount?: boolean;
+};
+export type TableOffsetPaginationSchema = PaginationConfig & {
+    mode?: 'offset';
+};
+export interface TableCursorPaginationSchema {
+    mode: 'cursor';
+    pageSize?: number | Partial<Record<TableLayout, number>>;
+    count?: 'none' | 'exact';
+}
+export type TablePaginationSchema = false | TableOffsetPaginationSchema | TableCursorPaginationSchema;
+export type TableGridMode = 'flow' | 'contained';
+export interface TableGridSchema<TRow extends GenericObject = GenericObject, TContext extends GenericObject = GenericObject, TPageContext extends GenericObject = GenericObject, TSortKey extends string = TableSortKey<TRow>> {
+    enabled?: boolean | string | (() => boolean | string);
+    mode?: TableGridMode;
+    renderItem?: (params: TableRowRenderParams<TRow, TContext, TPageContext>) => unknown;
+    renderSkeleton?: (params: {
+        layout?: 'grid';
+    }) => unknown;
+    gridSize?: number | string | (() => number | string);
+    itemSize?: number | string | (() => number | string);
+    sortOptions?: TableGridSortOption<TSortKey>[];
+    defaultSorting?: TableDefaultSort<TSortKey>;
+}
+export interface TableTableSchema<TRow extends GenericObject = GenericObject, TContext extends GenericObject = GenericObject, TPageContext extends GenericObject = GenericObject, TSortKey extends string = TableSortKey<TRow>> {
+    enabled?: boolean | string | (() => boolean | string);
+    columns?: TableColumnCollection<TRow, TContext, TPageContext, string, TSortKey>;
+    treeMode?: boolean;
+    childrenKey?: TableSortKey<TRow>;
+    defaultSorting?: TableDefaultSort<TSortKey>;
+    selection?: boolean | 'auto';
+}

package/dist/runtime/table/types/query-state.d.ts

@@ -0,0 +1,64 @@
+import type { TableBooleanFilterOperator, TableDateFilterOperator, TableFilterPrimitiveValue, TableBooleanFilterDefinition, TableDateFilterDefinition, TableNumberFilterOperator, TableNumberFilterDefinition, TableOptionFilterDefinition, TableOptionFilterOperator, TableTextFilterOperator, TableTextFilterDefinition, TableUiFilterDefinition } from './filters.js';
+import type { TableLayout, TableSortingDirection } from './utils.js';
+import type { TableResolvedSchema } from './utils.js';
+export type TableFilterOperator = 'contains' | 'is' | 'isAnyOf' | 'isNot' | 'gt' | 'gte' | 'lt' | 'lte' | 'between' | 'before' | 'after';
+export type TableQueryStateFilterKind = 'text' | 'option' | 'boolean' | 'number' | 'date';
+export interface TableQueryStateSort<TKey extends string = string> {
+    key: TKey;
+    dir: TableSortingDirection;
+}
+export interface TableQueryStateFilterRange<TValue = string | number> {
+    from?: TValue;
+    to?: TValue;
+}
+export type TableQueryStateFilterValue = string | number | boolean | Array<TableFilterPrimitiveValue> | Date | TableQueryStateFilterRange<number> | TableQueryStateFilterRange<Date>;
+export interface TableQueryStateFilterDefinition<TKey extends string = string> {
+    key: TKey;
+    kind: TableQueryStateFilterKind;
+    defaultValue?: TableQueryStateFilterValue;
+    defaultOperator?: TableFilterOperator;
+    operators?: TableFilterOperator[];
+}
+export interface TableQueryStateFilterRule<TKey extends string = string, TOperator extends string = TableFilterOperator, TValue = TableQueryStateFilterValue> {
+    key: TKey;
+    operator?: TOperator;
+    value: TValue;
+}
+export interface TableFilterState<TFilterKey extends string = string> {
+    search: string;
+    ui: TableQueryStateFilterRule<TFilterKey>[];
+}
+export interface TableQueryState<TFilterKey extends string = string, TSortKey extends string = string> {
+    layout?: TableLayout;
+    page: number;
+    pageSize: number;
+    sort?: TableQueryStateSort<TSortKey> | null;
+    search: string;
+    filters: TableQueryStateFilterRule<TFilterKey>[];
+}
+export type ExtractTableUiFilterDefinition<TSchema> = TableResolvedSchema<TSchema> extends {
+    filters?: {
+        ui?: infer TFilters extends TableUiFilterDefinition[];
+    };
+} ? TFilters[number] : never;
+export type ExtractTableFilterKey<TSchema> = ExtractTableUiFilterDefinition<TSchema> extends {
+    key: infer TKey extends string;
+} ? TKey : never;
+type ExtractDefinitionForKey<TSchema, TKey extends ExtractTableFilterKey<TSchema>> = Extract<ExtractTableUiFilterDefinition<TSchema>, {
+    key: TKey;
+}>;
+type DefinitionForKeyOrFallback<TSchema, TKey extends ExtractTableFilterKey<TSchema>> = [
+    ExtractDefinitionForKey<TSchema, TKey>
+] extends [never] ? ExtractTableUiFilterDefinition<TSchema> : ExtractDefinitionForKey<TSchema, TKey>;
+type FilterOperatorsByKind<TKind> = TKind extends 'text' ? TableTextFilterOperator : TKind extends 'option' ? TableOptionFilterOperator : TKind extends 'boolean' ? TableBooleanFilterOperator : TKind extends 'number' ? TableNumberFilterOperator : TKind extends 'date' ? TableDateFilterOperator : TableFilterOperator;
+export type ExtractTableFilterOperator<TSchema, TKey extends ExtractTableFilterKey<TSchema>> = DefinitionForKeyOrFallback<TSchema, TKey> extends infer TDefinition ? TDefinition extends {
+    kind: infer TKind;
+} ? FilterOperatorsByKind<TKind> : TableFilterOperator : TableFilterOperator;
+type ExtractFilterValueFromDefinition<TDefinition> = TDefinition extends TableTextFilterDefinition<object, object, string> ? string : TDefinition extends TableOptionFilterDefinition<object, object, string, infer TValue> ? TValue[] : TDefinition extends TableBooleanFilterDefinition<object, object, string> ? boolean : TDefinition extends TableNumberFilterDefinition<object, object, string> ? number | TableQueryStateFilterRange<number> : TDefinition extends TableDateFilterDefinition<object, object, string> ? Date | TableQueryStateFilterRange<Date> : TableQueryStateFilterValue;
+export type ExtractTableFilterValue<TSchema, TKey extends ExtractTableFilterKey<TSchema>> = ExtractFilterValueFromDefinition<DefinitionForKeyOrFallback<TSchema, TKey>>;
+export type ExtractTableFilterRule<TSchema, TKey extends ExtractTableFilterKey<TSchema>> = {
+    key: TKey;
+    operator?: ExtractTableFilterOperator<TSchema, TKey>;
+    value: ExtractTableFilterValue<TSchema, TKey>;
+};
+export {};

package/dist/runtime/table/types/schema.d.ts

@@ -0,0 +1,53 @@
+import type { TableBulkAction, TableRowAction, TableToolbarAction } from './actions.js';
+import type { TableContextDataFromItems, TableContextItem, TablePageContextItem } from './context.js';
+import type { TableFiltersSchema } from './filters.js';
+import type { TableControlsSchema, TableGridSchema, TablePaginationSchema, TablePersistenceOptions, TableSelectionSchema, TableTableSchema } from './layout.js';
+import type { InferTableSourceRow, NormalizeTableSource, TableCursorPageResult, TableSource, TableSourceExecutionResult } from './source.js';
+import type { TableKnownFieldPath, TableLayout, TableRowKey, TableSortKey, GenericObject } from './utils.js';
+export interface TableSchema<TRow extends GenericObject = GenericObject, TContextItems extends TableContextItem[] = TableContextItem[], TPageContextItems extends TablePageContextItem<TRow, TableContextDataFromItems<TContextItems>>[] = TablePageContextItem<TRow, TableContextDataFromItems<TContextItems>>[], TFilterKey extends string = TableKnownFieldPath<TRow>, TSortKey extends string = TableSortKey<TRow>> {
+    tableKey: string;
+    rowKey: TableRowKey<TRow>;
+    source: TableSource<TRow, TableContextDataFromItems<TContextItems>, TRow[] | TableSourceExecutionResult<TRow> | TableCursorPageResult<TRow>>;
+    defaultLayout?: TableLayout;
+    pagination?: TablePaginationSchema;
+    context?: TContextItems;
+    pageContext?: TPageContextItems;
+    filters?: TableFiltersSchema<TRow, TableContextDataFromItems<TContextItems>, TFilterKey>;
+    table?: TableTableSchema<TRow, TableContextDataFromItems<TContextItems>, TableContextDataFromItems<TPageContextItems>, TSortKey>;
+    grid?: TableGridSchema<TRow, TableContextDataFromItems<TContextItems>, TableContextDataFromItems<TPageContextItems>, TSortKey>;
+    selection?: TableSelectionSchema;
+    actions?: TableBulkAction<TRow, TableContextDataFromItems<TContextItems>, TableContextDataFromItems<TPageContextItems>>[];
+    toolbarActions?: TableToolbarAction<TRow, TableContextDataFromItems<TContextItems>, TableContextDataFromItems<TPageContextItems>>[];
+    rowActions?: TableRowAction<TRow, TableContextDataFromItems<TContextItems>, TableContextDataFromItems<TPageContextItems>>[] | ((params: {
+        row: TRow;
+        context: TableContextDataFromItems<TContextItems>;
+        pageContext: TableContextDataFromItems<TPageContextItems>;
+        tableApi: import('./table-api').TableApi<TableSchemaView>;
+        layout: TableLayout;
+    }) => TableRowAction<TRow, TableContextDataFromItems<TContextItems>, TableContextDataFromItems<TPageContextItems>>[]);
+    controls?: TableControlsSchema;
+    persistence?: TablePersistenceOptions;
+}
+export type BuildTableSchema<TSource extends TableSource<any, any, any> = TableSource<any, any, any>, TContextItems extends TableContextItem[] = TableContextItem[], TPageContextItems extends TablePageContextItem<InferTableSourceRow<TSource>, TableContextDataFromItems<TContextItems>>[] = TablePageContextItem<InferTableSourceRow<TSource>, TableContextDataFromItems<TContextItems>>[], TFilterKey extends string = TableKnownFieldPath<InferTableSourceRow<TSource>>, TSortKey extends string = TableKnownFieldPath<InferTableSourceRow<TSource>>> = Omit<TableSchema<InferTableSourceRow<TSource>, TContextItems, TPageContextItems, TFilterKey, TSortKey>, 'source'> & {
+    source: ValidateTableSource<TSource, TableContextDataFromItems<TContextItems>>;
+};
+type ValidateTableSource<TSource, TContext extends GenericObject> = TSource extends NormalizeTableSource<TSource, TContext> ? TSource : NormalizeTableSource<TSource, TContext>;
+type ResolveCollection<TCollection> = TCollection extends (...args: never[]) => infer TResult ? TResult : TCollection;
+export type ResolvedTableSchema<TSchema> = Omit<TSchema, 'table' | 'filters'> & {
+    table?: TSchema extends {
+        table?: infer TTable;
+    } ? TTable extends {
+        columns?: infer TColumns;
+    } ? Omit<TTable, 'columns'> & {
+        columns?: ResolveCollection<TColumns>;
+    } : TTable : never;
+    filters?: TSchema extends {
+        filters?: infer TFilters;
+    } ? TFilters extends {
+        ui?: infer TUi;
+    } ? Omit<TFilters, 'ui'> & {
+        ui?: ResolveCollection<TUi>;
+    } : TFilters : never;
+};
+export type TableSchemaView = ResolvedTableSchema<TableSchema>;
+export {};

package/dist/runtime/table/types/source.d.ts

@@ -0,0 +1,108 @@
+import type { InfiniteData, QueryFunction, QueryKey, UseQueryOptions } from '@tanstack/vue-query';
+import type { TableResolvedFilterGroup } from './filters.js';
+import type { GenericObject, TableKnownFieldPath, TablePaginationState, TableSortKey, TableSortingRule, TableRowsFromSourceResult } from './utils.js';
+export type TableQueryDefinition<TData = unknown> = Omit<UseQueryOptions<TData>, 'queryFn'> & {
+    queryKey: QueryKey;
+    queryFn?: QueryFunction<TData, QueryKey, string | null>;
+};
+export interface TableInfiniteQueryDefinition<TData = unknown> {
+    queryKey: QueryKey;
+    queryFn: QueryFunction<TData, QueryKey, string | null>;
+    initialPageParam: string | null;
+    getNextPageParam: (lastPage: TData, allPages: TData[], lastPageParam: string | null, allPageParams: Array<string | null>) => string | null | undefined;
+    enabled?: boolean;
+    staleTime?: number;
+    gcTime?: number;
+    refetchOnWindowFocus?: boolean;
+    initialData?: InfiniteData<TData, string | null> | (() => InfiniteData<TData, string | null>);
+}
+export type TableSourceMode = 'client' | 'remote';
+export interface TableSourceExecutionResult<TRow extends GenericObject = GenericObject, TKey extends string = string> {
+    rows: TRow[];
+    rowCount: number;
+    facets?: TableFacetResult<TKey>[];
+}
+export type TableCursorPageInfo = {
+    mode: 'cursor';
+    pageSize: number;
+    nextCursor: string | null;
+    count: 'none';
+    rowCount: null;
+} | {
+    mode: 'cursor';
+    pageSize: number;
+    nextCursor: string | null;
+    count: 'exact';
+    rowCount: number;
+};
+export interface TableCursorPageResult<TRow extends GenericObject = GenericObject, TKey extends string = string> {
+    rows: TRow[];
+    pageInfo: TableCursorPageInfo;
+    facets?: TableFacetResult<TKey>[];
+}
+export interface TableGlobalFacetDescriptor<TKey extends string = string> {
+    key: TKey;
+    mode?: 'exclude-self' | 'include-self';
+    limit?: number;
+}
+export interface TableFacetRequestDescriptor<TKey extends string = string> {
+    key: TKey;
+    mode?: 'exclude-self' | 'include-self';
+    search?: string;
+    limit?: number;
+    cursor?: string | null;
+}
+export interface TableFacetOptionResult<TValue = unknown> {
+    value: TValue;
+    count: number;
+}
+export interface TableFacetResult<TKey extends string = string, TValue = unknown> {
+    key: TKey;
+    options: TableFacetOptionResult<TValue>[];
+    nextCursor?: string | null;
+    total?: number;
+}
+export interface TableFacetExecutionResult<TKey extends string = string, TValue = unknown> {
+    facets: TableFacetResult<TKey, TValue>[];
+}
+export interface TableSourceSearchRequest<TRow extends GenericObject = GenericObject> {
+    value: string;
+    fields: TableKnownFieldPath<TRow>[];
+}
+export interface TableSourceRequestContext<TRow extends GenericObject = GenericObject, TContext extends GenericObject = GenericObject, TSortKey extends string = TableSortKey<TRow>> {
+    pagination: TablePaginationState;
+    sorting: TableSortingRule<TSortKey>[];
+    filters: TableResolvedFilterGroup<TableKnownFieldPath<TRow> | string>;
+    search: TableSourceSearchRequest<TRow>;
+    context: TContext;
+    facets?: TableGlobalFacetDescriptor<TableKnownFieldPath<TRow> | string>[];
+}
+export interface TableFacetsContext<TRow extends GenericObject = GenericObject, TContext extends GenericObject = GenericObject, TKey extends string = TableKnownFieldPath<TRow> | string> {
+    filters: TableResolvedFilterGroup<TKey>;
+    search: TableSourceSearchRequest<TRow>;
+    context: TContext;
+    facets: TableFacetRequestDescriptor<TKey>[];
+}
+export interface TableClientSource<TRow extends GenericObject = GenericObject, TContext extends GenericObject = GenericObject, TResult = TableSourceExecutionResult<TRow> | TRow[]> {
+    mode?: 'client';
+    query: (ctx: TableSourceRequestContext<TRow, TContext>) => TableQueryDefinition<TResult>;
+}
+export type TableRemoteFacetSource<TRow extends GenericObject = GenericObject, TContext extends GenericObject = GenericObject, TKey extends string = TableKnownFieldPath<TRow> | string> = true | ((ctx: TableFacetsContext<TRow, TContext, TKey>) => TableQueryDefinition<TableFacetExecutionResult<TKey>>);
+export interface TableRemoteSource<TRow extends GenericObject = GenericObject, TContext extends GenericObject = GenericObject, TResult = TableSourceExecutionResult<TRow, TableKnownFieldPath<TRow> | string> | TableCursorPageResult<TRow, TableKnownFieldPath<TRow> | string>> {
+    mode: 'remote';
+    query: (ctx: TableSourceRequestContext<TRow, TContext>) => TableQueryDefinition<TResult>;
+    facets?: TableRemoteFacetSource<TRow, TContext>;
+}
+export type TableSource<TRow extends GenericObject = GenericObject, TContext extends GenericObject = GenericObject, TResult = TableSourceExecutionResult<TRow> | TRow[]> = TableClientSource<TRow, TContext, Extract<TResult, TableSourceExecutionResult<TRow> | TRow[]> extends never ? TableSourceExecutionResult<TRow> | TRow[] : Extract<TResult, TableSourceExecutionResult<TRow> | TRow[]>> | TableRemoteSource<TRow, TContext, Extract<TResult, TableSourceExecutionResult<TRow, TableKnownFieldPath<TRow> | string> | TableCursorPageResult<TRow, TableKnownFieldPath<TRow> | string>> extends never ? TableSourceExecutionResult<TRow, TableKnownFieldPath<TRow> | string> | TableCursorPageResult<TRow, TableKnownFieldPath<TRow> | string> : Extract<TResult, TableSourceExecutionResult<TRow, TableKnownFieldPath<TRow> | string> | TableCursorPageResult<TRow, TableKnownFieldPath<TRow> | string>>>;
+export type NormalizeTableSource<TSource, TContext extends GenericObject> = TSource extends {
+    mode: 'remote';
+} ? TableRemoteSource<InferTableSourceRow<TSource>, TContext, ExtractTableSourceResult<TSource>> : TableClientSource<InferTableSourceRow<TSource>, TContext, ExtractTableSourceResult<TSource>>;
+type ExtractQueryResult<TQuery> = TQuery extends {
+    queryFn?: (...args: never[]) => Promise<infer TResult> | (infer TResult);
+} ? Awaited<TResult> : TQuery extends TableQueryDefinition<infer TResult> ? Awaited<TResult> : never;
+export type ExtractTableSourceResult<TSource> = TSource extends {
+    query: (...args: never[]) => infer TQuery;
+} ? ExtractQueryResult<TQuery> : never;
+type NormalizeSourceRow<TRow> = TRow extends GenericObject ? TRow : GenericObject;
+export type InferTableSourceRow<TSource> = NormalizeSourceRow<TableRowsFromSourceResult<ExtractTableSourceResult<TSource>>>;
+export {};

package/dist/runtime/table/types/state.d.ts

@@ -0,0 +1,5 @@
+import type { GenericObject } from './utils.js';
+export interface TableExternalState<TRow = GenericObject> {
+    rows: TRow[];
+    rowCount: number | null;
+}

package/dist/runtime/table/types/table-api.d.ts

@@ -0,0 +1,142 @@
+import type { ComputedRef, WritableComputedRef } from 'vue';
+import type { useTableData } from '../composables/use-table-data.js';
+import type { TableFilterState } from './query-state.js';
+import type { TableSchemaView } from './schema.js';
+import type { ExtractTableContextData, ExtractTablePageContextData, ExtractTableRow, TableLayout, TablePaginationState, TableSortingDirection, TableSortingRule } from './utils.js';
+export type PublicTableQueryState = {
+    layout: TableLayout;
+    pagination: TablePaginationState;
+    sorting: {
+        sortKey: string;
+        sortDirection: 'asc' | 'desc';
+    } | null;
+    filters: TableFilterState;
+};
+export interface TableOffsetPaginationApi {
+    mode: 'offset';
+    state: ComputedRef<{
+        mode: 'offset';
+        pageIndex: number;
+        pageSize: number;
+        pageCount: number;
+        loadedCount: number;
+        totalCount: number;
+        hasNextPage: boolean;
+        hasPreviousPage: boolean;
+    }>;
+    pageSizeOptions: ComputedRef<number[]>;
+    setPage: (page: number) => void;
+    setPageSize: (pageSize: number) => void;
+    next: () => void;
+    previous: () => void;
+    reset: () => void;
+}
+export interface TableCursorPaginationApi {
+    mode: 'cursor';
+    state: ComputedRef<{
+        mode: 'cursor';
+        loadedCount: number;
+        totalCount: number | null;
+        hasNextPage: boolean;
+        isLoadingMore: boolean;
+        loadMoreError: unknown;
+    }>;
+    loadMore: () => Promise<unknown>;
+    reset: () => void;
+}
+export interface TableNoPaginationApi {
+    mode: 'none';
+    state: ComputedRef<{
+        mode: 'none';
+        loadedCount: number;
+        totalCount: number | null;
+    }>;
+    reset: () => void;
+}
+export type TablePaginationApi<TSchema> = TSchema extends {
+    pagination: false;
+} ? TableNoPaginationApi : TSchema extends {
+    pagination: {
+        mode: 'cursor';
+    };
+} ? TableCursorPaginationApi : TableOffsetPaginationApi;
+export interface TableApi<TSchema = TableSchemaView> {
+    state: {
+        layout: ComputedRef<TableLayout>;
+        query: ComputedRef<PublicTableQueryState>;
+        initialized: ComputedRef<boolean>;
+        isEmpty: ComputedRef<boolean>;
+        isLoading: ComputedRef<boolean>;
+        isRefreshing: ComputedRef<boolean>;
+    };
+    data: {
+        rows: ComputedRef<ExtractTableRow<TSchema>[]>;
+        rowCount: ComputedRef<number | null>;
+        loadedRowCount: ComputedRef<number>;
+        totalRowCount: ComputedRef<number | null>;
+        rawRows: ComputedRef<ExtractTableRow<TSchema>[]>;
+        rawRowCount: ComputedRef<number | null>;
+        context: ComputedRef<ExtractTableContextData<TSchema>>;
+        pageContext: ComputedRef<ExtractTablePageContextData<TSchema>>;
+        requestContext: ReturnType<typeof useTableData>['requestContext'];
+        error: ReturnType<typeof useTableData>['error'];
+        status: ReturnType<typeof useTableData>['status'];
+        refresh: ReturnType<ReturnType<typeof useTableData>['refreshData']>;
+        updateRow: (row: ExtractTableRow<TSchema>) => void;
+        updateRows: (rows: ExtractTableRow<TSchema>[]) => void;
+    };
+    layout: {
+        state: ComputedRef<{
+            active: TableLayout;
+            available: TableLayout[];
+        }>;
+        set: (layout: TableLayout) => void;
+    };
+    filters: {
+        state: ComputedRef<TableFilterState>;
+        search: WritableComputedRef<string>;
+        activeCount: ComputedRef<number>;
+        clear: () => void;
+        remove: (key: string) => void;
+        replace: (rules: TableFilterState['ui']) => void;
+    };
+    pagination: TablePaginationApi<TSchema>;
+    sorting: {
+        state: ComputedRef<{
+            key?: string;
+            dir?: TableSortingDirection;
+            active: boolean;
+        }>;
+        sortKeys: ComputedRef<string[]>;
+        set: (sorting: TableSortingRule | null) => void;
+        setKey: (key?: string) => void;
+        setDirection: (direction: TableSortingDirection) => void;
+        clear: () => void;
+        toggle: (key: string) => void;
+    };
+    selection: {
+        state: ComputedRef<{
+            selectedKeys: string[];
+            selectedCount: number;
+            allSelected: boolean;
+            partiallySelected: boolean;
+        }>;
+        clear: () => void;
+        selectAll: () => void;
+        selectRows: (rowIds: string[]) => void;
+        unselectRows: (rowIds: string[]) => void;
+        toggle: (options: {
+            rowId: string;
+            selected?: boolean;
+            shiftKey?: boolean;
+        }) => void;
+        isSelected: (rowId: string) => boolean;
+    };
+    reset: {
+        query: () => void;
+        all: () => void;
+    };
+    refresh: ReturnType<ReturnType<typeof useTableData>['refreshData']>;
+    updateRow: (row: ExtractTableRow<TSchema>) => void;
+    updateRows: (rows: ExtractTableRow<TSchema>[]) => void;
+}

package/dist/runtime/table/types/utils.d.ts

@@ -0,0 +1,82 @@
+import type { ComputedRef, Ref } from 'vue';
+import type { LazyTextValue, MaybePromise, NestedPaths, Prettify, RenderableType, UnionToIntersection } from '../../shared/index.js';
+import type { TableApi } from './table-api.js';
+export type { ComputedRef, LazyTextValue, MaybePromise, NestedPaths, Prettify, Ref, RenderableType, UnionToIntersection, };
+export type GenericObject = object;
+export type TypeFromPath<TValue, TPath extends string> = TPath extends `${infer THead}.${infer TRest}` ? THead extends keyof TValue ? TypeFromPath<TValue[THead], TRest> : never : TPath extends keyof TValue ? TValue[TPath] : never;
+export type TableLayout = 'table' | 'grid';
+export type TableTextValue = LazyTextValue;
+export type TableColumnPinned = 'left' | 'right';
+export type TableColumnAlign = 'left' | 'center' | 'right';
+type FallbackIfNever<TValue, TFallback> = [TValue] extends [never] ? TFallback : TValue;
+export type TableFieldPath<TRow extends GenericObject> = FallbackIfNever<Extract<NestedPaths<TRow>, string>, string>;
+export type TableKnownFieldPath<TRow extends GenericObject> = TableFieldPath<TRow>;
+export type TableFieldValue<TRow extends GenericObject, TField extends TableFieldPath<TRow>> = TField extends string ? TypeFromPath<TRow, TField> : never;
+export type TableSortKey<TRow extends GenericObject> = TableFieldPath<TRow>;
+export type TableRowKey<TRow extends GenericObject> = TableFieldPath<TRow> | TableFieldPath<TRow>[];
+export type TableSortingDirection = 'asc' | 'desc';
+export interface TableSortingRule<TKey extends string = string> {
+    key: TKey;
+    dir: TableSortingDirection;
+}
+export interface TableOffsetPaginationRequest {
+    mode: 'offset';
+    pageIndex: number;
+    pageSize: number;
+    count: 'exact';
+}
+export interface TableCursorPaginationRequest {
+    mode: 'cursor';
+    cursor: string | null;
+    pageSize: number;
+    count: 'none' | 'exact';
+}
+export interface TableNoPaginationRequest {
+    mode: 'none';
+}
+export type TablePaginationState = TableOffsetPaginationRequest | TableCursorPaginationRequest | TableNoPaginationRequest;
+export interface TableRowRenderParams<TRow extends GenericObject = GenericObject, TContext extends GenericObject = GenericObject, TPageContext extends GenericObject = GenericObject> {
+    row: TRow;
+    index: number;
+    context: TContext;
+    pageContext: TPageContext;
+    tableApi: TableApi;
+    layout: TableLayout;
+}
+export interface TableGridSortOption<TKey extends string = string> {
+    label: string | (() => RenderableType);
+    key: TKey;
+}
+export type TableDefaultSort<TKey extends string = string> = TKey | {
+    key: TKey;
+    dir: TableSortingDirection;
+};
+export type TableSchemaRefLike<TValue> = {
+    value: TValue;
+};
+export type MaybeComputedRef<TValue> = TValue | Ref<TValue> | ComputedRef<TValue> | (() => TValue);
+export type TableSchemaSource<TSchema> = TSchema | TableSchemaRefLike<TSchema> | (() => TSchema);
+export type TableRowsFromSourceResult<TResult> = TResult extends (infer TRow)[] ? TRow : TResult extends {
+    rows: (infer TRow)[];
+} ? TRow : never;
+export type TableResolvedSchema<TSchema> = TSchema extends () => infer TValue ? TValue : TSchema extends {
+    value: infer TValue;
+} ? TValue : TSchema;
+type MergeContextItem<TItem> = TItem extends {
+    key: infer TKey extends string;
+    query: (...args: any[]) => import('@tanstack/vue-query').UseQueryOptions<infer TValue>;
+} ? {
+    [K in TKey]: Awaited<TValue>;
+} : {};
+type MergeContextItemUnion<TItem> = UnionToIntersection<MergeContextItem<TItem>>;
+type ExtractSourceResult<TSchema> = TableResolvedSchema<TSchema> extends {
+    source: infer TSource;
+} ? import('./source').ExtractTableSourceResult<TSource> : never;
+type NormalizeExtractedRow<TRow> = TRow extends GenericObject ? TRow : GenericObject;
+export type ExtractTableRow<TSchema> = NormalizeExtractedRow<TableRowsFromSourceResult<ExtractSourceResult<TSchema>>>;
+export type ExtractTableContextData<TSchema> = Prettify<TableResolvedSchema<TSchema> extends {
+    context?: infer TItems extends unknown[];
+} ? MergeContextItemUnion<TItems[number]> : {}>;
+export type ExtractTablePageContextData<TSchema> = Prettify<TableResolvedSchema<TSchema> extends {
+    pageContext?: infer TItems extends unknown[];
+} ? MergeContextItemUnion<TItems[number]> : {}>;

package/dist/runtime/table/utils/actions.d.ts

@@ -0,0 +1,28 @@
+import type { DropdownMenuItem } from '@nuxt/ui';
+import type { TableInjectedRowActionScope } from '../composables/use-table-row-actions.js';
+import type { GenericObject, TableRowAction, TableSchemaView } from '../types/index.js';
+type RowActionSchemaSource = {
+    rowActions?: TableSchemaView['rowActions'];
+};
+type ResolvedRowAction = TableRowAction<GenericObject, Record<string, unknown>, Record<string, unknown>>;
+export declare function resolveTableRowActions(options: {
+    schema: RowActionSchemaSource;
+    scope: TableInjectedRowActionScope;
+}): ResolvedRowAction[];
+export declare function resolveVisibleTableRowActions(options: {
+    schema: RowActionSchemaSource;
+    scope: TableInjectedRowActionScope;
+}): ResolvedRowAction[];
+export declare function hasVisibleTableRowActions(options: {
+    schema: RowActionSchemaSource;
+    rows: GenericObject[];
+    context: GenericObject;
+    pageContext: GenericObject;
+    tableApi: TableInjectedRowActionScope['tableApi'];
+    layout: TableInjectedRowActionScope['layout'];
+}): boolean;
+export declare function createRowActionDropdownItems(options: {
+    actions: ResolvedRowAction[];
+    scope: TableInjectedRowActionScope;
+}): DropdownMenuItem[];
+export {};