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

package/dist/components/trace-viewer/components/middle-truncate/copy-selection.js

@@ -0,0 +1,54 @@
+import { ELLIPSIS, toGraphemes } from './truncate';
+function getMiddleTruncateCopyText({ prefixText, selectionEnd, selectionStart, suffixText, value, }) {
+    const visibleText = prefixText + ELLIPSIS + suffixText;
+    if (selectionStart < 0 ||
+        selectionEnd > visibleText.length ||
+        selectionStart >= selectionEnd) {
+        return null;
+    }
+    if (selectionStart === 0 && selectionEnd === visibleText.length) {
+        return value;
+    }
+    const ellipsisStart = prefixText.length;
+    const ellipsisEnd = ellipsisStart + ELLIPSIS.length;
+    if (selectionStart > ellipsisStart || selectionEnd < ellipsisEnd) {
+        return null;
+    }
+    const originalGraphemes = toGraphemes(value);
+    const selectedPrefixGraphemeCount = toGraphemes(visibleText.slice(0, selectionStart)).length;
+    const selectedSuffixGraphemeCount = toGraphemes(visibleText.slice(ellipsisEnd, selectionEnd)).length;
+    const suffixStart = originalGraphemes.length - toGraphemes(suffixText).length;
+    return originalGraphemes
+        .slice(selectedPrefixGraphemeCount, suffixStart + selectedSuffixGraphemeCount)
+        .join('');
+}
+function getMiddleTruncateCopyTextFromSelectionText({ prefixText, selectionText, suffixText, value, }) {
+    const visibleText = prefixText + ELLIPSIS + suffixText;
+    const trimmedSelectionText = selectionText.trim();
+    if (!trimmedSelectionText) {
+        return null;
+    }
+    const leading = selectionText.slice(0, selectionText.length - selectionText.trimStart().length);
+    const trailing = selectionText.slice(selectionText.trimEnd().length);
+    if (trimmedSelectionText === visibleText) {
+        return leading + value + trailing;
+    }
+    if (!trimmedSelectionText.includes(ELLIPSIS)) {
+        return null;
+    }
+    const selectionStart = visibleText.indexOf(trimmedSelectionText);
+    if (selectionStart === -1) {
+        return null;
+    }
+    const selectionEnd = selectionStart + trimmedSelectionText.length;
+    const mappedText = getMiddleTruncateCopyText({
+        prefixText,
+        selectionEnd,
+        selectionStart,
+        suffixText,
+        value,
+    });
+    return mappedText === null ? null : leading + mappedText + trailing;
+}
+export { getMiddleTruncateCopyText, getMiddleTruncateCopyTextFromSelectionText, };
+//# sourceMappingURL=data:application/json;base64,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

package/dist/components/trace-viewer/components/middle-truncate/middle-truncate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"middle-truncate.d.ts","sourceRoot":"","sources":["../../../../../src/components/trace-viewer/components/middle-truncate/middle-truncate.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAkB,wBAAwB,EAAE,GAAG,EAAE,MAAM,OAAO,CAAC;AAU3E,sDAAsD;AACtD,UAAU,mBACR,SAAQ,IAAI,CAAC,wBAAwB,CAAC,MAAM,CAAC,EAAE,UAAU,CAAC;IAC1D,oFAAoF;IACpF,KAAK,EAAE,MAAM,CAAC;CACf;AA2BD;;;;;;;;;GASG;AACH,iBAAS,cAAc,CAAC,EACtB,KAAK,EACL,SAAS,EACT,MAAM,EAAE,UAAU,EAClB,GAAG,KAAK,EACT,EAAE,mBAAmB,GAAG,GAAG,CAAC,OAAO,CA8FnC;AAED,OAAO,EAAE,cAAc,EAAE,CAAC;AAC1B,YAAY,EAAE,mBAAmB,EAAE,CAAC"}

package/dist/components/trace-viewer/components/middle-truncate/middle-truncate.js

