nuxt-ui-tools 0.1.3 → 1.0.0

package/dist/runtime/table/utils/filters/ui.js

@@ -1,11 +1,11 @@
 import { useUiToolsLocale } from "#ui-tools/i18n";
 import { getFilterLabelText, getFilterTextValue } from "./common.js";
 const DEFAULT_FILTER_TRIGGER_ICONS = {
-  text: "i-lucide-search",
-  option: "i-lucide-filter",
   boolean: "i-lucide-check",
+  date: "i-lucide-calendar-days",
   number: "i-lucide-hash",
-  date: "i-lucide-calendar-days"
+  option: "i-lucide-filter",
+  text: "i-lucide-search"
 };
 export function resolveFilterTriggerIcon(definition) {
   return definition.display?.icon ?? DEFAULT_FILTER_TRIGGER_ICONS[definition.kind];
@@ -14,27 +14,27 @@ export function resolveTextFilterUi(definition, operator) {
   const { t } = useUiToolsLocale();
   const override = operator ? definition.editor?.operators?.[operator] : void 0;
   return {
-    commitMode: definition.behavior?.commitMode ?? "manual",
-    clearOnOperatorChange: definition.behavior?.clearOnOperatorChange ?? true,
-    reopenOnOperatorChange: definition.behavior?.reopenOnOperatorChange ?? true,
     actions: resolveActions({ common: definition.actions }),
-    placeholder: getFilterTextValue({
-      value: override?.placeholder ?? definition.editor?.placeholder,
-      fallback: getFilterLabelText({ label: definition.label })
-    }),
-    inputType: definition.editor?.inputType ?? "text",
-    leadingIcon: definition.editor?.leadingIcon ?? "i-lucide-search",
     autocomplete: definition.editor?.autocomplete ?? "off",
+    clearOnOperatorChange: definition.behavior?.clearOnOperatorChange ?? true,
+    commitMode: definition.behavior?.commitMode ?? "manual",
     input: {
       autofocus: definition.editor?.input?.autofocus ?? false,
-      highlight: definition.editor?.input?.highlight ?? false,
-      fixed: definition.editor?.input?.fixed ?? false
+      fixed: definition.editor?.input?.fixed ?? false,
+      highlight: definition.editor?.input?.highlight ?? false
     },
+    inputType: definition.editor?.inputType ?? "text",
+    leadingIcon: definition.editor?.leadingIcon ?? "i-lucide-search",
+    placeholder: getFilterTextValue({
+      fallback: getFilterLabelText({ label: definition.label }),
+      value: override?.placeholder ?? definition.editor?.placeholder
+    }),
     preview: resolvePreview({
       base: definition.preview,
       empty: t("table.filters.preview.empty"),
       mode: "summary"
-    })
+    }),
+    reopenOnOperatorChange: definition.behavior?.reopenOnOperatorChange ?? true
   };
 }
 export function resolveOptionFilterUi(definition, operator) {
@@ -58,49 +58,49 @@ export function resolveOptionFilterUi(definition, operator) {
     operator
   });
   return {
-    commitMode: definition.behavior?.commitMode ?? "manual",
-    clearOnOperatorChange: definition.behavior?.clearOnOperatorChange ?? true,
-    reopenOnOperatorChange: definition.behavior?.reopenOnOperatorChange ?? true,
     actions: resolveActions({
       common: definition.actions,
       local: labels
     }),
-    searchable: definition.editor?.searchable ?? true,
+    clearOnOperatorChange: definition.behavior?.clearOnOperatorChange ?? true,
     closeOnSelect: definition.editor?.closeOnSelect ?? false,
-    presentation: definition.editor?.presentation ?? "list",
-    tree: {
-      selectable: tree?.selectable ?? "all",
-      expandedByDefault: tree?.expandedByDefault ?? false,
-      searchMode: tree?.searchMode ?? "auto",
-      branchSelection: tree?.branchSelection ?? "children"
-    },
-    selection: {
-      mode,
-      allowEmpty: selection.allowEmpty ?? true,
-      max: selection.max
-    },
-    row: {
-      showCounts: row.showCounts ?? true,
-      selectedIcon: row.selectedIcon ?? "i-lucide-check",
-      truncate: row.truncate ?? true,
-      getIcon: row.getIcon
-    },
+    commitMode: definition.behavior?.commitMode ?? "manual",
     labels: {
-      searchPlaceholder: getFilterTextValue({
-        value: labels.searchPlaceholder,
-        fallback: getFilterLabelText({ label: definition.label })
-      }),
       empty: getFilterTextValue({
-        value: labels.empty,
-        fallback: t("table.filters.options.empty")
+        fallback: t("table.filters.options.empty"),
+        value: labels.empty
+      }),
+      searchPlaceholder: getFilterTextValue({
+        fallback: getFilterLabelText({ label: definition.label }),
+        value: labels.searchPlaceholder
       })
     },
+    presentation: definition.editor?.presentation ?? "list",
     preview: resolveTagPreview({
       base: definition.preview,
       empty: t("table.filters.preview.empty"),
-      mode: "auto",
-      maxTags: 1
-    })
+      maxTags: 3,
+      mode: "auto"
+    }),
+    reopenOnOperatorChange: definition.behavior?.reopenOnOperatorChange ?? true,
+    row: {
+      getIcon: row.getIcon,
+      selectedIcon: row.selectedIcon ?? "i-lucide-check",
+      showCounts: row.showCounts ?? true,
+      truncate: row.truncate ?? true
+    },
+    searchable: definition.editor?.searchable ?? true,
+    selection: {
+      allowEmpty: selection.allowEmpty ?? true,
+      max: selection.max,
+      mode
+    },
+    tree: {
+      branchSelection: tree?.branchSelection ?? "children",
+      expandedByDefault: tree?.expandedByDefault ?? false,
+      searchMode: tree?.searchMode ?? "auto",
+      selectable: tree?.selectable ?? "all"
+    }
   };
 }
 export function resolveBooleanFilterUi(definition, operator) {
@@ -119,43 +119,43 @@ export function resolveBooleanFilterUi(definition, operator) {
     ...override?.selection
   };
   return {
-    commitMode: definition.behavior?.commitMode ?? "manual",
-    clearOnOperatorChange: definition.behavior?.clearOnOperatorChange ?? true,
-    reopenOnOperatorChange: definition.behavior?.reopenOnOperatorChange ?? true,
     actions: resolveActions({
       common: definition.actions,
       local: labels
     }),
+    clearOnOperatorChange: definition.behavior?.clearOnOperatorChange ?? true,
+    commitMode: definition.behavior?.commitMode ?? "manual",
+    icons: {
+      false: icons.false,
+      true: icons.true
+    },
     labels: {
-      true: getFilterTextValue({
-        value: labels.true,
-        fallback: t("table.filters.booleans.true")
+      empty: getFilterTextValue({
+        fallback: t("table.filters.booleans.empty"),
+        value: labels.empty
       }),
       false: getFilterTextValue({
-        value: labels.false,
-        fallback: t("table.filters.booleans.false")
+        fallback: t("table.filters.booleans.false"),
+        value: labels.false
       }),
-      empty: getFilterTextValue({
-        value: labels.empty,
-        fallback: t("table.filters.booleans.empty")
+      true: getFilterTextValue({
+        fallback: t("table.filters.booleans.true"),
+        value: labels.true
       })
     },
-    icons: {
-      true: icons.true,
-      false: icons.false
-    },
-    selection: {
-      allowEmpty: selection.allowEmpty ?? true
-    },
     preview: resolveTagPreview({
       base: definition.preview,
       empty: getFilterTextValue({
-        value: labels.empty,
-        fallback: t("table.filters.booleans.empty")
+        fallback: t("table.filters.booleans.empty"),
+        value: labels.empty
       }),
-      mode: "summary",
-      maxTags: 1
-    })
+      maxTags: 3,
+      mode: "summary"
+    }),
+    reopenOnOperatorChange: definition.behavior?.reopenOnOperatorChange ?? true,
+    selection: {
+      allowEmpty: selection.allowEmpty ?? true
+    }
   };
 }
 export function resolveNumberFilterUi(definition, operator) {
@@ -165,68 +165,68 @@ export function resolveNumberFilterUi(definition, operator) {
   const scalar = mergeNumberScalarConfig(definition.editor?.scalar, scalarOverride);
   const range = mergeNumberRangeConfig(definition.editor?.range, rangeOverride);
   return {
-    commitMode: definition.behavior?.commitMode ?? "manual",
-    clearOnOperatorChange: definition.behavior?.clearOnOperatorChange ?? true,
-    reopenOnOperatorChange: definition.behavior?.reopenOnOperatorChange ?? true,
     actions: resolveActions({ common: definition.actions }),
-    min: definition.editor?.min,
-    max: definition.editor?.max,
-    step: definition.editor?.step ?? 1,
+    clearOnOperatorChange: definition.behavior?.clearOnOperatorChange ?? true,
+    commitMode: definition.behavior?.commitMode ?? "manual",
     formatOptions: definition.editor?.formatOptions,
+    max: definition.editor?.max,
+    min: definition.editor?.min,
     preview: resolveNumberPreview({
       base: definition.preview,
       empty: t("table.filters.preview.empty"),
       mode: "summary"
     }),
-    scalar: {
-      display: scalar.display ?? "input",
-      input: {
-        placeholder: getFilterTextValue({
-          value: scalar.input?.placeholder,
-          fallback: getFilterLabelText({ label: definition.label })
-        }),
-        hideStepper: scalar.input?.hideStepper ?? false,
-        disableWheelChange: scalar.input?.disableWheelChange ?? true
-      },
-      slider: {
-        min: scalar.slider?.min ?? definition.editor?.min,
-        max: scalar.slider?.max ?? definition.editor?.max,
-        step: scalar.slider?.step ?? definition.editor?.step,
-        showTooltip: scalar.slider?.showTooltip ?? true
-      },
-      preview: resolveNumberPreview({
-        base: definition.preview,
-        empty: t("table.filters.preview.empty"),
-        mode: "summary"
-      })
-    },
     range: {
       display: range.display ?? "inputs",
-      minGap: range.minGap,
       inputs: {
+        disableWheelChange: range.inputs?.disableWheelChange ?? true,
         fromPlaceholder: getFilterTextValue({
-          value: range.inputs?.fromPlaceholder,
-          fallback: "Min"
-        }),
-        toPlaceholder: getFilterTextValue({
-          value: range.inputs?.toPlaceholder,
-          fallback: "Max"
+          fallback: "Min",
+          value: range.inputs?.fromPlaceholder
         }),
         hideStepper: range.inputs?.hideStepper ?? false,
-        disableWheelChange: range.inputs?.disableWheelChange ?? true
+        toPlaceholder: getFilterTextValue({
+          fallback: "Max",
+          value: range.inputs?.toPlaceholder
+        })
       },
+      minGap: range.minGap,
+      preview: resolveNumberPreview({
+        base: definition.preview,
+        empty: t("table.filters.preview.empty"),
+        mode: "summary"
+      }),
       slider: {
-        min: range.slider?.min ?? definition.editor?.min,
         max: range.slider?.max ?? definition.editor?.max,
-        step: range.slider?.step ?? definition.editor?.step,
-        showTooltip: range.slider?.showTooltip ?? true
+        min: range.slider?.min ?? definition.editor?.min,
+        showTooltip: range.slider?.showTooltip ?? true,
+        step: range.slider?.step ?? definition.editor?.step
+      }
+    },
+    reopenOnOperatorChange: definition.behavior?.reopenOnOperatorChange ?? true,
+    scalar: {
+      display: scalar.display ?? "input",
+      input: {
+        disableWheelChange: scalar.input?.disableWheelChange ?? true,
+        hideStepper: scalar.input?.hideStepper ?? false,
+        placeholder: getFilterTextValue({
+          fallback: getFilterLabelText({ label: definition.label }),
+          value: scalar.input?.placeholder
+        })
       },
       preview: resolveNumberPreview({
         base: definition.preview,
         empty: t("table.filters.preview.empty"),
         mode: "summary"
-      })
-    }
+      }),
+      slider: {
+        max: scalar.slider?.max ?? definition.editor?.max,
+        min: scalar.slider?.min ?? definition.editor?.min,
+        showTooltip: scalar.slider?.showTooltip ?? true,
+        step: scalar.slider?.step ?? definition.editor?.step
+      }
+    },
+    step: definition.editor?.step ?? 1
   };
 }
 export function resolveDateFilterUi(definition, operator) {
@@ -236,70 +236,70 @@ export function resolveDateFilterUi(definition, operator) {
   const scalar = mergeDateScalarConfig(definition.editor?.scalar, scalarOverride);
   const range = mergeDateRangeConfig(definition.editor?.range, rangeOverride);
   return {
-    commitMode: definition.behavior?.commitMode ?? "manual",
-    clearOnOperatorChange: definition.behavior?.clearOnOperatorChange ?? true,
-    reopenOnOperatorChange: definition.behavior?.reopenOnOperatorChange ?? true,
     actions: resolveActions({ common: definition.actions }),
+    clearOnOperatorChange: definition.behavior?.clearOnOperatorChange ?? true,
+    commitMode: definition.behavior?.commitMode ?? "manual",
     preview: resolveDatePreview({
       base: definition.preview,
       empty: t("table.filters.preview.empty"),
       mode: "summary"
     }),
-    scalar: {
-      display: scalar.display ?? "calendar",
-      presets: scalar.presets,
-      input: {
-        placeholder: getFilterTextValue({
-          value: scalar.input?.placeholder,
-          fallback: getFilterLabelText({ label: definition.label })
-        }),
-        granularity: scalar.input?.granularity ?? "day",
-        hideTimeZone: scalar.input?.hideTimeZone ?? true,
-        hourCycle: scalar.input?.hourCycle,
-        fixed: scalar.input?.fixed ?? true,
-        highlight: scalar.input?.highlight ?? false
-      },
+    range: {
       calendar: {
-        months: scalar.calendar?.months,
-        pagedNavigation: scalar.calendar?.pagedNavigation,
-        fixedWeeks: scalar.calendar?.fixedWeeks ?? true,
-        min: scalar.calendar?.min,
-        max: scalar.calendar?.max,
-        maxRangeDays: scalar.calendar?.maxRangeDays
+        fixedWeeks: range.calendar?.fixedWeeks ?? true,
+        max: range.calendar?.max,
+        maxRangeDays: range.calendar?.maxRangeDays,
+        min: range.calendar?.min,
+        months: range.calendar?.months,
+        pagedNavigation: range.calendar?.pagedNavigation
       },
-      preview: resolveDatePreview({
-        base: definition.preview,
-        empty: t("table.filters.preview.empty"),
-        mode: "summary"
-      })
-    },
-    range: {
       display: range.display ?? "inputs-calendar",
-      presets: range.presets,
-      presetsPlacement: range.presetsPlacement ?? "side",
       input: {
+        fixed: range.input?.fixed ?? true,
         fromPlaceholder: getFilterTextValue({
-          value: range.input?.fromPlaceholder,
-          fallback: "Start date"
-        }),
-        toPlaceholder: getFilterTextValue({
-          value: range.input?.toPlaceholder,
-          fallback: "End date"
+          fallback: "Start date",
+          value: range.input?.fromPlaceholder
         }),
         granularity: range.input?.granularity ?? "day",
         hideTimeZone: range.input?.hideTimeZone ?? true,
+        highlight: range.input?.highlight ?? false,
         hourCycle: range.input?.hourCycle,
-        fixed: range.input?.fixed ?? true,
-        highlight: range.input?.highlight ?? false
+        toPlaceholder: getFilterTextValue({
+          fallback: "End date",
+          value: range.input?.toPlaceholder
+        })
       },
+      presets: range.presets,
+      presetsPlacement: range.presetsPlacement ?? "side",
+      preview: resolveDatePreview({
+        base: definition.preview,
+        empty: t("table.filters.preview.empty"),
+        mode: "summary"
+      })
+    },
+    reopenOnOperatorChange: definition.behavior?.reopenOnOperatorChange ?? true,
+    scalar: {
       calendar: {
-        months: range.calendar?.months,
-        pagedNavigation: range.calendar?.pagedNavigation,
-        fixedWeeks: range.calendar?.fixedWeeks ?? true,
-        min: range.calendar?.min,
-        max: range.calendar?.max,
-        maxRangeDays: range.calendar?.maxRangeDays
+        fixedWeeks: scalar.calendar?.fixedWeeks ?? true,
+        max: scalar.calendar?.max,
+        maxRangeDays: scalar.calendar?.maxRangeDays,
+        min: scalar.calendar?.min,
+        months: scalar.calendar?.months,
+        pagedNavigation: scalar.calendar?.pagedNavigation
+      },
+      display: scalar.display ?? "calendar",
+      input: {
+        fixed: scalar.input?.fixed ?? true,
+        granularity: scalar.input?.granularity ?? "day",
+        hideTimeZone: scalar.input?.hideTimeZone ?? true,
+        highlight: scalar.input?.highlight ?? false,
+        hourCycle: scalar.input?.hourCycle,
+        placeholder: getFilterTextValue({
+          fallback: getFilterLabelText({ label: definition.label }),
+          value: scalar.input?.placeholder
+        })
       },
+      presets: scalar.presets,
       preview: resolveDatePreview({
         base: definition.preview,
         empty: t("table.filters.preview.empty"),
@@ -311,39 +311,39 @@ export function resolveDateFilterUi(definition, operator) {
 function resolveActions(options) {
   const { t } = useUiToolsLocale();
   return {
-    clear: getFilterTextValue({
-      value: options.local?.clear ?? options.common?.clear,
-      fallback: t("table.filters.panel.clearAll")
-    }),
     apply: getFilterTextValue({
-      value: options.local?.apply ?? options.common?.apply,
-      fallback: t("table.filters.panel.apply")
+      fallback: t("table.filters.panel.apply"),
+      value: options.local?.apply ?? options.common?.apply
+    }),
+    clear: getFilterTextValue({
+      fallback: t("table.filters.panel.clearAll"),
+      value: options.local?.clear ?? options.common?.clear
     })
   };
 }
 function resolvePreview(options) {
   return {
-    mode: options.base?.mode ?? options.mode,
+    empty: getFilterTextValue({
+      fallback: options.empty,
+      value: options.base?.empty
+    }),
     label: getFilterTextValue({
       value: options.base?.label
     }),
-    empty: getFilterTextValue({
-      value: options.base?.empty,
-      fallback: options.empty
-    })
+    mode: options.base?.mode ?? options.mode
   };
 }
 function resolveTagPreview(options) {
   return {
-    mode: options.base?.mode ?? options.mode,
+    empty: getFilterTextValue({
+      fallback: options.empty,
+      value: options.base?.empty
+    }),
     label: getFilterTextValue({
       value: options.base?.label
     }),
-    empty: getFilterTextValue({
-      value: options.base?.empty,
-      fallback: options.empty
-    }),
-    maxTags: options.base?.maxTags ?? options.maxTags
+    maxTags: options.base?.maxTags ?? options.maxTags,
+    mode: options.base?.mode ?? options.mode
   };
 }
 function resolveNumberPreview(options) {
@@ -363,9 +363,12 @@ function resolveDatePreview(options) {
   };
 }
 function resolveOptionSelectionMode(options) {
-  if (options.configured === "single" || options.configured === "multiple")
+  if (options.configured === "single" || options.configured === "multiple") {
     return options.configured;
-  if (options.operator === "isAnyOf") return "multiple";
+  }
+  if (options.operator === "isAnyOf") {
+    return "multiple";
+  }
   return "single";
 }
 function mergeNumberScalarConfig(base, override) {
@@ -400,13 +403,13 @@ function mergeDateScalarConfig(base, override) {
   return {
     ...base,
     ...override,
-    input: {
-      ...base?.input,
-      ...override?.input
-    },
     calendar: {
       ...base?.calendar,
       ...override?.calendar
+    },
+    input: {
+      ...base?.input,
+      ...override?.input
     }
   };
 }
@@ -414,31 +417,33 @@ function mergeDateRangeConfig(base, override) {
   return {
     ...base,
     ...override,
-    input: {
-      ...base?.input,
-      ...override?.input
-    },
     calendar: {
       ...base?.calendar,
       ...override?.calendar
+    },
+    input: {
+      ...base?.input,
+      ...override?.input
     }
   };
 }
 function getNumberScalarOperatorOverride(editor, operator) {
-  if (operator === "is" || operator === "isNot" || operator === "gt" || operator === "gte" || operator === "lt" || operator === "lte")
+  if (operator === "is" || operator === "isNot" || operator === "gt" || operator === "gte" || operator === "lt" || operator === "lte") {
     return editor?.operators?.[operator]?.scalar;
-  return void 0;
+  }
 }
 function getNumberRangeOperatorOverride(editor, operator) {
-  if (operator === "between") return editor?.operators?.between?.range;
-  return void 0;
+  if (operator === "between") {
+    return editor?.operators?.between?.range;
+  }
 }
 function getDateScalarOperatorOverride(editor, operator) {
-  if (operator === "is" || operator === "isNot" || operator === "before" || operator === "after")
+  if (operator === "is" || operator === "isNot" || operator === "before" || operator === "after") {
     return editor?.operators?.[operator]?.scalar;
-  return void 0;
+  }
 }
 function getDateRangeOperatorOverride(editor, operator) {
-  if (operator === "between") return editor?.operators?.between?.range;
-  return void 0;
+  if (operator === "between") {
+    return editor?.operators?.between?.range;
+  }
 }

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

@@ -1,10 +1,14 @@
 export * from './actions.js';
 export * from './client-query.js';
 export * from './columns/index.js';
+export * from './cursor-query.js';
 export * from './data-list-ui.js';
+export * from './facets.js';
 export * from './filters/index.js';
 export * from './pagination.js';
+export * from './prefetch.js';
 export * from './query-state.js';
 export * from './resolved-filters.js';
 export * from './rows.js';
 export * from './schema.js';
+export { tableSource } from './builders/table-source.js';

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

@@ -1,10 +1,14 @@
 export * from "./actions.js";
 export * from "./client-query.js";
 export * from "./columns/index.js";
+export * from "./cursor-query.js";
 export * from "./data-list-ui.js";
+export * from "./facets.js";
 export * from "./filters/index.js";
 export * from "./pagination.js";
+export * from "./prefetch.js";
 export * from "./query-state.js";
 export * from "./resolved-filters.js";
 export * from "./rows.js";
 export * from "./schema.js";
+export { tableSource } from "./builders/table-source.js";

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

@@ -1,5 +1,5 @@
 import type { TableCursorPageResult, TableExternalState, TableSchemaView } from '../types/index.js';
-export declare function isTableCursorPageResult(value: unknown): value is TableCursorPageResult;
+export declare function isTableCursorPageResult<TValue>(value: TValue): value is TValue & TableCursorPageResult;
 export declare function flattenTableCursorPages(options: {
     pages: readonly unknown[];
     rowKey: TableSchemaView['rowKey'];

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

@@ -1,20 +1,31 @@
+import { isArray, isObject } from "../../shared/utils/predicate.js";
 import { resolveTableRowId } from "./rows.js";
 export function isTableCursorPageResult(value) {
-  if (!value || typeof value !== "object") return false;
-  if (!("rows" in value) || !("pageInfo" in value)) return false;
-  if (!Array.isArray(value.rows) || !value.pageInfo || typeof value.pageInfo !== "object")
+  if (!isObject(value)) {
     return false;
-  if (!("mode" in value.pageInfo)) return false;
+  }
+  if (!("rows" in value) || !("pageInfo" in value)) {
+    return false;
+  }
+  if (!isArray(value.rows) || !isObject(value.pageInfo)) {
+    return false;
+  }
+  if (!("mode" in value.pageInfo)) {
+    return false;
+  }
   return value.pageInfo.mode === "cursor";
 }
 export function flattenTableCursorPages(options) {
   const rows = /* @__PURE__ */ new Map();
   let rowCount = null;
   for (const page of options.pages) {
-    if (!isTableCursorPageResult(page)) continue;
-    for (const [index, row] of page.rows.entries())
-      rows.set(resolveTableRowId({ rowKey: options.rowKey, row, index }), row);
+    if (!isTableCursorPageResult(page)) {
+      continue;
+    }
+    for (const [index, row] of page.rows.entries()) {
+      rows.set(resolveTableRowId({ index, row, rowKey: options.rowKey }), row);
+    }
     rowCount = page.pageInfo.rowCount;
   }
-  return { rows: [...rows.values()], rowCount };
+  return { rowCount, rows: [...rows.values()] };
 }

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

@@ -0,0 +1,25 @@
+import type { QueryPrefetchRuntimeRoute } from '#ui-tools/query-prefetch/types/page';
+/**
+ * Builds the staged TanStack Query plan required to render a table route.
+ *
+ * Context queries run first. The source, global facets, and remote filter-option
+ * queries then receive that context and the destination route's table state.
+ * Page-context queries run last with the prefetched source rows.
+ *
+ * @example
+ * ```ts
+ * defineQueryPrefetch('users', ({ route }) =>
+ *   prefetchTable({ route, schema: usersTableSchema() }),
+ * )
+ * ```
+ */
+export declare function prefetchTable<const TSchema extends {
+    source: object;
+}>(params: {
+    route: Pick<QueryPrefetchRuntimeRoute, 'query'>;
+    schema: TSchema;
+}): import("#ui-tools/query-prefetch/types/plan").QueryPrefetchPlan<{
+    readonly [x: string]: unknown;
+} & {
+    [x: string]: unknown;
+}>;