@nastechai-research/ui 0.18.2

package/dist/ui/components/dropdown-menu.js

@@ -0,0 +1,102 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useEffect, useId, useRef, useState } from "react";
+import { cn } from "../../utils/index.js";
+const font = "font-mondwest text-[.9375rem] leading-[1.4] tracking-[0.1875rem]";
+export function DropdownMenu({
+  className,
+  direction = "down",
+  onChange,
+  options,
+  value
+}) {
+  const id = useId();
+  const [open, setOpen] = useState(false);
+  const ref = useRef(null);
+  const anchor = `--dropdown-${id.replace(/:/g, "")}`;
+  const panelStyle = {
+    position: "fixed",
+    positionAnchor: anchor,
+    positionTryFallbacks: direction === "left" || direction === "right" ? "flip-inline, flip-block" : "flip-block, flip-inline",
+    ...direction === "up" && {
+      left: "calc(anchor(left) - 0.5rem)",
+      top: "calc(anchor(top) + 1rem)",
+      transform: "translateY(-100%)"
+    },
+    ...direction === "right" && {
+      left: "calc(anchor(right))",
+      top: "calc(anchor(top) - 0.5rem)"
+    },
+    ...direction === "left" && {
+      left: "calc(anchor(left) - 1px)",
+      top: "calc(anchor(top) - 0.5rem)",
+      transform: "translateX(-100%)"
+    },
+    ...direction === "down" && {
+      left: "calc(anchor(left) - 0.5rem)",
+      top: "calc(anchor(top) - 0.5rem)"
+    }
+  };
+  useEffect(() => {
+    if (!open) {
+      return;
+    }
+    const ac = new AbortController();
+    document.addEventListener(
+      "mousedown",
+      (e) => {
+        if (!ref.current?.contains(e.target)) {
+          setOpen(false);
+        }
+      },
+      { signal: ac.signal }
+    );
+    return () => ac.abort();
+  }, [open]);
+  return /* @__PURE__ */ jsxs(
+    "span",
+    {
+      className: cn("relative inline-block align-top", className),
+      ref,
+      children: [
+        /* @__PURE__ */ jsxs(
+          "span",
+          {
+            className: cn(font, "inline-block cursor-pointer hover:underline"),
+            onClick: () => setOpen(!open),
+            style: { anchorName: anchor },
+            children: [
+              options.find((o) => o.value === value)?.label ?? value,
+              " ",
+              open ? "\u2191" : "\u2193"
+            ]
+          }
+        ),
+        open && /* @__PURE__ */ jsx(
+          "div",
+          {
+            className: "bg-background-base z-50 flex flex-col",
+            style: panelStyle,
+            children: options.map((o) => /* @__PURE__ */ jsx(
+              "span",
+              {
+                className: cn(
+                  font,
+                  "block cursor-pointer p-2 whitespace-nowrap",
+                  o.value === value ? "underline" : "hover:bg-midground/10"
+                ),
+                onClick: () => {
+                  onChange(o.value);
+                  setOpen(false);
+                },
+                children: o.label
+              },
+              o.value
+            ))
+          }
+        )
+      ]
+    }
+  );
+}
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiPHN0ZGluPiJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiJ3VzZSBjbGllbnQnXG5cbmltcG9ydCB7IHVzZUVmZmVjdCwgdXNlSWQsIHVzZVJlZiwgdXNlU3RhdGUgfSBmcm9tICdyZWFjdCdcblxuaW1wb3J0IHsgY24gfSBmcm9tICcuLi8uLi91dGlscydcblxuY29uc3QgZm9udCA9ICdmb250LW1vbmR3ZXN0IHRleHQtWy45Mzc1cmVtXSBsZWFkaW5nLVsxLjRdIHRyYWNraW5nLVswLjE4NzVyZW1dJ1xuXG50eXBlIERpcmVjdGlvbiA9ICdkb3duJyB8ICd1cCcgfCAnbGVmdCcgfCAncmlnaHQnXG5cbnR5cGUgQW5jaG9yU3R5bGUgPSBSZWFjdC5DU1NQcm9wZXJ0aWVzICYgUmVjb3JkPHN0cmluZywgc3RyaW5nIHwgbnVtYmVyPlxuXG5leHBvcnQgZnVuY3Rpb24gRHJvcGRvd25NZW51PFQgZXh0ZW5kcyBzdHJpbmc+KHtcbiAgY2xhc3NOYW1lLFxuICBkaXJlY3Rpb24gPSAnZG93bicsXG4gIG9uQ2hhbmdlLFxuICBvcHRpb25zLFxuICB2YWx1ZVxufToge1xuICBjbGFzc05hbWU/OiBzdHJpbmdcbiAgZGlyZWN0aW9uPzogRGlyZWN0aW9uXG4gIG9uQ2hhbmdlOiAodmFsdWU6IFQpID0+IHZvaWRcbiAgb3B0aW9uczogeyBsYWJlbDogc3RyaW5nOyB2YWx1ZTogVCB9W11cbiAgdmFsdWU6IFRcbn0pIHtcbiAgY29uc3QgaWQgPSB1c2VJZCgpXG4gIGNvbnN0IFtvcGVuLCBzZXRPcGVuXSA9IHVzZVN0YXRlKGZhbHNlKVxuICBjb25zdCByZWYgPSB1c2VSZWY8SFRNTFNwYW5FbGVtZW50PihudWxsKVxuXG4gIGNvbnN0IGFuY2hvciA9IGAtLWRyb3Bkb3duLSR7aWQucmVwbGFjZSgvOi9nLCAnJyl9YFxuXG4gIGNvbnN0IHBhbmVsU3R5bGU6IEFuY2hvclN0eWxlID0ge1xuICAgIHBvc2l0aW9uOiAnZml4ZWQnLFxuICAgIHBvc2l0aW9uQW5jaG9yOiBhbmNob3IsXG4gICAgcG9zaXRpb25UcnlGYWxsYmFja3M6XG4gICAgICBkaXJlY3Rpb24gPT09ICdsZWZ0JyB8fCBkaXJlY3Rpb24gPT09ICdyaWdodCdcbiAgICAgICAgPyAnZmxpcC1pbmxpbmUsIGZsaXAtYmxvY2snXG4gICAgICAgIDogJ2ZsaXAtYmxvY2ssIGZsaXAtaW5saW5lJyxcbiAgICAuLi4oZGlyZWN0aW9uID09PSAndXAnICYmIHtcbiAgICAgIGxlZnQ6ICdjYWxjKGFuY2hvcihsZWZ0KSAtIDAuNXJlbSknLFxuICAgICAgdG9wOiAnY2FsYyhhbmNob3IodG9wKSArIDFyZW0pJyxcbiAgICAgIHRyYW5zZm9ybTogJ3RyYW5zbGF0ZVkoLTEwMCUpJ1xuICAgIH0pLFxuICAgIC4uLihkaXJlY3Rpb24gPT09ICdyaWdodCcgJiYge1xuICAgICAgbGVmdDogJ2NhbGMoYW5jaG9yKHJpZ2h0KSknLFxuICAgICAgdG9wOiAnY2FsYyhhbmNob3IodG9wKSAtIDAuNXJlbSknXG4gICAgfSksXG4gICAgLi4uKGRpcmVjdGlvbiA9PT0gJ2xlZnQnICYmIHtcbiAgICAgIGxlZnQ6ICdjYWxjKGFuY2hvcihsZWZ0KSAtIDFweCknLFxuICAgICAgdG9wOiAnY2FsYyhhbmNob3IodG9wKSAtIDAuNXJlbSknLFxuICAgICAgdHJhbnNmb3JtOiAndHJhbnNsYXRlWCgtMTAwJSknXG4gICAgfSksXG4gICAgLi4uKGRpcmVjdGlvbiA9PT0gJ2Rvd24nICYmIHtcbiAgICAgIGxlZnQ6ICdjYWxjKGFuY2hvcihsZWZ0KSAtIDAuNXJlbSknLFxuICAgICAgdG9wOiAnY2FsYyhhbmNob3IodG9wKSAtIDAuNXJlbSknXG4gICAgfSlcbiAgfVxuXG4gIHVzZUVmZmVjdCgoKSA9PiB7XG4gICAgaWYgKCFvcGVuKSB7XG4gICAgICByZXR1cm5cbiAgICB9XG5cbiAgICBjb25zdCBhYyA9IG5ldyBBYm9ydENvbnRyb2xsZXIoKVxuICAgIGRvY3VtZW50LmFkZEV2ZW50TGlzdGVuZXIoXG4gICAgICAnbW91c2Vkb3duJyxcbiAgICAgIGUgPT4ge1xuICAgICAgICBpZiAoIXJlZi5jdXJyZW50Py5jb250YWlucyhlLnRhcmdldCBhcyBOb2RlKSkge1xuICAgICAgICAgIHNldE9wZW4oZmFsc2UpXG4gICAgICAgIH1cbiAgICAgIH0sXG4gICAgICB7IHNpZ25hbDogYWMuc2lnbmFsIH1cbiAgICApXG5cbiAgICByZXR1cm4gKCkgPT4gYWMuYWJvcnQoKVxuICB9LCBbb3Blbl0pXG5cbiAgcmV0dXJuIChcbiAgICA8c3BhblxuICAgICAgY2xhc3NOYW1lPXtjbigncmVsYXRpdmUgaW5saW5lLWJsb2NrIGFsaWduLXRvcCcsIGNsYXNzTmFtZSl9XG4gICAgICByZWY9e3JlZn1cbiAgICA+XG4gICAgICA8c3BhblxuICAgICAgICBjbGFzc05hbWU9e2NuKGZvbnQsICdpbmxpbmUtYmxvY2sgY3Vyc29yLXBvaW50ZXIgaG92ZXI6dW5kZXJsaW5lJyl9XG4gICAgICAgIG9uQ2xpY2s9eygpID0+IHNldE9wZW4oIW9wZW4pfVxuICAgICAgICBzdHlsZT17eyBhbmNob3JOYW1lOiBhbmNob3IgfSBhcyBBbmNob3JTdHlsZX1cbiAgICAgID5cbiAgICAgICAge29wdGlvbnMuZmluZChvID0+IG8udmFsdWUgPT09IHZhbHVlKT8ubGFiZWwgPz8gdmFsdWV9eycgJ31cbiAgICAgICAge29wZW4gPyAnXHUyMTkxJyA6ICdcdTIxOTMnfVxuICAgICAgPC9zcGFuPlxuXG4gICAgICB7b3BlbiAmJiAoXG4gICAgICAgIDxkaXZcbiAgICAgICAgICBjbGFzc05hbWU9XCJiZy1iYWNrZ3JvdW5kLWJhc2Ugei01MCBmbGV4IGZsZXgtY29sXCJcbiAgICAgICAgICBzdHlsZT17cGFuZWxTdHlsZX1cbiAgICAgICAgPlxuICAgICAgICAgIHtvcHRpb25zLm1hcChvID0+IChcbiAgICAgICAgICAgIDxzcGFuXG4gICAgICAgICAgICAgIGNsYXNzTmFtZT17Y24oXG4gICAgICAgICAgICAgICAgZm9udCxcbiAgICAgICAgICAgICAgICAnYmxvY2sgY3Vyc29yLXBvaW50ZXIgcC0yIHdoaXRlc3BhY2Utbm93cmFwJyxcbiAgICAgICAgICAgICAgICBvLnZhbHVlID09PSB2YWx1ZSA/ICd1bmRlcmxpbmUnIDogJ2hvdmVyOmJnLW1pZGdyb3VuZC8xMCdcbiAgICAgICAgICAgICAgKX1cbiAgICAgICAgICAgICAga2V5PXtvLnZhbHVlfVxuICAgICAgICAgICAgICBvbkNsaWNrPXsoKSA9PiB7XG4gICAgICAgICAgICAgICAgb25DaGFuZ2Uoby52YWx1ZSlcbiAgICAgICAgICAgICAgICBzZXRPcGVuKGZhbHNlKVxuICAgICAgICAgICAgICB9fVxuICAgICAgICAgICAgPlxuICAgICAgICAgICAgICB7by5sYWJlbH1cbiAgICAgICAgICAgIDwvc3Bhbj5cbiAgICAgICAgICApKX1cbiAgICAgICAgPC9kaXY+XG4gICAgICApfVxuICAgIDwvc3Bhbj5cbiAgKVxufVxuIl0sCiAgIm1hcHBpbmdzIjogIjtBQWtGTSxTQWVNLEtBZk47QUFoRk4sU0FBUyxXQUFXLE9BQU8sUUFBUSxnQkFBZ0I7QUFFbkQsU0FBUyxVQUFVO0FBRW5CLE1BQU0sT0FBTztBQU1OLGdCQUFTLGFBQStCO0FBQUEsRUFDN0M7QUFBQSxFQUNBLFlBQVk7QUFBQSxFQUNaO0FBQUEsRUFDQTtBQUFBLEVBQ0E7QUFDRixHQU1HO0FBQ0QsUUFBTSxLQUFLLE1BQU07QUFDakIsUUFBTSxDQUFDLE1BQU0sT0FBTyxJQUFJLFNBQVMsS0FBSztBQUN0QyxRQUFNLE1BQU0sT0FBd0IsSUFBSTtBQUV4QyxRQUFNLFNBQVMsY0FBYyxHQUFHLFFBQVEsTUFBTSxFQUFFLENBQUM7QUFFakQsUUFBTSxhQUEwQjtBQUFBLElBQzlCLFVBQVU7QUFBQSxJQUNWLGdCQUFnQjtBQUFBLElBQ2hCLHNCQUNFLGNBQWMsVUFBVSxjQUFjLFVBQ2xDLDRCQUNBO0FBQUEsSUFDTixHQUFJLGNBQWMsUUFBUTtBQUFBLE1BQ3hCLE1BQU07QUFBQSxNQUNOLEtBQUs7QUFBQSxNQUNMLFdBQVc7QUFBQSxJQUNiO0FBQUEsSUFDQSxHQUFJLGNBQWMsV0FBVztBQUFBLE1BQzNCLE1BQU07QUFBQSxNQUNOLEtBQUs7QUFBQSxJQUNQO0FBQUEsSUFDQSxHQUFJLGNBQWMsVUFBVTtBQUFBLE1BQzFCLE1BQU07QUFBQSxNQUNOLEtBQUs7QUFBQSxNQUNMLFdBQVc7QUFBQSxJQUNiO0FBQUEsSUFDQSxHQUFJLGNBQWMsVUFBVTtBQUFBLE1BQzFCLE1BQU07QUFBQSxNQUNOLEtBQUs7QUFBQSxJQUNQO0FBQUEsRUFDRjtBQUVBLFlBQVUsTUFBTTtBQUNkLFFBQUksQ0FBQyxNQUFNO0FBQ1Q7QUFBQSxJQUNGO0FBRUEsVUFBTSxLQUFLLElBQUksZ0JBQWdCO0FBQy9CLGFBQVM7QUFBQSxNQUNQO0FBQUEsTUFDQSxPQUFLO0FBQ0gsWUFBSSxDQUFDLElBQUksU0FBUyxTQUFTLEVBQUUsTUFBYyxHQUFHO0FBQzVDLGtCQUFRLEtBQUs7QUFBQSxRQUNmO0FBQUEsTUFDRjtBQUFBLE1BQ0EsRUFBRSxRQUFRLEdBQUcsT0FBTztBQUFBLElBQ3RCO0FBRUEsV0FBTyxNQUFNLEdBQUcsTUFBTTtBQUFBLEVBQ3hCLEdBQUcsQ0FBQyxJQUFJLENBQUM7QUFFVCxTQUNFO0FBQUEsSUFBQztBQUFBO0FBQUEsTUFDQyxXQUFXLEdBQUcsbUNBQW1DLFNBQVM7QUFBQSxNQUMxRDtBQUFBLE1BRUE7QUFBQTtBQUFBLFVBQUM7QUFBQTtBQUFBLFlBQ0MsV0FBVyxHQUFHLE1BQU0sNkNBQTZDO0FBQUEsWUFDakUsU0FBUyxNQUFNLFFBQVEsQ0FBQyxJQUFJO0FBQUEsWUFDNUIsT0FBTyxFQUFFLFlBQVksT0FBTztBQUFBLFlBRTNCO0FBQUEsc0JBQVEsS0FBSyxPQUFLLEVBQUUsVUFBVSxLQUFLLEdBQUcsU0FBUztBQUFBLGNBQU87QUFBQSxjQUN0RCxPQUFPLFdBQU07QUFBQTtBQUFBO0FBQUEsUUFDaEI7QUFBQSxRQUVDLFFBQ0M7QUFBQSxVQUFDO0FBQUE7QUFBQSxZQUNDLFdBQVU7QUFBQSxZQUNWLE9BQU87QUFBQSxZQUVOLGtCQUFRLElBQUksT0FDWDtBQUFBLGNBQUM7QUFBQTtBQUFBLGdCQUNDLFdBQVc7QUFBQSxrQkFDVDtBQUFBLGtCQUNBO0FBQUEsa0JBQ0EsRUFBRSxVQUFVLFFBQVEsY0FBYztBQUFBLGdCQUNwQztBQUFBLGdCQUVBLFNBQVMsTUFBTTtBQUNiLDJCQUFTLEVBQUUsS0FBSztBQUNoQiwwQkFBUSxLQUFLO0FBQUEsZ0JBQ2Y7QUFBQSxnQkFFQyxZQUFFO0FBQUE7QUFBQSxjQU5FLEVBQUU7QUFBQSxZQU9ULENBQ0Q7QUFBQTtBQUFBLFFBQ0g7QUFBQTtBQUFBO0FBQUEsRUFFSjtBQUVKOyIsCiAgIm5hbWVzIjogW10KfQo=

