Skip to content

A reactive notebook for Python — run reproducible experiments, query with SQL, execute as a script, deploy as an app, and version with git. Stored as pure Python. All in a modern, AI-native editor.

feat(table): highlight search matches in cells (#11424)

Kiran Gadhaveb47c617b4151
diff --git a/frontend/src/components/data-table/__tests__/columns.test.tsx b/frontend/src/components/data-table/__tests__/columns.test.tsx
index 70fe0acfad..5ecbffb4fe 100644
--- a/frontend/src/components/data-table/__tests__/columns.test.tsx
+++ b/frontend/src/components/data-table/__tests__/columns.test.tsx
@@ -14,6 +14,7 @@ import {
renderCellValue,
} from "../columns";
import { getMimeValues, isMimeValue, MimeCell } from "../mime-cell";
+import { buildHighlightPattern } from "../search-highlight";
import type { FieldTypesWithExternalType } from "../types";
import { uniformSample } from "../uniformSample";
import { UrlDetector } from "../url-detector";
@@ -240,6 +241,7 @@ describe("generateColumns", () => {
// "age" is a number column — should auto right-align
// oxlint-disable-next-line typescript/no-explicit-any
const cell = (columns[1].cell as any)({
+ table: { options: { meta: {} } },
column: {
columnDef: columns[1],
},
@@ -251,6 +253,7 @@ describe("generateColumns", () => {
// "name" is a string column — should remain left-aligned
// oxlint-disable-next-line typescript/no-explicit-any
const nameCell = (columns[0].cell as any)({
+ table: { options: { meta: {} } },
column: {
columnDef: columns[0],
},
@@ -271,6 +274,7 @@ describe("generateColumns", () => {
// "age" is numeric but explicitly set to left
// oxlint-disable-next-line typescript/no-explicit-any
const cell = (columns[1].cell as any)({
+ table: { options: { meta: {} } },
column: {
columnDef: columns[1],
},
@@ -311,6 +315,7 @@ describe("generateColumns", () => {
// Assuming getCellStyleClass is a function that returns a class name
// oxlint-disable-next-line typescript/no-explicit-any
const cell = (columns[0].cell as any)({
+ table: { options: { meta: {} } },
column: {
columnDef: columns[0],
},
@@ -1359,3 +1364,103 @@ test("column_widths sets fixed size and meta.width", () => {
expect(b?.size).toBeUndefined();
expect(b?.meta?.width).toBeUndefined();
});
+
+describe("renderCellValue with highlightPattern", () => {
+ const createColumn = (
+ dataType: "string" | "number" | "boolean" | "date",
+ dtype = "object",
+ ) =>
+ ({
+ id: "col",
+ columnDef: { meta: { dataType, dtype } },
+ getColumnFormatting: () => undefined,
+ getColumnWrapping: () => undefined,
+ applyColumnFormatting: (value: unknown) => value,
+ }) as unknown as Column<unknown>;
+
+ const renderCell = (
+ column: Column<unknown>,
+ value: unknown,
+ highlightQuery: string,
+ ) =>
+ render(
+ <I18nProvider locale="en-US">
+ <TooltipProvider>
+ {renderCellValue({
+ column,
+ renderValue: () => value,
+ getValue: () => value,
+ selectCell: undefined,
+ cellStyles: "",
+ highlightPattern: buildHighlightPattern(highlightQuery),
+ })}
+ </TooltipProvider>
+ </I18nProvider>,
+ );
+
+ const markTexts = (container: HTMLElement) =>
+ [...container.querySelectorAll("mark")].map((m) => m.textContent);
+
+ it("marks a match in a string cell", () => {
+ const { container } = renderCell(
+ createColumn("string"),
+ "Alice Smith",
+ "smi",
+ );
+ expect(markTexts(container)).toEqual(["Smi"]);
+ });
+
+ it("marks only the middle text when the string has edge whitespace", () => {
+ const { container } = renderCell(createColumn("string"), " a b ", " ");
+ expect(markTexts(container)).toEqual([" "]);
+ const edgeMarkers = container.querySelectorAll("span[aria-label]");
+ expect(edgeMarkers).toHaveLength(2);
+ for (const marker of edgeMarkers) {
+ expect(marker.querySelector("mark")).toBeNull();
+ }
+ });
+
+ it("marks a match in the locale display of a number", () => {
+ const { container } = renderCell(createColumn("number"), 1234.5, "234");
+ expect(markTexts(container)).toEqual(["234"]);
+ expect(container.textContent).toBe("1,234.5");
+ });
+
+ it("does not mark a number when the locale display hides the raw match", () => {
+ const { container } = renderCell(createColumn("number"), 1234, "1234");
+ expect(markTexts(container)).toEqual([]);
+ expect(container.textContent).toBe("1,234");
+ });
+
+ it("marks a boolean cell", () => {
+ const { container } = renderCell(createColumn("boolean"), false, "false");
+ expect(markTexts(container)).toEqual(["False"]);
+ });
+
+ it("marks a date cell by its display string", () => {
+ const { container } = renderCell(
+ createColumn("date", "date"),
+ new Date(2026, 0, 15),
+ "2026",
+ );
+ expect(markTexts(container)).toEqual(["2026"]);
+ });
+
+ it("renders no mark for an empty query", () => {
+ for (const [column, value] of [
+ [createColumn("string"), "Alice"],
+ [createColumn("number"), 12],
+ [createColumn("boolean"), false],
+ [createColumn("date", "date"), new Date(2026, 0, 15)],
+ ] as const) {
+ const { container } = renderCell(column, value, "");
+ expect(markTexts(container)).toEqual([]);
+ }
+ });
+
+ it("renders no mark in the trigger of a long-string popout", () => {
+ const value = "x".repeat(60);
+ const { container } = renderCell(createColumn("string"), value, "xxx");
+ expect(markTexts(container)).toEqual([]);
+ });
+});
diff --git a/frontend/src/components/data-table/__tests__/search-highlight.test.tsx b/frontend/src/components/data-table/__tests__/search-highlight.test.tsx
new file mode 100644
index 0000000000..3db4143087
--- /dev/null
+++ b/frontend/src/components/data-table/__tests__/search-highlight.test.tsx
@@ -0,0 +1,109 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+import { render } from "@testing-library/react";
+import { describe, expect, it } from "vitest";
+import {
+ buildHighlightPattern,
+ findMatchRanges,
+ highlightMatches,
+ highlightRanges,
+} from "../search-highlight";
+
+function highlight(text: string, query: string) {
+ return highlightMatches(text, buildHighlightPattern(query));
+}
+
+function marksOf(node: React.ReactNode) {
+ const { container } = render(<span>{node}</span>);
+ return {
+ container,
+ marks: [...container.querySelectorAll("mark")].map((m) => m.textContent),
+ };
+}
+
+describe("buildHighlightPattern", () => {
+ it("returns undefined for an empty or missing query", () => {
+ expect(buildHighlightPattern("")).toBeUndefined();
+ expect(buildHighlightPattern(undefined)).toBeUndefined();
+ });
+
+ it("escapes regex metacharacters so the query matches literally", () => {
+ const { marks } = marksOf(highlight("a.b a-b (x)", ".b"));
+ expect(marks).toEqual([".b"]);
+ expect(marksOf(highlight("f(x)", "(x)")).marks).toEqual(["(x)"]);
+ expect(marksOf(highlight("C and C++", "c++")).marks).toEqual(["C++"]);
+ });
+});
+
+describe("highlightMatches", () => {
+ it("returns the input unchanged without a pattern", () => {
+ expect(highlightMatches("Alice Smith", undefined)).toBe("Alice Smith");
+ });
+
+ it("returns the input unchanged when there is no match", () => {
+ expect(highlight("Alice Smith", "zzz")).toBe("Alice Smith");
+ });
+
+ it("returns the input unchanged when the query is longer than the text", () => {
+ expect(highlight("ab", "abc")).toBe("ab");
+ });
+
+ it("wraps a single match and keeps the surrounding text", () => {
+ const { container, marks } = marksOf(highlight("Alice Smith", "ce S"));
+ expect(marks).toEqual(["ce S"]);
+ expect(container.textContent).toBe("Alice Smith");
+ });
+
+ it("matches case-insensitively and keeps the original casing", () => {
+ const { marks } = marksOf(highlight("Alice Smith", "smi"));
+ expect(marks).toEqual(["Smi"]);
+ });
+
+ it("wraps every occurrence", () => {
+ const { container, marks } = marksOf(highlight("a-A-a", "a"));
+ expect(marks).toEqual(["a", "A", "a"]);
+ expect(container.textContent).toBe("a-A-a");
+ });
+
+ it("produces no empty segments for matches at the edges", () => {
+ const segments = highlight("xax", "x") as React.ReactNode[];
+ expect(Array.isArray(segments)).toBe(true);
+ expect(segments).toHaveLength(3);
+ expect(segments[1]).toBe("a");
+ });
+
+ it("is safe to reuse one global pattern across calls", () => {
+ const pattern = buildHighlightPattern("a");
+ expect(marksOf(highlightMatches("aa", pattern)).marks).toEqual(["a", "a"]);
+ expect(marksOf(highlightMatches("aa", pattern)).marks).toEqual(["a", "a"]);
+ });
+});
+
+describe("Unicode case folding", () => {
+ it("folds the Kelvin sign to k like the backend engines", () => {
+ expect(marksOf(highlight("K", "k")).marks).toEqual(["K"]);
+ });
+
+ it("folds every Greek sigma form", () => {
+ expect(marksOf(highlight("ΟΣ ος οσ", "σ")).marks).toEqual(["Σ", "ς", "σ"]);
+ });
+});
+
+describe("highlightRanges", () => {
+ it("applies shared ranges to a segment at an offset", () => {
+ const ranges = findMatchRanges(
+ "see https://x",
+ buildHighlightPattern("see https"),
+ );
+ expect(ranges).toEqual([[0, 9]]);
+ const { marks: textMarks } = marksOf(highlightRanges("see ", ranges, 0));
+ expect(textMarks).toEqual(["see "]);
+ const { marks: linkMarks } = marksOf(
+ highlightRanges("https://x", ranges, 4),
+ );
+ expect(linkMarks).toEqual(["https"]);
+ });
+
+ it("returns the segment unchanged when no range overlaps it", () => {
+ expect(highlightRanges("zzz", [[10, 12]], 0)).toBe("zzz");
+ });
+});
diff --git a/frontend/src/components/data-table/__tests__/url-detector.test.tsx b/frontend/src/components/data-table/__tests__/url-detector.test.tsx
index ca8bf17005..a16b0af02b 100644
--- a/frontend/src/components/data-table/__tests__/url-detector.test.tsx
+++ b/frontend/src/components/data-table/__tests__/url-detector.test.tsx
@@ -2,6 +2,7 @@
import { fireEvent, render, screen } from "@testing-library/react";
import { describe, expect, it, vi } from "vitest";
import { parseContent } from "@/utils/url-parser";
+import { buildHighlightPattern } from "../search-highlight";
import { isMarkdown, UrlDetector } from "../url-detector";
describe("UrlDetector", () => {
@@ -201,3 +202,76 @@ describe("isMarkdown", () => {
expect(isMarkdown("Visit [marimo](https://marimo.io)")).toBe(true);
});
});
+
+describe("UrlDetector with highlightPattern", () => {
+ it("wraps a text match in a mark", () => {
+ const { container } = render(
+ <UrlDetector
+ parts={parseContent("Alice Smith")}
+ highlightPattern={buildHighlightPattern("smi")}
+ />,
+ );
+ const marks = container.querySelectorAll("mark");
+ expect(marks).toHaveLength(1);
+ expect(marks[0].textContent).toBe("Smi");
+ expect(container.textContent).toBe("Alice Smith");
+ });
+
+ it("wraps a match inside a link label", () => {
+ const { container } = render(
+ <UrlDetector
+ parts={parseContent("see https://marimo.io/docs")}
+ highlightPattern={buildHighlightPattern("marimo")}
+ />,
+ );
+ const link = container.querySelector("a");
+ expect(link).not.toBeNull();
+ const mark = link?.querySelector("mark");
+ expect(mark?.textContent).toBe("marimo");
+ expect(link).toHaveAttribute("href", "https://marimo.io/docs");
+ });
+
+ it("renders no mark for an empty query", () => {
+ const { container } = render(
+ <UrlDetector
+ parts={parseContent("Alice Smith")}
+ highlightPattern={buildHighlightPattern("")}
+ />,
+ );
+ expect(container.querySelector("mark")).toBeNull();
+ });
+});
+
+describe("UrlDetector highlight across part boundaries", () => {
+ it("marks a query that spans a text part and a link", () => {
+ const { container } = render(
+ <UrlDetector
+ parts={parseContent("see https://marimo.io/docs")}
+ highlightPattern={buildHighlightPattern("see https")}
+ />,
+ );
+ const marks = [...container.querySelectorAll("mark")].map(
+ (m) => m.textContent,
+ );
+ expect(marks).toEqual(["see ", "https"]);
+ const link = container.querySelector("a");
+ expect(link?.querySelector("mark")?.textContent).toBe("https");
+ expect(link).toHaveAttribute("href", "https://marimo.io/docs");
+ expect(container.textContent).toBe("see https://marimo.io/docs");
+ });
+
+ it("marks the fallback link when an image fails to load", () => {
+ const { container } = render(
+ <UrlDetector
+ parts={parseContent("https://example.com/image.png")}
+ highlightPattern={buildHighlightPattern("image")}
+ />,
+ );
+ const img = container.querySelector("img");
+ expect(img).not.toBeNull();
+ fireEvent.error(img as HTMLImageElement);
+ const link = container.querySelector("a");
+ expect(link).toHaveAttribute("href", "https://example.com/image.png");
+ expect(link?.querySelector("mark")?.textContent).toBe("image");
+ });
+});
diff --git a/frontend/src/components/data-table/columns.tsx b/frontend/src/components/data-table/columns.tsx
index 6c3ab4c253..35c31e7ff0 100644
--- a/frontend/src/components/data-table/columns.tsx
+++ b/frontend/src/components/data-table/columns.tsx
@@ -41,6 +41,7 @@ import {
isNumericType,
} from "./types";
import { SentinelCell, WhitespaceMarkers } from "./sentinel-cell";
+import { highlightMatches } from "./search-highlight";
import { detectSentinel, splitLeadingTrailingWhitespace } from "./utils";
import { uniformSample } from "./uniformSample";
import { MarkdownUrlDetector, UrlDetector } from "./url-detector";
@@ -278,7 +279,7 @@ export function generateColumns<T>({
);
},
- cell: ({ column, renderValue, getValue, cell }) => {
+ cell: ({ column, renderValue, getValue, cell, table }) => {
function selectCell() {
if (selection !== "single-cell" && selection !== "multi-cell") {
return;
@@ -310,6 +311,7 @@ export function generateColumns<T>({
getValue,
selectCell,
cellStyles,
+ highlightPattern: table.options.meta?.highlightPattern,
});
// Row headers are bold
@@ -586,12 +588,14 @@ function renderDate({
dtype,
displayValue,
locale,
+ highlightPattern,
}: {
value: Date;
dataType?: DataType;
dtype?: string;
displayValue?: string;
locale: string;
+ highlightPattern?: RegExp;
}): React.ReactNode {
const type = dataType === "date" ? "date" : "datetime";
const timezone = extractTimezone(dtype);
@@ -600,7 +604,7 @@ function renderDate({
return (
<DatePopover date={value} type={type}>
- {exactValue}
+ {highlightMatches(exactValue, highlightPattern)}
</DatePopover>
);
}
@@ -611,12 +615,14 @@ export function renderCellValue<TData, TValue>({
getValue,
selectCell,
cellStyles,
+ highlightPattern,
}: {
column: Column<TData, TValue>;
renderValue: () => TValue | null;
getValue: () => TValue;
selectCell?: () => void;
cellStyles?: string;
+ highlightPattern?: RegExp;
}) {
const value = getValue();
const format = column.getColumnFormatting?.();
@@ -626,6 +632,28 @@ export function renderCellValue<TData, TValue>({
const isWrapped = column.getColumnWrapping?.() === "wrap";
+ const textCell = (text: string) => (
+ <div onClick={selectCell} className={cellStyles}>
+ {highlightMatches(text, highlightPattern)}
+ </div>
+ );
+ const dateCell = (date: Date, displayValue?: string) => (
+ <div onClick={selectCell} className={cellStyles}>
+ <WithLocale>
+ {(locale) =>
+ renderDate({
+ value: date,
+ dataType,
+ dtype,
+ displayValue,
+ locale,
+ highlightPattern,
+ })
+ }
+ </WithLocale>
+ </div>
+ );
+
// Sentinel values (null, whitespace, NaN, Infinity, NaT) rendered specially.
// Empty strings are left as-is
const sentinel = detectSentinel(value, dataType, dtype);
@@ -641,23 +669,10 @@ export function renderCellValue<TData, TValue>({
try {
const date = new Date(value);
if (!format || !isValid(date)) {
- return (
- <div onClick={selectCell} className={cellStyles}>
- {value}
- </div>
- );
+ return textCell(value);
}
- const displayValue = String(column.applyColumnFormatting(value));
- return (
- <div onClick={selectCell} className={cellStyles}>
- <WithLocale>
- {(locale) =>
- renderDate({ value: date, dataType, dtype, displayValue, locale })
- }
- </WithLocale>
- </div>
- );
+ return dateCell(date, String(column.applyColumnFormatting(value)));
} catch (error) {
Logger.error("Error parsing datetime, fallback to string", error);
}
@@ -673,17 +688,9 @@ export function renderCellValue<TData, TValue>({
}
// e.g. 2010-10-07 17:15:00
- const displayValue = format
- ? String(column.applyColumnFormatting(value))
- : undefined;
- return (
- <div onClick={selectCell} className={cellStyles}>
- <WithLocale>
- {(locale) =>
- renderDate({ value, dataType, dtype, displayValue, locale })
- }
- </WithLocale>
- </div>
+ return dateCell(
+ value,
+ format ? String(column.applyColumnFormatting(value)) : undefined,
);
}
@@ -729,7 +736,7 @@ export function renderCellValue<TData, TValue>({
className={cn(cellStyles, isWrapped && COLUMN_WRAPPING_STYLES)}
>
<WhitespaceMarkers value={leading} />
- <UrlDetector parts={parts} />
+ <UrlDetector parts={parts} highlightPattern={highlightPattern} />
<WhitespaceMarkers value={trailing} />
</div>
);
@@ -755,11 +762,7 @@ export function renderCellValue<TData, TValue>({
}
if (format) {
- return (
- <div onClick={selectCell} className={cellStyles}>
- {column.applyColumnFormatting(value)}
- </div>
- );
+ return textCell(String(column.applyColumnFormatting(value)));
}
// Format to the correct locale
@@ -769,26 +772,19 @@ export function renderCellValue<TData, TValue>({
<LocaleNumber
value={value}
minFractionDigits={column.columnDef.meta?.minFractionDigits}
+ highlightPattern={highlightPattern}
/>
</div>
);
}
if (typeof value === "boolean") {
- return (
- <div onClick={selectCell} className={cellStyles}>
- {value ? "True" : "False"}
- </div>
- );
+ return textCell(value ? "True" : "False");
}
if (isPrimitiveOrNullish(value)) {
const rendered = renderValue();
- return (
- <div onClick={selectCell} className={cellStyles}>
- {rendered == null ? "" : String(rendered)}
- </div>
- );
+ return textCell(rendered == null ? "" : String(rendered));
}
const mimeValues = getMimeValues(value);
@@ -826,14 +822,16 @@ export function renderCellValue<TData, TValue>({
export const LocaleNumber = ({
value,
minFractionDigits,
+ highlightPattern,
}: {
value: number;
minFractionDigits?: number;
+ highlightPattern?: RegExp;
}) => {
const { locale } = useLocale();
const format = useNumberFormatter({
minimumFractionDigits: minFractionDigits,
maximumFractionDigits: maxFractionalDigits(locale),
});
- return format.format(value);
+ return highlightMatches(format.format(value), highlightPattern);
};
diff --git a/frontend/src/components/data-table/data-table.tsx b/frontend/src/components/data-table/data-table.tsx
index c516c897fd..c54b86aa16 100644
--- a/frontend/src/components/data-table/data-table.tsx
+++ b/frontend/src/components/data-table/data-table.tsx
@@ -58,6 +58,7 @@ import { useColumnPinning } from "./hooks/use-column-pinning";
import { useScrollContainerHeight } from "./hooks/use-scroll-container-height";
import { CellSelectionProvider } from "./range-focus/provider";
import { DataTableBody, renderTableHeader } from "./renderers";
+import { buildHighlightPattern } from "./search-highlight";
import { TableBottomBar } from "./TableBottomBar";
import { TableTopBar } from "./TableTopBar";
import {
@@ -231,6 +232,11 @@ const DataTableInternal = <TData,>({
return idx + offset;
}
+ const highlightPattern = React.useMemo(
+ () => buildHighlightPattern(searchQuery),
+ [searchQuery],
+ );
+
const table = useReactTable<TData>({
_features: [
ColumnPinning,
@@ -245,7 +251,7 @@ const DataTableInternal = <TData,>({
],
data,
columns,
- meta: { rawData },
+ meta: { rawData, highlightPattern },
getCoreRowModel: getCoreRowModel(),
// pagination
rowCount: totalRows === "too_many" ? undefined : totalRows,
diff --git a/frontend/src/components/data-table/search-highlight.tsx b/frontend/src/components/data-table/search-highlight.tsx
new file mode 100644
index 0000000000..dd77de5da1
--- /dev/null
+++ b/frontend/src/components/data-table/search-highlight.tsx
@@ -0,0 +1,79 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import type { ReactNode } from "react";
+
+/** Half-open `[start, end)` offsets into a string. */
+export type MatchRange = readonly [start: number, end: number];
+
+/**
+ * Build the pattern that finds `query` in a display string. Returns
+ * `undefined` for an empty query. The query is matched as a literal,
+ * case-insensitive substring, which mirrors how the backend selects rows.
+ * The `u` flag selects Unicode simple case folding, the same folding the
+ * backend regex engines use.
+ */
+export function buildHighlightPattern(query?: string): RegExp | undefined {
+ if (!query) {
+ return undefined;
+ }
+ const escaped = query.replace(/[$()*+.?[\\\]^{|}]/g, "\\$&");
+ return new RegExp(escaped, "giu");
+}
+
+/** Offsets of every match of `pattern` in `text`. */
+export function findMatchRanges(text: string, pattern?: RegExp): MatchRange[] {
+ if (!pattern) {
+ return [];
+ }
+ const ranges: MatchRange[] = [];
+ for (const match of text.matchAll(pattern)) {
+ ranges.push([match.index, match.index + match[0].length]);
+ }
+ return ranges;
+}
+
+/**
+ * Wrap the parts of `text` covered by `ranges` in `<mark>` elements.
+ * `ranges` are offsets into a larger string in which `text` starts at
+ * `offset`, so one set of ranges can be shared across adjacent segments.
+ * Returns `text` unchanged when no range overlaps it.
+ */
+export function highlightRanges(
+ text: string,
+ ranges: readonly MatchRange[],
+ offset = 0,
+): ReactNode {
+ const segments: ReactNode[] = [];
+ let cursor = 0;
+ for (const [rangeStart, rangeEnd] of ranges) {
+ const start = Math.max(rangeStart - offset, cursor);
+ const end = Math.min(rangeEnd - offset, text.length);
+ if (end <= start) {
+ continue;
+ }
+ if (start > cursor) {
+ segments.push(text.slice(cursor, start));
+ }
+ segments.push(
+ <mark key={start} className="bg-search-highlight text-inherit">
+ {text.slice(start, end)}
+ </mark>,
+ );
+ cursor = end;
+ }
+ if (segments.length === 0) {
+ return text;
+ }
+ if (cursor < text.length) {
+ segments.push(text.slice(cursor));
+ }
+ return segments;
+}
+
+/**
+ * Wrap every match of `pattern` in `text` in a `<mark>` element. Returns
+ * `text` unchanged when `pattern` is absent or does not match.
+ */
+export function highlightMatches(text: string, pattern?: RegExp): ReactNode {
+ return highlightRanges(text, findMatchRanges(text, pattern));
+}
diff --git a/frontend/src/components/data-table/types.ts b/frontend/src/components/data-table/types.ts
index 9741a57058..8eefd425f4 100644
--- a/frontend/src/components/data-table/types.ts
+++ b/frontend/src/components/data-table/types.ts
@@ -6,6 +6,7 @@ import type { DataType } from "@/core/kernel/messages";
declare module "@tanstack/react-table" {
interface TableMeta<TData extends RowData> {
rawData?: TData[]; // raw data for filtering/copying (present only if format_mapping is provided)
+ highlightPattern?: RegExp; // built from the committed search query that produced the current rows
}
}
diff --git a/frontend/src/components/data-table/url-detector.tsx b/frontend/src/components/data-table/url-detector.tsx
index 38ab5e5bb9..177b126592 100644
--- a/frontend/src/components/data-table/url-detector.tsx
+++ b/frontend/src/components/data-table/url-detector.tsx
@@ -1,7 +1,7 @@
/* Copyright 2026 Marimo. All rights reserved. */
import { marked } from "marked";
-import { useState } from "react";
+import { Fragment, type ReactNode, useState } from "react";
import { MarkdownRenderer } from "@/components/markdown/markdown-renderer";
import {
Popover,
@@ -10,13 +10,20 @@ import {
} from "@/components/ui/popover";
import { Events } from "@/utils/events";
import type { ContentPart } from "@/utils/url-parser";
+import { findMatchRanges, highlightRanges } from "./search-highlight";
-const ImageWithFallback = ({ url }: { url: string }) => {
+const ImageWithFallback = ({
+ url,
+ fallbackLabel,
+}: {
+ url: string;
+ fallbackLabel?: ReactNode;
+}) => {
const [error, setError] = useState(false);
const [open, setOpen] = useState(false);
if (error) {
- return <URLAnchor url={url} />;
+ return <URLAnchor url={url}>{fallbackLabel}</URLAnchor>;
}
return (
@@ -93,21 +100,54 @@ export const MarkdownUrlDetector = ({
return <UrlDetector parts={parts} />;
};
-export const UrlDetector = ({ parts }: { parts: ContentPart[] }) => {
+export const UrlDetector = ({
+ parts,
+ highlightPattern,
+}: {
+ parts: ContentPart[];
+ highlightPattern?: RegExp;
+}) => {
+ // Match against the whole string so a query that spans a text part and
+ // a link is still marked. Each part then takes its slice of the ranges.
+ const ranges = highlightPattern
+ ? findMatchRanges(parts.map(partText).join(""), highlightPattern)
+ : [];
+
+ let offset = 0;
const markup = parts.map((part, idx) => {
+ const text = partText(part);
+ const label = highlightRanges(text, ranges, offset);
+ offset += text.length;
+
if (part.type === "url") {
- return <URLAnchor key={idx} url={part.url} />;
+ return (
+ <URLAnchor key={idx} url={part.url}>
+ {label}
+ </URLAnchor>
+ );
}
if (part.type === "image") {
- return <ImageWithFallback key={idx} url={part.url} />;
+ return (
+ <ImageWithFallback key={idx} url={part.url} fallbackLabel={label} />
+ );
}
- return part.value;
+ return <Fragment key={idx}>{label}</Fragment>;
});
return markup;
};
-const URLAnchor = ({ url }: { url: string }) => {
+function partText(part: ContentPart): string {
+ return part.type === "text" ? part.value : part.url;
+}
+
+const URLAnchor = ({
+ url,
+ children,
+}: {
+ url: string;
+ children?: ReactNode;
+}) => {
return (
<a
href={url}
@@ -116,7 +156,7 @@ const URLAnchor = ({ url }: { url: string }) => {
onClick={Events.stopPropagation()}
className="text-link hover:underline"
>
- {url}
+ {children ?? url}
</a>
);
};
diff --git a/frontend/src/css/globals.css b/frontend/src/css/globals.css
index ac592f32cd..1399618eea 100644
--- a/frontend/src/css/globals.css
+++ b/frontend/src/css/globals.css
@@ -92,6 +92,7 @@
--action-hover: var(--yellow-10, #ffdc00);
--action-border: var(--yellow-11, #9e6c00);
--action-foreground: var(--yellow-12, #473b1f);
+ --search-highlight: var(--yellow-4, #fff394);
--link: light-dark(hsl(211deg 90% 42%), hsl(211deg 90% 62%));
--link-visited: light-dark(hsl(272deg 51% 54%), hsl(272deg 51% 74%));
--stale: hsl(42deg 56% 44% / 25%);
@@ -140,6 +141,7 @@
--action-hover: var(--yellow-7, #665417);
--action-border: var(--yellow-11, #f5e147);
--action-foreground: var(--yellow-12, #f6eeb4);
+ --search-highlight: var(--yellow-6, #524202);
--stale: hsl(54deg 100% 86.7% / 25%);
}
}
diff --git a/frontend/tailwind.config.cjs b/frontend/tailwind.config.cjs
index 6cc5cd9583..309c67b588 100644
--- a/frontend/tailwind.config.cjs
+++ b/frontend/tailwind.config.cjs
@@ -90,6 +90,10 @@ module.exports = {
foreground:
"color-mix(in srgb, var(--action-foreground), transparent calc((1 - <alpha-value>) * 100%))",
},
+ "search-highlight": {
+ DEFAULT:
+ "color-mix(in srgb, var(--search-highlight), transparent calc((1 - <alpha-value>) * 100%))",
+ },
popover: {
DEFAULT:
"color-mix(in srgb, var(--popover), transparent calc((1 - <alpha-value>) * 100%))",
diff --git a/marimo/_plugins/ui/_impl/tables/narwhals_table.py b/marimo/_plugins/ui/_impl/tables/narwhals_table.py
index 1693142bdc..97a3acb8a1 100644
--- a/marimo/_plugins/ui/_impl/tables/narwhals_table.py
+++ b/marimo/_plugins/ui/_impl/tables/narwhals_table.py
@@ -35,6 +35,7 @@ from marimo._plugins.ui._impl.tables.table_manager import (
TableCell,
TableCoordinate,
TableManager,
+ regex_literal,
)
from marimo._sql.sql_quoting import quote_sql_identifier
from marimo._utils.narwhals_utils import (
@@ -454,7 +455,7 @@ class NarwhalsTableManager(
return self.with_new_data(self.data[offset : offset + count])
def search(self, query: str) -> TableManager[Any]:
- query = query.lower()
+ pattern = f"(?i){regex_literal(query)}"
expressions: list[Any] = []
for column, dtype in self.nw_schema.items():
@@ -465,7 +466,7 @@ class NarwhalsTableManager(
if is_narwhals_string_type(dtype):
# Cast to string as pandas may fail for certain values
expressions.append(
- nw.col(column).cast(nw.String).str.contains(f"(?i){query}")
+ nw.col(column).cast(nw.String).str.contains(pattern)
)
elif dtype == nw.List(nw.String):
# TODO: Narwhals doesn't support list.contains
@@ -479,7 +480,7 @@ class NarwhalsTableManager(
or dtype == nw.Boolean
):
expressions.append(
- nw.col(column).cast(nw.String).str.contains(f"(?i){query}")
+ nw.col(column).cast(nw.String).str.contains(pattern)
)
if not expressions:
diff --git a/marimo/_plugins/ui/_impl/tables/polars_table.py b/marimo/_plugins/ui/_impl/tables/polars_table.py
index 989542500a..25e5d6a1c0 100644
--- a/marimo/_plugins/ui/_impl/tables/polars_table.py
+++ b/marimo/_plugins/ui/_impl/tables/polars_table.py
@@ -22,6 +22,7 @@ from marimo._plugins.ui._impl.tables.table_manager import (
FieldType,
TableManager,
TableManagerFactory,
+ regex_literal,
)
LOGGER = _loggers.marimo_logger()
@@ -263,16 +264,18 @@ class PolarsTableManagerFactory(TableManagerFactory):
return isinstance(value, (pl.DataFrame, pl.LazyFrame))
def search(self, query: str) -> PolarsTableManager:
- query = query.lower()
+ pattern = f"(?i){regex_literal(query)}"
expressions: list[pl.Expr] = []
for column, dtype in self.schema.items():
if dtype == pl.String:
expressions.append(
- pl.col(column).str.contains(f"(?i){query}")
+ pl.col(column).str.contains(pattern)
)
elif dtype == pl.List(pl.Utf8):
- expressions.append(pl.col(column).list.contains(query))
+ expressions.append(
+ pl.col(column).list.contains(query.lower())
+ )
elif (
dtype.is_numeric()
or dtype.is_temporal()
@@ -281,7 +284,7 @@ class PolarsTableManagerFactory(TableManagerFactory):
expressions.append(
pl.col(column)
.cast(pl.String)
- .str.contains(f"(?i){query}")
+ .str.contains(pattern)
)
if not expressions:
diff --git a/marimo/_plugins/ui/_impl/tables/table_manager.py b/marimo/_plugins/ui/_impl/tables/table_manager.py
index cc4c5d2619..87b02fe436 100644
--- a/marimo/_plugins/ui/_impl/tables/table_manager.py
+++ b/marimo/_plugins/ui/_impl/tables/table_manager.py
@@ -34,6 +34,20 @@ RowId = str
FieldType = DataType
FieldTypes = list[tuple[ColumnName, tuple[FieldType, ExternalDataType]]]
+_REGEX_METACHARACTERS = frozenset(r"\.^$|?*+()[]{}")
+
+
+def regex_literal(text: str) -> str:
+ """Escape `text` so a regex engine matches it as a literal.
+
+ Only the metacharacters that Python `re`, Rust `regex`, and RE2 all
+ treat as special are escaped. `re.escape` also escapes spaces and
+ punctuation such as `#`, which some of those engines reject.
+ """
+ return "".join(
+ f"\\{char}" if char in _REGEX_METACHARACTERS else char for char in text
+ )
+
class TableCoordinate(NamedTuple):
row_id: int | str
diff --git a/tests/_plugins/ui/_impl/tables/test_ibis_table.py b/tests/_plugins/ui/_impl/tables/test_ibis_table.py
index 96accb5df6..c8232a8e09 100644
--- a/tests/_plugins/ui/_impl/tables/test_ibis_table.py
+++ b/tests/_plugins/ui/_impl/tables/test_ibis_table.py
@@ -309,13 +309,30 @@ class TestIbisTableManagerFactory(unittest.TestCase):
manager = self.factory.create()(table)
assert manager.get_field_type("A") == ("unknown", "unknown")
- def test_search_with_regex(self) -> None:
+ def test_search_treats_query_as_literal(self) -> None:
import ibis
- table = ibis.memtable({"A": ["apple", "banana", "cherry"]})
+ table = ibis.memtable(
+ {
+ "A": [
+ "apple",
+ "banana",
+ "C++",
+ "c++ guide",
+ "ΟΣ",
+ "ος",
+ "οσ",
+ "İstanbul",
+ ]
+ }
+ )
manager = self.factory.create()(table)
- result = manager.search("^[ab]")
- assert result.get_num_rows() == 2
+ assert manager.search("^[ab]").get_num_rows() == 0
+ assert manager.search("c++").get_num_rows() == 2
+ assert manager.search("C++ G").get_num_rows() == 1
+ assert manager.search("a.b").get_num_rows() == 0
+ assert manager.search("Σ").get_num_rows() == 3
+ assert manager.search("İ").get_num_rows() == 1
def test_sort_values_with_nulls(self) -> None:
import ibis
diff --git a/tests/_plugins/ui/_impl/tables/test_narwhals.py b/tests/_plugins/ui/_impl/tables/test_narwhals.py
index 696c87af7e..764b8da93a 100644
--- a/tests/_plugins/ui/_impl/tables/test_narwhals.py
+++ b/tests/_plugins/ui/_impl/tables/test_narwhals.py
@@ -1436,12 +1436,29 @@ class TestOldDates:
@pytest.mark.skipif(not HAS_DEPS, reason="optional dependencies not installed")
@pytest.mark.parametrize(
"df",
- create_dataframes({"A": ["apple", "banana", "cherry"]}),
+ create_dataframes(
+ {
+ "A": [
+ "apple",
+ "banana",
+ "C++",
+ "c++ guide",
+ "ΟΣ",
+ "ος",
+ "οσ",
+ "İstanbul",
+ ]
+ }
+ ),
)
-def test_search_with_regex(df: Any) -> None:
+def test_search_treats_query_as_literal(df: Any) -> None:
manager = NarwhalsTableManager.from_dataframe(df)
- result = manager.search("^[ab]")
- assert result.get_num_rows() == 2
+ assert manager.search("^[ab]").get_num_rows() == 0
+ assert manager.search("c++").get_num_rows() == 2
+ assert manager.search("C++ G").get_num_rows() == 1
+ assert manager.search("a.b").get_num_rows() == 0
+ assert manager.search("Σ").get_num_rows() == 3
+ assert manager.search("İ").get_num_rows() == 1
@pytest.mark.skipif(not HAS_DEPS, reason="optional dependencies not installed")
diff --git a/tests/_plugins/ui/_impl/tables/test_pandas_table.py b/tests/_plugins/ui/_impl/tables/test_pandas_table.py
index edf9bbe180..19d98a2a2d 100644
--- a/tests/_plugins/ui/_impl/tables/test_pandas_table.py
+++ b/tests/_plugins/ui/_impl/tables/test_pandas_table.py
@@ -1850,11 +1850,28 @@ class TestPandasTableManager(unittest.TestCase):
manager = self.factory.create()(df)
assert manager.get_field_type("A") == ("string", "object")
- def test_search_with_regex(self) -> None:
- df = pd.DataFrame({"A": ["apple", "banana", "cherry"]})
+ def test_search_treats_query_as_literal(self) -> None:
+ df = pd.DataFrame(
+ {
+ "A": [
+ "apple",
+ "banana",
+ "C++",
+ "c++ guide",
+ "ΟΣ",
+ "ος",
+ "οσ",
+ "İstanbul",
+ ]
+ }
+ )
manager = self.factory.create()(df)
- result = manager.search("^[ab]")
- assert result.get_num_rows() == 2
+ assert manager.search("^[ab]").get_num_rows() == 0
+ assert manager.search("c++").get_num_rows() == 2
+ assert manager.search("C++ G").get_num_rows() == 1
+ assert manager.search("a.b").get_num_rows() == 0
+ assert manager.search("Σ").get_num_rows() == 3
+ assert manager.search("İ").get_num_rows() == 1
def test_sort_values_with_nulls(self) -> None:
df = pd.DataFrame({"A": [3, 1, None, 2]})
diff --git a/tests/_plugins/ui/_impl/tables/test_polars_table.py b/tests/_plugins/ui/_impl/tables/test_polars_table.py
index e650298de6..c35b34e14e 100644
--- a/tests/_plugins/ui/_impl/tables/test_polars_table.py
+++ b/tests/_plugins/ui/_impl/tables/test_polars_table.py
@@ -844,13 +844,30 @@ class TestPolarsTableManagerFactory(unittest.TestCase):
manager = self.factory.create()(df)
assert manager.get_field_type("A") == ("string", "str")
- def test_search_with_regex(self) -> None:
+ def test_search_treats_query_as_literal(self) -> None:
import polars as pl
- df = pl.DataFrame({"A": ["apple", "banana", "cherry"]})
+ df = pl.DataFrame(
+ {
+ "A": [
+ "apple",
+ "banana",
+ "C++",
+ "c++ guide",
+ "ΟΣ",
+ "ος",
+ "οσ",
+ "İstanbul",
+ ]
+ }
+ )
manager = self.factory.create()(df)
- result = manager.search("^[ab]")
- assert result.get_num_rows() == 2
+ assert manager.search("^[ab]").get_num_rows() == 0
+ assert manager.search("c++").get_num_rows() == 2
+ assert manager.search("C++ G").get_num_rows() == 1
+ assert manager.search("a.b").get_num_rows() == 0
+ assert manager.search("Σ").get_num_rows() == 3
+ assert manager.search("İ").get_num_rows() == 1
def test_search_wide_dataframe(self) -> None:
"""Regression test: search must not crash on wide tables (GitHub #8449)."""