nuxt-ui-tools 0.1.3 → 1.0.0

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

@@ -0,0 +1,272 @@
+import { defineQueryPrefetchPlan } from "#ui-tools/query-prefetch/utils/plan";
+import {
+  isArray,
+  isBoolean,
+  isFunction,
+  isNumber,
+  isObject,
+  isNullish,
+  isString
+} from "../../shared/utils/predicate.js";
+import { QUERY_DEFAULTS } from "../constants/query-state.js";
+import { createTableCursorQueryKey } from "./cursor-query.js";
+import {
+  hasPerFilterFacetQuery,
+  resolveTableFacetMode,
+  resolveTableGlobalFacetDescriptors
+} from "./facets.js";
+import {
+  createTableFilterValueCodec,
+  getDefaultPageSize,
+  getDefaultSort,
+  getPaginationMode,
+  normalizeFilterDefinition,
+  parseTableFilterQueryState,
+  resolveFilterDefaultOperator,
+  resolveFilterSupportedOperators
+} from "./query-state.js";
+import { createResolvedFilterState } from "./resolved-filters.js";
+export function prefetchTable(params) {
+  if (!isTableSchemaView(params.schema)) {
+    throw new Error("Invalid table schema: expected a source query definition");
+  }
+  const { schema } = params;
+  const contextQueries = resolveContextQueries(schema);
+  return defineQueryPrefetchPlan().stage(contextQueries).stage((stageContext) => {
+    const context = resolveContextData(schema, stageContext);
+    const request = resolvePrefetchRequest({
+      context,
+      route: params.route,
+      schema
+    });
+    return resolveTableQueries({ request, schema });
+  }).stage((stageContext) => {
+    const rows = resolvePrefetchedRows(stageContext.source);
+    const context = resolveContextData(schema, stageContext);
+    return Object.fromEntries(
+      (schema.pageContext ?? []).filter((item) => item.condition?.() ?? true).map((item) => [
+        item.key,
+        withQueryDefaults(item.query({ context, rows }), QUERY_DEFAULTS.staleTime.context)
+      ])
+    );
+  });
+}
+function isTableSchemaView(value) {
+  if (!isObject(value) || !("source" in value)) {
+    return false;
+  }
+  return isObject(value.source) && isFunction(value.source.query);
+}
+function resolveContextQueries(schema) {
+  return Object.fromEntries(
+    (schema.context ?? []).filter((item) => item.condition?.() ?? true).map((item) => [item.key, withQueryDefaults(item.query(), QUERY_DEFAULTS.staleTime.context)])
+  );
+}
+function resolveContextData(schema, stageContext) {
+  return Object.fromEntries(
+    (schema.context ?? []).map((item) => [item.key, stageContext[item.key]])
+  );
+}
+function resolveTableQueries(options) {
+  const entries = [
+    [
+      "source",
+      withQueryDefaults(resolveSourcePrefetchQuery(options), QUERY_DEFAULTS.staleTime.data)
+    ]
+  ];
+  const definitions = options.schema.filters?.ui ?? [];
+  const globalFacets = resolveTableGlobalFacetDescriptors(definitions);
+  const remoteFacets = options.schema.source.mode === "remote" ? options.schema.source.facets : null;
+  if (isRemoteFacetResolver(remoteFacets) && globalFacets.length) {
+    entries.push([
+      "facets",
+      withQueryDefaults(
+        remoteFacets({
+          context: options.request.context,
+          facets: globalFacets,
+          filters: options.request.filters,
+          search: options.request.search
+        }),
+        QUERY_DEFAULTS.staleTime.filterOptions
+      )
+    ]);
+  }
+  for (const definition of definitions) {
+    if (definition.kind === "option" && isOptionQueryResolver(definition.source?.query)) {
+      entries.push([
+        `filter-options:${definition.key}`,
+        withQueryDefaults(
+          definition.source.query({ cursor: void 0, limit: void 0, search: void 0 }),
+          QUERY_DEFAULTS.staleTime.filterOptions
+        )
+      ]);
+    }
+    const facet = definition.kind === "option" || definition.kind === "boolean" ? definition.source?.facet : void 0;
+    if (!hasPerFilterFacetQuery(facet)) {
+      continue;
+    }
+    entries.push([
+      `filter-facets:${definition.key}`,
+      withQueryDefaults(
+        facet.query({
+          facets: [
+            {
+              cursor: void 0,
+              key: definition.key,
+              limit: resolveFacetLimit(facet),
+              mode: resolveTableFacetMode(facet)
+            }
+          ],
+          table: {
+            context: options.request.context,
+            filters: options.request.filters,
+            search: options.request.search
+          }
+        }),
+        QUERY_DEFAULTS.staleTime.filterOptions
+      )
+    ]);
+  }
+  return Object.fromEntries(entries);
+}
+function resolveSourcePrefetchQuery(options) {
+  const definition = options.schema.source.query(options.request);
+  if (options.request.pagination.mode !== "cursor" || !definition.queryFn) return definition;
+  const queryFn = definition.queryFn;
+  return {
+    ...definition,
+    queryFn: async (queryContext) => ({
+      pageParams: [null],
+      pages: [
+        await queryFn({
+          ...queryContext,
+          direction: "forward",
+          pageParam: null
+        })
+      ]
+    }),
+    queryKey: createTableCursorQueryKey(definition.queryKey, 0)
+  };
+}
+function resolvePrefetchRequest(options) {
+  const layout = resolveLayout(options.route, options.schema);
+  const filters = resolveFilterState(options.route, options.schema);
+  const globalFacets = resolveTableGlobalFacetDescriptors(options.schema.filters?.ui ?? []);
+  return {
+    context: options.context,
+    facets: options.schema.source.mode === "remote" && options.schema.source.facets === true && globalFacets.length ? globalFacets : void 0,
+    filters: createResolvedFilterState({
+      context: options.context,
+      definitions: options.schema.filters?.ui ?? [],
+      filters,
+      staticFilters: options.schema.filters?.static
+    }),
+    pagination: resolvePagination(options.route, options.schema, layout),
+    search: {
+      fields: options.schema.filters?.search?.fields ?? [],
+      value: filters.search
+    },
+    sorting: resolveSorting(options.route, options.schema, layout)
+  };
+}
+function resolveLayout(route, schema) {
+  const value = queryValue(route, "l");
+  return value === "grid" || value === "table" ? value : schema.defaultLayout ?? "table";
+}
+function resolvePagination(route, schema, layout) {
+  const mode = getPaginationMode(schema);
+  if (mode === "none") {
+    return { mode: "none" };
+  }
+  const defaultPageSize = getDefaultPageSize({ layout, schema });
+  const pageSize = positiveInteger(queryValue(route, "p.size")) ?? defaultPageSize;
+  if (mode === "cursor") {
+    return {
+      count: schema.pagination && isObject(schema.pagination) && schema.pagination.mode === "cursor" ? schema.pagination.count ?? "none" : "none",
+      cursor: null,
+      mode: "cursor",
+      pageSize
+    };
+  }
+  return {
+    count: "exact",
+    mode: "offset",
+    pageIndex: positiveInteger(queryValue(route, "p.page")) ?? 1,
+    pageSize
+  };
+}
+function resolveSorting(route, schema, layout) {
+  const defaultSort = getDefaultSort({ layout, schema });
+  const key = queryValue(route, "s.key") ?? defaultSort?.key;
+  if (!key) {
+    return [];
+  }
+  const direction = queryValue(route, "s.dir");
+  return [{ dir: direction === "desc" ? "desc" : defaultSort?.dir ?? "asc", key }];
+}
+function resolveFilterState(route, schema) {
+  const definitions = schema.filters?.ui ?? [];
+  const entries = /* @__PURE__ */ new Map();
+  for (const filter of definitions) {
+    const definition = normalizeFilterDefinition(filter);
+    const defaultOperator = resolveFilterDefaultOperator(definition);
+    for (const operator of resolveFilterSupportedOperators(definition)) {
+      const urlKey = operator === defaultOperator ? definition.key : `${definition.key}~${operator}`;
+      const raw = queryValue(route, `f.ui.${urlKey}`);
+      if (isNullish(raw) || raw === "") {
+        continue;
+      }
+      entries.set(urlKey, createTableFilterValueCodec(definition).parse(raw));
+    }
+  }
+  return {
+    search: queryValue(route, "f.search") ?? "",
+    ui: parseTableFilterQueryState({ definitions, entries })
+  };
+}
+function queryValue(route, key) {
+  const value = route.query[key];
+  const resolved = isArray(value) ? value[0] : value;
+  return isString(resolved) ? resolved : void 0;
+}
+function positiveInteger(value) {
+  if (!value) {
+    return;
+  }
+  const parsed = Number(value);
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : void 0;
+}
+function withQueryDefaults(query, staleTime) {
+  return {
+    ...query,
+    refetchOnWindowFocus: isQueryWithDefaults(query) && isBoolean(query.refetchOnWindowFocus) ? query.refetchOnWindowFocus : QUERY_DEFAULTS.refetchOnWindowFocus,
+    staleTime: isQueryWithDefaults(query) && isNumber(query.staleTime) ? query.staleTime : staleTime
+  };
+}
+function isQueryWithDefaults(value) {
+  return isObject(value);
+}
+function isRemoteFacetResolver(value) {
+  return isFunction(value);
+}
+function isOptionQueryResolver(value) {
+  return isFunction(value);
+}
+function resolveFacetLimit(facet) {
+  return facet.limit;
+}
+function resolvePrefetchedRows(value) {
+  if (isArray(value)) {
+    return value.filter(isGenericObject);
+  }
+  if (!isObject(value)) {
+    return [];
+  }
+  const pages = "pages" in value ? value.pages : void 0;
+  if (isArray(pages)) return pages.flatMap((page) => resolvePrefetchedRows(page));
+  const rows = "rows" in value ? value.rows : void 0;
+  return isArray(rows) ? rows.filter(isGenericObject) : [];
+}
+function isGenericObject(value) {
+  return isObject(value);
+}

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