package/dist/ui/components/fit-text/fit-text.css

@@ -0,0 +1,42 @@
+.fit-text {
+  --fit-captured-length: initial;
+  --fit-support-sentinel: var(--fit-captured-length, 9999px);
+
+  display: flex;
+  container-type: inline-size;
+
+  > [aria-hidden] {
+    visibility: hidden;
+  }
+
+  > :not([aria-hidden]) {
+    flex-grow: 1;
+    container-type: inline-size;
+
+    --fit-captured-length: 100cqi;
+    --fit-available-space: var(--fit-captured-length);
+
+    > * {
+      --fit-support-sentinel: inherit;
+      --fit-captured-length: 100cqi;
+      --fit-ratio: tan(
+        atan2(
+          var(--fit-available-space),
+          var(--fit-available-space) - var(--fit-captured-length)
+        )
+      );
+
+      display: block;
+      inline-size: var(--fit-available-space);
+      font-size: clamp(
+        var(--fit-min, 1em),
+        1em * var(--fit-ratio),
+        var(--fit-max, infinity * 1px) - var(--fit-support-sentinel)
+      );
+
+      @container (inline-size > 0) {
+        white-space: nowrap;
+      }
+    }
+  }
+}

package/dist/ui/components/fit-text/index.d.ts

@@ -0,0 +1,9 @@
+import { type PolyProps } from '../../../utils';
+export declare const FitText: import("../../..").PolyComponent<"span", OwnProps>;
+interface OwnProps {
+    children: string;
+    max?: string;
+    min?: string;
+}
+export type FitTextProps<T extends React.ElementType = 'span'> = PolyProps<T, OwnProps>;
+export {};

