nuxt-charts 3.0.0 → 3.1.0

package/dist/runtime/spec/types.d.ts

@@ -0,0 +1,132 @@
+/**
+ * The chart specification: a fully serializable description of what to plot.
+ *
+ * This is the layer between "application data" and "a rendered chart". A spec
+ * says *what* to show — which fields, how to bucket them, how to aggregate,
+ * what to compare against — and never *how* to draw it. Everything here is
+ * plain JSON: no functions, no class instances, no `Date` objects. That is a
+ * deliberate constraint, not an accident of the current implementation.
+ *
+ * Keeping it JSON means a spec can cross a boundary: stored in a database,
+ * sent over the wire, written by hand in a config file, or produced by a model
+ * from a natural-language question. Formatting concerns that genuinely need a
+ * function (custom tick formatters, tooltip templates) stay on the rendering
+ * props, so the spec itself survives `JSON.stringify` / `JSON.parse` intact.
+ */
+/** Chart forms a spec can request. Deliberately small for the first version. */
+export type SpecChartType = "line" | "area" | "bar";
+/**
+ * How rows sharing an x bucket are collapsed into one value.
+ *
+ * `count` ignores the y field entirely and counts rows, which is why the
+ * dimension's `y` is optional when counting.
+ */
+export type SpecAggregate = "sum" | "average" | "count" | "min" | "max";
+/** Calendar bucket width for a temporal x dimension. */
+export type SpecInterval = "day" | "week" | "month";
+/**
+ * A baseline to plot alongside the current period.
+ *
+ * `previous-period` shifts the window back by its own length (the 30 days
+ * before the visible 30 days); `previous-year` shifts it back one calendar
+ * year, which is the right comparison for seasonal data.
+ */
+export type SpecCompare = "previous-period" | "previous-year";
+/** Which row fields feed the axes. */
+export interface SpecDimensions {
+    /** Field plotted on the category (x) axis. */
+    x: string;
+    /**
+     * Field aggregated onto the value (y) axis. Optional only for `count`,
+     * which measures rows rather than a field.
+     */
+    y?: string;
+    /**
+     * Field whose distinct values split the data into separate series.
+     *
+     * Each distinct value becomes its own line/area/bar group, aggregated
+     * independently. Cannot be combined with `compare` — both want to own the
+     * series dimension, and stacking them produces a chart nobody can read.
+     */
+    series?: string;
+}
+/** How raw rows are reshaped before they reach the renderer. */
+export interface SpecTransform {
+    /**
+     * Bucket a temporal x dimension to this calendar width. Omit to treat the
+     * x values as opaque categories and group on exact equality.
+     */
+    interval?: SpecInterval;
+    /** How rows in a bucket are collapsed. Default `sum`. */
+    aggregate?: SpecAggregate;
+    /**
+     * Sort order of the resulting buckets. Temporal data defaults to `asc`
+     * (time reads left to right); categorical data defaults to `none`, which
+     * preserves first-seen order from the source rows.
+     */
+    sort?: "asc" | "desc" | "none";
+    /**
+     * Keep only the N largest buckets by value. Applied after aggregation, and
+     * meaningful mainly for categorical x dimensions.
+     */
+    limit?: number;
+    /**
+     * Emit buckets with no matching rows as zero instead of omitting them.
+     * Only possible with an `interval`, which defines what the missing buckets
+     * would have been. Default `true` — a gap in a time series is information,
+     * and silently closing it misrepresents the trend.
+     */
+    fillGaps?: boolean;
+}
+/**
+ * A complete, serializable chart description.
+ *
+ * @example
+ * ```ts
+ * const spec: ChartSpec = {
+ *   type: "line",
+ *   dimensions: { x: "createdAt", y: "amount" },
+ *   transform: { interval: "month", aggregate: "sum" },
+ *   compare: "previous-period",
+ * };
+ * ```
+ */
+export interface ChartSpec {
+    type: SpecChartType;
+    dimensions: SpecDimensions;
+    transform?: SpecTransform;
+    /** Plot a shifted copy of the window as a second, muted series. */
+    compare?: SpecCompare;
+    /**
+     * Restrict rows to a closed date window before aggregating, as ISO date
+     * strings. Required for `compare`: without a window there is no "period" to
+     * step back from.
+     */
+    range?: {
+        from: string;
+        to: string;
+    };
+    /** Display label for the primary series. Defaults to the `y` field name. */
+    label?: string;
+}
+/**
+ * One aggregated row produced by the transform, ready for the renderer.
+ *
+ * The x bucket is carried under a dedicated `x` key so the series values can
+ * stay purely numeric. Typing the index signature as `string | number` instead
+ * would make every key non-numeric as far as the renderers' `NumericKeys<T>`
+ * constraint is concerned, and no series could be plotted.
+ *
+ * `undefined` is a deliberate member: with `fillGaps` off, a bucket a series
+ * has no rows for is a hole in the line rather than a zero.
+ */
+export interface SpecDatum {
+    /** Bucket label for the x axis. */
+    x: string;
+    /** Aggregated values, keyed by series name. */
+    [series: string]: string | number | undefined;
+}
+/** Series key used for the shifted comparison series. */
+export declare const COMPARE_KEY = "compare";
+/** Series key used when a spec has neither a `series` split nor a compare. */
+export declare const VALUE_KEY = "value";

