basalt-ui 1.41.0 → 2.0.1

package/dist/charts/series.js

@@ -1,84 +0,0 @@
-import {
-  curveLinear,
-  curveMonotoneX,
-  curveStep,
-  curveStepAfter,
-  curveStepBefore
-} from "@visx/curve";
-const LINE_OVERLAY_STROKE_WIDTH = 1.9;
-const CURVES = {
-  monotone: curveMonotoneX,
-  linear: curveLinear,
-  step: curveStep,
-  stepAfter: curveStepAfter,
-  stepBefore: curveStepBefore
-};
-function curveFor(curve) {
-  return curve === void 0 ? curveMonotoneX : CURVES[curve];
-}
-const shapeFor = (mark) => mark === "line" ? "line" : "bar";
-function legendEntryFor(s) {
-  return {
-    key: s.key,
-    label: s.label,
-    color: s.color,
-    shape: shapeFor(s.mark),
-    dashed: s.dash === "dashed",
-    ...s.strokeWidth !== void 0 && { strokeWidth: s.strokeWidth },
-    ...s.fillOpacity !== void 0 && { fillOpacity: s.fillOpacity },
-    ...s.strokeOpacity !== void 0 && { strokeOpacity: s.strokeOpacity },
-    ...s.role !== void 0 && { role: s.role },
-    ...s.note !== void 0 && { note: s.note }
-  };
-}
-function deriveLegend(series) {
-  const entries = [];
-  const byKey = /* @__PURE__ */ new Map();
-  for (const s of series) {
-    if (s.legend === false) continue;
-    const entry = legendEntryFor(s);
-    entries.push(entry);
-    byKey.set(s.key, entry);
-  }
-  for (const s of series) {
-    if (s.legend !== false || s.parent === void 0) continue;
-    const parent = byKey.get(s.parent);
-    if (parent === void 0) continue;
-    parent.children ??= [];
-    parent.children.push(legendEntryFor(s));
-  }
-  return entries;
-}
-function deriveTooltipRows(series, datum, fallbackFormat) {
-  const rows = [];
-  for (const s of series) {
-    if (s.tooltip === false) continue;
-    const value = s.getValue(datum);
-    if (value === null) continue;
-    const format = s.formatValue ?? fallbackFormat;
-    rows.push({
-      key: s.key,
-      label: s.label,
-      color: s.color,
-      value: format(value, datum),
-      shape: shapeFor(s.mark),
-      dashed: s.dash === "dashed",
-      ...s.strokeWidth !== void 0 && { strokeWidth: s.strokeWidth }
-    });
-  }
-  return rows;
-}
-function toPlotPoint(v) {
-  return v === null || v === void 0 || Number.isNaN(v) ? null : v;
-}
-function definedOn(scale) {
-  return (d) => d.__y !== null && Number.isFinite(scale(d.__y));
-}
-export {
-  LINE_OVERLAY_STROKE_WIDTH,
-  curveFor,
-  definedOn,
-  deriveLegend,
-  deriveTooltipRows,
-  toPlotPoint
-};

package/dist/charts/sparklines/BarSparkline.d.ts

@@ -1,37 +0,0 @@
-import type { BasaltProps } from '../../common/props.js';
-export type BarSparklineProps = BasaltProps & {
-    data: number[];
-    width: number;
-    height: number;
-    color?: string;
-    /**
-     * Gap between two bars, in px. `1` is the shipped look; `2` at ~10 bars reads as a discrete series
-     * rather than a histogram, which is the KPI-card treatment.
-     *
-     * @default 1
-     */
-    barGap?: number;
-    /**
-     * Bar corner radius, in px. `0` is the shipped look.
-     *
-     * @default 0
-     */
-    barRadius?: number;
-    /**
-     * Paints the LAST bar in `emphasisColor` at full opacity — "this is where the series ends", the
-     * one reading a trend beside a KPI value is actually for. Off by default: a chart that means
-     * something by its final point must say so.
-     *
-     * @default false
-     */
-    emphasizeLast?: boolean;
-    /** The emphasised bar's fill. @default `VX.accent` */
-    emphasisColor?: string;
-    /** Accessible text alternative, applied as `aria-label` (+ `role="img"`) on the `<svg>`. */
-    ariaLabel?: string;
-};
-/** Quiet inline bar trend — defaults to `VX.faint`, matching the sparkline family's restrained
- * identity (docs/DESIGN-SPEC.md §5). Every geometry option below defaults to the shipped look, so
- * an existing call site renders byte-identically. */
-export declare function BarSparkline({ data, width, height, color, barGap, barRadius, emphasizeLast, emphasisColor, ariaLabel, className, style, }: BarSparklineProps): import("react").JSX.Element;
-//# sourceMappingURL=BarSparkline.d.ts.map

