@open-tomato/charts 0.0.0-stage → 0.1.0

package/dist/index-85mb21rn.js

@@ -0,0 +1,69 @@
+// src/theme/tokens.ts
+var SERIES_TOKENS = [
+  "--color-series-1",
+  "--color-series-2",
+  "--color-series-3",
+  "--color-series-4",
+  "--color-series-5",
+  "--color-series-6",
+  "--color-series-7",
+  "--color-series-8"
+];
+var STATUS_TOKENS = [
+  "--color-good",
+  "--color-warning",
+  "--color-serious",
+  "--color-critical"
+];
+var SURFACE_TOKENS = [
+  "--color-surface",
+  "--color-plane",
+  "--color-ink",
+  "--color-ink-2",
+  "--color-muted",
+  "--color-grid",
+  "--color-baseline",
+  "--color-ring"
+];
+var SEQUENTIAL_TOKENS = [
+  "--color-seq-100",
+  "--color-seq-200",
+  "--color-seq-300",
+  "--color-seq-400",
+  "--color-seq-500",
+  "--color-seq-600",
+  "--color-seq-700",
+  "--color-diverge-mid"
+];
+var POLE_TOKENS = [
+  "--color-pole-ship",
+  "--color-pole-ship-core",
+  "--color-pole-fail",
+  "--color-pole-fail-core",
+  "--color-pole-base",
+  "--color-pole-base-core"
+];
+var DELTA_TOKENS = [
+  "--color-delta-up"
+];
+var THEME_TOKENS = [
+  ...SERIES_TOKENS,
+  ...STATUS_TOKENS,
+  ...SURFACE_TOKENS,
+  ...SEQUENTIAL_TOKENS,
+  ...POLE_TOKENS,
+  ...DELTA_TOKENS
+];
+var THEME_ATTRIBUTE = "data-theme";
+var DARK_THEME = "dark";
+function tokenVar(token) {
+  return `var(${token})`;
+}
+var TOKEN_PREFIX = "--color-";
+function tokenName(token) {
+  return token.slice(TOKEN_PREFIX.length);
+}
+function tokenNames(tokens) {
+  return tokens.map((token) => tokenName(token));
+}
+export { SERIES_TOKENS, STATUS_TOKENS, SURFACE_TOKENS, SEQUENTIAL_TOKENS, POLE_TOKENS, DELTA_TOKENS, THEME_TOKENS, THEME_ATTRIBUTE, DARK_THEME, tokenVar, TOKEN_PREFIX, tokenName, tokenNames };

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * `@open-tomato/charts`: the root barrel. The seam (primitive types, tones,
+ * formatters, the engine provider), the ECharts engine's React adapter,
+ * `cn` and the theme token names. `./theme` is also a subpath export, and
+ * `./engine` is the headless engine (`src/engine/headless/`): option
+ * builders and an SVG renderer with no React and no DOM.
+ */
+export * from './engine/index.js';
+export * from './lib/index.js';
+export * from './seam/index.js';
+export * from './theme/index.js';

package/dist/index.js