package/dist/ui/components/fit-text/index.js

@@ -0,0 +1,25 @@
+"use client";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { createElement } from "react";
+import { cn, polyRef } from "../../../utils/index.js";
+export const FitText = polyRef(
+  ({ as, children, className, max, min = "1em", style: baseStyle, ...rest }, ref) => {
+    if (typeof children !== "string") {
+      return null;
+    }
+    const style = {
+      "--fit-max": max ?? "infinity * 1px",
+      "--fit-min": min,
+      ...baseStyle
+    };
+    return createElement(
+      as ?? "span",
+      { ...rest, className: cn("fit-text", className), ref, style },
+      /* @__PURE__ */ jsxs(Fragment, { children: [
+        /* @__PURE__ */ jsx("span", { children: /* @__PURE__ */ jsx("span", { children }) }),
+        /* @__PURE__ */ jsx("span", { "aria-hidden": "true", children })
+      ] })
+    );
+  }
+);
+//# sourceMappingURL=data:application/json;base64,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

package/dist/ui/components/graphs/bar-chart.d.ts

@@ -0,0 +1,12 @@
+import { type ChartProps, type DataPoint } from './utils';
+export declare const BarChart: {
+    (props: Omit<BarChartProps<DataPoint> & {
+        backgroundColor?: string;
+        color?: string;
+    }, keyof import("../blend-mode").BlendColors>): import("react").JSX.Element;
+    displayName: string;
+};
+interface BarChartProps<T extends DataPoint> extends ChartProps<T> {
+    xDomain?: [number, number];
+}
+export {};

