@jcsoftdev/ui 0.0.0-stage → 0.1.0

package/dist/charts/heatmap-chart/heatmap-grid.js

@@ -0,0 +1,494 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useMemo, useRef, useState } from "react";
+import { cn } from "../../utils/cn.js";
+import { estimateTextWidth } from "../core/axes.js";
+import {
+  inkOn,
+  rangeColor,
+  scaleGradient
+} from "../core/color-scale.js";
+import { EASE_OUT, useEntryAnimation } from "../core/motion.js";
+import { ChartTooltip } from "../core/tooltip.js";
+import { DEFAULT_LABELS } from "../core/types.js";
+import { useCanvasPaint } from "../core/use-canvas.js";
+import { hexLayout, hexPath } from "./hex-layout.js";
+const DEFAULT_HEATMAP_LABELS = {
+  ...DEFAULT_LABELS,
+  explore: "Heatmap cells. Use the arrow keys to move between rows and columns.",
+  category: "Row",
+  noData: "No data"
+};
+function resolveHeatmapLabels(labels) {
+  return labels ? { ...DEFAULT_HEATMAP_LABELS, ...labels } : DEFAULT_HEATMAP_LABELS;
+}
+const HEATMAP_TOP = 22;
+function rowGutter(width, rowLabels) {
+  return Math.min(
+    width < 420 ? 52 : 120,
+    Math.max(0, ...rowLabels.map((label) => estimateTextWidth(label, 11))) + 10
+  );
+}
+const TOP = HEATMAP_TOP;
+function HeatmapGrid({
+  width,
+  height,
+  title,
+  rowLabels,
+  columnLabels,
+  values,
+  colorScale,
+  format,
+  cellTitle,
+  labels,
+  cellLabels,
+  gap,
+  radius,
+  square,
+  tooltip,
+  animate,
+  onCellClick,
+  valueName,
+  shape = "rect",
+  renderer = "svg"
+}) {
+  const rows = rowLabels.length;
+  const columns = columnLabels.length;
+  const rowLabelWidth = rowGutter(width, rowLabels);
+  const left = rowLabelWidth;
+  const availableWidth = Math.max(0, width - left);
+  const availableHeight = Math.max(0, height - TOP);
+  const cellWidth = columns > 0 ? availableWidth / columns : 0;
+  const cellHeight = rows > 0 ? availableHeight / rows : 0;
+  const side = Math.min(cellWidth, cellHeight);
+  const w = square ? side : cellWidth;
+  const h = square ? side : cellHeight;
+  const pad = Math.min(gap, w * 0.2, h * 0.2);
+  const canvas = renderer === "canvas";
+  const honeycomb = useMemo(
+    () => shape === "hex" ? hexLayout({ rows, columns, width: availableWidth, height: availableHeight }) : null,
+    [shape, rows, columns, availableWidth, availableHeight]
+  );
+  const hexDraw = honeycomb ? Math.max(0, honeycomb.radius - gap * 0.55) : 0;
+  const cellCenter = (row, column) => {
+    if (honeycomb) {
+      const c = honeycomb.center(row, column);
+      return { x: left + c.x, y: TOP + c.y };
+    }
+    return { x: left + column * w + w / 2, y: TOP + row * h + h / 2 };
+  };
+  const visibleColumnLabels = useMemo(() => {
+    const out = [];
+    let lastEnd = Number.NEGATIVE_INFINITY;
+    columnLabels.forEach((label, index) => {
+      if (!label) return;
+      const x = honeycomb ? left + honeycomb.center(0, index).x : left + index * w + (square ? 0 : w / 2);
+      const textWidth = estimateTextWidth(label, 11);
+      const start = square && !honeycomb ? x : x - textWidth / 2;
+      if (start < lastEnd + 6 || start + textWidth > width + 2) return;
+      out.push({ index, label });
+      lastEnd = start + textWidth;
+    });
+    return out;
+  }, [columnLabels, left, w, square, width, honeycomb]);
+  const [hover, setHover] = useState(null);
+  const [active, setActive] = useState(null);
+  const svgRef = useRef(null);
+  const canvasRef = useRef(null);
+  useEntryAnimation(
+    svgRef,
+    (element) => {
+      element.querySelectorAll("[data-column]").forEach((group, index) => {
+        group.animate([{ opacity: 0 }, { opacity: 1 }], {
+          duration: 420,
+          delay: Math.min(index * (360 / Math.max(1, columns)), 360),
+          easing: EASE_OUT,
+          fill: "backwards"
+        });
+      });
+    },
+    { disabled: !animate }
+  );
+  const valueAt = (row, column) => values[row]?.[column];
+  useCanvasPaint(
+    canvasRef,
+    width,
+    height,
+    ({ ctx, resolve }) => {
+      const css = new Array(rows * columns);
+      const wanted = /* @__PURE__ */ new Set();
+      for (let row = 0; row < rows; row += 1) {
+        for (let column = 0; column < columns; column += 1) {
+          const value = valueAt(row, column);
+          if (value === void 0) continue;
+          const color = (value == null ? null : colorScale.color(value)?.color) ?? "var(--surface-2)";
+          css[row * columns + column] = color;
+          wanted.add(color);
+        }
+      }
+      const list = [...wanted];
+      const resolvedList = resolve(list);
+      const stops = new Map(list.map((color, index) => [color, resolvedList[index]]));
+      const round = ctx.roundRect;
+      for (let row = 0; row < rows; row += 1) {
+        for (let column = 0; column < columns; column += 1) {
+          const color = css[row * columns + column];
+          if (color === void 0) continue;
+          ctx.fillStyle = stops.get(color);
+          ctx.beginPath();
+          if (honeycomb) {
+            const c = honeycomb.center(row, column);
+            for (let i = 0; i < 6; i += 1) {
+              const angle = Math.PI / 180 * (60 * i - 90);
+              const px = left + c.x + hexDraw * Math.cos(angle);
+              const py = TOP + c.y + hexDraw * Math.sin(angle);
+              if (i === 0) ctx.moveTo(px, py);
+              else ctx.lineTo(px, py);
+            }
+            ctx.closePath();
+          } else {
+            const x = left + column * w + pad / 2;
+            const y = TOP + row * h + pad / 2;
+            const cw = Math.max(0, w - pad);
+            const ch = Math.max(0, h - pad);
+            if (typeof round === "function" && radius > 0) {
+              ctx.roundRect(x, y, cw, ch, Math.min(radius, cw / 2, ch / 2));
+            } else ctx.rect(x, y, cw, ch);
+          }
+          ctx.fill();
+        }
+      }
+    },
+    [values, colorScale, honeycomb, w, h, pad, left, radius, rows, columns, canvas]
+  );
+  const lit = hover ?? active;
+  const crosshair = !honeycomb && !canvas;
+  const local = (event) => {
+    const box = event.currentTarget.getBoundingClientRect();
+    const x = event.clientX - box.left - left;
+    const y = event.clientY - box.top - TOP;
+    if (honeycomb) {
+      const hit = honeycomb.cellAt(x, y);
+      return hit && valueAt(hit.row, hit.column) !== void 0 ? hit : null;
+    }
+    const column = Math.floor(x / w);
+    const row = Math.floor(y / h);
+    if (x < 0 || y < 0 || column >= columns || row >= rows) return null;
+    if (valueAt(row, column) === void 0) return null;
+    return { row, column };
+  };
+  const onKeyDown = (event) => {
+    const current = active ?? { row: 0, column: 0 };
+    const moves = {
+      ArrowUp: [-1, 0],
+      ArrowDown: [1, 0],
+      ArrowLeft: [0, -1],
+      ArrowRight: [0, 1]
+    };
+    if (event.key === "Escape") {
+      setActive(null);
+      return;
+    }
+    if (event.key === "Enter" || event.key === " ") {
+      if (active && onCellClick) {
+        event.preventDefault();
+        onCellClick({ ...active, value: valueAt(active.row, active.column) ?? null });
+      }
+      return;
+    }
+    let next = null;
+    if (event.key === "Home") next = { row: current.row, column: 0 };
+    else if (event.key === "End") next = { row: current.row, column: columns - 1 };
+    else {
+      const move = moves[event.key];
+      if (!move) return;
+      let { row, column } = current;
+      do {
+        row += move[0];
+        column += move[1];
+      } while (row >= 0 && row < rows && column >= 0 && column < columns && valueAt(row, column) === void 0);
+      if (row >= 0 && row < rows && column >= 0 && column < columns) next = { row, column };
+    }
+    event.preventDefault();
+    if (next) {
+      setActive(next);
+      setHover(null);
+    }
+  };
+  const describe = (row, column) => {
+    const value = valueAt(row, column);
+    return `${cellTitle(row, column)}: ${value == null ? labels.noData : format(value)}`;
+  };
+  const shown = lit;
+  const shownValue = shown ? valueAt(shown.row, shown.column) : void 0;
+  const shownColor = shown && typeof shownValue === "number" ? colorScale.color(shownValue)?.color ?? "var(--surface-2)" : "var(--surface-2)";
+  return /* @__PURE__ */ jsxs("div", { className: "relative h-full w-full", children: [
+    canvas ? /* @__PURE__ */ jsx(
+      "canvas",
+      {
+        ref: canvasRef,
+        "data-canvas": "",
+        className: "pointer-events-none absolute top-0 left-0",
+        style: { width, height }
+      }
+    ) : null,
+    /* @__PURE__ */ jsxs(
+      "svg",
+      {
+        ref: svgRef,
+        role: "img",
+        "aria-label": title,
+        width,
+        height,
+        className: "relative block overflow-visible",
+        children: [
+          rowLabels.map((label, row) => /* @__PURE__ */ jsx(
+            "text",
+            {
+              x: left - 8,
+              y: cellCenter(row, 0).y,
+              textAnchor: "end",
+              dominantBaseline: "central",
+              className: cn(
+                "select-none text-[11px] transition-[fill] duration-150",
+                lit?.row === row ? "fill-ink font-bold" : "fill-ink-3 font-semibold"
+              ),
+              children: estimateTextWidth(label, 11) > left - 10 ? `${label.slice(0, Math.max(1, Math.floor((left - 14) / 6.4)))}\u2026` : label
+            },
+            row
+          )),
+          visibleColumnLabels.map(({ index, label }) => /* @__PURE__ */ jsx(
+            "text",
+            {
+              x: honeycomb ? cellCenter(0, index).x : left + index * w + (square ? pad / 2 : w / 2),
+              y: TOP - 8,
+              textAnchor: square && !honeycomb ? "start" : "middle",
+              className: cn(
+                "select-none text-[11px] transition-[fill] duration-150",
+                lit?.column === index ? "fill-ink font-bold" : "fill-ink-3 font-semibold"
+              ),
+              children: label
+            },
+            index
+          )),
+          canvas ? null : Array.from({ length: columns }, (_, column) => (
+            // biome-ignore lint/suspicious/noArrayIndexKey: columns follow the data order.
+            /* @__PURE__ */ jsx("g", { "data-column": "", children: Array.from({ length: rows }, (_2, row) => {
+              const value = valueAt(row, column);
+              if (value === void 0) return null;
+              const stop = value == null ? null : colorScale.color(value);
+              const inCross = lit != null && (lit.row === row || lit.column === column);
+              const dimmed = crosshair && lit != null && !inCross;
+              const fill = stop?.color ?? "var(--surface-2)";
+              const style = {
+                fill,
+                opacity: dimmed ? 0.42 : 1,
+                transition: "opacity 150ms ease-out"
+              };
+              const text = value == null ? "" : format(value);
+              if (honeycomb) {
+                const c = cellCenter(row, column);
+                const showHexText = cellLabels && value != null && hexDraw * 1.6 >= estimateTextWidth(text, 11);
+                return (
+                  // biome-ignore lint/suspicious/noArrayIndexKey: rows follow the data order.
+                  /* @__PURE__ */ jsxs("g", { children: [
+                    /* @__PURE__ */ jsx("path", { d: hexPath(c.x, c.y, hexDraw), strokeLinejoin: "round", style }),
+                    showHexText ? /* @__PURE__ */ jsx(
+                      "text",
+                      {
+                        x: c.x,
+                        y: c.y,
+                        textAnchor: "middle",
+                        dominantBaseline: "central",
+                        className: "pointer-events-none select-none font-bold text-[11px] tabular-nums",
+                        style: { fill: inkOn(stop?.strength ?? 0) },
+                        children: text
+                      }
+                    ) : null
+                  ] }, row)
+                );
+              }
+              const x = left + column * w + pad / 2;
+              const y = TOP + row * h + pad / 2;
+              const cw = Math.max(0, w - pad);
+              const ch = Math.max(0, h - pad);
+              const showText = cellLabels && value != null && cw >= estimateTextWidth(text, 11) + 6 && ch >= 16;
+              return (
+                // biome-ignore lint/suspicious/noArrayIndexKey: rows follow the data order.
+                /* @__PURE__ */ jsxs("g", { children: [
+                  /* @__PURE__ */ jsx(
+                    "rect",
+                    {
+                      x,
+                      y,
+                      width: cw,
+                      height: ch,
+                      rx: Math.min(radius, cw / 2, ch / 2),
+                      style
+                    }
+                  ),
+                  showText ? /* @__PURE__ */ jsx(
+                    "text",
+                    {
+                      x: x + cw / 2,
+                      y: y + ch / 2,
+                      textAnchor: "middle",
+                      dominantBaseline: "central",
+                      className: "pointer-events-none select-none font-bold text-[11px] tabular-nums",
+                      style: {
+                        fill: inkOn(stop?.strength ?? 0),
+                        opacity: dimmed ? 0.5 : 1
+                      },
+                      children: text
+                    }
+                  ) : null
+                ] }, row)
+              );
+            }) }, column)
+          )),
+          lit ? honeycomb ? /* @__PURE__ */ jsx(
+            "path",
+            {
+              d: hexPath(
+                cellCenter(lit.row, lit.column).x,
+                cellCenter(lit.row, lit.column).y,
+                hexDraw + 1.5
+              ),
+              strokeWidth: 2,
+              strokeLinejoin: "round",
+              className: "pointer-events-none",
+              style: { fill: "none", stroke: "var(--ink)" }
+            }
+          ) : /* @__PURE__ */ jsx(
+            "rect",
+            {
+              x: left + lit.column * w + pad / 2 - 1,
+              y: TOP + lit.row * h + pad / 2 - 1,
+              width: Math.max(0, w - pad) + 2,
+              height: Math.max(0, h - pad) + 2,
+              rx: radius + 1,
+              strokeWidth: 2,
+              className: "pointer-events-none",
+              style: { fill: "none", stroke: "var(--ink)" }
+            }
+          ) : null
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      "div",
+      {
+        role: "slider",
+        tabIndex: 0,
+        "aria-label": labels.explore,
+        "aria-valuemin": 1,
+        "aria-valuemax": Math.max(1, rows * columns),
+        "aria-valuenow": active ? active.row * columns + active.column + 1 : 1,
+        "aria-valuetext": active ? describe(active.row, active.column) : title,
+        onKeyDown,
+        onFocus: (event) => {
+          if (!event.currentTarget.matches(":focus-visible")) return;
+          setActive((current) => {
+            if (current) return current;
+            for (let column = 0; column < columns; column++) {
+              for (let row = 0; row < rows; row++) {
+                if (valueAt(row, column) !== void 0) return { row, column };
+              }
+            }
+            return null;
+          });
+        },
+        onBlur: () => setActive(null),
+        onPointerMove: (event) => setHover(local(event)),
+        onPointerLeave: () => setHover(null),
+        onPointerUp: (event) => {
+          const cell = local(event);
+          if (cell && onCellClick) {
+            onCellClick({ ...cell, value: valueAt(cell.row, cell.column) ?? null });
+          }
+        },
+        className: cn(
+          "absolute inset-0 rounded-xs outline-none focus-visible:outline-2 focus-visible:outline-accent-ink focus-visible:outline-offset-4",
+          hover && onCellClick ? "cursor-pointer" : "cursor-default"
+        )
+      }
+    ),
+    tooltip && shown ? /* @__PURE__ */ jsx(
+      ChartTooltip,
+      {
+        x: cellCenter(shown.row, shown.column).x,
+        y: cellCenter(shown.row, shown.column).y,
+        containerWidth: width,
+        title: cellTitle(shown.row, shown.column),
+        rows: [
+          {
+            id: "value",
+            name: valueName ?? rowLabels[shown.row] ?? "",
+            value: shownValue == null ? labels.noData : format(shownValue),
+            color: shownColor
+          }
+        ]
+      }
+    ) : null
+  ] });
+}
+function HeatmapLegend({
+  kind,
+  domain,
+  center = 0,
+  colors,
+  ranges,
+  format
+}) {
+  if (ranges && ranges.length > 0) {
+    return /* @__PURE__ */ jsx("ul", { className: "@md/chart:-order-1 m-0 flex list-none flex-wrap @md/chart:justify-end gap-x-3 gap-y-1 p-0 text-[12px]", children: ranges.map((range, index) => /* @__PURE__ */ jsxs(
+      "li",
+      {
+        className: "inline-flex min-w-0 items-center gap-1.5 font-semibold text-ink-2",
+        children: [
+          /* @__PURE__ */ jsx(
+            "span",
+            {
+              "aria-hidden": "true",
+              className: "size-2.5 shrink-0 rounded-[3px]",
+              style: {
+                background: rangeColor(range, index, ranges.length).color
+              }
+            }
+          ),
+          /* @__PURE__ */ jsx("span", { className: "truncate", children: range.label })
+        ]
+      },
+      range.label
+    )) });
+  }
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      "aria-hidden": "true",
+      className: "@md/chart:-order-1 flex w-full max-w-[260px] @md/chart:self-end flex-col gap-1 text-[11px] text-ink-3 tabular-nums",
+      children: [
+        /* @__PURE__ */ jsx(
+          "span",
+          {
+            className: "h-2 w-full rounded-pill",
+            style: { background: scaleGradient(kind, colors) }
+          }
+        ),
+        /* @__PURE__ */ jsxs("span", { className: "flex justify-between font-semibold", children: [
+          /* @__PURE__ */ jsx("span", { children: format(domain[0]) }),
+          kind === "diverging" ? /* @__PURE__ */ jsx("span", { children: format(center) }) : null,
+          /* @__PURE__ */ jsx("span", { children: format(domain[1]) })
+        ] })
+      ]
+    }
+  );
+}
+export {
+  DEFAULT_HEATMAP_LABELS,
+  HEATMAP_TOP,
+  HeatmapGrid,
+  HeatmapLegend,
+  resolveHeatmapLabels,
+  rowGutter
+};