package/dist/charts/sparklines/BarSparkline.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"BarSparkline.d.ts","sourceRoot":"","sources":["../../../src/charts/sparklines/BarSparkline.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;AAGrD,MAAM,MAAM,iBAAiB,GAAG,WAAW,GAAG;IAC5C,IAAI,EAAE,MAAM,EAAE,CAAA;IACd,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,CAAC,EAAE,MAAM,CAAA;IACd;;;;;OAKG;IACH,MAAM,CAAC,EAAE,MAAM,CAAA;IACf;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB;;;;;;OAMG;IACH,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,sDAAsD;IACtD,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,4FAA4F;IAC5F,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB,CAAA;AAED;;qDAEqD;AACrD,wBAAgB,YAAY,CAAC,EAC3B,IAAI,EACJ,KAAK,EACL,MAAM,EACN,KAAK,EACL,MAAU,EACV,SAAa,EACb,aAAqB,EACrB,aAAa,EACb,SAAS,EACT,SAAS,EACT,KAAK,GACN,EAAE,iBAAiB,+BAyCnB"}

package/dist/charts/sparklines/BarSparkline.js

@@ -1,53 +0,0 @@
-import { jsx } from "react/jsx-runtime";
-import { scaleLinear } from "@visx/scale";
-import { useMemo } from "react";
-import { VX } from "../../tokens/index.js";
-function BarSparkline({
-  data,
-  width,
-  height,
-  color,
-  barGap = 1,
-  barRadius = 0,
-  emphasizeLast = false,
-  emphasisColor,
-  ariaLabel,
-  className,
-  style
-}) {
-  const fillColor = color ?? VX.faint;
-  const lastColor = emphasisColor ?? VX.accent;
-  const a11yProps = ariaLabel !== void 0 ? { role: "img", "aria-label": ariaLabel } : {};
-  const yScale = useMemo(() => {
-    const max = Math.max(...data.filter((v) => isFinite(v)), 1);
-    return scaleLinear({ domain: [0, max], range: [0, height] });
-  }, [data, height]);
-  const rootProps = {
-    ...className !== void 0 && { className },
-    ...style !== void 0 && { style }
-  };
-  if (!data.length) return /* @__PURE__ */ jsx("svg", { width, height, ...rootProps, ...a11yProps });
-  const step = width / data.length;
-  const barWidth = Math.max(step - barGap, 1);
-  const lastIndex = data.length - 1;
-  return /* @__PURE__ */ jsx("svg", { width, height, ...rootProps, ...a11yProps, children: data.map((v, i) => {
-    const bh = Math.max(yScale(Math.max(v, 0)), 0);
-    const isLast = emphasizeLast && i === lastIndex;
-    return /* @__PURE__ */ jsx(
-      "rect",
-      {
-        x: i * step,
-        y: height - bh,
-        width: barWidth,
-        height: bh,
-        ...barRadius > 0 && { rx: barRadius },
-        fill: isLast ? lastColor : fillColor,
-        fillOpacity: isLast ? 1 : 0.75
-      },
-      i
-    );
-  }) });
-}
-export {
-  BarSparkline
-};

package/dist/charts/sparklines/LineSparkline.d.ts

@@ -1,15 +0,0 @@
-import type { BasaltProps } from '../../common/props.js';
-export type LineSparklineProps = BasaltProps & {
-    data: number[];
-    width: number;
-    height: number;
-    color?: string;
-    /** Accessible text alternative, applied as `aria-label` (+ `role="img"`) on the `<svg>`. */
-    ariaLabel?: string;
-};
-/**
- * Quiet single-hue trend line (docs/DESIGN-SPEC.md §5: "single 1.6px faint line, no fill, no
- * axes, no dots"). Sparklines default to `VX.faint`, not the bolder `VX.line` used by full charts.
- */
-export declare function LineSparkline({ data, width, height, color, ariaLabel, className, style, }: LineSparklineProps): import("react").JSX.Element;
-//# sourceMappingURL=LineSparkline.d.ts.map