package/dist/runtime/spec/types.js

@@ -0,0 +1,2 @@
+export const COMPARE_KEY = "compare";
+export const VALUE_KEY = "value";

package/dist/runtime/types/charts.d.ts

@@ -13,6 +13,8 @@ import type { CurveType, DonutType, LegendPosition, Orientation } from "../enums
 import type { DitherVariant } from "../utils/dither.js";
 import type { StrokeGradientStop } from "../utils/gradient.js";
 import type { BackgroundVariant } from "../utils/background.js";
+import type { ChartSpec, SpecAggregate, SpecChartType, SpecCompare, SpecInterval } from "../spec/types.js";
+import type { MetricFormat, MetricRange } from "../spec/metric.js";
 import type { AreaFillVariant, BarVariant, DotVariant, LegendIndicatorVariant, RadarVariant, RadialVariant, StrokeVariant, TooltipRoundness, TooltipVariant } from "../utils/variants.js";
 import type { AxisConfig, AxisId, BulletLegendItemInterface, ChartPadding, ChartTheme, CrosshairConfig, MarkerConfig, YAxisConfig, axisFormatter } from "./shared.js";
 /** Keys whose declared value is numeric (nullable/optional numeric fields included). */
@@ -830,3 +832,132 @@ export interface SankeyChartProps<N extends SankeyInputNode = SankeyInputNode, L
     /** Animation duration in milliseconds. */
     duration?: number;
 }