package/dist/charts/heatmap-chart/heatmap-scale.d.ts

@@ -0,0 +1,19 @@
+import { type ColorRange, type ColorStop, type ScaleColors } from "../core/color-scale.js";
+export interface HeatmapScaleOptions {
+    /** "sequential": empty to brand; "diverging": low hue, neutral at `center`, brand. */
+    scale?: "sequential" | "diverging";
+    /** Fixed [min, max]; the data extent by default. */
+    domain?: readonly [number, number];
+    /** Neutral value of a diverging scale, 0 by default. */
+    center?: number;
+    colors?: ScaleColors;
+    /** Stepped coloring: each value takes the color of the range that contains it. */
+    ranges?: readonly ColorRange[];
+}
+export interface HeatmapScale {
+    domain: readonly [number, number];
+    /** `null` when the value falls outside every range. */
+    color: (value: number) => ColorStop | null;
+}
+/** Builds the color function of a heatmap from its options and every finite value. */
+export declare function heatmapScale(values: readonly number[], { scale, domain, center, colors, ranges }: HeatmapScaleOptions): HeatmapScale;

package/dist/charts/heatmap-chart/heatmap-scale.js

@@ -0,0 +1,38 @@
+import {
+  divergingColor,
+  rangeColor,
+  rangeIndex,
+  sequentialColor
+} from "../core/color-scale.js";
+function heatmapScale(values, { scale = "sequential", domain, center = 0, colors, ranges }) {
+  let min = Number.POSITIVE_INFINITY;
+  let max = Number.NEGATIVE_INFINITY;
+  for (const value of values) {
+    if (value < min) min = value;
+    if (value > max) max = value;
+  }
+  if (!Number.isFinite(min)) {
+    min = 0;
+    max = 1;
+  }
+  const extent = domain ?? [
+    scale === "sequential" ? Math.min(0, min) : min,
+    max
+  ];
+  if (ranges && ranges.length > 0) {
+    return {
+      domain: extent,
+      color: (value) => {
+        const index = rangeIndex(value, ranges);
+        return index < 0 ? null : rangeColor(ranges[index], index, ranges.length);
+      }
+    };
+  }
+  return {
+    domain: extent,
+    color: (value) => scale === "diverging" ? divergingColor(value, extent, center, colors) : sequentialColor(value, extent, colors)
+  };
+}
+export {
+  heatmapScale
+};

