waveform-analysis 0.1.71 → 0.1.73

package/src/components/rendering/WaveformTrackAxes.vue

@@ -1,12 +1,14 @@
 <script setup lang="ts">
 import { axisBottom, axisLeft, axisRight, select } from 'd3'
-import { nextTick, onMounted, ref, watch } from 'vue'
+import { computed, nextTick, onMounted, onBeforeUnmount, ref, watch } from 'vue'
 
 import type { WaveformAxesOptions } from '../../types'
 import { formatXAxisLabel } from '../../utils'
 import { formatYAxisTickLabel } from '../core/layout'
 import type { DisplaySeries, TrackLayout, WaveformYAxisLayout } from '../core/types'
-import { Y_AXIS_LABEL_BAND_WIDTH } from '../core/yAxisConstants'
+import { updateMaximumTickVisibility } from './yAxisTickVisibility'
+import { sameTick } from '../core/yAxisPadding'
+import { resolveYAxisLabelBandWidth, resolveYAxisLabelFontSize } from '../core/yAxisLabelStyle'
 import { formatChannelLabel } from './channelLabel'
 
 interface Props {
@@ -19,10 +21,20 @@ interface Props {
   showUnits?: boolean
   showLabelUnits?: boolean
   hideYAxisTitles?: boolean
-  containYAxisEndpoints?: boolean
+  hideOverlappingMaximumLabel?: boolean
 }
 
 const props = withDefaults(defineProps<Props>(), { showUnits: true })
+const labelBandWidth = computed(() => resolveYAxisLabelBandWidth(props.axes?.y?.labelTextStyle))
+const labelTextStyle = computed(() => {
+  const style = props.axes?.y?.labelTextStyle
+  return {
+    fontSize: `${resolveYAxisLabelFontSize(style)}px`,
+    fontWeight: style?.fontWeight ?? 600,
+    fontFamily: style?.fontFamily,
+    fontStyle: style?.fontStyle ?? 'normal',
+  }
+})
 const xAxisElement = ref<SVGGElement>()
 const yAxisElements = ref<SVGGElement[]>([])
 
@@ -45,6 +57,7 @@ function renderAxes() {
     const element = yAxisElements.value[index]
     if (!element) return
     const unit = props.showUnits ? axis.seriesList[0]?.unit : undefined
+    const highestTick = Math.max(...axis.tickValues)
     const yAxis = (axis.side === 'left' ? axisLeft(axis.scale) : axisRight(axis.scale))
       .tickFormat((value) =>
         formatYAxisTickLabel(
@@ -62,24 +75,39 @@ function renderAxes() {
 
     const selection = select(element)
     selection.call(yAxis)
-    const lowestTick = Math.min(...axis.tickValues)
-    const highestTick = props.containYAxisEndpoints ? Math.max(...axis.tickValues) : undefined
     selection
       .selectAll<SVGTextElement, number>('.tick text')
       .attr('y', null)
-      .attr('dy', (value) => (value === lowestTick || value === highestTick ? '0' : '0.32em'))
-      .attr('dominant-baseline', (value) =>
-        value === lowestTick
-          ? 'text-after-edge'
-          : value === highestTick
-            ? 'text-before-edge'
-            : null,
+      .attr('dy', '0')
+      .attr('dominant-baseline', 'central')
+      .attr('data-axis-maximum-label', (value) =>
+        props.hideOverlappingMaximumLabel && sameTick(value, highestTick) ? 'true' : null,
+      )
+      .attr('data-axis-minimum-label', (value) =>
+        props.hideOverlappingMaximumLabel && sameTick(value, Math.min(...axis.tickValues))
+          ? 'true'
+          : null,
       )
+    selection
+      .attr('data-label-domain-min', axis.scale.domain()[0])
+      .attr('data-label-domain-max', axis.scale.domain()[1])
+      .attr('data-label-unit', unit ?? null)
+    selection
+      .selectAll<SVGGElement, number>('.tick')
+      .attr('data-maximum-tick', (value) =>
+        axis.maximumTick !== undefined && sameTick(value, axis.maximumTick) ? 'true' : null,
+      )
+      .attr('data-minimum-tick', (value) =>
+        axis.minimumTick !== undefined && sameTick(value, axis.minimumTick) ? 'true' : null,
+      )
+      .attr('data-tick-value', (value) => value)
+      .attr('data-tick-y', (value) => axis.scale(value))
     selection
       .selectAll('path.domain')
       .attr('display', props.axes?.y?.lineVisible === false ? 'none' : null)
   })
 
+  scheduleVisibility()
   if (!xAxisElement.value) return
   const selection = select(xAxisElement.value)
   selection.call(
@@ -103,7 +131,24 @@ function renderAxes() {
     .attr('display', props.axes?.x?.lineVisible === false ? 'none' : null)
 }
 
+let disposed = false
+function scheduleVisibility() {
+  if (disposed) return
+  const apply = () => {
+    const svg = yAxisElements.value[0]?.ownerSVGElement
+    if (svg) updateMaximumTickVisibility(svg)
+  }
+  apply()
+}
+onBeforeUnmount(() => {
+  disposed = true
+  document.fonts?.removeEventListener?.('loadingdone', scheduleVisibility)
+})
 onMounted(async () => {
+  document.fonts?.addEventListener?.('loadingdone', scheduleVisibility)
+  void document.fonts?.ready.then(() => {
+    if (!disposed) scheduleVisibility()
+  })
   await nextTick()
   renderAxes()
 })
@@ -116,10 +161,10 @@ watch(
     () => props.track.yAxisTickValues,
     () => props.timeUnit,
     () => props.showUnits,
-    () => props.containYAxisEndpoints,
     () => props.axes?.x?.labelFormatter,
     () => props.axes?.x?.lineVisible,
     () => props.axes?.y?.lineVisible,
+    () => props.hideOverlappingMaximumLabel,
   ],
   async () => {
     await nextTick()
@@ -191,15 +236,16 @@ watch(
   >
     <rect
       class="waveform-track__y-axis-label-bg waveform-chart__y-axis-label-bg"
-      :x="track.yAxes[0].labelX - Y_AXIS_LABEL_BAND_WIDTH / 2"
+      :x="track.yAxes[0].labelX - labelBandWidth / 2"
       :y="track.height / 2 - 40"
-      :width="Y_AXIS_LABEL_BAND_WIDTH"
+      :width="labelBandWidth"
       height="80"
       rx="2"
     />
     <text
       class="waveform-track__y-axis-label waveform-chart__y-axis-label"
-      :fill="track.series?.color"
+      :fill="axes?.y?.labelTextStyle?.color || track.series?.color"
+      :style="labelTextStyle"
       :transform="`translate(${track.yAxes[0].labelX}, ${track.height / 2}) rotate(-90)`"
       text-anchor="middle"
       dominant-baseline="central"
@@ -218,15 +264,16 @@ watch(
   >
     <rect
       class="waveform-track__y-axis-label-bg waveform-chart__y-axis-label-bg"
-      :x="axis.labelX - Y_AXIS_LABEL_BAND_WIDTH / 2"
+      :x="axis.labelX - labelBandWidth / 2"
       :y="track.height / 2 - 40"
-      :width="Y_AXIS_LABEL_BAND_WIDTH"
+      :width="labelBandWidth"
       height="80"
       rx="2"
     />
     <text
       class="waveform-track__y-axis-label waveform-chart__y-axis-label"
-      :fill="axis.seriesList[0].color"
+      :fill="axes?.y?.labelTextStyle?.color || axis.seriesList[0].color"
+      :style="labelTextStyle"
       :transform="`translate(${axis.labelX}, ${track.height / 2}) rotate(-90)`"
       text-anchor="middle"
       dominant-baseline="central"

package/src/components/rendering/WaveformTrackBackdrop.vue

@@ -6,6 +6,7 @@ interface Props {
   clipPathId: string
   innerWidth: number
   cleanView: boolean
+  showEmptyFrame?: boolean
   frameNumber?: string | number
   frameStyle: {
     backgroundColor: string
@@ -17,7 +18,7 @@ defineProps<Props>()
 
 <template>
   <rect
-    v-if="!track.isEmpty && !cleanView"
+    v-if="(!track.isEmpty || showEmptyFrame) && !cleanView"
     class="waveform-track__plot-background waveform-chart__plot-background"
     :width="track.width ?? innerWidth"
     :height="track.height"
@@ -26,7 +27,7 @@ defineProps<Props>()
   />
 
   <g
-    v-if="!track.isEmpty && !cleanView"
+    v-if="(!track.isEmpty || showEmptyFrame) && !cleanView"
     :clip-path="`url(#${clipPathId}-${track.index})`"
     aria-hidden="true"
   >
@@ -89,7 +90,11 @@ defineProps<Props>()
   </g>
 
   <text
-    v-if="!track.isEmpty && track.hasVisibleSeries && frameNumber !== undefined && !cleanView"
+    v-if="
+      (track.hasVisibleSeries || (track.isEmpty && showEmptyFrame)) &&
+      frameNumber !== undefined &&
+      !cleanView
+    "
     class="waveform-track__watermark waveform-chart__watermark"
     :x="(track.width ?? innerWidth) / 2"
     :y="track.height / 2"

package/src/components/rendering/compactFrame.ts

@@ -0,0 +1,31 @@
+import type { TrackLayout } from '../core/types'
+
+type Frame = Pick<TrackLayout, 'left' | 'top' | 'width' | 'height' | 'isEmpty'>
+
+/** Keep the lower frame's top edge as the single owner of a shared boundary. */
+export function compactFramePath(track: Frame, tracks: Frame[], inset = 0): string | undefined {
+  let uncovered: [number, number][] = [[0, track.width]]
+  for (const below of tracks) {
+    if (below === track) continue
+    if (Math.abs(track.top + track.height - below.top) > 1e-6) continue
+    const start = Math.max(0, below.left - track.left)
+    const end = Math.min(track.width, below.left + below.width - track.left)
+    if (end <= start) continue
+    uncovered = uncovered.flatMap(([left, right]): [number, number][] => {
+      if (end <= left || start >= right) return [[left, right]]
+      const parts: [number, number][] = []
+      if (left < start) parts.push([left, start])
+      if (right > end) parts.push([end, right])
+      return parts
+    })
+  }
+  if (uncovered.length === 1 && uncovered[0][0] === 0 && uncovered[0][1] === track.width)
+    return undefined
+  inset = Number.isFinite(inset) ? Math.max(0, inset) : 0
+  const rightEdge = Math.max(inset, track.width - inset)
+  const bottomEdge = Math.max(inset, track.height - inset)
+  const bottom = uncovered
+    .map(([left, right]) => `M${Math.max(inset, left)},${bottomEdge}H${Math.min(rightEdge, right)}`)
+    .join('')
+  return `M${inset},${bottomEdge}V${inset}H${rightEdge}V${bottomEdge}${bottom}`
+}

package/src/components/rendering/yAxisTickVisibility.ts

@@ -0,0 +1,156 @@
+import { sameTick } from '../core/yAxisPadding'
+import { formatYAxisTickLabel } from '../core/layout'
+
+interface Box {
+  left: number
+  right: number
+  top: number
+  bottom: number
+}
+
+function textBox(text: SVGTextElement): Box {
+  const rect = text.getBoundingClientRect()
+  if (rect.width && rect.height) return rect
+  const height = Number.parseFloat(getComputedStyle(text).fontSize) || 11
+  const width = (text.textContent?.length ?? 0) * height * 0.65
+  let x = Number(text.getAttribute('x')) || 0
+  let y = Number(text.getAttribute('y')) || 0
+  for (let parent: Element | null = text.parentElement; parent; parent = parent.parentElement) {
+    const match = parent
+      .getAttribute('transform')
+      ?.match(/translate\(([-\d.e+]+)[ ,]+([-\d.e+]+)\)/)
+    if (match) {
+      x += Number(match[1])
+      y += Number(match[2])
+    }
+  }
+  const startAligned = text.getAttribute('text-anchor') === 'start'
+  return {
+    left: startAligned ? x : x - width,
+    right: startAligned ? x + width : x,
+    top: y - height / 2,
+    bottom: y + height / 2,
+  }
+}
+
+export function labelsOverlap(a: Box, b: Box): boolean {
+  return a.left < b.right && b.left < a.right && a.top < b.bottom + 4 && b.top < a.bottom + 4
+}
+
+export function linesOverlap(a: number, b: number, widthA = 1, widthB = 1): boolean {
+  return Math.abs(a - b) < (widthA + widthB) / 2 + 1
+}
+
+function hide(element: Element) {
+  element.setAttribute('display', 'none')
+  element.setAttribute('data-maximum-hidden', 'true')
+}
+
+function strokeWidth(element: Element): number {
+  return Number.parseFloat(getComputedStyle(element).strokeWidth) || 1
+}
+
+function formatCompactLabels(svg: SVGSVGElement) {
+  svg.querySelectorAll<SVGTextElement>('text[data-axis-maximum-label]').forEach((maximum) => {
+    const axis = maximum.parentElement!.parentElement!
+    const labels = [...axis.querySelectorAll<SVGTextElement>('.tick text')]
+    const value = (text: SVGTextElement) =>
+      Number(text.parentElement!.getAttribute('data-tick-value'))
+    const visibleValues = labels
+      .filter((text) => text.getAttribute('display') !== 'none')
+      .map(value)
+    const domain: [number, number] = [
+      Number(axis.getAttribute('data-label-domain-min')),
+      Number(axis.getAttribute('data-label-domain-max')),
+    ]
+    labels.forEach((text) => {
+      text.textContent = formatYAxisTickLabel(
+        value(text),
+        domain,
+        visibleValues,
+        axis.getAttribute('data-label-unit') ?? undefined,
+        axis.getAttribute('data-y-axis-side') === 'right' ? 'right' : 'left',
+      )
+    })
+  })
+}
+
+/** Apply after axes and grid are in the DOM; never feed the filtered set back into layout. */
+export function updateMaximumTickVisibility(svg: SVGSVGElement) {
+  svg.querySelectorAll('[data-maximum-hidden]').forEach((el) => {
+    el.removeAttribute('display')
+    el.removeAttribute('data-maximum-hidden')
+  })
+  svg.querySelectorAll('.waveform-track__axis--y .tick text').forEach((text) => {
+    text.removeAttribute('display')
+  })
+  formatCompactLabels(svg)
+  const minimumLabels = [...svg.querySelectorAll<SVGTextElement>('text[data-axis-minimum-label]')]
+  svg.querySelectorAll<SVGTextElement>('text[data-axis-maximum-label]').forEach((maximum) => {
+    const box = textBox(maximum)
+    if (minimumLabels.some((minimum) => labelsOverlap(box, textBox(minimum)))) hide(maximum)
+  })
+  svg.querySelectorAll<SVGGElement>('.waveform-track__axis--y .tick').forEach((tick) => {
+    const position = Number(tick.getAttribute('data-tick-y'))
+    const height = Number(tick.closest('.waveform-track')?.getAttribute('data-track-height'))
+    const line = tick.querySelector('line')
+    if (sameTick(position, 0) || sameTick(position, height)) line?.setAttribute('display', 'none')
+    else line?.removeAttribute('display')
+  })
+  const minimumTicks = [...svg.querySelectorAll<SVGGElement>('.tick[data-minimum-tick]')]
+  const maximumTicks = [...svg.querySelectorAll<SVGGElement>('.tick[data-maximum-tick]')]
+  const labels = [...svg.querySelectorAll<SVGTextElement>('.waveform-track__axis--y .tick text')]
+  minimumTicks.forEach((tick) => {
+    const text = tick.querySelector('text')
+    if (!text) return
+    maximumTicks.forEach((maximum) => {
+      const other = maximum.querySelector('text')
+      if (other && other !== text && labelsOverlap(textBox(text), textBox(other))) hide(other)
+    })
+  })
+  const extremeTicks = [...new Set([...minimumTicks, ...maximumTicks])]
+  extremeTicks.forEach((tick) => {
+    const text = tick.querySelector('text')
+    const line = tick.querySelector('line')
+    if (!text || !line) return
+    const box = textBox(text)
+    labels.forEach((other) => {
+      if (text.getAttribute('display') === 'none') return
+      if (other.getAttribute('display') === 'none') return
+      if (other.parentElement?.matches('[data-minimum-tick], [data-maximum-tick]')) return
+      if (!tick.hasAttribute('data-minimum-tick') && other.hasAttribute('data-axis-minimum-label'))
+        return
+      if (labelsOverlap(box, textBox(other))) hide(other)
+    })
+    const axis = tick.parentElement!
+    const value = Number(tick.getAttribute('data-tick-value'))
+    const position = Number(tick.getAttribute('data-tick-y'))
+    axis
+      .querySelectorAll<SVGGElement>('.tick:not([data-maximum-tick]):not([data-minimum-tick])')
+      .forEach((other) => {
+        const otherLine = other.querySelector('line')
+        if (
+          otherLine &&
+          linesOverlap(
+            position,
+            Number(other.getAttribute('data-tick-y')),
+            strokeWidth(line),
+            strokeWidth(otherLine),
+          )
+        )
+          hide(otherLine)
+      })
+    // Only the primary Y axis owns the existing horizontal grid.
+    if (axis.getAttribute('data-y-axis-index') !== '0') return
+    const track = axis.closest('.waveform-track')!
+    track.querySelectorAll('[data-grid-direction="horizontal"]').forEach((gridLine) => {
+      const gridY = Number(gridLine.getAttribute('y1'))
+      if (linesOverlap(position, gridY, strokeWidth(line), strokeWidth(gridLine))) hide(gridLine)
+    })
+    if (tick.hasAttribute('data-maximum-tick'))
+      tick.setAttribute('data-maximum-value', String(value))
+    if (tick.hasAttribute('data-minimum-tick'))
+      tick.setAttribute('data-minimum-value', String(value))
+  })
+  formatCompactLabels(svg)
+}

package/src/core/lineBoundary.ts

@@ -0,0 +1,24 @@
+import type { WaveformPointRange } from './waveformPointSource'
+
+/** Outside neighbors join the curve without changing visible-point statistics. */
+export function lineBoundaryIndexes(range: WaveformPointRange, length: number): number[] {
+  if (!length || (range.start === range.end && (range.start === 0 || range.end === length)))
+    return []
+  return [range.start > 0 ? range.start - 1 : -1, range.end < length ? range.end : -1].filter(
+    (index) => index >= 0,
+  )
+}
+
+export function withLineBoundaries<T>(
+  points: T[],
+  range: WaveformPointRange,
+  length: number,
+  pointAt: (index: number) => T,
+): T[] {
+  const boundaries = lineBoundaryIndexes(range, length)
+  return [
+    ...boundaries.filter((index) => index < range.start).map(pointAt),
+    ...points,
+    ...boundaries.filter((index) => index >= range.end).map(pointAt),
+  ]
+}

package/src/core/rendering.ts

@@ -1,3 +1,5 @@
+import { pointSourceFromPoints, type WaveformPointSource } from './waveformPointSource'
+import { withLineBoundaries } from './lineBoundary'
 import { bisector } from 'd3'
 
 import type { WaveformPoint } from '../types'
@@ -20,6 +22,7 @@ const acceptAllPoints = () => true
 
 interface PointSeriesSource {
   points: WaveformPoint[]
+  source?: WaveformPointSource
 }
 
 interface SeriesRenderSelectionOptions {
@@ -58,9 +61,10 @@ export function hasMinimumVisibleXValues(
   const required = Math.ceil(minimum)
   const xValues = new Set<number>()
   for (const series of seriesList) {
-    const range = resolveVisiblePointRange(series.points, domain)
+    const source = series.source ?? pointSourceFromPoints(series.points)
+    const range = source.visibleRange(domain)
     for (let index = range.start; index < range.end; index += 1) {
-      xValues.add(series.points[index].x)
+      xValues.add(source.pointAt(index)!.x)
       if (xValues.size >= required) return true
     }
   }
@@ -68,18 +72,20 @@ export function hasMinimumVisibleXValues(
 }
 
 function selectRenderablePointsInRange(
-  points: WaveformPoint[],
+  points: WaveformPointSource,
   range: VisiblePointRange,
   domain: [number, number],
   width: number,
   options: ResolvedWaveformRenderingOptions,
 ): WaveformPoint[] {
+  if (range.start === range.end && (range.start === 0 || range.end === points.length)) return []
   const start = Math.max(0, range.start - 1)
   const end = Math.min(points.length, range.end + 1)
   const visibleCount = end - start
   if (visibleCount <= 0) return []
   return resolveRenderablePointSelectionStrategy({ visibleCount, width, options })({
-    points,
+    points: [],
+    source: points,
     range,
     domain,
     width,
@@ -96,25 +102,25 @@ function shouldDeferLineSampling(
 }
 
 function selectSamplingPlaceholderPoints(
-  points: WaveformPoint[],
+  points: WaveformPointSource,
   range: VisiblePointRange,
   width: number,
   options: ResolvedWaveformRenderingOptions,
 ): WaveformPoint[] {
-  const start = Math.max(0, range.start - 1)
-  const end = Math.min(points.length, range.end + 1)
+  const { start, end } = range
   const count = end - start
-  if (count <= 0) return []
-  if (options.sampling.strategy === 'none') return points.slice(start, end)
   const target =
     options.sampling.maxPointCount ??
     Math.max(1, Math.floor(width * options.sampling.maxPointsPerPixel))
-  if (count <= target) return points.slice(start, end)
-  if (target === 1) return [points[start]!]
-  return Array.from({ length: target }, (_, index) => {
-    const offset = Math.round((index * (count - 1)) / (target - 1))
-    return points[start + offset]!
-  })
+  const interior =
+    count <= target || options.sampling.strategy === 'none'
+      ? points.pointsInRange(start, end)
+      : Array.from({ length: target }, (_, index) =>
+          points.pointAt(
+            start + (target === 1 ? 0 : Math.round((index * (count - 1)) / (target - 1))),
+          )!,
+        )
+  return withLineBoundaries(interior, range, points.length, (index) => points.pointAt(index)!)
 }
 
 /**
@@ -129,7 +135,7 @@ export function selectRenderablePoints(
 ): WaveformPoint[] {
   if (!points.length || width <= 0) return []
   return selectRenderablePointsInRange(
-    points,
+    pointSourceFromPoints(points),
     resolveVisiblePointRange(points, domain),
     domain,
     width,
@@ -138,7 +144,7 @@ export function selectRenderablePoints(
 }
 
 function selectDecorationPointsInRange(
-  points: WaveformPoint[],
+  points: WaveformPointSource,
   range: VisiblePointRange,
   domain: [number, number],
   width: number,
@@ -148,10 +154,10 @@ function selectDecorationPointsInRange(
   priorityPredicate?: (point: WaveformPoint) => boolean,
 ): WaveformPoint[] {
   if (!downsample || minSpacing === 0) {
-    if (predicate === acceptAllPoints) return points.slice(range.start, range.end)
+    if (predicate === acceptAllPoints) return points.pointsInRange(range.start, range.end)
     const visiblePoints: WaveformPoint[] = []
     for (let index = range.start; index < range.end; index += 1) {
-      if (predicate(points[index])) visiblePoints.push(points[index])
+      if (predicate(points.pointAt(index)!)) visiblePoints.push(points.pointAt(index)!)
     }
     return visiblePoints
   }
@@ -161,7 +167,7 @@ function selectDecorationPointsInRange(
   const span = domainEnd - domainStart
   if (span <= 0) {
     for (let index = range.start; index < range.end; index += 1) {
-      if (predicate(points[index])) return [points[index]]
+      if (predicate(points.pointAt(index)!)) return [points.pointAt(index)!]
     }
     return []
   }
@@ -208,7 +214,7 @@ function selectDecorationPointsInRange(
   }
 
   for (let index = range.start; index < range.end; index += 1) {
-    const point = points[index]
+    const point = points.pointAt(index)!
     if (!predicate(point)) continue
     first ??= point
     last = point
@@ -252,7 +258,7 @@ export function selectDecorationPoints(
 ): WaveformPoint[] {
   if (!points.length || width <= 0) return []
   return selectDecorationPointsInRange(
-    points,
+    pointSourceFromPoints(points),
     resolveVisiblePointRange(points, domain),
     domain,
     width,
@@ -268,8 +274,8 @@ function hasPointError(point: WaveformPoint): boolean {
   return lower !== 0 || upper !== 0
 }
 
-export function selectSeriesRenderPoints(
-  points: WaveformPoint[],
+export function selectSeriesRenderSourcePoints(
+  points: WaveformPointSource,
   domain: [number, number],
   width: number,
   rendering: ResolvedWaveformRenderingOptions,
@@ -278,7 +284,7 @@ export function selectSeriesRenderPoints(
   if (!points.length || width <= 0) {
     return { linePoints: [], pointRenderPoints: [], errorBarRenderPoints: [] }
   }
-  const range = resolveVisiblePointRange(points, domain)
+  const range = points.visibleRange(domain)
   const linePoints = selection.lineVisible
     ? (selection.linePointOverride ??
       (shouldDeferLineSampling(range.end - range.start, rendering)
@@ -329,3 +335,20 @@ export function selectSeriesRenderPoints(
       : [],
   }
 }
+
+/** Public array adapter; internal layout passes its normalized source directly. */
+export function selectSeriesRenderPoints(
+  points: WaveformPoint[],
+  domain: [number, number],
+  width: number,
+  rendering: ResolvedWaveformRenderingOptions,
+  selection: SeriesRenderSelectionOptions,
+): SeriesRenderPointSelection {
+  return selectSeriesRenderSourcePoints(
+    pointSourceFromPoints(points),
+    domain,
+    width,
+    rendering,
+    selection,
+  )
+}