waveform-analysis 0.1.38 → 0.1.40

package/dist/types/components/WaveformChart.vue.d.ts

@@ -1,6 +1,7 @@
 import type { WaveformChartProps } from './core/waveformChartTypes';
 declare const __VLS_export: import("vue").DefineComponent<WaveformChartProps, {
     resetViewport: (trackIndex?: number) => void;
+    setViewportDomain: (domain: [number, number], trackIndex?: number) => void;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
     "point-hover": (point: import("..").WaveformPoint | null) => any;
     "zoom-change": (domain: [number, number]) => any;

package/dist/types/components/core/layout.d.ts

@@ -11,7 +11,7 @@ export interface YAxisSeriesGroup {
 }
 export declare function buildYAxisSeriesGroups(track: DisplayTrack, overlayMode: WaveformOverlayMode): YAxisSeriesGroup[];
 export declare function resolveYAxisSeriesGroups(track: DisplayTrack, overlayMode: WaveformOverlayMode, yDomain?: WaveformYDomain, yDomains?: Record<string, WaveformYDomain>): YAxisSeriesGroup[];
-export declare function axisTextMetrics(domain: [number, number], nice?: boolean, tickValues?: number[]): {
+export declare function axisTextMetrics(domain: [number, number], nice?: boolean, tickValues?: number[], unit?: string): {
     tickTextWidth: number;
 };
 export declare function measureYAxisGroupClearance(group: YAxisSeriesGroup): number;

package/dist/types/components/core/useWaveformChartController.d.ts

@@ -228,6 +228,7 @@ export declare function useWaveformChartController(props: ResolvedWaveformChartP
     finishViewportDrag: (event: PointerEvent) => void;
     cancelViewportDrag: (event?: PointerEvent) => void;
     resetViewport: (trackIndex?: number) => void;
+    setViewportDomain: (domain: [number, number], trackIndex?: number) => void;
     requestViewportReset: (event: MouseEvent) => void;
     toggleSeriesVisibility: (seriesId: string) => void;
     changeDraftSeries: (seriesId: string) => void;

package/dist/types/components/core/useWaveformChartLifecycle.d.ts

@@ -31,6 +31,9 @@ interface LifecycleContext {
     trackLayouts: ComputedRef<TrackLayout[]>;
     innerWidth: ComputedRef<number>;
     innerHeight: ComputedRef<number>;
+    sharedZoomDomain: ComputedRef<[number, number]>;
+    initialXDomain: ComputedRef<[number, number]>;
+    sharedTransform: ShallowRef<ZoomTransform>;
     activeInteractionMode: ComputedRef<string | undefined>;
     hiddenSeriesIdSet: ComputedRef<Set<string>>;
     internalHiddenSeriesIds: Ref<Set<string>>;

package/dist/types/components/interaction/useWaveformViewport.d.ts

@@ -42,6 +42,7 @@ export declare function useWaveformViewport(context: ViewportContext): {
     finishViewportDrag: (event: PointerEvent) => void;
     cancelViewportDrag: (event?: PointerEvent) => void;
     resetViewport: (trackIndex?: number) => void;
+    setViewportDomain: (domain: [number, number], trackIndex?: number) => void;
     requestViewportReset: (event: MouseEvent) => void;
 };
 export {};

package/dist/types/components/interaction/viewportDomain.d.ts

@@ -0,0 +1,21 @@
+import { type ComputedRef, type Ref, type ShallowRef } from 'vue';
+import type { ZoomTransform } from 'd3';
+import type { TrackLayout } from '../core/types';
+import type { ResolvedWaveformChartProps } from '../core/waveformChartTypes';
+import type { AnnotationSeriesCandidate } from '../annotation';
+interface ViewportDomainContext {
+    props: ResolvedWaveformChartProps;
+    trackLayouts: ComputedRef<TrackLayout[]>;
+    initialXDomain: ComputedRef<[number, number]>;
+    resolveInitialTrackDomain: (track: TrackLayout) => [number, number];
+    innerWidth: ComputedRef<number>;
+    sharedTransform: ShallowRef<ZoomTransform>;
+    independentTransforms: ShallowRef<ZoomTransform[]>;
+    cancelPendingZoom: () => void;
+    cancelViewportDrag: () => void;
+    clearHover: () => void;
+    editorSeriesOptions: Ref<AnnotationSeriesCandidate[]>;
+    configureZoom: () => void;
+}
+export declare function createViewportDomainSetter(context: ViewportDomainContext): (domain: [number, number], trackIndex?: number) => void;
+export {};

package/dist/types/utils/formatters.d.ts

@@ -9,6 +9,7 @@ export interface ScientificAxisLabelOptions {
     axisMin?: number;
     axisMax?: number;
     topTickValue?: number;
+    unit?: string;
 }
 /** @deprecated Use ScientificAxisLabelOptions. */
 export type ScientificYAxisLabelOptions = ScientificAxisLabelOptions;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "waveform-analysis",
-  "version": "0.1.38",
+  "version": "0.1.40",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
   "types": "./dist/types/index.d.ts",

package/src/components/WaveformChart.vue

@@ -36,6 +36,7 @@ const controller = useWaveformChartController(props as ResolvedWaveformChartProp
 
 defineExpose({
   resetViewport: controller.resetViewport,
+  setViewportDomain: controller.setViewportDomain,
 })
 </script>
 

package/src/components/core/layout.ts

@@ -103,6 +103,7 @@ export function axisTextMetrics(
   domain: [number, number],
   nice = true,
   tickValues?: number[],
+  unit?: string,
 ): { tickTextWidth: number } {
   const scale = scaleLinear(domain, [1, 0])
   if (nice) scale.nice()
@@ -112,7 +113,7 @@ export function axisTextMetrics(
   const maximumTickCharacters = Math.max(
     1,
     ...values.map(
-      (value) => formatScientificAxisLabel(value, { axisMin, axisMax, topTickValue }).length,
+      (value) => formatScientificAxisLabel(value, { axisMin, axisMax, topTickValue, unit }).length,
     ),
   )
   return {
@@ -122,7 +123,8 @@ export function axisTextMetrics(
 
 export function measureYAxisGroupClearance(group: YAxisSeriesGroup): number {
   return (
-    axisTextMetrics(group.domain, !group.fixed).tickTextWidth +
+    axisTextMetrics(group.domain, !group.fixed, undefined, group.seriesList[0]?.unit)
+      .tickTextWidth +
     Y_AXIS_TICK_PADDING +
     Y_AXIS_LABEL_GAP +
     Y_AXIS_LABEL_BAND_WIDTH +
@@ -132,7 +134,8 @@ export function measureYAxisGroupClearance(group: YAxisSeriesGroup): number {
 
 function measureYAxisGroupTickClearance(group: YAxisSeriesGroup): number {
   return (
-    axisTextMetrics(group.domain, !group.fixed).tickTextWidth +
+    axisTextMetrics(group.domain, !group.fixed, undefined, group.seriesList[0]?.unit)
+      .tickTextWidth +
     Y_AXIS_TICK_PADDING +
     Y_AXIS_OUTER_PADDING
   )

package/src/components/core/trackLayoutBuilder.ts

@@ -135,7 +135,12 @@ export function buildTrackLayouts(options: BuildTrackLayoutsOptions): TrackLayou
       const tickValues = Array.from(
         new Set([axisStart, ...visibleMajorTicks, ...(showAxisEnd ? [axisEnd] : [])]),
       )
-      const { tickTextWidth } = axisTextMetrics(group.domain, !group.fixed, tickValues)
+      const { tickTextWidth } = axisTextMetrics(
+        group.domain,
+        !group.fixed,
+        tickValues,
+        group.seriesList[0]?.unit,
+      )
       const clearance =
         tickTextWidth +
         Y_AXIS_TICK_PADDING +

package/src/components/core/useWaveformChartController.ts

@@ -259,6 +259,9 @@ export function useWaveformChartController(
     trackLayouts,
     innerWidth,
     innerHeight,
+    sharedZoomDomain,
+    initialXDomain,
+    sharedTransform,
     activeInteractionMode,
     hiddenSeriesIdSet,
     internalHiddenSeriesIds,

package/src/components/core/useWaveformChartLifecycle.ts

@@ -39,6 +39,9 @@ interface LifecycleContext {
   trackLayouts: ComputedRef<TrackLayout[]>
   innerWidth: ComputedRef<number>
   innerHeight: ComputedRef<number>
+  sharedZoomDomain: ComputedRef<[number, number]>
+  initialXDomain: ComputedRef<[number, number]>
+  sharedTransform: ShallowRef<ZoomTransform>
   activeInteractionMode: ComputedRef<string | undefined>
   hiddenSeriesIdSet: ComputedRef<Set<string>>
   internalHiddenSeriesIds: Ref<Set<string>>
@@ -93,6 +96,9 @@ export function useWaveformChartLifecycle(context: LifecycleContext) {
     trackLayouts,
     innerWidth,
     innerHeight,
+    sharedZoomDomain,
+    initialXDomain,
+    sharedTransform,
     activeInteractionMode,
     hiddenSeriesIdSet,
     internalHiddenSeriesIds,
@@ -144,25 +150,24 @@ export function useWaveformChartLifecycle(context: LifecycleContext) {
     emit('page-change', nextPage, pageCount.value)
   }
 
+  let pendingSharedXDomain: [number, number] | undefined
   let pendingIndependentXDomains: Array<[number, number] | undefined> | undefined
 
   function handleBeforeDataReferenceChange() {
-    if (props.displayMode !== 'independent') return
-    pendingIndependentXDomains = trackLayouts.value.map((track) => {
-      const configuredDomain =
-        props.initialXDomains?.[track.series.trackId ?? track.series.id] ??
-        props.initialXDomains?.[track.series.id] ??
-        props.initialXDomain
-      if (
-        !configuredDomain ||
-        !Number.isFinite(configuredDomain[0]) ||
-        !Number.isFinite(configuredDomain[1]) ||
-        configuredDomain[0] === configuredDomain[1]
-      ) {
-        return undefined
-      }
-      return track.xScale.domain() as [number, number]
-    })
+    if (props.displayMode === 'independent') {
+      pendingSharedXDomain = undefined
+      pendingIndependentXDomains = trackLayouts.value.map((track) => {
+        const current = track.xScale.domain() as [number, number]
+        const boundary = resolveInitialTrackDomain(track)
+        return current[1] - current[0] < boundary[1] - boundary[0] - 1e-12 ? current : undefined
+      })
+      return
+    }
+    pendingIndependentXDomains = undefined
+    const current = sharedZoomDomain.value
+    const boundary = initialXDomain.value
+    pendingSharedXDomain =
+      current[1] - current[0] < boundary[1] - boundary[0] - 1e-12 ? [...current] : undefined
   }
 
   function handleDataReferenceChange() {
@@ -186,10 +191,15 @@ export function useWaveformChartLifecycle(context: LifecycleContext) {
         })
         independentTransforms.value = nextTransforms
         pendingIndependentXDomains = undefined
-        void nextTick(configureZoom)
-        return
+      } else if (props.displayMode !== 'independent' && pendingSharedXDomain) {
+        const boundary = initialXDomain.value
+        const groups = trackLayouts.value
+          .filter((track) => track.hasVisibleSeries)
+          .map((track) => track.seriesList)
+        const domain = constrainZoomDomain(pendingSharedXDomain, boundary, groups, props)
+        sharedTransform.value = transformForDomain(domain, boundary, innerWidth.value)
+        pendingSharedXDomain = undefined
       }
-      pendingIndependentXDomains = undefined
       configureZoom()
     })
   }

package/src/components/core/useWaveformLayout.ts

@@ -112,7 +112,11 @@ export function useWaveformLayout(context: LayoutContext) {
       .flatMap((track) =>
         resolveYAxisSeriesGroups(track, props.overlayMode, props.yDomain, props.yDomains),
       )
-      .map((group) => axisTextMetrics(group.domain, !group.fixed).tickTextWidth)
+      .map(
+        (group) =>
+          axisTextMetrics(group.domain, !group.fixed, undefined, group.seriesList[0]?.unit)
+            .tickTextWidth,
+      )
     const tickTextWidth = Math.max(Y_AXIS_CHARACTER_WIDTH, ...axisText)
     const tickClearance = tickTextWidth + Y_AXIS_TICK_PADDING + Y_AXIS_OUTER_PADDING
     const labelCenterX = -(

package/src/components/interaction/useWaveformViewport.ts

@@ -11,6 +11,7 @@ import type {
 import type { AnnotationSeriesCandidate } from '../annotation'
 import { tryReleasePointerCapture } from './pointerCapture'
 import { transitionViewportInteraction } from './viewportInteractionState'
+import { createViewportDomainSetter } from './viewportDomain'
 import { constrainZoomDomain, transformForDomain } from './zoomConstraints'
 interface ViewportContext {
   props: ResolvedWaveformChartProps
@@ -344,6 +345,20 @@ export function useWaveformViewport(context: ViewportContext) {
     editorSeriesOptions.value = []
     void nextTick(configureZoom)
   }
+  const setViewportDomain = createViewportDomainSetter({
+    props,
+    trackLayouts,
+    initialXDomain,
+    resolveInitialTrackDomain,
+    innerWidth,
+    sharedTransform,
+    independentTransforms,
+    cancelPendingZoom,
+    cancelViewportDrag,
+    clearHover,
+    editorSeriesOptions,
+    configureZoom,
+  })
   const requestViewportReset = (event: MouseEvent) => {
     if (isPresentationMode.value || !props.zoomable || !isZoomMode.value) return
     if (props.displayMode === 'independent') {
@@ -372,6 +387,7 @@ export function useWaveformViewport(context: ViewportContext) {
     finishViewportDrag,
     cancelViewportDrag,
     resetViewport,
+    setViewportDomain,
     requestViewportReset,
   }
 }

package/src/components/interaction/viewportDomain.ts

@@ -0,0 +1,60 @@
+import { nextTick, type ComputedRef, type Ref, type ShallowRef } from 'vue'
+import type { ZoomTransform } from 'd3'
+
+import type { TrackLayout } from '../core/types'
+import type { ResolvedWaveformChartProps } from '../core/waveformChartTypes'
+import type { AnnotationSeriesCandidate } from '../annotation'
+import { constrainZoomDomain, transformForDomain } from './zoomConstraints'
+
+interface ViewportDomainContext {
+  props: ResolvedWaveformChartProps
+  trackLayouts: ComputedRef<TrackLayout[]>
+  initialXDomain: ComputedRef<[number, number]>
+  resolveInitialTrackDomain: (track: TrackLayout) => [number, number]
+  innerWidth: ComputedRef<number>
+  sharedTransform: ShallowRef<ZoomTransform>
+  independentTransforms: ShallowRef<ZoomTransform[]>
+  cancelPendingZoom: () => void
+  cancelViewportDrag: () => void
+  clearHover: () => void
+  editorSeriesOptions: Ref<AnnotationSeriesCandidate[]>
+  configureZoom: () => void
+}
+
+export function createViewportDomainSetter(context: ViewportDomainContext) {
+  return (domain: [number, number], trackIndex?: number) => {
+    if (!Number.isFinite(domain[0]) || !Number.isFinite(domain[1]) || domain[0] === domain[1])
+      return
+    context.cancelPendingZoom()
+    context.cancelViewportDrag()
+    if (context.props.displayMode === 'independent') {
+      const indexes =
+        trackIndex === undefined
+          ? context.trackLayouts.value.map((track) => track.index)
+          : [trackIndex]
+      const nextTransforms = [...context.independentTransforms.value]
+      indexes.forEach((index) => {
+        const track = context.trackLayouts.value.find((item) => item.index === index)
+        if (!track) return
+        const boundary = context.resolveInitialTrackDomain(track)
+        const constrained = constrainZoomDomain(domain, boundary, [track.seriesList], context.props)
+        nextTransforms[index] = transformForDomain(constrained, boundary, track.width)
+      })
+      context.independentTransforms.value = nextTransforms
+    } else {
+      const boundary = context.initialXDomain.value
+      const groups = context.trackLayouts.value
+        .filter((track) => track.hasVisibleSeries)
+        .map((track) => track.seriesList)
+      const constrained = constrainZoomDomain(domain, boundary, groups, context.props)
+      context.sharedTransform.value = transformForDomain(
+        constrained,
+        boundary,
+        context.innerWidth.value,
+      )
+    }
+    context.clearHover()
+    context.editorSeriesOptions.value = []
+    void nextTick(context.configureZoom)
+  }
+}

package/src/components/rendering/WaveformTrackAxes.vue

@@ -44,9 +44,10 @@ function renderAxes() {
     if (!element) return
     const [axisMin, axisMax] = axis.scale.domain()
     const topTickValue = Math.max(...axis.tickValues)
+    const unit = axis.seriesList[0]?.unit
     const yAxis = (axis.side === 'left' ? axisLeft(axis.scale) : axisRight(axis.scale))
       .tickFormat((value) =>
-        formatScientificAxisLabel(Number(value), { axisMin, axisMax, topTickValue }),
+        formatScientificAxisLabel(Number(value), { axisMin, axisMax, topTickValue, unit }),
       )
       .tickSize(-4)
       .tickPadding(7)

package/src/components/waveformChartCases/dataLifecycle.test.ts

@@ -158,6 +158,12 @@ describe('WaveformChart', () => {
     expect(paths[0].attributes('data-series-name')).toBe('BT2_2M')
     const yAxisLabels = wrapper.findAll('.waveform-chart__y-axis-label')
     expect(yAxisLabels.map((label) => label.text())).toEqual(['BT2_2M', 'BT1_2M'])
+    expect(
+      wrapper
+        .findAll('.waveform-chart__axis--y .tick text')
+        .map((label) => label.text())
+        .some((label) => label.includes('(T)')),
+    ).toBe(true)
     expect(yAxisLabels.map((label) => label.attributes('fill'))).toEqual(['#0960bd', '#ff7f0e'])
     const labelX = Number(
       yAxisLabels[0].attributes('transform')?.match(/^translate\(([-\d.]+),/)?.[1],

package/src/components/waveformChartCases/multiAxisAndPagination.test.ts

@@ -15,6 +15,7 @@ describe('WaveformChart', () => {
           {
             trackId: 'shared-frame',
             name: '普通量程',
+            unit: 'V',
             data: {
               kind: 'points',
               points: [
@@ -26,6 +27,7 @@ describe('WaveformChart', () => {
           {
             trackId: 'shared-frame',
             name: '大量程',
+            unit: 'A',
             data: {
               kind: 'points',
               points: [
@@ -37,6 +39,7 @@ describe('WaveformChart', () => {
           {
             trackId: 'shared-frame',
             name: '小量程',
+            unit: 'T',
             data: {
               kind: 'points',
               points: [
@@ -57,7 +60,11 @@ describe('WaveformChart', () => {
           .map((label) => label.text())
           .filter((label) => label.startsWith('E')),
       ),
-    ).toEqual([[], [expect.stringMatching(/^E\+03 /)], [expect.stringMatching(/^E-04 /)]])
+    ).toEqual([
+      [],
+      [expect.stringMatching(/^E\+03 \(A\) /)],
+      [expect.stringMatching(/^E-04 \(T\) /)],
+    ])
   })
 
   it('reprojects annotations with the Y axis assigned to their series', async () => {

package/src/components/waveformChartCases/viewportReset.test.ts

@@ -119,6 +119,108 @@ describe('WaveformChart viewport reset', () => {
     expect(wrapper.findAll('.waveform-chart__axis-endpoint--end')[0].text()).toBe('1000')
   })
 
+  it('keeps a controlled shared viewport when the data reference changes', async () => {
+    const wrapper = await mountSizedChart(
+      {
+        kind: 'points',
+        points: [
+          { x: 0, y: 0 },
+          { x: 1, y: 1 },
+        ],
+      },
+      { displayMode: 'separated' },
+    )
+    const chart = wrapper.vm as unknown as {
+      setViewportDomain: (domain: [number, number], trackIndex?: number) => void
+    }
+    chart.setViewportDomain([0.25, 0.75])
+    await flushPromises()
+
+    const startBefore = Number(wrapper.get('.waveform-chart__axis-endpoint--start').text())
+    const endBefore = Number(wrapper.get('.waveform-chart__axis-endpoint--end').text())
+    expect(startBefore).toBeGreaterThan(0)
+    expect(endBefore).toBeLessThan(1000)
+
+    await wrapper.setProps({
+      data: {
+        kind: 'points',
+        points: [
+          { x: 0, y: 10 },
+          { x: 1, y: 11 },
+        ],
+      },
+    })
+    await flushPromises()
+
+    expect(Number(wrapper.get('.waveform-chart__axis-endpoint--start').text())).toBeCloseTo(
+      startBefore,
+      10,
+    )
+    expect(Number(wrapper.get('.waveform-chart__axis-endpoint--end').text())).toBeCloseTo(
+      endBefore,
+      10,
+    )
+  })
+
+  it('keeps independently controlled track viewports when the data reference changes', async () => {
+    const wrapper = await mountSizedChart(gridSeries(2), {
+      displayMode: 'independent',
+      grid: { rowCount: 1, columnCount: 2 },
+    })
+    const chart = wrapper.vm as unknown as {
+      setViewportDomain: (domain: [number, number], trackIndex?: number) => void
+    }
+    chart.setViewportDomain([0.2, 0.8], 0)
+    chart.setViewportDomain([0.1, 0.9], 1)
+    await flushPromises()
+
+    const endpoints = () =>
+      wrapper.findAll('.waveform-chart__track').map((track) => ({
+        start: track.get('.waveform-chart__axis-endpoint--start').text(),
+        end: track.get('.waveform-chart__axis-endpoint--end').text(),
+      }))
+    const endpointsBefore = endpoints()
+    expect(Number(endpointsBefore[0].start)).toBeGreaterThan(0)
+    expect(Number(endpointsBefore[0].end)).toBeLessThan(1000)
+    expect(Number(endpointsBefore[1].start)).toBeGreaterThan(0)
+    expect(Number(endpointsBefore[1].end)).toBeLessThan(1000)
+
+    await wrapper.setProps({ data: gridSeries(2) })
+    await flushPromises()
+
+    const endpointsAfter = endpoints()
+    endpointsAfter.forEach((endpoint, index) => {
+      expect(Number(endpoint.start)).toBeCloseTo(Number(endpointsBefore[index].start), 10)
+      expect(Number(endpoint.end)).toBeCloseTo(Number(endpointsBefore[index].end), 10)
+    })
+  })
+
+  it('ignores invalid domains and applies viewport constraints', async () => {
+    const wrapper = await mountSizedChart(
+      {
+        kind: 'points',
+        points: [
+          { x: 0, y: 0 },
+          { x: 1, y: 1 },
+        ],
+      },
+      { displayMode: 'separated', minZoomSpan: 0.2 },
+    )
+    const chart = wrapper.vm as unknown as {
+      setViewportDomain: (domain: [number, number], trackIndex?: number) => void
+    }
+    chart.setViewportDomain([Number.NaN, 0.5])
+    await flushPromises()
+    expect(wrapper.get('.waveform-chart__axis-endpoint--start').text()).toBe('0')
+    expect(wrapper.get('.waveform-chart__axis-endpoint--end').text()).toBe('1000')
+
+    chart.setViewportDomain([0.49, 0.51])
+    await flushPromises()
+    const start = Number(wrapper.get('.waveform-chart__axis-endpoint--start').text())
+    const end = Number(wrapper.get('.waveform-chart__axis-endpoint--end').text())
+    expect(end - start).toBeGreaterThanOrEqual(200)
+  })
+
   it('resets shared and independent explicit domains to their included nice bounds', async () => {
     const shared = await mountSizedChart(
       {

package/src/utils/formatters.test.ts

@@ -40,6 +40,15 @@ describe('waveform number formatters', () => {
     expect(formatScientificAxisExponent(0.0001, 0.0003)).toBe('E-04')
   })
 
+  it('appends a unit to the top tick with or without scientific notation', () => {
+    expect(formatScientificAxisLabel(3000, { axisMin: 1000, axisMax: 3000, unit: 'V' })).toBe(
+      'E+03 (V) 3',
+    )
+    expect(formatScientificAxisLabel(3, { axisMin: 0, axisMax: 3, unit: 'A' })).toBe('(A) 3')
+    expect(formatScientificAxisLabel(2, { axisMin: 0, axisMax: 3, unit: 'A' })).toBe('2')
+    expect(formatScientificAxisLabel(3, { axisMin: 0, axisMax: 3, unit: '  ' })).toBe('3')
+  })
+
   it('derives the exponent from the largest absolute endpoint', () => {
     expect(resolveScientificAxisExponent(-9000, -1000)).toBe(3)
     expect(resolveScientificAxisExponent(-100_000, -3000)).toBe(5)

package/src/utils/formatters.ts

@@ -11,6 +11,7 @@ export interface ScientificAxisLabelOptions {
   axisMin?: number
   axisMax?: number
   topTickValue?: number
+  unit?: string
 }
 
 /** @deprecated Use ScientificAxisLabelOptions. */
@@ -71,9 +72,11 @@ export function formatScientificAxisLabel(
   const scaledValue = exponent === null ? value : value / 10 ** exponent
   const formattedValue = formatYAxisNumber(scaledValue)
   const topTickValue = options.topTickValue ?? options.axisMax
-  return exponent !== null && value === topTickValue
-    ? `${formatExponent(exponent)} ${formattedValue}`
-    : formattedValue
+  if (value !== topTickValue) return formattedValue
+  const unit = options.unit?.trim()
+  const unitLabel = unit ? `(${unit}) ` : ''
+  const exponentLabel = exponent === null ? '' : `${formatExponent(exponent)} `
+  return `${exponentLabel}${unitLabel}${formattedValue}`
 }
 
 /** Return the shared E-style multiplier for an axis, or null for a plain axis. */