+/**
+ * Props for `<DataChart>`, the data-aware primitive.
+ *
+ * Unlike the other chart interfaces, this one takes *raw* rows plus a
+ * {@link ChartSpec} rather than pre-aggregated data and a `categories` map —
+ * the spec is what decides which fields become series and buckets.
+ */
+export interface DataChartProps<T> extends ChartStyleProps {
+    /** Raw application rows. Aggregated according to `spec`. */
+    data: T[];
+    /** What to plot. Fully serializable — see {@link ChartSpec}. */
+    spec: ChartSpec;
+    /** Chart height in pixels. Default 260. */
+    height?: number;
+    /** Locale for axis bucket labels. Defaults to the browser's. */
+    locale?: string;
+    /** Hide the legend. */
+    hideLegend?: boolean;
+    /** Stack series instead of overlaying / grouping them. */
+    stacked?: boolean;
+    /** Per-chart appearance overrides, forwarded to the renderer. */
+    theme?: ChartTheme;
+    /**
+     * Formats y-axis ticks. A function, so it deliberately lives on the props
+     * rather than in the spec — keeping the spec itself JSON-serializable.
+     */
+    valueFormatter?: (value: number) => string;
+}
+/**
+ * Props for `<MetricChart>`, the analytics component.
+ *
+ * Where {@link DataChartProps} takes a spec and renders it, this one takes the
+ * *question* — which field, aggregated how, over what window, compared against
+ * what — and assembles the spec itself. The extra props over `DataChart` are
+ * all about the chrome a metric needs around the plot: a headline value, a
+ * delta, a range selector, and the export affordances.
+ */
+export interface MetricChartProps<T> extends ChartStyleProps {
+    /** Raw application rows. Aggregated according to the props below. */
+    data: T[];
+    /** Metric name, rendered as the card's heading. */
+    title?: string;
+    /** Optional supporting line under the title. */
+    description?: string;
+    /** Field plotted on the x axis. Must hold dates for a temporal metric. */
+    x: string;
+    /** Field aggregated onto the y axis. Optional only for `count`. */
+    y?: string;
+    /**
+     * Field whose distinct values split the plot into separate series.
+     *
+     * Mutually exclusive with `compare`: both claim the series dimension, so
+     * asking for a split suppresses the comparison rather than stacking them.
+     */
+    series?: string;
+    /** How rows sharing a bucket are collapsed. Default `sum`. */
+    aggregate?: SpecAggregate;
+    /**
+     * Bucket width. Omit to let the selected range choose one that keeps the
+     * number of marks readable.
+     */
+    interval?: SpecInterval;
+    /** Plot a shifted baseline and compute the delta against it. */
+    compare?: SpecCompare;
+    /** Chart form. Default `line`. */
+    type?: SpecChartType;
+    /** Number rendering for the headline, axis and tooltip. Default `number`. */
+    format?: MetricFormat;
+    /** ISO 4217 code for the `currency` format. Default `EUR`. */
+    currency?: string;
+    /** Locale for every number and date. Defaults to the browser's. */
+    locale?: string;
+    /** Extra `Intl.NumberFormat` options, merged over the format's defaults. */
+    formatOptions?: Intl.NumberFormatOptions;
+    /**
+     * Full control over the headline and axis text, bypassing `format`.
+     *
+     * A function, so it stays on the props rather than in the spec.
+     */
+    valueFormatter?: (value: number) => string;
+    /**
+     * Treat a fall as the good outcome, so the delta colours invert.
+     *
+     * The right default for latency, error rates, churn and cost — anything
+     * where "down" is the win.
+     */
+    inverseSentiment?: boolean;
+    /**
+     * Selectable windows. Default 7D / 30D / 3M / 1Y.
+     *
+     * Pass an empty array to hide the selector and plot `range` alone.
+     */
+    ranges?: readonly MetricRange[];
+    /** Selected range key. Use `v-model:range` to control it. */
+    range?: string;
+    /**
+     * Explicit window, overriding the range selector's arithmetic.
+     *
+     * Use when the window comes from elsewhere on the page (a shared date
+     * picker) rather than from this component's own buttons.
+     */
+    window?: {
+        from: string;
+        to: string;
+    };
+    /**
+     * Date the windows count back from. Defaults to now.
+     *
+     * Pinning it makes a demo, a screenshot or a test render the same chart
+     * every time instead of drifting with the clock.
+     */
+    anchor?: string | number | Date;
+    /** Chart height in pixels. Default 220. */
+    height?: number;
+    /** Stack series instead of overlaying them. */
+    stacked?: boolean;
+    /** Hide the chart's own legend. */
+    hideLegend?: boolean;
+    /** Per-chart appearance overrides, forwarded to the renderer. */
+    theme?: ChartTheme;
+    /** Offer a toggle that swaps the chart for its data table. */
+    showTable?: boolean;
+    /** Offer a CSV download of the aggregated rows. */
+    exportable?: boolean;
+    /** Filename for the CSV download. Defaults to a slug of the title. */
+    exportFilename?: string;
+    /** Hide the headline value and delta, leaving the title and the plot. */
+    hideValue?: boolean;
+}

package/dist/runtime/types/maps.d.ts

