nuxt-ui-tools 0.1.3 → 1.0.1

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

@@ -1,10 +1,10 @@
-import type { TableColumnCollection } from './columns.js';
-import type { GenericObject, TableDefaultSort, TableGridSortOption, TableLayout, TableRowRenderParams, TableSortKey } from './utils.js';
+import type { TableColumnCollection, TableSummaryRequest, TableSummaryScope, TableSummaryValue } from './columns.js';
+import type { GenericObject, TableDefaultSort, TableGridSortOption, TableLayout, TableRowRenderParams, RenderableType, TableSortKey, TableTextValue } 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 type TableLayoutControl<TLayout extends TableLayout = TableLayout> = boolean | string | Partial<Record<TLayout, boolean | string>> | (() => boolean | string | Partial<Record<TLayout, boolean | string>>);
 export interface TableControlsSchema {
     refresh?: TableLayoutControl;
     layout?: TableLayoutControl;
@@ -17,9 +17,9 @@ export interface TableSelectionSchema {
     mode?: false | true | 'auto';
     scope?: 'page' | 'all';
 }
-export type PaginationConfig = {
-    sizeOptions?: Array<number> | {
-        [key in TableLayout]: Array<number>;
+export interface PaginationConfig {
+    sizeOptions?: number[] | {
+        [key in TableLayout]: number[];
     };
     defaultSize?: number | {
         [key in TableLayout]: number;
@@ -27,7 +27,7 @@ export type PaginationConfig = {
     showPageSizePicker?: boolean;
     showPagesList?: boolean;
     showPagesCount?: boolean;
-};
+}
 export type TableOffsetPaginationSchema = PaginationConfig & {
     mode?: 'offset';
 };
@@ -41,10 +41,10 @@ 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;
+    renderItem?: (params: TableRowRenderParams<TRow, TContext, TPageContext>) => RenderableType;
     renderSkeleton?: (params: {
         layout?: 'grid';
-    }) => unknown;
+    }) => RenderableType;
     gridSize?: number | string | (() => number | string);
     itemSize?: number | string | (() => number | string);
     sortOptions?: TableGridSortOption<TSortKey>[];
@@ -57,4 +57,19 @@ export interface TableTableSchema<TRow extends GenericObject = GenericObject, TC
     childrenKey?: TableSortKey<TRow>;
     defaultSorting?: TableDefaultSort<TSortKey>;
     selection?: boolean | 'auto';
+    summaries?: TableSummariesSchema<TRow>;
+}
+export interface TableSummariesSchema<TRow extends GenericObject = GenericObject> {
+    /** Rows the aggregates describe; defaults to `filtered`. */
+    scope?: TableSummaryScope;
+    /** Scopes the footer toggle offers; defaults to all three when selection is enabled. */
+    scopes?: TableSummaryScope[];
+    /** Footer label; defaults to a localized "Total". */
+    label?: TableTextValue;
+    /** Resolves every column summary at once, typically from the server; merged over derived values. */
+    resolve?: (context: {
+        scope: TableSummaryScope;
+        rows: TRow[];
+        request: TableSummaryRequest;
+    }) => Record<string, TableSummaryValue> | Promise<Record<string, TableSummaryValue>>;
 }

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

@@ -1,6 +1,5 @@
 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';
+import type { TableLayout, TableSortingDirection, 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> {
@@ -11,7 +10,7 @@ export interface TableQueryStateFilterRange<TValue = string | number> {
     from?: TValue;
     to?: TValue;
 }
-export type TableQueryStateFilterValue = string | number | boolean | Array<TableFilterPrimitiveValue> | Date | TableQueryStateFilterRange<number> | TableQueryStateFilterRange<Date>;
+export type TableQueryStateFilterValue = string | number | boolean | TableFilterPrimitiveValue[] | Date | TableQueryStateFilterRange<number> | TableQueryStateFilterRange<Date>;
 export interface TableQueryStateFilterDefinition<TKey extends string = string> {
     key: TKey;
     kind: TableQueryStateFilterKind;
@@ -56,9 +55,9 @@ export type ExtractTableFilterOperator<TSchema, TKey extends ExtractTableFilterK
 } ? 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>> = {
+export interface ExtractTableFilterRule<TSchema, TKey extends ExtractTableFilterKey<TSchema>> {
     key: TKey;
     operator?: ExtractTableFilterOperator<TSchema, TKey>;
     value: ExtractTableFilterValue<TSchema, TKey>;
-};
+}
 export {};

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

@@ -9,7 +9,7 @@ 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;
+    getNextPageParam: (lastPage: TData, allPages: TData[], lastPageParam: string | null, allPageParams: (string | null)[]) => string | null | undefined;
     enabled?: boolean;
     staleTime?: number;
     gcTime?: number;
@@ -22,6 +22,18 @@ export interface TableSourceExecutionResult<TRow extends GenericObject = Generic
     rowCount: number;
     facets?: TableFacetResult<TKey>[];
 }
+export interface TableOffsetPageResult<TRow extends GenericObject = GenericObject, TKey extends string = string> {
+    rows: TRow[];
+    pageInfo: {
+        mode: 'offset';
+        pageIndex: number;
+        pageSize: number;
+        hasNextPage: boolean;
+        count: 'exact';
+        rowCount: number;
+    };
+    facets?: TableFacetResult<TKey>[];
+}
 export type TableCursorPageInfo = {
     mode: 'cursor';
     pageSize: number;
@@ -77,6 +89,15 @@ export interface TableSourceRequestContext<TRow extends GenericObject = GenericO
     context: TContext;
     facets?: TableGlobalFacetDescriptor<TableKnownFieldPath<TRow> | string>[];
 }
+export interface TableRemoteSourceRequest<TRow extends GenericObject = GenericObject, TSortKey extends string = TableSortKey<TRow>> {
+    pagination?: Exclude<TablePaginationState, {
+        mode: 'none';
+    }>;
+    sorting: TableSortingRule<TSortKey>[];
+    filters: TableResolvedFilterGroup<TableKnownFieldPath<TRow> | string>[];
+    search: TableSourceSearchRequest<TRow>;
+    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>;
@@ -88,12 +109,12 @@ export interface TableClientSource<TRow extends GenericObject = GenericObject, T
     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>> {
+export interface TableRemoteSource<TRow extends GenericObject = GenericObject, TContext extends GenericObject = GenericObject, TResult = TableSourceExecutionResult<TRow, TableKnownFieldPath<TRow> | string> | TableOffsetPageResult<TRow, TableKnownFieldPath<TRow> | string> | TableCursorPageResult<TRow, TableKnownFieldPath<TRow> | string>> {
     mode: 'remote';
-    query: (ctx: TableSourceRequestContext<TRow, TContext>) => TableQueryDefinition<TResult>;
+    query: (request: TableRemoteSourceRequest<TRow>, context: 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 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> | TableOffsetPageResult<TRow, TableKnownFieldPath<TRow> | string> | TableCursorPageResult<TRow, TableKnownFieldPath<TRow> | string>> extends never ? TableSourceExecutionResult<TRow, TableKnownFieldPath<TRow> | string> | TableOffsetPageResult<TRow, TableKnownFieldPath<TRow> | string> | TableCursorPageResult<TRow, TableKnownFieldPath<TRow> | string> : Extract<TResult, TableSourceExecutionResult<TRow, TableKnownFieldPath<TRow> | string> | TableOffsetPageResult<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>>;

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

@@ -1,9 +1,10 @@
 import type { ComputedRef, WritableComputedRef } from 'vue';
 import type { useTableData } from '../composables/use-table-data.js';
+import type { useTablePagination } from '../composables/use-table-pagination.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 = {
+export interface PublicTableQueryState {
     layout: TableLayout;
     pagination: TablePaginationState;
     sorting: {
@@ -11,7 +12,12 @@ export type PublicTableQueryState = {
         sortDirection: 'asc' | 'desc';
     } | null;
     filters: TableFilterState;
-};
+}
+export interface TableRefreshResult {
+    data?: unknown;
+    error?: unknown;
+}
+export type TableLoadMoreResult = Awaited<ReturnType<ReturnType<typeof useTablePagination>['loadMore']>>;
 export interface TableOffsetPaginationApi {
     mode: 'offset';
     state: ComputedRef<{
@@ -41,7 +47,7 @@ export interface TableCursorPaginationApi {
         isLoadingMore: boolean;
         loadMoreError: unknown;
     }>;
-    loadMore: () => Promise<unknown>;
+    loadMore: () => Promise<TableLoadMoreResult>;
     reset: () => void;
 }
 export interface TableNoPaginationApi {
@@ -59,7 +65,11 @@ export type TablePaginationApi<TSchema> = TSchema extends {
     pagination: {
         mode: 'cursor';
     };
-} ? TableCursorPaginationApi : TableOffsetPaginationApi;
+} ? TableCursorPaginationApi : TSchema extends {
+    pagination?: infer TPagination;
+} ? TPagination extends false ? TableNoPaginationApi : TPagination extends {
+    mode: 'cursor';
+} ? TableCursorPaginationApi : TableOffsetPaginationApi : TableOffsetPaginationApi;
 export interface TableApi<TSchema = TableSchemaView> {
     state: {
         layout: ComputedRef<TableLayout>;

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

@@ -1,8 +1,11 @@
 import type { ComputedRef, Ref } from 'vue';
-import type { LazyTextValue, MaybePromise, NestedPaths, Prettify, RenderableType, UnionToIntersection } from '../../shared/index.js';
+import type { LazyTextValue, 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 ComputedRef, type Ref } from 'vue';
+export type { LazyTextValue, MaybePromise, NestedPaths, Prettify, RenderableType, UnionToIntersection, } from '../../shared/index.js';
 export type GenericObject = object;
+/** Runtime records retain arbitrary decoded values while keeping dictionary ownership explicit. */
+export type TableRuntimeRecord = import('../../shared/types/utils').GenericObject;
 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;
@@ -51,13 +54,13 @@ export type TableDefaultSort<TKey extends string = string> = TKey | {
     key: TKey;
     dir: TableSortingDirection;
 };
-export type TableSchemaRefLike<TValue> = {
+export interface 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)[];
+export type TableRowsFromSourceResult<TResult> = TResult extends readonly (infer TRow)[] ? TRow : TResult extends {
+    rows: readonly (infer TRow)[];
 } ? TRow : never;
 export type TableResolvedSchema<TSchema> = TSchema extends () => infer TValue ? TValue : TSchema extends {
     value: infer TValue;
@@ -67,7 +70,7 @@ type MergeContextItem<TItem> = TItem extends {
     query: (...args: any[]) => import('@tanstack/vue-query').UseQueryOptions<infer TValue>;
 } ? {
     [K in TKey]: Awaited<TValue>;
-} : {};
+} : NonNullable<unknown>;
 type MergeContextItemUnion<TItem> = UnionToIntersection<MergeContextItem<TItem>>;
 type ExtractSourceResult<TSchema> = TableResolvedSchema<TSchema> extends {
     source: infer TSource;
@@ -76,7 +79,7 @@ type NormalizeExtractedRow<TRow> = TRow extends GenericObject ? TRow : GenericOb
 export type ExtractTableRow<TSchema> = NormalizeExtractedRow<TableRowsFromSourceResult<ExtractSourceResult<TSchema>>>;
 export type ExtractTableContextData<TSchema> = Prettify<TableResolvedSchema<TSchema> extends {
     context?: infer TItems extends unknown[];
-} ? MergeContextItemUnion<TItems[number]> : {}>;
+} ? MergeContextItemUnion<TItems[number]> : NonNullable<unknown>>;
 export type ExtractTablePageContextData<TSchema> = Prettify<TableResolvedSchema<TSchema> extends {
     pageContext?: infer TItems extends unknown[];
-} ? MergeContextItemUnion<TItems[number]> : {}>;
+} ? MergeContextItemUnion<TItems[number]> : NonNullable<unknown>>;

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

@@ -1,10 +1,23 @@
 import type { DropdownMenuItem } from '@nuxt/ui/components/DropdownMenu.vue';
 import type { TableInjectedRowActionScope } from '../composables/use-table-row-actions.js';
-import type { GenericObject, TableRowAction, TableSchemaView } from '../types/index.js';
-type RowActionSchemaSource = {
+import type { GenericObject, TableRowAction, TableRuntimeRecord, TableSchemaView, TableTextValue } from '../types/index.js';
+interface RowActionSchemaSource {
     rowActions?: TableSchemaView['rowActions'];
+}
+export declare function hasConfiguredTableActions(schema: Pick<TableSchemaView, 'actions' | 'toolbarActions' | 'rowActions'>): boolean;
+export declare function resolveTableActionDefinitions(schema: Pick<TableSchemaView, 'actions' | 'toolbarActions'>): {
+    bulkActions: import("../types/index.js").TableBulkAction<object, {
+        [x: string]: unknown;
+    }, {
+        [x: string]: unknown;
+    }>[];
+    toolbarActions: import("../types/index.js").TableToolbarAction<object, {
+        [x: string]: unknown;
+    }, {
+        [x: string]: unknown;
+    }>[];
 };
-type ResolvedRowAction = TableRowAction<GenericObject, Record<string, unknown>, Record<string, unknown>>;
+type ResolvedRowAction = TableRowAction<GenericObject, TableRuntimeRecord, TableRuntimeRecord>;
 export declare function resolveTableRowActions(options: {
     schema: RowActionSchemaSource;
     scope: TableInjectedRowActionScope;
@@ -25,4 +38,5 @@ export declare function createRowActionDropdownItems(options: {
     actions: ResolvedRowAction[];
     scope: TableInjectedRowActionScope;
 }): DropdownMenuItem[];
+export declare function resolveTableActionLabel(label: TableTextValue | undefined): string | undefined;
 export {};

package/dist/runtime/table/utils/actions.js

@@ -1,7 +1,21 @@
+import { isFunction, isNumber } from "../../shared/utils/predicate.js";
+export function hasConfiguredTableActions(schema) {
+  return Boolean(schema.actions?.length);
+}
+export function resolveTableActionDefinitions(schema) {
+  return {
+    bulkActions: schema.actions ?? [],
+    toolbarActions: schema.toolbarActions ?? []
+  };
+}
 export function resolveTableRowActions(options) {
   const source = options.schema.rowActions;
-  if (!source) return [];
-  if (typeof source === "function") return source(options.scope);
+  if (!source) {
+    return [];
+  }
+  if (isRowActionResolver(source)) {
+    return source(options.scope);
+  }
   return source;
 }
 export function resolveVisibleTableRowActions(options) {
@@ -15,12 +29,12 @@ export function hasVisibleTableRowActions(options) {
     (row, index) => resolveVisibleTableRowActions({
       schema: options.schema,
       scope: {
-        row,
-        index,
         context: toPlainRecord(options.context),
+        index,
+        layout: options.layout,
         pageContext: toPlainRecord(options.pageContext),
-        tableApi: options.tableApi,
-        layout: options.layout
+        row,
+        tableApi: options.tableApi
       }
     }).length > 0
   );
@@ -37,16 +51,16 @@ function mapRowActionToDropdownItem(options) {
   }) : void 0;
   const item = {
     ...options.action,
-    label: resolveActionLabel(options.action),
+    children: children?.length ? children : void 0,
     disabled: resolveFlag({
-      value: options.action.disabled,
-      scope: options.scope
+      scope: options.scope,
+      value: options.action.disabled
     }),
+    label: resolveActionLabel(options.action),
     loading: resolveFlag({
-      value: options.action.loading,
-      scope: options.scope
+      scope: options.scope,
+      value: options.action.loading
     }),
-    children: children?.length ? children : void 0,
     onSelect: () => {
       void options.action.action?.(options.scope);
     }
@@ -56,30 +70,51 @@ function mapRowActionToDropdownItem(options) {
   return item;
 }
 function resolveActionLabel(action) {
-  if (typeof action.label === "function") return String(action.label());
-  if (typeof action.label === "number") return String(action.label);
-  return action.label;
+  return resolveTableActionLabel(action.label);
+}
+export function resolveTableActionLabel(label) {
+  if (isFunction(label)) {
+    return String(label());
+  }
+  if (isNumber(label)) {
+    return String(label);
+  }
+  return label;
 }
 function resolveConditionalBoolean(options) {
-  if (typeof options.value === "function") return options.value(options.scope);
+  if (isRowActionBooleanResolver(options.value)) {
+    return options.value(options.scope);
+  }
   return options.value ?? true;
 }
 function resolveCondition(options) {
   return resolveConditionalBoolean(options);
 }
 function resolveFlag(options) {
-  if (typeof options.value === "function") return options.value(options.scope);
+  if (isRowActionBooleanResolver(options.value)) {
+    return options.value(options.scope);
+  }
   return options.value ?? false;
 }
+function isRowActionResolver(value) {
+  return isFunction(value);
+}
+function isRowActionBooleanResolver(value) {
+  return isFunction(value);
+}
 function pruneTableRowActions(options) {
   return options.actions.flatMap((action) => {
-    if (!resolveCondition({ value: action.condition, scope: options.scope })) return [];
+    if (!resolveCondition({ scope: options.scope, value: action.condition })) {
+      return [];
+    }
     const children = action.children ? pruneTableRowActions({
       actions: action.children,
       scope: options.scope
     }) : void 0;
     const nextAction = children ? { ...action, children } : action;
-    if (!children?.length && !isActionItemSelectable(nextAction)) return [];
+    if (!children?.length && !isActionItemSelectable(nextAction)) {
+      return [];
+    }
     return [
       {
         ...nextAction,
@@ -89,11 +124,21 @@ function pruneTableRowActions(options) {
   });
 }
 function isActionItemSelectable(action) {
-  if (action.action) return true;
-  if (action.href) return true;
-  if (action.to) return true;
-  if (action.type === "checkbox") return true;
-  if (action.onUpdateChecked) return true;
+  if (action.action) {
+    return true;
+  }
+  if (action.href) {
+    return true;
+  }
+  if (action.to) {
+    return true;
+  }
+  if (action.type === "checkbox") {
+    return true;
+  }
+  if (action.onUpdateChecked) {
+    return true;
+  }
   return false;
 }
 function toPlainRecord(value) {

package/dist/runtime/table/utils/builders/table-source.d.ts

@@ -0,0 +1,59 @@
+import type { QueryKey, UseQueryOptions } from '@tanstack/vue-query';
+import type { GenericObject, TableClientSource, TableCursorPageResult, TableGlobalFacetDescriptor, TableOffsetPageResult, TablePaginationState, TableRemoteSource, TableRemoteSourceRequest, TableResolvedFilterGroup, TableRowsFromSourceResult, TableSourceExecutionResult, TableSortingRule } from '../../types/index.js';
+type TableSourceRow<TResult> = TableRowsFromSourceResult<Awaited<TResult>> extends infer TRow ? TRow extends GenericObject ? TRow : GenericObject : GenericObject;
+type ClientTableSourceResult<TResult> = TResult extends readonly GenericObject[] ? TableSourceRow<TResult>[] : TableSourceExecutionResult<TableSourceRow<TResult>>;
+type RemoteTableSourceResult<TResult> = TResult extends {
+    pageInfo: {
+        nextCursor: string | null;
+    };
+} ? TableCursorPageResult<TableSourceRow<TResult>> : TResult extends {
+    pageInfo: {
+        pageIndex: number;
+    };
+} ? TableOffsetPageResult<TableSourceRow<TResult>> : TableSourceExecutionResult<TableSourceRow<TResult>>;
+interface TableSourceInferenceContext {
+    pagination: TablePaginationState;
+    sorting: TableSortingRule<never>[];
+    filters: TableResolvedFilterGroup<never>;
+    search: {
+        value: string;
+        fields: never[];
+    };
+    context: GenericObject;
+    facets?: TableGlobalFacetDescriptor<never>[];
+}
+interface TableSourceQueryDefinition {
+    queryKey: QueryKey;
+}
+type TableSourceQueryResult<TQuery> = TQuery extends {
+    queryFn: (...args: never[]) => infer TResult;
+} ? Awaited<TResult> : TQuery extends UseQueryOptions<infer _TQueryFnData, infer _TError, infer TResult, infer _TQueryData, infer _TQueryKey> ? Awaited<TResult> : never;
+interface ClientTableSourceInput<TQuery extends TableSourceQueryDefinition> {
+    mode?: 'client';
+    query: (context: TableSourceInferenceContext) => TQuery;
+}
+interface RemoteTableSourceInput<TQuery extends TableSourceQueryDefinition> {
+    mode: 'remote';
+    query: (request: TableRemoteSourceRequest<GenericObject, string>, context: GenericObject) => TQuery;
+    facets?: TableRemoteSource['facets'];
+}
+/**
+ * Defines a table source inline while preserving its query-result inference before the surrounding
+ * schema derives row-aware filters, columns, actions, and page context.
+ *
+ * @example
+ * ```ts
+ * defineTableSchema({
+ *   source: tableSource({
+ *     mode: 'remote',
+ *     query: (request) => ({
+ *       queryKey: ['employees', request],
+ *       queryFn: () => api.queryEmployees(request),
+ *     }),
+ *   }),
+ * })
+ * ```
+ */
+export declare function tableSource<TQuery extends TableSourceQueryDefinition>(source: RemoteTableSourceInput<TQuery>): TableRemoteSource<TableSourceRow<TableSourceQueryResult<TQuery>>, GenericObject, RemoteTableSourceResult<TableSourceQueryResult<TQuery>>>;
+export declare function tableSource<TQuery extends TableSourceQueryDefinition>(source: ClientTableSourceInput<TQuery>): TableClientSource<TableSourceRow<TableSourceQueryResult<TQuery>>, GenericObject, ClientTableSourceResult<TableSourceQueryResult<TQuery>>>;
+export {};

package/dist/runtime/table/utils/builders/table-source.js

@@ -0,0 +1,3 @@
+export function tableSource(source) {
+  return source;
+}

package/dist/runtime/table/utils/client-query.d.ts

@@ -13,7 +13,7 @@ export declare function executeClientFacets<TRow extends GenericObject = Generic
 export declare function filterClientRows<TRow extends GenericObject>(params: {
     rows: Iterable<TRow>;
     filters: TableResolvedFilterGroup<string>;
-    search: TableSourceRequestContext<TRow>['search'];
+    search: TableSourceRequestContext['search'];
 }): TRow[];
 export declare function sortClientRows<TRow extends GenericObject>(params: {
     rows: Iterable<TRow>;