@workflow/web-shared 5.0.0-beta.4 → 5.0.0-beta.40

package/src/components/ui/timestamp-tooltip.tsx

@@ -1,15 +1,20 @@
 'use client';
 
 import type { ReactNode } from 'react';
-import { useEffect, useRef, useState } from 'react';
-import { createPortal } from 'react-dom';
+import { useEffect, useState } from 'react';
+import {
+  ContextCardProvider,
+  ContextCardTrigger,
+  type ContextCardTriggerProps,
+  useHasContextCardProvider,
+} from './context-card';
 
 // ---------------------------------------------------------------------------
 // Time formatting helpers
 // ---------------------------------------------------------------------------
 
 interface TimeUnit {
-  unit: string;
+  unit: Intl.RelativeTimeFormatUnit;
   ms: number;
 }
 
@@ -38,25 +43,69 @@ function formatTimeDifference(diff: number): string {
   return result.join(', ');
 }
 
-function useTimeAgo(date: number): string {
+/**
+ * Detailed relative time string that auto-updates every second
+ * (e.g. "2 hours, 15 minutes, 30 seconds ago"). Used inside the hover card.
+ */
+export function useTimeAgo(date: number): string {
   const [timeAgo, setTimeAgo] = useState<string>('');
 
   useEffect(() => {
-    const update = (): void => {
+    const updateTimeAgo = (): void => {
       const diff = Date.now() - date;
-      const formatted = formatTimeDifference(diff);
-      setTimeAgo(formatted ? `${formatted} ago` : 'Just now');
+      const formattedDiff = formatTimeDifference(diff);
+      setTimeAgo(formattedDiff ? `${formattedDiff} ago` : 'Just now');
     };
-    update();
-    const timer = setInterval(update, 1000);
+
+    updateTimeAgo();
+    const timer = setInterval(updateTimeAgo, 1000);
     return () => clearInterval(timer);
   }, [date]);
 
   return timeAgo;
 }
 
+/**
+ * Short relative time string that auto-updates every minute
+ * (e.g. "3 days ago", "5 hours ago"). Returns an empty string if `date` is
+ * nullish.
+ */
+export function useShortTimeAgo(date: number | null | undefined): string {
+  const [shortTimeAgo, setShortTimeAgo] = useState<string>('');
+
+  useEffect(() => {
+    if (!date) {
+      setShortTimeAgo('');
+      return;
+    }
+
+    const updateShortTimeAgo = (): void => {
+      const diff = Date.now() - date;
+      const days = Math.floor(diff / (1000 * 60 * 60 * 24));
+      const hours = Math.floor(diff / (1000 * 60 * 60));
+      const minutes = Math.floor(diff / (1000 * 60));
+
+      if (days > 0) {
+        setShortTimeAgo(`${days} day${days > 1 ? 's' : ''} ago`);
+      } else if (hours > 0) {
+        setShortTimeAgo(`${hours} hour${hours > 1 ? 's' : ''} ago`);
+      } else if (minutes > 0) {
+        setShortTimeAgo(`${minutes} minute${minutes > 1 ? 's' : ''} ago`);
+      } else {
+        setShortTimeAgo('Just now');
+      }
+    };
+
+    updateShortTimeAgo();
+    const timer = setInterval(updateShortTimeAgo, 60000);
+    return () => clearInterval(timer);
+  }, [date]);
+
+  return shortTimeAgo;
+}
+
 // ---------------------------------------------------------------------------
-// Timezone row
+// Hover card content
 // ---------------------------------------------------------------------------
 
 function ZoneDateTimeRow({
@@ -91,86 +140,34 @@ function ZoneDateTimeRow({
   });
 
   return (
-    <div
-      style={{
-        display: 'flex',
-        alignItems: 'center',
-        justifyContent: 'space-between',
-        gap: 12,
-      }}
-    >
-      <div style={{ display: 'flex', alignItems: 'center', gap: 6 }}>
-        <div
-          style={{
-            display: 'inline-flex',
-            alignItems: 'center',
-            justifyContent: 'center',
-            height: 16,
-            padding: '0 6px',
-            backgroundColor: 'var(--ds-gray-200)',
-            borderRadius: 3,
-            fontSize: 11,
-            fontFamily: 'var(--font-mono, monospace)',
-            fontWeight: 500,
-            color: 'var(--ds-gray-900)',
-            whiteSpace: 'nowrap',
-          }}
-        >
-          {formattedZone}
+    <div className="flex items-center justify-between gap-3">
+      <div className="flex items-center gap-1.5">
+        <div className="flex items-center justify-center h-4 px-1.5 bg-gray-200 rounded-xs">
+          <span className="text-label-12-mono text-gray-900">
+            {formattedZone}
+          </span>
         </div>
-        <span
-          style={{
-            fontSize: 13,
-            color: 'var(--ds-gray-1000)',
-            whiteSpace: 'nowrap',
-          }}
-        >
-          {formattedDate}
-        </span>
+        <span className="text-label-13 text-gray-1000">{formattedDate}</span>
       </div>
-      <span
-        style={{
-          fontSize: 11,
-          fontFamily: 'var(--font-mono, monospace)',
-          fontVariantNumeric: 'tabular-nums',
-          color: 'var(--ds-gray-900)',
-          whiteSpace: 'nowrap',
-        }}
-      >
+      <span className="tabular-nums text-label-12-mono text-gray-900">
         {formattedTime}
       </span>
     </div>
   );
 }
 
-// ---------------------------------------------------------------------------
-// Tooltip card content
-// ---------------------------------------------------------------------------
-
-function TimestampTooltipContent({ date }: { date: number }): ReactNode {
+function RelativeTimeContextCardContent({ date }: { date: number }): ReactNode {
   const localTimezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
   const timeAgo = useTimeAgo(date);
 
   return (
-    <div
-      style={{
-        display: 'flex',
-        flexDirection: 'column',
-        gap: 12,
-        minWidth: 300,
-        padding: '12px 14px',
-      }}
-    >
-      <span
-        style={{
-          fontSize: 13,
-          fontVariantNumeric: 'tabular-nums',
-          color: 'var(--ds-gray-900)',
-        }}
-      >
-        {timeAgo}
-      </span>
-      <div style={{ display: 'flex', flexDirection: 'column', gap: 8 }}>
+    <div className="flex flex-col gap-3 min-w-[300px]">
+      <div className="flex flex-col gap-3">
+        <span className="tabular-nums text-label-13 text-gray-900">
+          {timeAgo}
+        </span>
+      </div>
+      <div className="flex flex-col gap-2">
         <ZoneDateTimeRow date={date} zone="UTC" />
         <ZoneDateTimeRow date={date} zone={localTimezone} />
       </div>
@@ -178,102 +175,75 @@ function TimestampTooltipContent({ date }: { date: number }): ReactNode {
   );
 }
 
+function DefaultTimeText({
+  date,
+}: {
+  date: number | null | undefined;
+}): ReactNode {
+  const shortTimeAgo = useShortTimeAgo(date);
+  return <span className="text-label-14 text-gray-900">{shortTimeAgo}</span>;
+}
+
 // ---------------------------------------------------------------------------
-// Hover tooltip wrapper
+// RelativeTimeCard
 // ---------------------------------------------------------------------------
 
-const TOOLTIP_WIDTH = 330;
-const VIEWPORT_PAD = 8;
-
-function TooltipPortal({
-  triggerRect,
-  onMouseEnter,
-  onMouseLeave,
+type RelativeTimeCardProps = Omit<
+  ContextCardTriggerProps,
+  'content' | 'children'
+> & {
+  /** Timestamp in milliseconds to display as a relative time. */
+  date?: number | null;
+  /** Custom content to render instead of the default relative time text. */
+  children?: ReactNode;
+};
+
+/**
+ * Relative time label that reveals a context card with detailed UTC and local
+ * timestamps on hover. Renders a default short relative time label (e.g.
+ * "3 days ago") when `children` is omitted; renders just the children without
+ * the hover card when `date` is nullish.
+ */
+export function RelativeTimeCard({
   date,
-}: {
-  triggerRect: DOMRect;
-  onMouseEnter: () => void;
-  onMouseLeave: () => void;
-  date: number;
-}): ReactNode {
-  const tooltipRef = useRef<HTMLDivElement>(null);
-  const [style, setStyle] = useState<React.CSSProperties>({
-    position: 'fixed',
-    zIndex: 9999,
-    visibility: 'hidden',
-  });
+  children: _children,
+  ...props
+}: RelativeTimeCardProps): ReactNode {
+  const children =
+    _children === undefined ? <DefaultTimeText date={date} /> : _children;
 
-  useEffect(() => {
-    const placement = triggerRect.top > 240 ? 'above' : 'below';
-    const centerX = triggerRect.left + triggerRect.width / 2;
-
-    const el = tooltipRef.current;
-    const w = el ? el.offsetWidth : TOOLTIP_WIDTH;
-    const h = el ? el.offsetHeight : 100;
-
-    let left = centerX - w / 2;
-    left = Math.max(
-      VIEWPORT_PAD,
-      Math.min(left, window.innerWidth - w - VIEWPORT_PAD)
-    );
-
-    let top: number;
-    if (placement === 'above') {
-      top = triggerRect.top - h - 6;
-      if (top < VIEWPORT_PAD) {
-        top = triggerRect.bottom + 6;
-      }
-    } else {
-      top = triggerRect.bottom + 6;
-      if (top + h > window.innerHeight - VIEWPORT_PAD) {
-        top = triggerRect.top - h - 6;
-      }
-    }
+  if (!date) return children;
 
-    setStyle({
-      position: 'fixed',
-      left,
-      top,
-      zIndex: 9999,
-      borderRadius: 10,
-      border: '1px solid var(--ds-gray-alpha-200)',
-      backgroundColor: 'var(--ds-background-100)',
-      boxShadow: '0 4px 12px rgba(0,0,0,0.08), 0 1px 3px rgba(0,0,0,0.06)',
-      visibility: 'visible',
-    });
-  }, [triggerRect]);
-
-  return createPortal(
-    // biome-ignore lint/a11y/noStaticElementInteractions: tooltip hover zone
-    <div
-      ref={tooltipRef}
-      onMouseEnter={onMouseEnter}
-      onMouseLeave={onMouseLeave}
-      style={style}
+  return (
+    <ContextCardTrigger
+      content={<RelativeTimeContextCardContent date={date} />}
+      {...props}
     >
-      <TimestampTooltipContent date={date} />
-    </div>,
-    document.body
+      {children}
+    </ContextCardTrigger>
   );
 }
 
+// ---------------------------------------------------------------------------
+// TimestampTooltip — convenience wrapper used across the observability UI
+// ---------------------------------------------------------------------------
+
+/**
+ * Wraps an already-formatted timestamp display with a relative-time hover
+ * card. Self-mounts a {@link ContextCardProvider} when one isn't already
+ * present so it works anywhere, but shares a provider (enabling the animated
+ * card morph between adjacent timestamps) when rendered inside one.
+ */
 export function TimestampTooltip({
   date,
   children,
+  side = 'top',
 }: {
   date: number | Date | string | null | undefined;
   children: ReactNode;
+  side?: ContextCardTriggerProps['side'];
 }): ReactNode {
-  const [open, setOpen] = useState(false);
-  const [triggerRect, setTriggerRect] = useState<DOMRect | null>(null);
-  const triggerRef = useRef<HTMLSpanElement>(null);
-  const closeTimer = useRef<ReturnType<typeof setTimeout> | null>(null);
-
-  useEffect(() => {
-    return () => {
-      if (closeTimer.current) clearTimeout(closeTimer.current);
-    };
-  }, []);
+  const hasProvider = useHasContextCardProvider();
 
   const ts =
     date == null
@@ -284,43 +254,11 @@ export function TimestampTooltip({
 
   if (ts == null || Number.isNaN(ts)) return <>{children}</>;
 
-  const cancelClose = () => {
-    if (closeTimer.current) {
-      clearTimeout(closeTimer.current);
-      closeTimer.current = null;
-    }
-  };
-
-  const scheduleClose = () => {
-    cancelClose();
-    closeTimer.current = setTimeout(() => setOpen(false), 120);
-  };
-
-  const handleOpen = () => {
-    cancelClose();
-    if (triggerRef.current) {
-      setTriggerRect(triggerRef.current.getBoundingClientRect());
-    }
-    setOpen(true);
-  };
-
-  return (
-    // biome-ignore lint/a11y/noStaticElementInteractions: tooltip trigger
-    <span
-      ref={triggerRef}
-      onMouseEnter={handleOpen}
-      onMouseLeave={scheduleClose}
-      style={{ display: 'inline-flex' }}
-    >
+  const card = (
+    <RelativeTimeCard date={ts} side={side} asChild>
       {children}
-      {open && triggerRect && (
-        <TooltipPortal
-          triggerRect={triggerRect}
-          onMouseEnter={cancelClose}
-          onMouseLeave={scheduleClose}
-          date={ts}
-        />
-      )}
-    </span>
+    </RelativeTimeCard>
   );
+
+  return hasProvider ? card : <ContextCardProvider>{card}</ContextCardProvider>;
 }

package/src/components/ui/tooltip.tsx

@@ -0,0 +1,47 @@
+'use client';
+
+import * as TooltipPrimitive from '@radix-ui/react-tooltip';
+import * as React from 'react';
+import { cn } from '../../lib/cn';
+
+const TooltipProvider = TooltipPrimitive.Provider;
+
+const Tooltip = TooltipPrimitive.Root;
+
+const TooltipTrigger = TooltipPrimitive.Trigger;
+
+const TooltipContent = React.forwardRef<
+  React.ElementRef<typeof TooltipPrimitive.Content>,
+  React.ComponentPropsWithoutRef<typeof TooltipPrimitive.Content> & {
+    showArrow?: boolean;
+  }
+>(
+  (
+    { className, sideOffset = 8, showArrow = true, children, ...props },
+    ref
+  ) => (
+    <TooltipPrimitive.Portal>
+      <TooltipPrimitive.Content
+        ref={ref}
+        sideOffset={sideOffset}
+        className={cn(
+          'z-[99999] flex items-center gap-1 rounded-[10px] bg-gray-1000 px-2 py-1.5 !text-label-13 text-background-100 shadow-md select-none',
+          className
+        )}
+        {...props}
+      >
+        {children}
+        {showArrow ? (
+          <TooltipPrimitive.Arrow
+            width={11}
+            height={5}
+            className="fill-gray-1000"
+          />
+        ) : null}
+      </TooltipPrimitive.Content>
+    </TooltipPrimitive.Portal>
+  )
+);
+TooltipContent.displayName = TooltipPrimitive.Content.displayName;
+
+export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider };

package/src/components/workflow-traces/event-colors.ts

@@ -2,7 +2,7 @@
  * Color utilities for workflow event markers
  */
 
-import type { Event } from '@workflow/world';
+import { type Event, isHookLifecycleEventType } from '@workflow/world';
 
 export interface EventColorPalette {
   /** Color of the diamond/marker itself */
@@ -22,6 +22,7 @@ export interface EventColorPalette {
  * - Red for failures (step_failed, run_failed)
  * - Orange/yellow for retries (step_retrying)
  * - Purple for webhook-related events
+ * - Teal for attribute changes (attr_set)
  * - Blue otherwise (default)
  */
 export function getEventColor(
@@ -50,11 +51,7 @@ export function getEventColor(
   }
 
   // Webhook-related - Purple
-  if (
-    eventType === 'hook_created' ||
-    eventType === 'hook_received' ||
-    eventType === 'hook_disposed'
-  ) {
+  if (isHookLifecycleEventType(eventType)) {
     return {
       color: 'var(--ds-purple-600)',
       background: 'var(--ds-purple-100)',
@@ -64,6 +61,17 @@ export function getEventColor(
     };
   }
 
+  // Attribute changes - Teal
+  if (eventType === 'attr_set') {
+    return {
+      color: 'var(--ds-teal-900)',
+      background: 'var(--ds-teal-200)',
+      border: 'var(--ds-teal-500)',
+      text: 'var(--ds-teal-900)',
+      secondary: 'var(--ds-gray-900)',
+    };
+  }
+
   // Default - Blue
   return {
     color: 'var(--ds-blue-600)',
@@ -81,11 +89,7 @@ export function getEventColor(
  */
 export function shouldShowVerticalLine(eventType: Event['eventType']): boolean {
   // Show vertical lines for hook-related events
-  if (
-    eventType === 'hook_created' ||
-    eventType === 'hook_received' ||
-    eventType === 'hook_disposed'
-  ) {
+  if (isHookLifecycleEventType(eventType)) {
     return true;
   }
 

package/src/components/workflow-traces/trace-span-construction.test.ts

@@ -0,0 +1,85 @@
+import type { Event, WorkflowRun } from '@workflow/world';
+import { describe, expect, it } from 'vitest';
+import { runToSpan } from './trace-span-construction';
+import { otelTimeToMs } from './trace-time-utils';
+
+const date = (ms: number) => new Date(ms);
+
+function run(overrides: Partial<WorkflowRun> = {}): WorkflowRun {
+  return {
+    runId: 'run_1',
+    status: 'completed',
+    deploymentId: 'dpl_1',
+    workflowName: 'workflow//./workflow//testWorkflow',
+    specVersion: 2,
+    attributes: {},
+    createdAt: date(1_000),
+    updatedAt: date(6_000),
+    startedAt: date(2_000),
+    completedAt: date(6_000),
+    output: null,
+    ...overrides,
+  } as WorkflowRun;
+}
+
+function event(overrides: Partial<Event>): Event {
+  return {
+    runId: 'run_1',
+    eventId: `evt_${overrides.eventType ?? 'unknown'}`,
+    eventType: 'run_created',
+    createdAt: date(1_000),
+    specVersion: 2,
+    eventData: {
+      deploymentId: 'dpl_1',
+      workflowName: 'workflow//./workflow//testWorkflow',
+      input: null,
+    },
+    ...overrides,
+  } as Event;
+}
+
+describe('runToSpan', () => {
+  it('prefers occurredAt for run span timing when available', () => {
+    const span = runToSpan(
+      run(),
+      [
+        event({
+          eventType: 'run_created',
+          createdAt: date(1_000),
+          occurredAt: date(100),
+        }),
+        event({
+          eventType: 'run_started',
+          createdAt: date(2_000),
+          occurredAt: date(200),
+        }),
+        event({
+          eventType: 'run_completed',
+          createdAt: date(6_000),
+          occurredAt: date(500),
+        }),
+      ],
+      date(10_000)
+    );
+
+    expect(otelTimeToMs(span.startTime)).toBe(100);
+    expect(
+      span.activeStartTime ? otelTimeToMs(span.activeStartTime) : undefined
+    ).toBe(200);
+    expect(otelTimeToMs(span.endTime)).toBe(500);
+    expect(
+      span.events.find((e) => e.name === 'run_created')?.timestamp
+    ).toEqual([0, 100_000_000]);
+
+    const data = span.attributes.data as {
+      createdAt: Date;
+      startedAt?: Date;
+      completedAt?: Date;
+      occurredAt?: Date;
+    };
+    expect(data.createdAt).toEqual(date(100));
+    expect(data.startedAt).toEqual(date(200));
+    expect(data.completedAt).toEqual(date(500));
+    expect(data).not.toHaveProperty('occurredAt');
+  });
+});