@@ -0,0 +1,237 @@
+import type { GeoProjection } from "d3-geo";
+import type { Feature, FeatureCollection, Geometry } from "geojson";
+import type { Topology, GeometryObject } from "topojson-specification";
+import type { LegendPosition } from "../enums.js";
+import type { ChartStyleProps } from "./charts.js";
+import type { BulletLegendItemInterface, ChartPadding, ChartTheme, axisFormatter } from "./shared.js";
+export type MapAccessor<T, V> = V | ((datum: T, index: number) => V);
+export type MapProjectionName = "mercator" | "equalEarth" | "naturalEarth" | "equirectangular" | "orthographic" | "albersUsa";
+/** Pass a projection name, a configured D3 projection, or a factory returning one. */
+export type MapProjection = MapProjectionName | GeoProjection | (() => GeoProjection);
+export type MapGeometry = FeatureCollection | Feature | Geometry | Topology<Record<string, GeometryObject>>;
+export type MapRegionName = "world" | "europe" | "asia" | "oceania" | "usa";
+export interface MapRegion {
+    lat: {
+        min: number;
+        max: number;
+    };
+    lng: {
+        min: number;
+        max: number;
+    };
+}
+export interface MapPoint {
+    id: string | number;
+    latitude: number;
+    longitude: number;
+    label?: string;
+    color?: string;
+    radius?: number;
+    [key: string]: unknown;
+}
+export interface MapLink<P extends MapPoint = MapPoint> {
+    source: string | number | P;
+    target: string | number | P;
+    color?: string;
+    width?: number;
+    label?: string;
+    [key: string]: unknown;
+}
+export interface MapArea {
+    id: string | number;
+    color?: string;
+    value?: number;
+    [key: string]: unknown;
+}
+export interface MapData<A extends MapArea = MapArea, P extends MapPoint = MapPoint, L extends MapLink<P> = MapLink<P>> {
+    areas?: A[];
+    points?: P[];
+    links?: L[];
+}
+/** Area accessors and tooltips receive joined row data and the original feature. */
+export type MapFeature<A extends MapArea = MapArea> = A & {
+    properties: Record<string, unknown>;
+    feature: Feature;
+};
+export interface MapPin {
+    lat: number;
+    lng: number;
+    id?: string | number;
+    label?: string;
+    color?: string;
+    radius?: number;
+    svgOptions?: {
+        color?: string;
+        radius?: number;
+        strokeColor?: string;
+        strokeWidth?: number;
+        strokeOpacity?: number;
+    };
+    data?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export interface MapLegendItem {
+    color: string;
+    label: string;
+}
+export interface MapDot extends MapPin {
+    x: number;
+    y: number;
+    countryId?: string;
+}
+export interface PrecomputedMap {
+    width: number;
+    height: number;
+    points: Record<string, MapDot>;
+    region?: MapRegion;
+    grid?: "vertical" | "diagonal";
+    projection?: MapProjectionName;
+    countries?: string[];
+    /** Projection metadata used by getPin. */
+    scale?: number;
+    translate?: [number, number];
+    /** Legacy Mercator bounds from maps precomputed with nuxt-charts v2. */
+    X_MIN?: number;
+    Y_MAX?: number;
+    X_RANGE?: number;
+    Y_RANGE?: number;
+    ystep?: number;
+}
+export interface MapZoom {
+    x: number;
+    y: number;
+    k: number;
+}
+export interface MapMarkSlot<T> {
+    values: T;
+    x?: number;
+    y?: number;
+    path?: string;
+    color: string;
+    radius?: number;
+    scale: number;
+    projection: GeoProjection;
+}
+export interface MapOverlaySlot {
+    width: number;
+    height: number;
+    transform: MapZoom;
+    projection: GeoProjection;
+}
+export type MapTooltipSlot<A extends MapArea, P extends MapPoint, L extends MapLink<P>> = {
+    kind: "feature";
+    values: MapFeature<A>;
+} | {
+    kind: "point";
+    values: P;
+} | {
+    kind: "link";
+    values: L;
+};
+export type DottedMapTooltipSlot = {
+    kind: "pin";
+    values: MapPin;
+} | {
+    kind: "dot";
+    values: MapDot;
+};
+export type MapInteractionKind = "feature" | "point" | "link" | "pin" | "dot";
+export interface MapBaseProps extends ChartStyleProps {
+    height?: number | string;
+    width?: number | string;
+    projection?: MapProjection;
+    /** Fit the projection to the geometry. Default true. Disable for a preconfigured projection. */
+    fitView?: boolean;
+    fitViewPadding?: number;
+    padding?: number | Partial<ChartPadding>;
+    disableZoom?: boolean;
+    zoomFactor?: number;
+    zoomExtent?: [number, number];
+    /** Wheel zoom is opt-in so a map does not capture normal page scrolling. */
+    zoomOnScroll?: boolean;
+    zoomDuration?: number;
+    duration?: number;
+    showControls?: boolean;
+    hideTooltip?: boolean;
+    hideLegend?: boolean;
+    categories?: Record<string, BulletLegendItemInterface>;
+    legendPosition?: LegendPosition;
+    legendStyle?: string | Record<string, string>;
+    backgroundColor?: string;
+    theme?: ChartTheme;
+    showGraticule?: boolean;
+    showSphere?: boolean;
+    graticuleColor?: string;
+    sphereColor?: string;
+}
+export interface TopoJSONMapProps<A extends MapArea = MapArea, P extends MapPoint = MapPoint, L extends MapLink<P> = MapLink<P>> extends MapBaseProps {
+    /** Omit geometry to use the bundled world map. */
+    topoJson?: MapGeometry;
+    geoJson?: MapGeometry;
+    /** TopoJSON object name; defaults to countries, land, or the first object. */
+    mapFeatureKey?: string;
+    /** Property used to join areas to features. Defaults to feature.id. */
+    featureId?: string | ((feature: Feature) => string | number);
+    data?: MapData<A, P, L>;
+    areaColor?: MapAccessor<MapFeature<A>, string>;
+    areaCursor?: MapAccessor<MapFeature<A>, string>;
+    areaStroke?: MapAccessor<MapFeature<A>, string>;
+    areaStrokeWidth?: MapAccessor<MapFeature<A>, number>;
+    /** Numeric field/accessor for an automatically scaled choropleth. */
+    value?: keyof A | ((area: MapFeature<A>) => number | undefined);
+    colorScale?: (value: number) => string;
+    colorRange?: [string, string];
+    valueDomain?: [number, number];
+    pointColor?: MapAccessor<P, string>;
+    pointSize?: MapAccessor<P, number>;
+    pointRadius?: MapAccessor<P, number>;
+    pointStrokeColor?: MapAccessor<P, string>;
+    pointStrokeWidth?: MapAccessor<P, number>;
+    pointCursor?: MapAccessor<P, string>;
+    pointLabel?: MapAccessor<P, string>;
+    showPointLabels?: boolean;
+    linkColor?: MapAccessor<L, string>;
+    linkWidth?: MapAccessor<L, number>;
+    linkCursor?: MapAccessor<L, string>;
+    linkDasharray?: MapAccessor<L, string>;
+    /** Great-circle routes follow the globe and clip correctly at the date line. */
+    linkCurve?: "geodesic" | "straight" | "arc";
+    linkCurvature?: number;
+    mapFitToPoints?: boolean;
+    zoomOnClick?: boolean;
+    heatmapMode?: boolean;
+    heatmapModeBlurStdDeviation?: number;
+    heatmapModeZoomLevelThreshold?: number;
+    tooltipTitleFormatter?: (datum: MapFeature<A> | P | L) => string | number;
+    yFormatter?: axisFormatter;
+}
+/** Compatibility name for the v2 TopoJSONMap prop interface. */
+export type MapsData<A extends MapArea = MapArea> = TopoJSONMapProps<A>;
+export interface DottedMapProps extends MapBaseProps {
+    geoJson?: MapGeometry;
+    mapFeatureKey?: string;
+    regionName?: MapRegionName;
+    region?: MapRegion;
+    countries?: string[];
+    pins?: MapPin[];
+    mapHeight?: number;
+    mapWidth?: number;
+    grid?: "vertical" | "diagonal";
+    shape?: "circle" | "hexagon";
+    dotSize?: number;
+    color?: string;
+    countryColors?: Record<string, string>;
+    strokeColor?: string;
+    strokeWidth?: number;
+    strokeOpacity?: number;
+    avoidOuterPins?: boolean;
+    precomputedMap?: string | PrecomputedMap;
+    defaultZoom?: number;
+    showLegend?: boolean;
+    legend?: MapLegendItem[];
+    maxHeight?: number | string;
+    pinColor?: MapAccessor<MapPin, string>;
+    pinSize?: MapAccessor<MapPin, number>;
+    showPinLabels?: boolean;
+    tooltipTitleFormatter?: (datum: MapPin | MapDot) => string | number;
+}

package/dist/runtime/types.d.ts

@@ -6,6 +6,9 @@
  */
 export type * from "./types/shared";
 export type * from "./types/charts";
+export type * from "./types/maps";
+export type * from "./spec/types";
+export type { TransformResult } from "./spec/transform.js";
 export type { AreaFillVariant, BarVariant, DotVariant, LegendIndicatorVariant, RadarVariant, RadialVariant, StrokeVariant, TooltipRoundness, TooltipVariant, } from "./utils/variants.js";
 export type { BackgroundVariant } from "./utils/background.js";
 export type { DitherVariant } from "./utils/dither.js";

package/dist/runtime/utils/axis.d.ts

@@ -29,10 +29,28 @@ export declare const AXIS_SLOT: {
     readonly defaultXHeight: 38;
     readonly titledXHeight: 52;
 };
+/**
+ * Approximate rendered width of a tick label. A canvas measure would be exact
+ * but the axis slot is needed during setup, before the chart (or, in SSR, any
+ * DOM at all) exists — so width is estimated from glyph counts instead.
+ */
+export declare function estimateTickLabelWidth(label: string, fontPx?: number): number;
 export declare function resolveYAxisWidth(options: {
     hasTitle: boolean;
     isCategoryAxis: boolean;
+    /** Formatted sample of the widest ticks the value axis is likely to show. */
+    sampleLabels?: readonly string[];
+    tickFontPx?: number;
+    /** Gap between the plot edge and the label, so it is not counted as space. */
+    tickMargin?: number;
 }): number;
+/**
+ * The "nice" round tick values d3 (and so vccs) picks for a numeric domain.
+ * Mirrors d3-array's `ticks` step selection so the axis slot can be sized from
+ * the labels that will actually be drawn — the top tick usually sits above the
+ * data maximum, and is the widest.
+ */
+export declare function niceTickValues(min: number, max: number, count?: number): number[];
 export declare function resolveXAxisHeight(options: {
     hasTitle: boolean;
 }): number;

package/dist/runtime/utils/axis.js

@@ -30,10 +30,53 @@ export const AXIS_SLOT = {
   defaultXHeight: 38,
   titledXHeight: 52
 };
+const MAX_NUMERIC_Y_WIDTH = 96;
+const GLYPH_ADVANCE_RATIO = 0.6;
+const DIGIT_ADVANCE_RATIO = 0.62;
+const DEFAULT_TICK_FONT_PX = 12;
+export function estimateTickLabelWidth(label, fontPx = DEFAULT_TICK_FONT_PX) {
+  let width = 0;
+  for (const char of label) {
+    width += /[0-9.,\s$€£¥%+-]/.test(char) ? DIGIT_ADVANCE_RATIO : GLYPH_ADVANCE_RATIO;
+  }
+  return width * fontPx;
+}
 export function resolveYAxisWidth(options) {
   if (options.hasTitle) return AXIS_SLOT.titledYWidth;
   if (options.isCategoryAxis) return AXIS_SLOT.categoryYWidth;
-  return AXIS_SLOT.numericYWidth;
+  const labels = options.sampleLabels;
+  if (!labels?.length) return AXIS_SLOT.numericYWidth;
+  let widest = 0;
+  for (const label of labels) {
+    widest = Math.max(widest, estimateTickLabelWidth(label, options.tickFontPx));
+  }
+  const needed = Math.ceil(widest + (options.tickMargin ?? 0));
+  return Math.min(Math.max(AXIS_SLOT.numericYWidth, needed), MAX_NUMERIC_Y_WIDTH);
+}
+export function niceTickValues(min, max, count = 5) {
+  if (!Number.isFinite(min) || !Number.isFinite(max)) return [];
+  if (min === max) return [min];
+  if (count <= 0) return [];
+  const step = tickIncrement(min, max, count);
+  if (!Number.isFinite(step) || step === 0) return [min, max];
+  const start = Math.ceil(min / step) * step;
+  const stop = Math.floor(max / step) * step;
+  const ticks = [];
+  for (let value = start, i = 0; value <= stop + step / 2; value += step, i++) {
+    ticks.push(start + i * step);
+    if (ticks.length > 100) break;
+  }
+  return ticks;
+}
+function tickIncrement(min, max, count) {
+  const rawStep = (max - min) / count;
+  const power = Math.floor(Math.log10(rawStep));
+  const magnitude = Math.pow(10, power);
+  const normalized = rawStep / magnitude;
+  if (normalized >= 7.5) return 10 * magnitude;
+  if (normalized >= 3) return 5 * magnitude;
+  if (normalized >= 1.5) return 2 * magnitude;
+  return magnitude;
 }
 export function resolveXAxisHeight(options) {
   return options.hasTitle ? AXIS_SLOT.titledXHeight : AXIS_SLOT.defaultXHeight;

package/dist/runtime/utils/dottedMap.d.ts

@@ -0,0 +1,14 @@
+import type { GeoProjection } from "d3-geo";
+import type { FeatureCollection } from "geojson";
+import type { DottedMapProps, MapDot, MapPin, PrecomputedMap, MapProjectionName } from "../types/maps.js";
+export declare function filterMapCountries(collection: FeatureCollection, countries?: string[]): FeatureCollection;
+export declare function generateMapDots(collection: FeatureCollection, projection: GeoProjection, width: number, height: number, options: Pick<DottedMapProps, "mapWidth" | "mapHeight" | "grid" | "region">): MapDot[];
+/** Precompute a serializable dotted map, using the same grid as DottedMap. */
+export declare function getMap(options?: Pick<DottedMapProps, "mapHeight" | "mapWidth" | "countries" | "region" | "grid" | "geoJson" | "mapFeatureKey"> & {
+    height?: number;
+    width?: number;
+    projection?: MapProjectionName;
+    geojsonWorld?: DottedMapProps["geoJson"];
+}): PrecomputedMap;
+/** Return the nearest grid position for a pin on a map produced by getMap. */
+export declare function getPin(map: PrecomputedMap, pin: MapPin): MapDot;