@@ -1,4 +1,4 @@
-import type { QueryCodec } from '#ui-tools/query-state';
+import type { QueryCodec } from '#ui-tools/query-state/codecs';
 import type { TableFilterOperator, TableLayout, TableQueryStateFilterRule, TableUiFilterDefinition, TableQueryStateFilterDefinition, TableQueryStateFilterValue, TableSchemaView, TableSortingDirection, TablePaginationState, TablePaginationSchema } from '../types/index.js';
 export declare function getPaginationMode(schema: {
     pagination?: TablePaginationSchema;

package/dist/runtime/table/utils/query-state.js

@@ -5,30 +5,43 @@ import {
   dateISOCodec,
   numberCodec,
   stringCodec
-} from "#ui-tools/query-state";
-import { isObject, isString } from "../../shared/utils/predicate.js";
+} from "#ui-tools/query-state/codecs";
+import { isBoolean, isNumber, isObject, isString, isNullish } from "../../shared/utils/predicate.js";
 import { DEFAULT_FILTER_OPERATOR, PAGINATION_DEFAULTS } from "../constants/query-state.js";
 export function getPaginationMode(schema) {
-  if (schema.pagination === false) return "none";
-  if (schema.pagination?.mode === "cursor") return "cursor";
+  if (schema.pagination === false) {
+    return "none";
+  }
+  if (schema.pagination?.mode === "cursor") {
+    return "cursor";
+  }
   return "offset";
 }
 export function getDefaultPageSize(params) {
   const paginationConf = params.schema.pagination;
-  if (!paginationConf || typeof paginationConf !== "object")
+  if (!isObject(paginationConf)) {
     return PAGINATION_DEFAULTS.defaultSize[params.layout];
+  }
   if ("mode" in paginationConf && paginationConf.mode === "cursor") {
-    if (isObject(paginationConf.pageSize))
+    if (isNumber(paginationConf.pageSize)) {
+      return paginationConf.pageSize;
+    }
+    if (isLayoutNumberMap(paginationConf.pageSize)) {
       return paginationConf.pageSize[params.layout] ?? PAGINATION_DEFAULTS.defaultSize[params.layout];
-    return paginationConf.pageSize ?? PAGINATION_DEFAULTS.defaultSize[params.layout];
+    }
+    return PAGINATION_DEFAULTS.defaultSize[params.layout];
   }
-  if (isObject(paginationConf.defaultSize))
+  if (isNumber(paginationConf.defaultSize)) {
+    return paginationConf.defaultSize;
+  }
+  if (isLayoutNumberMap(paginationConf.defaultSize)) {
     return paginationConf.defaultSize[params.layout] ?? PAGINATION_DEFAULTS.defaultSize[params.layout];
-  return paginationConf.defaultSize ?? PAGINATION_DEFAULTS.defaultSize[params.layout];
+  }
+  return PAGINATION_DEFAULTS.defaultSize[params.layout];
 }
 export function getPageSizeOptions(params) {
   const paginationConf = params.schema.pagination;
-  if (!paginationConf || typeof paginationConf !== "object") {
+  if (!isObject(paginationConf)) {
     return PAGINATION_DEFAULTS.sizes[params.layout];
   }
   if ("mode" in paginationConf && paginationConf.mode === "cursor") {
@@ -37,16 +50,25 @@ export function getPageSizeOptions(params) {
   if (Array.isArray(paginationConf.sizeOptions)) {
     return paginationConf.sizeOptions;
   }
-  if (isObject(paginationConf.sizeOptions)) {
+  if (isLayoutPageSizeMap(paginationConf.sizeOptions)) {
     return paginationConf.sizeOptions[params.layout] ?? PAGINATION_DEFAULTS.sizes[params.layout];
   }
   return PAGINATION_DEFAULTS.sizes[params.layout];
 }
+function isLayoutNumberMap(value) {
+  return isObject(value);
+}
+function isLayoutPageSizeMap(value) {
+  return isObject(value);
+}
 export function getDefaultSort(params) {
   const defaultSorting = params.schema[params.layout]?.defaultSorting;
-  if (!defaultSorting) return null;
-  else if (isString(defaultSorting)) return { key: defaultSorting, dir: "asc" };
-  else return defaultSorting;
+  if (!defaultSorting) {
+    return null;
+  } else if (isString(defaultSorting)) {
+    return { dir: "asc", key: defaultSorting };
+  }
+  return defaultSorting;
 }
 export function getSortKeys(params) {
   const keys = /* @__PURE__ */ new Set();
@@ -76,44 +98,52 @@ export function createTableFilterValueCodec(definition) {
       if (!rawValue) {
         return definition.defaultValue;
       }
-      if (definition.kind === "option" && rawValue.includes(",")) {
+      if (definition.kind === "option") {
         return createArrayCodec(stringCodec).parse(rawValue);
       }
       if (definition.kind === "number" && rawValue.includes("..")) {
         const [from, to] = rawValue.split("..");
-        return {
-          ...from ? { from: numberCodec.parse(from) } : {},
-          ...to ? { to: numberCodec.parse(to) } : {}
-        };
+        const range = {};
+        if (from) {
+          range.from = numberCodec.parse(from);
+        }
+        if (to) {
+          range.to = numberCodec.parse(to);
+        }
+        return range;
       }
       if (definition.kind === "date" && rawValue.includes("..")) {
         const [from, to] = rawValue.split("..");
-        return {
-          ...from ? { from: dateISOCodec.parse(from) } : {},
-          ...to ? { to: dateISOCodec.parse(to) } : {}
-        };
+        const range = {};
+        if (from) {
+          range.from = dateISOCodec.parse(from);
+        }
+        if (to) {
+          range.to = dateISOCodec.parse(to);
+        }
+        return range;
       }
       return parseScalar(rawValue, definition);
     },
     serialize(value) {
-      if (value == null) {
+      if (isNullish(value)) {
         return null;
       }
       if (Array.isArray(value)) {
         return value.map((item) => serializeScalar(item)).join(",");
       }
       if (isRange(value)) {
-        const from = value.from == null ? "" : serializeScalar(value.from);
-        const to = value.to == null ? "" : serializeScalar(value.to);
+        const from = serializeOptionalScalar(value.from);
+        const to = serializeOptionalScalar(value.to);
         return `${from}..${to}`;
       }
       if (value instanceof Date) {
         return dateISOCodec.serialize(value);
       }
-      if (typeof value === "number") {
+      if (isNumber(value)) {
         return numberCodec.serialize(value);
       }
-      if (typeof value === "boolean") {
+      if (isBoolean(value)) {
         return booleanCodec.serialize(value);
       }
       return stringCodec.serialize(String(value));
@@ -121,12 +151,16 @@ export function createTableFilterValueCodec(definition) {
   };
 }
 export function resolveFilterDefaultOperator(definition) {
-  if (definition.defaultOperator) return definition.defaultOperator;
+  if (definition.defaultOperator) {
+    return definition.defaultOperator;
+  }
   return DEFAULT_FILTER_OPERATOR[definition.kind];
 }
 export function resolveFilterSupportedOperators(definition) {
   const defaultOperator = resolveFilterDefaultOperator(definition);
-  if (!definition.operators?.length) return [defaultOperator];
+  if (!definition.operators?.length) {
+    return [defaultOperator];
+  }
   return [.../* @__PURE__ */ new Set([defaultOperator, ...definition.operators])];
 }
 export function normalizeFilterDefinition(definition) {
@@ -138,26 +172,30 @@ export function normalizeFilterDefinition(definition) {
     return {
       ...definition,
       defaultOperator,
-      operators,
-      defaultValue
+      defaultValue,
+      operators
     };
   }
   if (isMinMaxNumberRange(defaultValue)) {
+    const range = {};
+    if ("min" in defaultValue) {
+      range.from = defaultValue.min;
+    }
+    if ("max" in defaultValue) {
+      range.to = defaultValue.max;
+    }
     return {
       ...definition,
       defaultOperator,
-      operators,
-      defaultValue: {
-        ..."min" in defaultValue ? { from: defaultValue.min } : {},
-        ..."max" in defaultValue ? { to: defaultValue.max } : {}
-      }
+      defaultValue: range,
+      operators
     };
   }
   return {
     ...definition,
     defaultOperator,
-    operators,
-    defaultValue
+    defaultValue,
+    operators
   };
 }
 export function resolveTableFilterDefaultRules(definitions) {
@@ -190,13 +228,13 @@ export function mergeTableFilterDefaultRules(options) {
 }
 export function isTableFilterRuleDefault(options) {
   const normalizedDefinition = normalizeFilterDefinition(options.definition);
-  const defaultValue = normalizedDefinition.defaultValue;
+  const { defaultValue } = normalizedDefinition;
   return defaultValue !== void 0 && (options.rule.operator ?? resolveFilterDefaultOperator(normalizedDefinition)) === resolveFilterDefaultOperator(normalizedDefinition) && areFilterValuesEqual(options.rule.value, defaultValue);
 }
 export function resolveTableActiveFilterRules(options) {
   return options.rules.filter((rule) => {
     const definition = options.definitions.find((candidate) => candidate.key === rule.key);
-    return !definition || !isTableFilterRuleDefault({ rule, definition });
+    return !definition || !isTableFilterRuleDefault({ definition, rule });
   });
 }
 export function parseTableFilterQueryState(options) {
@@ -214,13 +252,15 @@ export function parseTableFilterQueryState(options) {
       }
     }
   }
-  return mergeTableFilterDefaultRules({ rules, definitions: options.definitions });
+  return mergeTableFilterDefaultRules({ definitions: options.definitions, rules });
 }
 export function serializeTableFilterQueryState(options) {
   const result = /* @__PURE__ */ new Map();
   for (const rule of options.rules) {
     const filter = options.definitions.find((definition2) => definition2.key === rule.key);
-    if (!filter || isTableFilterRuleDefault({ rule, definition: filter })) continue;
+    if (!filter || isTableFilterRuleDefault({ definition: filter, rule })) {
+      continue;
+    }
     const definition = normalizeFilterDefinition(filter);
     const operator = rule.operator ?? resolveFilterDefaultOperator(definition);
     const defaultOperator = resolveFilterDefaultOperator(definition);
@@ -230,38 +270,45 @@ export function serializeTableFilterQueryState(options) {
   return result;
 }
 function isRange(value) {
-  if (!value || typeof value !== "object") {
-    return false;
-  }
-  return "from" in value || "to" in value;
+  return isObject(value) && ("from" in value || "to" in value);
 }
 function hasFilterValue(value) {
-  if (Array.isArray(value)) return value.length > 0;
-  if (typeof value === "string") return value.length > 0;
-  if (isRange(value)) return value.from != null || value.to != null;
+  if (Array.isArray(value)) {
+    return value.length > 0;
+  }
+  if (isString(value)) {
+    return value.length > 0;
+  }
+  if (isRange(value)) {
+    return !isNullish(value.from) || !isNullish(value.to);
+  }
   return true;
 }
 function isTableFilterValue(value) {
-  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value instanceof Date) {
+  if (isString(value) || isNumber(value) || isBoolean(value) || value instanceof Date) {
     return true;
   }
   if (Array.isArray(value)) {
-    return value.every(
-      (item) => typeof item === "string" || typeof item === "number" || typeof item === "boolean"
-    );
+    return value.every((item) => isString(item) || isNumber(item) || isBoolean(item));
+  }
+  if (!isRange(value)) {
+    return false;
   }
-  if (!isRange(value)) return false;
   return [value.from, value.to].every(
-    (item) => item == null || typeof item === "number" || item instanceof Date
+    (item) => isNullish(item) || isNumber(item) || item instanceof Date
   );
 }
 function areFilterValuesEqual(left, right) {
   if (Array.isArray(left) || Array.isArray(right)) {
-    if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length) return false;
+    if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length) {
+      return false;
+    }
     const unmatched = [...right];
     for (const value of left) {
       const index = unmatched.findIndex((candidate) => Object.is(candidate, value));
-      if (index === -1) return false;
+      if (index === -1) {
+        return false;
+      }
       unmatched.splice(index, 1);
     }
     return true;
@@ -270,7 +317,9 @@ function areFilterValuesEqual(left, right) {
     return left instanceof Date && right instanceof Date && left.getTime() === right.getTime();
   }
   if (isRange(left) || isRange(right)) {
-    if (!isRange(left) || !isRange(right)) return false;
+    if (!isRange(left) || !isRange(right)) {
+      return false;
+    }
     return areOptionalFilterValuesEqual(left.from, right.from) && areOptionalFilterValuesEqual(left.to, right.to);
   }
   return Object.is(left, right);
@@ -282,7 +331,7 @@ function areOptionalFilterValuesEqual(left, right) {
   return Object.is(left, right);
 }
 function isMinMaxNumberRange(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
+  if (!isObject(value) || Array.isArray(value)) {
     return false;
   }
   if ("from" in value || "to" in value) {
@@ -290,17 +339,26 @@ function isMinMaxNumberRange(value) {
   }
   const minValue = "min" in value ? value.min : void 0;
   const maxValue = "max" in value ? value.max : void 0;
-  return (minValue == null || typeof minValue === "number") && (maxValue == null || typeof maxValue === "number");
+  return (isNullish(minValue) || isNumber(minValue)) && (isNullish(maxValue) || isNumber(maxValue));
 }
 function serializeScalar(value) {
   if (value instanceof Date) {
     return value.toISOString();
   }
-  if (typeof value === "boolean") {
+  if (isBoolean(value)) {
     return value ? "true" : "false";
   }
   return String(value);
 }
+function serializeOptionalScalar(value) {
+  if (isNullish(value)) {
+    return "";
+  }
+  if (isString(value) || isNumber(value) || isBoolean(value) || value instanceof Date) {
+    return serializeScalar(value);
+  }
+  return "";
+}
 function parseScalar(rawValue, definition) {
   if (definition.kind === "boolean") {
     return booleanCodec.parse(rawValue);

package/dist/runtime/table/utils/resolved-filters.d.ts

@@ -1,7 +1,7 @@
 import type { GenericObject, TableFilterState, TableResolvedFilterGroup, TableStaticFilterNode, TableUiFilterDefinition } from '../types/index.js';
-export declare function createResolvedFilterState(params: {
-    definitions: Array<TableUiFilterDefinition<GenericObject, GenericObject, string>>;
-    filters: TableFilterState<string>;
-    staticFilters?: Array<TableStaticFilterNode<GenericObject, GenericObject, string>>;
-    context?: GenericObject;
+export declare function createResolvedFilterState<TRow extends GenericObject = GenericObject, TContext extends GenericObject = GenericObject, TKey extends string = string>(params: {
+    definitions: TableUiFilterDefinition<TRow, TContext, TKey>[];
+    filters: TableFilterState<TKey>;
+    staticFilters?: TableStaticFilterNode<TRow, TContext, TKey>[];
+    context?: TContext;
 }): TableResolvedFilterGroup<string>;