@marimo-team/islands 0.24.1-dev79 → 0.24.1-dev80

package/dist/{process-output-BCqcNNll.js → process-output-C2joqP7d.js}

@@ -1,4 +1,4 @@
-import { O as e, et as t, tt as n } from "./html-to-image-B7RQgQQy.js";
+import { O as e, et as t, tt as n } from "./html-to-image-CvCnIqTI.js";
 import { u as r } from "./dist-wdOJ5T7-.js";
 import { b as i } from "./select-DQ9jU_B_.js";
 import { n as a } from "./semaphore-89jsoHtS.js";

package/dist/{reveal-component-BDQwrD89.js → reveal-component-CdEcs6WV.js}

@@ -2,11 +2,11 @@ import { a as e } from "./rolldown-runtime-Cb76FRpK.js";
 import { c as t, g as n, h as r, m as i, t as a } from "./button-DlqUC8W-.js";
 import { t as o } from "./react-DMWcHin-.js";
 import { t as s } from "./compiler-runtime-CAH9RLw2.js";
-import { it as c, wt as l } from "./html-to-image-B7RQgQQy.js";
+import { it as c, wt as l } from "./html-to-image-CvCnIqTI.js";
 import { u } from "./dist-wdOJ5T7-.js";
-import { J as d, X as f, Y as p, in as m, l as h, n as g, rn as _, sn as v, t as y, u as b } from "./common-DuuFqqGa.js";
+import { J as d, X as f, Y as p, in as m, l as h, n as g, rn as _, sn as v, t as y, u as b } from "./common-C8LWIius.js";
 import { R as x } from "./select-DQ9jU_B_.js";
-import { X as S } from "./dropdown-menu-C8N-kZzD.js";
+import { Y as S } from "./dropdown-menu-B39I9ARA.js";
 import { t as C } from "./jsx-runtime-CpoKNRgu.js";
 import { Tc as w } from "./schemas-JTyiKlcH.js";
 import { t as T } from "./tooltip-7p_32zdw.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@marimo-team/islands",
-  "version": "0.24.1-dev79",
+  "version": "0.24.1-dev80",
   "main": "dist/main.js",
   "types": "dist/index.d.ts",
   "type": "module",

package/src/plugins/impl/DataEditorPlugin.tsx

@@ -1,27 +1,28 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
 import glideCss from "@glideapps/glide-data-grid/dist/index.css?inline";
-import React, { useState } from "react";
+import React, { useEffect, useState } from "react";
 import { z } from "zod";
 import { inferFieldTypes } from "@/components/data-table/columns";
 import { LoadingTable } from "@/components/data-table/loading-table";
-import { type FieldTypes, toFieldTypes } from "@/components/data-table/types";
+import {
+  type FieldTypesWithExternalType,
+  toFieldTypes,
+} from "@/components/data-table/types";
 import { Alert, AlertTitle } from "@/components/ui/alert";
 import { DelayMount } from "@/components/utils/delay-mount";
 import { useAsyncData } from "@/hooks/useAsyncData";
 import { createPlugin } from "../core/builder";
 import type { Setter } from "../types";
 import { columnToFieldTypesSchema } from "./data-frames/schema";
-import {
-  BulkEdit,
-  type DataEditorProps,
-  type Edits,
-} from "./data-editor/types";
+import { orderColumnFields } from "./data-editor/data-utils";
+import { applyEditorEdits } from "./data-editor/editor-state";
+import type { EditorRow, EditorState, Edits } from "./data-editor/types";
 import { vegaLoadData } from "./vega/loader";
 import { getVegaFieldTypes } from "./vega/utils";
 
 type CsvURL = string;
-type TableData<T> = T[] | CsvURL;
+type TableData = EditorRow[] | CsvURL;
 
 // Lazy load the data editor since it brings in glide-data-grid
 const LazyDataEditor = React.lazy(
@@ -45,6 +46,7 @@ export const DataEditorPlugin = createPlugin<Edits>("marimo-data-editor", {
       label: z.string().nullable(),
       data: z.union([z.string(), z.array(z.object({}).passthrough())]),
       fieldTypes: columnToFieldTypesSchema.nullish(),
+      columnNames: z.array(z.string()).default([]),
       editableColumns: z.union([z.array(z.string()), z.literal("all")]),
       columnSizingMode: z.enum(["auto", "fit"]).default("auto"), // TODO: Remove this
     }),
@@ -55,31 +57,28 @@ export const DataEditorPlugin = createPlugin<Edits>("marimo-data-editor", {
       <LoadingDataEditor
         data={props.data.data}
         fieldTypes={props.data.fieldTypes}
+        columnNames={props.data.columnNames}
         edits={props.value}
         onEdits={props.setValue}
-        host={props.host}
         editableColumns={props.data.editableColumns}
       />
     );
   });
 