package/dist/ui/components/graphs/bar-chart.js

@@ -0,0 +1,129 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import * as Plot from "@observablehq/plot";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { cn } from "../../../utils/index.js";
+import {
+  accessor,
+  CHART_MARGINS,
+  CHART_STYLE,
+  Crosshair,
+  setupCrosshair,
+  stylePlot,
+  useDims,
+  withChartBlend
+} from "./utils.js";
+export const BarChart = withChartBlend(
+  ({
+    backgroundColor: _,
+    className,
+    color: fillColor,
+    data = [],
+    formatTooltip,
+    formatX: formatXProp,
+    formatY: formatYProp,
+    x = "label",
+    xDomain,
+    xTicks = [0, 5e4, 1e5],
+    y = "value",
+    yDomain = [0, 10],
+    yTicks = [10, 8, 4, 2],
+    ...props
+  }) => {
+    const ref = useRef(null);
+    const plotRef = useRef(null);
+    const [crosshair, setCrosshair] = useState({ x: null });
+    const dims = useDims(ref);
+    const formatX = useCallback(
+      (v) => formatXProp?.(v) ?? (typeof v === "number" ? v.toLocaleString("en-US") : String(v)),
+      [formatXProp]
+    );
+    const formatY = useCallback(
+      (v) => formatYProp?.(v) ?? String(v),
+      [formatYProp]
+    );
+    const getX = useMemo(() => accessor(x), [x]);
+    const getY = useMemo(() => accessor(y), [y]);
+    useEffect(() => {
+      if (!ref.current || !plotRef.current || !data.length || !dims.h || !dims.w) {
+        return;
+      }
+      plotRef.current.innerHTML = "";
+      const [xMin, xMax] = [
+        xDomain?.[0] ?? 0,
+        xDomain?.[1] ?? Math.max(...data.map((d) => getX(d)))
+      ];
+      const plot = Plot.plot({
+        ...CHART_MARGINS,
+        height: dims.h,
+        marks: [
+          Plot.rectY(data, {
+            fill: fillColor ?? "currentColor",
+            fillOpacity: 0.3,
+            interval: (xMax - xMin) / data.length,
+            x: getX,
+            y: getY
+          }),
+          Plot.axisX({ tickFormat: formatX, ticks: xTicks })
+        ],
+        style: CHART_STYLE,
+        width: dims.w,
+        x: { domain: [xMin, xMax], label: null, type: "linear" },
+        y: {
+          domain: yDomain,
+          grid: true,
+          label: null,
+          tickFormat: formatY,
+          ticks: yTicks
+        }
+      });
+      stylePlot(plot);
+      plotRef.current.appendChild(plot);
+      const cleanup = setupCrosshair(
+        ref.current,
+        data,
+        (d) => getX(d),
+        getY,
+        yDomain,
+        (d) => formatTooltip?.(d) ?? `${formatX(getX(d))}: ${formatY(getY(d))}`,
+        setCrosshair
+      );
+      return cleanup;
+    }, [
+      data,
+      dims.h,
+      dims.w,
+      fillColor,
+      formatTooltip,
+      formatX,
+      formatY,
+      getX,
+      getY,
+      xDomain,
+      xTicks,
+      yDomain,
+      yTicks
+    ]);
+    return /* @__PURE__ */ jsxs(
+      "div",
+      {
+        className: cn("relative aspect-4/1 w-full overflow-clip", className),
+        ref,
+        ...props,
+        children: [
+          /* @__PURE__ */ jsx("div", { className: "absolute inset-0", ref: plotRef }),
+          /* @__PURE__ */ jsx(
+            Crosshair,
+            {
+              color: fillColor,
+              containerWidth: dims.w,
+              height: dims.h,
+              ...crosshair
+            }
+          )
+        ]
+      }
+    );
+  }
+);
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["<stdin>"],
  "sourcesContent": ["'use client'\n\nimport * as Plot from '@observablehq/plot'\nimport { useCallback, useEffect, useMemo, useRef, useState } from 'react'\n\nimport { cn } from '../../../utils'\n\nimport {\n  accessor,\n  CHART_MARGINS,\n  CHART_STYLE,\n  type ChartProps,\n  Crosshair,\n  type CrosshairState,\n  type DataPoint,\n  setupCrosshair,\n  stylePlot,\n  useDims,\n  withChartBlend\n} from './utils'\n\nexport const BarChart = withChartBlend(\n  <T extends DataPoint>({\n    backgroundColor: _,\n    className,\n    color: fillColor,\n    data = [],\n    formatTooltip,\n    formatX: formatXProp,\n    formatY: formatYProp,\n    x = 'label' as keyof T,\n    xDomain,\n    xTicks = [0, 50000, 100000],\n    y = 'value' as keyof T,\n    yDomain = [0, 10],\n    yTicks = [10, 8, 4, 2],\n    ...props\n  }: BarChartProps<T> & { backgroundColor?: string; color?: string }) => {\n    const ref = useRef<HTMLDivElement>(null)\n    const plotRef = useRef<HTMLDivElement>(null)\n    const [crosshair, setCrosshair] = useState<CrosshairState>({ x: null })\n    const dims = useDims(ref)\n\n    const formatX = useCallback(\n      (v: unknown) =>\n        formatXProp?.(v) ??\n        (typeof v === 'number' ? v.toLocaleString('en-US') : String(v)),\n      [formatXProp]\n    )\n\n    const formatY = useCallback(\n      (v: number) => formatYProp?.(v) ?? String(v),\n      [formatYProp]\n    )\n\n    const getX = useMemo(() => accessor<T, unknown>(x), [x])\n    const getY = useMemo(() => accessor<T, number>(y), [y])\n\n    useEffect(() => {\n      if (\n        !ref.current ||\n        !plotRef.current ||\n        !data.length ||\n        !dims.h ||\n        !dims.w\n      ) {\n        return\n      }\n\n      plotRef.current.innerHTML = ''\n\n      const [xMin, xMax] = [\n        xDomain?.[0] ?? 0,\n        xDomain?.[1] ?? Math.max(...data.map(d => getX(d) as number))\n      ]\n\n      const plot = Plot.plot({\n        ...CHART_MARGINS,\n        height: dims.h,\n        marks: [\n          Plot.rectY(data, {\n            fill: fillColor ?? 'currentColor',\n            fillOpacity: 0.3,\n            interval: (xMax - xMin) / data.length,\n            x: getX as (d: T) => unknown,\n            y: getY\n          }),\n          Plot.axisX({ tickFormat: formatX, ticks: xTicks })\n        ],\n        style: CHART_STYLE,\n        width: dims.w,\n        x: { domain: [xMin, xMax], label: null, type: 'linear' },\n        y: {\n          domain: yDomain,\n          grid: true,\n          label: null,\n          tickFormat: formatY,\n          ticks: yTicks\n        }\n      })\n\n      stylePlot(plot as HTMLElement)\n      plotRef.current.appendChild(plot)\n\n      const cleanup = setupCrosshair(\n        ref.current,\n        data,\n        d => getX(d) as number,\n        getY,\n        yDomain,\n        d => formatTooltip?.(d) ?? `${formatX(getX(d))}: ${formatY(getY(d))}`,\n        setCrosshair\n      )\n\n      return cleanup\n    }, [\n      data,\n      dims.h,\n      dims.w,\n      fillColor,\n      formatTooltip,\n      formatX,\n      formatY,\n      getX,\n      getY,\n      xDomain,\n      xTicks,\n      yDomain,\n      yTicks\n    ])\n\n    return (\n      <div\n        className={cn('relative aspect-4/1 w-full overflow-clip', className)}\n        ref={ref}\n        {...props}\n      >\n        <div className=\"absolute inset-0\" ref={plotRef} />\n\n        <Crosshair\n          color={fillColor}\n          containerWidth={dims.w}\n          height={dims.h}\n          {...crosshair}\n        />\n      </div>\n    )\n  }\n)\n\ninterface BarChartProps<T extends DataPoint> extends ChartProps<T> {\n  xDomain?: [number, number]\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/ui/components/graphs/index.d.ts

@@ -0,0 +1,3 @@
+export { BarChart } from './bar-chart';
+export { LineChart } from './line-chart';
+export * from './utils';

package/dist/ui/components/graphs/index.js

@@ -0,0 +1,4 @@
+export { BarChart } from "./bar-chart.js";
+export { LineChart } from "./line-chart.js";
+export * from "./utils.js";
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiPHN0ZGluPiJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiZXhwb3J0IHsgQmFyQ2hhcnQgfSBmcm9tICcuL2Jhci1jaGFydCdcbmV4cG9ydCB7IExpbmVDaGFydCB9IGZyb20gJy4vbGluZS1jaGFydCdcblxuZXhwb3J0ICogZnJvbSAnLi91dGlscydcbiJdLAogICJtYXBwaW5ncyI6ICJBQUFBLFNBQVMsZ0JBQWdCO0FBQ3pCLFNBQVMsaUJBQWlCO0FBRTFCLGNBQWM7IiwKICAibmFtZXMiOiBbXQp9Cg==

package/dist/ui/components/graphs/line-chart.d.ts

@@ -0,0 +1,14 @@
+import { type ChartProps, type DataPoint } from './utils';
+export declare const LineChart: {
+    (props: Omit<LineChartProps<DataPoint> & {
+        backgroundColor?: string;
+        color?: string;
+    }, keyof import("../blend-mode").BlendColors>): import("react").JSX.Element;
+    displayName: string;
+};
+interface LineChartProps<T extends DataPoint> extends ChartProps<T> {
+    curve?: 'basis' | 'catmull-rom' | 'linear' | 'natural' | 'step';
+    series?: keyof T;
+    showArea?: boolean;
+}
+export {};

package/dist/ui/components/graphs/line-chart.js

@@ -0,0 +1,175 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import * as Plot from "@observablehq/plot";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { cn } from "../../../utils/index.js";
+import {
+  accessor,
+  CHART_MARGINS,
+  CHART_STYLE,
+  Crosshair,
+  setupCrosshair,
+  stylePlot,
+  useDims,
+  withChartBlend
+} from "./utils.js";
+export const LineChart = withChartBlend(
+  ({
+    backgroundColor: _,
+    className,
+    color: strokeColor,
+    curve = "natural",
+    data = [],
+    formatTooltip,
+    formatX: formatXProp,
+    formatY: formatYProp,
+    series = "series",
+    showArea = false,
+    x = "label",
+    xTicks,
+    y = "value",
+    yDomain = [0, 0.5],
+    yTicks = 4,
+    ...props
+  }) => {
+    const ref = useRef(null);
+    const plotRef = useRef(null);
+    const [hovered, setHovered] = useState(null);
+    const [crosshair, setCrosshair] = useState({ x: null });
+    const dims = useDims(ref);
+    const formatX = useCallback(
+      (v) => formatXProp?.(v) ?? (v >= 1e3 ? `${v / 1e3}k` : `${v}`),
+      [formatXProp]
+    );
+    const formatY = useCallback(
+      (v) => formatYProp?.(v) ?? `${Math.round(v * 100)}%`,
+      [formatYProp]
+    );
+    const getX = useMemo(() => accessor(x), [x]);
+    const getY = useMemo(() => accessor(y), [y]);
+    const getZ = useCallback((d) => d[series], [series]);
+    useEffect(() => {
+      if (!ref.current || !plotRef.current || !data.length || !dims.h || !dims.w) {
+        return;
+      }
+      plotRef.current.innerHTML = "";
+      const hasSeries = data.some((d) => d[series] !== void 0);
+      const seriesIdx = hasSeries ? data.reduce(
+        (acc, d, i) => (acc[d[series]] ??= i, acc),
+        {}
+      ) : {};
+      const n = Object.keys(seriesIdx).length;
+      const opacity = (d) => {
+        if (!hasSeries) {
+          return 1;
+        }
+        if (hovered) {
+          return d[series] === hovered[series] ? 1 : 0.2;
+        }
+        return 1 - seriesIdx[d[series]] / Math.max(n - 1, 1) * 0.2;
+      };
+      const lineOpts = {
+        curve,
+        x: getX,
+        y: getY,
+        ...hasSeries && { z: getZ }
+      };
+      const plot = Plot.plot({
+        ...CHART_MARGINS,
+        height: dims.h,
+        marks: [
+          ...showArea ? [
+            Plot.areaY(data, {
+              ...lineOpts,
+              fill: strokeColor,
+              fillOpacity: 0.15,
+              y1: yDomain[0]
+            })
+          ] : [],
+          Plot.lineY(data, {
+            ...lineOpts,
+            stroke: "transparent",
+            strokeWidth: 16
+          }),
+          Plot.lineY(data, {
+            ...lineOpts,
+            stroke: strokeColor,
+            strokeOpacity: opacity,
+            strokeWidth: 1.5
+          })
+        ],
+        style: { ...CHART_STYLE, fontStretch: "expanded" },
+        width: dims.w,
+        x: { label: null, tickFormat: formatX, ticks: xTicks },
+        y: {
+          domain: yDomain,
+          grid: true,
+          label: null,
+          tickFormat: formatY,
+          ticks: yTicks
+        }
+      });
+      plot.addEventListener("input", () => setHovered(plot.value));
+      stylePlot(plot);
+      plot.querySelectorAll('g[aria-label="line"] path').forEach(
+        (el) => Object.assign(el.style, {
+          transition: "stroke-opacity 0.2s"
+        })
+      );
+      plotRef.current.appendChild(plot);
+      const cleanup = setupCrosshair(
+        ref.current,
+        data,
+        (d) => getX(d),
+        getY,
+        yDomain,
+        (d) => formatTooltip?.(d) ?? `${formatX(getX(d))}: ${formatY(getY(d))}`,
+        setCrosshair,
+        hasSeries ? (d) => getZ(d) : void 0
+      );
+      return () => {
+        cleanup();
+        plot.parentNode && plot.remove();
+      };
+    }, [
+      curve,
+      data,
+      dims.h,
+      dims.w,
+      formatTooltip,
+      formatX,
+      formatY,
+      getX,
+      getY,
+      getZ,
+      hovered,
+      series,
+      showArea,
+      strokeColor,
+      xTicks,
+      yDomain,
+      yTicks
+    ]);
+    return /* @__PURE__ */ jsxs(
+      "div",
+      {
+        className: cn("relative aspect-4/1 w-full overflow-clip", className),
+        ref,
+        ...props,
+        children: [
+          /* @__PURE__ */ jsx("div", { className: "absolute inset-0", ref: plotRef }),
+          /* @__PURE__ */ jsx(
+            Crosshair,
+            {
+              color: strokeColor,
+              containerWidth: dims.w,
+              height: dims.h,
+              ...crosshair
+            }
+          )
+        ]
+      }
+    );
+  }
+);
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["<stdin>"],
  "sourcesContent": ["'use client'\n\nimport * as Plot from '@observablehq/plot'\nimport { useCallback, useEffect, useMemo, useRef, useState } from 'react'\n\nimport { cn } from '../../../utils'\n\nimport {\n  accessor,\n  CHART_MARGINS,\n  CHART_STYLE,\n  type ChartProps,\n  Crosshair,\n  type CrosshairState,\n  type DataPoint,\n  setupCrosshair,\n  stylePlot,\n  useDims,\n  withChartBlend\n} from './utils'\n\nexport const LineChart = withChartBlend(\n  <T extends DataPoint>({\n    backgroundColor: _,\n    className,\n    color: strokeColor,\n    curve = 'natural',\n    data = [],\n    formatTooltip,\n    formatX: formatXProp,\n    formatY: formatYProp,\n    series = 'series' as keyof T,\n    showArea = false,\n    x = 'label' as keyof T,\n    xTicks,\n    y = 'value' as keyof T,\n    yDomain = [0, 0.5],\n    yTicks = 4,\n    ...props\n  }: LineChartProps<T> & { backgroundColor?: string; color?: string }) => {\n    const ref = useRef<HTMLDivElement>(null)\n    const plotRef = useRef<HTMLDivElement>(null)\n    const [hovered, setHovered] = useState<null | T>(null)\n    const [crosshair, setCrosshair] = useState<CrosshairState>({ x: null })\n    const dims = useDims(ref)\n\n    const formatX = useCallback(\n      (v: unknown) =>\n        formatXProp?.(v) ??\n        ((v as number) >= 1e3 ? `${(v as number) / 1e3}k` : `${v}`),\n      [formatXProp]\n    )\n\n    const formatY = useCallback(\n      (v: number) => formatYProp?.(v) ?? `${Math.round(v * 100)}%`,\n      [formatYProp]\n    )\n\n    const getX = useMemo(() => accessor<T, unknown>(x), [x])\n    const getY = useMemo(() => accessor<T, number>(y), [y])\n    const getZ = useCallback((d: T) => d[series], [series])\n\n    useEffect(() => {\n      if (\n        !ref.current ||\n        !plotRef.current ||\n        !data.length ||\n        !dims.h ||\n        !dims.w\n      ) {\n        return\n      }\n\n      plotRef.current.innerHTML = ''\n\n      const hasSeries = data.some(d => d[series] !== undefined)\n\n      const seriesIdx = hasSeries\n        ? data.reduce(\n            (acc, d, i) => ((acc[d[series] as string] ??= i), acc),\n            {} as Record<string, number>\n          )\n        : {}\n\n      const n = Object.keys(seriesIdx).length\n\n      const opacity = (d: T) => {\n        if (!hasSeries) {\n          return 1\n        }\n\n        if (hovered) {\n          return d[series] === hovered[series] ? 1 : 0.2\n        }\n\n        return 1 - (seriesIdx[d[series] as string] / Math.max(n - 1, 1)) * 0.2\n      }\n\n      const lineOpts = {\n        curve,\n        x: getX as (d: T) => unknown,\n        y: getY,\n        ...(hasSeries && { z: getZ as (d: T) => unknown })\n      }\n\n      const plot = Plot.plot({\n        ...CHART_MARGINS,\n        height: dims.h,\n        marks: [\n          ...(showArea\n            ? [\n                Plot.areaY(data, {\n                  ...lineOpts,\n                  fill: strokeColor,\n                  fillOpacity: 0.15,\n                  y1: yDomain[0]\n                })\n              ]\n            : []),\n          Plot.lineY(data, {\n            ...lineOpts,\n            stroke: 'transparent',\n            strokeWidth: 16\n          }),\n          Plot.lineY(data, {\n            ...lineOpts,\n            stroke: strokeColor,\n            strokeOpacity: opacity,\n            strokeWidth: 1.5\n          })\n        ],\n        style: { ...CHART_STYLE, fontStretch: 'expanded' },\n        width: dims.w,\n        x: { label: null, tickFormat: formatX, ticks: xTicks },\n        y: {\n          domain: yDomain,\n          grid: true,\n          label: null,\n          tickFormat: formatY,\n          ticks: yTicks\n        }\n      })\n\n      plot.addEventListener('input', () => setHovered(plot.value as null | T))\n      stylePlot(plot as HTMLElement)\n\n      plot.querySelectorAll('g[aria-label=\"line\"] path').forEach(el =>\n        Object.assign((el as SVGPathElement).style, {\n          transition: 'stroke-opacity 0.2s'\n        })\n      )\n\n      plotRef.current.appendChild(plot)\n\n      const cleanup = setupCrosshair(\n        ref.current,\n        data,\n        d => getX(d) as number,\n        getY,\n        yDomain,\n        d => formatTooltip?.(d) ?? `${formatX(getX(d))}: ${formatY(getY(d))}`,\n        setCrosshair,\n        hasSeries ? d => getZ(d) : undefined\n      )\n\n      return () => {\n        cleanup()\n        plot.parentNode && plot.remove()\n      }\n    }, [\n      curve,\n      data,\n      dims.h,\n      dims.w,\n      formatTooltip,\n      formatX,\n      formatY,\n      getX,\n      getY,\n      getZ,\n      hovered,\n      series,\n      showArea,\n      strokeColor,\n      xTicks,\n      yDomain,\n      yTicks\n    ])\n\n    return (\n      <div\n        className={cn('relative aspect-4/1 w-full overflow-clip', className)}\n        ref={ref}\n        {...props}\n      >\n        <div className=\"absolute inset-0\" ref={plotRef} />\n\n        <Crosshair\n          color={strokeColor}\n          containerWidth={dims.w}\n          height={dims.h}\n          {...crosshair}\n        />\n      </div>\n    )\n  }\n)\n\ninterface LineChartProps<T extends DataPoint> extends ChartProps<T> {\n  curve?: 'basis' | 'catmull-rom' | 'linear' | 'natural' | 'step'\n  series?: keyof T\n  showArea?: boolean\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/ui/components/graphs/utils.d.ts

@@ -0,0 +1,52 @@
+import { type ComponentType, type HTMLAttributes, type RefObject } from 'react';
+import { type BlendColors, type BlendModeProps } from '../blend-mode';
+export declare const accessor: <T, R>(key: ((d: T) => R) | keyof T) => (d: T) => R;
+export declare const CHART_MARGINS: {
+    readonly marginBottom: 24;
+    readonly marginLeft: 36;
+    readonly marginRight: 12;
+    readonly marginTop: 8;
+};
+export declare const CHART_STYLE: {
+    readonly background: "transparent";
+    readonly color: "var(--midground)";
+    readonly fontFamily: "var(--font-mono), monospace";
+    readonly fontSize: "11px";
+    readonly overflow: "hidden";
+};
+export declare const stylePlot: (plot: HTMLElement) => void;
+export declare const useDims: (ref: RefObject<HTMLElement | null>) => {
+    h: number;
+    w: number;
+};
+export declare const Crosshair: ({ color, containerWidth, height, points, x }: CrosshairState & {
+    color?: string;
+    containerWidth: number;
+    height: number;
+}) => import("react").JSX.Element | null;
+export declare const setupCrosshair: <T extends DataPoint>(container: HTMLElement, data: T[], getX: (d: T) => number, getY: (d: T) => number, yDomain: [number, number], formatTooltip: (d: T) => string, onUpdate: (state: CrosshairState) => void, getZ?: (d: T) => unknown) => () => void;
+export declare const withChartBlend: <P extends BlendModeProps>(Component: ComponentType<P>) => {
+    (props: Omit<P, keyof BlendColors>): import("react").JSX.Element;
+    displayName: string;
+};
+export type DataPoint = Record<string, unknown>;
+export interface CrosshairPoint {
+    dotY: number;
+    tooltip: string;
+}
+export interface CrosshairState {
+    points?: CrosshairPoint[];
+    x: null | number;
+}
+export interface ChartProps<T = DataPoint> extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    data?: T[];
+    formatTooltip?: (d: T) => string;
+    formatX?: (v: unknown) => string;
+    formatY?: (v: number) => string;
+    height?: number;
+    x?: ((d: T) => unknown) | keyof T;
+    xTicks?: number | number[];
+    y?: ((d: T) => number) | keyof T;
+    yDomain?: [number, number];
+    yTicks?: number | number[];
+}