@marimo-team/islands 0.25.3-dev141 → 0.25.3-dev16

package/src/plugins/impl/__tests__/DataTablePlugin.test.tsx

@@ -136,6 +136,90 @@ describe("LoadingDataTableComponent", () => {
     expect(downloadGeoJSON).toHaveBeenCalledTimes(1);
   });
 
+  it("refreshes export metadata when a dataframe transform changes the data", async () => {
+    const host = document.createElement("div");
+    const metadataFor = (name: string) => ({
+      geometry_columns: [{ name, encoding: "objects", crs: "EPSG:4326" }],
+      primary_geometry_column: name,
+      default_geometry_column: name,
+      formats: {
+        parquet: { available: true, reason: null, missing_packages: [] },
+      },
+    });
+    const getExportMetadata = vi
+      .fn()
+      .mockResolvedValueOnce(metadataFor("before"))
+      .mockResolvedValueOnce(metadataFor("after"));
+    const view = (data: string) => (
+      <Provider store={store}>
+        <TooltipProvider>
+          <LoadingDataTableComponent
+            label={null}
+            totalRows={1}
+            pagination={false}
+            pageSize={10}
+            selection={null}
+            showDownload={true}
+            showFilters={false}
+            showColumnSummaries={false}
+            showDataTypes={false}
+            showPageSizeSelector={false}
+            showColumnExplorer={false}
+            showRowExplorer={false}
+            showChartBuilder={false}
+            rowHeaders={[]}
+            fieldTypes={undefined}
+            totalColumns={1}
+            maxColumns="all"
+            hasStableRowId={false}
+            lazy={false}
+            host={host}
+            showSearch={false}
+            value={[]}
+            setValue={vi.fn()}
+            data={data}
+            search={vi.fn().mockResolvedValue({
+              data,
+              total_rows: 1,
+              cell_styles: null,
+              cell_hover_texts: null,
+            })}
+            download_as={vi.fn()}
+            download_geojson={vi.fn()}
+            get_export_metadata={getExportMetadata}
+            get_column_summaries={vi.fn()}
+            get_data_url={vi.fn() as GetDataUrl}
+            get_row_ids={vi.fn() as GetRowIds}
+            get_size_bytes={vi.fn().mockResolvedValue({ size_bytes: null })}
+          />
+        </TooltipProvider>
+      </Provider>
+    );
+    const { rerender } = render(
+      view(JSON.stringify([{ before: "POINT (1 2)" }])),
+    );
+    await waitFor(() =>
+      expect(
+        screen.getByRole("columnheader", { name: "before" }),
+      ).toBeInTheDocument(),
+    );
+    fireEvent.click(screen.getByTestId("export-button"));
+    await waitFor(() =>
+      expect(screen.getByTestId("export-summary-parquet")).toHaveTextContent(
+        "before",
+      ),
+    );
+
+    rerender(view(JSON.stringify([{ after: "POINT (3 4)" }])));
+
+    await waitFor(() =>
+      expect(screen.getByTestId("export-summary-parquet")).toHaveTextContent(
+        "after",
+      ),
+    );
+    expect(getExportMetadata).toHaveBeenCalledTimes(2);
+  });
+
   it("does not log duplicate keys when a pivot becomes empty", async () => {
     const host = document.createElement("div");
     const consoleError = vi

package/src/utils/__tests__/dates.test.ts

@@ -4,6 +4,9 @@ import {
   exactDateTime,
   getDateFormat,
   getShortTimeZone,
+  parseLocalISODate,
+  parseLocalISODateTime,
+  parseTimeToDate,
   prettyDate,
   timeAgo,
 } from "../dates";
@@ -191,6 +194,119 @@ describe("dates", () => {
     });
   });
 
