nuxt-ui-tools 0.1.3 → 1.0.0

package/dist/runtime/table/composables/use-table-data.js

@@ -1,14 +1,13 @@
-import {
-  useInfiniteQuery,
-  useQueries,
-  useQuery
-} from "@tanstack/vue-query";
+import { keepPreviousData, useInfiniteQuery, useQueries, useQuery } from "@tanstack/vue-query";
 import { computed, shallowRef, watch } from "vue";
+import { isArray, isFunction, isNumber, isObject, isString } from "../../shared/utils/predicate.js";
 import { QUERY_DEFAULTS } from "../constants/query-state.js";
 import {
+  createTableCursorQueryKey,
   executeClientFacets,
   filterClientRows,
   flattenTableCursorPages,
+  resolveTableGlobalFacetDescriptors,
   isTableCursorPageResult,
   paginateClientRows,
   resolveTableRowId,
@@ -19,16 +18,16 @@ export function useTableData(params) {
     () => (params.schema.value.context ?? []).filter((item) => item?.condition?.() ?? true)
   );
   const context = useQueries({
-    queries: () => contextItems.value.map(
-      (item) => withEnabled(item.query(), params.startup.isActive.value, {
-        staleTime: QUERY_DEFAULTS.staleTime.context,
-        refetchOnWindowFocus: QUERY_DEFAULTS.refetchOnWindowFocus
-      })
-    ),
     combine: (results) => results.map((result, index) => ({
       key: contextItems.value[index]?.key,
       ...result
-    }))
+    })),
+    queries: () => contextItems.value.map(
+      (item) => withEnabled(item.query(), params.startup.isActive.value, {
+        refetchOnWindowFocus: QUERY_DEFAULTS.refetchOnWindowFocus,
+        staleTime: QUERY_DEFAULTS.staleTime.context
+      })
+    )
   });
   const contextResults = computed(() => context.value);
   const contextData = computed(
@@ -54,38 +53,31 @@ export function useTableData(params) {
   );
   const requestFilters = computed(() => params.state.resolvedFilterState.value);
   const requestSearch = computed(() => ({
-    value: params.state.queryState.filters.value.search,
-    fields: params.schema.value.filters?.search?.fields ?? []
+    fields: params.schema.value.filters?.search?.fields ?? [],
+    value: params.state.queryState.filters.value.search
   }));
   const facetsBaseContext = computed(() => ({
+    context: contextData.value,
     filters: requestFilters.value,
-    search: requestSearch.value,
-    context: contextData.value
+    search: requestSearch.value
   }));
   const globalFacetDescriptors = computed(
-    () => (params.schema.value.filters?.ui ?? []).flatMap((definition) => {
-      if (definition.kind !== "option" && definition.kind !== "boolean") return [];
-      const descriptor = toGlobalFacetDescriptor({
-        key: definition.key,
-        facet: definition.source?.facet
-      });
-      return descriptor ? [descriptor] : [];
-    })
+    () => resolveTableGlobalFacetDescriptors(params.schema.value.filters?.ui ?? [])
   );
   const remoteSource = computed(
     () => params.schema.value.source.mode === "remote" ? params.schema.value.source : null
   );
-  const hasRemoteFacetQuery = computed(() => typeof remoteSource.value?.facets === "function");
+  const hasRemoteFacetQuery = computed(() => isRemoteFacetQuery(remoteSource.value?.facets));
   const usesEmbeddedRemoteFacets = computed(() => remoteSource.value?.facets === true);
   const facetsContextKey = computed(() => JSON.stringify(facetsBaseContext.value));
   const lastResolvedEmbeddedFacetsKey = shallowRef(null);
   const requestContext = computed(() => ({
     context: contextData.value,
-    pagination: requestPagination.value,
-    sorting: requestSorting.value,
+    facets: usesEmbeddedRemoteFacets.value && globalFacetDescriptors.value.length > 0 && facetsContextKey.value !== lastResolvedEmbeddedFacetsKey.value ? globalFacetDescriptors.value : void 0,
     filters: requestFilters.value,
+    pagination: requestPagination.value,
     search: requestSearch.value,
-    facets: usesEmbeddedRemoteFacets.value && globalFacetDescriptors.value.length > 0 && facetsContextKey.value !== lastResolvedEmbeddedFacetsKey.value ? globalFacetDescriptors.value : void 0
+    sorting: requestSorting.value
   }));
   const searchParams = requestContext;
   const dataStaleTime = computed(() => QUERY_DEFAULTS.staleTime.data);
@@ -93,31 +85,36 @@ export function useTableData(params) {
   const query = useQuery(
     computed(() => {
       const definition = resolveSourceDefinition({
-        source: params.schema.value.source,
+        context: contextData.value,
         request: requestContext.value,
-        context: contextData.value
+        source: params.schema.value.source
       });
-      if (isCursorPagination.value) return disabledQueryDefinition("cursor");
+      if (isCursorPagination.value) {
+        return disabledQueryDefinition("cursor");
+      }
       return withEnabled(definition, params.startup.isActive.value && isContextReady.value, {
-        staleTime: dataStaleTime.value,
-        refetchOnWindowFocus: QUERY_DEFAULTS.refetchOnWindowFocus
+        placeholderData: keepPreviousData,
+        refetchOnWindowFocus: QUERY_DEFAULTS.refetchOnWindowFocus,
+        staleTime: dataStaleTime.value
       });
     })
   );
   const infiniteQuery = useInfiniteQuery(
     computed(() => {
-      if (!isCursorPagination.value) return disabledInfiniteQueryDefinition();
+      if (!isCursorPagination.value) {
+        return disabledInfiniteQueryDefinition();
+      }
       return withInfiniteEnabled(
         createCursorQueryDefinition({
-          source: params.schema.value.source,
-          request: requestContext.value,
           context: contextData.value,
-          revision: params.state.queryState.paginationRevision.value
+          request: requestContext.value,
+          revision: params.state.queryState.paginationRevision.value,
+          source: params.schema.value.source
         }),
         params.startup.isActive.value && isContextReady.value,
         {
-          staleTime: dataStaleTime.value,
-          refetchOnWindowFocus: QUERY_DEFAULTS.refetchOnWindowFocus
+          refetchOnWindowFocus: QUERY_DEFAULTS.refetchOnWindowFocus,
+          staleTime: dataStaleTime.value
         }
       );
     })
@@ -125,11 +122,11 @@ export function useTableData(params) {
   const globalFacetsQuery = useQuery(
     computed(() => {
       const facetsSource = remoteSource.value?.facets;
-      if (!hasRemoteFacetQuery.value || typeof facetsSource !== "function" || !globalFacetDescriptors.value.length) {
+      if (!hasRemoteFacetQuery.value || !isRemoteFacetQuery(facetsSource) || !globalFacetDescriptors.value.length) {
         return {
-          queryKey: ["table-global-facets", "disabled"],
+          enabled: false,
           queryFn: async () => ({ facets: [] }),
-          enabled: false
+          queryKey: ["table-global-facets", "disabled"]
         };
       }
       const facetContext = {
@@ -140,15 +137,15 @@ export function useTableData(params) {
         facetsSource(facetContext),
         params.startup.isActive.value && isContextReady.value,
         {
-          staleTime: QUERY_DEFAULTS.staleTime.filterOptions,
-          refetchOnWindowFocus: QUERY_DEFAULTS.refetchOnWindowFocus
+          refetchOnWindowFocus: QUERY_DEFAULTS.refetchOnWindowFocus,
+          staleTime: QUERY_DEFAULTS.staleTime.filterOptions
         }
       );
     })
   );
   const rawDataState = shallowRef({
-    rows: [],
-    rowCount: 0
+    rowCount: 0,
+    rows: []
   });
   const cursorRowOverrides = shallowRef(/* @__PURE__ */ new Map());
   const embeddedFacetsState = shallowRef([]);
@@ -157,68 +154,88 @@ export function useTableData(params) {
       pages: infiniteQuery.data.value?.pages ?? [],
       rowKey: params.schema.value.rowKey
     });
-    if (!cursorRowOverrides.value.size) return flattened;
+    if (!cursorRowOverrides.value.size) {
+      return flattened;
+    }
     return {
+      rowCount: flattened.rowCount,
       rows: mergeRowsByKey({
         currentRows: flattened.rows,
         nextRows: [...cursorRowOverrides.value.values()],
         rowKey: params.schema.value.rowKey
-      }),
-      rowCount: flattened.rowCount
+      })
     };
   });
   const rawData = computed(
     () => isCursorPagination.value ? cursorRawData.value : rawDataState.value
   );
   const clientFilteredRows = computed(() => {
-    if (!params.startup.isActive.value) return [];
-    if (params.schema.value.source.mode !== "client") return rawData.value.rows;
+    if (!params.startup.isActive.value) {
+      return [];
+    }
+    if (params.schema.value.source.mode !== "client") {
+      return rawData.value.rows;
+    }
     return filterClientRows({
-      rows: rawData.value.rows,
       filters: requestFilters.value,
+      rows: rawData.value.rows,
       search: requestSearch.value
     });
   });
   const clientSortedRows = computed(() => {
-    if (!params.startup.isActive.value) return [];
-    if (params.schema.value.source.mode !== "client") return clientFilteredRows.value;
+    if (!params.startup.isActive.value) {
+      return [];
+    }
+    if (params.schema.value.source.mode !== "client") {
+      return clientFilteredRows.value;
+    }
     return sortClientRows({
       rows: clientFilteredRows.value,
       sorting: requestSorting.value
     });
   });
   const data = computed(() => {
-    if (!params.startup.isActive.value)
+    if (!params.startup.isActive.value) {
       return {
-        rows: [],
-        rowCount: 0
+        rowCount: 0,
+        rows: []
       };
-    if (params.schema.value.source.mode !== "client") return rawData.value;
+    }
+    if (params.schema.value.source.mode !== "client") {
+      return rawData.value;
+    }
     return paginateClientRows({
-      rows: clientSortedRows.value,
-      pagination: requestPagination.value
+      pagination: requestPagination.value,
+      rows: clientSortedRows.value
     });
   });
   const selectableRows = computed(
-    () => !params.startup.isActive.value ? [] : params.schema.value.source.mode === "client" ? clientSortedRows.value : data.value.rows
+    () => params.startup.isActive.value ? params.schema.value.source.mode === "client" ? clientSortedRows.value : data.value.rows : []
   );
   const clientFacetDescriptors = computed(
     () => globalFacetDescriptors.value.map((facet) => ({
       key: facet.key,
-      mode: facet.mode,
-      limit: facet.limit
+      limit: facet.limit,
+      mode: facet.mode
     }))
   );
   const facets = computed(() => {
-    if (!params.startup.isActive.value) return { facets: [] };
-    if (params.schema.value.source.mode === "client")
+    if (!params.startup.isActive.value) {
+      return { facets: [] };
+    }
+    if (params.schema.value.source.mode === "client") {
       return executeClientFacets({
-        rows: rawData.value.rows,
+        facets: clientFacetDescriptors.value,
         request: requestContext.value,
-        facets: clientFacetDescriptors.value
+        rows: rawData.value.rows
       });
-    if (hasRemoteFacetQuery.value) return globalFacetsQuery.data.value ?? { facets: [] };
-    if (usesEmbeddedRemoteFacets.value) return { facets: embeddedFacetsState.value };
+    }
+    if (hasRemoteFacetQuery.value) {
+      return globalFacetsQuery.data.value ?? { facets: [] };
+    }
+    if (usesEmbeddedRemoteFacets.value) {
+      return { facets: embeddedFacetsState.value };
+    }
     return { facets: [] };
   });
   const pageContextItems = computed(
@@ -243,6 +260,10 @@ export function useTableData(params) {
     () => params.startup.isActive.value && isContextReady.value && isActiveDataSuccess.value && !isActiveDataFetching.value
   );
   const pageContext = useQueries({
+    combine: (results) => results.map((result, index) => ({
+      key: pageContextItems.value[index]?.key,
+      ...result
+    })),
     queries: () => {
       if (!isPageContextEnabled.value) {
         return [];
@@ -250,21 +271,17 @@ export function useTableData(params) {
       return pageContextItems.value.map(
         (item) => withEnabled(
           item.query({
-            rows: data.value.rows,
-            context: contextData.value
+            context: contextData.value,
+            rows: data.value.rows
           }),
           true,
           {
-            staleTime: QUERY_DEFAULTS.staleTime.context,
-            refetchOnWindowFocus: QUERY_DEFAULTS.refetchOnWindowFocus
+            refetchOnWindowFocus: QUERY_DEFAULTS.refetchOnWindowFocus,
+            staleTime: QUERY_DEFAULTS.staleTime.context
           }
         )
       );
-    },
-    combine: (results) => results.map((result, index) => ({
-      key: pageContextItems.value[index]?.key,
-      ...result
-    }))
+    }
   });
   const pageContextResults = computed(() => pageContext.value);
   const pageContextData = computed(
@@ -298,18 +315,18 @@ export function useTableData(params) {
     if (!params.startup.isActive.value) {
       return {
         initialized: false,
-        phase: params.startup.phase.value,
         isBooting: true,
-        isPending: true,
-        isFetching: false,
-        isRefreshing: false,
-        isRevalidating: false,
-        isContextPending: false,
         isContextFetching: false,
-        isDataPending: false,
+        isContextPending: false,
         isDataFetching: false,
+        isDataPending: false,
+        isFetching: false,
+        isPageContextFetching: false,
         isPageContextPending: false,
-        isPageContextFetching: false
+        isPending: true,
+        isRefreshing: false,
+        isRevalidating: false,
+        phase: params.startup.phase.value
       };
     }
     const isDataPending = isActiveDataPending.value;
@@ -317,28 +334,32 @@ export function useTableData(params) {
     const isRefreshing = context.value.some((item) => Boolean(item.isRefetching)) || isActiveDataRefetching.value || pageContextResults.value.some((item) => Boolean(item.isRefetching));
     return {
       initialized: initialized.value,
-      phase: params.startup.phase.value,
       isBooting: false,
-      isPending: isContextPending.value || !isActiveDataSuccess.value && isDataPending || !initialized.value && isPageContextPending.value,
-      isFetching: isContextFetching.value || isDataFetching || isPageContextFetching.value,
-      isRefreshing,
-      isRevalidating: isActiveDataRefetching.value && rawData.value.rows.length > 0,
-      isContextPending: isContextPending.value,
       isContextFetching: isContextFetching.value,
-      isDataPending,
+      isContextPending: isContextPending.value,
       isDataFetching,
+      isDataPending,
+      isFetching: isContextFetching.value || isDataFetching || isPageContextFetching.value,
+      isPageContextFetching: isPageContextFetching.value,
       isPageContextPending: isPageContextPending.value,
-      isPageContextFetching: isPageContextFetching.value
+      isPending: isContextPending.value || !isActiveDataSuccess.value && isDataPending || !initialized.value && isPageContextPending.value,
+      isRefreshing,
+      isRevalidating: isActiveDataRefetching.value && rawData.value.rows.length > 0,
+      phase: params.startup.phase.value
     };
   });
   watch(
     () => query.data.value,
     (nextQueryData) => {
       const normalized = normalizeExternalState(nextQueryData);
-      if (sameExternalState(rawDataState.value, normalized)) return;
+      if (sameExternalState(rawDataState.value, normalized)) {
+        return;
+      }
       rawDataState.value = normalized;
       const embeddedFacets = extractEmbeddedFacets(nextQueryData);
-      if (!embeddedFacets) return;
+      if (!embeddedFacets) {
+        return;
+      }
       embeddedFacetsState.value = embeddedFacets;
       lastResolvedEmbeddedFacetsKey.value = facetsContextKey.value;
     },
@@ -347,10 +368,14 @@ export function useTableData(params) {
   watch(
     () => infiniteQuery.data.value?.pages,
     (pages) => {
-      if (!pages) return;
-      for (let index = pages.length - 1; index >= 0; index--) {
+      if (!pages) {
+        return;
+      }
+      for (let index = pages.length - 1; index >= 0; index -= 1) {
         const embeddedFacets = extractEmbeddedFacets(pages[index]);
-        if (!embeddedFacets) continue;
+        if (!embeddedFacets) {
+          continue;
+        }
         embeddedFacetsState.value = embeddedFacets;
         lastResolvedEmbeddedFacetsKey.value = facetsContextKey.value;
         return;
@@ -380,14 +405,17 @@ export function useTableData(params) {
     return Promise.all(pageContextResults.value.map((item) => item.refetch()));
   }
   function updateRows(rows) {
-    if (!rows.length) return;
+    if (!rows.length) {
+      return;
+    }
     if (isCursorPagination.value) {
       const nextOverrides = new Map(cursorRowOverrides.value);
-      for (const [index, row] of rows.entries())
+      for (const [index, row] of rows.entries()) {
         nextOverrides.set(
-          resolveTableRowId({ rowKey: params.schema.value.rowKey, row, index }),
+          resolveTableRowId({ index, row, rowKey: params.schema.value.rowKey }),
           row
         );
+      }
       cursorRowOverrides.value = nextOverrides;
       return;
     }
@@ -396,120 +424,153 @@ export function useTableData(params) {
       nextRows: rows,
       rowKey: params.schema.value.rowKey
     });
-    if (sameRows(rawDataState.value.rows, nextRawRows)) return;
+    if (sameRows(rawDataState.value.rows, nextRawRows)) {
+      return;
+    }
     rawDataState.value = {
-      rows: nextRawRows,
-      rowCount: rawDataState.value.rowCount
+      rowCount: rawDataState.value.rowCount,
+      rows: nextRawRows
     };
   }
   return {
     context,
     contextData,
+    data,
+    error,
+    facets,
+    facetsBaseContext,
+    infiniteQuery,
     pageContext,
     pageContextData,
-    facetsBaseContext,
-    requestContext,
-    searchParams,
     query,
-    infiniteQuery,
     rawData,
-    data,
-    selectableRows,
-    facets,
-    error,
-    status,
     refreshContext,
     refreshData,
     refreshPageContext,
+    requestContext,
+    searchParams,
+    selectableRows,
+    status,
     updateRows
   };
 }
 function normalizeExternalState(result) {
-  if (Array.isArray(result)) {
+  if (isArray(result)) {
     return {
-      rows: result,
-      rowCount: result.length
+      rowCount: result.length,
+      rows: result
     };
   }
   if (isTableExternalState(result)) {
     return {
-      rows: result.rows,
-      rowCount: result.rowCount
+      rowCount: result.rowCount,
+      rows: result.rows
+    };
+  }
+  if (isTableOffsetPageResult(result)) {
+    return {
+      rowCount: result.pageInfo.rowCount,
+      rows: result.rows
     };
   }
   return {
-    rows: [],
-    rowCount: 0
+    rowCount: 0,
+    rows: []
   };
 }
 function extractEmbeddedFacets(result) {
-  if (!result || typeof result !== "object" || !("facets" in result)) return void 0;
+  if (!isObject(result) || !("facets" in result)) {
+    return void 0;
+  }
   const { facets } = result;
-  if (!Array.isArray(facets)) return void 0;
-  return facets;
+  if (!isArray(facets)) {
+    return void 0;
+  }
+  return facets.filter(isTableFacetResult);
 }
-function toGlobalFacetDescriptor(options) {
-  if (!options.facet) return null;
-  if (hasPerFilterFacetQuery(options.facet)) return null;
-  return {
-    key: options.key,
-    mode: resolveFacetMode(options.facet),
-    limit: typeof options.facet === "object" ? options.facet.limit : void 0
-  };
+function isTableExternalState(value) {
+  if (!isObject(value)) {
+    return false;
+  }
+  if (!("rows" in value) || !("rowCount" in value)) {
+    return false;
+  }
+  return isArray(value.rows) && isNumber(value.rowCount);
 }
-function hasPerFilterFacetQuery(facet) {
-  return typeof facet === "object" && typeof facet.query === "function";
+function isTableOffsetPageResult(value) {
+  if (!isObject(value) || !("rows" in value) || !("pageInfo" in value)) {
+    return false;
+  }
+  if (!isArray(value.rows) || !isObject(value.pageInfo)) {
+    return false;
+  }
+  if (!("mode" in value.pageInfo) || value.pageInfo.mode !== "offset") {
+    return false;
+  }
+  if (!("rowCount" in value.pageInfo)) {
+    return false;
+  }
+  return isNumber(value.pageInfo.rowCount);
 }
-function resolveFacetMode(facet) {
-  if (facet === "include-self") return "include-self";
-  if (typeof facet === "object" && facet.mode === "include-self") return "include-self";
-  return "exclude-self";
+function isTableFacetResult(value) {
+  return isObject(value) && "key" in value && isStringKey(value.key) && "options" in value && isArray(value.options);
 }
-function isTableExternalState(value) {
-  if (!value || typeof value !== "object") return false;
-  if (!("rows" in value) || !("rowCount" in value)) return false;
-  return Array.isArray(value.rows) && typeof value.rowCount === "number";
+function isStringKey(value) {
+  return isString(value);
 }
 function sameExternalState(left, right) {
   return left.rowCount === right.rowCount && sameRows(left.rows, right.rows);
 }
 function sameRows(left, right) {
-  if (left === right) return true;
-  if (left.length !== right.length) return false;
-  for (let index = 0; index < left.length; index++) {
-    if (left[index] !== right[index]) return false;
+  if (left === right) {
+    return true;
+  }
+  if (left.length !== right.length) {
+    return false;
+  }
+  for (let index = 0; index < left.length; index += 1) {
+    if (left[index] !== right[index]) {
+      return false;
+    }
   }
   return true;
 }
 function mergeRowsByKey(options) {
   const replacements = new Map(
     options.nextRows.map((row, index) => [
-      resolveTableRowId({ rowKey: options.rowKey, row, index }),
+      resolveTableRowId({ index, row, rowKey: options.rowKey }),
       row
     ])
   );
   return options.currentRows.map((row, index) => {
-    const nextRow = replacements.get(resolveTableRowId({ rowKey: options.rowKey, row, index }));
+    const nextRow = replacements.get(resolveTableRowId({ index, row, rowKey: options.rowKey }));
     return nextRow ?? row;
   });
 }
 function withEnabled(query, enabled, defaults) {
   return {
     ...query,
-    ...defaults ?? {},
+    ...defaults,
     enabled: enabled && query.enabled !== false
   };
 }
+function isRemoteFacetQuery(value) {
+  return isFunction(value);
+}
 function resolveSourceDefinition(options) {
   return options.source.query({ ...options.request, context: options.context });
 }
 function createCursorQueryDefinition(options) {
   const firstPageDefinition = resolveSourceDefinition(options);
-  const pagination = options.request.pagination;
-  if (pagination.mode !== "cursor")
+  const { pagination } = options.request;
+  if (pagination.mode !== "cursor") {
     throw new Error("Cursor query definitions require cursor pagination.");
+  }
   return {
-    queryKey: [...firstPageDefinition.queryKey, { tableCursorRevision: options.revision }],
+    enabled: isQueryDefinitionEnabled(firstPageDefinition),
+    getNextPageParam(lastPage) {
+      return isTableCursorPageResult(lastPage) ? lastPage.pageInfo.nextCursor ?? void 0 : void 0;
+    },
     initialPageParam: null,
     async queryFn(queryContext) {
       const definition = resolveSourceDefinition({
@@ -517,46 +578,47 @@ function createCursorQueryDefinition(options) {
         request: {
           ...options.request,
           pagination: {
-            mode: "cursor",
+            count: pagination.count,
             cursor: queryContext.pageParam,
-            pageSize: pagination.pageSize,
-            count: pagination.count
+            mode: "cursor",
+            pageSize: pagination.pageSize
           }
         }
       });
-      if (!definition.queryFn) throw new Error("Cursor table sources must provide a queryFn.");
+      if (!definition.queryFn) {
+        throw new Error("Cursor table sources must provide a queryFn.");
+      }
       return definition.queryFn(queryContext);
     },
-    getNextPageParam(lastPage) {
-      return isTableCursorPageResult(lastPage) ? lastPage.pageInfo.nextCursor ?? void 0 : void 0;
-    },
-    enabled: isQueryDefinitionEnabled(firstPageDefinition)
+    queryKey: createTableCursorQueryKey(firstPageDefinition.queryKey, options.revision)
   };
 }
 function isQueryDefinitionEnabled(query) {
-  if (!("enabled" in query)) return true;
+  if (!("enabled" in query)) {
+    return true;
+  }
   return query.enabled !== false;
 }
 function disabledQueryDefinition(reason) {
   return {
-    queryKey: ["table-data-disabled", reason],
+    enabled: false,
     queryFn: async () => [],
-    enabled: false
+    queryKey: ["table-data-disabled", reason]
   };
 }
 function disabledInfiniteQueryDefinition() {
   return {
-    queryKey: ["table-infinite-data-disabled"],
-    queryFn: async () => [],
+    enabled: false,
+    getNextPageParam: () => null,
     initialPageParam: null,
-    getNextPageParam: () => void 0,
-    enabled: false
+    queryFn: async () => [],
+    queryKey: ["table-infinite-data-disabled"]
   };
 }
 function withInfiniteEnabled(query, enabled, defaults) {
   return {
     ...query,
-    ...defaults ?? {},
+    ...defaults,
     enabled: enabled && query.enabled !== false
   };
 }