@@ -0,0 +1,81 @@
+'use client';
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useRef } from 'react';
+import { cn } from '../../../../lib/cn';
+import { getMiddleTruncateCopyText, getMiddleTruncateCopyTextFromSelectionText, } from './copy-selection';
+import { ELLIPSIS } from './truncate';
+import { useMiddleTruncate } from './use-middle-truncate';
+function getRangeOffsets(container, range) {
+    if (!container.contains(range.startContainer) ||
+        !container.contains(range.endContainer)) {
+        return null;
+    }
+    const startRange = document.createRange();
+    startRange.selectNodeContents(container);
+    startRange.setEnd(range.startContainer, range.startOffset);
+    const endRange = document.createRange();
+    endRange.selectNodeContents(container);
+    endRange.setEnd(range.endContainer, range.endOffset);
+    return {
+        end: endRange.toString().length,
+        start: startRange.toString().length,
+    };
+}
+/**
+ * @gdoc
+ *
+ * Truncates text from the middle with an ellipsis when it overflows, preserving the beginning and end (e.g. file paths, URLs). Copy behavior restores the full untruncated text to the clipboard.
+ * Renders a `<span>` element.
+ *
+ * Documentation: [Geist Middle Truncate](https://vercel.com/geist/middle-truncate)
+ *
+ * @param value - Full text string to display.
+ */
+function MiddleTruncate({ value, className, onCopy: onCopyProp, ...props }) {
+    const { ref, measureRef, displayText, isTruncated, prefixText, suffixText } = useMiddleTruncate(value);
+    const visibleRef = useRef(null);
+    const handleCopy = useCallback((e) => {
+        onCopyProp?.(e);
+        if (e.defaultPrevented || !isTruncated)
+            return;
+        const selection = window.getSelection();
+        if (!selection || selection.rangeCount === 0)
+            return;
+        const selectionText = selection.toString();
+        if (!selectionText)
+            return;
+        // Only intercept when the selection is fully within this element.
+        // If the user selected across elements (e.g. a table row), let
+        // the browser's default behavior preserve surrounding context.
+        const range = selection.getRangeAt(0);
+        const visibleEl = visibleRef.current;
+        let copyText = null;
+        if (e.currentTarget.contains(range.startContainer) &&
+            e.currentTarget.contains(range.endContainer) &&
+            visibleEl) {
+            const offsets = getRangeOffsets(visibleEl, range);
+            if (offsets) {
+                copyText = getMiddleTruncateCopyText({
+                    prefixText,
+                    selectionEnd: offsets.end,
+                    selectionStart: offsets.start,
+                    suffixText,
+                    value,
+                });
+            }
+        }
+        copyText ??= getMiddleTruncateCopyTextFromSelectionText({
+            prefixText,
+            selectionText,
+            suffixText,
+            value,
+        });
+        if (copyText === null)
+            return;
+        e.preventDefault();
+        e.clipboardData.setData('text/plain', copyText);
+    }, [onCopyProp, isTruncated, prefixText, suffixText, value]);
+    return (_jsxs("span", { title: isTruncated ? value : undefined, ...props, ref: ref, className: cn('relative inline-grid min-w-0 max-w-full overflow-hidden whitespace-nowrap', className), onCopy: handleCopy, children: [isTruncated && _jsx("span", { className: "sr-only select-none", children: value }), _jsx("span", { "aria-hidden": "true", className: "pointer-events-none col-start-1 row-start-1 invisible select-none whitespace-nowrap", children: value }), _jsx("span", { "aria-hidden": isTruncated || undefined, className: "col-start-1 row-start-1 min-w-0 overflow-hidden", ref: visibleRef, children: isTruncated ? (_jsxs(_Fragment, { children: [_jsx("span", { children: prefixText }), _jsx("span", { children: ELLIPSIS }), _jsx("span", { children: suffixText })] })) : (displayText) }), _jsx("span", { "aria-hidden": "true", className: "pointer-events-none absolute left-0 top-0 inline-block invisible select-none whitespace-nowrap", ref: measureRef })] }));
+}
+export { MiddleTruncate };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"middle-truncate.js","sourceRoot":"","sources":["../../../../../src/components/trace-viewer/components/middle-truncate/middle-truncate.tsx"],"names":[],"mappings":"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","sourcesContent":["'use client';\n\nimport type { ClipboardEvent, ComponentPropsWithoutRef, JSX } from 'react';\nimport { useCallback, useRef } from 'react';\nimport { cn } from '../../../../lib/cn';\nimport {\n  getMiddleTruncateCopyText,\n  getMiddleTruncateCopyTextFromSelectionText,\n} from './copy-selection';\nimport { ELLIPSIS } from './truncate';\nimport { useMiddleTruncate } from './use-middle-truncate';\n\n/** Props for the {@link MiddleTruncate} component. */\ninterface MiddleTruncateProps\n  extends Omit<ComponentPropsWithoutRef<'span'>, 'children'> {\n  /** The full text string to display, truncated from the middle when it overflows. */\n  value: string;\n}\n\nfunction getRangeOffsets(\n  container: HTMLElement,\n  range: Range\n): { end: number; start: number } | null {\n  if (\n    !container.contains(range.startContainer) ||\n    !container.contains(range.endContainer)\n  ) {\n    return null;\n  }\n\n  const startRange = document.createRange();\n  startRange.selectNodeContents(container);\n  startRange.setEnd(range.startContainer, range.startOffset);\n\n  const endRange = document.createRange();\n  endRange.selectNodeContents(container);\n  endRange.setEnd(range.endContainer, range.endOffset);\n\n  return {\n    end: endRange.toString().length,\n    start: startRange.toString().length,\n  };\n}\n\n/**\n * @gdoc\n *\n * Truncates text from the middle with an ellipsis when it overflows, preserving the beginning and end (e.g. file paths, URLs). Copy behavior restores the full untruncated text to the clipboard.\n * Renders a `<span>` element.\n *\n * Documentation: [Geist Middle Truncate](https://vercel.com/geist/middle-truncate)\n *\n * @param value - Full text string to display.\n */\nfunction MiddleTruncate({\n  value,\n  className,\n  onCopy: onCopyProp,\n  ...props\n}: MiddleTruncateProps): JSX.Element {\n  const { ref, measureRef, displayText, isTruncated, prefixText, suffixText } =\n    useMiddleTruncate(value);\n  const visibleRef = useRef<HTMLSpanElement | null>(null);\n\n  const handleCopy = useCallback(\n    (e: ClipboardEvent<HTMLSpanElement>) => {\n      onCopyProp?.(e);\n      if (e.defaultPrevented || !isTruncated) return;\n\n      const selection = window.getSelection();\n      if (!selection || selection.rangeCount === 0) return;\n      const selectionText = selection.toString();\n      if (!selectionText) return;\n\n      // Only intercept when the selection is fully within this element.\n      // If the user selected across elements (e.g. a table row), let\n      // the browser's default behavior preserve surrounding context.\n      const range = selection.getRangeAt(0);\n      const visibleEl = visibleRef.current;\n      let copyText: string | null = null;\n\n      if (\n        e.currentTarget.contains(range.startContainer) &&\n        e.currentTarget.contains(range.endContainer) &&\n        visibleEl\n      ) {\n        const offsets = getRangeOffsets(visibleEl, range);\n        if (offsets) {\n          copyText = getMiddleTruncateCopyText({\n            prefixText,\n            selectionEnd: offsets.end,\n            selectionStart: offsets.start,\n            suffixText,\n            value,\n          });\n        }\n      }\n\n      copyText ??= getMiddleTruncateCopyTextFromSelectionText({\n        prefixText,\n        selectionText,\n        suffixText,\n        value,\n      });\n\n      if (copyText === null) return;\n\n      e.preventDefault();\n      e.clipboardData.setData('text/plain', copyText);\n    },\n    [onCopyProp, isTruncated, prefixText, suffixText, value]\n  );\n\n  return (\n    <span\n      title={isTruncated ? value : undefined}\n      {...props}\n      ref={ref}\n      className={cn(\n        'relative inline-grid min-w-0 max-w-full overflow-hidden whitespace-nowrap',\n        className\n      )}\n      onCopy={handleCopy}\n    >\n      {isTruncated && <span className=\"sr-only select-none\">{value}</span>}\n      <span\n        aria-hidden=\"true\"\n        className=\"pointer-events-none col-start-1 row-start-1 invisible select-none whitespace-nowrap\"\n      >\n        {value}\n      </span>\n      <span\n        aria-hidden={isTruncated || undefined}\n        className=\"col-start-1 row-start-1 min-w-0 overflow-hidden\"\n        ref={visibleRef}\n      >\n        {isTruncated ? (\n          <>\n            <span>{prefixText}</span>\n            <span>{ELLIPSIS}</span>\n            <span>{suffixText}</span>\n          </>\n        ) : (\n          displayText\n        )}\n      </span>\n      <span\n        aria-hidden=\"true\"\n        className=\"pointer-events-none absolute left-0 top-0 inline-block invisible select-none whitespace-nowrap\"\n        ref={measureRef}\n      />\n    </span>\n  );\n}\n\nexport { MiddleTruncate };\nexport type { MiddleTruncateProps };\n"]}