-interface Props extends Omit<
-  DataEditorProps<object>,
-  "data" | "onAddEdits" | "onAddRows"
-> {
-  data: TableData<object>;
+interface Props {
+  data: TableData;
+  fieldTypes: FieldTypesWithExternalType | null | undefined;
   edits: Edits;
   onEdits: Setter<Edits>;
-  host: HTMLElement;
   editableColumns: string[] | "all";
+  columnNames: string[];
 }
 
 const LoadingDataEditor = (props: Props) => {
-  const [data, setData] = useState<unknown[]>([]);
-  const [columnFields, setColumnFields] = useState<FieldTypes>(new Map());
+  const [editorState, setEditorState] = useState<EditorState | null>(null);
 
   // Load the data
-  const { error } = useAsyncData(async () => {
+  const { data: loadedState, error } = useAsyncData(async () => {
     const withoutExternalTypes = toFieldTypes(props.fieldTypes ?? []);
 
     // If we already have the data, return it
@@ -87,7 +86,7 @@ const LoadingDataEditor = (props: Props) => {
     // plain `Record`; column order doesn't matter for parsing.
     const localData = Array.isArray(props.data)
       ? props.data
-      : await vegaLoadData(
+      : await vegaLoadData<EditorRow>(
           props.data,
           {
             type: "csv",
@@ -96,11 +95,20 @@ const LoadingDataEditor = (props: Props) => {
           { handleBigIntAndNumberLike: true },
         );
 
-    setData(localData);
-    setColumnFields(
-      toFieldTypes(props.fieldTypes ?? inferFieldTypes(localData)),
-    );
-  }, [props.fieldTypes, props.data]);
+    return {
+      data: localData,
+      columnFields: orderColumnFields(
+        toFieldTypes(props.fieldTypes ?? inferFieldTypes(localData)),
+        props.columnNames,
+      ),
+    } satisfies EditorState;
+  }, [props.fieldTypes, props.columnNames, props.data]);
+
+  useEffect(() => {
+    if (loadedState !== undefined) {
+      setEditorState(applyEditorEdits(loadedState, props.edits.edits));
+    }
+  }, [loadedState, props.edits.edits]);
 
   if (error) {
     return (
@@ -113,7 +121,7 @@ const LoadingDataEditor = (props: Props) => {
     );
   }
 
-  if (!data) {
+  if (editorState === null) {
     return (
       <DelayMount milliseconds={200}>
         <LoadingTable pageSize={10} />
@@ -123,54 +131,14 @@ const LoadingDataEditor = (props: Props) => {
 
   return (
     <LazyDataEditor
-      data={data}
-      setData={setData}
-      columnFields={columnFields}
-      setColumnFields={setColumnFields}
+      data={editorState.data}
+      columnFields={editorState.columnFields}
       editableColumns={props.editableColumns}
-      edits={props.edits.edits}
       onAddEdits={(edits) => {
-        props.onEdits((v) => ({ ...v, edits: [...v.edits, ...edits] }));
-      }}
-      onAddRows={(rows) => {
-        const newEdits = rows.flatMap((row, rowIndex) =>
-          Object.entries(row).map(([columnId, value]) => ({
-            rowIdx: data.length + rowIndex,
-            columnId,
-            value,
-          })),
+        setEditorState((state) =>
+          state === null ? null : applyEditorEdits(state, edits),
         );
-        props.onEdits((v) => ({ ...v, edits: [...v.edits, ...newEdits] }));
-      }}
-      onDeleteRows={(rowIndexes) => {
-        props.onEdits((v) => {
-          const newEdits = rowIndexes.map((rowIdx, index) => ({
-            rowIdx: rowIdx - index,
-            type: BulkEdit.Remove,
-          }));
-          return {
-            ...v,
-            edits: [...v.edits, ...newEdits],
-          };
-        });
-      }}
-      onRenameColumn={(columnIdx: number, newName: string) => {
-        props.onEdits((v) => ({
-          ...v,
-          edits: [...v.edits, { columnIdx, newName, type: BulkEdit.Rename }],
-        }));
-      }}
-      onDeleteColumn={(columnIdx: number) => {
-        props.onEdits((v) => ({
-          ...v,
-          edits: [...v.edits, { columnIdx, type: BulkEdit.Remove }],
-        }));
-      }}
-      onAddColumn={(columnIdx: number, newName: string) => {
-        props.onEdits((v) => ({
-          ...v,
-          edits: [...v.edits, { columnIdx, newName, type: BulkEdit.Insert }],
-        }));
+        props.onEdits((v) => ({ ...v, edits: [...v.edits, ...edits] }));
       }}
     />
   );

package/src/plugins/impl/__tests__/DataEditorPlugin.test.ts

@@ -1,9 +1,55 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
-import { describe, expect, it } from "vitest";
+import React, { Suspense } from "react";
+import { act, render, screen, waitFor } from "@testing-library/react";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { z } from "zod";
+import type { IPluginProps } from "../../types";
+import type { EditorRow, Edits } from "../data-editor/types";
 import { DataEditorPlugin } from "../DataEditorPlugin";
 
+type PluginData = z.infer<typeof DataEditorPlugin.validator>;
+
+const mocks = vi.hoisted(() => ({
+  loadData: vi.fn(),
+}));
+
+vi.mock("../vega/loader", () => ({
+  vegaLoadData: mocks.loadData,
+}));
+
+vi.mock("../data-editor/glide-data-editor", async () => {
+  const React = await import("react");
+  return {
+    default: (props: { data: EditorRow[] }) =>
+      React.createElement(
+        "pre",
+        { "data-testid": "editor-data" },
+        JSON.stringify(props.data),
+      ),
+  };
+});
+
+function renderPlugin(data: PluginData, value: Edits) {
+  const props: IPluginProps<Edits, PluginData> = {
+    host: document.createElement("div"),
+    data,
+    value,
+    setValue: vi.fn(),
+    functions: {},
+  };
+  return React.createElement(
+    Suspense,
+    { fallback: null },
+    DataEditorPlugin.render(props),
+  );
+}
+
 describe("DataEditorPlugin", () => {
+  beforeEach(() => {
+    mocks.loadData.mockReset();
+  });
+
   it("normalizes an unrecognized field type", () => {
     const result = DataEditorPlugin.validator.parse({
       initialValue: { edits: [] },
@@ -27,4 +73,109 @@ describe("DataEditorPlugin", () => {
 
     expect(result.fieldTypes).toEqual([["geom", ["geometry", "geometry"]]]);
   });
+
+  it("applies the latest edits when an async data load completes", async () => {
+    let resolveLoad: ((data: EditorRow[]) => void) | undefined;
+    mocks.loadData.mockImplementationOnce(
+      () =>
+        new Promise<EditorRow[]>((resolve) => {
+          resolveLoad = resolve;
+        }),
+    );
+
+    const data = DataEditorPlugin.validator.parse({
+      initialValue: { edits: [] },
+      label: null,
+      data: "data.csv",
+      fieldTypes: null,
+      columnNames: ["name"],
+      editableColumns: "all",
+    });
+    const result = render(renderPlugin(data, { edits: [] }));
+    result.rerender(
+      renderPlugin(data, {
+        edits: [{ rowIdx: 0, columnId: "name", value: "latest" }],
+      }),
+    );
+    expect(resolveLoad).toBeDefined();
+    resolveLoad?.([{ name: "original" }]);
+
+    await waitFor(() => {
+      expect(screen.getByTestId("editor-data")).toHaveTextContent(
+        JSON.stringify([{ name: "latest" }]),
+      );
+    });
+  });
+
+  it("applies edit updates after data has loaded", async () => {
+    const data = DataEditorPlugin.validator.parse({
+      initialValue: { edits: [] },
+      label: null,
+      data: [{ name: "original" }],
+      fieldTypes: null,
+      columnNames: ["name"],
+      editableColumns: "all",
+    });
+    const result = render(renderPlugin(data, { edits: [] }));
+    await waitFor(() => {
+      expect(screen.getByTestId("editor-data")).toHaveTextContent(
+        JSON.stringify([{ name: "original" }]),
+      );
+    });
+
+    result.rerender(
+      renderPlugin(data, {
+        edits: [{ rowIdx: 0, columnId: "name", value: "updated" }],
+      }),
+    );
+
+    await waitFor(() => {
+      expect(screen.getByTestId("editor-data")).toHaveTextContent(
+        JSON.stringify([{ name: "updated" }]),
+      );
+    });
+  });
+
+  it("ignores a superseded async data load", async () => {
+    let resolveFirst: ((data: EditorRow[]) => void) | undefined;
+    let resolveSecond: ((data: EditorRow[]) => void) | undefined;
+    mocks.loadData.mockImplementation((source: string) => {
+      return new Promise<EditorRow[]>((resolve) => {
+        if (source === "first.csv") {
+          resolveFirst = resolve;
+        } else {
+          resolveSecond = resolve;
+        }
+      });
+    });
+
+    const makeData = (source: string) =>
+      DataEditorPlugin.validator.parse({
+        initialValue: { edits: [] },
+        label: null,
+        data: source,
+        fieldTypes: null,
+        columnNames: ["source"],
+        editableColumns: "all",
+      });
+    const result = render(renderPlugin(makeData("first.csv"), { edits: [] }));
+    result.rerender(renderPlugin(makeData("second.csv"), { edits: [] }));
+
+    expect(resolveFirst).toBeDefined();
+    expect(resolveSecond).toBeDefined();
+    resolveSecond?.([{ source: "second" }]);
+    await waitFor(() => {
+      expect(screen.getByTestId("editor-data")).toHaveTextContent(
+        JSON.stringify([{ source: "second" }]),
+      );
+    });
+
+    await act(async () => {
+      resolveFirst?.([{ source: "first" }]);
+      await Promise.resolve();
+    });
+    expect(screen.getByTestId("editor-data")).toHaveTextContent(
+      JSON.stringify([{ source: "second" }]),
+    );
+  });
 });

package/src/plugins/impl/data-editor/__tests__/data-utils.test.ts

@@ -6,6 +6,7 @@ import type { DataType } from "@/core/kernel/messages";
 import {
   insertColumn,
   modifyColumnFields,
+  orderColumnFields,
   removeColumn,
   renameColumn,
 } from "../data-utils";
@@ -15,16 +16,43 @@ import {
 const asFieldTypes = (obj: Record<string, DataType>): FieldTypes =>
   new Map(Object.entries(obj));
 
-describe("removeColumn", () => {
-  const testData = [
-    { int: 1, string: "a", bool: "True", datetime: "2025-07-12 00:07:13" },
-    { int: 2, string: "b", bool: "False", datetime: null },
-    { int: 3, string: "c", bool: null, datetime: "2025-07-12 00:07:13" },
-    { int: 0, string: "", bool: "", datetime: "" },
-  ];
+const testData = [
+  { int: 1, string: "a", bool: "True", datetime: "2025-07-12 00:07:13" },
+  { int: 2, string: "b", bool: "False", datetime: null },
+  { int: 3, string: "c", bool: null, datetime: "2025-07-12 00:07:13" },
+  { int: 0, string: "", bool: "", datetime: "" },
+];
+
+const mixedData = [{ a: 1, b: 2 }, { a: 3, b: 4, c: 5 }, { a: 6 }];
+
+const dataWithNulls = [
+  { a: 1, b: null, c: undefined },
+  { a: null, b: 2, c: 3 },
+];
+
+describe("orderColumnFields", () => {
+  it("uses explicit order for numeric-looking column names", () => {
+    const inferred = new Map([
+      ["2", "string"],
+      ["10", "string"],
+    ]) as FieldTypes;
+
+    expect([...orderColumnFields(inferred, ["10", "2"])]).toEqual([
+      ["10", "string"],
+      ["2", "string"],
+    ]);
+  });
 
-  it("should remove column at index 0", () => {
-    const result = removeColumn(testData, 0);
+  it("creates unknown fields for an empty table", () => {
+    expect([...orderColumnFields(new Map(), ["value"])]).toEqual([
+      ["value", "unknown"],
+    ]);
+  });
+});
+
+describe("removeColumn", () => {
+  it("should remove the first column", () => {
+    const result = removeColumn(testData, "int");
 
     expect(result).toEqual([
       { string: "a", bool: "True", datetime: "2025-07-12 00:07:13" },
@@ -34,8 +62,8 @@ describe("removeColumn", () => {
     ]);
   });
 
-  it("should remove column at index 1", () => {
-    const result = removeColumn(testData, 1);
+  it("should remove the second column", () => {
+    const result = removeColumn(testData, "string");
 
     expect(result).toEqual([
       { int: 1, bool: "True", datetime: "2025-07-12 00:07:13" },
@@ -45,8 +73,8 @@ describe("removeColumn", () => {
     ]);
   });
 
-  it("should remove column at index 2", () => {
-    const result = removeColumn(testData, 2);
+  it("should remove the third column", () => {
+    const result = removeColumn(testData, "bool");
 
     expect(result).toEqual([
       { int: 1, string: "a", datetime: "2025-07-12 00:07:13" },
@@ -56,8 +84,8 @@ describe("removeColumn", () => {
     ]);
   });
 
-  it("should remove column at index 3", () => {
-    const result = removeColumn(testData, 3);
+  it("should remove the last column", () => {
+    const result = removeColumn(testData, "datetime");
 
     expect(result).toEqual([
       { int: 1, string: "a", bool: "True" },
@@ -67,40 +95,26 @@ describe("removeColumn", () => {
     ]);
   });
 
-  it("should handle removing non-existent column index", () => {
-    const result = removeColumn(testData, 999);
-    // Should return the original data since the index doesn't exist
-    expect(result).toEqual(testData);
-  });
-
-  it("should handle negative index", () => {
-    const result = removeColumn(testData, -1);
-    // Should return the original data since negative index is invalid
+  it("should handle removing a non-existent column", () => {
+    const result = removeColumn(testData, "missing");
     expect(result).toEqual(testData);
   });
 
   it("should preserve original data structure", () => {
     const originalData = [...testData];
-    removeColumn(testData, 1);
+    removeColumn(testData, "string");
     // Original data should remain unchanged
     expect(testData).toEqual(originalData);
   });
 
   it("should handle objects with different property counts", () => {
-    const mixedData = [{ a: 1, b: 2 }, { a: 3, b: 4, c: 5 }, { a: 6 }];
-
-    const result = removeColumn(mixedData, 1);
+    const result = removeColumn(mixedData, "b");
 
     expect(result).toEqual([{ a: 1 }, { a: 3, c: 5 }, { a: 6 }]);
   });
 
   it("should handle null and undefined values in data", () => {
-    const dataWithNulls = [
-      { a: 1, b: null, c: undefined },
-      { a: null, b: 2, c: 3 },
-    ];
-
-    const result = removeColumn(dataWithNulls, 1);
+    const result = removeColumn(dataWithNulls, "b");
 
     expect(result).toEqual([
       { a: 1, c: undefined },
@@ -110,15 +124,8 @@ describe("removeColumn", () => {
 });
 
 describe("insertColumn", () => {
-  const testData = [
-    { int: 1, string: "a", bool: "True", datetime: "2025-07-12 00:07:13" },
-    { int: 2, string: "b", bool: "False", datetime: null },
-    { int: 3, string: "c", bool: null, datetime: "2025-07-12 00:07:13" },
-    { int: 0, string: "", bool: "", datetime: "" },
-  ];
-
   it("should insert column at index 0", () => {
-    const result = insertColumn(testData, "newColumn");
+    const result = insertColumn(testData, "newColumn", 0);
 
     const expected = [
       {
@@ -139,10 +146,17 @@ describe("insertColumn", () => {
       { newColumn: "", int: 0, string: "", bool: "", datetime: "" },
     ];
     expect(result).toEqual(expected);
+    expect(Object.keys(result[0])).toEqual([
+      "newColumn",
+      "int",
+      "string",
+      "bool",
+      "datetime",
+    ]);
   });
 
   it("should insert column at index 1", () => {
-    const result = insertColumn(testData, "newColumn");
+    const result = insertColumn(testData, "newColumn", 1);
 
     expect(result).toEqual([
       {
@@ -162,10 +176,17 @@ describe("insertColumn", () => {
       },
       { int: 0, newColumn: "", string: "", bool: "", datetime: "" },
     ]);
+    expect(Object.keys(result[0])).toEqual([
+      "int",
+      "newColumn",
+      "string",
+      "bool",
+      "datetime",
+    ]);
   });
 
   it("should insert column at index 2", () => {
-    const result = insertColumn(testData, "newColumn");
+    const result = insertColumn(testData, "newColumn", 2);
 
     expect(result).toEqual([
       {
@@ -188,7 +209,7 @@ describe("insertColumn", () => {
   });
 
   it("should insert column at index 3", () => {
-    const result = insertColumn(testData, "newColumn");
+    const result = insertColumn(testData, "newColumn", 3);
 
     expect(result).toEqual([
       {
@@ -211,7 +232,7 @@ describe("insertColumn", () => {
   });
 
   it("should insert column at the end when index equals length", () => {
-    const result = insertColumn(testData, "newColumn");
+    const result = insertColumn(testData, "newColumn", 4);
 
     expect(result).toEqual([
       {
@@ -234,7 +255,7 @@ describe("insertColumn", () => {
   });
 
   it("should handle inserting at index beyond array length", () => {
-    const result = insertColumn(testData, "newColumn");
+    const result = insertColumn(testData, "newColumn", 999);
     // Should add the column at the end
     expect(result).toEqual([
       {
@@ -270,14 +291,12 @@ describe("insertColumn", () => {
 
   it("should handle array with single object", () => {
     const singleRowData = [{ a: 1, b: 2, c: 3 }];
-    const result = insertColumn(singleRowData, "newColumn");
+    const result = insertColumn(singleRowData, "newColumn", 1);
     expect(result).toEqual([{ a: 1, newColumn: "", b: 2, c: 3 }]);
   });
 
   it("should handle objects with different property counts", () => {
-    const mixedData = [{ a: 1, b: 2 }, { a: 3, b: 4, c: 5 }, { a: 6 }];
-
-    const result = insertColumn(mixedData, "newColumn");
+    const result = insertColumn(mixedData, "newColumn", 1);
 
     expect(result).toEqual([
       { a: 1, newColumn: "", b: 2 },
@@ -287,12 +306,7 @@ describe("insertColumn", () => {
   });
 
   it("should handle null and undefined values in data", () => {
-    const dataWithNulls = [
-      { a: 1, b: null, c: undefined },
-      { a: null, b: 2, c: 3 },
-    ];
-
-    const result = insertColumn(dataWithNulls, "newColumn");
+    const result = insertColumn(dataWithNulls, "newColumn", 1);
 
     expect(result).toEqual([
       { a: 1, newColumn: "", b: null, c: undefined },
@@ -301,7 +315,7 @@ describe("insertColumn", () => {
   });
 
   it("should handle special characters in column name", () => {
-    const result = insertColumn(testData, "new-column_with_123");
+    const result = insertColumn(testData, "new-column_with_123", 1);
 
     expect(result).toEqual([
       {
@@ -331,13 +345,6 @@ describe("insertColumn", () => {
 });
 
 describe("renameColumn", () => {
-  const testData = [
-    { int: 1, string: "a", bool: "True", datetime: "2025-07-12 00:07:13" },
-    { int: 2, string: "b", bool: "False", datetime: null },
-    { int: 3, string: "c", bool: null, datetime: "2025-07-12 00:07:13" },
-    { int: 0, string: "", bool: "", datetime: "" },
-  ];
-
   it("should rename a column successfully", () => {
     const result = renameColumn(testData, "int", "number");
 
@@ -373,12 +380,7 @@ describe("renameColumn", () => {
   it("should handle renaming to an existing column name", () => {
     const result = renameColumn(testData, "int", "string");
 
-    expect(result).toEqual([
-      { string: 1, bool: "True", datetime: "2025-07-12 00:07:13" },
-      { string: 2, bool: "False", datetime: null },
-      { string: 3, bool: null, datetime: "2025-07-12 00:07:13" },
-      { string: 0, bool: "", datetime: "" },
-    ]);
+    expect(result).toEqual(testData);
   });
 
   it("should handle non-existent column name gracefully", () => {
@@ -421,8 +423,6 @@ describe("renameColumn", () => {
   });
 
   it("should handle objects with different property counts", () => {
-    const mixedData = [{ a: 1, b: 2 }, { a: 3, b: 4, c: 5 }, { a: 6 }];
-
     const result = renameColumn(mixedData, "a", "alpha");
 
     expect(result).toEqual([
@@ -433,11 +433,6 @@ describe("renameColumn", () => {
   });
 
   it("should handle null and undefined values in data", () => {
-    const dataWithNulls = [
-      { a: 1, b: null, c: undefined },
-      { a: null, b: 2, c: 3 },
-    ];
-
     const result = renameColumn(dataWithNulls, "b", "beta");
 
     expect(result).toEqual([