package/dist/charts/heatmap-chart/hex-layout.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Honeycomb geometry for heatmaps: pointy-top hexagons in an "odd-r" offset
+ * grid (odd rows are shifted half a cell to the right). Pure.
+ */
+export interface HexLayoutInput {
+    rows: number;
+    columns: number;
+    /** Area the honeycomb must fit, in pixels. */
+    width: number;
+    height: number;
+}
+export interface HexLayout {
+    /** Circumradius of one hexagon. */
+    radius: number;
+    /** Horizontal distance between two neighbours of a row. */
+    stepX: number;
+    /** Vertical distance between two rows. */
+    stepY: number;
+    /** Top-left of the honeycomb inside the area (it is centred). */
+    originX: number;
+    originY: number;
+    /** Centre of a cell. */
+    center(row: number, column: number): {
+        x: number;
+        y: number;
+    };
+    /** Cell under a point (relative to the area), or null outside the honeycomb. */
+    cellAt(x: number, y: number): {
+        row: number;
+        column: number;
+    } | null;
+}
+export declare function hexLayout({ rows, columns, width, height }: HexLayoutInput): HexLayout;
+/** Closed path of a pointy-top hexagon centred at `(cx, cy)`. */
+export declare function hexPath(cx: number, cy: number, radius: number): string;