+  describe("parseTimeToDate", () => {
+    it("parses 24-hour times", () => {
+      expect(parseTimeToDate("14:30")).toEqual(new Date(1970, 0, 1, 14, 30));
+      expect(parseTimeToDate("14:30:05")).toEqual(
+        new Date(1970, 0, 1, 14, 30, 5),
+      );
+    });
+
+    it("parses times with an am/pm suffix", () => {
+      expect(parseTimeToDate("2:30 PM")).toEqual(new Date(1970, 0, 1, 14, 30));
+      expect(parseTimeToDate("12:00 am")).toEqual(new Date(1970, 0, 1, 0, 0));
+      expect(parseTimeToDate("12:00 pm")).toEqual(new Date(1970, 0, 1, 12, 0));
+    });
+
+    it("rejects an out-of-range hour instead of letting Date normalize it", () => {
+      // new Date(1970, 0, 1, 25, 0) would silently become 01:00 the next day.
+      expect(parseTimeToDate("25:00")).toBeUndefined();
+    });
+
+    it("rejects an out-of-range minute instead of letting Date normalize it", () => {
+      // new Date(1970, 0, 1, 12, 99) would silently become 13:39.
+      expect(parseTimeToDate("12:99")).toBeUndefined();
+    });
+
+    it("rejects an out-of-range second", () => {
+      expect(parseTimeToDate("12:30:99")).toBeUndefined();
+    });
+
+    it("requires an hour from 1 to 12 with an am/pm suffix", () => {
+      expect(parseTimeToDate("0:30 am")).toBeUndefined();
+      expect(parseTimeToDate("13:30 pm")).toBeUndefined();
+    });
+
+    it("parses milliseconds", () => {
+      expect(parseTimeToDate("14:30:05.123")).toEqual(
+        new Date(1970, 0, 1, 14, 30, 5, 123),
+      );
+    });
+
+    it("pads a short millisecond fraction and truncates a long one", () => {
+      expect(parseTimeToDate("14:30:05.5")).toEqual(
+        new Date(1970, 0, 1, 14, 30, 5, 500),
+      );
+      expect(parseTimeToDate("14:30:05.123456")).toEqual(
+        new Date(1970, 0, 1, 14, 30, 5, 123),
+      );
+    });
+  });
+
+  describe("parseLocalISODate", () => {
+    it("parses a date-only string into local midnight", () => {
+      expect(parseLocalISODate("2024-01-15")).toEqual(new Date(2024, 0, 15));
+    });
+
+    it("returns undefined for a non-date-only string", () => {
+      expect(parseLocalISODate("2024-01-15T00:00:00")).toBeUndefined();
+      expect(parseLocalISODate("")).toBeUndefined();
+      expect(parseLocalISODate("not-a-date")).toBeUndefined();
+    });
+
+    it("returns undefined for a calendar date that doesn't exist", () => {
+      expect(parseLocalISODate("2024-02-30")).toBeUndefined();
+      expect(parseLocalISODate("2024-13-01")).toBeUndefined();
+    });
+  });
+
+  describe("parseLocalISODateTime", () => {
+    it("parses a 'T'-separated datetime into local wall-clock time", () => {
+      expect(parseLocalISODateTime("2024-01-15T08:30:00")).toEqual(
+        new Date(2024, 0, 15, 8, 30, 0),
+      );
+    });
+
+    it("parses a space-separated datetime", () => {
+      expect(parseLocalISODateTime("2024-01-15 08:30:00")).toEqual(
+        new Date(2024, 0, 15, 8, 30, 0),
+      );
+    });
+
+    it("defaults seconds to 0 when omitted", () => {
+      expect(parseLocalISODateTime("2024-01-15T08:30")).toEqual(
+        new Date(2024, 0, 15, 8, 30, 0),
+      );
+    });
+
+    it("ignores a trailing Z instead of shifting to UTC", () => {
+      expect(parseLocalISODateTime("2024-01-15T08:30:00Z")).toEqual(
+        new Date(2024, 0, 15, 8, 30, 0),
+      );
+    });
+
+    it("ignores a trailing UTC offset instead of shifting the time", () => {
+      expect(parseLocalISODateTime("2024-01-15T08:30:00+05:00")).toEqual(
+        new Date(2024, 0, 15, 8, 30, 0),
+      );
+      expect(parseLocalISODateTime("2024-01-15T08:30:00-0500")).toEqual(
+        new Date(2024, 0, 15, 8, 30, 0),
+      );
+    });
+
+    it("ignores sub-second precision", () => {
+      expect(parseLocalISODateTime("2024-01-15T08:30:00.123")).toEqual(
+        new Date(2024, 0, 15, 8, 30, 0),
+      );
+    });
+
+    it("returns undefined for a date-only or unparsable string", () => {
+      expect(parseLocalISODateTime("2024-01-15")).toBeUndefined();
+      expect(parseLocalISODateTime("not-a-datetime")).toBeUndefined();
+      expect(parseLocalISODateTime("")).toBeUndefined();
+    });
+  });
+
   describe("getDateFormat", () => {
     it("returns the correct format for date", () => {
       expect(getDateFormat("2023-05-15")).toBe("yyyy-MM-dd");

package/src/utils/dates.ts

@@ -165,6 +165,44 @@ export function dateToLocalISOTime(d: Date): string {
   return `${pad2(d.getHours())}:${pad2(d.getMinutes())}:${pad2(d.getSeconds())}`;
 }
 
+/**
+ * Parse a time string into a Date anchored at the Unix epoch day. Supports
+ * the backend's wire format (`HH:MM:SS`, as produced by `dateToLocalISOTime`)
+ * as well as looser pasted text: optional seconds, optional milliseconds,
+ * and an optional `am`/`pm` suffix (e.g. `"14:30"`, `"2:30 PM"`,
+ * `"14:30:00.123"`).
+ */
+export function parseTimeToDate(value: string): Date | undefined {
+  const match = /^(\d{1,2}):(\d{2})(?::(\d{2}))?(?:\.(\d+))?\s*(am|pm)?$/i.exec(
+    value.trim(),
+  );
+  if (!match) {
+    return undefined;
+  }
+  const [, hStr, mStr, sStr, msStr, ampm] = match;
+  let hour = Number.parseInt(hStr, 10);
+  const minute = Number.parseInt(mStr, 10);
+  const second = sStr ? Number.parseInt(sStr, 10) : 0;
+  const ms = msStr ? Number.parseInt(msStr.padEnd(3, "0").slice(0, 3), 10) : 0;
+  if (minute > 59 || second > 59) {
+    return undefined;
+  }
+  if (ampm) {
+    if (hour < 1 || hour > 12) {
+      return undefined;
+    }
+    const isPm = ampm.toLowerCase() === "pm";
+    if (hour === 12) {
+      hour = isPm ? 12 : 0;
+    } else if (isPm) {
+      hour += 12;
+    }
+  } else if (hour > 23) {
+    return undefined;
+  }
+  return new Date(1970, 0, 1, hour, minute, second, ms);
+}
+
 /**
  * Format a Date as `YYYY-MM-DDTHH:MM:SS` (no timezone suffix) using local
  * fields. See `dateToLocalISODate` for the rationale on local vs UTC.
@@ -173,6 +211,62 @@ export function dateToLocalISODateTime(d: Date): string {
   return `${dateToLocalISODate(d)}T${dateToLocalISOTime(d)}`;
 }
 
+/**
+ * Parse a `YYYY-MM-DD` string into a Date anchored at local midnight.
+ *
+ * Unlike `new Date("YYYY-MM-DD")`, which the spec parses as UTC midnight,
+ * this treats the string as a calendar date in the viewer's own timezone.
+ * Returns undefined if the string doesn't match, or encodes a calendar
+ * date that doesn't exist (e.g. month 13, Feb 30), since `Date` would
+ * otherwise silently roll those over into a different date.
+ */
+export function parseLocalISODate(value: string): Date | undefined {
+  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value.trim());
+  if (!match) {
+    return undefined;
+  }
+  const [, yStr, mStr, dStr] = match;
+  const year = Number.parseInt(yStr, 10);
+  const month = Number.parseInt(mStr, 10);
+  const day = Number.parseInt(dStr, 10);
+  const date = new Date(year, month - 1, day);
+  if (
+    date.getFullYear() !== year ||
+    date.getMonth() !== month - 1 ||
+    date.getDate() !== day
+  ) {
+    return undefined;
+  }
+  return date;
+}
+
+/**
+ * Parse an ISO-ish `YYYY-MM-DD[T ]HH:MM[:SS[.sss]][Z|+HH:MM]` datetime string
+ * as wall-clock local time, ignoring any trailing `Z` or UTC offset.
+ *
+ * This keeps pasted datetimes consistent with the date/time pickers' local-
+ * time basis: pasting `2024-01-15T08:30:00Z` displays `08:30` instead of
+ * being shifted by the viewer's timezone.
+ */
+export function parseLocalISODateTime(value: string): Date | undefined {
+  const match =
+    /^(\d{4})-(\d{2})-(\d{2})[T ](\d{2}):(\d{2})(?::(\d{2})(?:\.\d+)?)?(?:Z|[+-]\d{2}:?\d{2})?$/.exec(
+      value.trim(),
+    );
+  if (!match) {
+    return undefined;
+  }
+  const [, yStr, moStr, dStr, hStr, miStr, sStr] = match;
+  return new Date(
+    Number.parseInt(yStr, 10),
+    Number.parseInt(moStr, 10) - 1,
+    Number.parseInt(dStr, 10),
+    Number.parseInt(hStr, 10),
+    Number.parseInt(miStr, 10),
+    sStr ? Number.parseInt(sStr, 10) : 0,
+  );
+}
+
 export const supportedDateFormats = ["yyyy", "yyyy-MM", "yyyy-MM-dd"] as const;
 export type DateFormat = (typeof supportedDateFormats)[number];
 

package/dist/error-entries-CzoYkIQZ.js

@@ -1,56 +0,0 @@
-import { At as e, N as t, b as n, d as r, jt as i, kt as a } from "./cells-C8iCYvLU.js";
-import { C as o } from "./select-BButFi-d.js";
-//#region src/core/errors/error-entries.ts
-function s(t) {
-	if (e(t.mimetype)) {
-		if (!Array.isArray(t.data)) return null;
-		let e = t.data.filter((e) => !e.type.includes("ancestor"));
-		return e.length === 0 ? null : { errorData: e };
-	}
-	return i(t.mimetype) ? typeof t.data != "string" || t.data.length === 0 ? null : {
-		errorData: [],
-		tracebackHtml: t.data
-	} : null;
-}
-function c(e) {
-	return e.some((e) => "traceback" in e && e.traceback);
-}
-function l(e) {
-	let t = e?.find((e) => i(e.mimetype));
-	if (!(!t || typeof t.data != "string" || t.data.length === 0)) return t.data;
-}
-function u(e, t) {
-	if (e.tracebackHtml) return e.tracebackHtml;
-	if (!c(e.errorData)) return l(t);
-}
-function d(e) {
-	let { cellIds: n, cellRuntime: i, cellData: o } = e.get(r), c = [];
-	for (let [e, r] of n.inOrderIds.entries()) {
-		let n = i[r], l = n.output;
-		if (!l || !a(l.mimetype)) continue;
-		let d = s(l);
-		if (!d) continue;
-		let f = t(o[r].name, e), p = o[r].lastCodeRun ?? o[r].code;
-		c.push({
-			cellId: r,
-			cellName: f,
-			cellCode: p,
-			errorData: d.errorData,
-			tracebackHtml: u(d, n.consoleOutputs)
-		});
-	}
-	return c;
-}
-function f(e) {
-	return e.type === "setup-refs" ? "The setup cell cannot have references" : e.type === "cycle" ? "This cell is in a cycle" : e.type === "multiple-defs" ? `The variable '${e.name}' was defined by another cell` : e.type === "import-star" || e.type === "ancestor-stopped" || e.type === "ancestor-prevented" || e.type === "exception" || e.type === "strict-exception" ? e.msg : e.type === "interruption" ? "This cell was interrupted and needs to be re-run" : e.type === "syntax" || e.type === "unknown" || e.type === "sql-error" ? e.msg : e.type === "internal" ? e.msg || "An internal error occurred" : (o(e), "Unknown error");
-}
-function p(e) {
-	let t = f(e);
-	return "traceback" in e && e.traceback && (t += `\n\nTraceback:\n${n(e.traceback)}`), t;
-}
-function m(e) {
-	let t = [e.cellName];
-	return e.tracebackHtml && t.push(n(e.tracebackHtml)), e.errorData.length > 0 && t.push(e.errorData.map(p).join("\n\n")), t.join("\n\n");
-}
-//#endregion
-export { d as i, m as n, p as r, f as t };

package/src/core/websocket/useWebSocket.tsx

@@ -1,88 +0,0 @@
-/* Copyright 2026 Marimo. All rights reserved. */
-
-import { useEffect, useState } from "react";
-import { Logger } from "@/utils/Logger";
-import { createPyodideConnection } from "../wasm/bridge";
-import { isWasm } from "../wasm/utils";
-import { BasicTransport } from "./transports/basic";
-import { SseTransport } from "./transports/sse";
-import { WsTransport } from "./transports/ws";
-import type { IConnectionTransport } from "./transports/transport";
-
-interface UseConnectionTransportOptions {
-  url: () => string;
-  static: boolean;
-  transportType: "websocket" | "sse";
-  /** Request headers for the SSE transport (auth); unused by WebSockets. */
-  headers: () => Record<string, string>;
-  waitToConnect: () => Promise<void>;
-  onOpen: (event: WebSocketEventMap["open"]) => void;
-  onMessage: (event: WebSocketEventMap["message"]) => void;
-  onClose: (event: WebSocketEventMap["close"]) => void;
-  onError: (event: WebSocketEventMap["error"]) => void;
-}
-
-export function createConnectionTransport(
-  options: Pick<
-    UseConnectionTransportOptions,
-    "url" | "static" | "transportType" | "headers"
-  >,
-): IConnectionTransport {
-  if (options.static) {
-    return BasicTransport.empty();
-  }
-  if (isWasm()) {
-    return createPyodideConnection();
-  }
-  // urlProvider is passed lazily; it may change after a runtime redirect.
-  if (options.transportType === "sse") {
-    return new SseTransport(options.url, options.headers);
-  }
-  return new WsTransport(options.url);
-}
-
-/**
- * A hook for creating a connection transport with React.
- */
-export function useConnectionTransport(options: UseConnectionTransportOptions) {
-  const { onOpen, onMessage, onClose, onError, waitToConnect } = options;
-
-  // oxlint-disable-next-line react/hook-use-state
-  const [transport] = useState<IConnectionTransport>(() => {
-    const socket = createConnectionTransport(options);
-
-    socket.addEventListener("open", onOpen);
-    socket.addEventListener("close", onClose);
-    socket.addEventListener("error", onError);
-    socket.addEventListener("message", onMessage);
-
-    return socket;
-  });
-
-  useEffect(() => {
-    // If it's closed, reconnect
-    // This starts closed, so we need to connect for the first time
-    if (transport.readyState === WebSocket.CLOSED) {
-      void waitToConnect()
-        .then(() => transport.reconnect())
-        .catch((error) => {
-          Logger.error("Healthy connection never made", error);
-          transport.close();
-        });
-    }
-
-    return () => {
-      Logger.warn(
-        "useConnectionTransport is unmounting. This likely means there is a bug.",
-      );
-      transport.close();
-      transport.removeEventListener("open", onOpen);
-      transport.removeEventListener("close", onClose);
-      transport.removeEventListener("error", onError);
-      transport.removeEventListener("message", onMessage);
-    };
-    // oxlint-disable-next-line react-hooks/exhaustive-deps
-  }, [transport]);
-
-  return transport;
-}