@antelopejs/dms 0.11.0 → 0.12.0

package/frontend-vue/layers/dms-ui/app/build/composables/table-view/tableViewViews.ts

@@ -0,0 +1,114 @@
+import { useTableViews } from "./useTableViews";
+import { useMobileDisplay } from "./useMobileDisplay";
+import type { TableViewScope } from "./tableViewScope";
+
+export function useTableViewViews<T extends Data>(
+  scope: Pick<
+    TableViewScope<T>,
+    | "pinnedFilters"
+    | "defaultSorting"
+    | "configuration"
+    | "filterState"
+    | "displayPreferences"
+    | "displayOptions"
+    | "urlFilters"
+    | "arrival"
+    | "props"
+  >,
+) {
+  const { pinnedDefaultFilters } = scope.pinnedFilters;
+  const { defaultSortState, sorting } = scope.defaultSorting;
+  const { initialVisibility, listableColumns } = scope.configuration;
+  const {
+    displayDefault,
+    columnFilters,
+    globalFilter,
+    columnVisibility,
+    columnOrder,
+  } = scope.filterState;
+  const { DEFAULT_DENSITY, density } = scope.displayPreferences;
+  const { offeredDisplayIds, activeDisplayId } = scope.displayOptions;
+  const { paginationState } = scope.urlFilters;
+  const { tablePreferences, urlScope } = scope.arrival;
+  const { props } = scope;
+  const {
+    items: tableViewItems,
+    activeViewId,
+    activeView,
+    isModified: isViewModified,
+    canSaveViews,
+    selectView,
+    openLinkedView,
+    resetView,
+    saveView,
+    saveAsNewView,
+    deleteView,
+  } = useTableViews({
+    views: props.views,
+    defaults: {
+      pinnedFilters: pinnedDefaultFilters,
+      sorting: defaultSortState,
+      visibility: initialVisibility,
+      columnOrder: listableColumns.map(
+        (column) => column.id ?? column.accessorKey,
+      ),
+
+      get display() {
+        return displayDefault.value;
+      },
+      density: props.density ?? DEFAULT_DENSITY,
+      displays: offeredDisplayIds,
+    },
+    state: {
+      columnFilters,
+      globalFilter,
+      sorting,
+      columnVisibility,
+      columnOrder,
+      display: activeDisplayId,
+      density,
+      pagination: paginationState,
+    },
+    preferences: tablePreferences,
+    urlScope,
+  });
+  return {
+    activeViewId,
+    activeView,
+    tableViewItems,
+    openLinkedView,
+    canSaveViews,
+    isViewModified,
+    selectView,
+    resetView,
+    saveView,
+    saveAsNewView,
+    deleteView,
+  };
+}
+
+export function useTableViewMobileDisplay<T extends Data>(
+  scope: Pick<
+    TableViewScope<T>,
+    "filterState" | "displayOptions" | "views" | "arrival" | "props"
+  >,
+) {
+  const { displayDefault } = scope.filterState;
+  const { offeredDisplayIds, activeDisplayId, isDefaultDisplayStandalone } =
+    scope.displayOptions;
+  const { activeView } = scope.views;
+  const { tablePreferences } = scope.arrival;
+  const { props } = scope;
+  useMobileDisplay({
+    mobileDisplay: props.mobileDisplay,
+    defaultDisplay: displayDefault,
+    offered: offeredDisplayIds,
+    display: activeDisplayId,
+    activeView,
+    isDisplayChosen: () =>
+      isDefaultDisplayStandalone ||
+      tablePreferences.get<string | undefined>("viewMode", undefined) !==
+        undefined,
+  });
+  return {};
+}

package/frontend-vue/layers/dms-ui/app/build/composables/table-view/useCardFields.ts

@@ -2,8 +2,11 @@ import { get } from "@nuxt/ui/runtime/utils/index.js";
 import { h, type VNodeChild } from "vue";
 import type { TableViewColumn } from "../../../composables/table-view/types/column";
 import { useColumnValueRenderer } from "../data-types/useColumnValueRenderer";
+import { isNumber, isString } from "#dms-core/app/utils/type-check";
 