package/dist/charts/heatmap-chart/hex-layout.js

@@ -0,0 +1,58 @@
+const SQRT3 = Math.sqrt(3);
+function hexLayout({ rows, columns, width, height }) {
+  const fitX = columns > 0 ? width / (SQRT3 * (columns + 0.5)) : 0;
+  const fitY = rows > 0 ? height / (1.5 * (rows - 1) + 2) : 0;
+  const radius = Math.max(0, Math.min(fitX, fitY));
+  const stepX = SQRT3 * radius;
+  const stepY = 1.5 * radius;
+  const usedWidth = stepX * (columns + 0.5);
+  const usedHeight = stepY * Math.max(0, rows - 1) + 2 * radius;
+  const originX = Math.max(0, (width - usedWidth) / 2);
+  const originY = Math.max(0, (height - usedHeight) / 2);
+  const center = (row, column) => ({
+    x: originX + stepX * (column + 0.5 + (row & 1) * 0.5),
+    y: originY + radius + stepY * row
+  });
+  return {
+    radius,
+    stepX,
+    stepY,
+    originX,
+    originY,
+    center,
+    cellAt(x, y) {
+      if (radius <= 0) return null;
+      const first = center(0, 0);
+      const px = x - first.x;
+      const py = y - first.y;
+      const q = (SQRT3 / 3 * px - py / 3) / radius;
+      const r = 2 / 3 * py / radius;
+      let cx = Math.round(q);
+      let cz = Math.round(r);
+      const cy = Math.round(-q - r);
+      const dx = Math.abs(cx - q);
+      const dy = Math.abs(cy - (-q - r));
+      const dz = Math.abs(cz - r);
+      if (dx > dy && dx > dz) cx = -cy - cz;
+      else if (dy <= dz) cz = -cx - cy;
+      const row = cz;
+      const column = cx + (row - (row & 1)) / 2;
+      if (row < 0 || row >= rows || column < 0 || column >= columns) return null;
+      return { row, column };
+    }
+  };
+}
+function hexPath(cx, cy, radius) {
+  const points = [];
+  for (let i = 0; i < 6; i += 1) {
+    const angle = Math.PI / 180 * (60 * i - 90);
+    points.push(
+      `${Math.round((cx + radius * Math.cos(angle)) * 100) / 100},${Math.round((cy + radius * Math.sin(angle)) * 100) / 100}`
+    );
+  }
+  return `M${points.join("L")}Z`;
+}
+export {
+  hexLayout,
+  hexPath
+};

package/dist/charts/heatmap-chart/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./calendar-heatmap.js";
+export * from "./calendar-layout.js";
+export * from "./datetime-columns.js";
+export * from "./drilldown-heatmap.js";
+export * from "./heatmap-chart.js";
+export type { HeatmapCellInfo, HeatmapLabels } from "./heatmap-grid.js";
+export { DEFAULT_HEATMAP_LABELS, resolveHeatmapLabels } from "./heatmap-grid.js";
+export * from "./heatmap-scale.js";
+export * from "./hex-layout.js";

package/dist/charts/heatmap-chart/index.js

@@ -0,0 +1,12 @@
+export * from "./calendar-heatmap.js";
+export * from "./calendar-layout.js";
+export * from "./datetime-columns.js";
+export * from "./drilldown-heatmap.js";
+export * from "./heatmap-chart.js";
+import { DEFAULT_HEATMAP_LABELS, resolveHeatmapLabels } from "./heatmap-grid.js";
+export * from "./heatmap-scale.js";
+export * from "./hex-layout.js";
+export {
+  DEFAULT_HEATMAP_LABELS,
+  resolveHeatmapLabels
+};