@marimo-team/islands 0.23.3-dev45 → 0.23.3-dev48

package/package.json

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

package/src/components/editor/output/JsonOutput.tsx

@@ -18,6 +18,7 @@ import { memo, useState } from "react";
 import type { OutputMessage } from "@/core/kernel/messages";
 import { cn } from "@/utils/cn";
 import { copyToClipboard } from "@/utils/copy";
+import { jsonParseWithSpecialChar } from "@/utils/json/json-parser";
 import { isUrl } from "@/utils/urls";
 import { useTheme } from "../../../theme/useTheme";
 import { logNever } from "../../../utils/assertNever";
@@ -386,14 +387,41 @@ function renderLeaf(leaf: string, render: LeafRenderer): React.ReactNode {
 // See `_key_formatter` in marimo/_output/formatters/structures.py.
 const KEY_ENCODED_PREFIX = "text/plain+";
 
+// Format elements for a Python collection literal. Non-finite floats
+// (NaN / Infinity / -Infinity) parse as JS `number` via
+// `jsonParseWithSpecialChar`; `JSON.stringify` on those returns `null`,
+// so render them as the same `float(...)` literals we use for scalar
+// float keys (see `decodeKeyForCopy`).
+function formatCollectionItems(items: unknown[]): string {
+  return items
+    .map((x) => {
+      if (typeof x === "number" && !Number.isFinite(x)) {
+        if (Number.isNaN(x)) {
+          return "float('nan')";
+        }
+        return x > 0 ? "float('inf')" : "-float('inf')";
+      }
+      return JSON.stringify(x);
+    })
+    .join(", ");
+}
+
 // Format a JSON-list payload as a Python tuple literal. 1-element tuples
 // need a trailing comma — `(1)` is just `1` in Python, `(1,)` is the tuple.
+// Uses `jsonParseWithSpecialChar` so bare `NaN`/`Infinity`/`-Infinity`
+// emitted by Python's json.dumps round-trip cleanly.
 function formatTuplePayload(jsonList: string): string {
-  const items = JSON.parse(jsonList) as unknown[];
-  const inner = items.map((x) => JSON.stringify(x)).join(", ");
+  const items = jsonParseWithSpecialChar<unknown[]>(jsonList);
+  // `jsonParseWithSpecialChar` returns `{}` when both parse passes fail;
+  // fall back to the raw payload so a malformed wire form doesn't crash
+  // rendering/copy. Matches the defensive pattern in `formatSetPayload`.
+  if (!Array.isArray(items)) {
+    return jsonList;
+  }
   if (items.length === 0) {
     return "()";
   }
+  const inner = formatCollectionItems(items);
   if (items.length === 1) {
     return `(${inner},)`;
   }
@@ -403,29 +431,31 @@ function formatTuplePayload(jsonList: string): string {
 // Format a JSON-list payload as a Python frozenset literal. Empty → `frozenset()`
 // rather than `frozenset({})` (which reads like a dict).
 function formatFrozensetPayload(jsonList: string): string {
-  const items = JSON.parse(jsonList) as unknown[];
+  const items = jsonParseWithSpecialChar<unknown[]>(jsonList);
+  if (!Array.isArray(items)) {
+    return jsonList;
+  }
   if (items.length === 0) {
     return "frozenset()";
   }
-  const inner = items.map((x) => JSON.stringify(x)).join(", ");
+  const inner = formatCollectionItems(items);
   return `frozenset({${inner}})`;
 }
 
 // Format a JSON-list payload as a Python set literal. Empty → `set()`
 // (not `{}`, which is a dict literal in Python).
 function formatSetPayload(jsonList: string): string {
-  try {
-    const items = JSON.parse(jsonList) as unknown[];
-    if (items.length === 0) {
-      return "set()";
-    }
-    const inner = items.map((x) => JSON.stringify(x)).join(", ");
-    return `{${inner}}`;
-  } catch {
+  const items = jsonParseWithSpecialChar<unknown[]>(jsonList);
+  if (!Array.isArray(items)) {
     // Back-compat: older wire form was `text/plain+set:{1, 2, 3}` (Python
     // set-literal string, not JSON). Pass it through as-is rather than crash.
     return jsonList;
   }
+  if (items.length === 0) {
+    return "set()";
+  }
+  const inner = formatCollectionItems(items);
+  return `{${inner}}`;
 }
 
 // Renderers for decoded non-string keys. Visual affordances match Python:

package/src/components/editor/output/__tests__/json-output.test.ts

@@ -417,6 +417,44 @@ describe("getCopyValue with encoded non-string keys", () => {
     `);
   });
 
+  it("parses tuple/frozenset payloads containing bare NaN/Infinity", () => {
+    // Python's json.dumps emits bare `NaN`/`Infinity` inside the embedded
+    // tuple/frozenset payload strings (JSON spec violation, but ECMA-262-
+    // friendly via the fallback in jsonParseWithSpecialChar). The outer
+    // JSON stays strict because those tokens live inside a JSON string
+    // key/value. Regression for tuple-key payloads that previously broke
+    // the frontend's `JSON.parse` and threw.
+    const value = {
+      "text/plain+tuple:[NaN]": "tn",
+      "text/plain+tuple:[Infinity, -Infinity]": "ti",
+      k: "text/plain+frozenset:[Infinity, 1]",
+    };
+    expect(getCopyValue(value)).toMatchInlineSnapshot(`
+      "{
+        (float('nan'),): "tn",
+        (float('inf'), -float('inf')): "ti",
+        "k": frozenset({float('inf'), 1})
+      }"
+    `);
+  });
+
+  it("falls back to the raw payload for malformed tuple/frozenset", () => {
+    // `jsonParseWithSpecialChar` returns `{}` on parse failure rather
+    // than throwing; without an `Array.isArray` guard, the formatters
+    // would crash on `.length`/`.map`. Pass the raw payload through so
+    // a malformed wire form doesn't break the whole render.
+    const value = {
+      "text/plain+tuple:not a json list": "t",
+      k: "text/plain+frozenset:also broken",
+    };
+    expect(getCopyValue(value)).toMatchInlineSnapshot(`
+      "{
+        not a json list: "t",
+        "k": also broken
+      }"
+    `);
+  });
+
   it("unescapes string keys that looked encoded", () => {
     const value = {
       "text/plain+str:text/plain+int:2": "hello",