-type Row = Record<string, unknown>;
+type Row = Parameters<
+  ReturnType<typeof useColumnValueRenderer>["renderColumnValue"]
+>[1];
 
 /**
  * Draws a row's fields on a card (the cards display, the kanban board) the
@@ -16,11 +19,11 @@ export function useCardFields() {
 
   const renderField = (column: TableViewColumn, item: Row): VNodeChild => {
     const rendered = renderColumnValue(column, item, "cell");
-    if (typeof rendered !== "string" && typeof rendered !== "number") {
+    if (!isString(rendered) && !isNumber(rendered)) {
       return rendered;
     }
     const value = get(item, column.accessorKey);
-    // The fallback of a missing value reads dimmed, as an empty cell does.
+
     const isMissing = value === null || value === undefined;
     return h(
       "span",

package/frontend-vue/layers/dms-ui/app/build/composables/table-view/useGroupedRows.ts

@@ -11,6 +11,7 @@ import type {
   TableRowGrouping,
 } from "../../components/table/Table.vue";
 import { useColumnValueRenderer } from "../data-types/useColumnValueRenderer";
+import type { TableCountQuery } from "./useTableRows";
 import {
   dateGroupLabel,
   groupFilter,
@@ -29,11 +30,9 @@ export interface GroupedRowsOptions {
   /** The rows listed. */
   rows: ComputedRef<Data[] | undefined>;
   /** The count query of the rows listed, narrowed by one more filter. */
-  countQuery: (filter: TableFilter) => Record<string, unknown>;
+  countQuery: (filter: TableFilter) => TableCountQuery["query"];
   /** Asks the counts, by id, in one request (`count/batch`). */
-  countBatch: (
-    queries: { id: string; query: Record<string, unknown> }[],
-  ) => Promise<Record<string, number>>;
+  countBatch: (queries: TableCountQuery[]) => Promise<Record<string, number>>;
 }
 
 /**
@@ -55,8 +54,6 @@ export function useGroupedRows(options: GroupedRowsOptions) {
   const keyOf = (row: Data): string =>
     rowGroupKey(get(row, field.value), by.value, locale.value);
 
-  // A date heads its group as a mono eyebrow ("TODAY · 29 SEPT"); a value
-  // as its cell draws it, without the row's other fields.
   const eyebrow = (text: string) =>
     h("span", { class: GROUP_EYEBROW_CLASS }, text);
   const header = (key: string, row: Data) => {
@@ -84,7 +81,6 @@ export function useGroupedRows(options: GroupedRowsOptions) {
       : [],
   );
 
-  // Asked again whenever the groups listed or the rows' filters change.
   const countQueries = computed(() =>
     listedKeys.value.flatMap((key) => {
       const filter = groupFilter(field.value, key, by.value);
@@ -92,14 +88,14 @@ export function useGroupedRows(options: GroupedRowsOptions) {
     }),
   );
 
-  // Counted in the browser: a server render draws the headers without them.
   const refreshCounts = async () => {
     const queries = countQueries.value;
     if (import.meta.env.SSR || queries.length === 0) return;
+    // prettier-ignore
     try {
       counts.value = await options.countBatch(queries);
     } catch {
-      // Without its count a group header still reads.
+      // eslint-disable-line no-empty -- A failed count request leaves the group rows readable.
     }
   };
 

package/frontend-vue/layers/dms-ui/app/build/composables/table-view/usePersistedPagination.ts

@@ -1,6 +1,6 @@
 import type { PaginationState } from "@tanstack/vue-table";
 import { computed, ref, watch, type Ref } from "vue";
-import { hashText } from "#dms-core/app/build/composables/user/tablePreferences";
+import { hashText } from "#dms-core/app/entries/composables/user/tablePreferences";
 import type { TablePreferences } from "./useTablePreferences";
 
 const FIRST_PAGE_INDEX = 0;
@@ -13,6 +13,7 @@ export interface PersistedPaginationOptions {
    * What lists other rows without the user picking it: the hidden filters
    * the page URL sets. A change of value lists from the first page.
    */
+  // oxlint-disable-next-line anti-slop/no-unknown-returns -- The scope is an opaque value serialized for equality, not a query sent to an endpoint. No schema owns all scope values; narrowing would exclude existing serializable callers.
   scope: () => unknown;
 }
 
@@ -36,7 +37,7 @@ export function usePersistedPagination(
     hashText(JSON.stringify(options.scope() ?? null)),
   );
   const stored = preferences.get<PaginationState>("pagination", defaults);