package/dist/components/{new-trace-viewer → trace-viewer}/components/middle-truncate/truncate.d.ts

@@ -1,4 +1,4 @@
-declare const ELLIPSIS = "...";
+declare const ELLIPSIS = "\u2026";
 declare const MIN_START = 3;
 declare const MIN_END = 3;
 type MeasureFn = (text: string) => number;

package/dist/components/trace-viewer/components/middle-truncate/truncate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"truncate.d.ts","sourceRoot":"","sources":["../../../../../src/components/trace-viewer/components/middle-truncate/truncate.ts"],"names":[],"mappings":"AAAA,QAAA,MAAM,QAAQ,WAAM,CAAC;AACrB,QAAA,MAAM,SAAS,IAAI,CAAC;AACpB,QAAA,MAAM,OAAO,IAAI,CAAC;AAOlB,KAAK,SAAS,GAAG,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;AAE1C;;;GAGG;AACH,iBAAS,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAK3C;AAED,UAAU,cAAc;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,UAAU,EAAE,MAAM,CAAC;IACnB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,OAAO,CAAC;CACpB;AAmCD;;;GAGG;AACH,iBAAS,cAAc,CACrB,SAAS,EAAE,MAAM,EAAE,EACnB,cAAc,EAAE,MAAM,EACtB,OAAO,EAAE,SAAS,EAClB,SAAS,CAAC,EAAE,MAAM,GACjB,cAAc,CAuDhB;AAED,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,QAAQ,EAAE,SAAS,EAAE,OAAO,EAAE,CAAC;AACrE,YAAY,EAAE,SAAS,EAAE,cAAc,EAAE,CAAC"}

