Skip to content

🪢 Open source agent evals & observability: Trace, evaluate, and improve LLM applications with one open platform.

refactor(dashboards): Migrate WidgetForm to use design system (#18000)

Ben Bachemc53e6c6d5eb7
diff --git a/web/src/__tests__/detail-page-route-params.clienttest.tsx b/web/src/__tests__/detail-page-route-params.clienttest.tsx
index a147aadd13..195b05762c 100644
--- a/web/src/__tests__/detail-page-route-params.clienttest.tsx
+++ b/web/src/__tests__/detail-page-route-params.clienttest.tsx
@@ -27,7 +27,7 @@ vi.mock("@/src/features/events/hooks/useReadPath", () => ({
}));
vi.mock("@/src/features/widgets", () => ({
- WidgetForm: ({ projectId }: { projectId: string }) => (
+ ConnectedWidgetForm: ({ projectId }: { projectId: string }) => (
<div data-testid="widget-form">{projectId}</div>
),
}));
diff --git a/web/src/components/DashboardDateRangeDropdown.tsx b/web/src/components/DashboardDateRangeDropdown.tsx
deleted file mode 100644
index bef5ba701a..0000000000
--- a/web/src/components/DashboardDateRangeDropdown.tsx
+++ /dev/null
@@ -1,146 +0,0 @@
-import * as React from "react";
-import { addMinutes } from "date-fns";
-import {
- Select,
- SelectContent,
- SelectItem,
- SelectTrigger,
- SelectValue,
-} from "@/src/components/ui/select";
-
-import {
- dashboardDateRangeAggregationSettings,
- DASHBOARD_AGGREGATION_PLACEHOLDER,
- type DashboardDateRangeOptions,
- DASHBOARD_AGGREGATION_OPTIONS,
- type DashboardDateRange,
- isDashboardDateRangeOptionAvailable,
- getAbbreviatedTimeRange,
- getTimeRangeLabel,
-} from "@/src/utils/date-range-utils";
-import { useEntitlementLimit } from "@/src/features/entitlements";
-import { useMemo } from "react";
-import { HoverCard } from "@/src/components/design-system/HoverCard/HoverCard";
-
-type BaseDateRangeDropdownProps<T> = {
- selectedOption: T;
- options: readonly T[];
- limitedOptions?: readonly T[];
- onSelectionChange: (value: T) => void;
-};
-
-const BaseDateRangeDropdown = <T extends string>({
- selectedOption,
- options,
- limitedOptions,
- onSelectionChange,
-}: BaseDateRangeDropdownProps<T>) => {
- return (
- <Select value={selectedOption} onValueChange={onSelectionChange}>
- <SelectTrigger className="hover:bg-accent hover:text-accent-foreground w-fit font-bold focus:ring-0 focus:ring-offset-0">
- <SelectValue placeholder="Select">
- <div className="flex items-center gap-2">
- <span className="bg-muted w-10 rounded px-1.5 py-0.5 text-center text-xs">
- {getAbbreviatedTimeRange(selectedOption)}
- </span>
- <span>{getTimeRangeLabel(selectedOption)}</span>
- </div>
- </SelectValue>
- </SelectTrigger>
- <SelectContent
- position="popper"
- defaultValue={60}
- className="**:data-checkmark:hidden"
- >
- {options.map((item) => {
- const itemObj = (
- <SelectItem
- key={item}
- value={item}
- disabled={limitedOptions?.includes(item)}
- className="pl-2"
- >
- <div className="flex items-center gap-2">
- <span className="bg-muted w-10 rounded px-1.5 py-0.5 text-center text-xs">
- {getAbbreviatedTimeRange(item)}
- </span>
- <span>{getTimeRangeLabel(item)}</span>
- </div>
- </SelectItem>
- );
- const isLimited = limitedOptions?.includes(item);
-
- return isLimited ? (
- <HoverCard
- openDelay={200}
- key={item}
- placement="right"
- content={
- <div className="w-60 p-3 text-sm">
- This time range is not available in your current plan.
- </div>
- }
- >
- {({ getTriggerProps }) => (
- <span {...getTriggerProps()}>{itemObj}</span>
- )}
- </HoverCard>
- ) : (
- itemObj
- );
- })}
- </SelectContent>
- </Select>
- );
-};
-
-type DashboardDateRangeDropdownProps = {
- selectedOption: DashboardDateRangeOptions;
- setDateRangeAndOption: (
- option: DashboardDateRangeOptions,
- date?: DashboardDateRange,
- ) => void;
-};
-
-export const DashboardDateRangeDropdown: React.FC<
- DashboardDateRangeDropdownProps
-> = ({ selectedOption, setDateRangeAndOption }) => {
- const lookbackLimit = useEntitlementLimit("data-access-days");
- const disabledOptions = useMemo(() => {
- return DASHBOARD_AGGREGATION_OPTIONS.filter(
- (option) =>
- !isDashboardDateRangeOptionAvailable({
- option,
- limitDays: lookbackLimit,
- }),
- );
- }, [lookbackLimit]);
-
- const onDropDownSelection = (value: DashboardDateRangeOptions) => {
- if (value === DASHBOARD_AGGREGATION_PLACEHOLDER) {
- setDateRangeAndOption(DASHBOARD_AGGREGATION_PLACEHOLDER, undefined);
- return;
- }
- const setting =
- dashboardDateRangeAggregationSettings[
- value as keyof typeof dashboardDateRangeAggregationSettings
- ];
- setDateRangeAndOption(value, {
- from: addMinutes(new Date(), -setting!.minutes!),
- to: new Date(),
- });
- };
-
- const options =
- selectedOption === DASHBOARD_AGGREGATION_PLACEHOLDER
- ? [...DASHBOARD_AGGREGATION_OPTIONS, DASHBOARD_AGGREGATION_PLACEHOLDER]
- : [...DASHBOARD_AGGREGATION_OPTIONS];
- return (
- <BaseDateRangeDropdown
- selectedOption={selectedOption}
- options={options}
- limitedOptions={disabledOptions}
- onSelectionChange={onDropDownSelection}
- />
- );
-};
diff --git a/web/src/components/date-picker.tsx b/web/src/components/date-picker.tsx
index c90a9ed390..d157f02eb2 100644
--- a/web/src/components/date-picker.tsx
+++ b/web/src/components/date-picker.tsx
@@ -18,11 +18,7 @@ import { type DateRange as RDPDateRange } from "react-day-picker";
import { useEffect, useMemo, useState, useCallback } from "react";
import { setBeginningOfDay, setEndOfDay } from "@/src/utils/dates";
import { TimePicker } from "@/src/components/ui/TimePicker";
-import { DashboardDateRangeDropdown } from "@/src/components/DashboardDateRangeDropdown";
import {
- DASHBOARD_AGGREGATION_PLACEHOLDER,
- type DashboardDateRangeOptions,
- type DashboardDateRange,
TIME_RANGES,
formatDateRange,
type TimeRange,
@@ -91,17 +87,6 @@ export function DatePicker({
);
}
-export type DatePickerWithRangeProps = {
- dateRange?: DashboardDateRange;
- className?: string;
- selectedOption: DashboardDateRangeOptions;
- disabled?: React.ComponentProps<typeof Calendar>["disabled"];
- setDateRangeAndOption: (
- option: DashboardDateRangeOptions,
- date?: DashboardDateRange,
- ) => void;
-};
-
/**
* Computes the next range for a calendar day click so the FIRST click always
* starts a new range and the SECOND click sets the end (LFE-8156). The decision
@@ -134,178 +119,6 @@ export function isRangeWithinMaxDuration(
return range.to.getTime() - range.from.getTime() <= maxDurationMs;
}
-export function DatePickerWithRange({
- className,
- dateRange,
- selectedOption,
- setDateRangeAndOption,
- disabled,
-}: DatePickerWithRangeProps) {
- const [internalDateRange, setInternalDateRange] = useState<
- RDPDateRange | undefined
- >(dateRange);
-
- useEffect(() => {
- setInternalDateRange(dateRange);
- }, [dateRange]);
-
- const setNewDateRange = (
- internalDateRange: RDPDateRange | undefined,
- newFromDate: Date | undefined,
- newToDate: Date | undefined,
- ): RDPDateRange | undefined => {
- return internalDateRange
- ? {
- from: newFromDate ?? internalDateRange.from,
- to: newToDate ?? internalDateRange.to,
- }
- : undefined;
- };
-
- const updateDashboardDateRange = (
- newRange: RDPDateRange | undefined,
- setDateRangeAndOption: (
- option: DashboardDateRangeOptions,
- date?: DashboardDateRange,
- ) => void,
- ) => {
- if (newRange && newRange.from && newRange.to) {
- const dashboardDateRange: DashboardDateRange = {
- from: newRange.from,
- to: newRange.to,
- };
- setDateRangeAndOption(
- DASHBOARD_AGGREGATION_PLACEHOLDER,
- dashboardDateRange,
- );
- }
- };
-
- const onCalendarSelection = (triggerDay?: Date) => {
- if (!triggerDay) return;
- const next = nextRangeForDayClick(internalDateRange, triggerDay);
- const newRange: RDPDateRange = {
- from: setBeginningOfDay(next.from),
- to: next.to ? setEndOfDay(next.to) : undefined,
- };
- setInternalDateRange(newRange);
- updateDashboardDateRange(newRange, setDateRangeAndOption);
- };
-
- const onStartTimeSelection = (date: Date | undefined) => {
- const newDateTime = combineDateAndTime(internalDateRange?.from, date);
- const newRange = setNewDateRange(
- internalDateRange,
- newDateTime,
- internalDateRange?.to,
- );
- setInternalDateRange(newRange);
- updateDashboardDateRange(newRange, setDateRangeAndOption);
- };
-
- const onEndTimeSelection = (date: Date | undefined) => {
- const newDateTime = combineDateAndTime(internalDateRange?.to, date);
- const newRange = setNewDateRange(
- internalDateRange,
- internalDateRange?.from,
- newDateTime,
- );
- setInternalDateRange(newRange);
- updateDashboardDateRange(newRange, setDateRangeAndOption);
- };
-
- return (
- <div
- className={cn("my-3 flex flex-col-reverse gap-2 md:flex-row", className)}
- >
- <Popover
- onOpenChange={(open) => {
- // Discard an abandoned first click on close so the next open starts
- // fresh instead of extending a left-over start (LFE-8156).
- if (!open && internalDateRange?.from && !internalDateRange.to) {
- setInternalDateRange(dateRange);
- }
- }}
- >
- <PopoverTrigger asChild>
- <Button
- id="date"
- variant="outline"
- className={cn(
- "w-[330px] justify-start text-left font-normal",
- !internalDateRange && "text-muted-foreground",
- )}
- >
- <CalendarIcon size="base" color="default" __rawClassName="mr-2" />
- {internalDateRange?.from ? (
- internalDateRange.to ? (
- <>
- {format(internalDateRange.from, "LLL dd, yy : HH:mm")} -{" "}
- {format(internalDateRange.to, "LLL dd, yy : HH:mm")}
- </>
- ) : (
- format(internalDateRange.from, "LLL dd, y")
- )
- ) : (
- <span>Pick a date</span>
- )}
- </Button>
- </PopoverTrigger>
- <PopoverContent className="w-auto p-0" align="start">
- <Calendar
- autoFocus={true}
- mode="range"
- // First click starts a new range, second sets the end — see
- // onCalendarSelection / nextRangeForDayClick (LFE-8156).
- defaultMonth={internalDateRange?.from}
- selected={internalDateRange}
- onSelect={(_, triggerDay) => onCalendarSelection(triggerDay)}
- numberOfMonths={2}
- // react-day-picker v9 lays the two months out in a flex row; on
- // narrow screens drop the second month rather than overriding that
- // flex (the old `[&>div]` rule stacked them vertically). LFE-8156.
- className="max-sm:[&>div>div:last-child]:hidden"
- disabled={disabled}
- />
- {/* Time pickers tune the boundaries of a *complete* range. During
- the partial range (after the first click, before the second) they
- are hidden: the End-time input would silently ignore edits, and a
- typed Start time would be clobbered by setBeginningOfDay on the
- next calendar click. See LFE-8156. */}
- {internalDateRange?.from && internalDateRange.to && (
- <div className="flex flex-col gap-2 border-t-2 py-1.5 sm:flex-row sm:gap-0">
- <div className="px-3">
- <p className="px-1 text-sm font-bold">
- Start<span className="hidden sm:inline"> time</span>
- </p>
- <TimePicker
- date={internalDateRange?.from}
- setDate={onStartTimeSelection}
- className="border-0 px-0 pt-1"
- />
- </div>
- <div className="px-3">
- <p className="px-1 text-sm font-bold">
- End<span className="hidden sm:inline"> time</span>
- </p>
- <TimePicker
- date={internalDateRange?.to}
- setDate={onEndTimeSelection}
- className="border-0 px-0 pt-1"
- />
- </div>
- </div>
- )}
- </PopoverContent>
- </Popover>
- <DashboardDateRangeDropdown
- selectedOption={selectedOption}
- setDateRangeAndOption={setDateRangeAndOption}
- />
- </div>
- );
-}
-
export type TimeRangePickerProps = {
timeRange?: TimeRange;
onTimeRangeChange: (timeRange: TimeRange) => void;
diff --git a/web/src/components/design-system/DateRangeInput/DateRangeInput.stories.tsx b/web/src/components/design-system/DateRangeInput/DateRangeInput.stories.tsx
new file mode 100644
index 0000000000..91ae69c998
--- /dev/null
+++ b/web/src/components/design-system/DateRangeInput/DateRangeInput.stories.tsx
@@ -0,0 +1,152 @@
+import { useState } from "react";
+import { expect, fireEvent, fn, userEvent, within } from "storybook/test";
+import preview from "../../../../.storybook/preview";
+import { DateRangeInput } from "./DateRangeInput";
+
+const meta = preview.meta({ component: DateRangeInput });
+
+export const Default = meta.story({
+ args: {
+ value: "last7Days",
+ customValue: "custom",
+ presets: [
+ { value: "last24Hours", label: "Last 24 hours" },
+ { value: "last7Days", label: "Last 7 days" },
+ { value: "last30Days", label: "Last 30 days" },
+ { value: "last90Days", label: "Last 90 days", disabled: true },
+ ],
+ onPresetChange: fn(),
+ onCustomChange: fn(),
+ },
+ render: (args) => {
+ const [value, setValue] = useState<string>(args.value);
+ const [range, setRange] = useState<{ from: Date; to: Date }>();
+
+ return (
+ <DateRangeInput
+ {...args}
+ value={value}
+ range={range}
+ onPresetChange={setValue}
+ onCustomChange={(next) => {
+ setRange(next);
+ setValue(args.customValue);
+ }}
+ />
+ );
+ },
+});
+
+export const TestPresetSelection = meta.story({
+ name: "(Test) Preset selection",
+ args: {
+ value: "last7Days",
+ customValue: "custom",
+ presets: [
+ { value: "last7Days", label: "Last 7 days" },
+ { value: "last30Days", label: "Last 30 days" },
+ ],
+ onPresetChange: fn(),
+ onCustomChange: fn(),
+ },
+ render: (args) => {
+ const [value, setValue] = useState<string>(args.value);
+ return <DateRangeInput {...args} value={value} onPresetChange={setValue} />;
+ },
+ play: async ({ canvasElement }) => {
+ const canvas = within(canvasElement);
+ const body = within(canvasElement.ownerDocument.body);
+ await userEvent.click(canvas.getByRole("button", { name: "Date range" }));
+ await expect(body.getByLabelText("Start time")).toBeDisabled();
+ await expect(body.getByLabelText("End time")).toBeDisabled();
+ await userEvent.click(body.getByRole("button", { name: "Last 30 days" }));
+ await expect(
+ canvas.getByRole("button", { name: "Date range" }),
+ ).toHaveTextContent("Last 30 days");
+ },
+});
+
+export const TestWholeDaySelection = meta.story({
+ name: "(Test) Whole day includes the final millisecond",
+ args: {
+ value: "custom",
+ customValue: "custom",
+ range: {
+ from: new Date(2026, 9, 20, 12),
+ to: new Date(2026, 9, 21, 12),
+ },
+ presets: [],
+ onPresetChange: fn(),
+ onCustomChange: fn(),
+ },
+ play: async ({ canvasElement, args }) => {
+ const canvas = within(canvasElement);
+ const body = within(canvasElement.ownerDocument.body);
+ await userEvent.click(canvas.getByRole("button", { name: "Date range" }));
+ const day = body.getByRole("button", {
+ name: /Tuesday, October 20th, 2026/,
+ });
+ await userEvent.click(day);
+ await userEvent.click(day);
+ await expect(args.onCustomChange).toHaveBeenLastCalledWith({
+ from: new Date(2026, 9, 20),
+ to: new Date(2026, 9, 20, 23, 59, 59, 999),
+ });
+ },
+});
+
+export const TestEndTimeOutsideRollingLookback = meta.story({
+ name: "(Test) End time remains editable outside the rolling lookback",
+ args: {
+ value: "custom",
+ customValue: "custom",
+ range: {
+ from: new Date(2026, 9, 20, 12),
+ to: new Date(2026, 9, 21, 12),
+ },
+ earliestDate: new Date(2026, 9, 20, 12, 0, 1),
+ presets: [],
+ onPresetChange: fn(),
+ onCustomChange: fn(),
+ },
+ play: async ({ canvasElement, args }) => {
+ const canvas = within(canvasElement);
+ const body = within(canvasElement.ownerDocument.body);
+ await userEvent.click(canvas.getByRole("button", { name: "Date range" }));
+ fireEvent.change(body.getByLabelText("End time"), {
+ target: { value: "13:00" },
+ });
+ await expect(args.onCustomChange).toHaveBeenLastCalledWith({
+ from: new Date(2026, 9, 20, 12),
+ to: new Date(2026, 9, 21, 13),
+ });
+ },
+});
+
+export const TestStartTimeClampedToEarliest = meta.story({
+ name: "(Test) Start time clamps to the earliest allowed timestamp",
+ args: {
+ value: "custom",
+ customValue: "custom",
+ range: {
+ from: new Date(2026, 9, 20, 12),
+ to: new Date(2026, 9, 21, 12),
+ },
+ earliestDate: new Date(2026, 9, 20, 11, 30, 1),
+ presets: [],
+ onPresetChange: fn(),
+ onCustomChange: fn(),
+ },
+ play: async ({ canvasElement, args }) => {
+ const canvas = within(canvasElement);
+ const body = within(canvasElement.ownerDocument.body);
+ await userEvent.click(canvas.getByRole("button", { name: "Date range" }));
+ fireEvent.change(body.getByLabelText("Start time"), {
+ target: { value: "10:00" },
+ });
+ await expect(args.onCustomChange).toHaveBeenLastCalledWith({
+ from: args.earliestDate,
+ to: new Date(2026, 9, 21, 12),
+ });
+ },
+});
diff --git a/web/src/components/design-system/DateRangeInput/DateRangeInput.tsx b/web/src/components/design-system/DateRangeInput/DateRangeInput.tsx
new file mode 100644
index 0000000000..755b208316
--- /dev/null
+++ b/web/src/components/design-system/DateRangeInput/DateRangeInput.tsx
@@ -0,0 +1,244 @@
+"use client";
+
+import * as React from "react";
+import * as Popover from "@radix-ui/react-popover";
+import { format } from "date-fns";
+import {
+ CalendarDays,
+ ChevronDown,
+ ChevronLeft,
+ ChevronRight,
+} from "@langfuse/icons";
+import {
+ DayPicker,
+ SelectionState,
+ UI,
+ type DateRange,
+ type ChevronProps,
+} from "react-day-picker";
+
+import { useLayerContainer } from "@/src/context/LayerContext/LayerContext";
+import { InputControl } from "../internal/InputControl/InputControl";
+import { Input } from "../Input/Input";
+
+type DateRangeInputProps<V extends string> = {
+ value: V;
+ customValue: V;
+ range?: { from: Date; to: Date };
+ earliestDate?: Date;
+ presets: { value: V; label: string; disabled?: boolean }[];
+ onPresetChange: (value: V) => void;
+ onCustomChange: (range: { from: Date; to: Date }) => void;
+ id?: string;
+ "aria-describedby"?: string;
+ disabled?: boolean;
+};
+
+function DateRangeInput<V extends string>({
+ value,
+ customValue,
+ range,
+ earliestDate,
+ presets,
+ onPresetChange,
+ onCustomChange,
+ id,
+ "aria-describedby": ariaDescribedBy,
+ disabled,
+}: DateRangeInputProps<V>) {
+ const container = useLayerContainer("popover");
+ const [open, setOpen] = React.useState(false);
+ const [draft, setDraft] = React.useState<DateRange | undefined>(range);
+ const label = presets.find((preset) => preset.value === value)?.label;
+ const displayValue =
+ value === customValue && range
+ ? `${format(range.from, "LLL d, yy HH:mm")} – ${format(range.to, "LLL d, yy HH:mm")}`
+ : (label ?? "Select date range");
+
+ const selectDay = (day: Date) => {
+ if (
+ earliestDate &&
+ day <
+ new Date(
+ earliestDate.getFullYear(),
+ earliestDate.getMonth(),
+ earliestDate.getDate(),
+ )
+ )
+ return;
+ if (!draft?.from || draft.to) {
+ setDraft({ from: day, to: undefined });
+ return;
+ }
+ const from = day < draft.from ? day : draft.from;
+ const to = day < draft.from ? draft.from : day;
+ const start = new Date(from.getFullYear(), from.getMonth(), from.getDate());
+ const next = {
+ from: earliestDate && start < earliestDate ? earliestDate : start,
+ to: new Date(
+ to.getFullYear(),
+ to.getMonth(),
+ to.getDate(),
+ 23,
+ 59,
+ 59,
+ 999,
+ ),
+ };
+ setDraft(next);
+ onCustomChange(next);
+ };
+
+ const changeTime = (boundary: "from" | "to", time: string) => {
+ if (!draft?.from || !draft.to) return;
+ const [hours, minutes] = time.split(":").map(Number);
+ const updated = new Date(draft[boundary]!);
+ updated.setHours(hours ?? 0, minutes ?? 0);
+ if (boundary === "from" && earliestDate && updated < earliestDate) {
+ updated.setTime(earliestDate.getTime());
+ }
+ const next = { from: draft.from, to: draft.to, [boundary]: updated };
+ if (next.from > next.to) return;
+ setDraft(next);
+ onCustomChange(next);
+ };
+
+ const handleOpenChange = (nextOpen: boolean) => {
+ setOpen(nextOpen);
+ if (nextOpen || !draft?.to) setDraft(range);
+ };
+ const handlePresetClick = (event: React.MouseEvent<HTMLButtonElement>) => {
+ const preset = presets.find(
+ (option) => option.value === event.currentTarget.value,
+ );
+ if (!preset) return;
+ onPresetChange(preset.value);
+ setOpen(false);
+ };
+ const handleTimeChange = (event: React.ChangeEvent<HTMLInputElement>) => {
+ const boundary = event.target.name;
+ if (boundary === "from" || boundary === "to") {
+ changeTime(boundary, event.target.value);
+ }
+ };
+
+ return (
+ <Popover.Root open={open} onOpenChange={handleOpenChange}>
+ <InputControl contentLayout="spread" disabled={disabled}>
+ <Popover.Trigger
+ id={id}
+ disabled={disabled}
+ aria-label="Date range"
+ aria-describedby={ariaDescribedBy}
+ >
+ <span
+ className="flex min-w-0 items-center gap-2 truncate text-left"
+ title={displayValue}
+ >
+ <CalendarDays size="base" />
+ {displayValue}
+ </span>
+ <ChevronDown size="base" color="muted" />
+ </Popover.Trigger>
+ </InputControl>
+ <Popover.Portal container={container}>
+ <Popover.Content
+ align="start"
+ sideOffset={4}
+ className="bg-popover text-popover-foreground flex max-h-[min(90vh,650px)] max-w-[calc(100vw-2rem)] flex-col overflow-auto rounded-md border shadow-md sm:flex-row"
+ >
+ <div className="flex max-h-40 min-w-40 flex-col gap-0.5 overflow-auto border-b p-2 sm:max-h-none sm:border-r sm:border-b-0">
+ {presets.map((preset) => (
+ <button
+ key={preset.value}
+ type="button"
+ value={preset.value}
+ disabled={preset.disabled}
+ aria-pressed={value === preset.value}
+ className="hover:bg-muted aria-pressed:bg-primary/10 aria-pressed:text-primary aria-pressed:hover:bg-primary/15 rounded-sm px-3 py-1.5 text-left text-sm disabled:cursor-not-allowed disabled:opacity-50"
+ onClick={handlePresetClick}
+ >
+ {preset.label}
+ </button>
+ ))}
+ </div>
+ <div>
+ <DayPicker
+ mode="range"
+ disabled={
+ earliestDate
+ ? {
+ before: new Date(
+ earliestDate.getFullYear(),
+ earliestDate.getMonth(),
+ earliestDate.getDate(),
+ ),
+ }
+ : undefined
+ }
+ numberOfMonths={2}
+ selected={draft}
+ defaultMonth={draft?.from}
+ onDayClick={selectDay}
+ className="relative p-3 max-sm:[&_.rdp-months>.rdp-month:last-child]:hidden"
+ classNames={{
+ [UI.Months]: "flex gap-4",
+ [UI.Month]: "space-y-4",
+ [UI.MonthCaption]: "flex justify-center items-center h-8",
+ [UI.CaptionLabel]: "text-sm font-bold",
+ [UI.PreviousMonthButton]:
+ "absolute left-2 top-3 rounded p-1 hover:bg-accent",
+ [UI.NextMonthButton]:
+ "absolute right-2 top-3 rounded p-1 hover:bg-accent",
+ [UI.MonthGrid]: "w-full border-collapse",
+ [UI.Weekdays]: "flex",
+ [UI.Weekday]: "text-muted-foreground w-9 text-center text-xs",
+ [UI.Week]: "flex",
+ [UI.Day]: "size-9 text-center",
+ [UI.DayButton]:
+ "size-9 rounded text-sm hover:bg-muted focus-visible:ring-2 focus-visible:ring-ring group-[.range-start]:bg-primary group-[.range-start]:text-primary-foreground group-[.range-start]:hover:bg-primary/90 group-[.range-end]:bg-primary group-[.range-end]:text-primary-foreground group-[.range-end]:hover:bg-primary/90 group-[.range-middle]:hover:bg-primary/25",
+ [SelectionState.range_start]:
+ "group range-start bg-primary/15 rounded-l-md",
+ [SelectionState.range_middle]:
+ "group range-middle bg-primary/15",
+ [SelectionState.range_end]:
+ "group range-end bg-primary/15 rounded-r-md",
+ }}
+ components={{
+ Chevron: CalendarChevron,
+ }}
+ />
+ <div className="flex flex-wrap gap-3 border-t p-3 text-sm">
+ {(["from", "to"] as const).map((boundary) => (
+ <label key={boundary} className="flex items-center gap-2">
+ {boundary === "from" ? "Start" : "End"}
+ <span className="w-32">
+ <Input
+ type="time"
+ name={boundary}
+ aria-label={`${boundary === "from" ? "Start" : "End"} time`}
+ disabled={!draft?.from || !draft.to}
+ value={
+ draft?.from && draft.to
+ ? format(draft[boundary]!, "HH:mm")
+ : ""
+ }
+ onChange={handleTimeChange}
+ />
+ </span>
+ </label>
+ ))}
+ </div>
+ </div>
+ </Popover.Content>
+ </Popover.Portal>
+ </Popover.Root>
+ );
+}
+
+function CalendarChevron({ orientation }: ChevronProps) {
+ if (orientation === "right") return <ChevronRight size="base" />;
+ return <ChevronLeft size="base" />;
+}
+
+export { DateRangeInput };
diff --git a/web/src/components/design-system/FormField/FormField.stories.tsx b/web/src/components/design-system/FormField/FormField.stories.tsx
index 68b6c75172..847241e1d0 100644
--- a/web/src/components/design-system/FormField/FormField.stories.tsx
+++ b/web/src/components/design-system/FormField/FormField.stories.tsx
@@ -55,6 +55,26 @@ const meta = preview.meta({
export const Default = meta.story({});
+export const Standalone = meta.story({
+ name: "(Test) Standalone",
+ render: () => (
+ <FormField
+ label="Preview date range"
+ description="Only affects this preview."
+ >
+ {(field) => (
+ <Input id={field.id} aria-describedby={field.inputDescribedById} />
+ )}
+ </FormField>
+ ),
+ play: async ({ canvasElement }) => {
+ const canvas = within(canvasElement);
+ const input = canvas.getByLabelText("Preview date range");
+ const description = canvas.getByText("Only affects this preview.");
+ await expect(input).toHaveAttribute("aria-describedby", description.id);
+ },
+});
+
export const WithDescription = meta.story({
name: "(Test) Description",
args: {
diff --git a/web/src/components/design-system/FormField/FormField.tsx b/web/src/components/design-system/FormField/FormField.tsx
index 3b7924b1df..76f31cffe7 100644
--- a/web/src/components/design-system/FormField/FormField.tsx
+++ b/web/src/components/design-system/FormField/FormField.tsx
@@ -36,75 +36,141 @@ export type FormFieldProps<
registerLabelTooltip?: TooltipTriggerPropsGetter;
};
+type StandaloneFormFieldProps = {
+ control?: never;
+ name?: never;
+ children: (field: {
+ id: string;
+ inputDescribedById: string | undefined;
+ }) => ReactElement;
+ description?: string;
+ label: string;
+ registerLabelTooltip?: TooltipTriggerPropsGetter;
+};
+
+function FormFieldLayout({
+ label,
+ controlId,
+ description,
+ descriptionId,
+ errorMessage,
+ errorId,
+ registerLabelTooltip,
+ children,
+}: {
+ label: string;
+ controlId: string;
+ description?: string;
+ descriptionId: string;
+ errorMessage?: string;
+ errorId: string;
+ registerLabelTooltip?: TooltipTriggerPropsGetter;
+ children: ReactElement;
+}) {
+ return (
+ <div className="space-y-2">
+ <div className="flex items-center gap-1.5">
+ <label htmlFor={controlId} className="text-sm leading-none font-bold">
+ {label}
+ </label>
+ {registerLabelTooltip ? (
+ <button
+ type="button"
+ {...registerLabelTooltip()}
+ aria-label={`About ${label}`}
+ >
+ <Info aria-hidden size="base" color="muted" />
+ </button>
+ ) : null}
+ </div>
+ <div className="space-y-1">
+ {children}
+ {errorMessage ? (
+ <p id={errorId} className="text-destructive text-sm">
+ {errorMessage}
+ </p>
+ ) : null}
+ </div>
+ {description ? (
+ <p id={descriptionId} className="text-muted-foreground text-sm">
+ {description}
+ </p>
+ ) : null}
+ </div>
+ );
+}
+
export function FormField<
TFieldValues extends FieldValues,
TName extends FieldPath<TFieldValues>,
TTransformedValues extends FieldValues = TFieldValues,
->({
- control,
- children,
- description,
- label,
- name,
- registerLabelTooltip,
-}: FormFieldProps<TFieldValues, TName, TTransformedValues>) {
+>(props: FormFieldProps<TFieldValues, TName, TTransformedValues>): ReactElement;
+export function FormField(props: StandaloneFormFieldProps): ReactElement;
+export function FormField<
+ TFieldValues extends FieldValues,
+ TName extends FieldPath<TFieldValues>,
+ TTransformedValues extends FieldValues = TFieldValues,
+>(
+ props:
+ | FormFieldProps<TFieldValues, TName, TTransformedValues>
+ | StandaloneFormFieldProps,
+) {
const id = useId();
const controlId = `${id}-control`;
const descriptionId = `${id}-description`;
const errorId = `${id}-error`;
+ const { label, description, registerLabelTooltip } = props;
- return (
- <Controller
- control={control}
- name={name}
- render={({ field, fieldState }) => {
- const errorMessage = fieldState.error?.message;
- const inputDescribedById = [
- errorMessage ? errorId : undefined,
- description ? descriptionId : undefined,
- ]
- .filter((value) => value !== undefined)
- .join(" ");
- return (
- <div className="space-y-2">
- <div className="flex items-center gap-1.5">
- <label
- htmlFor={controlId}
- className="text-sm leading-none font-bold"
- >
- {label}
- </label>
- {registerLabelTooltip ? (
- <button
- type="button"
- {...registerLabelTooltip()}
- aria-label={`About ${label}`}
- >
- <Info aria-hidden size="base" color="muted" />
- </button>
- ) : null}
- </div>
- <div className="space-y-1">
+ if (props.control) {
+ const { control, name, children } = props;
+ return (
+ <Controller
+ control={control}
+ name={name}
+ render={({ field, fieldState }) => {
+ const errorMessage = fieldState.error?.message;
+ const inputDescribedById = [
+ errorMessage ? errorId : undefined,
+ description ? descriptionId : undefined,
+ ]
+ .filter((value) => value !== undefined)
+ .join(" ");
+ return (
+ <FormFieldLayout
+ label={label}
+ controlId={controlId}
+ description={description}
+ descriptionId={descriptionId}
+ errorMessage={errorMessage}
+ errorId={errorId}
+ registerLabelTooltip={registerLabelTooltip}
+ >
{children({
...field,
error: fieldState.error,
id: controlId,
inputDescribedById: inputDescribedById || undefined,
})}
- {errorMessage ? (
- <p id={errorId} className="text-destructive text-sm">
- {errorMessage}
- </p>
- ) : null}
- </div>
- {description ? (
- <p id={descriptionId} className="text-muted-foreground text-sm">
- {description}
- </p>
- ) : null}
- </div>
- );
- }}
- />
+ </FormFieldLayout>
+ );
+ }}
+ />
+ );
+ }
+
+ return (
+ <FormFieldLayout
+ label={label}
+ controlId={controlId}
+ description={description}
+ descriptionId={descriptionId}
+ errorId={errorId}
+ registerLabelTooltip={registerLabelTooltip}
+ >
+ {props.children({
+ id: controlId,
+ inputDescribedById: description ? descriptionId : undefined,
+ })}
+ </FormFieldLayout>
);
}
diff --git a/web/src/components/design-system/Input/Input.tsx b/web/src/components/design-system/Input/Input.tsx
index 3b21ccf8a1..6b922bc99f 100644
--- a/web/src/components/design-system/Input/Input.tsx
+++ b/web/src/components/design-system/Input/Input.tsx
@@ -17,6 +17,7 @@ type InputProps = Pick<
| "id"
| "inputMode"
| "maxLength"
+ | "max"
| "min"
| "minLength"
| "name"
diff --git a/web/src/components/design-system/SelectDropdown/SelectDropdown.tsx b/web/src/components/design-system/SelectDropdown/SelectDropdown.tsx
index 3e6bd9f330..2b5adbb154 100644
--- a/web/src/components/design-system/SelectDropdown/SelectDropdown.tsx
+++ b/web/src/components/design-system/SelectDropdown/SelectDropdown.tsx
@@ -2,14 +2,21 @@
import * as React from "react";
import * as SelectPrimitive from "@radix-ui/react-select";
-import { ChevronDown, ChevronUp } from "@langfuse/icons";
+import { ChevronDown, ChevronUp, type IconComponent } from "@langfuse/icons";
import { useLayerContainer } from "@/src/context/LayerContext/LayerContext";
import { Badge } from "@/src/components/design-system/Badge/Badge";
+import { CustomTooltip } from "@/src/components/design-system/CustomTooltip/CustomTooltip";
import { InputDropdown } from "@/src/components/design-system/internal/InputDropdown/InputDropdown";
type SelectOption<V> = {
value: V;
label: string;
+ icon?: IconComponent;
+ explanation?: {
+ title: string;
+ description?: string;
+ badges?: { label: string; value: string }[];
+ };
badges?: Array<
Pick<React.ComponentProps<typeof Badge>, "text" | "color" | "title">
>;
@@ -117,26 +124,69 @@ export function SelectDropdown<V extends string>({
);
}
+ const item = (
+ <InputDropdown.Option highlight="focus">
+ <SelectPrimitive.Item value={node.value} disabled={node.disabled}>
+ <InputDropdown.OptionContent
+ type="radio"
+ checked={value === node.value}
+ label={
+ <SelectPrimitive.ItemText>
+ <span className="flex items-center gap-2">
+ {node.icon && <node.icon size="base" />}
+ {node.label}
+ </span>
+ </SelectPrimitive.ItemText>
+ }
+ title={node.disabled ? node.disabledReason : node.label}
+ badges={node.badges?.map((badge, index) => (
+ <Badge key={index} {...badge} />
+ ))}
+ />
+ </SelectPrimitive.Item>
+ </InputDropdown.Option>
+ );
+
return (
<React.Fragment key={node.value}>
{hasPreviousGroup && <div aria-hidden="true" className="h-4" />}
- <InputDropdown.Option highlight="focus">
- <SelectPrimitive.Item value={node.value} disabled={node.disabled}>
- <InputDropdown.OptionContent
- type="radio"
- checked={value === node.value}
- label={
- <SelectPrimitive.ItemText>
- {node.label}
- </SelectPrimitive.ItemText>
- }
- title={node.disabled ? node.disabledReason : node.label}
- badges={node.badges?.map((badge, index) => (
- <Badge key={index} {...badge} />
- ))}
- />
- </SelectPrimitive.Item>
- </InputDropdown.Option>
+ {node.explanation ? (
+ <CustomTooltip
+ delay={0}
+ placement="right-start"
+ content={
+ <div>
+ <div className="mb-1 text-sm font-bold">
+ {node.explanation.title}
+ </div>
+ {node.explanation.badges !== undefined &&
+ node.explanation.badges.length > 0 && (
+ <div className="mb-2 flex flex-wrap gap-2 text-xs">
+ {node.explanation.badges.map((badge) => (
+ <span
+ key={badge.label}
+ className="bg-muted text-muted-foreground rounded px-1.5 py-0.5"
+ >
+ {badge.label}: {badge.value}
+ </span>
+ ))}
+ </div>
+ )}
+ {node.explanation.description && (
+ <p className="text-xs leading-snug">
+ {node.explanation.description}
+ </p>
+ )}
+ </div>
+ }
+ >
+ {({ getTriggerProps }) =>
+ React.cloneElement(item, getTriggerProps())
+ }
+ </CustomTooltip>
+ ) : (
+ item
+ )}
</React.Fragment>
);
};
diff --git a/web/src/components/design-system/SelectInput/SelectInput.stories.tsx b/web/src/components/design-system/SelectInput/SelectInput.stories.tsx
index 104a360861..5b8e3243a9 100644
--- a/web/src/components/design-system/SelectInput/SelectInput.stories.tsx
+++ b/web/src/components/design-system/SelectInput/SelectInput.stories.tsx
@@ -1,4 +1,5 @@
import { useState } from "react";
+import { BarChart3, LineChart } from "@langfuse/icons";
import { expect, fn, userEvent, waitFor, within } from "storybook/test";
import preview from "../../../../.storybook/preview";
import { SelectInput } from "./SelectInput";
@@ -72,6 +73,50 @@ export const Default = meta.story({
},
});
+export const WithIconsAndExplanations = meta.story({
+ args: {
+ value: "line",
+ placeholder: "Select a chart type",
+ options: [
+ {
+ value: "line",
+ label: "Line chart",
+ icon: LineChart,
+ explanation: {
+ title: "Line chart",
+ description: "Show how a value changes over time.",
+ badges: [{ label: "Category", value: "Time series" }],
+ },
+ },
+ {
+ value: "bar",
+ label: "Bar chart",
+ icon: BarChart3,
+ explanation: {
+ title: "Bar chart",
+ description: "Compare values across categories.",
+ badges: [{ label: "Category", value: "Comparison" }],
+ },
+ },
+ ],
+ onValueChange: fn(),
+ },
+ render: (args) => {
+ const [value, setValue] = useState(args.value);
+
+ return (
+ <SelectInput
+ {...args}
+ value={value}
+ onValueChange={(newValue) => {
+ setValue(newValue);
+ args.onValueChange(newValue);
+ }}
+ />
+ );
+ },
+});
+
export const WithLongText = meta.story({
args: {
value: "long-option",
diff --git a/web/src/features/metrics/components/ConnectedMetricsFilterBuilder.tsx b/web/src/features/metrics/components/ConnectedMetricsFilterBuilder.tsx
new file mode 100644
index 0000000000..eb401e8c12
--- /dev/null
+++ b/web/src/features/metrics/components/ConnectedMetricsFilterBuilder.tsx
@@ -0,0 +1,216 @@
+import { type FilterState, type TimeFilter } from "@langfuse/shared";
+import { type views, type ViewVersion } from "@langfuse/shared/query";
+import { type z } from "zod";
+import { api } from "@/src/utils/api";
+import { useMetadataValueOptions } from "@/src/features/events";
+import {
+ getMetricsColumnsWithCustomSelect,
+ getMetricsFilterColumns,
+} from "@/src/features/metrics/metricsFilterColumns";
+import {
+ MetricsFilterBuilder,
+ buildV1FilterColumnsParams,
+ buildV2FilterColumnsParams,
+ type EventFilterOptionsColumn,
+} from "./MetricsFilterBuilder";
+
+const v1FilterOptionsQueryConfig = {
+ trpc: { context: { skipBatch: true } },
+ refetchOnMount: false,
+ refetchOnWindowFocus: false,
+ refetchOnReconnect: false,
+ staleTime: Infinity,
+} as const;
+
+const v2FilterOptionsQueryConfig = {
+ trpc: { context: { skipBatch: true } },
+ staleTime: 60 * 1000,
+ refetchOnWindowFocus: false,
+ refetchOnReconnect: false,
+} as const;
+
+/** eventsFilterOptionsColumns lists the v2 facets fast enough to load in one request. */
+const eventsFilterOptionsColumns = [
+ "providedModelName",
+ "modelId",
+ "name",
+ "promptName",
+ "traceTags",
+ "traceName",
+ "type",
+ "userId",
+ "version",
+ "release",
+ "sessionId",
+ "level",
+ "environment",
+ "ingestionApiKey",
+ "experimentDatasetId",
+ "experimentId",
+ "experimentName",
+ "isRootObservation",
+ "calledToolNames",
+ "skillNamesAvailable",
+ "skillsNamesLoaded",
+ "metadataKeys",
+ "scores_avg",
+ "score_categories",
+ "score_booleans",
+ "trace_scores_avg",
+ "trace_score_categories",
+ "trace_score_booleans",
+] satisfies EventFilterOptionsColumn[];
+
+/** slowEventsFilterOptionsColumns lists the v2 facets that scan slowly enough to need their own request. */
+const slowEventsFilterOptionsColumns = [
+ "toolNames",
+] satisfies EventFilterOptionsColumn[];
+
+type MetricsFilterDateRange = { from: Date; to?: Date };
+
+type MetricsFilterFetcherProps = {
+ view: z.infer<typeof views>;
+ projectId: string;
+ dateRange?: MetricsFilterDateRange;
+ filters: FilterState;
+ onChange: (filters: FilterState) => void;
+};
+
+type ConnectedMetricsFilterBuilderProps = MetricsFilterFetcherProps & {
+ version: ViewVersion;
+};
+
+/** Connected filter builder for existing callers. */
+export function ConnectedMetricsFilterBuilder({
+ version,
+ view,
+ projectId,
+ dateRange,
+ filters,
+ onChange,
+}: ConnectedMetricsFilterBuilderProps) {
+ const data = useMetricsFilterBuilderData({
+ version,
+ view,
+ projectId,
+ dateRange,
+ filters,
+ });
+ return (
+ <MetricsFilterBuilder
+ view={view}
+ filters={filters}
+ onChange={onChange}
+ {...data}
+ />
+ );
+}
+
+/** Fetch filter options separately so the editor can render with fixture data. */
+export function useMetricsFilterBuilderData({
+ version,
+ view,
+ projectId,
+ dateRange,
+ filters,
+}: Omit<MetricsFilterFetcherProps, "onChange"> & { version: ViewVersion }) {
+ const isV1 = version === "v1";
+ const evaluatorOptions = api.evalsV2.options.useQuery(
+ { projectId, limit: 100 },
+ v2FilterOptionsQueryConfig,
+ );
+ const evaluatorNameOptions =
+ evaluatorOptions.data?.map(({ id, name }) => ({
+ value: id,
+ displayValue: name,
+ })) ?? [];
+ const startTimeFilter = metricsFilterTimeFilter("startTime", dateRange);
+ const traceFilterOptions = api.traces.filterOptions.useQuery(
+ {
+ projectId,
+ timestampFilter: metricsFilterTimeFilter("timestamp", dateRange),
+ },
+ { ...v1FilterOptionsQueryConfig, enabled: isV1 },
+ );
+ const generationsFilterOptions = api.generations.filterOptions.useQuery(
+ { projectId, startTimeFilter, observationType: "ALL" },
+ { ...v1FilterOptionsQueryConfig, enabled: isV1 },
+ );
+ const environmentFilterOptions =
+ api.projects.environmentFilterOptions.useQuery(
+ { projectId, fromTimestamp: dateRange?.from },
+ { ...v1FilterOptionsQueryConfig, enabled: isV1 },
+ );
+ const eventsFilterOptions = api.events.filterOptions.useQuery(
+ { projectId, startTimeFilter, columns: eventsFilterOptionsColumns },
+ { ...v2FilterOptionsQueryConfig, enabled: !isV1 },
+ );
+ const slowEventsFilterOptions = api.events.filterOptions.useQuery(
+ { projectId, startTimeFilter, columns: slowEventsFilterOptionsColumns },
+ { ...v2FilterOptionsQueryConfig, enabled: !isV1 },
+ );
+ const datasets = api.datasets.allDatasetMeta.useQuery(
+ { projectId },
+ { enabled: !isV1 },
+ );
+ const { metadataValueOptions, onMetadataKeyChange } = useMetadataValueOptions(
+ {
+ projectId,
+ filterState: filters,
+ startTimeFilter,
+ enabled: !isV1,
+ },
+ );
+
+ if (isV1) {
+ const params = buildV1FilterColumnsParams({
+ view,
+ traceFilterOptions: traceFilterOptions.data,
+ generationsFilterOptions: generationsFilterOptions.data,
+ environmentFilterOptions: environmentFilterOptions.data,
+ evaluatorOptions: evaluatorNameOptions,
+ });
+ return {
+ columns: getMetricsFilterColumns(params),
+ columnsWithCustomSelect: getMetricsColumnsWithCustomSelect(params),
+ stringObjectValueOptions: undefined,
+ onStringObjectKeyChange: undefined,
+ };
+ }
+ const params = buildV2FilterColumnsParams({
+ view,
+ filterOptions: eventsFilterOptions.data,
+ slowFilterOptions: slowEventsFilterOptions.data,
+ datasets: datasets.data,
+ evaluatorOptions: evaluatorNameOptions,
+ metadataKeys: eventsFilterOptions.data?.metadataKeys?.map(
+ (row) => row.value,
+ ),
+ });
+ return {
+ columns: getMetricsFilterColumns(params),
+ columnsWithCustomSelect: getMetricsColumnsWithCustomSelect(params),
+ stringObjectValueOptions: metadataValueOptions,
+ onStringObjectKeyChange: onMetadataKeyChange,
+ };
+}
+
+/** metricsFilterTimeFilter keys a {from, to?} range to a column as the TimeFilter[] the filter-options endpoints expect. */
+const metricsFilterTimeFilter = (
+ column: "timestamp" | "startTime",
+ dateRange?: MetricsFilterDateRange,
+): TimeFilter[] | undefined => {
+ if (!dateRange) return undefined;
+ const filters: TimeFilter[] = [
+ { column, type: "datetime", operator: ">=", value: dateRange.from },
+ ];
+ if (dateRange.to) {
+ filters.push({
+ column,
+ type: "datetime",
+ operator: "<=",
+ value: dateRange.to,
+ });
+ }
+ return filters;
+};
diff --git a/web/src/features/metrics/components/MetricsFilterBuilder.clienttest.ts b/web/src/features/metrics/components/MetricsFilterBuilder.clienttest.ts
index 516821c6df..3cd14ef8df 100644
--- a/web/src/features/metrics/components/MetricsFilterBuilder.clienttest.ts
+++ b/web/src/features/metrics/components/MetricsFilterBuilder.clienttest.ts
@@ -1,4 +1,5 @@
// @vitest-environment node
+/* eslint-disable @repo/prefer-stories-over-client-tests -- Tests pure filter mappings, not component interactions. */
import { describe, expect, it } from "vitest";
diff --git a/web/src/features/metrics/components/MetricsFilterBuilder.stories.tsx b/web/src/features/metrics/components/MetricsFilterBuilder.stories.tsx
new file mode 100644
index 0000000000..87465af888
--- /dev/null
+++ b/web/src/features/metrics/components/MetricsFilterBuilder.stories.tsx
@@ -0,0 +1,22 @@
+import { fn } from "storybook/test";
+import preview from "../../../../.storybook/preview";
+import { MetricsFilterBuilder } from "./MetricsFilterBuilder";
+
+const meta = preview.meta({ component: MetricsFilterBuilder });
+
+export const Empty = meta.story({
+ args: {
+ view: "observations",
+ columns: [
+ {
+ name: "Environment",
+ id: "environment",
+ type: "string",
+ internal: "internalValue",
+ },
+ ],
+ columnsWithCustomSelect: [],
+ filters: [],
+ onChange: fn(),
+ },
+});
diff --git a/web/src/features/metrics/components/MetricsFilterBuilder.tsx b/web/src/features/metrics/components/MetricsFilterBuilder.tsx
index 3da242f61e..08967b5501 100644
--- a/web/src/features/metrics/components/MetricsFilterBuilder.tsx
+++ b/web/src/features/metrics/components/MetricsFilterBuilder.tsx
@@ -7,29 +7,22 @@ import {
ObservationLevelDomain,
ObservationTypeDomain,
type SingleValueOption,
- type TimeFilter,
} from "@langfuse/shared";
-import { type views, type ViewVersion } from "@langfuse/shared/query";
+import { type views } from "@langfuse/shared/query";
import { type z } from "zod";
-
import { Alert } from "@/src/components/design-system/Alert/Alert";
-import { api, type RouterInputs, type RouterOutputs } from "@/src/utils/api";
+import { type RouterInputs, type RouterOutputs } from "@/src/utils/api";
import {
displayNameForFilterColumn,
mapViewFilterToUiTableFilter,
partitionWidgetUiTableFiltersToView,
} from "@/src/features/dashboard";
-import { useMetadataValueOptions } from "@/src/features/events";
import {
InlineFilterBuilder,
normalizeSingleValueOptions,
sortOptionValues,
} from "@/src/features/filters";
-import {
- getMetricsColumnsWithCustomSelect,
- getMetricsFilterColumns,
- type GetMetricsFilterColumnsParams,
-} from "@/src/features/metrics/metricsFilterColumns";
+import { type GetMetricsFilterColumnsParams } from "@/src/features/metrics/metricsFilterColumns";
const observationLevelOptions = ObservationLevelDomain.options.map((value) => ({
value,
@@ -38,210 +31,18 @@ const observationTypeOptions = ObservationTypeDomain.options.map((value) => ({
value,
}));
-const v1FilterOptionsQueryConfig = {
- trpc: { context: { skipBatch: true } },
- refetchOnMount: false,
- refetchOnWindowFocus: false,
- refetchOnReconnect: false,
- staleTime: Infinity,
-} as const;
-
-const v2FilterOptionsQueryConfig = {
- trpc: { context: { skipBatch: true } },
- staleTime: 60 * 1000,
- refetchOnWindowFocus: false,
- refetchOnReconnect: false,
-} as const;
-
-/** eventsFilterOptionsColumns lists the v2 facets fast enough to load in one request. */
-const eventsFilterOptionsColumns = [
- "providedModelName",
- "modelId",
- "name",
- "promptName",
- "traceTags",
- "traceName",
- "type",
- "userId",
- "version",
- "release",
- "sessionId",
- "level",
- "environment",
- "ingestionApiKey",
- "experimentDatasetId",
- "experimentId",
- "experimentName",
- "isRootObservation",
- "calledToolNames",
- "skillNamesAvailable",
- "skillsNamesLoaded",
- "metadataKeys",
- "scores_avg",
- "score_categories",
- "score_booleans",
- "trace_scores_avg",
- "trace_score_categories",
- "trace_score_booleans",
-] satisfies EventFilterOptionsColumn[];
-
-/** slowEventsFilterOptionsColumns lists the v2 facets that scan slowly enough to need their own request. */
-const slowEventsFilterOptionsColumns = [
- "toolNames",
-] satisfies EventFilterOptionsColumn[];
-
-/** MetricsFilterBuilder filters metrics by the dimensions of the data model, dispatching to the version-specific fetcher. */
-export const MetricsFilterBuilder = ({
- version,
- ...props
-}: MetricsFilterFetcherProps & { version: ViewVersion }) => {
- const evaluatorOptions = api.evalsV2.options.useQuery(
- { projectId: props.projectId, limit: 100 },
- v2FilterOptionsQueryConfig,
- );
- const evaluatorNameOptions =
- evaluatorOptions.data?.map(({ id, name }) => ({
- value: id,
- displayValue: name,
- })) ?? [];
-
- if (version === "v1") {
- return (
- <MetricsFilterBuilderV1
- {...props}
- evaluatorOptions={evaluatorNameOptions}
- />
- );
- }
- return (
- <MetricsFilterBuilderV2
- {...props}
- evaluatorOptions={evaluatorNameOptions}
- />
- );
-};
-
-/** MetricsFilterDateRange is the preview/lookback window used to scope filter-value discovery. */
-type MetricsFilterDateRange = { from: Date; to?: Date };
-
-/** MetricsFilterFetcherProps is the version-agnostic contract shared by both fetchers. */
-type MetricsFilterFetcherProps = {
+type MetricsFilterBuilderProps = {
view: z.infer<typeof views>;
- projectId: string;
- dateRange?: MetricsFilterDateRange;
+ columns: ColumnDefinition[];
+ columnsWithCustomSelect: string[];
+ stringObjectValueOptions?: Record<string, SingleValueOption[]>;
+ onStringObjectKeyChange?: (key: string) => void;
filters: FilterState;
onChange: (filters: FilterState) => void;
};
-type MetricsFilterFetcherWithEvaluatorOptionsProps =
- MetricsFilterFetcherProps & {
- evaluatorOptions: SingleValueOption[];
- };
-
-/** MetricsFilterBuilderV1 loads the v1 (traces + generations + project) filter options and renders the filter view. */
-const MetricsFilterBuilderV1 = ({
- view,
- projectId,
- dateRange,
- filters,
- onChange,
- evaluatorOptions,
-}: MetricsFilterFetcherWithEvaluatorOptionsProps) => {
- const traceFilterOptions = api.traces.filterOptions.useQuery(
- {
- projectId,
- timestampFilter: metricsFilterTimeFilter("timestamp", dateRange),
- },
- v1FilterOptionsQueryConfig,
- );
-
- const generationsFilterOptions = api.generations.filterOptions.useQuery(
- {
- projectId,
- startTimeFilter: metricsFilterTimeFilter("startTime", dateRange),
- observationType: "ALL",
- },
- v1FilterOptionsQueryConfig,
- );
-
- const environmentFilterOptions =
- api.projects.environmentFilterOptions.useQuery(
- { projectId, fromTimestamp: dateRange?.from },
- v1FilterOptionsQueryConfig,
- );
-
- const params = buildV1FilterColumnsParams({
- view,
- traceFilterOptions: traceFilterOptions.data,
- generationsFilterOptions: generationsFilterOptions.data,
- environmentFilterOptions: environmentFilterOptions.data,
- evaluatorOptions,
- });
-
- return (
- <MetricsFilterView
- view={view}
- columns={getMetricsFilterColumns(params)}
- columnsWithCustomSelect={getMetricsColumnsWithCustomSelect(params)}
- filters={filters}
- onChange={onChange}
- />
- );
-};
-
-/** MetricsFilterBuilderV2 loads the v2 (events) filter options and renders the filter view with metadata value suggestions. */
-const MetricsFilterBuilderV2 = ({
- view,
- projectId,
- dateRange,
- filters,
- onChange,
- evaluatorOptions,
-}: MetricsFilterFetcherWithEvaluatorOptionsProps) => {
- const startTimeFilter = metricsFilterTimeFilter("startTime", dateRange);
-
- const eventsFilterOptions = api.events.filterOptions.useQuery(
- { projectId, startTimeFilter, columns: eventsFilterOptionsColumns },
- v2FilterOptionsQueryConfig,
- );
-
- const slowEventsFilterOptions = api.events.filterOptions.useQuery(
- { projectId, startTimeFilter, columns: slowEventsFilterOptionsColumns },
- v2FilterOptionsQueryConfig,
- );
-
- const datasets = api.datasets.allDatasetMeta.useQuery({ projectId });
-
- const { metadataValueOptions, onMetadataKeyChange } = useMetadataValueOptions(
- { projectId, filterState: filters, startTimeFilter },
- );
-
- const params = buildV2FilterColumnsParams({
- view,
- filterOptions: eventsFilterOptions.data,
- slowFilterOptions: slowEventsFilterOptions.data,
- datasets: datasets.data,
- evaluatorOptions,
- metadataKeys: eventsFilterOptions.data?.metadataKeys?.map(
- (row) => row.value,
- ),
- });
-
- return (
- <MetricsFilterView
- view={view}
- columns={getMetricsFilterColumns(params)}
- columnsWithCustomSelect={getMetricsColumnsWithCustomSelect(params)}
- stringObjectValueOptions={metadataValueOptions}
- onStringObjectKeyChange={onMetadataKeyChange}
- filters={filters}
- onChange={onChange}
- />
- );
-};
-
-/** MetricsFilterView renders the metric filter builder, translating between view-dimension space and UI-table labels and surfacing rows that are not valid for the view. */
-const MetricsFilterView = ({
+/** Renders the filter controls without fetching. */
+export function MetricsFilterBuilder({
view,
columns,
columnsWithCustomSelect,
@@ -249,15 +50,7 @@ const MetricsFilterView = ({
onStringObjectKeyChange,
filters,
onChange,
-}: {
- view: z.infer<typeof views>;
- columns: ColumnDefinition[];
- columnsWithCustomSelect: string[];
- stringObjectValueOptions?: Record<string, SingleValueOption[]>;
- onStringObjectKeyChange?: (key: string) => void;
- filters: FilterState;
- onChange: (filters: FilterState) => void;
-}) => {
+}: MetricsFilterBuilderProps) {
const editorFilters = viewFiltersToEditorFilters(view, filters);
const renderable = editorFilters.filter((filter) =>
resolvesToColumn(filter, columns),
@@ -293,37 +86,17 @@ const MetricsFilterView = ({
/>
</div>
);
-};
-
-/** metricsFilterTimeFilter keys a {from, to?} range to a column as the TimeFilter[] the filter-options endpoints expect. */
-const metricsFilterTimeFilter = (
- column: "timestamp" | "startTime",
- dateRange?: MetricsFilterDateRange,
-): TimeFilter[] | undefined => {
- if (!dateRange) return undefined;
- const filters: TimeFilter[] = [
- { column, type: "datetime", operator: ">=", value: dateRange.from },
- ];
- if (dateRange.to) {
- filters.push({
- column,
- type: "datetime",
- operator: "<=",
- value: dateRange.to,
- });
- }
- return filters;
-};
+}
/** buildV1FilterColumnsParams assembles the metric filter column options from the v1 endpoints; v1 keeps plain-string columns, so the events-only suggestion lists stay empty. */
-const buildV1FilterColumnsParams = ({
+export const buildV1FilterColumnsParams = ({
view,
traceFilterOptions,
generationsFilterOptions,
environmentFilterOptions,
evaluatorOptions = [],
}: {
- view: MetricsFilterFetcherProps["view"];
+ view: z.infer<typeof views>;
traceFilterOptions: RouterOutputs["traces"]["filterOptions"] | undefined;
generationsFilterOptions:
| RouterOutputs["generations"]["filterOptions"]
@@ -362,7 +135,7 @@ const buildV1FilterColumnsParams = ({
});
/** buildV2FilterColumnsParams assembles the metric filter column options from the v2 events filter-options discovery; closed Type/Level enums come from the domain schemas. */
-const buildV2FilterColumnsParams = ({
+export const buildV2FilterColumnsParams = ({
view,
filterOptions,
slowFilterOptions,
@@ -464,7 +237,7 @@ const resolvesToColumn = (
);
/** EventFilterOptionsColumn is one facet column the events filter-options endpoint understands. */
-type EventFilterOptionsColumn = NonNullable<
+export type EventFilterOptionsColumn = NonNullable<
RouterInputs["events"]["filterOptions"]["columns"]
>[number];
diff --git a/web/src/features/metrics/index.ts b/web/src/features/metrics/index.ts
index ab331bc20b..0bff6a82be 100644
--- a/web/src/features/metrics/index.ts
+++ b/web/src/features/metrics/index.ts
@@ -1 +1 @@
-export { MetricsFilterBuilder } from "@/src/features/metrics/components/MetricsFilterBuilder";
+export { ConnectedMetricsFilterBuilder } from "@/src/features/metrics/components/ConnectedMetricsFilterBuilder";
diff --git a/web/src/features/monitors/components/MonitorForm.tsx b/web/src/features/monitors/components/MonitorForm.tsx
index 3c8c9f9d7f..e78c147533 100644
--- a/web/src/features/monitors/components/MonitorForm.tsx
+++ b/web/src/features/monitors/components/MonitorForm.tsx
@@ -44,7 +44,7 @@ import { useHasProjectAccess } from "@/src/features/rbac";
import { useLangfuseCloudRegion } from "@/src/features/organizations";
import { useProject } from "@/src/features/projects";
import { WidgetPropertySelectItem } from "@/src/features/widgets";
-import { MetricsFilterBuilder } from "@/src/features/metrics";
+import { ConnectedMetricsFilterBuilder } from "@/src/features/metrics";
import { partitionWidgetUiTableFiltersToView } from "@/src/features/dashboard";
import { usePostHogClientCapture } from "@/src/features/posthog-analytics";
import {
@@ -624,7 +624,7 @@ export const MonitorForm = ({
<FormItem>
<FormLabel>Filters</FormLabel>
<FormControl>
- <MetricsFilterBuilder
+ <ConnectedMetricsFilterBuilder
version="v2"
view={(watched.view ?? "observations") as MonitorView}
projectId={projectId}
diff --git a/web/src/features/widgets/EditWidgetPage.tsx b/web/src/features/widgets/EditWidgetPage.tsx
index 01abe4477a..3c7ef7f199 100644
--- a/web/src/features/widgets/EditWidgetPage.tsx
+++ b/web/src/features/widgets/EditWidgetPage.tsx
@@ -1,7 +1,7 @@
import { useRouter } from "next/router";
import Page from "@/src/components/layouts/page";
import { api } from "@/src/utils/api";
-import { WidgetForm } from "@/src/features/widgets/components/WidgetForm";
+import { ConnectedWidgetForm } from "@/src/features/widgets/components/ConnectedWidgetForm";
import { type WidgetSavePayload } from "@/src/features/widgets/components/widgetFormSchema";
import { showErrorToast, showSuccessToast } from "@/src/features/notifications";
import { type metricAggregations, type views } from "@langfuse/shared/query";
@@ -105,7 +105,7 @@ export default function EditWidgetPage() {
}}
>
{!isWidgetLoading && widgetData && isResolved ? (
- <WidgetForm
+ <ConnectedWidgetForm
// Remount when the edited widget changes so its loaded values seed
// the form defaults once, rather than syncing via an effect.
key={widgetId}
diff --git a/web/src/features/widgets/NewWidgetPage.tsx b/web/src/features/widgets/NewWidgetPage.tsx
index cbab891836..40bfe6bdf0 100644
--- a/web/src/features/widgets/NewWidgetPage.tsx
+++ b/web/src/features/widgets/NewWidgetPage.tsx
@@ -1,7 +1,7 @@
import { useRouter } from "next/router";
import Page from "@/src/components/layouts/page";
import { api } from "@/src/utils/api";
-import { WidgetForm } from "@/src/features/widgets";
+import { ConnectedWidgetForm } from "@/src/features/widgets";
import { type WidgetSavePayload } from "@/src/features/widgets/components/widgetFormSchema";
import { showSuccessToast, showErrorToast } from "@/src/features/notifications";
import { type metricAggregations, type views } from "@langfuse/shared/query";
@@ -147,7 +147,7 @@ function NewWidgetView({ projectId }: { projectId: string }) {
},
}}
>
- <WidgetForm
+ <ConnectedWidgetForm
// No `key` on the beta flag: WidgetForm derives viewVersion (and its
// available views/measures/filter columns) reactively from isV4
// + the selected view, so a live beta toggle re-derives them without a
diff --git a/web/src/features/widgets/components/ConnectedWidgetForm.tsx b/web/src/features/widgets/components/ConnectedWidgetForm.tsx
new file mode 100644
index 0000000000..71d55361b2
--- /dev/null
+++ b/web/src/features/widgets/components/ConnectedWidgetForm.tsx
@@ -0,0 +1,33 @@
+import { ConnectedWidgetPreview } from "./ConnectedWidgetPreview";
+import { WidgetForm, useWidgetFormState } from "./WidgetForm";
+import { useMetricsFilterBuilderData } from "@/src/features/metrics/components/ConnectedMetricsFilterBuilder";
+import {
+ type WidgetInitialValues,
+ type WidgetSavePayload,
+} from "./widgetFormSchema";
+
+type ConnectedWidgetFormProps = {
+ initialValues: WidgetInitialValues;
+ projectId: string;
+ onSave: (widgetData: WidgetSavePayload) => void;
+ widgetId?: string;
+};
+
+export function ConnectedWidgetForm(props: ConnectedWidgetFormProps) {
+ const formProps = useWidgetFormState(props);
+ const filterData = useMetricsFilterBuilderData({
+ version: formProps.viewVersion,
+ view: formProps.values.view,
+ projectId: props.projectId,
+ dateRange: formProps.dateRange,
+ filters: formProps.values.filters,
+ });
+ return (
+ <div className="flex h-full gap-4">
+ <div className="h-full w-1/3 min-w-[430px]">
+ <WidgetForm {...formProps} filterData={filterData} />
+ </div>
+ <ConnectedWidgetPreview {...formProps} />
+ </div>
+ );
+}
diff --git a/web/src/features/widgets/components/ConnectedWidgetPreview.tsx b/web/src/features/widgets/components/ConnectedWidgetPreview.tsx
new file mode 100644
index 0000000000..9e9127ad01
--- /dev/null
+++ b/web/src/features/widgets/components/ConnectedWidgetPreview.tsx
@@ -0,0 +1,323 @@
+import { useMemo, type ComponentProps } from "react";
+import {
+ Card,
+ CardContent,
+ CardDescription,
+ CardHeader,
+ CardTitle,
+} from "@/src/components/ui/card";
+import { Alert } from "@/src/components/design-system/Alert/Alert";
+import { AlertCircle } from "@langfuse/icons";
+import { api } from "@/src/utils/api";
+import { getResultUnit } from "@langfuse/shared/query";
+import { Chart } from "@/src/features/widgets/chart-library/Chart";
+import { type DataPoint } from "@/src/features/widgets/chart-library/chart-props";
+import { isTimeSeriesChart } from "@/src/features/widgets/chart-library/utils";
+import { ChartLoadingState } from "@/src/features/widgets/chart-library/ChartLoadingState";
+import {
+ getChartLoadingProgress,
+ getChartLoadingStateProps,
+} from "@/src/features/widgets/chart-library/chartLoadingStateUtils";
+import {
+ formatMetricName,
+ getWidgetMetricPresentation,
+ getWidgetMissingBucketValue,
+} from "@/src/features/widgets/utils";
+import { type WidgetFormState } from "./WidgetForm";
+
+type ConnectedWidgetPreviewProps = Pick<
+ WidgetFormState,
+ | "projectId"
+ | "query"
+ | "viewVersion"
+ | "queryValidation"
+ | "chartType"
+ | "values"
+ | "selectedAggregation"
+ | "selectedDimension"
+ | "selectedMeasure"
+ | "selectedView"
+ | "effectiveSort"
+ | "previewSortState"
+ | "pivotDimensionFields"
+ | "displayName"
+ | "displayDescription"
+>;
+
+export function ConnectedWidgetPreview(props: ConnectedWidgetPreviewProps) {
+ const {
+ viewVersion,
+ queryValidation,
+ chartType,
+ values,
+ selectedAggregation,
+ selectedMeasure,
+ selectedView,
+ effectiveSort,
+ previewSortState,
+ pivotDimensionFields,
+ displayName,
+ displayDescription,
+ } = props;
+ const {
+ queryResult,
+ chartLoadingState,
+ loadingProgress,
+ transformedData,
+ chartPresentation,
+ } = useWidgetPreviewData(props);
+
+ const chartConfig: ComponentProps<typeof Chart>["chartConfig"] = (() => {
+ if (chartType === "PIVOT_TABLE") {
+ return {
+ type: chartType,
+ dimensions: pivotDimensionFields,
+ row_limit: values.chart.rowLimit,
+ metrics: values.metrics.map(
+ (metric) => `${metric.aggregation}_${metric.measure}`,
+ ),
+ units: values.metrics.map((metric) =>
+ getResultUnit(
+ selectedView,
+ metric.measure,
+ metric.aggregation,
+ viewVersion,
+ ),
+ ),
+ defaultSort: effectiveSort ?? undefined,
+ };
+ }
+ if (chartType === "HISTOGRAM") {
+ return {
+ type: chartType,
+ bins: values.chart.bins,
+ unit: getResultUnit(
+ selectedView,
+ selectedMeasure,
+ selectedAggregation,
+ viewVersion,
+ ),
+ };
+ }
+ return {
+ type: chartType,
+ row_limit: values.chart.rowLimit,
+ unit: getResultUnit(
+ selectedView,
+ selectedMeasure,
+ selectedAggregation,
+ viewVersion,
+ ),
+ };
+ })();
+
+ return (
+ <div className="w-2/3">
+ <Card className="flex aspect-video flex-col">
+ <CardHeader>
+ <CardTitle className="truncate" title={displayName}>
+ {displayName}
+ </CardTitle>
+ <CardDescription className="truncate" title={displayDescription}>
+ {displayDescription}
+ </CardDescription>
+ </CardHeader>
+ {!queryValidation.valid && (
+ <CardContent>
+ <div className="flex h-[300px] items-center justify-center">
+ <div className="w-full max-w-sm">
+ <Alert variant="destructive" icon={AlertCircle}>
+ <Alert.Title>Invalid query</Alert.Title>
+ <Alert.Description>
+ {queryValidation.reason}
+ </Alert.Description>
+ </Alert>
+ </div>
+ </div>
+ </CardContent>
+ )}
+ {queryValidation.valid &&
+ (queryResult.data || chartLoadingState.isLoading) && (
+ <div className="flex min-h-0 flex-1 flex-col">
+ <div className="relative min-h-0 flex-1">
+ <Chart
+ chartType={chartType}
+ data={transformedData}
+ config={
+ chartPresentation
+ ? { metric: { label: chartPresentation.label } }
+ : undefined
+ }
+ rowLimit={values.chart.rowLimit}
+ chartConfig={chartConfig}
+ sortState={
+ chartType === "PIVOT_TABLE" ? previewSortState : undefined
+ }
+ onSortChange={undefined}
+ isLoading={queryResult.isPending}
+ metricFormatter={chartPresentation?.metricFormatter}
+ missingValue={getWidgetMissingBucketValue(
+ selectedAggregation,
+ )}
+ />
+ {chartLoadingState.isLoading && (
+ <ChartLoadingState
+ showSpinner={chartLoadingState.showSpinner}
+ showHintImmediately={chartLoadingState.showHintImmediately}
+ hintText={chartLoadingState.hintText}
+ progress={loadingProgress}
+ className="bg-background/80 absolute inset-0 z-20 backdrop-blur-xs"
+ />
+ )}
+ </div>
+ </div>
+ )}
+ {queryValidation.valid &&
+ !queryResult.data &&
+ !chartLoadingState.isLoading && (
+ <CardContent>
+ <div className="flex h-[300px] items-center justify-center">
+ <p className="text-muted-foreground">
+ Waiting for Input / Loading...
+ </p>
+ </div>
+ </CardContent>
+ )}
+ </Card>
+ </div>
+ );
+}
+
+function useWidgetPreviewData({
+ projectId,
+ query,
+ viewVersion,
+ queryValidation,
+ chartType,
+ values,
+ selectedAggregation,
+ selectedDimension,
+ selectedMeasure,
+ selectedView,
+}: ConnectedWidgetPreviewProps) {
+ const queryResult = api.dashboard.executeQuery.useQuery(
+ {
+ projectId,
+ query,
+ version: viewVersion,
+ },
+ {
+ trpc: { context: { skipBatch: true } },
+ meta: { silentHttpCodes: [412, 422] },
+ enabled: queryValidation.valid,
+ },
+ );
+
+ const chartLoadingState = getChartLoadingStateProps({
+ isPending: queryResult.isPending,
+ isError: queryResult.isError,
+ });
+ const loadingProgress = getChartLoadingProgress({
+ isPending: queryResult.isPending,
+ progress: null,
+ useBackendProgress: false,
+ });
+
+ const transformedData: DataPoint[] = useMemo(
+ () =>
+ queryResult.data?.map((item) => {
+ const timeDimension =
+ typeof item["time_dimension"] === "string"
+ ? item["time_dimension"]
+ : undefined;
+ if (chartType === "PIVOT_TABLE") {
+ return {
+ ...item,
+ dimension:
+ values.dimensions.length > 0
+ ? values.dimensions[0].field
+ : "dimension",
+ metric: 0,
+ time_dimension: timeDimension,
+ };
+ }
+ const metricField = `${selectedAggregation}_${selectedMeasure}`;
+ const metric = item[metricField];
+ const dimensionField = selectedDimension;
+ const dimensionValue = item[dimensionField];
+ const isTimeSeries = isTimeSeriesChart(chartType);
+
+ const isFillerMetricValue =
+ metric == null ||
+ (getWidgetMissingBucketValue(selectedAggregation) === "zero" &&
+ Number(metric) === 0);
+ if (
+ isTimeSeries &&
+ dimensionField !== "none" &&
+ (dimensionValue === null || dimensionValue === "") &&
+ isFillerMetricValue
+ ) {
+ return {
+ dimension: undefined,
+ metric: null,
+ time_dimension: timeDimension,
+ };
+ }
+
+ return {
+ dimension:
+ dimensionValue !== undefined && dimensionField !== "none"
+ ? (() => {
+ const val = dimensionValue;
+ if (val === null || val === undefined || val === "")
+ return "n/a";
+ if (typeof val === "string") return val;
+ if (Array.isArray(val)) return val.join(", ");
+ return String(val);
+ })()
+ : formatMetricName(metricField),
+ metric: (() => {
+ if (Array.isArray(metric)) {
+ return metric.map((bucket: unknown) =>
+ Array.isArray(bucket) ? bucket.map(Number) : [],
+ );
+ }
+ if (isTimeSeries && metric == null) return null;
+ return Number(metric || 0);
+ })(),
+ time_dimension: timeDimension,
+ };
+ }) ?? [],
+ [
+ queryResult.data,
+ selectedAggregation,
+ selectedDimension,
+ selectedMeasure,
+ chartType,
+ values.dimensions,
+ ],
+ );
+
+ const chartPresentation = useMemo(() => {
+ if (chartType === "PIVOT_TABLE") return undefined;
+ return getWidgetMetricPresentation({
+ metric: { measure: selectedMeasure, agg: selectedAggregation },
+ view: selectedView,
+ version: viewVersion,
+ });
+ }, [
+ selectedAggregation,
+ chartType,
+ selectedMeasure,
+ selectedView,
+ viewVersion,
+ ]);
+
+ return {
+ queryResult,
+ chartLoadingState,
+ loadingProgress,
+ transformedData,
+ chartPresentation,
+ };
+}
diff --git a/web/src/features/widgets/components/WidgetForm.observationNameOptions.clienttest.tsx b/web/src/features/widgets/components/WidgetForm.observationNameOptions.clienttest.tsx
index 9d74829fa1..e5a355dd8c 100644
--- a/web/src/features/widgets/components/WidgetForm.observationNameOptions.clienttest.tsx
+++ b/web/src/features/widgets/components/WidgetForm.observationNameOptions.clienttest.tsx
@@ -57,7 +57,7 @@ vi.mock("next-auth/react", () => ({
useSession: () => ({ data: null, status: "unauthenticated" }),
}));
-import { WidgetForm } from "./WidgetForm";
+import { ConnectedWidgetForm } from "./ConnectedWidgetForm";
describe("WidgetForm v1 observation-name options", () => {
beforeAll(() => {
@@ -80,7 +80,7 @@ describe("WidgetForm v1 observation-name options", () => {
// irrelevant to what input the query under test received.
try {
render(
- <WidgetForm
+ <ConnectedWidgetForm
projectId="p1"
onSave={vi.fn()}
initialValues={{
diff --git a/web/src/features/widgets/components/WidgetForm.stories.tsx b/web/src/features/widgets/components/WidgetForm.stories.tsx
new file mode 100644
index 0000000000..f868d0dcec
--- /dev/null
+++ b/web/src/features/widgets/components/WidgetForm.stories.tsx
@@ -0,0 +1,75 @@
+import { useEffect } from "react";
+import { useForm, useWatch } from "react-hook-form";
+import { fn } from "storybook/test";
+import preview from "../../../../.storybook/preview";
+import { WidgetForm } from "./WidgetForm";
+import { toDefaultValues, type WidgetFormValues } from "./widgetFormSchema";
+
+function WidgetFormFixture({ invalidQuery }: { invalidQuery: boolean }) {
+ const form = useForm<WidgetFormValues>({
+ defaultValues: toDefaultValues(
+ {
+ name: "Observation count",
+ description: "Observations over time",
+ view: "observations",
+ measure: "count",
+ aggregation: "count",
+ dimension: "none",
+ chartType: "LINE_TIME_SERIES",
+ filters: [],
+ },
+ "v1",
+ ),
+ mode: "onChange",
+ });
+ const values = useWatch({ control: form.control }) as WidgetFormValues;
+ const { trigger } = form;
+
+ useEffect(() => {
+ trigger();
+ }, [trigger]);
+
+ return (
+ <div className="h-[700px] w-[480px]">
+ <WidgetForm
+ form={form}
+ values={values}
+ queryValidation={
+ invalidQuery
+ ? { valid: false, reason: "Choose a supported filter." }
+ : { valid: true }
+ }
+ onSave={fn()}
+ baseMinVersion={1}
+ activeVersion="v1"
+ projectId="storybook-project"
+ widgetId="storybook-widget"
+ isV4={false}
+ viewVersion="v1"
+ dateRange={undefined}
+ suggestions={{
+ name: "Observation count",
+ description: "Observations over time",
+ }}
+ setDateRangeAndOption={() => {}}
+ selectedOption="last7Days"
+ filterData={{
+ columns: [],
+ columnsWithCustomSelect: [],
+ stringObjectValueOptions: undefined,
+ onStringObjectKeyChange: undefined,
+ }}
+ />
+ </div>
+ );
+}
+
+const meta = preview.meta({ component: WidgetForm });
+
+export const Default = meta.story({
+ render: () => <WidgetFormFixture invalidQuery={false} />,
+});
+
+export const InvalidQuery = meta.story({
+ render: () => <WidgetFormFixture invalidQuery={true} />,
+});
diff --git a/web/src/features/widgets/components/WidgetForm.tsx b/web/src/features/widgets/components/WidgetForm.tsx
index 443ab13e1b..92203f485c 100644
--- a/web/src/features/widgets/components/WidgetForm.tsx
+++ b/web/src/features/widgets/components/WidgetForm.tsx
@@ -7,12 +7,10 @@ import {
CardTitle,
CardFooter,
} from "@/src/components/ui/card";
-import { api } from "@/src/utils/api";
import { WidgetImporter } from "@/src/features/widgets/components/WidgetImporter";
import { type ImportedWidgetFormSnapshot } from "@/src/features/widgets/utils/import-export-utils";
import {
buildWidgetOrderBy,
- getResultUnit,
getValidAggregationsForMeasureType,
isV2BreakdownChart,
validateQuery,
@@ -36,33 +34,30 @@ import {
type Resolver,
} from "react-hook-form";
import { zodResolver } from "@hookform/resolvers/zod";
-import {
- Select,
- SelectContent,
- SelectGroup,
- SelectItem,
- SelectLabel,
- SelectTrigger,
- SelectValue,
-} from "@/src/components/ui/select";
-import { WidgetPropertySelectItem } from "@/src/features/widgets/components/WidgetPropertySelectItem";
+import { SelectInput } from "@/src/components/design-system/SelectInput/SelectInput";
import { Label } from "@/src/components/ui/label";
import { Alert } from "@/src/components/design-system/Alert/Alert";
import { type z } from "zod";
import { useReadPath } from "@/src/features/events";
-import { Input } from "@/src/components/ui/input";
+import { Input } from "@/src/components/design-system/Input/Input";
+import { FormField } from "@/src/components/design-system/FormField/FormField";
import startCase from "lodash/startCase";
-import { DatePickerWithRange } from "@/src/components/date-picker";
-import { MetricsFilterBuilder } from "@/src/features/metrics";
+import { DateRangeInput } from "@/src/components/design-system/DateRangeInput/DateRangeInput";
+import { useEntitlementLimit } from "@/src/features/entitlements";
+import { addMinutes } from "date-fns";
+import { MetricsFilterBuilder } from "@/src/features/metrics/components/MetricsFilterBuilder";
+import { type useMetricsFilterBuilderData } from "@/src/features/metrics/components/ConnectedMetricsFilterBuilder";
import { useDashboardDateRange } from "@/src/hooks/useDashboardDateRange";
import {
+ DASHBOARD_AGGREGATION_OPTIONS,
+ dashboardDateRangeAggregationSettings,
+ getTimeRangeLabel,
+ isDashboardDateRangeOptionAvailable,
toAbsoluteTimeRange,
type DashboardDateRangeOptions,
} from "@/src/utils/date-range-utils";
-import { Chart } from "@/src/features/widgets/chart-library/Chart";
-import { type DataPoint } from "@/src/features/widgets/chart-library/chart-props";
import { Button } from "@/src/components/ui/button";
import { type DashboardWidgetChartType } from "@langfuse/shared/src/db";
import { showErrorToast } from "@/src/features/notifications";
@@ -82,20 +77,11 @@ import {
PopoverTrigger,
PopoverClose,
} from "@/src/components/ui/popover";
-import {
- formatMetricName,
- getWidgetMetricPresentation,
- getWidgetMissingBucketValue,
-} from "@/src/features/widgets/utils";
+import { formatMetricName } from "@/src/features/widgets/utils";
import {
MAX_PIVOT_TABLE_DIMENSIONS,
MAX_PIVOT_TABLE_METRICS,
} from "@/src/features/widgets/utils/pivot-table-utils";
-import { ChartLoadingState } from "@/src/features/widgets/chart-library/ChartLoadingState";
-import {
- getChartLoadingProgress,
- getChartLoadingStateProps,
-} from "@/src/features/widgets/chart-library/chartLoadingStateUtils";
import { WIDGET_FILTER_PRESETS } from "@/src/features/widgets/constants/widgetFilterPresets";
import { useCaptureWidgetHighCardinalityError } from "@/src/features/widgets/hooks/useWidgetQueryErrorCapture";
import {
@@ -194,119 +180,50 @@ type WidgetFieldContext = {
chartType: DashboardWidgetChartType;
};
+export type WidgetFormState = ReturnType<typeof useWidgetFormState>;
+
+type WidgetFormProps = Pick<
+ WidgetFormState,
+ | "form"
+ | "values"
+ | "queryValidation"
+ | "onSave"
+ | "baseMinVersion"
+ | "activeVersion"
+ | "projectId"
+ | "widgetId"
+ | "isV4"
+ | "viewVersion"
+ | "dateRange"
+ | "suggestions"
+ | "setDateRangeAndOption"
+ | "selectedOption"
+> & {
+ filterData: ReturnType<typeof useMetricsFilterBuilderData>;
+};
+
export function WidgetForm({
- initialValues,
- projectId,
+ filterData,
+ form,
+ values,
+ queryValidation,
onSave,
+ baseMinVersion,
+ activeVersion,
+ projectId,
widgetId,
-}: {
- initialValues: {
- name: string;
- description: string;
- view: z.infer<typeof views>;
- measure: string;
- aggregation: z.infer<typeof metricAggregations>;
- dimension: string;
- filters?: FilterState;
- chartType: DashboardWidgetChartType;
- chartConfig?: WidgetInitialValues["chartConfig"];
- // Support for complete widget data (editing mode)
- metrics?: { measure: string; agg: string }[];
- dimensions?: { field: string }[];
- minVersion?: number;
- };
- projectId: string;
- onSave: (widgetData: WidgetSavePayload) => void;
- widgetId?: string;
-}) {
- const { isV4 } = useReadPath();
-
- // The initial widget's persisted version is a local hint frozen at mount.
- // The resolver and live viewVersion additionally derive v2 from the current
- // form shape; the server derives the value that gets persisted.
- const baseMinVersion = deriveWidgetBaseMinVersion(initialValues);
- const activeVersion: ViewVersion = isV4 ? "v2" : "v1";
-
- // The auto-suggestions change on every keystroke; a ref keeps the resolver
- // closure from being rebuilt on each one (the filled name/description do not
- // affect validity — name/description are nullable with no min).
- const suggestionsRef = useRef<{ name: string; description: string }>({
- name: "",
- description: "",
- });
-
- // Precompute both version schemas/resolvers once. A blank name/description is
- // filled with the live suggestion and the filters are mapped into view space
- // before zod (mirrors MonitorForm).
- const resolversByVersion = useMemo(
- () => ({
- v1: zodResolver(makeWidgetFormSchema("v1") as any),
- v2: zodResolver(makeWidgetFormSchema("v2") as any),
- }),
- [],
- );
- // The schema version is derived INSIDE the resolver from the (mapped) view
- // being validated — not from a render-written ref — so it is never render
- // stale after a version-flipping view or import. baseMinVersion and
- // activeVersion are in the dep list so either promotion rebuilds the closure
- // (react-hook-form re-reads control._options each render).
- const resolver = useMemo<Resolver<WidgetFormValues>>(() => {
- return (values, context, options) => {
- const v = values as WidgetFormValues;
- const suggestions = suggestionsRef.current;
- const mapped = {
- ...v,
- name: effectiveWidgetName(v.name, suggestions.name),
- description: effectiveWidgetName(
- v.description,
- suggestions.description,
- ),
- // mapWidgetUiTableFilterToView MUST stay idempotent: the form holds
- // editor-space filters, and both this validation path and toSavePayload
- // map them to view space independently.
- filters: mapWidgetUiTableFilterToView(v.view, v.filters ?? []),
- };
- const version = resolveWidgetFormVersion({
- view: mapped.view,
- baseMinVersion,
- activeVersion,
- shape: mapped,
- });
- return resolversByVersion[version](mapped as any, context, options);
- };
- }, [resolversByVersion, baseMinVersion, activeVersion]);
-
- // The initial view version, derived from initialValues alone (view is known
- // before the form mounts) so the seed can normalize against the right view
- // declaration.
- const initialViewVersion = resolveWidgetFormVersion({
- view: initialValues.view,
- baseMinVersion,
- activeVersion,
- });
-
- const form = useForm<WidgetFormValues>({
- resolver,
- defaultValues: toDefaultValues(initialValues, initialViewVersion),
- mode: "onChange",
- });
-
- // THE single useWatch. Everything below is derived from `values` once.
- const values = useWatch({ control: form.control }) as WidgetFormValues;
-
+ isV4,
+ viewVersion,
+ dateRange,
+ suggestions,
+ setDateRangeAndOption,
+ selectedOption,
+}: WidgetFormProps) {
const selectedView = values.view;
const chartType = values.chart.type;
- const viewVersion = resolveWidgetFormVersion({
- view: selectedView,
- baseMinVersion,
- activeVersion,
- shape: values,
- });
- const suggestions = deriveWidgetSuggestions(values);
+ const selectedMeasure = values.metrics[0]?.measure ?? "count";
const effectiveSort = deriveEffectiveSort(values);
- suggestionsRef.current = suggestions;
-
// `viewsV2` is the public/new-widget v2 allowlist and intentionally excludes
// `traces`. Existing legacy trace widgets are a compatibility exception:
// their v2 query uses the internal events-backed declaration, so the current
@@ -339,7 +256,7 @@ export function WidgetForm({
// superRefine messages, surfaced inline under the relevant control and next
// to the disabled Save button (replaces the legacy save-time error toasts).
- const formErrors = form.formState.errors as Record<string, any>;
+ const formErrors = form.formState.errors;
const chartTypeError: string | undefined = formErrors.chart?.type?.message;
const metricsError: string | undefined =
formErrors.metrics?.message ??
@@ -348,49 +265,6 @@ export function WidgetForm({
formErrors.metrics?.[0]?.aggregation?.message;
const dimensionsError: string | undefined = formErrors.dimensions?.message;
- // Preview time range. The picker here is a transient PREVIEW control — the
- // widget does not own a time range, so it must not write the user's shared
- // cross-view default. Kept as LOCAL state (not RHF).
- const { timeRange, setTimeRange } = useDashboardDateRange({
- defaultRelativeAggregation: "last7Days",
- persistAsDefault: false,
- });
- const dateRange = useMemo(
- () => toAbsoluteTimeRange(timeRange) ?? undefined,
- [timeRange],
- );
- const selectedOption = useMemo(() => {
- if ("range" in timeRange) return timeRange.range;
- return "custom" as const;
- }, [timeRange]);
- const setDateRangeAndOption = (
- option: DashboardDateRangeOptions,
- range?: { from: Date; to: Date },
- ) => {
- if (option === "custom") {
- if (range) setTimeRange({ from: range.from, to: range.to });
- } else {
- setTimeRange({ range: option });
- }
- };
- const unsupportedFilters = useMemo(
- () =>
- partitionWidgetUiTableFiltersToView(selectedView, values.filters)
- .unsupportedFilters,
- [selectedView, values.filters],
- );
- const unsupportedFilterColumns = useMemo(
- () =>
- Array.from(
- new Set(unsupportedFilters.map((filter) => filter.column)),
- ).join(", "),
- [unsupportedFilters],
- );
- const normalizedUserFilters = useMemo(
- () => mapWidgetUiTableFilterToView(selectedView, values.filters),
- [selectedView, values.filters],
- );
-
// Available measures for the single (non-pivot) metric picker.
const singleChartMetrics = useMemo(() => {
const measures = viewDeclarations[viewVersion][selectedView].measures;
@@ -466,269 +340,56 @@ export function WidgetForm({
);
}, [selectedView, viewVersion]);
- const previewSortState = effectiveSort ?? null;
- const pivotDimensionFields = values.dimensions.map((d) => d.field);
-
- // Preview query. Depends ONLY on the fields that affect it — not
- // name/description.
- const query = useMemo<QueryType>(() => {
- const fromTimestamp = dateRange
- ? dateRange.from
- : new Date(new Date().getTime() - 7 * 24 * 60 * 60 * 1000);
- const toTimestamp = dateRange ? dateRange.to : new Date();
-
- const queryDimensions =
- chartType === "PIVOT_TABLE"
- ? values.dimensions.map((d) => ({ field: d.field }))
- : values.dimensions.length > 0
- ? [{ field: values.dimensions[0].field }]
- : [];
-
- const queryMetrics =
- chartType === "PIVOT_TABLE"
- ? values.metrics
- .filter((metric) => metric.measure && metric.measure !== "")
- .map((metric) => ({
- measure: metric.measure,
- aggregation: metric.aggregation,
- }))
- : [
- {
- measure: values.metrics[0]?.measure ?? "count",
- aggregation: values.metrics[0]?.aggregation ?? "count",
- },
- ];
+ // ---------------------------------------------------------------------------
+ // Cross-slice cascades — the ONLY writers of sibling fields. Each builds the
+ // candidate next state, HEALS it through the shared normalizeWidgetFormValues
+ // (resolve aggregation/chart type + drop unsupported dimensions), and commits
+ // the changed slices. This is the same healing the legacy resolve/breakdown
+ // effects did, run in the initiating event handler — so no view change,
+ // chart-type change, or measure change can leave the form invalid, and there
+ // is no effect.
+ // ---------------------------------------------------------------------------
- const needsTopN = isV2BreakdownChart({
- version: viewVersion,
- hasDimension: queryDimensions.length > 0,
- isTimeSeries: isTimeSeriesChart(chartType),
- chartType,
- });
+ // Applies a healed candidate to the changed slices; the final write validates.
+ const commitHealed = (
+ candidate: WidgetFormValues,
+ opts: { view?: boolean; filters?: boolean } = {},
+ ) => {
+ form.setValue("metrics", candidate.metrics);
+ form.setValue("dimensions", candidate.dimensions);
+ if (opts.filters) form.setValue("filters", candidate.filters);
+ if (opts.view) form.setValue("view", candidate.view);
+ form.setValue("chart.type", candidate.chart.type, { shouldValidate: true });
+ };
- const orderBy = buildWidgetOrderBy({
- chartType,
- sortState: previewSortState,
- needsTopN,
- firstMetric: {
- aggregation: values.metrics[0]?.aggregation ?? "count",
- measure: values.metrics[0]?.measure ?? "count",
- },
+ // View change (ports resetChartFieldsForView + setSelectedView + the mount
+ // resolve/breakdown-wipe healing so the post-view-change state is valid).
+ const onViewChange = (newView: z.infer<typeof views>) => {
+ if (newView === selectedView) return;
+ const newViewVersion = resolveWidgetFormVersion({
+ view: newView,
+ baseMinVersion,
+ activeVersion,
+ shape: values,
});
+ const newViewDeclaration = viewDeclarations[newViewVersion][newView];
- let chartConfig: QueryType["chartConfig"];
- if (chartType === "HISTOGRAM") {
- chartConfig = { type: chartType, bins: values.chart.bins };
- } else if (chartType === "PIVOT_TABLE" || needsTopN) {
- chartConfig = { type: chartType, row_limit: values.chart.rowLimit };
+ let metrics: WidgetFormValues["metrics"];
+ let dimensions: WidgetFormValues["dimensions"];
+ if (chartType === "PIVOT_TABLE") {
+ const validMetrics = values.metrics.filter(
+ (metric) => metric.measure in newViewDeclaration.measures,
+ );
+ metrics =
+ validMetrics.length > 0
+ ? validMetrics
+ : [{ measure: "count", aggregation: "count" }];
+ dimensions = values.dimensions.filter(
+ (dimension) => dimension.field in newViewDeclaration.dimensions,
+ );
} else {
- chartConfig = { type: chartType };
- }
-
- return {
- view: selectedView,
- dimensions: queryDimensions,
- metrics: queryMetrics,
- filters: [...normalizedUserFilters],
- timeDimension: isTimeSeriesChart(chartType)
- ? { granularity: "auto" }
- : null,
- fromTimestamp: fromTimestamp.toISOString(),
- toTimestamp: toTimestamp.toISOString(),
- orderBy,
- chartConfig,
- };
- }, [
- selectedView,
- values.metrics,
- values.dimensions,
- chartType,
- values.chart.bins,
- values.chart.rowLimit,
- dateRange,
- previewSortState,
- viewVersion,
- normalizedUserFilters,
- ]);
-
- const queryValidation = useMemo(() => {
- if (unsupportedFilters.length > 0) {
- return {
- valid: false as const,
- reason:
- `Unsupported legacy filter column(s): ${unsupportedFilterColumns}. ` +
- "Remove them or switch to a compatible view before saving this widget.",
- };
- }
- return validateQuery(query, viewVersion);
- }, [query, unsupportedFilterColumns, unsupportedFilters.length, viewVersion]);
-
- useCaptureWidgetHighCardinalityError({
- validation: queryValidation,
- surface: widgetId ? "edit_editor" : "create_editor",
- chartType,
- isV4: viewVersion === "v2",
- });
-
- const queryResult = api.dashboard.executeQuery.useQuery(
- {
- projectId,
- query,
- version: viewVersion,
- },
- {
- trpc: { context: { skipBatch: true } },
- meta: { silentHttpCodes: [412, 422] },
- enabled: queryValidation.valid,
- },
- );
-
- const chartLoadingState = getChartLoadingStateProps({
- isPending: queryResult.isPending,
- isError: queryResult.isError,
- });
- const loadingProgress = getChartLoadingProgress({
- isPending: queryResult.isPending,
- progress: null,
- useBackendProgress: false,
- });
-
- const selectedMeasure = values.metrics[0]?.measure ?? "count";
- const selectedAggregation = values.metrics[0]?.aggregation ?? "count";
- const selectedDimension = values.dimensions[0]?.field ?? "none";
-
- const transformedData: DataPoint[] = useMemo(
- () =>
- queryResult.data?.map((item: any) => {
- if (chartType === "PIVOT_TABLE") {
- return {
- dimension:
- values.dimensions.length > 0
- ? values.dimensions[0].field
- : "dimension",
- metric: 0,
- time_dimension: item["time_dimension"],
- ...item,
- };
- }
- const metricField = `${selectedAggregation}_${selectedMeasure}`;
- const metric = item[metricField];
- const dimensionField = selectedDimension;
- const dimensionValue = item[dimensionField];
- const isTimeSeries = isTimeSeriesChart(chartType);
-
- const isFillerMetricValue =
- metric == null ||
- (getWidgetMissingBucketValue(selectedAggregation) === "zero" &&
- Number(metric) === 0);
- if (
- isTimeSeries &&
- dimensionField !== "none" &&
- (dimensionValue === null || dimensionValue === "") &&
- isFillerMetricValue
- ) {
- return {
- dimension: undefined,
- metric: null,
- time_dimension: item["time_dimension"],
- };
- }
-
- return {
- dimension:
- dimensionValue !== undefined && dimensionField !== "none"
- ? (() => {
- const val = dimensionValue;
- if (val === null || val === undefined || val === "")
- return "n/a";
- if (typeof val === "string") return val;
- if (Array.isArray(val)) return val.join(", ");
- return String(val);
- })()
- : formatMetricName(metricField),
- metric: Array.isArray(metric)
- ? metric
- : isTimeSeries && metric == null
- ? null
- : Number(metric || 0),
- time_dimension: item["time_dimension"],
- };
- }) ?? [],
- [
- queryResult.data,
- selectedAggregation,
- selectedDimension,
- selectedMeasure,
- chartType,
- values.dimensions,
- ],
- );
-
- const chartPresentation = useMemo(() => {
- if (chartType === "PIVOT_TABLE") return undefined;
- return getWidgetMetricPresentation({
- metric: { measure: selectedMeasure, agg: selectedAggregation },
- view: selectedView,
- version: viewVersion,
- });
- }, [
- selectedAggregation,
- chartType,
- selectedMeasure,
- selectedView,
- viewVersion,
- ]);
-
- // ---------------------------------------------------------------------------
- // Cross-slice cascades — the ONLY writers of sibling fields. Each builds the
- // candidate next state, HEALS it through the shared normalizeWidgetFormValues
- // (resolve aggregation/chart type + drop unsupported dimensions), and commits
- // the changed slices. This is the same healing the legacy resolve/breakdown
- // effects did, run in the initiating event handler — so no view change,
- // chart-type change, or measure change can leave the form invalid, and there
- // is no effect.
- // ---------------------------------------------------------------------------
-
- // Applies a healed candidate to the changed slices; the final write validates.
- const commitHealed = (
- candidate: WidgetFormValues,
- opts: { view?: boolean; filters?: boolean } = {},
- ) => {
- form.setValue("metrics", candidate.metrics);
- form.setValue("dimensions", candidate.dimensions);
- if (opts.filters) form.setValue("filters", candidate.filters);
- if (opts.view) form.setValue("view", candidate.view);
- form.setValue("chart.type", candidate.chart.type, { shouldValidate: true });
- };
-
- // View change (ports resetChartFieldsForView + setSelectedView + the mount
- // resolve/breakdown-wipe healing so the post-view-change state is valid).
- const onViewChange = (newView: z.infer<typeof views>) => {
- if (newView === selectedView) return;
- const newViewVersion = resolveWidgetFormVersion({
- view: newView,
- baseMinVersion,
- activeVersion,
- shape: values,
- });
- const newViewDeclaration = viewDeclarations[newViewVersion][newView];
-
- let metrics: WidgetFormValues["metrics"];
- let dimensions: WidgetFormValues["dimensions"];
- if (chartType === "PIVOT_TABLE") {
- const validMetrics = values.metrics.filter(
- (metric) => metric.measure in newViewDeclaration.measures,
- );
- metrics =
- validMetrics.length > 0
- ? validMetrics
- : [{ measure: "count", aggregation: "count" }];
- dimensions = values.dimensions.filter(
- (dimension) => dimension.field in newViewDeclaration.dimensions,
- );
- } else {
- metrics = [{ measure: "count", aggregation: "count" }];
- dimensions = [];
+ metrics = [{ measure: "count", aggregation: "count" }];
+ dimensions = [];
}
// Filters are kept across view changes; MetricsFilterBuilder surfaces any
@@ -858,12 +519,6 @@ export function WidgetForm({
);
});
- const displayName = effectiveWidgetName(values.name, suggestions.name);
- const displayDescription = effectiveWidgetName(
- values.description,
- suggestions.description,
- );
-
const metricsForSort = values.metrics
.filter((metric) => metric.measure && metric.measure !== "")
.map((metric) => ({ id: `${metric.aggregation}_${metric.measure}` }));
@@ -878,329 +533,200 @@ export function WidgetForm({
: deriveSaveReason(formErrors);
return (
- <div className="flex h-full gap-4">
- {/* Left column - Form */}
- <div className="h-full w-1/3 min-w-[430px]">
- <Card className="flex h-full flex-col">
- <CardHeader>
- <div className="flex items-start justify-between gap-3">
- <CardTitle>Widget Configuration</CardTitle>
- {!widgetId && isV4 && (
- <WidgetImporter
- projectId={projectId}
- viewVersion={viewVersion}
- dateRange={dateRange}
- isV4={isV4}
- onImport={handleImportedWidget}
- />
- )}
- </div>
- <CardDescription>
- Configure your widget by selecting data and visualization options
- </CardDescription>
- </CardHeader>
- <CardContent className="space-y-4 overflow-y-auto">
- {isV4 && selectedView === "traces" && (
- <Alert variant="warning" icon={AlertCircle}>
- <Alert.Title>Traces view is not available in v4</Alert.Title>
- <Alert.Description>
- This widget uses the traces view which is not supported in v4.
- It will continue to use v3 definitions. To use v4, change the
- view to observations or scores.
- </Alert.Description>
- </Alert>
- )}
- {/* Data Selection Section */}
- <div className="space-y-4">
- <div className="flex items-center justify-between">
- <h3 className="text-lg font-bold">Data Selection</h3>
- {viewVersion === "v2" && (
- <Popover>
- <PopoverTrigger asChild>
- <Button variant="outline" size="sm">
- <Sparkles
- size="base"
- color="default"
- __rawClassName="mr-2"
- />
- Presets
- </Button>
- </PopoverTrigger>
- <PopoverContent className="w-64 p-1" align="end">
- {Object.entries(WIDGET_FILTER_PRESETS).map(
- ([key, preset]) => (
- <PopoverClose key={key} asChild>
- <Button
- className="w-full justify-start"
- variant="ghost"
- onClick={() => applyPreset(preset)}
- >
- <preset.icon size="base" __rawClassName="mr-2" />
- {preset.label}
- </Button>
- </PopoverClose>
- ),
- )}
- </PopoverContent>
- </Popover>
- )}
- </div>
-
- <ViewSelect
- control={form.control}
- ctx={ctx}
- availableViewOptions={availableViewOptions}
- onViewChange={onViewChange}
- />
-
- {/* Metrics Selection */}
- <div className="space-y-2">
- <Label htmlFor="metrics-select">
- {chartType === "PIVOT_TABLE" ? "Metrics" : "Metric"}
- </Label>
- {chartType === "PIVOT_TABLE" ? (
- <PivotMetricsField
- control={form.control}
- ctx={ctx}
- error={metricsError}
- getAvailablePivotMetrics={getAvailablePivotMetrics}
- getAvailablePivotAggregations={
- getAvailablePivotAggregations
- }
- />
- ) : (
- <SingleMetricField
- control={form.control}
- ctx={ctx}
- error={metricsError}
- measure={selectedMeasure}
- onMeasureChange={onMeasureChange}
- availableMetrics={singleChartMetrics}
- validAggregationsForMeasure={validAggregationsForMeasure}
- />
- )}
- </div>
-
- <FiltersField
- control={form.control}
+ <div className="h-full w-full">
+ <Card className="flex h-full flex-col">
+ <CardHeader>
+ <div className="flex items-start justify-between gap-3">
+ <CardTitle>Widget Configuration</CardTitle>
+ {!widgetId && isV4 && (
+ <WidgetImporter
projectId={projectId}
viewVersion={viewVersion}
dateRange={dateRange}
- selectedView={selectedView}
+ isV4={isV4}
+ onImport={handleImportedWidget}
/>
+ )}
+ </div>
+ <CardDescription>
+ Configure your widget by selecting data and visualization options
+ </CardDescription>
+ </CardHeader>
+ <CardContent className="space-y-4 overflow-y-auto">
+ {isV4 && selectedView === "traces" && (
+ <Alert variant="warning" icon={AlertCircle}>
+ <Alert.Title>Traces view is not available in v4</Alert.Title>
+ <Alert.Description>
+ This widget uses the traces view which is not supported in v4.
+ It will continue to use v3 definitions. To use v4, change the
+ view to observations or scores.
+ </Alert.Description>
+ </Alert>
+ )}
+ {/* Data Selection Section */}
+ <div className="space-y-4">
+ <div className="flex items-center justify-between">
+ <h3 className="text-lg font-bold">Data Selection</h3>
+ {viewVersion === "v2" && (
+ <Popover>
+ <PopoverTrigger asChild>
+ <Button variant="outline" size="sm">
+ <Sparkles
+ size="base"
+ color="default"
+ __rawClassName="mr-2"
+ />
+ Presets
+ </Button>
+ </PopoverTrigger>
+ <PopoverContent className="w-64 p-1" align="end">
+ {Object.entries(WIDGET_FILTER_PRESETS).map(
+ ([key, preset]) => (
+ <PopoverClose key={key} asChild>
+ <Button
+ className="w-full justify-start"
+ variant="ghost"
+ onClick={() => applyPreset(preset)}
+ >
+ <preset.icon size="base" __rawClassName="mr-2" />
+ {preset.label}
+ </Button>
+ </PopoverClose>
+ ),
+ )}
+ </PopoverContent>
+ </Popover>
+ )}
+ </div>
- {/* Dimension Selection - Regular charts (Breakdown) */}
- {widgetChartTypeSupportsBreakdown(chartType) &&
- chartType !== "PIVOT_TABLE" && (
- <BreakdownSelect
- control={form.control}
- ctx={ctx}
- error={dimensionsError}
- availableDimensions={availableDimensions}
- />
- )}
+ <ViewSelect
+ control={form.control}
+ ctx={ctx}
+ availableViewOptions={availableViewOptions}
+ onViewChange={onViewChange}
+ />
- {/* Pivot Table Dimension Selection */}
- {chartType === "PIVOT_TABLE" && (
- <PivotDimensionsField
+ {/* Metrics Selection */}
+ <div className="space-y-2">
+ <Label htmlFor="metrics-select">
+ {chartType === "PIVOT_TABLE" ? "Metrics" : "Metric"}
+ </Label>
+ {chartType === "PIVOT_TABLE" ? (
+ <PivotMetricsField
control={form.control}
ctx={ctx}
- error={dimensionsError}
- availableDimensions={availableDimensions}
+ error={metricsError}
+ getAvailablePivotMetrics={getAvailablePivotMetrics}
+ getAvailablePivotAggregations={getAvailablePivotAggregations}
/>
- )}
-
- {/* Pivot Table Default Sort Configuration */}
- {chartType === "PIVOT_TABLE" && (
- <PivotSortField
+ ) : (
+ <SingleMetricField
control={form.control}
- effectiveSort={effectiveSort}
- metricsForSort={metricsForSort}
+ ctx={ctx}
+ error={metricsError}
+ measure={selectedMeasure}
+ onMeasureChange={onMeasureChange}
+ availableMetrics={singleChartMetrics}
+ validAggregationsForMeasure={validAggregationsForMeasure}
/>
)}
</div>
- {/* Visualization Section */}
- <div className="mt-6 space-y-4">
- <h3 className="text-lg font-bold">Visualization</h3>
+ <FiltersField
+ filterData={filterData}
+ control={form.control}
+ selectedView={selectedView}
+ />
+
+ {/* Dimension Selection - Regular charts (Breakdown) */}
+ {widgetChartTypeSupportsBreakdown(chartType) &&
+ chartType !== "PIVOT_TABLE" && (
+ <BreakdownSelect
+ control={form.control}
+ ctx={ctx}
+ error={dimensionsError}
+ availableDimensions={availableDimensions}
+ />
+ )}
- <NameField control={form.control} suggestion={suggestions.name} />
- <DescriptionField
+ {/* Pivot Table Dimension Selection */}
+ {chartType === "PIVOT_TABLE" && (
+ <PivotDimensionsField
control={form.control}
- suggestion={suggestions.description}
+ ctx={ctx}
+ error={dimensionsError}
+ availableDimensions={availableDimensions}
/>
+ )}
- <ChartTypeSelect
- value={chartType}
- onChartTypeChange={onChartTypeChange}
- measureSupportsHistogram={measureSupportsHistogram}
- error={chartTypeError}
+ {/* Pivot Table Default Sort Configuration */}
+ {chartType === "PIVOT_TABLE" && (
+ <PivotSortField
+ control={form.control}
+ effectiveSort={effectiveSort}
+ metricsForSort={metricsForSort}
/>
+ )}
+ </div>
+
+ {/* Visualization Section */}
+ <div className="mt-6 space-y-4">
+ <h3 className="text-lg font-bold">Visualization</h3>
+
+ <NameField control={form.control} suggestion={suggestions.name} />
+ <DescriptionField
+ control={form.control}
+ suggestion={suggestions.description}
+ />
- <div className="space-y-2">
- <Label htmlFor="date-select">Date Range</Label>
- <DatePickerWithRange
+ <ChartTypeSelect
+ control={form.control}
+ value={chartType}
+ onChartTypeChange={onChartTypeChange}
+ measureSupportsHistogram={measureSupportsHistogram}
+ error={chartTypeError}
+ />
+
+ <FormField label="Date Range">
+ {(field) => (
+ <WidgetDateRangeInput
+ id={field.id}
+ aria-describedby={field.inputDescribedById}
dateRange={dateRange}
- setDateRangeAndOption={(option, range) => {
- if (option === "custom") {
- setDateRangeAndOption("custom", range);
- } else {
- setDateRangeAndOption(option, range);
- }
- }}
+ setDateRangeAndOption={setDateRangeAndOption}
selectedOption={
(selectedOption ?? "custom") as DashboardDateRangeOptions
}
- className="w-full"
/>
- </div>
-
- {chartType === "HISTOGRAM" && (
- <HistogramBinsField control={form.control} />
)}
+ </FormField>
- {widgetChartTypeSupportsBreakdown(chartType) &&
- !isTimeSeriesChart(chartType) && (
- <RowLimitField control={form.control} />
- )}
- </div>
- </CardContent>
- <CardFooter className="mt-auto flex-col items-stretch gap-2">
- {saveDisabled && saveDisabledReason && (
- <p role="alert" className="text-destructive text-xs">
- {saveDisabledReason}
- </p>
+ {chartType === "HISTOGRAM" && (
+ <HistogramBinsField control={form.control} />
)}
- <Button
- className="w-full"
- size="lg"
- onClick={onSubmit}
- disabled={saveDisabled}
- >
- Save Widget
- </Button>
- </CardFooter>
- </Card>
- </div>
- {/* Right column - Chart */}
- <div className="w-2/3">
- <Card className="flex aspect-video flex-col">
- <CardHeader>
- <CardTitle className="truncate" title={displayName}>
- {displayName}
- </CardTitle>
- <CardDescription className="truncate" title={displayDescription}>
- {displayDescription}
- </CardDescription>
- </CardHeader>
- {!queryValidation.valid ? (
- <CardContent>
- <div className="flex h-[300px] items-center justify-center">
- <div className="w-full max-w-sm">
- <Alert variant="destructive" icon={AlertCircle}>
- <Alert.Title>Invalid query</Alert.Title>
- <Alert.Description>
- {queryValidation.reason}
- </Alert.Description>
- </Alert>
- </div>
- </div>
- </CardContent>
- ) : queryResult.data || chartLoadingState.isLoading ? (
- <div className="flex min-h-0 flex-1 flex-col">
- <div className="relative min-h-0 flex-1">
- <Chart
- chartType={chartType}
- data={transformedData}
- config={
- chartPresentation
- ? { metric: { label: chartPresentation.label } }
- : undefined
- }
- rowLimit={values.chart.rowLimit}
- chartConfig={
- chartType === "PIVOT_TABLE"
- ? {
- type: chartType,
- dimensions: pivotDimensionFields,
- row_limit: values.chart.rowLimit,
- metrics: values.metrics.map(
- (metric) =>
- `${metric.aggregation}_${metric.measure}`,
- ),
- units: values.metrics.map((metric) =>
- getResultUnit(
- selectedView,
- metric.measure,
- metric.aggregation,
- viewVersion,
- ),
- ),
- defaultSort: effectiveSort ?? undefined,
- }
- : chartType === "HISTOGRAM"
- ? {
- type: chartType,
- bins: values.chart.bins,
- unit: getResultUnit(
- selectedView,
- selectedMeasure,
- selectedAggregation,
- viewVersion,
- ),
- }
- : {
- type: chartType,
- row_limit: values.chart.rowLimit,
- unit: getResultUnit(
- selectedView,
- selectedMeasure,
- selectedAggregation,
- viewVersion,
- ),
- }
- }
- sortState={
- chartType === "PIVOT_TABLE" ? previewSortState : undefined
- }
- onSortChange={undefined}
- isLoading={queryResult.isPending}
- metricFormatter={chartPresentation?.metricFormatter}
- missingValue={getWidgetMissingBucketValue(
- selectedAggregation,
- )}
- />
- {chartLoadingState.isLoading && (
- <ChartLoadingState
- showSpinner={chartLoadingState.showSpinner}
- showHintImmediately={chartLoadingState.showHintImmediately}
- hintText={chartLoadingState.hintText}
- progress={loadingProgress}
- className="bg-background/80 absolute inset-0 z-20 backdrop-blur-xs"
- />
- )}
- </div>
- </div>
- ) : (
- <CardContent>
- <div className="flex h-[300px] items-center justify-center">
- {chartLoadingState.isLoading ? (
- <ChartLoadingState
- showSpinner={chartLoadingState.showSpinner}
- showHintImmediately={chartLoadingState.showHintImmediately}
- hintText={chartLoadingState.hintText}
- progress={loadingProgress}
- />
- ) : (
- <p className="text-muted-foreground">
- Waiting for Input / Loading...
- </p>
- )}
- </div>
- </CardContent>
+
+ {widgetChartTypeSupportsBreakdown(chartType) &&
+ !isTimeSeriesChart(chartType) && (
+ <RowLimitField control={form.control} />
+ )}
+ </div>
+ </CardContent>
+ <CardFooter className="mt-auto flex-col items-stretch gap-2">
+ {saveDisabled && saveDisabledReason && (
+ <p role="alert" className="text-destructive text-xs">
+ {saveDisabledReason}
+ </p>
)}
- </Card>
- </div>
+ <Button
+ className="w-full"
+ size="lg"
+ onClick={onSubmit}
+ disabled={saveDisabled}
+ >
+ Save Widget
+ </Button>
+ </CardFooter>
+ </Card>
</div>
);
}
@@ -1212,6 +738,64 @@ export function WidgetForm({
// onMeasureChange); no child pokes a sibling field or calls `watch`.
// -----------------------------------------------------------------------------
+function WidgetDateRangeInput({
+ id,
+ "aria-describedby": ariaDescribedBy,
+ dateRange,
+ selectedOption,
+ setDateRangeAndOption,
+}: {
+ id: string;
+ "aria-describedby"?: string;
+ dateRange?: { from: Date; to: Date };
+ selectedOption: DashboardDateRangeOptions;
+ setDateRangeAndOption: (
+ option: DashboardDateRangeOptions,
+ date?: { from: Date; to: Date },
+ ) => void;
+}) {
+ const lookbackLimit = useEntitlementLimit("data-access-days");
+
+ const handlePresetChange = (option: DashboardDateRangeOptions) => {
+ if (option === "custom") return;
+ const now = new Date();
+ const minutes = dashboardDateRangeAggregationSettings[option].minutes;
+ if (minutes === null) return;
+ setDateRangeAndOption(option, {
+ from: addMinutes(now, -minutes),
+ to: now,
+ });
+ };
+ const handleCustomChange = (range: { from: Date; to: Date }) => {
+ setDateRangeAndOption("custom", range);
+ };
+
+ return (
+ <DateRangeInput
+ id={id}
+ aria-describedby={ariaDescribedBy}
+ earliestDate={
+ lookbackLimit === false
+ ? undefined
+ : addMinutes(new Date(), -lookbackLimit * 24 * 60)
+ }
+ value={selectedOption}
+ customValue="custom"
+ range={dateRange}
+ presets={DASHBOARD_AGGREGATION_OPTIONS.map((option) => ({
+ value: option,
+ label: getTimeRangeLabel(option),
+ disabled: !isDashboardDateRangeOptionAvailable({
+ option,
+ limitDays: lookbackLimit,
+ }),
+ }))}
+ onPresetChange={handlePresetChange}
+ onCustomChange={handleCustomChange}
+ />
+ );
+}
+
function ViewSelect({
control,
ctx,
@@ -1223,29 +807,30 @@ function ViewSelect({
availableViewOptions: typeof views | typeof viewsV2;
onViewChange: (view: z.infer<typeof views>) => void;
}) {
- const { field } = useController({ control, name: "view" });
return (
- <div className="space-y-2">
- <Label htmlFor="view-select">View</Label>
- <Select
- value={field.value}
- onValueChange={(value) => onViewChange(value as z.infer<typeof views>)}
- >
- <SelectTrigger id="view-select">
- <SelectValue placeholder="Select a view" />
- </SelectTrigger>
- <SelectContent>
- {availableViewOptions.options.map((view) => (
- <WidgetPropertySelectItem
- key={view}
- value={view}
- label={startCase(view)}
- description={viewDeclarations[ctx.viewVersion][view].description}
- />
- ))}
- </SelectContent>
- </Select>
- </div>
+ <FormField control={control} name="view" label="View">
+ {(field) => (
+ <SelectInput
+ value={field.value}
+ onValueChange={(value) =>
+ onViewChange(value as z.infer<typeof views>)
+ }
+ id={field.id}
+ placeholder="Select a view"
+ error={Boolean(field.error)}
+ aria-invalid={Boolean(field.error)}
+ aria-describedby={field.inputDescribedById}
+ options={availableViewOptions.options.map((view) => ({
+ value: view,
+ label: startCase(view),
+ explanation: {
+ title: startCase(view),
+ description: viewDeclarations[ctx.viewVersion][view].description,
+ },
+ }))}
+ />
+ )}
+ </FormField>
);
}
@@ -1284,57 +869,52 @@ function SingleMetricField({
<div className="space-y-2">
<div className="flex items-center gap-2">
<div className="flex-1">
- <Select
+ <SelectInput
value={measure}
onValueChange={(value) => onMeasureChange(value)}
- >
- <SelectTrigger
- id="metrics-select"
- aria-invalid={error ? true : undefined}
- aria-describedby={error ? "single-metric-error" : undefined}
- >
- <SelectValue placeholder="Select metrics" />
- </SelectTrigger>
- <SelectContent>
- {availableMetrics.map((metric) => {
- const meta =
- viewDeclarations[ctx.viewVersion][ctx.view]?.measures?.[
- metric.value
- ];
- return (
- <WidgetPropertySelectItem
- key={metric.value}
- value={metric.value}
- label={metric.label}
- description={meta?.description}
- unit={meta?.unit}
- type={meta?.type}
- />
- );
- })}
- </SelectContent>
- </Select>
+ id="metrics-select"
+ placeholder="Select metrics"
+ error={Boolean(error)}
+ aria-invalid={error ? true : undefined}
+ aria-describedby={error ? "single-metric-error" : undefined}
+ options={availableMetrics.map((metric) => {
+ const meta =
+ viewDeclarations[ctx.viewVersion][ctx.view]?.measures?.[
+ metric.value
+ ];
+ return {
+ ...metric,
+ explanation: {
+ title: metric.label,
+ description: meta?.description,
+ badges: [
+ ...(meta?.unit
+ ? [{ label: "Unit", value: meta.unit }]
+ : []),
+ ...(meta?.type
+ ? [{ label: "Type", value: meta.type }]
+ : []),
+ ],
+ },
+ };
+ })}
+ />
</div>
{measure !== "count" && (
<div className="flex-1">
- <Select
+ <SelectInput
value={aggField.value}
disabled={ctx.chartType === "HISTOGRAM"}
onValueChange={(value) =>
aggField.onChange(value as z.infer<typeof metricAggregations>)
}
- >
- <SelectTrigger id="aggregation-select">
- <SelectValue placeholder="Select Aggregation" />
- </SelectTrigger>
- <SelectContent>
- {aggregationOptions.map((aggregation) => (
- <SelectItem key={aggregation} value={aggregation}>
- {startCase(aggregation)}
- </SelectItem>
- ))}
- </SelectContent>
- </Select>
+ id="aggregation-select"
+ placeholder="Select Aggregation"
+ options={aggregationOptions.map((aggregation) => ({
+ value: aggregation,
+ label: startCase(aggregation),
+ }))}
+ />
</div>
)}
</div>
@@ -1455,54 +1035,52 @@ function PivotMetricsField({
</div>
<div className="flex items-center gap-2">
<div className="flex-1">
- <Select
+ <SelectInput
value={currentMeasure}
onValueChange={(value) =>
updateMetric(index, value, undefined)
}
disabled={!isEnabled || !canEdit}
- >
- <SelectTrigger
- id={`pivot-metric-${index}`}
- aria-invalid={error && index === 0 ? true : undefined}
- aria-describedby={
- error && index === 0 ? "pivot-metrics-error" : undefined
- }
- >
- <SelectValue
- placeholder={
- !isEnabled
- ? "Select previous metric first"
- : !canEdit
- ? "No more measures available"
- : "Select measure"
- }
- />
- </SelectTrigger>
- <SelectContent>
- {metricsForIndex.map((metric) => {
- const meta =
- viewDeclarations[ctx.viewVersion][ctx.view]?.measures?.[
- metric.value
- ];
- return (
- <WidgetPropertySelectItem
- key={metric.value}
- value={metric.value}
- label={metric.label}
- description={meta?.description}
- unit={meta?.unit}
- type={meta?.type}
- />
- );
- })}
- </SelectContent>
- </Select>
+ id={`pivot-metric-${index}`}
+ error={Boolean(error && index === 0)}
+ aria-invalid={error && index === 0 ? true : undefined}
+ aria-describedby={
+ error && index === 0 ? "pivot-metrics-error" : undefined
+ }
+ placeholder={
+ !isEnabled
+ ? "Select previous metric first"
+ : !canEdit
+ ? "No more measures available"
+ : "Select measure"
+ }
+ options={metricsForIndex.map((metric) => {
+ const meta =
+ viewDeclarations[ctx.viewVersion][ctx.view]?.measures?.[
+ metric.value
+ ];
+ return {
+ ...metric,
+ explanation: {
+ title: metric.label,
+ description: meta?.description,
+ badges: [
+ ...(meta?.unit
+ ? [{ label: "Unit", value: meta.unit }]
+ : []),
+ ...(meta?.type
+ ? [{ label: "Type", value: meta.type }]
+ : []),
+ ],
+ },
+ };
+ })}
+ />
</div>
{currentMeasure && currentMeasure !== "count" && (
<div className="flex-1">
- <Select
+ <SelectInput
value={currentAggregation}
onValueChange={(value) =>
updateMetric(
@@ -1511,18 +1089,12 @@ function PivotMetricsField({
value as z.infer<typeof metricAggregations>,
)
}
- >
- <SelectTrigger>
- <SelectValue placeholder="Select aggregation" />
- </SelectTrigger>
- <SelectContent>
- {aggregationsForIndex.map((aggregation) => (
- <SelectItem key={aggregation} value={aggregation}>
- {startCase(aggregation)}
- </SelectItem>
- ))}
- </SelectContent>
- </Select>
+ placeholder="Select aggregation"
+ options={aggregationsForIndex.map((aggregation) => ({
+ value: aggregation,
+ label: startCase(aggregation),
+ }))}
+ />
</div>
)}
</div>
@@ -1553,29 +1125,21 @@ function PivotMetricsField({
}
function FiltersField({
+ filterData,
control,
- projectId,
- viewVersion,
- dateRange,
selectedView,
}: {
+ filterData: ReturnType<typeof useMetricsFilterBuilderData>;
control: Control<WidgetFormValues>;
- projectId: string;
- viewVersion: ViewVersion;
- dateRange: { from: Date; to: Date } | undefined;
selectedView: z.infer<typeof views>;
}) {
- // MetricsFilterBuilder owns the column schema, the UI-table translation, and
- // the unsupported-column banner.
const { field } = useController({ control, name: "filters" });
return (
<div className="space-y-2">
<Label>Filters</Label>
<MetricsFilterBuilder
- version={viewVersion}
+ {...filterData}
view={selectedView}
- projectId={projectId}
- dateRange={dateRange}
filters={field.value}
onChange={(next: FilterState) => field.onChange(next)}
/>
@@ -1595,50 +1159,50 @@ function BreakdownSelect({
availableDimensions: { value: string; label: string }[];
}) {
// Owns the entire `dimensions` slice; a non-pivot chart carries at most one.
- const { field } = useController({ control, name: "dimensions" });
- const value = field.value[0]?.field ?? "none";
return (
- <div className="space-y-2">
- <Label htmlFor="dimension-select">Breakdown Dimension (Optional)</Label>
- <Select
- value={value}
- onValueChange={(next) =>
- field.onChange(next === "none" ? [] : [{ field: next }])
- }
- >
- <SelectTrigger
- id="dimension-select"
- aria-invalid={error ? true : undefined}
- aria-describedby={error ? "breakdown-error" : undefined}
- >
- <SelectValue placeholder="Select a dimension" />
- </SelectTrigger>
- <SelectContent>
- <SelectItem value="none">None</SelectItem>
- {availableDimensions.map((dimension) => {
- const meta =
- viewDeclarations[ctx.viewVersion][ctx.view]?.dimensions?.[
- dimension.value
- ];
- return (
- <WidgetPropertySelectItem
- key={dimension.value}
- value={dimension.value}
- label={dimension.label}
- description={meta?.description}
- unit={meta?.unit}
- type={meta?.type}
- />
- );
- })}
- </SelectContent>
- </Select>
- {error && (
- <p id="breakdown-error" className="text-destructive text-xs">
- {error}
- </p>
+ <FormField
+ control={control}
+ name="dimensions"
+ label="Breakdown Dimension (Optional)"
+ >
+ {(field) => (
+ <SelectInput
+ value={field.value[0]?.field ?? "none"}
+ onValueChange={(next) =>
+ field.onChange(next === "none" ? [] : [{ field: next }])
+ }
+ id={field.id}
+ placeholder="Select a dimension"
+ error={Boolean(error || field.error)}
+ aria-invalid={Boolean(error || field.error)}
+ aria-describedby={field.inputDescribedById}
+ options={[
+ { value: "none", label: "None" },
+ ...availableDimensions.map((dimension) => {
+ const meta =
+ viewDeclarations[ctx.viewVersion][ctx.view]?.dimensions?.[
+ dimension.value
+ ];
+ return {
+ ...dimension,
+ explanation: {
+ title: dimension.label,
+ description: meta?.description,
+ badges: [
+ ...(meta?.unit
+ ? [{ label: "Unit", value: meta.unit }]
+ : []),
+ ...(meta?.type
+ ? [{ label: "Type", value: meta.type }]
+ : []),
+ ],
+ },
+ };
+ }),
+ ]}
+ />
)}
- </div>
+ </FormField>
);
}
@@ -1686,48 +1250,48 @@ function PivotDimensionsField({
<Label htmlFor={`pivot-dimension-${index}`}>
Dimension {index + 1} (Optional)
</Label>
- <Select
+ <SelectInput
value={currentValue}
onValueChange={(value) => updateDimension(index, value)}
disabled={!isEnabled}
- >
- <SelectTrigger
- id={`pivot-dimension-${index}`}
- aria-invalid={error && index === 0 ? true : undefined}
- aria-describedby={
- error && index === 0 ? "pivot-dimensions-error" : undefined
- }
- >
- <SelectValue
- placeholder={
- isEnabled
- ? "Select a dimension"
- : "Select previous dimension first"
- }
- />
- </SelectTrigger>
- <SelectContent>
- <SelectItem value="none">None</SelectItem>
- {availableDimensions
+ id={`pivot-dimension-${index}`}
+ error={Boolean(error && index === 0)}
+ aria-invalid={error && index === 0 ? true : undefined}
+ aria-describedby={
+ error && index === 0 ? "pivot-dimensions-error" : undefined
+ }
+ placeholder={
+ isEnabled
+ ? "Select a dimension"
+ : "Select previous dimension first"
+ }
+ options={[
+ { value: "none", label: "None" },
+ ...availableDimensions
.filter((d) => !selectedDimensions.includes(d.value))
.map((dimension) => {
const meta =
viewDeclarations[ctx.viewVersion][ctx.view]?.dimensions?.[
dimension.value
];
- return (
- <WidgetPropertySelectItem
- key={dimension.value}
- value={dimension.value}
- label={dimension.label}
- description={meta?.description}
- unit={meta?.unit}
- type={meta?.type}
- />
- );
- })}
- </SelectContent>
- </Select>
+ return {
+ ...dimension,
+ explanation: {
+ title: dimension.label,
+ description: meta?.description,
+ badges: [
+ ...(meta?.unit
+ ? [{ label: "Unit", value: meta.unit }]
+ : []),
+ ...(meta?.type
+ ? [{ label: "Type", value: meta.type }]
+ : []),
+ ],
+ },
+ };
+ }),
+ ]}
+ />
</div>
);
})}
@@ -1751,7 +1315,6 @@ function PivotSortField({
}) {
// Owns chart.sort; the DISPLAY value is always the sanitized effectiveSort so
// a stale sort column shows as "no default sort" without any write-back.
- const { field } = useController({ control, name: "chart.sort" });
const column = effectiveSort?.column ?? "none";
const order = effectiveSort?.order ?? "DESC";
@@ -1766,47 +1329,47 @@ function PivotSortField({
</div>
<div className="grid grid-cols-2 gap-4">
- <div className="space-y-2">
- <Label htmlFor="default-sort-column">Sort Column</Label>
- <Select
- value={column}
- onValueChange={(next) =>
- field.onChange(next === "none" ? null : { column: next, order })
- }
- >
- <SelectTrigger id="default-sort-column">
- <SelectValue placeholder="Select a column to sort by" />
- </SelectTrigger>
- <SelectContent>
- <SelectItem value="none">No default sort</SelectItem>
- {metricsForSort.map((metric) => (
- <SelectItem key={metric.id} value={metric.id}>
- {formatMetricName(metric.id)}
- </SelectItem>
- ))}
- </SelectContent>
- </Select>
- </div>
-
- <div className="space-y-2">
- <Label htmlFor="default-sort-order">Sort Order</Label>
- <Select
- value={order}
- onValueChange={(value: "ASC" | "DESC") =>
- field.onChange({ column, order: value })
- }
- disabled={column === "none"}
- >
- <SelectTrigger id="default-sort-order">
- <SelectValue />
- </SelectTrigger>
- <SelectContent>
- <SelectItem value="ASC">Ascending (A-Z)</SelectItem>
- <SelectItem value="DESC">Descending (Z-A)</SelectItem>
- </SelectContent>
- </Select>
- </div>
- </div>
+ <FormField control={control} name="chart.sort" label="Sort Column">
+ {(field) => (
+ <SelectInput
+ value={column}
+ onValueChange={(next) =>
+ field.onChange(next === "none" ? null : { column: next, order })
+ }
+ id={field.id}
+ placeholder="Select a column to sort by"
+ error={Boolean(field.error)}
+ aria-invalid={Boolean(field.error)}
+ aria-describedby={field.inputDescribedById}
+ options={[
+ { value: "none", label: "No default sort" },
+ ...metricsForSort.map((metric) => ({
+ value: metric.id,
+ label: formatMetricName(metric.id),
+ })),
+ ]}
+ />
+ )}
+ </FormField>
+
+ <FormField control={control} name="chart.sort" label="Sort Order">
+ {(field) => (
+ <SelectInput
+ value={order}
+ onValueChange={(value: "ASC" | "DESC") =>
+ field.onChange({ column, order: value })
+ }
+ disabled={column === "none"}
+ id={field.id}
+ placeholder="Select sort order"
+ options={[
+ { value: "ASC", label: "Ascending (A-Z)" },
+ { value: "DESC", label: "Descending (Z-A)" },
+ ]}
+ />
+ )}
+ </FormField>
+ </div>
</div>
);
}
@@ -1826,21 +1389,24 @@ function NameField({
control: Control<WidgetFormValues>;
suggestion: string;
}) {
- const { field } = useController({ control, name: "name" });
return (
- <div className="space-y-2">
- <Label htmlFor="widget-name">Name</Label>
- <Input
- id="widget-name"
- // A blank/whitespace-only override shows the live suggestion; typing
- // real content sticks; clearing reverts to tracking + saving the
- // suggestion. Uses the same trim-aware effective logic as the preview
- // title and toSavePayload, so input, preview, and saved value agree.
- value={effectiveWidgetName(field.value, suggestion)}
- onChange={(e) => field.onChange(e.target.value)}
- placeholder="Enter widget name"
- />
- </div>
+ <FormField control={control} name="name" label="Name">
+ {(field) => (
+ <Input
+ id={field.id}
+ aria-invalid={Boolean(field.error)}
+ aria-describedby={field.inputDescribedById}
+ error={Boolean(field.error)}
+ // A blank/whitespace-only override shows the live suggestion; typing
+ // real content sticks; clearing reverts to tracking + saving the
+ // suggestion. Uses the same trim-aware effective logic as the preview
+ // title and toSavePayload, so input, preview, and saved value agree.
+ value={effectiveWidgetName(field.value, suggestion)}
+ onChange={(e) => field.onChange(e.target.value)}
+ placeholder="Enter widget name"
+ />
+ )}
+ </FormField>
);
}
@@ -1851,88 +1417,89 @@ function DescriptionField({
control: Control<WidgetFormValues>;
suggestion: string;
}) {
- const { field } = useController({ control, name: "description" });
return (
- <div className="space-y-2">
- <Label htmlFor="widget-description">Description</Label>
- <Input
- id="widget-description"
- value={effectiveWidgetName(field.value, suggestion)}
- onChange={(e) => field.onChange(e.target.value)}
- placeholder="Enter widget description"
- />
- </div>
+ <FormField control={control} name="description" label="Description">
+ {(field) => (
+ <Input
+ id={field.id}
+ aria-invalid={Boolean(field.error)}
+ aria-describedby={field.inputDescribedById}
+ error={Boolean(field.error)}
+ value={effectiveWidgetName(field.value, suggestion)}
+ onChange={(e) => field.onChange(e.target.value)}
+ placeholder="Enter widget description"
+ />
+ )}
+ </FormField>
);
}
function ChartTypeSelect({
+ control,
value,
onChartTypeChange,
measureSupportsHistogram,
error,
}: {
+ control: Control<WidgetFormValues>;
value: DashboardWidgetChartType;
onChartTypeChange: (type: DashboardWidgetChartType) => void;
measureSupportsHistogram: boolean;
error?: string;
}) {
return (
- <div className="space-y-2">
- <Label htmlFor="chart-type-select">Chart Type</Label>
- <Select
- value={value}
- onValueChange={(next) =>
- onChartTypeChange(next as DashboardWidgetChartType)
- }
- >
- <SelectTrigger
- id="chart-type-select"
- aria-invalid={error ? true : undefined}
- aria-describedby={error ? "chart-type-error" : undefined}
- >
- <SelectValue placeholder="Select a chart type" />
- </SelectTrigger>
- <SelectContent>
- <SelectGroup>
- <SelectLabel>Time Series</SelectLabel>
- {chartTypes
- .filter((item) => item.group === "time-series")
- .map((chart) => (
- <SelectItem key={chart.value} value={chart.value}>
- <div className="flex items-center gap-2">
- <chart.icon size="base" />
- <span>{chart.name}</span>
- </div>
- </SelectItem>
- ))}
- </SelectGroup>
- <SelectGroup>
- <SelectLabel>Total Value</SelectLabel>
- {chartTypes
- .filter((item) => item.group === "total-value")
- .map((chart) => (
- <SelectItem
- key={chart.value}
- value={chart.value}
- disabled={
- chart.value === "HISTOGRAM" && !measureSupportsHistogram
- }
- >
- <div className="flex items-center gap-2">
- <chart.icon size="base" />
- <span>{chart.name}</span>
- </div>
- </SelectItem>
- ))}
- </SelectGroup>
- </SelectContent>
- </Select>
- {error && (
- <p id="chart-type-error" className="text-destructive text-xs">
- {error}
- </p>
+ <FormField control={control} name="chart.type" label="Chart Type">
+ {(field) => (
+ <SelectInput
+ value={value}
+ onValueChange={(next) =>
+ onChartTypeChange(next as DashboardWidgetChartType)
+ }
+ id={field.id}
+ placeholder="Select a chart type"
+ error={Boolean(error || field.error)}
+ aria-invalid={Boolean(error || field.error)}
+ aria-describedby={field.inputDescribedById}
+ options={[
+ {
+ type: "group",
+ id: "time-series",
+ label: "Time Series",
+ options: chartTypes
+ .filter((chart) => chart.group === "time-series")
+ .map((chart) => ({
+ value: chart.value,
+ label: chart.name,
+ icon: chart.icon,
+ })),
+ },
+ {
+ type: "group",
+ id: "total-value",
+ label: "Total Value",
+ options: chartTypes
+ .filter((chart) => chart.group === "total-value")
+ .map((chart) =>
+ chart.value === "HISTOGRAM" && !measureSupportsHistogram
+ ? {
+ value: chart.value,
+ label: chart.name,
+ icon: chart.icon,
+ disabled: true as const,
+ disabledReason:
+ "Histogram is not supported for this metric",
+ }
+ : {
+ value: chart.value,
+ label: chart.name,
+ icon: chart.icon,
+ },
+ ),
+ },
+ ]}
+ />
)}
- </div>
+ </FormField>
);
}
@@ -1941,47 +1508,346 @@ function HistogramBinsField({
}: {
control: Control<WidgetFormValues>;
}) {
- const { field } = useController({ control, name: "chart.bins" });
return (
- <div className="space-y-2">
- <Label htmlFor="histogram-bins">Number of Bins (1-100)</Label>
- <Input
- id="histogram-bins"
- type="number"
- min={1}
- max={100}
- value={field.value}
- onChange={(e) => {
- const value = parseInt(e.target.value);
- if (!isNaN(value) && value >= 1 && value <= 100) {
- field.onChange(value);
- }
- }}
- placeholder="Enter number of bins (1-100)"
- />
- </div>
+ <FormField
+ control={control}
+ name="chart.bins"
+ label="Number of Bins (1-100)"
+ >
+ {(field) => (
+ <Input
+ id={field.id}
+ type="number"
+ min={1}
+ max={100}
+ aria-invalid={Boolean(field.error)}
+ aria-describedby={field.inputDescribedById}
+ error={Boolean(field.error)}
+ value={field.value}
+ onChange={(e) => {
+ const value = parseInt(e.target.value);
+ if (!isNaN(value) && value >= 1 && value <= 100) {
+ field.onChange(value);
+ }
+ }}
+ placeholder="Enter number of bins (1-100)"
+ />
+ )}
+ </FormField>
);
}
function RowLimitField({ control }: { control: Control<WidgetFormValues> }) {
- const { field } = useController({ control, name: "chart.rowLimit" });
return (
- <div className="space-y-2">
- <Label htmlFor="row-limit">Breakdown Row Limit (0-1000)</Label>
- <Input
- id="row-limit"
- type="number"
- min={0}
- max={1000}
- value={field.value}
- onChange={(e) => {
- const value = parseInt(e.target.value);
- if (!isNaN(value) && value >= 0 && value <= 1000) {
- field.onChange(value);
- }
- }}
- placeholder="Enter breakdown row limit (0-1000)"
- />
- </div>
+ <FormField
+ control={control}
+ name="chart.rowLimit"
+ label="Breakdown Row Limit (0-1000)"
+ >
+ {(field) => (
+ <Input
+ id={field.id}
+ type="number"
+ min={0}
+ max={1000}
+ aria-invalid={Boolean(field.error)}
+ aria-describedby={field.inputDescribedById}
+ error={Boolean(field.error)}
+ value={field.value}
+ onChange={(e) => {
+ const value = parseInt(e.target.value);
+ if (!isNaN(value) && value >= 0 && value <= 1000) {
+ field.onChange(value);
+ }
+ }}
+ placeholder="Enter breakdown row limit (0-1000)"
+ />
+ )}
+ </FormField>
);
}
+
+export function useWidgetFormState({
+ initialValues,
+ projectId,
+ onSave,
+ widgetId,
+}: {
+ initialValues: WidgetInitialValues;
+ projectId: string;
+ onSave: (widgetData: WidgetSavePayload) => void;
+ widgetId?: string;
+}) {
+ const { isV4 } = useReadPath();
+
+ // The initial widget's persisted version is a local hint frozen at mount.
+ // The resolver and live viewVersion additionally derive v2 from the current
+ // form shape; the server derives the value that gets persisted.
+ const baseMinVersion = deriveWidgetBaseMinVersion(initialValues);
+ const activeVersion: ViewVersion = isV4 ? "v2" : "v1";
+
+ // The auto-suggestions change on every keystroke; a ref keeps the resolver
+ // closure from being rebuilt on each one (the filled name/description do not
+ // affect validity — name/description are nullable with no min).
+ const suggestionsRef = useRef<{ name: string; description: string }>({
+ name: "",
+ description: "",
+ });
+
+ // Precompute both version schemas/resolvers once. A blank name/description is
+ // filled with the live suggestion and the filters are mapped into view space
+ // before zod (mirrors MonitorForm).
+ const resolversByVersion = useMemo(
+ () => ({
+ v1: zodResolver(makeWidgetFormSchema("v1") as any),
+ v2: zodResolver(makeWidgetFormSchema("v2") as any),
+ }),
+ [],
+ );
+ // The schema version is derived INSIDE the resolver from the (mapped) view
+ // being validated — not from a render-written ref — so it is never render
+ // stale after a version-flipping view or import. baseMinVersion and
+ // activeVersion are in the dep list so either promotion rebuilds the closure
+ // (react-hook-form re-reads control._options each render).
+ const resolver = useMemo<Resolver<WidgetFormValues>>(() => {
+ return (values, context, options) => {
+ const v = values as WidgetFormValues;
+ const suggestions = suggestionsRef.current;
+ const mapped = {
+ ...v,
+ name: effectiveWidgetName(v.name, suggestions.name),
+ description: effectiveWidgetName(
+ v.description,
+ suggestions.description,
+ ),
+ // mapWidgetUiTableFilterToView MUST stay idempotent: the form holds
+ // editor-space filters, and both this validation path and toSavePayload
+ // map them to view space independently.
+ filters: mapWidgetUiTableFilterToView(v.view, v.filters ?? []),
+ };
+ const version = resolveWidgetFormVersion({
+ view: mapped.view,
+ baseMinVersion,
+ activeVersion,
+ shape: mapped,
+ });
+ return resolversByVersion[version](mapped as any, context, options);
+ };
+ }, [resolversByVersion, baseMinVersion, activeVersion]);
+
+ // The initial view version, derived from initialValues alone (view is known
+ // before the form mounts) so the seed can normalize against the right view
+ // declaration.
+ const initialViewVersion = resolveWidgetFormVersion({
+ view: initialValues.view,
+ baseMinVersion,
+ activeVersion,
+ });
+
+ const form = useForm<WidgetFormValues>({
+ resolver,
+ defaultValues: toDefaultValues(initialValues, initialViewVersion),
+ mode: "onChange",
+ });
+
+ // THE single useWatch. Everything below is derived from `values` once.
+ const values = useWatch({ control: form.control }) as WidgetFormValues;
+
+ const selectedView = values.view;
+ const chartType = values.chart.type;
+ const viewVersion = resolveWidgetFormVersion({
+ view: selectedView,
+ baseMinVersion,
+ activeVersion,
+ shape: values,
+ });
+ const suggestions = deriveWidgetSuggestions(values);
+ const effectiveSort = deriveEffectiveSort(values);
+
+ suggestionsRef.current = suggestions;
+
+ // Preview time range. The picker here is a transient PREVIEW control — the
+ // widget does not own a time range, so it must not write the user's shared
+ // cross-view default. Kept as LOCAL state (not RHF).
+ const { timeRange, setTimeRange } = useDashboardDateRange({
+ defaultRelativeAggregation: "last7Days",
+ persistAsDefault: false,
+ });
+ const dateRange = useMemo(
+ () => toAbsoluteTimeRange(timeRange) ?? undefined,
+ [timeRange],
+ );
+ const selectedOption = useMemo(() => {
+ if ("range" in timeRange) return timeRange.range;
+ return "custom" as const;
+ }, [timeRange]);
+ const setDateRangeAndOption = (
+ option: DashboardDateRangeOptions,
+ range?: { from: Date; to: Date },
+ ) => {
+ if (option === "custom") {
+ if (range) setTimeRange({ from: range.from, to: range.to });
+ } else {
+ setTimeRange({ range: option });
+ }
+ };
+ const unsupportedFilters = useMemo(
+ () =>
+ partitionWidgetUiTableFiltersToView(selectedView, values.filters)
+ .unsupportedFilters,
+ [selectedView, values.filters],
+ );
+ const unsupportedFilterColumns = useMemo(
+ () =>
+ Array.from(
+ new Set(unsupportedFilters.map((filter) => filter.column)),
+ ).join(", "),
+ [unsupportedFilters],
+ );
+ const normalizedUserFilters = useMemo(
+ () => mapWidgetUiTableFilterToView(selectedView, values.filters),
+ [selectedView, values.filters],
+ );
+
+ const previewSortState = effectiveSort ?? null;
+ const pivotDimensionFields = values.dimensions.map((d) => d.field);
+
+ // Preview query. Depends ONLY on the fields that affect it — not
+ // name/description.
+ const query = useMemo<QueryType>(() => {
+ const fromTimestamp = dateRange
+ ? dateRange.from
+ : new Date(new Date().getTime() - 7 * 24 * 60 * 60 * 1000);
+ const toTimestamp = dateRange ? dateRange.to : new Date();
+
+ const queryDimensions =
+ chartType === "PIVOT_TABLE"
+ ? values.dimensions.map((d) => ({ field: d.field }))
+ : values.dimensions.length > 0
+ ? [{ field: values.dimensions[0].field }]
+ : [];
+
+ const queryMetrics =
+ chartType === "PIVOT_TABLE"
+ ? values.metrics
+ .filter((metric) => metric.measure && metric.measure !== "")
+ .map((metric) => ({
+ measure: metric.measure,
+ aggregation: metric.aggregation,
+ }))
+ : [
+ {
+ measure: values.metrics[0]?.measure ?? "count",
+ aggregation: values.metrics[0]?.aggregation ?? "count",
+ },
+ ];
+
+ const needsTopN = isV2BreakdownChart({
+ version: viewVersion,
+ hasDimension: queryDimensions.length > 0,
+ isTimeSeries: isTimeSeriesChart(chartType),
+ chartType,
+ });
+
+ const orderBy = buildWidgetOrderBy({
+ chartType,
+ sortState: previewSortState,
+ needsTopN,
+ firstMetric: {
+ aggregation: values.metrics[0]?.aggregation ?? "count",
+ measure: values.metrics[0]?.measure ?? "count",
+ },
+ });
+
+ let chartConfig: QueryType["chartConfig"];
+ if (chartType === "HISTOGRAM") {
+ chartConfig = { type: chartType, bins: values.chart.bins };
+ } else if (chartType === "PIVOT_TABLE" || needsTopN) {
+ chartConfig = { type: chartType, row_limit: values.chart.rowLimit };
+ } else {
+ chartConfig = { type: chartType };
+ }
+
+ return {
+ view: selectedView,
+ dimensions: queryDimensions,
+ metrics: queryMetrics,
+ filters: [...normalizedUserFilters],
+ timeDimension: isTimeSeriesChart(chartType)
+ ? { granularity: "auto" }
+ : null,
+ fromTimestamp: fromTimestamp.toISOString(),
+ toTimestamp: toTimestamp.toISOString(),
+ orderBy,
+ chartConfig,
+ };
+ }, [
+ selectedView,
+ values.metrics,
+ values.dimensions,
+ chartType,
+ values.chart.bins,
+ values.chart.rowLimit,
+ dateRange,
+ previewSortState,
+ viewVersion,
+ normalizedUserFilters,
+ ]);
+
+ const queryValidation = useMemo(() => {
+ if (unsupportedFilters.length > 0) {
+ return {
+ valid: false as const,
+ reason:
+ `Unsupported legacy filter column(s): ${unsupportedFilterColumns}. ` +
+ "Remove them or switch to a compatible view before saving this widget.",
+ };
+ }
+ return validateQuery(query, viewVersion);
+ }, [query, unsupportedFilterColumns, unsupportedFilters.length, viewVersion]);
+
+ useCaptureWidgetHighCardinalityError({
+ validation: queryValidation,
+ surface: widgetId ? "edit_editor" : "create_editor",
+ chartType,
+ isV4: viewVersion === "v2",
+ });
+
+ const selectedMeasure = values.metrics[0]?.measure ?? "count";
+ const selectedAggregation = values.metrics[0]?.aggregation ?? "count";
+ const selectedDimension = values.dimensions[0]?.field ?? "none";
+
+ const displayName = effectiveWidgetName(values.name, suggestions.name);
+ const displayDescription = effectiveWidgetName(
+ values.description,
+ suggestions.description,
+ );
+
+ return {
+ form,
+ onSave,
+ baseMinVersion,
+ activeVersion,
+ projectId,
+ query,
+ selectedDimension,
+ widgetId,
+ isV4,
+ viewVersion,
+ dateRange,
+ selectedView,
+ chartType,
+ selectedMeasure,
+ effectiveSort,
+ suggestions,
+ setDateRangeAndOption,
+ selectedOption,
+ displayName,
+ displayDescription,
+ queryValidation,
+ values,
+ pivotDimensionFields,
+ selectedAggregation,
+ previewSortState,
+ };
+}
diff --git a/web/src/features/widgets/index.ts b/web/src/features/widgets/index.ts
index f212e6425f..ac6bd5f801 100644
--- a/web/src/features/widgets/index.ts
+++ b/web/src/features/widgets/index.ts
@@ -39,5 +39,5 @@ export type {
WidgetImport,
} from "@/src/features/widgets/utils/import-export-utils";
export { DashboardWidget } from "@/src/features/widgets/components/DashboardWidget";
-export { WidgetForm } from "@/src/features/widgets/components/WidgetForm";
+export { ConnectedWidgetForm } from "@/src/features/widgets/components/ConnectedWidgetForm";
export { ConnectedDashboardWidgetTable } from "@/src/features/widgets/components/WidgetTable/ConnectedWidgetTable";
diff --git a/web/src/utils/date-range-utils.ts b/web/src/utils/date-range-utils.ts
index 0394ecfcdf..954cf34fbc 100644
--- a/web/src/utils/date-range-utils.ts
+++ b/web/src/utils/date-range-utils.ts
@@ -10,7 +10,6 @@ export {
type TableDateRangeAggregationOption,
type AbsoluteTimeRange,
type TimeRange,
- getAbbreviatedTimeRange,
rangeToString,
} from "@langfuse/shared";
import {
@@ -27,7 +26,6 @@ const ABBREVIATION_TO_KEY = new Map(
);
export const DEFAULT_DASHBOARD_AGGREGATION_SELECTION = "last1Day" as const;
-export const DASHBOARD_AGGREGATION_PLACEHOLDER = "custom" as const;
export const DASHBOARD_AGGREGATION_OPTIONS = [
"last5Minutes",
@@ -49,18 +47,13 @@ export type TableDateRange = {
to?: Date;
};
-export type DashboardDateRange = {
- from: Date;
- to: Date;
-};
-
type DateRangeAggregationOption =
| DashboardDateRangeAggregationOption
| TableDateRangeAggregationOption;
export type DashboardDateRangeOptions =
| DashboardDateRangeAggregationOption
- | typeof DASHBOARD_AGGREGATION_PLACEHOLDER;
+ | "custom";
export type DashboardDateRangeAggregationSettings = Record<
DashboardDateRangeAggregationOption,