waveform-analysis 0.1.55 → 0.1.58

package/src/components/core/yAxisSlotLayout.test.ts

@@ -0,0 +1,129 @@
+import { zoomIdentity } from 'd3'
+import { describe, expect, it } from 'vitest'
+
+import { DEFAULT_WAVEFORM_RENDERING_OPTIONS } from '../../core'
+import { buildTrackLayouts, buildYAxisSlots } from './layout'
+import type { DisplaySeries, DisplayTrack } from './types'
+import { Y_AXIS_RIGHT_LABEL_OFFSET } from './yAxisConstants'
+
+function series(id: string, minimum: number, maximum: number): DisplaySeries {
+  return {
+    id,
+    name: id,
+    color: '#1677ff',
+    lineType: 'linear',
+    lineStyle: 'solid',
+    pointType: 'none',
+    errorBar: { visible: false, width: 1.5, capWidth: 8 },
+    points: [
+      { x: 0, y: minimum },
+      { x: 1, y: maximum },
+    ],
+    xDomain: [0, 1],
+    yDomain: [minimum, maximum],
+    hasErrorPoints: false,
+  }
+}
+
+function track(seriesList: DisplaySeries[]): DisplayTrack {
+  return {
+    id: seriesList[0]!.id,
+    series: seriesList,
+    visibleSeries: seriesList,
+    xDomain: [0, 1],
+    yDomain: [0, 1],
+  }
+}
+
+describe('Y-axis slots', () => {
+  it('aligns matching slots across single and multi-axis tracks', () => {
+    const tracks = [
+      track([series('single', -1e120, 1e120)]),
+      track([series('left', 0, 1), series('right', 1000, 3000)]),
+      track([series('left-two', 0, 1), series('right-two', 1000, 3000)]),
+    ]
+    const yAxisSlots = buildYAxisSlots(tracks, 'multi-axis')
+    const layouts = buildTrackLayouts({
+      cells: tracks.map((series, index) => ({
+        slotIndex: index,
+        row: index,
+        column: 0,
+        left: 0,
+        top: index * 100,
+        width: 600,
+        height: 100,
+        plotHeight: 100,
+        cellHeight: 130,
+        xAxisBand: 30,
+        series,
+      })),
+      grid: {
+        rowCount: 3,
+        columnCount: 1,
+        showPagination: false,
+        fillIncompleteLastRow: false,
+        trackLines: {},
+      },
+      displayMode: 'independent',
+      overlayMode: 'multi-axis',
+      independentTransforms: [zoomIdentity, zoomIdentity, zoomIdentity],
+      sharedZoomDomain: [0, 1],
+      timeUnit: 'ms',
+      rendering: DEFAULT_WAVEFORM_RENDERING_OPTIONS,
+      hideSecondaryLabels: false,
+      yAxisLabelX: yAxisSlots.slots.find((slot) => slot.side === 'left')!.labelOffset,
+      yAxisSlots: yAxisSlots.slots,
+      showCompactEmptyTracks: false,
+    })
+
+    expect(layouts.map((layout) => layout.yAxes[0]?.labelX)).toEqual([
+      layouts[0]?.yAxes[0]?.labelX,
+      layouts[0]?.yAxes[0]?.labelX,
+      layouts[0]?.yAxes[0]?.labelX,
+    ])
+    expect(layouts[1]?.yAxes[1]?.labelX).toBe(layouts[2]?.yAxes[1]?.labelX)
+    expect(layouts[1]?.yAxes[1]?.labelX).toBe(
+      600 +
+        yAxisSlots.slots.find((slot) => slot.side === 'right')!.labelOffset -
+        Y_AXIS_RIGHT_LABEL_OFFSET,
+    )
+    expect(yAxisSlots.slots).toMatchObject([
+      { side: 'left', sideIndex: 0, axisOffset: 0 },
+      { side: 'right', sideIndex: 0, axisOffset: 0 },
+    ])
+    expect(yAxisSlots.clearance.left).toBeGreaterThan(yAxisSlots.clearance.right)
+  })
+
+  it('reserves outward second slots for three and four value axes', () => {
+    const threeAxisSlots = buildYAxisSlots(
+      [track([series('left', 0, 1), series('right-one', 10, 20), series('right-two', 30, 40)])],
+      'multi-axis',
+    )
+    const fourAxisSlots = buildYAxisSlots(
+      [
+        track([
+          series('left-one', 0, 1),
+          series('left-two', 10, 20),
+          series('right-one', 30, 40),
+          series('right-two', 50, 60),
+        ]),
+      ],
+      'multi-axis',
+    )
+
+    expect(threeAxisSlots.slots).toMatchObject([
+      { side: 'left', sideIndex: 0, axisOffset: 0 },
+      { side: 'right', sideIndex: 0, axisOffset: 0 },
+      { side: 'right', sideIndex: 1 },
+    ])
+    expect(threeAxisSlots.slots[2]!.axisOffset).toBeGreaterThan(0)
+    expect(fourAxisSlots.slots).toMatchObject([
+      { side: 'left', sideIndex: 0, axisOffset: 0 },
+      { side: 'left', sideIndex: 1 },
+      { side: 'right', sideIndex: 0, axisOffset: 0 },
+      { side: 'right', sideIndex: 1 },
+    ])
+    expect(fourAxisSlots.slots[1]!.axisOffset).toBeLessThan(0)
+    expect(fourAxisSlots.slots[3]!.axisOffset).toBeGreaterThan(0)
+  })
+})

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