package/dist/components/trace-viewer/components/middle-truncate/truncate.js

@@ -0,0 +1,101 @@
+const ELLIPSIS = '…';
+const MIN_START = 3;
+const MIN_END = 3;
+const MIN_KEPT = MIN_START + MIN_END;
+const graphemeSegmenter = typeof Intl !== 'undefined' && 'Segmenter' in Intl
+    ? new Intl.Segmenter(undefined, { granularity: 'grapheme' })
+    : null;
+/**
+ * Splits a string into grapheme clusters using Intl.Segmenter.
+ * Falls back to Array.from for environments without Intl.Segmenter.
+ */
+function toGraphemes(text) {
+    if (graphemeSegmenter) {
+        return [...graphemeSegmenter.segment(text)].map((s) => s.segment);
+    }
+    return Array.from(text);
+}
+function buildCandidate(graphemes, kept) {
+    if (kept <= 0) {
+        return {
+            prefixText: '',
+            prefixGraphemeCount: 0,
+            suffixText: '',
+            suffixGraphemeCount: 0,
+            text: ELLIPSIS,
+            truncated: true,
+        };
+    }
+    const suffixGraphemeCount = kept >= MIN_KEPT
+        ? Math.max(MIN_END, Math.floor(kept / 2))
+        : Math.floor(kept / 2);
+    const prefixGraphemeCount = kept - suffixGraphemeCount;
+    const prefixText = graphemes.slice(0, prefixGraphemeCount).join('');
+    const suffixText = suffixGraphemeCount > 0
+        ? graphemes.slice(-suffixGraphemeCount).join('')
+        : '';
+    return {
+        prefixText,
+        prefixGraphemeCount,
+        suffixText,
+        suffixGraphemeCount,
+        text: prefixText + ELLIPSIS + suffixText,
+        truncated: true,
+    };
+}
+/**
+ * Middle-truncates a string so `prefix...suffix` fits within `availableWidth`.
+ * Uses binary search over grapheme clusters with an injectable measure function.
+ */
+function middleTruncate(graphemes, availableWidth, measure, fullWidth) {
+    const fullText = graphemes.join('');
+    const resolvedFullWidth = fullWidth ?? measure(fullText);
+    if (availableWidth <= 0 || graphemes.length === 0) {
+        return {
+            prefixText: fullText,
+            prefixGraphemeCount: graphemes.length,
+            suffixText: '',
+            suffixGraphemeCount: 0,
+            text: fullText,
+            truncated: false,
+        };
+    }
+    if (resolvedFullWidth <= availableWidth) {
+        return {
+            prefixText: fullText,
+            prefixGraphemeCount: graphemes.length,
+            suffixText: '',
+            suffixGraphemeCount: 0,
+            text: fullText,
+            truncated: false,
+        };
+    }
+    // Binary search for the maximum number of kept graphemes
+    let lo = 0;
+    let hi = graphemes.length - 1;
+    let best = -1;
+    while (lo <= hi) {
+        const mid = (lo + hi) >>> 1;
+        const candidate = buildCandidate(graphemes, mid);
+        if (measure(candidate.text) <= availableWidth) {
+            best = mid;
+            lo = mid + 1;
+        }
+        else {
+            hi = mid - 1;
+        }
+    }
+    if (best === -1) {
+        return {
+            prefixText: '',
+            prefixGraphemeCount: 0,
+            suffixText: '',
+            suffixGraphemeCount: 0,
+            text: '',
+            truncated: true,
+        };
+    }
+    return buildCandidate(graphemes, best);
+}
+export { middleTruncate, toGraphemes, ELLIPSIS, MIN_START, MIN_END };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"truncate.js","sourceRoot":"","sources":["../../../../../src/components/trace-viewer/components/middle-truncate/truncate.ts"],"names":[],"mappings":"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","sourcesContent":["const ELLIPSIS = '…';\nconst MIN_START = 3;\nconst MIN_END = 3;\nconst MIN_KEPT = MIN_START + MIN_END;\nconst graphemeSegmenter =\n  typeof Intl !== 'undefined' && 'Segmenter' in Intl\n    ? new Intl.Segmenter(undefined, { granularity: 'grapheme' })\n    : null;\n\ntype MeasureFn = (text: string) => number;\n\n/**\n * Splits a string into grapheme clusters using Intl.Segmenter.\n * Falls back to Array.from for environments without Intl.Segmenter.\n */\nfunction toGraphemes(text: string): string[] {\n  if (graphemeSegmenter) {\n    return [...graphemeSegmenter.segment(text)].map((s) => s.segment);\n  }\n  return Array.from(text);\n}\n\ninterface TruncateResult {\n  prefixText: string;\n  prefixGraphemeCount: number;\n  suffixText: string;\n  suffixGraphemeCount: number;\n  text: string;\n  truncated: boolean;\n}\n\nfunction buildCandidate(graphemes: string[], kept: number): TruncateResult {\n  if (kept <= 0) {\n    return {\n      prefixText: '',\n      prefixGraphemeCount: 0,\n      suffixText: '',\n      suffixGraphemeCount: 0,\n      text: ELLIPSIS,\n      truncated: true,\n    };\n  }\n\n  const suffixGraphemeCount =\n    kept >= MIN_KEPT\n      ? Math.max(MIN_END, Math.floor(kept / 2))\n      : Math.floor(kept / 2);\n  const prefixGraphemeCount = kept - suffixGraphemeCount;\n  const prefixText = graphemes.slice(0, prefixGraphemeCount).join('');\n  const suffixText =\n    suffixGraphemeCount > 0\n      ? graphemes.slice(-suffixGraphemeCount).join('')\n      : '';\n\n  return {\n    prefixText,\n    prefixGraphemeCount,\n    suffixText,\n    suffixGraphemeCount,\n    text: prefixText + ELLIPSIS + suffixText,\n    truncated: true,\n  };\n}\n\n/**\n * Middle-truncates a string so `prefix...suffix` fits within `availableWidth`.\n * Uses binary search over grapheme clusters with an injectable measure function.\n */\nfunction middleTruncate(\n  graphemes: string[],\n  availableWidth: number,\n  measure: MeasureFn,\n  fullWidth?: number\n): TruncateResult {\n  const fullText = graphemes.join('');\n  const resolvedFullWidth = fullWidth ?? measure(fullText);\n\n  if (availableWidth <= 0 || graphemes.length === 0) {\n    return {\n      prefixText: fullText,\n      prefixGraphemeCount: graphemes.length,\n      suffixText: '',\n      suffixGraphemeCount: 0,\n      text: fullText,\n      truncated: false,\n    };\n  }\n\n  if (resolvedFullWidth <= availableWidth) {\n    return {\n      prefixText: fullText,\n      prefixGraphemeCount: graphemes.length,\n      suffixText: '',\n      suffixGraphemeCount: 0,\n      text: fullText,\n      truncated: false,\n    };\n  }\n\n  // Binary search for the maximum number of kept graphemes\n  let lo = 0;\n  let hi = graphemes.length - 1;\n  let best = -1;\n\n  while (lo <= hi) {\n    const mid = (lo + hi) >>> 1;\n    const candidate = buildCandidate(graphemes, mid);\n\n    if (measure(candidate.text) <= availableWidth) {\n      best = mid;\n      lo = mid + 1;\n    } else {\n      hi = mid - 1;\n    }\n  }\n\n  if (best === -1) {\n    return {\n      prefixText: '',\n      prefixGraphemeCount: 0,\n      suffixText: '',\n      suffixGraphemeCount: 0,\n      text: '',\n      truncated: true,\n    };\n  }\n\n  return buildCandidate(graphemes, best);\n}\n\nexport { middleTruncate, toGraphemes, ELLIPSIS, MIN_START, MIN_END };\nexport type { MeasureFn, TruncateResult };\n"]}

