@marimo-team/frontend 0.25.3-dev2 → 0.25.3-dev21

package/src/components/data-table/export-actions.tsx

@@ -14,6 +14,7 @@ import {
   TableIcon,
 } from "lucide-react";
 import React from "react";
+import useEvent from "react-use-event-hook";
 import { downloadSizeLimitAtom } from "./download-policy/atoms";
 import type {
   DownloadAsArgs,
@@ -22,6 +23,7 @@ import type {
   ExportMetadata,
   GetExportMetadata,
 } from "./schemas";
+import { useAsyncData } from "@/hooks/useAsyncData";
 import { logNever } from "@/utils/assertNever";
 import { cn } from "@/utils/cn";
 import { copyToClipboard } from "@/utils/copy";
@@ -274,19 +276,130 @@ const failureTitleForAction = (action: ExportAction): string =>
 const failureDescription = (error: unknown): string =>
   typeof error === "string" ? error : prettyError(error);
 
+const OBSOLETE_GEOMETRY_MESSAGE =
+  "The selected geometry is no longer available. Choose another geometry to export.";
+
+type GeographicBlocker =
+  | "format-unavailable"
+  | "geometry-required"
+  | "choose-geometry"
+  | "obsolete-geometry"
+  | "missing-crs";
+
+/**
+ * Find the first reason that a geographic export cannot start with the
+ * selected geometry. The dialog uses it to disable a format, and the retry
+ * after a package installation uses it to decide whether to export.
+ */
+function geographicBlocker(
+  metadata: ExportMetadata,
+  format: GeographicFormat,
+  geometryColumn: string | null,
+): GeographicBlocker | null {
+  if (metadata.formats[format]?.available === false) {
+    return "format-unavailable";
+  }
+  const selected = metadata.geometry_columns.find(
+    (column) => column.name === geometryColumn,
+  );
+  if (geometryColumn !== null && !selected) {
+    return "obsolete-geometry";
+  }
+  if (metadata.geometry_columns.length === 0) {
+    return format === "geojson" ? "geometry-required" : null;
+  }
+  if (!selected) {
+    return "choose-geometry";
+  }
+  if (format === "geojson" && !selected.crs) {
+    return "missing-crs";
+  }
+  return null;
+}
+
+const geometryDisplayName = (name: string | null): string | null =>
+  name === "" ? "(unnamed geometry)" : name;
+
+function geographicBlockerReason(
+  blocker: GeographicBlocker | null,
+  formatLabel: string,
+  geometryColumn: string | null,
+): string | null {
+  switch (blocker) {
+    case "choose-geometry":
+      return `Choose a primary geometry column to export ${formatLabel}.`;
+    case "obsolete-geometry":
+      return OBSOLETE_GEOMETRY_MESSAGE;
+    case "missing-crs":
+      return `Geometry column ${geometryDisplayName(geometryColumn)} needs a CRS for GeoJSON export. Declare its source CRS in Python before exporting.`;
+    case "format-unavailable":
+    case "geometry-required":
+    case null:
+      return null;
+    default:
+      logNever(blocker);
+      return null;
+  }
+}
+
+/**
+ * One open dialog for one table source. Closing the dialog or replacing the
+ * source creates a new context, and work started under an older context must
+ * not change the dialog or start an export.
+ */
+interface ExportContext {
+  source: unknown;
+}
+
 export const ExportActions: React.FC<ExportActionProps> = (props) => {
   const { getExportMetadata, metadataSource } = props;
   const [exportDialogOpen, setExportDialogOpen] = React.useState(false);
   const [failure, setFailure] = React.useState<ExportFailure | null>(null);
   const [settings, setSettings] =
     React.useState<ExportSettings>(DEFAULT_SETTINGS);
-  const [metadata, setMetadata] = React.useState<ExportMetadata | null>(null);
-  const [metadataLoading, setMetadataLoading] = React.useState(false);
-  const [metadataError, setMetadataError] = React.useState<string | null>(null);
-  const [metadataRefresh, setMetadataRefresh] = React.useState(0);
+  const [exportContext, setExportContext] = React.useState<ExportContext>(
+    () => ({ source: metadataSource }),
+  );
+  if (exportContext.source !== metadataSource) {
+    setExportContext({ source: metadataSource });
+  }
+  const mounted = React.useRef(false);
+  const isCurrentContext = useEvent(
+    (context: ExportContext) => mounted.current && context === exportContext,
+  );
+  const metadataRequest = useAsyncData(async () => {
+    if (!exportDialogOpen || !getExportMetadata) {
+      return null;
+    }
+    return { context: exportContext, metadata: await getExportMetadata({}) };
+  }, [exportDialogOpen, getExportMetadata, exportContext]);
+  // The hook keeps earlier data while it reloads and after a failure. Only a
+  // completed response for the current context can enable an export.
+  const metadata =
+    metadataRequest.status === "success" &&
+    metadataRequest.data?.context === exportContext
+      ? metadataRequest.data.metadata
+      : null;
+  const metadataError =
+    metadataRequest.status === "error"
+      ? failureDescription(metadataRequest.error)
+      : null;
   const [geometryColumn, setGeometryColumn] = React.useState<string | null>(
     null,
   );
+  const [reconciledMetadata, setReconciledMetadata] =
+    React.useState<ExportMetadata | null>(null);
+  if (metadata !== reconciledMetadata) {
+    setReconciledMetadata(metadata);
+    if (metadata) {
+      setGeometryColumn((current) =>
+        current !== null &&
+        metadata.geometry_columns.some((column) => column.name === current)
+          ? current
+          : metadata.default_geometry_column,
+      );
+    }
+  }
   const hasGeometry = !!metadata?.geometry_columns.length;
   const [expandedFormat, setExpandedFormat] = React.useState<
     ConfigurableFormat | GeographicFormat | null
@@ -294,43 +407,17 @@ export const ExportActions: React.FC<ExportActionProps> = (props) => {
   const triggerRef = React.useRef<HTMLButtonElement>(null);
   const dialogRef = React.useRef<HTMLDivElement>(null);
   const latestActionId = React.useRef(0);
+  React.useLayoutEffect(() => {
+    mounted.current = true;
+    return () => {
+      mounted.current = false;
+      latestActionId.current += 1;
+    };
+  }, []);
   React.useEffect(() => {
     latestActionId.current += 1;
+    setFailure(null);
   }, [metadataSource]);
-  React.useEffect(() => {
-    if (!exportDialogOpen || !getExportMetadata) {
-      return;
-    }
-    let active = true;
-    setMetadata(null);
-    setMetadataLoading(true);
-    setMetadataError(null);
-    void getExportMetadata({}).then(
-      (result) => {
-        if (!active) {
-          return;
-        }
-        setMetadata(result);
-        setGeometryColumn((current) =>
-          current !== null &&
-          result.geometry_columns.some((column) => column.name === current)
-            ? current
-            : result.default_geometry_column,
-        );
-        setMetadataLoading(false);
-      },
-      (error: unknown) => {
-        if (!active) {
-          return;
-        }
-        setMetadataError(failureDescription(error));
-        setMetadataLoading(false);
-      },
-    );
-    return () => {
-      active = false;
-    };
-  }, [exportDialogOpen, getExportMetadata, metadataSource, metadataRefresh]);
   const policy = useAtomValue(downloadSizeLimitAtom);
   const overLimit = !!(
     policy &&
@@ -368,9 +455,8 @@ export const ExportActions: React.FC<ExportActionProps> = (props) => {
       setFailure(null);
       setExpandedFormat(null);
       setSettings(DEFAULT_SETTINGS);
-      setMetadata(null);
-      setMetadataError(null);
       setGeometryColumn(null);
+      setExportContext({ source: metadataSource });
     }
   };
 
@@ -553,57 +639,67 @@ export const ExportActions: React.FC<ExportActionProps> = (props) => {
     }
   };
 
-  const retryAfterInstall = async (action: ExportAction) => {
-    if (isGeographic(action.format) && getExportMetadata) {
+  // Package installation can finish after the dialog closes or the source
+  // changes, so the retry carries the context in which installation began.
+  const retryAfterInstall = useEvent(
+    async (action: ExportAction, context: ExportContext) => {
+      if (!isCurrentContext(context)) {
+        return;
+      }
+      if (!isGeographic(action.format) || !getExportMetadata) {
+        retryAction(action);
+        return;
+      }
       const actionId = latestActionId.current;
+      const isCurrent = () =>
+        isCurrentContext(context) && actionId === latestActionId.current;
       let result: ExportMetadata;
       try {
         result = await getExportMetadata({});
-      } catch (error) {
-        if (actionId === latestActionId.current) {
-          setMetadataError(failureDescription(error));
+      } catch {
+        if (isCurrent()) {
+          metadataRequest.refetch();
         }
         return;
       }
-      if (actionId !== latestActionId.current) {
+      if (!isCurrent()) {
         return;
       }
-      setMetadata(result);
-      setMetadataError(null);
-      if (result.formats[action.format]?.available === false) {
-        setFailure(null);
-        return;
-      }
-      if (
-        geometryColumn !== null &&
-        !result.geometry_columns.some(
-          (column) => column.name === geometryColumn,
-        )
-      ) {
-        setGeometryColumn(result.default_geometry_column);
-        setActionFailure(actionId, {
-          kind: "error",
-          title: failureTitleForAction(action),
-          description:
-            "The selected geometry is no longer available. Choose another geometry to export.",
-          action,
-        });
-        return;
-      }
-      if (result.geometry_columns.length > 0 && geometryColumn === null) {
-        return;
-      }
-      if (
-        action.format === "geojson" &&
-        !result.geometry_columns.find(
-          (column) => column.name === geometryColumn,
-        )?.crs
-      ) {
-        setFailure(null);
-        return;
+      // Validation reads its own response, so a display refresh cannot
+      // start an export that this check rejected.
+      metadataRequest.refetch();
+      const blocker = geographicBlocker(result, action.format, geometryColumn);
+      switch (blocker) {
+        case null:
+          retryAction(action);
+          return;
+        case "obsolete-geometry":
+          setGeometryColumn(result.default_geometry_column);
+          setActionFailure(actionId, {
+            kind: "error",
+            title: failureTitleForAction(action),
+            description: OBSOLETE_GEOMETRY_MESSAGE,
+            action,
+          });
+          return;
+        case "choose-geometry":
+          return;
+        case "format-unavailable":
+        case "geometry-required":
+        case "missing-crs":
+          setFailure(null);
+          return;
+        default:
+          logNever(blocker);
       }
-    }
-    retryAction(action);
+    },
+  );
+
+  const createInstallRetry = (action: ExportAction) => {
+    const context = exportContext;
+    return () => {
+      void retryAfterInstall(action, context);
+    };
   };
 
   const toggleExpanded = (format: ExportFormat) => {
@@ -670,9 +766,7 @@ export const ExportActions: React.FC<ExportActionProps> = (props) => {
               failure?.action.format === option.format ? failure : null;
             const summary =
               isGeographic(option.format) && hasGeometry
-                ? geometryColumn === ""
-                  ? "(unnamed geometry)"
-                  : (geometryColumn ?? "Choose geometry")
+                ? (geometryDisplayName(geometryColumn) ?? "Choose geometry")
                 : settingsSummary(settings, option.format);
             const selectedGeometryIndex =
               metadata?.geometry_columns.findIndex(
@@ -681,20 +775,14 @@ export const ExportActions: React.FC<ExportActionProps> = (props) => {
             const eligibility = isGeographic(option.format)
               ? metadata?.formats[option.format]
               : undefined;
-            const selectedGeometry =
-              metadata?.geometry_columns[selectedGeometryIndex];
-            const missingCrs =
-              option.format === "geojson" &&
-              selectedGeometry !== undefined &&
-              !selectedGeometry.crs;
+            const blocker =
+              isGeographic(option.format) && metadata
+                ? geographicBlocker(metadata, option.format, geometryColumn)
+                : null;
             const geometryReason = metadataError
               ? `Could not load geometry options: ${metadataError}`
               : (eligibility?.reason ??
-                (hasGeometry && geometryColumn === null
-                  ? `Choose a primary geometry column to export ${optionLabel}.`
-                  : missingCrs
-                    ? `Geometry column ${geometryColumn === "" ? "(unnamed geometry)" : geometryColumn} needs a CRS for GeoJSON export. Declare its source CRS in Python before exporting.`
-                    : null));
+                geographicBlockerReason(blocker, optionLabel, geometryColumn));
             const missingPackageFailure =
               rowFailure?.kind === "missing-packages" ? rowFailure : null;
             const missingPackages =
@@ -704,13 +792,7 @@ export const ExportActions: React.FC<ExportActionProps> = (props) => {
                 : []);
             const geographicUnavailable =
               isGeographic(option.format) &&
-              ((!!getExportMetadata && !metadata) ||
-                metadataLoading ||
-                !!metadataError ||
-                eligibility?.available === false ||
-                missingCrs ||
-                (!!metadata?.geometry_columns.length &&
-                  geometryColumn === null));
+              ((!!getExportMetadata && !metadata) || blocker !== null);
             const copyUnavailable =
               isGeographic(option.format) &&
               (geographicUnavailable || missingPackages.length > 0);
@@ -888,9 +970,7 @@ export const ExportActions: React.FC<ExportActionProps> = (props) => {
                           type="button"
                           size="xs"
                           variant="outline"
-                          onClick={() =>
-                            setMetadataRefresh((current) => current + 1)
-                          }
+                          onClick={metadataRequest.refetch}
                         >
                           Retry
                         </Button>
@@ -906,17 +986,13 @@ export const ExportActions: React.FC<ExportActionProps> = (props) => {
                         missingPackageFailure?.description ??
                         eligibility?.reason
                       }
-                      onInstall={() => {
-                        void retryAfterInstall(
-                          missingPackageFailure?.action ?? {
-                            destination: "download",
-                            format:
-                              option.format === "geojson"
-                                ? "geojson"
-                                : "parquet",
-                          },
-                        );
-                      }}
+                      onInstall={createInstallRetry(
+                        missingPackageFailure?.action ?? {
+                          destination: "download",
+                          format:
+                            option.format === "geojson" ? "geojson" : "parquet",
+                        },
+                      )}
                       className="items-start"
                     />
                   </div>

package/src/components/data-table/schemas.ts

@@ -3,42 +3,6 @@
 import z from "zod";
 import { rpc } from "@/plugins/core/rpc";
 
-export type DownloadFormat = "csv" | "json" | "parquet" | "tsv" | "geojson";
-
-/**
- * Per-request export options. Each field is optional. A missing field keeps
- * the widget's default for that setting.
- */
-export interface DownloadAsOptions {
-  separator?: string;
-  encoding?: string;
-  ensure_ascii?: boolean;
-}
-
-export interface DownloadAsRequest {
-  format: DownloadFormat;
-  options?: DownloadAsOptions;
-  geometry_column?: string | null;
-}
-
-export type DownloadAsArgs = (req: DownloadAsRequest) => Promise<{
-  url: string;
-  filename: string;
-  error?: string | null;
-  missing_packages?: string[] | null;
-  code?:
-    | "geometry_required"
-    | "invalid_geometry"
-    | "invalid_metadata"
-    | "unsupported_representation"
-    | "unsupported_version"
-    | "missing_packages"
-    | "missing_crs"
-    | "conversion_failed"
-    | null;
-  column?: string | null;
-}>;
-
 const DownloadRequestSchema = z.object({
   geometry_column: z.string().nullish(),
   options: z
@@ -88,6 +52,20 @@ export const DownloadGeoJSONSchema = rpc
     }),
   );
 
+export type DownloadAsRequest =
+  | z.infer<typeof DownloadAsSchema.input>
+  | z.infer<typeof DownloadGeoJSONSchema.input>;
+
+type DownloadResponse =
+  | z.infer<typeof DownloadAsSchema.output>
+  | z.infer<typeof DownloadGeoJSONSchema.output>;
+
+export type DownloadFormat = DownloadAsRequest["format"];
+export type DownloadAsOptions = NonNullable<DownloadAsRequest["options"]>;
+export type DownloadAsArgs = (
+  req: DownloadAsRequest,
+) => Promise<DownloadResponse>;
+
 export type DownloadAsFunction = (
   req: z.infer<typeof DownloadAsSchema.input>,
 ) => Promise<z.infer<typeof DownloadAsSchema.output>>;

package/src/components/data-table/utils.ts

@@ -228,6 +228,24 @@ export function detectSentinel(
   return null;
 }
 
+type NullishSentinelType = Extract<CellValueSentinel["type"], "null" | "nat">;
+
+const NULLISH_SENTINEL_TYPES: ReadonlySet<CellValueSentinel["type"]> =
+  new Set<NullishSentinelType>(["null", "nat"]);
+
+/**
+ * True when the cell value represents a missing value (null, NaT)
+ * rather than a real value that happens to look special.
+ */
+export function isNullishSentinel(
+  value: unknown,
+  dataType: DataType | undefined,
+  dtype?: string,
+): boolean {
+  const sentinel = detectSentinel(value, dataType, dtype);
+  return sentinel !== null && NULLISH_SENTINEL_TYPES.has(sentinel.type);
+}
+
 /**
  * Stringify an unknown value. Converts objects to JSON strings.
  * @param opts.value - The value to stringify.

package/src/components/editor/Output.tsx

@@ -66,7 +66,10 @@ export type OnRefactorWithAI = (opts: {
  * Renders an output based on an OutputMessage.
  */
 export const OutputRenderer: React.FC<{
-  message: Pick<OutputMessage, "channel" | "data" | "mimetype">;
+  message: Pick<
+    OutputMessage,
+    "channel" | "data" | "mimetype" | "code" | "traceback_format"
+  >;
   cellId?: CellId;
   onRefactorWithAI?: OnRefactorWithAI;
   wrapText?: boolean;
@@ -172,7 +175,9 @@ export const OutputRenderer: React.FC<{
 
     case "application/vnd.marimo+error":
       invariant(Array.isArray(data), "Expected array data");
-      return <MarimoErrorOutput cellId={cellId} errors={data} />;
+      return (
+        <MarimoErrorOutput cellId={cellId} errors={data} code={message.code} />
+      );
 
     case "application/vnd.marimo+traceback":
       invariant(
@@ -183,6 +188,8 @@ export const OutputRenderer: React.FC<{
         <MarimoTracebackOutput
           onRefactorWithAI={onRefactorWithAI}
           traceback={data}
+          tracebackFormat={message.traceback_format}
+          code={message.code}
           cellId={cellId}
         />
       );