@@ -0,0 +1,618 @@
+import {
+  ALL_TONES,
+  CHROME_ROLES,
+  DATE_PATTERNS,
+  DEFAULT_CHART_HEIGHT,
+  DEFAULT_FORMAT_CONTEXT,
+  DEFAULT_HEIGHT,
+  DOTS_SERIES,
+  DURATION_UNITS,
+  HIT_SERIES,
+  PERCENT_BASES,
+  SEQUENTIAL_STEPS,
+  UNIT_POSITIONS,
+  VALUE_FORMAT_KINDS,
+  buildOption,
+  buildOption1 as buildOption2,
+  buildOption10 as buildOption11,
+  buildOption11 as buildOption12,
+  buildOption12 as buildOption13,
+  buildOption13 as buildOption14,
+  buildOption14 as buildOption15,
+  buildOption2 as buildOption3,
+  buildOption3 as buildOption4,
+  buildOption4 as buildOption5,
+  buildOption5 as buildOption6,
+  buildOption6 as buildOption7,
+  buildOption7 as buildOption8,
+  buildOption8 as buildOption9,
+  buildOption9 as buildOption10,
+  chartFrameVariants,
+  chartRootVariants,
+  chartTone,
+  finishOption,
+  formatCompact,
+  formatContextSchema,
+  formatDate,
+  formatDay,
+  formatElapsed,
+  formatMeasured,
+  formatMinutes,
+  formatPercent,
+  formatRelative,
+  formatWeek,
+  formatterFor,
+  nodeIdOf,
+  pathsById,
+  plotHeightOf,
+  readTokens,
+  resolveFormatContext,
+  tokensFrom,
+  toneVar,
+  valueFormatSchema
+} from "./index-4bxmxw89.js";
+import {
+  DARK_THEME,
+  DELTA_TOKENS,
+  POLE_TOKENS,
+  SEQUENTIAL_TOKENS,
+  SERIES_TOKENS,
+  STATUS_TOKENS,
+  SURFACE_TOKENS,
+  THEME_ATTRIBUTE,
+  THEME_TOKENS,
+  TOKEN_PREFIX,
+  tokenName,
+  tokenNames,
+  tokenVar
+} from "./index-85mb21rn.js";
+
+// src/engine/shared.tsx
+import * as echarts from "echarts/core";
+import { CanvasRenderer } from "echarts/renderers";
+import { useEffect as useEffect2, useLayoutEffect, useMemo, useRef } from "react";
+
+// src/lib/cn.ts
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+function cn(...inputs) {
+  return twMerge(clsx(inputs));
+}
+
+// src/seam/useResolvedTokens.ts
+import { useEffect, useState } from "react";
+function sameTokens(a, b) {
+  const names = Object.keys(a);
+  return names.length === Object.keys(b).length && names.every((name) => a[name] === b[name]);
+}
+function useResolvedTokens() {
+  const [tokens, setTokens] = useState(() => readTokens());
+  useEffect(() => {
+    const observer = new MutationObserver(() => {
+      const next = readTokens();
+      setTokens((previous) => sameTokens(previous, next) ? previous : next);
+    });
+    observer.observe(document.documentElement, { attributes: true, attributeFilter: [THEME_ATTRIBUTE] });
+    return () => observer.disconnect();
+  }, []);
+  return tokens;
+}
+
+// src/engine/shared.tsx
+import { jsx } from "react/jsx-runtime";
+echarts.use([CanvasRenderer]);
+function useBuiltOption(props, build) {
+  const tokens = useResolvedTokens();
+  return useMemo(() => finishOption(build(props, tokens), props.animate), [build, props, tokens]);
+}
+function EChart({ option, ariaLabel, height, className, cursor, onEvents, replaceMerge, transform }) {
+  const hostRef = useRef(null);
+  const chartRef = useRef(null);
+  const hostHeight = height === "fill" ? "100%" : `${height ?? DEFAULT_HEIGHT}px`;
+  useLayoutEffect(() => {
+    const host = hostRef.current;
+    if (!host)
+      return;
+    host.style.height = hostHeight;
+    chartRef.current?.resize();
+  }, [hostHeight]);
+  useLayoutEffect(() => {
+    const host = hostRef.current;
+    if (!host)
+      return;
+    const chart = echarts.init(host, undefined, { renderer: "canvas" });
+    chartRef.current = chart;
+    let width = chart.getWidth();
+    let height2 = chart.getHeight();
+    let frame = 0;
+    const observer = new ResizeObserver(() => {
+      cancelAnimationFrame(frame);
+      frame = requestAnimationFrame(() => {
+        const next = { width: host.clientWidth, height: host.clientHeight };
+        if (next.width === width && next.height === height2)
+          return;
+        width = next.width;
+        height2 = next.height;
+        chart.resize();
+      });
+    });
+    observer.observe(host);
+    return () => {
+      cancelAnimationFrame(frame);
+      observer.disconnect();
+      chart.dispose();
+      chartRef.current = null;
+    };
+  }, []);
+  useEffect2(() => {
+    const chart = chartRef.current;
+    if (!chart)
+      return;
+    const next = transform ? transform(option, chart) : option;
+    chart.setOption(next, replaceMerge ? { replaceMerge: [...replaceMerge] } : { notMerge: true });
+  }, [option, replaceMerge, transform]);
+  useEffect2(() => {
+    const chart = chartRef.current;
+    if (!chart || !onEvents)
+      return;
+    const bound = Object.entries(onEvents).map(([name, handler]) => {
+      const listener = (event) => handler(event, chart);
+      chart.on(name, listener);
+      return [name, listener];
+    });
+    return () => {
+      for (const [name, listener] of bound)
+        chart.off(name, listener);
+    };
+  }, [onEvents]);
+  return /* @__PURE__ */ jsx("div", {
+    ref: hostRef,
+    role: "img",
+    "aria-label": ariaLabel,
+    className: cn(chartRootVariants({ cursor }), className)
+  });
+}
+
+// src/engine/BarChart/BarChart.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+function BarChart(props) {
+  const { className } = props;
+  const option = useBuiltOption(props, buildOption);
+  return /* @__PURE__ */ jsx2(EChart, {
+    option,
+    ariaLabel: props.ariaLabel,
+    height: props.height,
+    className
+  });
+}
+// src/engine/BoxPlot/BoxPlot.tsx
+import { jsx as jsx3 } from "react/jsx-runtime";
+function BoxPlot(props) {
+  const { className } = props;
+  const option = useBuiltOption(props, buildOption2);
+  return /* @__PURE__ */ jsx3(EChart, {
+    option,
+    ariaLabel: props.ariaLabel,
+    height: props.height,
+    className
+  });
+}
+// src/engine/Bullet/Bullet.tsx
+import { jsx as jsx4 } from "react/jsx-runtime";
+function Bullet(props) {
+  const { className } = props;
+  const option = useBuiltOption(props, buildOption3);
+  return /* @__PURE__ */ jsx4(EChart, {
+    option,
+    ariaLabel: props.ariaLabel,
+    height: props.height,
+    className
+  });
+}
+// src/engine/Donut/Donut.tsx
+import { jsx as jsx5 } from "react/jsx-runtime";
+function Donut(props) {
+  const { className } = props;
+  const option = useBuiltOption(props, buildOption4);
+  return /* @__PURE__ */ jsx5(EChart, {
+    option,
+    ariaLabel: props.ariaLabel,
+    height: props.height,
+    className
+  });
+}
+// src/engine/Gauge/Gauge.tsx
+import { jsx as jsx6 } from "react/jsx-runtime";
+function Gauge(props) {
+  const { className } = props;
+  const option = useBuiltOption(props, buildOption5);
+  return /* @__PURE__ */ jsx6(EChart, {
+    option,
+    ariaLabel: props.ariaLabel,
+    height: props.height,
+    className
+  });
+}
+// src/engine/HeatmapGrid/HeatmapGrid.tsx
+import { useMemo as useMemo2 } from "react";
+import { jsx as jsx7 } from "react/jsx-runtime";
+function cellOf(event) {
+  if (typeof event !== "object" || event === null || !("value" in event))
+    return null;
+  const value = event.value;
+  if (!Array.isArray(value))
+    return null;
+  const [col, row, count] = value.map(Number);
+  if (col === undefined || row === undefined || count === undefined)
+    return null;
+  return { row, col, value: count };
+}
+function HeatmapGrid(props) {
+  const { className } = props;
+  const option = useBuiltOption(props, buildOption6);
+  const { onCellClick } = props;
+  const onEvents = useMemo2(() => onCellClick ? {
+    click: (event) => {
+      const cell = cellOf(event);
+      if (cell)
+        onCellClick(cell);
+    }
+  } : undefined, [onCellClick]);
+  return /* @__PURE__ */ jsx7(EChart, {
+    option,
+    ariaLabel: props.ariaLabel,
+    height: props.height,
+    className,
+    cursor: onCellClick ? "auto" : "default",
+    onEvents
+  });
+}
+// src/engine/Histogram/Histogram.tsx
+import { jsx as jsx8 } from "react/jsx-runtime";
+function Histogram(props) {
+  const { className } = props;
+  const option = useBuiltOption(props, buildOption7);
+  return /* @__PURE__ */ jsx8(EChart, {
+    option,
+    ariaLabel: props.ariaLabel,
+    height: props.height,
+    className
+  });
+}
+// src/engine/LineChart/LineChart.tsx
+import { useMemo as useMemo3, useRef as useRef2 } from "react";
+import { jsx as jsx9 } from "react/jsx-runtime";
+var REPLACE_MERGE = ["series"];
+function readZoomWindow(instance) {
+  const live = instance.getOption();
+  const zoom = live?.dataZoom?.[0];
+  if (!zoom)
+    return null;
+  const full = (zoom.start ?? 0) <= 0 && (zoom.end ?? 100) >= 100;
+  if (full || zoom.startValue === undefined || zoom.endValue === undefined)
+    return null;
+  return { from: zoom.startValue, to: zoom.endValue };
+}
+function carryZoom(option, instance) {
+  const zoomWindow = readZoomWindow(instance);
+  if (zoomWindow === null || !Array.isArray(option.dataZoom))
+    return option;
+  const dataZoom = option.dataZoom.map((entry) => {
+    const rest = Object.fromEntries(Object.entries(entry).filter(([key]) => key !== "start" && key !== "end"));
+    return { ...rest, startValue: zoomWindow.from, endValue: zoomWindow.to };
+  });
+  return { ...option, dataZoom };
+}
+function LineChart(props) {
+  const { className } = props;
+  const reportedRef = useRef2(null);
+  const option = useBuiltOption(props, buildOption8);
+  const { onRangeChange, zoom } = props;
+  const onEvents = useMemo3(() => zoom ? {
+    datazoom: (_event, instance) => {
+      const next = readZoomWindow(instance);
+      const previous = reportedRef.current;
+      if (next?.from === previous?.from && next?.to === previous?.to)
+        return;
+      reportedRef.current = next;
+      onRangeChange?.(next === null ? null : { from: new Date(next.from), to: new Date(next.to) });
+    }
+  } : undefined, [zoom, onRangeChange]);
+  return /* @__PURE__ */ jsx9(EChart, {
+    option,
+    ariaLabel: props.ariaLabel,
+    height: props.height,
+    className,
+    onEvents,
+    replaceMerge: zoom ? REPLACE_MERGE : undefined,
+    transform: zoom ? carryZoom : undefined
+  });
+}
+// src/engine/NetworkGraph/NetworkGraph.tsx
+import { useMemo as useMemo4 } from "react";
+import { jsx as jsx10 } from "react/jsx-runtime";
+function NetworkGraph(props) {
+  const { className } = props;
+  const { nodes, links, groupTones, onNodeClick, animate } = props;
+  const optionProps = useMemo4(() => ({ nodes, links, groupTones, onNodeClick, animate }), [nodes, links, groupTones, onNodeClick, animate]);
+  const option = useBuiltOption(optionProps, buildOption9);
+  const onEvents = useMemo4(() => onNodeClick ? {
+    click: (event) => {
+      const data = typeof event === "object" && event !== null && "data" in event ? event.data : undefined;
+      const node = nodes.find((entry) => entry.id === nodeIdOf(data));
+      if (node)
+        onNodeClick(node);
+    }
+  } : undefined, [nodes, onNodeClick]);
+  return /* @__PURE__ */ jsx10(EChart, {
+    option,
+    ariaLabel: props.ariaLabel,
+    height: props.height,
+    className,
+    onEvents
+  });
+}
+// src/engine/Nightingale/Nightingale.tsx
+import { jsx as jsx11 } from "react/jsx-runtime";
+function Nightingale(props) {
+  const { className } = props;
+  const option = useBuiltOption(props, buildOption10);
+  return /* @__PURE__ */ jsx11(EChart, {
+    option,
+    ariaLabel: props.ariaLabel,
+    height: props.height,
+    className
+  });
+}
+// src/engine/Radar/Radar.tsx
+import { jsx as jsx12 } from "react/jsx-runtime";
+function Radar(props) {
+  const { className } = props;
+  const option = useBuiltOption(props, buildOption11);
+  return /* @__PURE__ */ jsx12(EChart, {
+    option,
+    ariaLabel: props.ariaLabel,
+    height: props.height,
+    className
+  });
+}
+// src/engine/Sankey/Sankey.tsx
+import { useMemo as useMemo5 } from "react";
+import { jsx as jsx13 } from "react/jsx-runtime";
+function Sankey(props) {
+  const { className } = props;
+  const { nodes, links, groupTones, groupOrder, valueFormat, animate } = props;
+  const optionProps = useMemo5(() => ({ nodes, links, groupTones, groupOrder, valueFormat, animate }), [nodes, links, groupTones, groupOrder, valueFormat, animate]);
+  const option = useBuiltOption(optionProps, buildOption12);
+  return /* @__PURE__ */ jsx13(EChart, {
+    option,
+    ariaLabel: props.ariaLabel,
+    height: props.height,
+    className,
+    cursor: "default"
+  });
+}
+// src/engine/ScatterChart/ScatterChart.tsx
+import { jsx as jsx14 } from "react/jsx-runtime";
+var liftDot = {
+  mouseover: (event, instance) => {
+    const index = dataIndexOf(event);
+    if (index !== undefined)
+      instance.dispatchAction({ type: "highlight", seriesId: DOTS_SERIES, dataIndex: index });
+  },
+  mouseout: (event, instance) => {
+    const index = dataIndexOf(event);
+    if (index !== undefined)
+      instance.dispatchAction({ type: "downplay", seriesId: DOTS_SERIES, dataIndex: index });
+  }
+};
+function dataIndexOf(event) {
+  if (typeof event !== "object" || event === null)
+    return;
+  const { seriesId, dataIndex } = event;
+  return seriesId === HIT_SERIES && typeof dataIndex === "number" ? dataIndex : undefined;
+}
+function ScatterChart(props) {
+  const { className } = props;
+  const option = useBuiltOption(props, buildOption13);
+  return /* @__PURE__ */ jsx14(EChart, {
+    option,
+    ariaLabel: props.ariaLabel,
+    height: props.height,
+    className,
+    onEvents: liftDot
+  });
+}
+// src/engine/Sunburst/Sunburst.tsx
+import {
+  useCallback,
+  useMemo as useMemo6,
+  useState as useState2
+} from "react";
+import { jsx as jsx15 } from "react/jsx-runtime";
+function idOf(event) {
+  if (typeof event !== "object" || event === null || !("data" in event))
+    return;
+  const data = event.data;
+  return typeof data === "object" && data !== null && "id" in data ? String(data.id) : undefined;
+}
+var UNMEASURED = { width: 0, height: 0 };
+function useSize() {
+  const [size, setSize] = useState2(UNMEASURED);
+  const ref = useCallback((element) => {
+    if (!element)
+      return;
+    const observer = new ResizeObserver(([entry]) => {
+      const width = Math.round(entry?.contentRect.width ?? 0);
+      const height = Math.round(entry?.contentRect.height ?? 0);
+      setSize((current) => current.width === width && current.height === height ? current : { width, height });
+    });
+    observer.observe(element);
+    return () => observer.disconnect();
+  }, []);
+  return [ref, size];
+}
+function Sunburst(props) {
+  const { className } = props;
+  const [measure, size] = useSize();
+  const fill = props.height === "fill";
+  const { width } = size;
+  const height = fill ? size.height : 0;
+  const tokens = useResolvedTokens();
+  const option = useMemo6(() => finishOption(buildOption14(props, tokens, width, height), props.animate), [props, tokens, width, height]);
+  const { onNodeClick, nodes } = props;
+  const onEvents = useMemo6(() => onNodeClick ? {
+    click: (event) => {
+      const id = idOf(event);
+      const path = id === undefined ? undefined : pathsById(nodes).get(id);
+      if (path)
+        onNodeClick(path);
+    }
+  } : undefined, [nodes, onNodeClick]);
+  return /* @__PURE__ */ jsx15("div", {
+    ref: measure,
+    className: chartFrameVariants({ fill }),
+    children: /* @__PURE__ */ jsx15(EChart, {
+      option,
+      ariaLabel: props.ariaLabel,
+      height: props.height,
+      className,
+      cursor: onNodeClick ? "auto" : "default",
+      onEvents
+    })
+  });
+}
+// src/engine/Treemap/Treemap.tsx
+import { jsx as jsx16 } from "react/jsx-runtime";
+function Treemap(props) {
+  const { className } = props;
+  const option = useBuiltOption(props, buildOption15);
+  return /* @__PURE__ */ jsx16(EChart, {
+    option,
+    ariaLabel: props.ariaLabel,
+    height: props.height,
+    className
+  });
+}
+// src/engine/echartsEngine.ts
+var echartsEngine = {
+  id: "echarts",
+  label: "ECharts 6",
+  notes: [
+    "All fifteen primitives are native ECharts series (bar, line, scatter, boxplot, gauge, pie, treemap, heatmap, graph, sankey, sunburst, radar); structural: canvas cannot read CSS variables, so every option is rebuilt from useResolvedTokens() and set with notMerge on a theme flip (the zoomable line chart merges instead, replacing only its series, so the zoom window survives a legend toggle).",
+    "Line zoom: native dataZoom (slider + inside, pinch or ctrl+wheel); the window is read back from the instance on each datazoom event and fed into every rebuilt option.",
+    "Gauge compare and overflow: a second gauge series is the inner arc; the max marker is a third, zero-span gauge whose only split line sits at the arc end, since the gauge has no marker of its own.",
+    "Donut compare: a second pie series is the inner ring; the shared tooltip matches the slice across rings by id.",
+    "Heatmap click: native click event and a per-item ink border for the selected cell (drawn last so no neighbour gap paints over it). Keyboard is a canvas gap: cells cannot take focus, so Enter/Space are not supported. The heatmap view ignores the series cursor, so a root class removes the pointer when cells are not buttons.",
+    "Sankey: columns come from groupOrder via node depth, spread over ECharts' own column count (the longest path), which it uses whatever depths the nodes carry; links inside one layer have no column to cross and draw as short back-curves.",
+    "Bar stacked100: no built-in percent stack; the values are normalised to category shares before the option, with a percent formatter.",
+    "Bullet: no bullet series; composed from three stacked bar series (the bands) and an 8px bar on a second hidden category axis, the target as a markLine, the value text as graphic elements.",
+    "Box plot: one borderColor strokes box, whiskers and median; it is set to ink-2 and a custom series redraws the median as a 2px ink line on top.",
+    "Treemap: native labels truncate rather than hide; a labelLayout hook measures the text against the node rect and parks unfit labels off the canvas.",
+    "Scatter: dots are hit-tested at their drawn size; an invisible 24px scatter series takes the hover and highlights the visible dot.",
+    "Histogram: ticks at bin edges come from a second category axis with n+1 entries and no boundary gap over the band axis.",
+    `Nightingale: native pie with roseType "area" (equal angles, radius by value; ECharts' "radius" rose sizes the angles too); labels under 4% of the total are switched off per item.`,
+    "Sunburst: native sunburst; the two rings are levels with their own radii, labels hide natively under 18 degrees (minAngle), nodeClick is off and a click maps the item id to its root-to-node path for onNodeClick.",
+    "Radar: native radar and radar series; the sectors are a silent pie behind it whose wedges span each sector's axes, labelled outside with icon and name; the baseline is a second one-axis radar sized to the baseline value, its ring in ink-2 and its axis name as the label; the per-axis tooltip comes from a transparent pie with one slice per axis on top, since the radar series only reports whole shapes."
+  ],
+  BarChart,
+  LineChart,
+  ScatterChart,
+  Histogram,
+  BoxPlot,
+  Gauge,
+  Bullet,
+  Donut,
+  Treemap,
+  HeatmapGrid,
+  NetworkGraph,
+  Sankey,
+  Nightingale,
+  Sunburst,
+  Radar
+};
+// src/seam/FormatProvider.tsx
+import { createContext, useContext, useMemo as useMemo7 } from "react";
+import { jsx as jsx17 } from "react/jsx-runtime";
+var FormatContextState = createContext({});
+function FormatProvider({ context, children }) {
+  return /* @__PURE__ */ jsx17(FormatContextState.Provider, {
+    value: context,
+    children
+  });
+}
+function useFormatContext() {
+  return useContext(FormatContextState);
+}
+function useFormatter(spec) {
+  const context = useFormatContext();
+  const key = spec === undefined ? undefined : JSON.stringify(spec);
+  return useMemo7(() => key === undefined ? undefined : formatterFor(JSON.parse(key), context), [key, context]);
+}
+// src/seam/ChartEngineProvider.tsx
+import { createContext as createContext2, useContext as useContext2 } from "react";
+import { jsx as jsx18 } from "react/jsx-runtime";
+var EngineContext = createContext2(null);
+function ChartEngineProvider({ engine, children }) {
+  return /* @__PURE__ */ jsx18(EngineContext.Provider, {
+    value: engine,
+    children
+  });
+}
+function useChartEngine() {
+  const engine = useContext2(EngineContext);
+  if (!engine)
+    throw new Error("useChartEngine needs a ChartEngineProvider above it");
+  return engine;
+}
+export {
+  valueFormatSchema,
+  useResolvedTokens,
+  useFormatter,
+  useFormatContext,
+  useChartEngine,
+  toneVar,
+  tokensFrom,
+  tokenVar,
+  tokenNames,
+  tokenName,
+  resolveFormatContext,
+  readTokens,
+  plotHeightOf,
+  formatterFor,
+  formatWeek,
+  formatRelative,
+  formatPercent,
+  formatMinutes,
+  formatMeasured,
+  formatElapsed,
+  formatDay,
+  formatDate,
+  formatContextSchema,
+  formatCompact,
+  echartsEngine,
+  cn,
+  chartTone,
+  VALUE_FORMAT_KINDS,
+  UNIT_POSITIONS,
+  TOKEN_PREFIX,
+  THEME_TOKENS,
+  THEME_ATTRIBUTE,
+  SURFACE_TOKENS,
+  STATUS_TOKENS,
+  SERIES_TOKENS,
+  SEQUENTIAL_TOKENS,
+  SEQUENTIAL_STEPS,
+  POLE_TOKENS,
+  PERCENT_BASES,
+  FormatProvider,
+  DURATION_UNITS,
+  DELTA_TOKENS,
+  DEFAULT_FORMAT_CONTEXT,
+  DEFAULT_CHART_HEIGHT,
+  DATE_PATTERNS,
+  DARK_THEME,
+  ChartEngineProvider,
+  CHROME_ROLES,
+  ALL_TONES
+};

package/dist/lib/cn.d.ts

@@ -0,0 +1,7 @@
+import { type ClassValue } from 'clsx';
+/**
+ * Joins class values and resolves Tailwind conflicts, the later class
+ * winning. A component calls it as `cn(xVariants({ ... }), className)`, so
+ * the passthrough `className` merges last and can override layout only.
+ */
+export declare function cn(...inputs: ClassValue[]): string;