package/dist/components/trace-viewer/components/middle-truncate/use-middle-truncate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-middle-truncate.d.ts","sourceRoot":"","sources":["../../../../../src/components/trace-viewer/components/middle-truncate/use-middle-truncate.ts"],"names":[],"mappings":"AAsCA;;;;;;;GAOG;AACH,iBAAS,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG;IACzC,GAAG,EAAE,KAAK,CAAC,SAAS,CAAC,eAAe,GAAG,IAAI,CAAC,CAAC;IAC7C,UAAU,EAAE,KAAK,CAAC,SAAS,CAAC,eAAe,GAAG,IAAI,CAAC,CAAC;IACpD,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,OAAO,CAAC;IACrB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,UAAU,EAAE,MAAM,CAAC;IACnB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,UAAU,EAAE,MAAM,CAAC;CACpB,CA6GA;AAED,OAAO,EAAE,iBAAiB,EAAE,CAAC"}

package/dist/components/trace-viewer/components/middle-truncate/use-middle-truncate.js

@@ -0,0 +1,114 @@
+'use client';
+import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState, } from 'react';
+import { middleTruncate, toGraphemes } from './truncate';
+const useIsomorphicLayoutEffect = typeof window === 'undefined' ? useEffect : useLayoutEffect;
+function createFullState(value, graphemes) {
+    return {
+        displayText: value,
+        isTruncated: false,
+        prefixGraphemeCount: graphemes.length,
+        prefixText: value,
+        suffixGraphemeCount: 0,
+        suffixText: '',
+    };
+}
+/**
+ * Middle-truncation logic. Returns refs to attach to the container and measurement elements, plus the truncated display text. Recalculates on resize, font loading, and value changes.
+ * Powers the `<MiddleTruncate>` (`<span>`) component.
+ *
+ * Documentation: [Geist Middle Truncate](https://vercel.com/geist/middle-truncate)
+ *
+ * @param value - Full text string to truncate.
+ */
+function useMiddleTruncate(value) {
+    const graphemes = useMemo(() => toGraphemes(value), [value]);
+    const fullState = useMemo(() => createFullState(value, graphemes), [graphemes, value]);
+    const ref = useRef(null);
+    const measureRef = useRef(null);
+    const [state, setState] = useState(() => fullState);
+    const rafRef = useRef(0);
+    const updateState = useCallback((nextState) => {
+        setState((currentState) => {
+            if (currentState.displayText === nextState.displayText &&
+                currentState.isTruncated === nextState.isTruncated &&
+                currentState.prefixText === nextState.prefixText &&
+                currentState.prefixGraphemeCount === nextState.prefixGraphemeCount &&
+                currentState.suffixText === nextState.suffixText &&
+                currentState.suffixGraphemeCount === nextState.suffixGraphemeCount) {
+                return currentState;
+            }
+            return nextState;
+        });
+    }, []);
+    const recalculate = useCallback(() => {
+        const el = ref.current;
+        const measureEl = measureRef.current;
+        if (!el || !measureEl)
+            return;
+        const available = el.clientWidth;
+        if (available <= 0) {
+            updateState(fullState);
+            return;
+        }
+        const measure = (text) => {
+            measureEl.textContent = text;
+            return measureEl.scrollWidth;
+        };
+        const fullWidth = measure(value);
+        if (fullWidth <= available) {
+            updateState(fullState);
+            return;
+        }
+        const result = middleTruncate(graphemes, available, measure, fullWidth);
+        updateState({
+            displayText: result.text,
+            isTruncated: result.truncated,
+            prefixGraphemeCount: result.prefixGraphemeCount,
+            prefixText: result.prefixText,
+            suffixGraphemeCount: result.suffixGraphemeCount,
+            suffixText: result.suffixText,
+        });
+    }, [fullState, graphemes, updateState, value]);
+    // Measure on mount and when value changes - before paint
+    useIsomorphicLayoutEffect(() => {
+        recalculate();
+    }, [recalculate]);
+    // ResizeObserver + font loading for ongoing responsiveness
+    useEffect(() => {
+        const el = ref.current;
+        if (!el)
+            return;
+        const debouncedRecalc = () => {
+            cancelAnimationFrame(rafRef.current);
+            rafRef.current = requestAnimationFrame(recalculate);
+        };
+        const ro = typeof ResizeObserver !== 'undefined'
+            ? new ResizeObserver(debouncedRecalc)
+            : null;
+        ro?.observe(el);
+        window.addEventListener('resize', debouncedRecalc);
+        const onFontsLoaded = () => {
+            debouncedRecalc();
+        };
+        const fontSet = 'fonts' in document ? document.fonts : null;
+        fontSet?.addEventListener?.('loadingdone', onFontsLoaded);
+        return () => {
+            ro?.disconnect();
+            window.removeEventListener('resize', debouncedRecalc);
+            cancelAnimationFrame(rafRef.current);
+            fontSet?.removeEventListener?.('loadingdone', onFontsLoaded);
+        };
+    }, [recalculate]);
+    return {
+        ref,
+        measureRef,
+        displayText: state.displayText,
+        isTruncated: state.isTruncated,
+        prefixGraphemeCount: state.prefixGraphemeCount,
+        prefixText: state.prefixText,
+        suffixGraphemeCount: state.suffixGraphemeCount,
+        suffixText: state.suffixText,
+    };
+}
+export { useMiddleTruncate };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"use-middle-truncate.js","sourceRoot":"","sources":["../../../../../src/components/trace-viewer/components/middle-truncate/use-middle-truncate.ts"],"names":[],"mappings":"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","sourcesContent":["'use client';\n\nimport {\n  useCallback,\n  useEffect,\n  useLayoutEffect,\n  useMemo,\n  useRef,\n  useState,\n} from 'react';\nimport { middleTruncate, toGraphemes } from './truncate';\n\nconst useIsomorphicLayoutEffect =\n  typeof window === 'undefined' ? useEffect : useLayoutEffect;\n\ninterface MiddleTruncateState {\n  displayText: string;\n  isTruncated: boolean;\n  prefixGraphemeCount: number;\n  prefixText: string;\n  suffixGraphemeCount: number;\n  suffixText: string;\n}\n\nfunction createFullState(\n  value: string,\n  graphemes: string[]\n): MiddleTruncateState {\n  return {\n    displayText: value,\n    isTruncated: false,\n    prefixGraphemeCount: graphemes.length,\n    prefixText: value,\n    suffixGraphemeCount: 0,\n    suffixText: '',\n  };\n}\n\n/**\n * Middle-truncation logic. Returns refs to attach to the container and measurement elements, plus the truncated display text. Recalculates on resize, font loading, and value changes.\n * Powers the `<MiddleTruncate>` (`<span>`) component.\n *\n * Documentation: [Geist Middle Truncate](https://vercel.com/geist/middle-truncate)\n *\n * @param value - Full text string to truncate.\n */\nfunction useMiddleTruncate(value: string): {\n  ref: React.RefObject<HTMLSpanElement | null>;\n  measureRef: React.RefObject<HTMLSpanElement | null>;\n  displayText: string;\n  isTruncated: boolean;\n  prefixGraphemeCount: number;\n  prefixText: string;\n  suffixGraphemeCount: number;\n  suffixText: string;\n} {\n  const graphemes = useMemo(() => toGraphemes(value), [value]);\n  const fullState = useMemo(\n    () => createFullState(value, graphemes),\n    [graphemes, value]\n  );\n  const ref = useRef<HTMLSpanElement | null>(null);\n  const measureRef = useRef<HTMLSpanElement | null>(null);\n  const [state, setState] = useState<MiddleTruncateState>(() => fullState);\n  const rafRef = useRef<number>(0);\n\n  const updateState = useCallback((nextState: MiddleTruncateState) => {\n    setState((currentState) => {\n      if (\n        currentState.displayText === nextState.displayText &&\n        currentState.isTruncated === nextState.isTruncated &&\n        currentState.prefixText === nextState.prefixText &&\n        currentState.prefixGraphemeCount === nextState.prefixGraphemeCount &&\n        currentState.suffixText === nextState.suffixText &&\n        currentState.suffixGraphemeCount === nextState.suffixGraphemeCount\n      ) {\n        return currentState;\n      }\n\n      return nextState;\n    });\n  }, []);\n\n  const recalculate = useCallback(() => {\n    const el = ref.current;\n    const measureEl = measureRef.current;\n    if (!el || !measureEl) return;\n\n    const available = el.clientWidth;\n\n    if (available <= 0) {\n      updateState(fullState);\n      return;\n    }\n\n    const measure = (text: string): number => {\n      measureEl.textContent = text;\n      return measureEl.scrollWidth;\n    };\n\n    const fullWidth = measure(value);\n\n    if (fullWidth <= available) {\n      updateState(fullState);\n      return;\n    }\n\n    const result = middleTruncate(graphemes, available, measure, fullWidth);\n    updateState({\n      displayText: result.text,\n      isTruncated: result.truncated,\n      prefixGraphemeCount: result.prefixGraphemeCount,\n      prefixText: result.prefixText,\n      suffixGraphemeCount: result.suffixGraphemeCount,\n      suffixText: result.suffixText,\n    });\n  }, [fullState, graphemes, updateState, value]);\n\n  // Measure on mount and when value changes - before paint\n  useIsomorphicLayoutEffect(() => {\n    recalculate();\n  }, [recalculate]);\n\n  // ResizeObserver + font loading for ongoing responsiveness\n  useEffect(() => {\n    const el = ref.current;\n    if (!el) return;\n\n    const debouncedRecalc = (): void => {\n      cancelAnimationFrame(rafRef.current);\n      rafRef.current = requestAnimationFrame(recalculate);\n    };\n\n    const ro =\n      typeof ResizeObserver !== 'undefined'\n        ? new ResizeObserver(debouncedRecalc)\n        : null;\n    ro?.observe(el);\n    window.addEventListener('resize', debouncedRecalc);\n\n    const onFontsLoaded = (): void => {\n      debouncedRecalc();\n    };\n    const fontSet = 'fonts' in document ? document.fonts : null;\n    fontSet?.addEventListener?.('loadingdone', onFontsLoaded);\n\n    return () => {\n      ro?.disconnect();\n      window.removeEventListener('resize', debouncedRecalc);\n      cancelAnimationFrame(rafRef.current);\n      fontSet?.removeEventListener?.('loadingdone', onFontsLoaded);\n    };\n  }, [recalculate]);\n\n  return {\n    ref,\n    measureRef,\n    displayText: state.displayText,\n    isTruncated: state.isTruncated,\n    prefixGraphemeCount: state.prefixGraphemeCount,\n    prefixText: state.prefixText,\n    suffixGraphemeCount: state.suffixGraphemeCount,\n    suffixText: state.suffixText,\n  };\n}\n\nexport { useMiddleTruncate };\n"]}

