@synnaxlabs/client 0.54.2 → 0.56.0

package/src/table/table.spec.ts

@@ -11,6 +11,7 @@ import { uuid } from "@synnaxlabs/x";
 import { describe, expect, test } from "vitest";
 
 import { NotFoundError } from "@/errors";
+import { table } from "@/table";
 import { createTestClient } from "@/testutil/client";
 
 const client = createTestClient();
@@ -19,88 +20,632 @@ describe("Table", () => {
   describe("create", () => {
     test("create one", async () => {
       const ws = await client.workspaces.create({ name: "Table", layout: { one: 1 } });
-      const table = await client.tables.create(ws.key, {
+      const t = await client.tables.create(ws.key, {
         name: "Table",
-        data: { one: 1 },
       });
-      expect(table.name).toEqual("Table");
-      expect(table.key).not.toEqual(uuid.ZERO);
-      expect(table.data.one).toEqual(1);
+      expect(t.name).toEqual("Table");
+      expect(t.key).not.toEqual(uuid.ZERO);
+      const retrieved = await client.tables.retrieve({ key: t.key });
+      expect(retrieved.key).toEqual(t.key);
     });
   });
+
   describe("rename", () => {
     test("rename one", async () => {
       const ws = await client.workspaces.create({ name: "Table", layout: { one: 1 } });
-      const table = await client.tables.create(ws.key, {
+      const t = await client.tables.create(ws.key, {
         name: "Table",
-        data: { one: 1 },
       });
-      await client.tables.rename(table.key, "Table2");
-      const res = await client.tables.retrieve({ key: table.key });
+      await client.tables.rename(t.key, "Table2");
+      const res = await client.tables.retrieve({ key: t.key });
       expect(res.name).toEqual("Table2");
     });
   });
+
   describe("setData", () => {
-    test("set data", async () => {
+    test("set data replaces body fields while preserving key and name", async () => {
       const ws = await client.workspaces.create({ name: "Table", layout: { one: 1 } });
-      const table = await client.tables.create(ws.key, {
+      const t = await client.tables.create(ws.key, {
         name: "Table",
-        data: { one: 1 },
       });
-      await client.tables.setData(table.key, { two: 2 });
-      const res = await client.tables.retrieve({ key: table.key });
-      expect(res.data.two).toEqual(2);
+      await client.tables.setData(t.key, {
+        rows: [{ size: 40, cells: ["a", "b"] }],
+        columns: [{ size: 80 }, { size: 100 }],
+        cells: {
+          a: { key: "a", variant: "text", props: { value: "hello" } },
+          b: { key: "b", variant: "value", props: { units: "psi" } },
+        },
+      });
+      const res = await client.tables.retrieve({ key: t.key });
+      expect(res.name).toEqual("Table");
+      expect(res.rows).toHaveLength(1);
+      expect(res.rows[0].cells).toEqual(["a", "b"]);
+      expect(res.columns).toHaveLength(2);
+      expect(res.cells.a.variant).toEqual("text");
+      expect((res.cells.a.props as Record<string, unknown>).value).toEqual("hello");
+      expect(res.cells.b.variant).toEqual("value");
     });
   });
+
   describe("delete", () => {
     test("delete one", async () => {
       const ws = await client.workspaces.create({ name: "Table", layout: { one: 1 } });
-      const table = await client.tables.create(ws.key, {
+      const t = await client.tables.create(ws.key, {
         name: "Table",
-        data: { one: 1 },
       });
-      await client.tables.delete(table.key);
-      await expect(client.tables.retrieve({ key: table.key })).rejects.toThrow(
+      await client.tables.delete(t.key);
+      await expect(client.tables.retrieve({ key: t.key })).rejects.toThrow(
         NotFoundError,
       );
     });
   });
-  describe("case preservation", () => {
-    test("should preserve key casing in data field on create/retrieve cycle", async () => {
+
+  describe("cell props case preservation", () => {
+    test("preserves arbitrary key casing within cell props values", async () => {
       const ws = await client.workspaces.create({ name: "CaseTest", layout: {} });
-      const table = await client.tables.create(ws.key, {
+      const t = await client.tables.create(ws.key, {
         name: "CaseTest",
-        data: {
-          camelCaseKey: "value1",
-          PascalCaseKey: "value2",
-          snake_case_key: "value3",
-          nested: {
-            innerCamelCase: 123,
-            InnerPascalCase: { deepKey: true },
+        cells: {
+          a: {
+            key: "a",
+            variant: "value",
+            props: {
+              camelCaseKey: "value1",
+              PascalCaseKey: "value2",
+              snake_case_key: "value3",
+              nested: {
+                innerCamelCase: 123,
+                InnerPascalCase: { deepKey: true },
+              },
+            },
           },
         },
       });
-
-      const retrieved = await client.tables.retrieve({ key: table.key });
-
-      const data = retrieved.data as Record<string, unknown>;
-      expect(data.camelCaseKey).toEqual("value1");
-      expect(data.PascalCaseKey).toEqual("value2");
-      expect(data.snake_case_key).toEqual("value3");
-      expect((data.nested as Record<string, unknown>).innerCamelCase).toEqual(123);
+      const retrieved = await client.tables.retrieve({ key: t.key });
+      const props = retrieved.cells.a.props as Record<string, unknown>;
+      expect(props.camelCaseKey).toEqual("value1");
+      expect(props.PascalCaseKey).toEqual("value2");
+      expect(props.snake_case_key).toEqual("value3");
+      expect((props.nested as Record<string, unknown>).innerCamelCase).toEqual(123);
       expect(
         (
-          (data.nested as Record<string, unknown>).InnerPascalCase as Record<
+          (props.nested as Record<string, unknown>).InnerPascalCase as Record<
             string,
             unknown
           >
         ).deepKey,
       ).toEqual(true);
-      expect(Object.keys(data)).toContain("camelCaseKey");
-      expect(Object.keys(data)).toContain("PascalCaseKey");
-      expect(Object.keys(data)).toContain("snake_case_key");
-      expect(Object.keys(data)).not.toContain("camel_case_key");
-      expect(Object.keys(data)).not.toContain("pascal_case_key");
+      expect(Object.keys(props)).toContain("camelCaseKey");
+      expect(Object.keys(props)).toContain("PascalCaseKey");
+      expect(Object.keys(props)).toContain("snake_case_key");
+    });
+  });
+
+  describe("dispatch", () => {
+    const seed = async () => {
+      const ws = await client.workspaces.create({ name: "Dispatch", layout: {} });
+      return client.tables.create(ws.key, {
+        name: "Dispatch",
+        rows: [{ size: 30, cells: ["a", "b"] }],
+        columns: [{ size: 80 }, { size: 100 }],
+        cells: {
+          a: { key: "a", variant: "text", props: { value: "A" } },
+          b: { key: "b", variant: "text", props: { value: "B" } },
+        },
+      });
+    };
+
+    test("rename applies via dispatch", async () => {
+      const t = await seed();
+      await client.tables.dispatch(t.key, "dk-1", [table.rename({ name: "renamed" })]);
+      const res = await client.tables.retrieve({ key: t.key });
+      expect(res.name).toEqual("renamed");
+    });
+
+    test("addRow appends a row and its cells", async () => {
+      const t = await seed();
+      await client.tables.dispatch(t.key, "dk-1", [
+        table.addRow({
+          index: 1,
+          size: 40,
+          cells: [
+            { key: "c", variant: "text", props: { value: "C" } },
+            { key: "d", variant: "text", props: { value: "D" } },
+          ],
+        }),
+      ]);
+      const res = await client.tables.retrieve({ key: t.key });
+      expect(res.rows).toHaveLength(2);
+      expect(res.rows[1].cells).toEqual(["c", "d"]);
+      expect(res.cells.c.props.value).toEqual("C");
+    });
+
+    test("removeRow drops the row and its cells", async () => {
+      const t = await seed();
+      await client.tables.dispatch(t.key, "dk-1", [table.removeRow({ index: 0 })]);
+      const res = await client.tables.retrieve({ key: t.key });
+      expect(res.rows).toEqual([]);
+      expect(Object.keys(res.cells)).toEqual([]);
+    });
+
+    test("addCol inserts a column at the given index across every row", async () => {
+      const t = await seed();
+      await client.tables.dispatch(t.key, "dk-1", [
+        table.addCol({
+          index: 1,
+          size: 90,
+          cells: [{ key: "mid-1", variant: "text", props: { value: "M1" } }],
+        }),
+      ]);
+      const res = await client.tables.retrieve({ key: t.key });
+      expect(res.columns).toHaveLength(3);
+      expect(res.rows[0].cells).toEqual(["a", "mid-1", "b"]);
+    });
+
+    test("removeCol drops every cell in that column", async () => {
+      const t = await seed();
+      await client.tables.dispatch(t.key, "dk-1", [table.removeCol({ index: 0 })]);
+      const res = await client.tables.retrieve({ key: t.key });
+      expect(res.columns).toHaveLength(1);
+      expect(res.rows[0].cells).toEqual(["b"]);
+      expect(res.cells.a).toBeUndefined();
+    });
+
+    test("resize actions update size in place", async () => {
+      const t = await seed();
+      await client.tables.dispatch(t.key, "dk-1", [
+        table.resizeRow({ index: 0, size: 55 }),
+        table.resizeCol({ index: 1, size: 200 }),
+      ]);
+      const res = await client.tables.retrieve({ key: t.key });
+      expect(res.rows[0].size).toEqual(55);
+      expect(res.columns[1].size).toEqual(200);
+    });
+
+    test("setCell replaces an existing cell", async () => {
+      const t = await seed();
+      await client.tables.dispatch(t.key, "dk-1", [
+        table.setCell({
+          cell: { key: "a", variant: "value", props: { units: "psi" } },
+        }),
+      ]);
+      const res = await client.tables.retrieve({ key: t.key });
+      expect(res.cells.a.variant).toEqual("value");
+      expect(res.cells.a.props.units).toEqual("psi");
+    });
+
+    test("setCell is a no-op for an unknown key", async () => {
+      const t = await seed();
+      await client.tables.dispatch(t.key, "dk-1", [
+        table.setCell({ cell: { key: "ghost", variant: "text", props: {} } }),
+      ]);
+      const res = await client.tables.retrieve({ key: t.key });
+      expect(res.cells.ghost).toBeUndefined();
+      expect(Object.keys(res.cells).sort()).toEqual(["a", "b"]);
+    });
+
+    test("multi-action sequence applies atomically", async () => {
+      const t = await seed();
+      await client.tables.dispatch(t.key, "dk-1", [
+        table.rename({ name: "multi" }),
+        table.addRow({
+          index: 1,
+          size: 40,
+          cells: [
+            { key: "c", variant: "text", props: {} },
+            { key: "d", variant: "text", props: {} },
+          ],
+        }),
+        table.setCell({
+          cell: { key: "c", variant: "value", props: { telem: "ch1" } },
+        }),
+      ]);
+      const res = await client.tables.retrieve({ key: t.key });
+      expect(res.name).toEqual("multi");
+      expect(res.rows).toHaveLength(2);
+      expect(res.cells.c.variant).toEqual("value");
+      expect(res.cells.c.props.telem).toEqual("ch1");
+    });
+  });
+
+  describe("reduceAll", () => {
+    const KEY = "00000000-0000-0000-0000-000000000001";
+    const TEMPLATE_KEY = "11111111-2222-4333-8444-555555555555";
+    const DERIVED_KEY_0 = "11111111-2222-4333-8444-555555550000";
+    const DERIVED_KEY_1 = "11111111-2222-4333-8444-555555550001";
+    const textTemplate: table.CellTemplate = { variant: "text", props: {} };
+
+    const emptyState = (name = "t"): table.Table => ({
+      key: KEY,
+      name,
+      rows: [],
+      columns: [],
+      cells: {},
+    });
+
+    const seed2x2 = (): table.Table => ({
+      key: KEY,
+      name: "before",
+      rows: [
+        { size: 36, cells: ["a", "b"] },
+        { size: 36, cells: ["c", "d"] },
+      ],
+      columns: [{ size: 80 }, { size: 100 }],
+      cells: {
+        a: { key: "a", variant: "text", props: { value: "A" } },
+        b: { key: "b", variant: "text", props: { value: "B" } },
+        c: { key: "c", variant: "text", props: { value: "C" } },
+        d: { key: "d", variant: "text", props: { value: "D" } },
+      },
+    });
+
+    const seed3x3 = (): table.Table => {
+      const keys = ["a", "b", "c", "d", "e", "f", "g", "h", "i"];
+      return {
+        key: KEY,
+        name: "t",
+        rows: [
+          { size: 36, cells: ["a", "b", "c"] },
+          { size: 36, cells: ["d", "e", "f"] },
+          { size: 36, cells: ["g", "h", "i"] },
+        ],
+        columns: [{ size: 80 }, { size: 80 }, { size: 80 }],
+        cells: Object.fromEntries(
+          keys.map((k) => [k, { key: k, variant: "value", props: { units: "psi" } }]),
+        ),
+      };
+    };
+
+    describe("inverses", () => {
+      test("rename produces a rename inverse with the old name", () => {
+        const { next, inverse } = table.reduceAll(emptyState("before"), [
+          table.rename({ name: "after" }),
+        ]);
+        expect(next.name).toEqual("after");
+        expect(inverse).toHaveLength(1);
+        expect(inverse[0].type).toEqual("rename");
+        expect(inverse[0].type === "rename" ? inverse[0].rename.name : null).toEqual(
+          "before",
+        );
+      });
+
+      test("addRow inverse is a removeRow at the inserted index", () => {
+        const { inverse } = table.reduceAll(emptyState(), [
+          table.addRow({
+            index: 0,
+            size: 30,
+            cells: [{ key: "x", variant: "text", props: {} }],
+          }),
+        ]);
+        expect(inverse).toHaveLength(1);
+        expect(inverse[0].type).toEqual("remove_row");
+      });
+
+      test("setCell inverse restores the previous cell value", () => {
+        const { next, inverse } = table.reduceAll(
+          {
+            ...emptyState(),
+            rows: [{ size: 30, cells: ["a"] }],
+            columns: [{ size: 80 }],
+            cells: { a: { key: "a", variant: "text", props: { v: 1 } } },
+          },
+          [table.setCell({ cell: { key: "a", variant: "value", props: { v: 2 } } })],
+        );
+        expect(next.cells.a.variant).toEqual("value");
+        expect(inverse).toHaveLength(1);
+        expect(inverse[0].type).toEqual("set_cell");
+        if (inverse[0].type === "set_cell") {
+          expect(inverse[0].setCell.cell.variant).toEqual("text");
+          expect(inverse[0].setCell.cell.props).toEqual({ v: 1 });
+        }
+      });
+
+      test("setCell on an unknown key returns no inverse", () => {
+        const { inverse } = table.reduceAll(emptyState(), [
+          table.setCell({ cell: { key: "ghost", variant: "text", props: {} } }),
+        ]);
+        expect(inverse).toEqual([]);
+      });
+    });
+
+    describe("bootstrap", () => {
+      test("addRow on an empty table bootstraps one default column per cell", () => {
+        const { next } = table.reduceAll(emptyState(), [
+          table.addRow({
+            index: 0,
+            size: 36,
+            cells: [
+              { key: "a", variant: "text", props: {} },
+              { key: "b", variant: "text", props: {} },
+            ],
+          }),
+        ]);
+        expect(next.rows).toHaveLength(1);
+        expect(next.columns).toHaveLength(2);
+        expect(next.columns[0].size).toEqual(72);
+        expect(next.rows[0].cells).toEqual(["a", "b"]);
+      });
+
+      test("addCol on an empty table bootstraps one default row per cell", () => {
+        const { next } = table.reduceAll(emptyState(), [
+          table.addCol({
+            index: 0,
+            size: 72,
+            cells: [
+              { key: "a", variant: "text", props: {} },
+              { key: "b", variant: "text", props: {} },
+            ],
+          }),
+        ]);
+        expect(next.columns).toHaveLength(1);
+        expect(next.rows).toHaveLength(2);
+        expect(next.rows[0].size).toEqual(36);
+        expect(next.rows[0].cells).toEqual(["a"]);
+        expect(next.rows[1].cells).toEqual(["b"]);
+      });
+    });
+
+    describe("cellTemplate", () => {
+      const template = { key: TEMPLATE_KEY, variant: "text", props: { value: "t" } };
+
+      test("addRow replicates the template across existing columns", () => {
+        const { next } = table.reduceAll(
+          {
+            ...emptyState(),
+            rows: [{ size: 36, cells: ["a", "b"] }],
+            columns: [{ size: 80 }, { size: 80 }],
+            cells: {
+              a: { key: "a", variant: "text", props: {} },
+              b: { key: "b", variant: "text", props: {} },
+            },
+          },
+          [table.addRow({ index: 1, size: 36, cells: [], cellTemplate: template })],
+        );
+        expect(next.rows[1].cells).toEqual([DERIVED_KEY_0, DERIVED_KEY_1]);
+        expect(next.cells[DERIVED_KEY_0].variant).toEqual("text");
+        expect(next.cells[DERIVED_KEY_0].props).toEqual({ value: "t" });
+      });
+
+      test("addCol replicates the template across existing rows", () => {
+        const { next } = table.reduceAll(
+          {
+            ...emptyState(),
+            rows: [
+              { size: 36, cells: ["a"] },
+              { size: 36, cells: ["b"] },
+            ],
+            columns: [{ size: 80 }],
+            cells: {
+              a: { key: "a", variant: "text", props: {} },
+              b: { key: "b", variant: "text", props: {} },
+            },
+          },
+          [table.addCol({ index: 1, size: 80, cells: [], cellTemplate: template })],
+        );
+        expect(next.rows[0].cells).toEqual(["a", DERIVED_KEY_0]);
+        expect(next.rows[1].cells).toEqual(["b", DERIVED_KEY_1]);
+      });
+
+      test("addCol with template adds an empty column when rows are empty", () => {
+        const { next } = table.reduceAll(
+          { ...emptyState(), columns: [{ size: 80 }, { size: 80 }] },
+          [table.addCol({ index: 2, size: 72, cells: [], cellTemplate: template })],
+        );
+        expect(next.rows).toHaveLength(0);
+        expect(next.columns).toHaveLength(3);
+        expect(next.cells).toEqual({});
+      });
+
+      test("addRow with template adds an empty row when columns are empty", () => {
+        const { next } = table.reduceAll(
+          { ...emptyState(), rows: [{ size: 36, cells: [] }] },
+          [table.addRow({ index: 1, size: 36, cells: [], cellTemplate: template })],
+        );
+        expect(next.rows).toHaveLength(2);
+        expect(next.rows[1].cells).toEqual([]);
+        expect(next.cells).toEqual({});
+      });
+
+      test("addRow with template on an empty table seeds a 1x1 grid", () => {
+        const { next } = table.reduceAll(emptyState(), [
+          table.addRow({ index: 0, size: 36, cells: [], cellTemplate: template }),
+        ]);
+        expect(next.columns).toHaveLength(1);
+        expect(next.rows[0].cells).toEqual([DERIVED_KEY_0]);
+      });
+    });
+
+    describe("size clamping", () => {
+      const MIN = 32;
+      const baseWithOneCol = {
+        ...emptyState(),
+        columns: [{ size: 80 }],
+      };
+      const baseWithOneCell: table.Table = {
+        ...emptyState(),
+        rows: [{ size: 60, cells: ["a"] }],
+        columns: [{ size: 80 }],
+        cells: { a: { key: "a", variant: "text", props: {} } },
+      };
+      test.for<{
+        name: string;
+        state: table.Table;
+        action: table.Action;
+        get: (t: table.Table) => number;
+      }>([
+        {
+          name: "addRow size below minimum",
+          state: baseWithOneCol,
+          action: table.addRow({
+            index: 0,
+            size: 5,
+            cells: [{ key: "a", variant: "text", props: {} }],
+          }),
+          get: (t) => t.rows[0].size,
+        },
+        {
+          name: "addCol size below minimum",
+          state: baseWithOneCell,
+          action: table.addCol({
+            index: 1,
+            size: 10,
+            cells: [{ key: "b", variant: "text", props: {} }],
+          }),
+          get: (t) => t.columns[1].size,
+        },
+        {
+          name: "resizeRow size below minimum",
+          state: baseWithOneCell,
+          action: table.resizeRow({ index: 0, size: 5 }),
+          get: (t) => t.rows[0].size,
+        },
+        {
+          name: "resizeCol size below minimum",
+          state: baseWithOneCell,
+          action: table.resizeCol({ index: 0, size: 0 }),
+          get: (t) => t.columns[0].size,
+        },
+      ])("clamps $name to the floor", ({ state, action, get }) => {
+        const { next } = table.reduceAll(state, [action]);
+        expect(get(next)).toEqual(MIN);
+      });
+    });
+
+    describe("eraseCells", () => {
+      test.for<{
+        name: string;
+        cells: string[];
+        rows: number;
+        columns: number;
+        row0?: string[];
+      }>([
+        {
+          name: "partial selection leaves axes intact",
+          cells: ["b", "e"],
+          rows: 3,
+          columns: 3,
+          row0: ["a", "b", "c"],
+        },
+        {
+          name: "fully-selected row is removed",
+          cells: ["d", "e", "f"],
+          rows: 2,
+          columns: 3,
+          row0: ["a", "b", "c"],
+        },
+        {
+          name: "fully-selected column is removed",
+          cells: ["b", "e", "h"],
+          rows: 3,
+          columns: 2,
+          row0: ["a", "c"],
+        },
+        {
+          name: "full row + full column in one call",
+          cells: ["a", "b", "c", "f", "i"],
+          rows: 2,
+          columns: 2,
+          row0: ["d", "e"],
+        },
+      ])("$name", ({ cells, rows, columns, row0 }) => {
+        const { next } = table.reduceAll(seed3x3(), [
+          table.eraseCells({ cells, template: textTemplate }),
+        ]);
+        expect(next.rows).toHaveLength(rows);
+        expect(next.columns).toHaveLength(columns);
+        if (row0 != null) expect(next.rows[0].cells).toEqual(row0);
+      });
+
+      test("resets surviving cells to the template variant", () => {
+        const { next } = table.reduceAll(seed3x3(), [
+          table.eraseCells({ cells: ["b", "e"], template: textTemplate }),
+        ]);
+        expect(next.cells.b.variant).toEqual("text");
+        expect(next.cells.e.variant).toEqual("text");
+        expect(next.cells.a.variant).toEqual("value");
+      });
+
+      test("drops cells from the map when their row is fully removed", () => {
+        const { next } = table.reduceAll(seed3x3(), [
+          table.eraseCells({ cells: ["d", "e", "f"], template: textTemplate }),
+        ]);
+        for (const k of ["d", "e", "f"]) expect(next.cells[k]).toBeUndefined();
+      });
+
+      test("inverse restores the prior state on undo", () => {
+        const seed = seed3x3();
+        const { next, inverse } = table.reduceAll(seed, [
+          table.eraseCells({
+            cells: ["a", "b", "c", "e"],
+            template: textTemplate,
+          }),
+        ]);
+        expect(next.rows).toHaveLength(2);
+        const { next: restored } = table.reduceAll(next, inverse);
+        expect(restored).toEqual(seed);
+      });
+
+      test("empty selection returns no inverse", () => {
+        const { inverse } = table.reduceAll(seed3x3(), [
+          table.eraseCells({ cells: [], template: textTemplate }),
+        ]);
+        expect(inverse).toEqual([]);
+      });
+
+      test("inverse round-trips when payload.cells contains duplicates", () => {
+        const seed = seed3x3();
+        const { next, inverse } = table.reduceAll(seed, [
+          table.eraseCells({ cells: ["b", "b", "b"], template: textTemplate }),
+        ]);
+        expect(next.cells.b.variant).toEqual("text");
+        const { next: restored } = table.reduceAll(next, inverse);
+        expect(restored).toEqual(seed);
+      });
+    });
+
+    describe("round-trip", () => {
+      const roundTrip = (forward: table.Action) => {
+        const original = seed2x2();
+        const { next, inverse } = table.reduceAll(original, [forward]);
+        const { next: restored } = table.reduceAll(next, inverse);
+        expect(restored).toEqual(original);
+      };
+
+      test.for<{ name: string; action: table.Action }>([
+        { name: "rename", action: table.rename({ name: "after" }) },
+        {
+          name: "addRow",
+          action: table.addRow({
+            index: 1,
+            size: 40,
+            cells: [
+              { key: "e", variant: "text", props: { value: "E" } },
+              { key: "f", variant: "text", props: { value: "F" } },
+            ],
+          }),
+        },
+        { name: "removeRow", action: table.removeRow({ index: 0 }) },
+        {
+          name: "addCol",
+          action: table.addCol({
+            index: 1,
+            size: 60,
+            cells: [
+              { key: "m1", variant: "text", props: { value: "M1" } },
+              { key: "m2", variant: "value", props: { units: "psi" } },
+            ],
+          }),
+        },
+        { name: "removeCol", action: table.removeCol({ index: 0 }) },
+        { name: "resizeRow", action: table.resizeRow({ index: 0, size: 55 }) },
+        { name: "resizeCol", action: table.resizeCol({ index: 1, size: 200 }) },
+        {
+          name: "setCell",
+          action: table.setCell({
+            cell: { key: "a", variant: "value", props: { units: "psi" } },
+          }),
+        },
+      ])("$name round-trips", ({ action }) => roundTrip(action));
     });
   });
 });