matterviz 0.3.4 → 0.3.6

package/dist/src/lib/plot/utils/label-placement.ts

@@ -0,0 +1,541 @@
+import type { Point2D } from '$lib/math'
+import type { AxisConfig, DataSeries } from '$lib/plot'
+import type { PlotScaleFn } from '$lib/plot/scales'
+import type { LabelPlacementConfig, LabelPlacementWeights } from '$lib/plot/types'
+import { is_time_scale } from '$lib/plot/types'
+
+export interface Rect {
+  x: number
+  y: number
+  w: number
+  h: number
+}
+
+export interface PlotBounds {
+  min_x: number
+  min_y: number
+  max_x: number
+  max_y: number
+}
+
+interface AnchorInfo {
+  x: number
+  y: number
+  radius: number
+}
+
+interface LabelState extends Rect {
+  anchor_idx: number
+}
+
+// Collected data for a single label before SA begins
+interface LabelInfo {
+  id: string
+  anchor: AnchorInfo
+  width: number
+  height: number
+  candidates: Point2D[]
+}
+
+export interface LabelSize {
+  width: number
+  height: number
+}
+
+export interface LeaderLineSegment {
+  x1: number
+  y1: number
+  x2: number
+  y2: number
+}
+
+export interface LeaderLineOptions {
+  point: Point2D
+  point_radius: number
+  label_center: Point2D
+  label_size: LabelSize
+  min_length?: number
+  label_padding?: number
+}
+
+const DEFAULT_WEIGHTS: Required<LabelPlacementWeights> = {
+  overlap: 30,
+  marker: 100,
+  leader_cross: 10,
+  leader_text: 8,
+  distance: 0.5,
+  bounds: 100,
+}
+const NEIGHBOR_CELL_OFFSETS = [-1, 0, 1] as const
+
+const copy_state = (target: LabelState, source: LabelState) => {
+  target.x = source.x
+  target.y = source.y
+  target.w = source.w
+  target.h = source.h
+  target.anchor_idx = source.anchor_idx
+}
+
+export function parse_font_size(size_str?: string): number {
+  if (!size_str) return 12
+  const match = /^(\d+(?:\.\d+)?)(px|em|rem)?$/.exec(size_str)
+  if (!match) return 12
+  const value = parseFloat(match[1])
+  return match[2] === `em` || match[2] === `rem` ? value * 16 : value
+}
+
+export function estimate_label_size(text: string, font_size_str?: string): LabelSize {
+  const font_size = parse_font_size(font_size_str)
+  const label_lines = text.split(/\r?\n/)
+  const max_line_length = Math.max(...label_lines.map((line) => line.length))
+  return {
+    width: max_line_length * font_size * 0.6 + 10,
+    height: label_lines.length * font_size * 1.2,
+  }
+}
+
+// === Geometry helpers ===
+
+export function rect_overlap_area(a: Rect, b: Rect): number {
+  const ox = Math.max(0, Math.min(a.x + a.w, b.x + b.w) - Math.max(a.x, b.x))
+  const oy = Math.max(0, Math.min(a.y + a.h, b.y + b.h) - Math.max(a.y, b.y))
+  return ox * oy
+}
+
+export function rect_circle_overlap(
+  rect: Rect,
+  cx: number,
+  cy: number,
+  radius: number,
+): number {
+  // Inflate rect by radius to create an exclusion zone around the marker
+  const left = rect.x - radius
+  const top = rect.y - radius
+  const right = rect.x + rect.w + radius
+  const bottom = rect.y + rect.h + radius
+  if (cx < left || cx > right || cy < top || cy > bottom) return 0
+  // Penalty proportional to how deep the marker center is inside the exclusion zone
+  const dx = Math.min(cx - left, right - cx)
+  const dy = Math.min(cy - top, bottom - cy)
+  return Math.min(dx, dy) + radius
+}
+
+export function segments_intersect(
+  ax1: number,
+  ay1: number,
+  ax2: number,
+  ay2: number,
+  bx1: number,
+  by1: number,
+  bx2: number,
+  by2: number,
+): boolean {
+  const d1x = ax2 - ax1,
+    d1y = ay2 - ay1
+  const d2x = bx2 - bx1,
+    d2y = by2 - by1
+  const cross = d1x * d2y - d1y * d2x
+  if (Math.abs(cross) < 1e-10) return false
+  const t_val = ((bx1 - ax1) * d2y - (by1 - ay1) * d2x) / cross
+  const u_val = ((bx1 - ax1) * d1y - (by1 - ay1) * d1x) / cross
+  return t_val > 0 && t_val < 1 && u_val > 0 && u_val < 1
+}
+
+export function segment_rect_intersects(
+  sx1: number,
+  sy1: number,
+  sx2: number,
+  sy2: number,
+  rect: Rect,
+): boolean {
+  const rx = rect.x,
+    ry = rect.y,
+    rx2 = rx + rect.w,
+    ry2 = ry + rect.h
+  return (
+    segments_intersect(sx1, sy1, sx2, sy2, rx, ry, rx2, ry) ||
+    segments_intersect(sx1, sy1, sx2, sy2, rx2, ry, rx2, ry2) ||
+    segments_intersect(sx1, sy1, sx2, sy2, rx, ry2, rx2, ry2) ||
+    segments_intersect(sx1, sy1, sx2, sy2, rx, ry, rx, ry2)
+  )
+}
+
+export function rect_out_of_bounds_area(rect: Rect, bounds: PlotBounds): number {
+  let penalty = 0
+  if (rect.x < bounds.min_x) penalty += (bounds.min_x - rect.x) * rect.h
+  if (rect.y < bounds.min_y) penalty += (bounds.min_y - rect.y) * rect.w
+  if (rect.x + rect.w > bounds.max_x) penalty += (rect.x + rect.w - bounds.max_x) * rect.h
+  if (rect.y + rect.h > bounds.max_y) penalty += (rect.y + rect.h - bounds.max_y) * rect.w
+  return penalty
+}
+
+export function label_leader_segment({
+  point,
+  point_radius,
+  label_center,
+  label_size,
+  min_length = 6,
+  label_padding = 1,
+}: LeaderLineOptions): LeaderLineSegment | null {
+  const delta_x = label_center.x - point.x
+  const delta_y = label_center.y - point.y
+  const center_distance = Math.hypot(delta_x, delta_y)
+  if (center_distance <= 0) return null
+
+  const unit_x = delta_x / center_distance
+  const unit_y = delta_y / center_distance
+  const start_x = point.x + unit_x * point_radius
+  const start_y = point.y + unit_y * point_radius
+  const half_width = label_size.width / 2 + label_padding
+  const half_height = label_size.height / 2 + label_padding
+  const edge_distance = Math.min(
+    Math.abs(unit_x) > 0.001 ? half_width / Math.abs(unit_x) : Infinity,
+    Math.abs(unit_y) > 0.001 ? half_height / Math.abs(unit_y) : Infinity,
+  )
+  const visible_length = center_distance - point_radius - edge_distance
+  if (visible_length <= min_length) return null
+
+  const end_x = label_center.x - unit_x * edge_distance
+  const end_y = label_center.y - unit_y * edge_distance
+  return { x1: start_x, y1: start_y, x2: end_x, y2: end_y }
+}
+
+// 8 candidate positions around anchor: R, TR, T, TL, L, BL, B, BR
+// Positions are top-left corner of the label bounding box.
+// All positions keep a full `offset` gap from the marker edge.
+export function generate_candidates(
+  ax: number,
+  ay: number,
+  point_radius: number,
+  label_w: number,
+  label_h: number,
+  gap: number,
+): Point2D[] {
+  const offset = point_radius + gap
+  return [
+    { x: ax + offset, y: ay - label_h + offset / 2 }, // R  (baseline just below center)
+    { x: ax + offset, y: ay - label_h - offset / 2 }, // TR
+    { x: ax - label_w / 2, y: ay - label_h - offset }, // T
+    { x: ax - label_w - offset, y: ay - label_h - offset / 2 }, // TL
+    { x: ax - label_w - offset, y: ay - label_h + offset / 2 }, // L  (baseline just below center)
+    { x: ax - label_w - offset, y: ay + offset / 2 }, // BL
+    { x: ax - label_w / 2, y: ay + offset }, // B
+    { x: ax + offset, y: ay + offset / 2 }, // BR
+  ]
+}
+
+// Compute energy delta when only label at `changed_idx` moves
+export function compute_delta_energy(
+  labels: LabelState[],
+  anchors: AnchorInfo[],
+  changed_idx: number,
+  old_state: LabelState,
+  new_state: LabelState,
+  weights: Required<LabelPlacementWeights>,
+  bounds: PlotBounds,
+): number {
+  let delta = 0
+  const anchor = anchors[new_state.anchor_idx]
+
+  const old_cx = old_state.x + old_state.w / 2,
+    old_cy = old_state.y + old_state.h / 2
+  const new_cx = new_state.x + new_state.w / 2,
+    new_cy = new_state.y + new_state.h / 2
+
+  // Distance penalty change
+  delta +=
+    weights.distance *
+    (Math.hypot(new_cx - anchor.x, new_cy - anchor.y) -
+      Math.hypot(old_cx - anchor.x, old_cy - anchor.y))
+
+  // Bounds penalty change
+  delta +=
+    weights.bounds *
+    (rect_out_of_bounds_area(new_state, bounds) - rect_out_of_bounds_area(old_state, bounds))
+
+  // Marker overlap change (all markers)
+  for (const marker of anchors) {
+    delta +=
+      weights.marker *
+      (rect_circle_overlap(new_state, marker.x, marker.y, marker.radius) -
+        rect_circle_overlap(old_state, marker.x, marker.y, marker.radius))
+  }
+
+  // Pairwise interactions with all other labels
+  for (let jdx = 0; jdx < labels.length; jdx++) {
+    if (jdx === changed_idx) continue
+    const other = labels[jdx]
+    const anchor_j = anchors[other.anchor_idx]
+    const other_cx = other.x + other.w / 2,
+      other_cy = other.y + other.h / 2
+
+    // Label-label overlap delta
+    delta +=
+      weights.overlap *
+      (rect_overlap_area(new_state, other) - rect_overlap_area(old_state, other))
+
+    // Leader line crossing delta (changed label's leader vs other's leader)
+    const old_cross = segments_intersect(
+      anchor.x,
+      anchor.y,
+      old_cx,
+      old_cy,
+      anchor_j.x,
+      anchor_j.y,
+      other_cx,
+      other_cy,
+    )
+    const new_cross = segments_intersect(
+      anchor.x,
+      anchor.y,
+      new_cx,
+      new_cy,
+      anchor_j.x,
+      anchor_j.y,
+      other_cx,
+      other_cy,
+    )
+    if (new_cross !== old_cross) delta += (new_cross ? 1 : -1) * weights.leader_cross
+
+    // Changed label's leader crossing other label's rect
+    const old_text = segment_rect_intersects(anchor.x, anchor.y, old_cx, old_cy, other)
+    const new_text = segment_rect_intersects(anchor.x, anchor.y, new_cx, new_cy, other)
+    if (new_text !== old_text) delta += (new_text ? 1 : -1) * weights.leader_text
+
+    // Other label's leader crossing changed label's rect
+    const old_other = segment_rect_intersects(
+      anchor_j.x,
+      anchor_j.y,
+      other_cx,
+      other_cy,
+      old_state,
+    )
+    const new_other = segment_rect_intersects(
+      anchor_j.x,
+      anchor_j.y,
+      other_cx,
+      other_cy,
+      new_state,
+    )
+    if (new_other !== old_other) delta += (new_other ? 1 : -1) * weights.leader_text
+  }
+
+  return delta
+}
+
+function cull_dense_labels(
+  label_infos: LabelInfo[],
+  max_neighbors: number,
+  radius: number,
+): LabelInfo[] {
+  if (radius <= 0 || label_infos.length <= max_neighbors + 1) return label_infos
+  const radius_squared = radius * radius
+  const get_cell = (value: number) => Math.floor(value / radius)
+  const grid: Record<string, number[]> = {}
+  label_infos.forEach(({ anchor }, label_idx) => {
+    const key = `${get_cell(anchor.x)},${get_cell(anchor.y)}`
+    const bucket = grid[key] ?? (grid[key] = [])
+    bucket.push(label_idx)
+  })
+
+  return label_infos.filter(({ anchor }, label_idx) => {
+    const cell_x = get_cell(anchor.x)
+    const cell_y = get_cell(anchor.y)
+    let neighbors = 0
+    for (const cell_x_offset of NEIGHBOR_CELL_OFFSETS) {
+      for (const cell_y_offset of NEIGHBOR_CELL_OFFSETS) {
+        const bucket = grid[`${cell_x + cell_x_offset},${cell_y + cell_y_offset}`]
+        if (!bucket) continue
+        for (const neighbor_idx of bucket) {
+          if (neighbor_idx === label_idx) continue
+          const delta_x = anchor.x - label_infos[neighbor_idx].anchor.x
+          const delta_y = anchor.y - label_infos[neighbor_idx].anchor.y
+          if (delta_x * delta_x + delta_y * delta_y <= radius_squared) neighbors += 1
+          if (neighbors > max_neighbors) return false
+        }
+      }
+    }
+    return true
+  })
+}
+
+// === Main export ===
+export function compute_label_positions(
+  filtered_series: DataSeries[],
+  config: LabelPlacementConfig,
+  scales: {
+    x_scale_fn: PlotScaleFn
+    y_scale_fn: PlotScaleFn
+    y2_scale_fn: PlotScaleFn
+    x_axis: AxisConfig
+  },
+  bounds: {
+    width: number
+    height: number
+    pad: { t: number; b: number; l: number; r: number }
+  },
+): Record<string, Point2D> {
+  const { x_scale_fn, y_scale_fn, y2_scale_fn, x_axis } = scales
+  const { width, height, pad } = bounds
+
+  const plot_bounds: PlotBounds = {
+    min_x: pad.l,
+    min_y: pad.t,
+    max_x: width - pad.r,
+    max_y: height - pad.b,
+  }
+
+  // Collect all label data in a single pass
+  let label_infos: LabelInfo[] = []
+  const candidate_gap = config.candidate_gap ?? 4
+
+  for (const series of filtered_series) {
+    for (const pt of series.filtered_data ?? []) {
+      if (!pt.point_label?.auto_placement || !pt.point_label.text) continue
+
+      const ax = is_time_scale(x_axis.scale_type, x_axis.format)
+        ? x_scale_fn(new Date(pt.x))
+        : x_scale_fn(pt.x)
+      const ay = (series.y_axis === `y2` ? y2_scale_fn : y_scale_fn)(pt.y)
+      const label_size =
+        pt.point_label.size ??
+        estimate_label_size(pt.point_label.text, pt.point_label.font_size)
+      const label_w = label_size.width
+      const label_h = label_size.height
+      const radius = pt.point_style?.radius ?? 3
+
+      label_infos.push({
+        id: `${pt.series_idx}-${pt.point_idx}`,
+        anchor: { x: ax, y: ay, radius },
+        width: label_w,
+        height: label_h,
+        candidates: generate_candidates(ax, ay, radius, label_w, label_h, candidate_gap),
+      })
+    }
+  }
+
+  if (config.max_neighbors) {
+    label_infos = cull_dense_labels(
+      label_infos,
+      config.max_neighbors.count,
+      config.max_neighbors.radius,
+    )
+  }
+
+  const num_labels = label_infos.length
+  if (num_labels === 0) return {}
+
+  // Fallback: too many labels, just offset to the right with bounds clamping
+  if (config.max_labels && num_labels > config.max_labels) {
+    return Object.fromEntries(
+      label_infos.map((info) => [
+        info.id,
+        {
+          x: Math.min(
+            Math.max(info.anchor.x + 5, plot_bounds.min_x),
+            plot_bounds.max_x - info.width,
+          ),
+          y: Math.min(
+            Math.max(info.anchor.y, plot_bounds.min_y),
+            plot_bounds.max_y - info.height,
+          ),
+        },
+      ]),
+    )
+  }
+
+  const weights: Required<LabelPlacementWeights> = { ...DEFAULT_WEIGHTS, ...config.weights }
+  const anchors = label_infos.map((info) => info.anchor)
+
+  // Greedy initialization: pick best candidate per label
+  const labels: LabelState[] = []
+  for (let idx = 0; idx < num_labels; idx++) {
+    const { candidates, width: lw, height: lh, anchor } = label_infos[idx]
+    let best_candidate = candidates[0]
+    let best_score = Infinity
+
+    for (const candidate of candidates) {
+      const test_rect: Rect = { x: candidate.x, y: candidate.y, w: lw, h: lh }
+      let score = weights.bounds * rect_out_of_bounds_area(test_rect, plot_bounds)
+
+      for (const placed of labels) {
+        score += weights.overlap * rect_overlap_area(test_rect, placed)
+      }
+      for (const marker of anchors) {
+        score +=
+          weights.marker * rect_circle_overlap(test_rect, marker.x, marker.y, marker.radius)
+      }
+      score +=
+        weights.distance *
+        Math.hypot(candidate.x + lw / 2 - anchor.x, candidate.y + lh / 2 - anchor.y)
+
+      if (score < best_score) {
+        best_score = score
+        best_candidate = candidate
+      }
+    }
+
+    labels.push({ x: best_candidate.x, y: best_candidate.y, w: lw, h: lh, anchor_idx: idx })
+  }
+
+  // Simulated annealing
+  const sa_iterations = config.sa_iterations ?? 2000
+  const total_steps = sa_iterations * num_labels
+  const cooling_rate = 1 / total_steps
+
+  // Seeded pseudo-random for deterministic results
+  let rng_state = 42
+  const next_random = (): number => {
+    rng_state = (rng_state * 1664525 + 1013904223) & 0x7fffffff
+    return rng_state / 0x7fffffff
+  }
+
+  // Reusable scratch objects to avoid allocations in the hot loop
+  const old_scratch: LabelState = { x: 0, y: 0, w: 0, h: 0, anchor_idx: 0 }
+  const new_scratch: LabelState = { x: 0, y: 0, w: 0, h: 0, anchor_idx: 0 }
+
+  for (let step = 0; step < total_steps; step++) {
+    const temperature = Math.max(0.001, 1.0 - step * cooling_rate)
+    const label_idx = Math.floor(next_random() * num_labels)
+    const current = labels[label_idx]
+    copy_state(old_scratch, current)
+    copy_state(new_scratch, current)
+
+    // 70% try a candidate position, 30% small perturbation
+    if (next_random() < 0.7) {
+      const candidate =
+        label_infos[label_idx].candidates[
+          Math.floor(next_random() * label_infos[label_idx].candidates.length)
+        ]
+      new_scratch.x = candidate.x
+      new_scratch.y = candidate.y
+    } else {
+      const max_shift = 30 * temperature + 5
+      new_scratch.x += (next_random() - 0.5) * 2 * max_shift
+      new_scratch.y += (next_random() - 0.5) * 2 * max_shift
+    }
+
+    const delta = compute_delta_energy(
+      labels,
+      anchors,
+      label_idx,
+      old_scratch,
+      new_scratch,
+      weights,
+      plot_bounds,
+    )
+
+    if (delta < 0 || next_random() < Math.exp(-delta / (temperature * 10 + 0.1))) {
+      current.x = new_scratch.x
+      current.y = new_scratch.y
+    }
+  }
+
+  // Return label center positions (matching existing API)
+  return Object.fromEntries(
+    labels.map((label, idx) => [
+      label_infos[idx].id,
+      { x: label.x + label.w / 2, y: label.y + label.h / 2 },
+    ]),
+  )
+}