@@ -86,7 +86,7 @@ describe('WaveformChart', () => {
     expect(secondLeft - firstWidth).toBeGreaterThanOrEqual(60)
   })
 
-  it('keeps the Y-axis label gutter stable while paging between value ranges', async () => {
+  it('updates the Y-axis label position while preserving the chart gutter between pages', async () => {
     const wrapper = await mountSizedChart(
       {
         kind: 'series',
@@ -118,14 +118,12 @@ describe('WaveformChart', () => {
       { grid: { rowCount: 1, columnCount: 1 } },
     )
     const initialMargin = wrapper.attributes('data-chart-left-margin')
-    const initialLabelX = wrapper.get('.waveform-chart__track').attributes('data-y-axis-label-x')
+    expect(wrapper.get('.waveform-chart__track').attributes('data-y-axis-label-x')).toBe('-34')
 
     await wrapper.get('.ant-pagination-next button').trigger('click')
 
     expect(wrapper.attributes('data-chart-left-margin')).toBe(initialMargin)
-    expect(wrapper.get('.waveform-chart__track').attributes('data-y-axis-label-x')).toBe(
-      initialLabelX,
-    )
+    expect(wrapper.get('.waveform-chart__track').attributes('data-y-axis-label-x')).toBe('-62')
   })
 
   it('hides only secondary-column Y-axis labels when the grid is too narrow', async () => {

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

@@ -0,0 +1,61 @@
+import { describe, expect, it } from 'vitest'
+
+import { mountSizedChart } from '../../test/waveformChart'
+
+describe('WaveformChart multi-axis labels', () => {
+  it('aligns single-axis and multi-axis Y-axis titles in one column', async () => {
+    const wrapper = await mountSizedChart(
+      {
+        kind: 'series',
+        series: [
+          {
+            id: 'single',
+            trackId: 'single-track',
+            name: '单轴',
+            data: {
+              kind: 'points',
+              points: [
+                { x: 0, y: -1e120 },
+                { x: 1, y: 1e120 },
+              ],
+            },
+          },
+          {
+            id: 'left',
+            trackId: 'multi-track',
+            name: '左轴',
+            data: {
+              kind: 'points',
+              points: [
+                { x: 0, y: 0 },
+                { x: 1, y: 1 },
+              ],
+            },
+          },
+          {
+            id: 'right',
+            trackId: 'multi-track',
+            name: '右轴',
+            data: {
+              kind: 'points',
+              points: [
+                { x: 0, y: 1000 },
+                { x: 1, y: 3000 },
+              ],
+            },
+          },
+        ],
+      },
+      { overlayMode: 'multi-axis', grid: { rowCount: 2, columnCount: 1 } },
+    )
+    const tracks = wrapper.findAll('.waveform-chart__track')
+    const titleX = (transform: string | undefined) =>
+      Number(transform?.match(/translate\(([^,]+)/)?.[1])
+
+    expect(titleX(tracks[0]!.get('.waveform-chart__y-axis-label').attributes('transform'))).toBe(
+      titleX(
+        tracks[1]!.findAll('.waveform-track__multi-axis-title text')[0]!.attributes('transform'),
+      ),
+    )
+  })
+})

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

@@ -104,6 +104,68 @@ describe('WaveformChart track order', () => {
     expect(wrapper.findAll('.waveform-chart__crosshair line')).toHaveLength(2)
   })
 
+  it('keeps incremental watermarks stable when empty ordered tracks are hidden', async () => {
+    const wrapper = await mountSizedChart(mergedFourTrackSeries(), {
+      frameNumber: 1,
+      grid: {
+        rowCount: 2,
+        columnCount: 1,
+        hideEmptyTracks: true,
+        trackOrder: ['frame-1', 'frame-2', 'frame-3', 'frame-4'],
+      },
+    })
+
+    expect(
+      wrapper.findAll('.waveform-chart__track').map((track) => track.attributes('data-track-id')),
+    ).toEqual(['frame-1', 'frame-3'])
+    expect(
+      wrapper.findAll('.waveform-chart__watermark').map((watermark) => watermark.text()),
+    ).toEqual(['1', '3'])
+
+    await wrapper.get('.ant-pagination-next button').trigger('click')
+
+    expect(
+      wrapper.findAll('.waveform-chart__track').map((track) => track.attributes('data-track-id')),
+    ).toEqual(['frame-4'])
+    expect(
+      wrapper.findAll('.waveform-chart__watermark').map((watermark) => watermark.text()),
+    ).toEqual(['4'])
+  })
+
+  it('uses stable track IDs for explicit frame watermark overrides', async () => {
+    const wrapper = await mountSizedChart(mergedFourTrackSeries(), {
+      frameNumber: 1,
+      frameNumbers: { 'frame-1': 'A', 'frame-3': 'C', 'frame-4': 'D' },
+      grid: {
+        rowCount: 2,
+        columnCount: 1,
+        hideEmptyTracks: true,
+        trackOrder: ['frame-1', 'frame-2', 'frame-3', 'frame-4'],
+      },
+    })
+
+    expect(
+      wrapper.findAll('.waveform-chart__watermark').map((watermark) => watermark.text()),
+    ).toEqual(['A', 'C'])
+
+    await wrapper.get('.ant-pagination-next button').trigger('click')
+
+    expect(
+      wrapper.findAll('.waveform-chart__watermark').map((watermark) => watermark.text()),
+    ).toEqual(['D'])
+  })
+
+  it('keeps the existing incremental watermark fallback when frame mappings are absent', async () => {
+    const wrapper = await mountSizedChart(orderedSeries(['frame-1', 'frame-2']), {
+      frameNumber: 7,
+      grid: { rowCount: 2, columnCount: 1 },
+    })
+
+    expect(
+      wrapper.findAll('.waveform-chart__watermark').map((watermark) => watermark.text()),
+    ).toEqual(['7', '8'])
+  })
+
   it('appends data tracks absent from trackOrder in input order', async () => {
     const wrapper = await mountSizedChart(
       {

package/src/data/simulatedWaveforms.test.ts

@@ -3,7 +3,7 @@ import { describe, expect, it } from 'vitest'
 import { createSimulatedWaveformData } from './simulatedWaveforms'
 
 describe('simulated waveform data', () => {
-  it('creates deterministic, finite seven-channel data with a two-series second frame', () => {
+  it('creates deterministic, finite eight-channel data with a three-series second frame', () => {
     const first = createSimulatedWaveformData()
     const second = createSimulatedWaveformData()
 
@@ -11,12 +11,12 @@ describe('simulated waveform data', () => {
     expect(first.kind).toBe('series')
     if (first.kind !== 'series') return
 
-    expect(first.series).toHaveLength(7)
-    expect(new Set(first.series.map((series) => series.id)).size).toBe(7)
+    expect(first.series).toHaveLength(8)
+    expect(new Set(first.series.map((series) => series.id)).size).toBe(8)
     const secondFrame = first.series.filter(
       (series) => series.trackId === 'simulated-harmonic-frame',
     )
-    expect(secondFrame).toHaveLength(2)
+    expect(secondFrame).toHaveLength(3)
     expect(new Set(first.series.map((series) => series.shotNo))).toEqual(new Set(['13300']))
     const firstSeries = first.series[0]
     expect(firstSeries).toMatchObject({

package/src/data/simulatedWaveforms.ts

@@ -84,6 +84,18 @@ const seriesDefinitions: SimulatedSeriesDefinition[] = [
     signal: (time) =>
       0.62 * Math.sin(TWO_PI * 0.55 * time + 0.55) + 0.18 * Math.sin(TWO_PI * 2.2 * time - 0.2),
   },
+  {
+    id: 'simulated-harmonic-correction',
+    trackId: 'simulated-harmonic-frame',
+    shotNo: '13300',
+    name: '谐波校正',
+    unit: 'V',
+    color: '#722ed1',
+    lineType: 'linear',
+    pointType: 'none',
+    signal: (time) =>
+      0.48 * Math.sin(TWO_PI * 0.55 * time - 0.35) + 0.12 * Math.sin(TWO_PI * 2.2 * time + 0.7),
+  },
   {
     id: 'simulated-damped',
     shotNo: '13300',