-  // A page kept without its scope (the first one): kept as it is.
+
   const storedScope = preferences.get<string>(
     "paginationScope",
     scopeKey.value,
@@ -45,7 +46,6 @@ export function usePersistedPagination(
     storedScope === scopeKey.value ? stored : firstPage(stored),
   );
 
-  // Synchronous, so the list is queried once, with both changes.
   watch(
     scopeKey,
     () => {

package/frontend-vue/layers/dms-ui/app/build/composables/table-view/useReorderHandles.ts

@@ -4,9 +4,7 @@ import type {
   TableViewReorderHandle,
 } from "../../../composables/table-view/types/display";
 
-// One place back or forward: a row of the grid steps up and down, a card of
-// the cards grid also left and right.
-const STEP_BY_KEY: Record<string, number> = {
+const STEP_BY_KEY: Record<KeyboardEvent["key"], number> = {
   ArrowUp: -1,
   ArrowLeft: -1,
   ArrowDown: 1,
@@ -55,17 +53,16 @@ export function useReorderHandles(options: ReorderHandlesOptions) {
 
   const startDrag = (index: number, event: DragEvent) => {
     draggedIndex.value = index;
-    // Firefox starts a drag only once it carries data.
+
     event.dataTransfer?.setData("text/plain", String(index));
     if (event.dataTransfer) event.dataTransfer.effectAllowed = DRAG_EFFECT;
   };
 
-  // The handle moves with its row (rows are keyed by id), and the browser
-  // drops the focus of an element it moves: give it back.
   const stepByKey = (index: number, event: KeyboardEvent) => {
     const delta = STEP_BY_KEY[event.key];
     if (delta === undefined) return;
     event.preventDefault();
+    // oxlint-disable-next-line anti-slop/require-safety-comment-for-type-assertion -- EventTarget has no focus method, and the DOM event owner does not narrow currentTarget to the handle. A runtime HTMLElement check would change behavior for other focusable targets.
     const handle = event.currentTarget as HTMLElement | null;
     if (step(index, delta)) void nextTick(() => handle?.focus());
   };

package/frontend-vue/layers/dms-ui/app/build/composables/table-view/useTableFooter.ts

@@ -10,13 +10,14 @@ import type {
   TableFooterTexts,
 } from "../../components/table/Table.vue";
 import { useColumnValueRenderer } from "../data-types/useColumnValueRenderer";
+import type { TableCountQuery } from "./useTableRows";
 
 export interface TableFooterOptions {
   footer: TableViewFooter | undefined;
   columns: TableViewColumn[];
   location: string;
   /** The list query without paging: the rows the figures cover. */
-  query: ComputedRef<Record<string, unknown>>;
+  query: ComputedRef<TableCountQuery["query"]>;
   /** Prefix of the data key, unique to the table on its page. */
   dataKey: string;
 }
@@ -27,7 +28,6 @@ interface LegendItemOption {
   iconColor?: string;
 }
 
-// Sorting changes no figure: it stays out of the summary request.
 const UNSORTED_KEYS = new Set(["sortKey", "sortDirection"]);
 
 /**
@@ -60,7 +60,7 @@ export function useTableFooter(options: TableFooterOptions) {
             query: summaryQuery.value,
             signal,
           }),
-    // Read again with the table's rows, on the table's own triggers.
+
     { lazy: true, watch: [summaryQuery], refreshOnPageRefresh: false },
   );
 
@@ -85,11 +85,9 @@ export function useTableFooter(options: TableFooterOptions) {
     (column) => column.accessorKey === footer?.legend,
   );
   const legend = computed<TableFooterLegendItem[] | undefined>(() => {
-    const items = (
-      legendColumn?.type?.inputComponent?.options as
-        | { items?: LegendItemOption[] }
-        | undefined
-    )?.items;
+    const options: { items?: LegendItemOption[] } | undefined =
+      legendColumn?.type?.inputComponent?.options;
+    const items = options?.items;
     return items?.map((item) => ({
       label: processI18n(item.label ?? ""),
       color: item.textColor ?? item.iconColor,

package/frontend-vue/layers/dms-ui/app/build/composables/table-view/useTableLinkedVisit.ts

@@ -4,12 +4,13 @@ import type { QueryParamFilters } from "../../../composables/table-view/types/co
 import { isLinkedVisit } from "./utils/linkedArrival";
 import { queryOfUrl } from "./utils/urlFilters";
 import type { TableUrlScope } from "./utils/views";
+import type { LocationQuery } from "#dms/frontend-module";
 
 const URL_BASE = "http://dms.invalid";
 
 /** What `useTableLinkedVisit` reads a visit against, and what it calls. */
 export interface TableLinkedVisitOptions {
-  route: { path: string; query: Record<string, unknown> };
+  route: { path: string; query: LocationQuery };
   urlScope: TableUrlScope;
   queryParamFilters: QueryParamFilters | undefined;
   activeView: () => string | undefined;
@@ -17,7 +18,7 @@ export interface TableLinkedVisitOptions {
   canOpenView: (id: string) => boolean;
   canOpenTab: (id: string) => boolean;
   /** Opens the table on what the visit's link names, as an arrival would. */
-  follow: (query: Record<string, unknown>) => void;
+  follow: (query: LocationQuery) => void;
 }
 
 /**
@@ -30,10 +31,9 @@ export interface TableLinkedVisitOptions {
  * another page is left alone: the table is about to unmount.
  */
 export function useTableLinkedVisit(options: TableLinkedVisitOptions): void {
-  // The page the table is shown on, as the visit that mounted it reached it.
   const pathname = options.route.path;
-  let previousQuery: Record<string, unknown> = { ...options.route.query };
-  // A pushed visit announces itself twice when it changes the URL.
+  let previousQuery: LocationQuery = { ...options.route.query };
+
   let followedVisitId: string | undefined;
   const stops: Array<() => void> = [];
 

package/frontend-vue/layers/dms-ui/app/build/composables/table-view/useTableListData.ts

@@ -1,9 +1,9 @@
 import { computed, type ComputedRef } from "vue";
 import type { TableViewListResponse } from "../../../composables/table-view/types";
-import type { useTableRows } from "./useTableRows";
+import type { TableCountQuery, useTableRows } from "./useTableRows";
 import { buildTableDataKey } from "./utils/tableQuery";
 
-type Query = Record<string, unknown>;
+type Query = TableCountQuery["query"];
 type TableRows<T extends Record<string, unknown>> = ReturnType<
   typeof useTableRows<T>
 >;
@@ -81,7 +81,7 @@ export function useTableListData<T extends Record<string, unknown>>(
   });
   return useDmsAsyncData(
     key,
-    // `null` while a source waits on its period scope: the table's skeleton.
+
     ({ signal }): Promise<TableViewListResponse<T> | null> =>
       isSelfManaged.value
         ? Promise.resolve(EMPTY_LIST_RESULT)
@@ -97,7 +97,7 @@ export function useTableListData<T extends Record<string, unknown>>(
         rows.sourceUrl,
       ],
       lazy: true,
-      // The table reads again on its own triggers, through its live hold.
+
       refreshOnPageRefresh: false,
     },
   );

package/frontend-vue/layers/dms-ui/app/build/composables/table-view/useTableLiveHold.ts

@@ -11,12 +11,12 @@ import { usePageLive } from "../../../composables/live/usePageLive";
 import type {
   PageLiveNote,
   TableViewLiveHoldOptions,
-} from "../../../types/live";
+} from "#dms-core/app/types/live";
 import type { LiveGate } from "../live/currentPageLive";
 import { useScrolledPastTop, useTableReached } from "./useScrolledPastTop";
-import { LIVE_HELD_AT_QUERY_KEY } from "./useTableRows";
+import { LIVE_HELD_AT_QUERY_KEY, type TableCountQuery } from "./useTableRows";
 
-type Query = Record<string, unknown>;
+type Query = TableCountQuery["query"];
 
 /** What the table tells its hold about the user's reading. */
 export interface TableLiveHoldSignals {
@@ -30,6 +30,7 @@ export interface TableLiveHoldSignals {
    * The table's element: whether it is on screen, and where its first row
    * stands for `whileScrolled`.
    */
+  // oxlint-disable-next-line anti-slop/no-unknown-returns -- The resolver may return unparsed or missing element refs. useLocalHold accepts only HTMLElement instances and treats other values as absent; an HTMLElement-only contract would exclude those existing fallback cases.
   tableElement?: () => unknown;
 }
 
@@ -114,10 +115,6 @@ function holdOptionsOf(
   return liveHold === true ? {} : liveHold;
 }
 
-// The table alone holds while the page is live: the user reads a row in the
-// side panel, narrows or reorders the rows, reads further down than the rows
-// that would move, or has them on screen at all — a new row at the top would
-// push them down. The first reason in this order is the one shown.
 function useLocalHold(
   holdOptions: TableViewLiveHoldOptions | null,
   signals: TableLiveHoldSignals,
@@ -167,7 +164,7 @@ export function useTableLiveHold(options: TableLiveHoldOptions): TableLiveHold {
       isEnabled.value &&
       (isPaused.value || isLocallyHeld.value),
   );
-  // Again on a new controller: the gate binds to the page on screen.
+
   watch(
     [isLocallyHeld, isEnabled],
     ([held, enabled]) => {
@@ -200,13 +197,6 @@ export function useTableLiveHold(options: TableLiveHoldOptions): TableLiveHold {
 /** Lets a burst of events through before counting the new rows once. */
 const NEW_ROWS_COUNT_DELAY_MS = 500;
 
-// The new rows the table would show, counted on its source while it holds
-// some events: a topic publishes on every row, so a "4xx" tab, a search or a
-// filter would otherwise announce rows it never lists. Counted again on each
-// new event or held list, a burst at a time. Rows removed meanwhile lower
-// the count: the table answers what it lists, not what came in. A count that
-// fails falls back to the events. Only in the browser, once mounted: the
-// table sets up its gate and its list after its hold.
 function useCountedNewRows(
   missed: () => number,
   counter: TableNewRowsCounter,
@@ -264,9 +254,6 @@ function useCountedNewRows(
   });
 }
 
-// The bound a source route receives while the rows are held: they are as
-// fresh as the hold, or as the last read the user asked for since (Show, an
-// action of theirs).
 function useHeldQuery(
   isHolding: ComputedRef<boolean>,
   options: TableLiveHoldOptions,

package/frontend-vue/layers/dms-ui/app/build/composables/table-view/useTablePreferences.ts

@@ -13,7 +13,7 @@ import {
   TABLES_PREFERENCE_KEY,
   tablePreferenceId,
   writeLocalTableEntry,
-} from "#dms-core/app/build/composables/user/tablePreferences";
+} from "#dms-core/app/entries/composables/user/tablePreferences";
 
 /**
  * The preferences of one table view. A field the server render needs
@@ -40,7 +40,7 @@ export interface TablePreferences {
 
 interface PendingRestore {
   field: LocalTableField;
-  apply: (value: unknown) => void;
+  apply: (value: ReturnType<typeof readLocalTableEntry>[string]) => void;
 }
 
 /** The table's entry in the cookie: `tables.<id>`, its server fields. */
@@ -51,9 +51,8 @@ function useServerTableEntry(id: string) {
   const entry = (): CompactTableEntry | undefined =>
     getPreference<CompactTableEntry | undefined>(path, undefined);
   const tables = () =>
-    getPreference<Record<string, unknown>>(TABLES_PREFERENCE_KEY, {});
+    getPreference<CompactTableEntry>(TABLES_PREFERENCE_KEY, {});
 
-  // The last entry takes the collection with it: no empty branch left over.
   const forget = () => {
     const isLastEntry = Object.keys(tables()).every((key) => key === id);
     removePreference(isLastEntry ? TABLES_PREFERENCE_KEY : path);
@@ -61,8 +60,8 @@ function useServerTableEntry(id: string) {
 
   const set = (
     field: ServerTableField,
-    value: unknown,
-    defaultValue: unknown,
+    value: Parameters<typeof encodeServerField>[1],
+    defaultValue: Parameters<typeof encodeServerField>[2],
   ) => {
     const { key } = SERVER_TABLE_FIELDS[field];
     const next = { ...entry() };
@@ -74,7 +73,6 @@ function useServerTableEntry(id: string) {
     else setPreference(path, next);
   };
 
-  // The table used last is evicted last: opening it counts as a write.
   const markUsed = () => {
     const current = entry();
     if (current && Object.keys(tables()).at(-1) !== id) {
@@ -88,8 +86,8 @@ function useServerTableEntry(id: string) {
 const setLocalField = (
   id: string,
   field: LocalTableField,
-  value: unknown,
-  defaultValue: unknown,
+  value: Parameters<typeof isDefaultValue>[0],
+  defaultValue: Parameters<typeof isDefaultValue>[1],
 ) => {
   const entry = readLocalTableEntry(id);
   if (isDefaultValue(value, defaultValue)) {
@@ -140,6 +138,7 @@ export function useTablePreferences(
       pending.push({
         field,
         apply: (value) => {
+          // oxlint-disable-next-line anti-slop/require-safety-comment-for-type-assertion -- Storage returns arbitrary preference values, while restore accepts caller-selected T and an optional boolean validator. Neither owner proves T; adding mandatory validation would change restoration behavior.
           const restored = value as typeof state.value;
           if (!isValid || isValid(restored)) state.value = restored;
         },

package/frontend-vue/layers/dms-ui/app/build/composables/table-view/useTableRecordLink.ts

@@ -9,10 +9,11 @@ import {
 } from "./utils/recordLink";
 import { queryOfUrl } from "./utils/urlFilters";
 import type { TableUrlScope } from "./utils/views";
+import type { LocationQuery } from "#dms/frontend-module";
 
 /** What `useTableRecordLink` follows the URL's `?record=` with. */
 export interface TableRecordLinkOptions<T> {
-  route: { query: Record<string, unknown> };
+  route: { query: LocationQuery };
   urlScope: TableUrlScope;
   /** The table's `deepLink` action: the container a link opens. */
   action: CustomRowAction;
@@ -48,13 +49,13 @@ export function useTableRecordLink<T>(
   options: TableRecordLinkOptions<T>,
 ): TableRecordLink {
   const { action, urlScope } = options;
-  // The row opened or being opened: arrival and the visit that mounted the
-  // table name it twice, a visit while it is open names it again.
+
   let linkedId: string | undefined;
 
   const settle = async (id: string) => {
     const found = await options.resolve(id);
     const outcome = deepLinkOutcome(found, action);
+    // oxlint-disable-next-line anti-slop/require-safety-comment-for-type-assertion -- deepLinkOutcome returns a string rather than a row type predicate. DeepLinkedRow keeps row optional; the open outcome guarantees it operationally but neither inference nor its owner expresses that relation.
     if (outcome === "open") return options.open(found.row as T);
     if (outcome === "missingPanel") return options.showMissing(id);
     writeRecordId(urlScope);
@@ -62,7 +63,7 @@ export function useTableRecordLink<T>(
     options.notify(outcome);
   };
 
-  const follow = (query: Record<string, unknown>) => {
+  const follow = (query: LocationQuery) => {
     const id = readRecordId(query, urlScope);
     if (!id || id === linkedId) return;
     linkedId = id;
@@ -78,8 +79,6 @@ export function useTableRecordLink<T>(
   });
   onBeforeUnmount(() => stopFollowingVisits?.());
 
-  // A visit Inertia does not announce (a `router.replace`) still moves the
-  // route: a new value there is followed as well.
   watch(
     () => readRecordId(options.route.query, urlScope),
     () => follow(options.route.query),

package/frontend-vue/layers/dms-ui/app/build/composables/table-view/useTableReorder.ts

@@ -22,6 +22,7 @@ export interface TableReorderOptions<T> {
   isOrderedDisplay: ComputedRef<boolean>;
   /** Lists the rows again, after a move failed. */
   refresh: () => Promise<void> | void;
+  // oxlint-disable-next-line anti-slop/no-unknown-parameters -- Fetch may reject with any JavaScript value. No error schema owns this callback, and restricting it would exclude existing rejection values.
   onError: (error: unknown) => void;
 }
 
@@ -55,7 +56,10 @@ export function useTableReorder<T>(options: TableReorderOptions<T>) {
     data.value = {
       ...page,
       results: moved.map((row) => {
-        const value = values.get(String(get(row as never, rowIdKey)));
+        const value = values.get(
+          // oxlint-disable-next-line anti-slop/require-safety-comment-for-type-assertion -- T is unconstrained, while Nuxt get declares object input even though its implementation handles other values. Its owner-derived input type preserves this unchecked dynamic lookup without adding guards.
+          String(get(row as Parameters<typeof get>[0], rowIdKey)),
+        );
         return value === undefined ? row : { ...row, [reorder.field]: value };
       }),
     };