package/dist/src/lib/plot/utils/series-visibility.ts

@@ -0,0 +1,140 @@
+import type { DataSeries } from '$lib/plot/types'
+
+export type StrRecord = Record<string, unknown>
+
+type SeriesSource = [string, string, string, unknown, unknown]
+
+export type SeriesVisibilitySnapshot = {
+  visibility: boolean[]
+  source: SeriesSource[]
+}
+
+const series_source = <Metadata extends StrRecord = StrRecord>(
+  series: DataSeries<Metadata>[],
+  length = series.length,
+): SeriesSource[] =>
+  series
+    .slice(0, length)
+    .map((srs) => [srs.label ?? ``, srs.unit ?? ``, srs.y_axis ?? ``, srs.x, srs.y])
+
+const same_series_source = (
+  series: SeriesSource[],
+  snapshot_series: SeriesSource[],
+): boolean =>
+  series.length === snapshot_series.length &&
+  series.every((source, idx) =>
+    source.every((part, part_idx) => Object.is(part, snapshot_series[idx][part_idx])),
+  )
+
+export function have_compatible_units<Metadata extends StrRecord = StrRecord>(
+  series1: DataSeries<Metadata>,
+  series2: DataSeries<Metadata>,
+): boolean {
+  if (!series1.unit || !series2.unit) return true
+  return series1.unit === series2.unit
+}
+
+export function toggle_series_visibility<Metadata extends StrRecord = StrRecord>(
+  series: DataSeries<Metadata>[],
+  series_idx: number,
+): DataSeries<Metadata>[] {
+  if (series_idx < 0 || series_idx >= series.length || !series[series_idx]) return series
+
+  const toggled = series[series_idx]
+  const new_visibility = !(toggled.visible ?? true)
+  const target_axis = toggled.y_axis ?? `y1`
+
+  return series.map((srs, idx) => {
+    if (
+      (toggled.label && srs.label === toggled.label) ||
+      (idx === series_idx && !toggled.label)
+    ) {
+      return { ...srs, visible: new_visibility }
+    }
+    if (new_visibility && (srs.y_axis ?? `y1`) === target_axis) {
+      if (!have_compatible_units(toggled, srs) && (srs.visible ?? true)) {
+        return { ...srs, visible: false }
+      }
+    }
+    return srs
+  })
+}
+
+export function toggle_group_visibility<Metadata extends StrRecord = StrRecord>(
+  series: DataSeries<Metadata>[],
+  series_indices: number[],
+): DataSeries<Metadata>[] {
+  // Filter to valid indices upfront
+  const valid_indices = series_indices.filter((idx) => idx >= 0 && idx < series.length)
+  if (valid_indices.length === 0) return series
+
+  const idx_set = new Set(valid_indices)
+
+  // Check if all series in the group are currently visible
+  const all_visible = valid_indices.every((idx) => series[idx].visible ?? true)
+
+  // Toggle: if all visible, hide all; otherwise show all
+  const new_visibility = !all_visible
+
+  return series.map((srs, idx) =>
+    idx_set.has(idx) ? { ...srs, visible: new_visibility } : srs,
+  )
+}
+
+export function handle_legend_double_click<Metadata extends StrRecord = StrRecord>(
+  series: DataSeries<Metadata>[],
+  idx: number,
+  prev_snapshot: SeriesVisibilitySnapshot | null,
+): {
+  series: DataSeries<Metadata>[]
+  prev_visibility: SeriesVisibilitySnapshot | null
+} {
+  if (idx < 0 || idx >= series.length) {
+    return { series, prev_visibility: prev_snapshot }
+  }
+
+  const { label } = series[idx]
+  const current = series.map((srs) => srs.visible ?? true)
+  const current_source = prev_snapshot
+    ? series_source(series, prev_snapshot.visibility.length)
+    : []
+  const prev_visibility =
+    prev_snapshot && same_series_source(current_source, prev_snapshot.source)
+      ? prev_snapshot.visibility
+      : null
+  // Only check original series (ignore new ones added after isolation)
+  const check_series = prev_visibility ? series.slice(0, prev_visibility.length) : series
+  const is_isolated = check_series.every((srs, srs_idx) => {
+    const in_group = label ? srs.label === label : srs_idx === idx
+    return in_group ? (srs.visible ?? true) : !(srs.visible ?? true)
+  })
+
+  // Restore from isolation
+  if (is_isolated && prev_visibility) {
+    return {
+      series: series.map((srs, srs_idx) =>
+        srs_idx < prev_visibility.length && current[srs_idx] !== prev_visibility[srs_idx]
+          ? { ...srs, visible: prev_visibility[srs_idx] }
+          : srs,
+      ),
+      prev_visibility: null,
+    }
+  }
+
+  // Isolate series
+  const new_prev = prev_visibility
+    ? prev_snapshot
+    : current.filter(Boolean).length > 1
+      ? {
+          visibility: [...current],
+          source: series_source(series),
+        }
+      : null
+  return {
+    series: series.map((srs, srs_idx) => {
+      const in_group = label ? srs.label === label : srs_idx === idx
+      return (srs.visible ?? true) !== in_group ? { ...srs, visible: in_group } : srs
+    }),
+    prev_visibility: new_prev,
+  }
+}

package/dist/src/lib/plot/utils.ts

@@ -0,0 +1,11 @@
+export function calc_auto_range(values: number[]): [number, number] {
+  const finite_values = values.filter(Number.isFinite)
+  if (finite_values.length === 0) return [0, 1]
+  let [min_value, max_value] = [finite_values[0], finite_values[0]]
+  for (const value of finite_values) {
+    if (value < min_value) min_value = value
+    else if (value > max_value) max_value = value
+  }
+  const padding = (max_value - min_value) * 0.05 || 0.5
+  return [min_value - padding, max_value + padding]
+}