package/dist/charts/sparklines/LineSparkline.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"LineSparkline.d.ts","sourceRoot":"","sources":["../../../src/charts/sparklines/LineSparkline.tsx"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;AAGrD,MAAM,MAAM,kBAAkB,GAAG,WAAW,GAAG;IAC7C,IAAI,EAAE,MAAM,EAAE,CAAA;IACd,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,4FAA4F;IAC5F,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB,CAAA;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,EAC5B,IAAI,EACJ,KAAK,EACL,MAAM,EACN,KAAK,EACL,SAAS,EACT,SAAS,EACT,KAAK,GACN,EAAE,kBAAkB,+BAyCpB"}

package/dist/charts/sparklines/LineSparkline.js

@@ -1,51 +0,0 @@
-import { jsx } from "react/jsx-runtime";
-import { curveMonotoneX } from "@visx/curve";
-import { Group } from "@visx/group";
-import { scaleLinear } from "@visx/scale";
-import { LinePath } from "@visx/shape";
-import { useMemo } from "react";
-import { VX } from "../../tokens/index.js";
-function LineSparkline({
-  data,
-  width,
-  height,
-  color,
-  ariaLabel,
-  className,
-  style
-}) {
-  const strokeColor = color ?? VX.faint;
-  const a11yProps = ariaLabel !== void 0 ? { role: "img", "aria-label": ariaLabel } : {};
-  const xScale = useMemo(
-    () => scaleLinear({ domain: [0, Math.max(data.length - 1, 1)], range: [0, width] }),
-    [data.length, width]
-  );
-  const yScale = useMemo(() => {
-    const vals = data.filter((v) => isFinite(v));
-    if (!vals.length) return scaleLinear({ domain: [0, 1], range: [height, 0] });
-    const min = Math.min(...vals);
-    const max = Math.max(...vals);
-    const pad = (max - min) * 0.1 || 1;
-    return scaleLinear({ domain: [min - pad, max + pad], range: [height, 0] });
-  }, [data, height]);
-  const rootProps = {
-    ...className !== void 0 && { className },
-    ...style !== void 0 && { style }
-  };
-  if (data.length < 2) return /* @__PURE__ */ jsx("svg", { width, height, ...rootProps, ...a11yProps });
-  const indexed = data.map((v, i) => ({ v, i }));
-  return /* @__PURE__ */ jsx("svg", { width, height, ...rootProps, ...a11yProps, children: /* @__PURE__ */ jsx(Group, { children: /* @__PURE__ */ jsx(
-    LinePath,
-    {
-      data: indexed,
-      x: (d) => xScale(d.i),
-      y: (d) => yScale(d.v),
-      stroke: strokeColor,
-      strokeWidth: 1.6,
-      curve: curveMonotoneX
-    }
-  ) }) });
-}
-export {
-  LineSparkline
-};

package/dist/charts/sparklines/index.d.ts

@@ -1,3 +0,0 @@
-export { LineSparkline, type LineSparklineProps } from './LineSparkline.js';
-export { BarSparkline, type BarSparklineProps } from './BarSparkline.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/charts/sparklines/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/charts/sparklines/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,KAAK,kBAAkB,EAAE,MAAM,iBAAiB,CAAA;AACxE,OAAO,EAAE,YAAY,EAAE,KAAK,iBAAiB,EAAE,MAAM,gBAAgB,CAAA"}

package/dist/charts/sparklines/index.js

@@ -1,6 +0,0 @@
-import { LineSparkline } from "./LineSparkline.js";
-import { BarSparkline } from "./BarSparkline.js";
-export {
-  BarSparkline,
-  LineSparkline
-};

package/dist/charts/utils/domain.d.ts

@@ -1,35 +0,0 @@
-/**
- * Auto y-domain lower-bound padding — shared by every `yAutoMinCeil`/`autoMinCeil` idiom across
- * the kinds (MultiLine, ZonedLine, Bars' left/right axes).
- *
- * The lower bound must always pad AWAY from the data (`lower <= candidate`), never toward it —
- * a naive `candidate * pad` clips data whenever `candidate` is positive (padding a positive floor
- * UP moves it toward, and past, the data minimum). This is exactly the `yAutoMinCeil={Infinity}`
- * ("no forced zero baseline") idiom: `candidate` becomes the raw data minimum, which is usually
- * positive (e.g. a body-weight series bottoming out at 78), and the old multiplicative pad shoved
- * the axis floor above it.
- *
- * `candidate` is the caller's `Math.min(dataMin, ceil)` — the ceiling has already been applied.
- *  - `candidate === 0` (the common default-zero-baseline case: positive-only data with the
- *    default `ceil = 0`) stays exactly 0 — never pushed negative.
- *  - `candidate > 0` divides by `pad`, moving the floor DOWN toward (and below) the candidate.
- *  - `candidate < 0` multiplies by `pad`, moving the floor further DOWN (more negative) — the
- *    pre-existing, still-correct behavior for genuinely negative-swinging metrics.
- */
-export declare function padAutoLower(candidate: number, pad: number): number;
-/**
- * Auto y-domain upper-bound padding — the exact mirror of {@link padAutoLower}, sharing its
- * sign-safety: pad AWAY from zero (`upper >= candidate`), never toward it. `candidate` is the
- * caller's `Math.max(dataMax, floor)` — the `autoMaxFloor` clamp has already been applied, so
- * padding runs AFTER the floor, not before it. Applying the floor post-pad (the pre-existing bug)
- * lands a floored axis top exactly on the floor value with zero headroom — a target line pinned to
- * that floor then sits glued to the plot edge instead of getting the same breathing room every
- * other bound gets.
- *
- *  - `candidate === 0` stays exactly 0 — never pushed positive.
- *  - `candidate > 0` multiplies by `pad`, moving the ceiling further UP (away from zero).
- *  - `candidate < 0` divides by `pad`, moving the ceiling UP toward (and past) zero — the mirror of
- *    `padAutoLower`'s `candidate > 0` branch.
- */
-export declare function padAutoUpper(candidate: number, pad: number): number;
-//# sourceMappingURL=domain.d.ts.map

package/dist/charts/utils/domain.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"domain.d.ts","sourceRoot":"","sources":["../../../src/charts/utils/domain.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAGnE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAGnE"}

package/dist/charts/utils/domain.js

@@ -1,12 +0,0 @@
-function padAutoLower(candidate, pad) {
-  if (candidate === 0) return 0;
-  return candidate > 0 ? candidate / pad : candidate * pad;
-}
-function padAutoUpper(candidate, pad) {
-  if (candidate === 0) return 0;
-  return candidate > 0 ? candidate * pad : candidate / pad;
-}
-export {
-  padAutoLower,
-  padAutoUpper
-};

package/dist/charts/utils/format.d.ts

@@ -1,8 +0,0 @@
-/**
- * Re-export shim. The implementation moved to `basalt-ui/format` (C5 consolidation, so
- * `money`/`percent`/`duration`/`clock`/… and the chart formatters share one implementation
- * instead of two). This file stays so every existing relative import inside `src/charts/**`
- * (`../utils/format`) keeps resolving unchanged.
- */
-export { fmtAxisDate, fmtTooltipDate, fmtCompact, type FmtCompactOptions, fmtPercent, type FmtPercentOptions, fmtCurrency, type FmtCurrencyOptions, fmtInt, formatters, NON_FINITE, } from '../../format/index.js';
-//# sourceMappingURL=format.d.ts.map

package/dist/charts/utils/format.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../../../src/charts/utils/format.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EACL,WAAW,EACX,cAAc,EACd,UAAU,EACV,KAAK,iBAAiB,EACtB,UAAU,EACV,KAAK,iBAAiB,EACtB,WAAW,EACX,KAAK,kBAAkB,EACvB,MAAM,EACN,UAAU,EACV,UAAU,GACX,MAAM,cAAc,CAAA"}

package/dist/charts/utils/format.js

@@ -1,20 +0,0 @@
-import {
-  fmtAxisDate,
-  fmtTooltipDate,
-  fmtCompact,
-  fmtPercent,
-  fmtCurrency,
-  fmtInt,
-  formatters,
-  NON_FINITE
-} from "../../format/index.js";
-export {
-  NON_FINITE,
-  fmtAxisDate,
-  fmtCompact,
-  fmtCurrency,
-  fmtInt,
-  fmtPercent,
-  fmtTooltipDate,
-  formatters
-};

package/dist/charts/utils/measure-text.d.ts

@@ -1,25 +0,0 @@
-/**
- * Text measurement for chart layout — the input to {@link autoMargin}.
- *
- * A static margin token cannot know how wide a tick label is, which is why charts used to have to be
- * hand-nudged whenever a label grew (`docs/CHARTS-SPEC.md` §1). This measures the strings that
- * will actually be painted, via an OFFSCREEN canvas 2D context: no element is attached, so there
- * is no layout thrash and no reflow — unlike an SVG `getBBox()` probe.
- *
- * Mantine-free and dependency-free by construction (`charts/**` boundary).
- */
-/**
- * The resolved value of `--basalt-font-mono` — canvas needs a concrete family list, it cannot
- * resolve a CSS custom property. Read once from the document element.
- */
-export declare function monoFontFamily(): string;
-/**
- * Width in px of `text` at `fontPx` in the chart tick font. Memoized per `font|text` — a chart
- * re-measures the same ~10 tick labels on every resize, and the cache turns that into a Map hit.
- */
-export declare function measureText(text: string, fontPx: number, fontFamily?: string): number;
-/** Widest of `texts` at `fontPx`. Returns 0 for an empty list. */
-export declare function maxTextWidth(texts: readonly string[], fontPx: number, fontFamily?: string): number;
-/** Test seam — drops the memo table (and the resolved family) so a test can change fonts. */
-export declare function resetTextMetrics(): void;
-//# sourceMappingURL=measure-text.d.ts.map

package/dist/charts/utils/measure-text.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"measure-text.d.ts","sourceRoot":"","sources":["../../../src/charts/utils/measure-text.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAuCH;;;GAGG;AACH,wBAAgB,cAAc,IAAI,MAAM,CAWvC;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,CAkBrF;AAED,kEAAkE;AAClE,wBAAgB,YAAY,CAC1B,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,MAAM,EAAE,MAAM,EACd,UAAU,CAAC,EAAE,MAAM,GAClB,MAAM,CAOR;AAED,6FAA6F;AAC7F,wBAAgB,gBAAgB,IAAI,IAAI,CAIvC"}

package/dist/charts/utils/measure-text.js

@@ -1,64 +0,0 @@
-const FALLBACK_CHAR_RATIO = 0.6;
-const FALLBACK_MONO = "ui-monospace, SFMono-Regular, Menlo, monospace";
-const CACHE_LIMIT = 2e3;
-const cache = /* @__PURE__ */ new Map();
-let ctx;
-let monoFamily;
-function canvasContext() {
-  if (ctx !== void 0) return ctx;
-  if (typeof document === "undefined") {
-    ctx = null;
-    return ctx;
-  }
-  ctx = document.createElement("canvas").getContext("2d");
-  document.fonts?.ready?.then?.(() => cache.clear()).catch(() => {
-  });
-  return ctx;
-}
-function monoFontFamily() {
-  if (monoFamily !== void 0) return monoFamily;
-  if (typeof document === "undefined" || typeof getComputedStyle !== "function") {
-    monoFamily = FALLBACK_MONO;
-    return monoFamily;
-  }
-  const value = getComputedStyle(document.documentElement).getPropertyValue("--basalt-font-mono").trim();
-  monoFamily = value.length > 0 ? value : FALLBACK_MONO;
-  return monoFamily;
-}
-function measureText(text, fontPx, fontFamily) {
-  const family = fontFamily ?? monoFontFamily();
-  const font = `${fontPx}px ${family}`;
-  const key = `${font}|${text}`;
-  const hit = cache.get(key);
-  if (hit !== void 0) return hit;
-  const c = canvasContext();
-  let width;
-  if (c === null) {
-    width = text.length * fontPx * FALLBACK_CHAR_RATIO;
-  } else {
-    c.font = font;
-    width = c.measureText(text).width;
-  }
-  if (cache.size >= CACHE_LIMIT) cache.clear();
-  cache.set(key, width);
-  return width;
-}
-function maxTextWidth(texts, fontPx, fontFamily) {
-  let max = 0;
-  for (const text of texts) {
-    const width = measureText(text, fontPx, fontFamily);
-    if (width > max) max = width;
-  }
-  return max;
-}
-function resetTextMetrics() {
-  cache.clear();
-  ctx = void 0;
-  monoFamily = void 0;
-}
-export {
-  maxTextWidth,
-  measureText,
-  monoFontFamily,
-  resetTextMetrics
-};

package/dist/charts/utils/ticks.d.ts

@@ -1,103 +0,0 @@
-import type { ChartTier } from '../primitives/chart-frame-layout.js';
-/**
- * The horizontal room one x tick label needs: the widest string in `labels`, plus breathing space
- * to its neighbour. Feeds `smartTicks`, which otherwise thinned the axis by a constant that knew
- * nothing about what was actually painted (`docs/CHARTS-SPEC.md` §1). Shared by `CartesianChart`,
- * `useBandPlot` and `DualPanel` — the three call sites that used to reimplement this formula.
- *
- * `fontPx` defaults to `VX.axisFont`; a phone-tier chart passes its own smaller tick font
- * (`chartMetrics().axisFont`) so the spacing is derived from the size actually painted.
- */
-export declare function xLabelPxFor(labels: string[], fontPx?: number): number;
-/**
- * The horizontal room one 45°-rotated x label takes: its projected box (`cos 45°` of the width plus
- * one line box) plus the gap. A tilted label still competes with its neighbour for this much, so
- * thinning by the bare `VX.minPxPerTick` floor let two of them touch as soon as the plot widened.
- */
-export declare function rotatedXLabelPx(labels: string[], fontPx?: number): number;
-/**
- * Pick evenly-spaced tick values that fit the available width.
- *
- * `labelPx` is the width one formatted label actually needs (measured, plus the gap it wants from
- * its neighbour) and REPLACES the `VX.minPxPerTick` constant whenever it is supplied, in either
- * direction — a wide label needs more room than the constant assumed (a `formatX` returning
- * `Mar 08 14:00` used to overlap at every width, the one side of the chart that did not follow
- * §1's "measure what you paint" law), and a narrow one (single-digit band labels) can pack in
- * MORE ticks than the constant would allow, which the floor used to suppress (R2C-11). Omit it and
- * the constant is what governs, same as before.
- *
- * The final key is still appended when the step misses the last index — a thinned axis would
- * otherwise paint no label at the right edge at all — but it no longer prints ON TOP of its
- * neighbour. An appended tick lands a PARTIAL step from the last one on the grid, so at any tick
- * count wide enough labels overlap there; measured at `/charts-stress` block (f1), `Mar 13 14:00`
- * and `Mar 14 14:00` printed over each other at 1440px. When that gap is narrower than one label,
- * the grid tick before it is dropped instead.
- *
- * `anchorTerminals` (default false) mirrors the SAME flag `autoMargin`/`Axes.tsx` take: when the
- * axis anchors index 0 and the last index at their TEXT edge rather than their centre
- * (`terminalAnchor`), each reaches a FULL label's width toward its neighbour instead of half, so
- * the plain per-tick pitch above (sized for two centred labels) isn't enough at either boundary —
- * `Bars` with 30 daily "Jan DD HH:MM" keys overlapped there at phone width even though the interior
- * pitch was fine (R2C-6). The SAME rule then applies, symmetrically, to the tick right after
- * index 0. 1.5× is a deliberately generous (cheap, simple) stand-in for "one label plus half a
- * label" rather than measuring the split precisely; it's skipped when `labelPx` is only the bare
- * `VX.minPxPerTick` floor, which has no relationship to how wide a label actually is. Index 0
- * always survives (never the one dropped here) and `last` is always (re-)added below, so dropping
- * any OTHER index never breaks the "at least 2 ticks" floor.
- */
-export declare function smartTicks(dates: string[], xMax: number, labelPx?: number, anchorTerminals?: boolean): string[];
-/**
- * Which of a BAND axis's category labels may be painted so that no two neighbours overlap — the
- * same measured law {@link smartTicks} applies to a point axis, for a chart that lays its labels
- * out itself instead of through the `Axis*` primitives.
- *
- * `Heatmap` was the one kind rendering labels as plain `<text>`, and therefore the one kind exempt
- * from §1's measured-margin law: it printed all 12 columns at 390px, ten of them overlapping. Here
- * `bandPx` is the pitch between two neighbouring labels (a cell's width for columns, its height for
- * rows) and `labelPx` the room one label needs ({@link xLabelPxFor} for a horizontal run, the line
- * box for a vertical one); a label is kept every `ceil(labelPx / bandPx)` bands, so the gap between
- * two painted labels is never narrower than one label.
- *
- * The first and last band always keep theirs — they are the two a reader orients from — and when
- * the last one lands a partial step from the grid, the grid label before it is dropped rather than
- * printed underneath, exactly as `smartTicks` does with its appended final tick.
- */
-export declare function thinLabels(labels: readonly string[], bandPx: number, labelPx: number): Set<number>;
-/** Variant of smartTicks that targets an exact tick count rather than deriving from width. */
-export declare function smartTicksEvery(dates: string[], count: number): string[];
-/**
- * The phone tier's default x-label rotation: 45° when the labels are so wide that fewer than
- * {@link MIN_HORIZONTAL_TICKS} of them fit side by side, else none.
- *
- * `xLabelRotate` already existed as the answer to a `formatX` too wide to repeat horizontally
- * (`docs/CHARTS-SPEC.md` §1) — it just had to be reached for by hand, per chart, by someone who
- * had already seen it collide on a phone. This makes it the DEFAULT at phone width and only there:
- * rotating trades horizontal crowding for bottom-gutter depth, which is the cheap axis on a narrow
- * viewport and the expensive one on a wide screen that had room all along. Opt out with an
- * explicit `xLabelRotate: 0`.
- *
- * Deliberately measured against the same `labelPx` `smartTicks` thins by, so the decision and the
- * thinning cannot disagree about how wide a label is.
- *
- * **Wanting to rotate is not the same as rotating fitting.** A rotated label reaches into the LEFT
- * gutter (`rotatedLabelExtents`), so rotating BUYS bottom-gutter depth and SPENDS plot width — and
- * at a narrow enough box it spends more than it buys. `/charts-stress` block (f1) is the case:
- * three clean horizontal labels at 390, and at 320 an auto-rotation that reached off the left edge
- * and bought not one extra label for it. So the trade is CHECKED, not assumed. Pass `rotatedXMax`
- * (the width left once `autoMargin({ rotate: 45 })` has taken its deeper left gutter) and the
- * rotation is taken only when the rotated axis paints MORE labels than the flat one at its
- * projected pitch (`labelPx · cos 45°`), and at least two of them. Otherwise the axis stays flat
- * and `smartTicks` thins further — two readable horizontal labels beat two tilted ones in a
- * narrower plot. Omit `rotatedXMax` and the check is skipped.
- */
-export declare function autoXLabelRotate(input: {
-    tier: ChartTier;
-    /** Plot width available to the x axis, from the UNROTATED margin. */
-    xMax: number;
-    /** What one x label needs horizontally ({@link xLabelPxFor}). */
-    labelPx: number;
-    /** Plot width that would REMAIN once the rotated margin takes its deeper left gutter
-     * (`autoMargin({ rotate: 45 })`). Omit to skip the fit check. */
-    rotatedXMax?: number;
-}): 0 | 45;
-//# sourceMappingURL=ticks.d.ts.map

package/dist/charts/utils/ticks.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ticks.d.ts","sourceRoot":"","sources":["../../../src/charts/utils/ticks.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAA;AAMjE;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,MAAM,GAAE,MAAoB,GAAG,MAAM,CAElF;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,MAAM,GAAE,MAAoB,GAAG,MAAM,CAItF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,UAAU,CACxB,KAAK,EAAE,MAAM,EAAE,EACf,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,MAAM,EAChB,eAAe,UAAQ,GACtB,MAAM,EAAE,CAoEV;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,UAAU,CACxB,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,GACd,GAAG,CAAC,MAAM,CAAC,CAkBb;AAED,8FAA8F;AAC9F,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAKxE;AAaD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE;IACtC,IAAI,EAAE,SAAS,CAAA;IACf,qEAAqE;IACrE,IAAI,EAAE,MAAM,CAAA;IACZ,iEAAiE;IACjE,OAAO,EAAE,MAAM,CAAA;IACf;qEACiE;IACjE,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB,GAAG,CAAC,GAAG,EAAE,CAST"}

package/dist/charts/utils/ticks.js

@@ -1,92 +0,0 @@
-import { VX } from "../../tokens/index.js";
-import { maxTextWidth } from "./measure-text.js";
-const X_TICK_LABEL_GAP = 8;
-function xLabelPxFor(labels, fontPx = VX.axisFont) {
-  return maxTextWidth(labels, fontPx) + X_TICK_LABEL_GAP;
-}
-function rotatedXLabelPx(labels, fontPx = VX.axisFont) {
-  return Math.ceil(COS_45 * (maxTextWidth(labels, fontPx) + Math.ceil(fontPx * 1.35))) + X_TICK_LABEL_GAP;
-}
-function smartTicks(dates, xMax, labelPx, anchorTerminals = false) {
-  if (dates.length === 0) return [];
-  const perTick = labelPx !== void 0 && labelPx > 0 ? labelPx : VX.minPxPerTick;
-  const maxTicks = Math.max(2, Math.floor(xMax / perTick));
-  const last = dates.length - 1;
-  const pxPerIndex = dates.length > 0 ? xMax / dates.length : 0;
-  const anchored = anchorTerminals && labelPx !== void 0 && labelPx > 0;
-  const keep = /* @__PURE__ */ new Set();
-  if (dates.length <= maxTicks) {
-    for (let i = 0; i <= last; i += 1) keep.add(i);
-  } else {
-    const step = Math.ceil(dates.length / maxTicks);
-    for (let i = 0; i <= last; i += step) keep.add(i);
-    const BOUNDARY_FACTOR = 1.5;
-    const boundaryPx = anchored ? perTick * BOUNDARY_FACTOR : perTick;
-    const lastOnGrid = Math.floor(last / step) * step;
-    if (lastOnGrid !== last) {
-      const gapPx = (last - lastOnGrid) * pxPerIndex;
-      if (lastOnGrid > 0 && gapPx > 0 && gapPx < boundaryPx) keep.delete(lastOnGrid);
-      keep.add(last);
-    }
-  }
-  if (anchored && keep.size > 1) {
-    const BOUNDARY_FACTOR = 1.5;
-    const boundaryPx = perTick * BOUNDARY_FACTOR;
-    const sorted = [...keep].toSorted((a, b) => a - b);
-    const second = sorted[1];
-    if (second !== void 0 && second !== last && second * pxPerIndex < boundaryPx) {
-      keep.delete(second);
-    }
-    const afterHead = [...keep].toSorted((a, b) => a - b);
-    const secondLast = afterHead[afterHead.length - 2];
-    if (secondLast !== void 0 && secondLast !== 0 && (last - secondLast) * pxPerIndex < boundaryPx) {
-      keep.delete(secondLast);
-    }
-  }
-  return dates.filter((_, i) => keep.has(i));
-}
-function thinLabels(labels, bandPx, labelPx) {
-  const keep = /* @__PURE__ */ new Set();
-  const last = labels.length - 1;
-  if (last < 0) return keep;
-  keep.add(0);
-  if (last === 0) return keep;
-  if (bandPx <= 0 || labelPx <= 0) {
-    keep.add(last);
-    return keep;
-  }
-  const step = Math.max(1, Math.ceil(labelPx / bandPx));
-  for (let i = 0; i <= last; i += step) keep.add(i);
-  const lastOnGrid = Math.floor(last / step) * step;
-  if (lastOnGrid !== last && lastOnGrid > 0 && (last - lastOnGrid) * bandPx < labelPx) {
-    keep.delete(lastOnGrid);
-  }
-  keep.add(last);
-  return keep;
-}
-function smartTicksEvery(dates, count) {
-  if (dates.length === 0) return [];
-  if (dates.length <= count) return dates;
-  const step = Math.ceil(dates.length / count);
-  return dates.filter((_, i) => i % step === 0 || i === dates.length - 1);
-}
-const MIN_HORIZONTAL_TICKS = 3;
-const COS_45 = Math.SQRT1_2;
-function autoXLabelRotate(input) {
-  const { tier, xMax, labelPx, rotatedXMax } = input;
-  if (tier !== "phone") return 0;
-  if (labelPx <= 0 || xMax <= 0) return 0;
-  const flatLabels = Math.floor(xMax / labelPx);
-  if (flatLabels >= MIN_HORIZONTAL_TICKS) return 0;
-  if (rotatedXMax === void 0) return 45;
-  const rotatedLabels = Math.floor(rotatedXMax / (labelPx * COS_45));
-  return rotatedLabels >= 2 && rotatedLabels > flatLabels ? 45 : 0;
-}
-export {
-  autoXLabelRotate,
-  rotatedXLabelPx,
-  smartTicks,
-  smartTicksEvery,
-  thinLabels,
-  xLabelPxFor
-};