package/dist/components/trace-viewer/components/minimap.d.ts

@@ -0,0 +1,14 @@
+import type { ReactNode } from 'react';
+import type { Span } from '../types';
+import { type RootBounds, type ViewportRange } from '../utils';
+export declare const Minimap: import("react").MemoExoticComponent<({ spans, root, viewport, minViewportMs, onViewportChange, onAnimateTo, }: {
+    spans: Span[];
+    root: RootBounds;
+    viewport: ViewportRange;
+    minViewportMs: number;
+    /** Immediate viewport update (used while dragging). */
+    onViewportChange: (viewport: ViewportRange) => void;
+    /** Eased viewport transition (used for click-to-jump and selections). */
+    onAnimateTo: (viewport: ViewportRange) => void;
+}) => ReactNode>;
+//# sourceMappingURL=minimap.d.ts.map

package/dist/components/trace-viewer/components/minimap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"minimap.d.ts","sourceRoot":"","sources":["../../../../src/components/trace-viewer/components/minimap.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAUvC,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,UAAU,CAAC;AAErC,OAAO,EAGL,KAAK,UAAU,EACf,KAAK,aAAa,EAGnB,MAAM,UAAU,CAAC;AA4HlB,eAAO,MAAM,OAAO,iHAOjB;IACD,KAAK,EAAE,IAAI,EAAE,CAAC;IACd,IAAI,EAAE,UAAU,CAAC;IACjB,QAAQ,EAAE,aAAa,CAAC;IACxB,aAAa,EAAE,MAAM,CAAC;IACtB,uDAAuD;IACvD,gBAAgB,EAAE,CAAC,QAAQ,EAAE,aAAa,KAAK,IAAI,CAAC;IACpD,yEAAyE;IACzE,WAAW,EAAE,CAAC,QAAQ,EAAE,aAAa,KAAK,IAAI,CAAC;CAChD,KAAG,SAAS,CA0YX,CAAC"}