@marimo-team/islands 0.25.1-dev17 → 0.25.1-dev18

package/src/plugins/impl/vega/__tests__/utils.test.ts

@@ -1,7 +1,22 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 
 import { describe, expect, it } from "vitest";
-import { getContainerWidth } from "../utils";
+import { getContainerWidth, getVegaFieldTypes } from "../utils";
+
+describe("getVegaFieldTypes", () => {
+  it("preserves date strings unless the caller requests date parsing", () => {
+    expect(getVegaFieldTypes({ day: "date", timestamp: "datetime" })).toEqual({
+      day: "string",
+      timestamp: "date",
+    });
+    expect(
+      getVegaFieldTypes(
+        { day: "date", timestamp: "datetime" },
+        { parseDates: true },
+      ),
+    ).toEqual({ day: "date", timestamp: "date" });
+  });
+});
 
 describe("getContainerWidth", () => {
   it('should return "container" when spec width is "container"', () => {

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

@@ -13,6 +13,43 @@ const { ZERO_WIDTH_SPACE, replacePeriodsInColumnNames, uniquifyColumnNames } =
   exportedForTesting;
 
 describe("vega loader", () => {
+  it("parses infinities only in explicitly numeric CSV fields", async () => {
+    vi.spyOn(vegaLoader, "load").mockResolvedValue(
+      "value,label,id\ninf,inf,1\n-inf,-inf,2\n+inf,+inf,3\n2.5,002.5,4\n,,5\nNaN,NaN,6\n",
+    );
+
+    const data = await vegaLoadData("chart.csv", {
+      type: "csv",
+      parse: { value: "number", label: "string", id: "integer" },
+    });
+
+    expect(data).toEqual([
+      { value: Infinity, label: "inf", id: 1 },
+      { value: -Infinity, label: "-inf", id: 2 },
+      { value: Infinity, label: "+inf", id: 3 },
+      { value: 2.5, label: "002.5", id: 4 },
+      { value: null, label: null, id: 5 },
+      { value: Number.NaN, label: "NaN", id: 6 },
+    ]);
+  });
+
+  it("preserves the table's large integer and infinity handling", async () => {
+    vi.spyOn(vegaLoader, "load").mockResolvedValue(
+      "id,value\n9007199254740993,inf\n9007199254740995,-inf\n",
+    );
+
+    const data = await vegaLoadData(
+      "table.csv",
+      { type: "csv", parse: { id: "integer", value: "number" } },
+      { handleBigIntAndNumberLike: true },
+    );
+
+    expect(data).toEqual([
+      { id: BigInt("9007199254740993"), value: "inf" },
+      { id: BigInt("9007199254740995"), value: "-inf" },
+    ]);
+  });
+
   it("should parse csv data with dates", async () => {
     const csvData = `
 active,username,id

package/src/plugins/impl/vega/loader.ts

@@ -16,6 +16,26 @@ const previousNumberParser = typeParsers.number;
 const previousDateParser = typeParsers.date;
 const previousBooleanParser = typeParsers.boolean;
 
+const NUMBER_MIDDLEWARE: Middleware = () => {
+  const parseNumber = (value: string) => {
+    if (value === "inf" || value === "+inf") {
+      return Number.POSITIVE_INFINITY;
+    }
+    if (value === "-inf") {
+      return Number.NEGATIVE_INFINITY;
+    }
+    return previousNumberParser(value);
+  };
+
+  typeParsers.integer = parseNumber;
+  typeParsers.number = parseNumber;
+
+  return () => {
+    typeParsers.integer = previousIntegerParser;
+    typeParsers.number = previousNumberParser;
+  };
+};
+
 const BIG_INT_MIDDLEWARE: Middleware = () => {
   // Custom parser to:
   // - handle BigInt
@@ -159,6 +179,8 @@ export async function vegaLoadData<T = object>(
   const middleware: Middleware[] = [DATE_MIDDLEWARE];
   if (handleBigIntAndNumberLike) {
     middleware.push(BIG_INT_MIDDLEWARE);
+  } else {
+    middleware.push(NUMBER_MIDDLEWARE);
   }
 
   let unsubscribes: Unsubscribe[] = [];
@@ -216,7 +238,7 @@ export async function vegaLoadData<T = object>(
 
     // Apply middleware
     unsubscribes = middleware.map((m) => m());
-    // Always set parse to auto for csv data, to be able to parse dates and floats
+    // CSV defaults to inference when no explicit column types are available.
     const results = isCsv
       ? // csv -> json
         read(csvOrJsonData, {

package/src/plugins/impl/vega/utils.ts

@@ -45,21 +45,22 @@ function toArray<T>(value: T | T[] | undefined): T[] {
 
 export function getVegaFieldTypes(
   types: Record<string, DataType> | undefined | null,
+  { parseDates = false }: { parseDates?: boolean } = {},
 ): FieldTypes | "auto" {
   if (!types || Object.keys(types).length === 0) {
     // If fieldTypes is provided, use it to parse the data
     // Otherwise, infer the data types
     return "auto";
   }
-  // Convert all 'date' to 'string', because dates don't format back to
-  // the correct formatting. For example, a date like '2024-01-01' will
-  // be formatted to '2024-01-01T00:00:00.000Z'.
+  // Preserve date-only strings for callers such as the data editor.
+  // Parsing creates Date objects that JSON serializes as full timestamps.
+  // Charts opt into date parsing for temporal axes.
   return Objects.mapValues(types, (type): VegaDataType => {
     if (type === "geometry") {
       return "string";
     }
     if (type === "date") {
-      return "string";
+      return parseDates ? "date" : "string";
     }
     if (type === "time") {
       return "string";