waveform-analysis 0.1.55 → 0.1.57

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

@@ -10,6 +10,13 @@ export interface YAxisSeriesGroup {
     domain: [number, number];
     fixed: boolean;
 }
+export interface YAxisSlot {
+    side: 'left' | 'right';
+    sideIndex: number;
+    axisOffset: number;
+    labelOffset: number;
+    clearance: number;
+}
 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[], unit?: string, tickCount?: number): {
@@ -20,6 +27,17 @@ export declare function measureTrackYAxisClearance(track: DisplayTrack, overlayM
     left: number;
     right: number;
 };
+/**
+ * Reserves stable Y-axis positions for every visible track on the current page.
+ * Slots are ordered from the plot edge outward for each side.
+ */
+export declare function buildYAxisSlots(tracks: readonly DisplayTrack[], overlayMode: WaveformOverlayMode, yDomain?: WaveformYDomain, yDomains?: Record<string, WaveformYDomain>, tickCount?: number, nice?: boolean): {
+    slots: YAxisSlot[];
+    clearance: {
+        left: number;
+        right: number;
+    };
+};
 type PositionedTrack = Pick<TrackLayout, 'left' | 'top' | 'width' | 'height'>;
 export declare function findClosestTrackAtPointer<T extends PositionedTrack>(tracks: readonly T[], pointerX: number, pointerY: number): T | undefined;
 export { buildTrackLayouts, type BuildTrackLayoutsOptions } from './trackLayoutBuilder';

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

@@ -2,6 +2,7 @@ import { type ZoomTransform } from 'd3';
 import { type ResolvedWaveformRenderingOptions } from '../../core/rendering';
 import type { WaveformDisplayMode, WaveformOverlayMode, WaveformPoint, WaveformXDomainStrategy, WaveformXAxisLabelFormatter } from '../../types';
 import { type GridCellGeometry, type NormalizedWaveformGridOptions } from './grid';
+import { type YAxisSlot } from './layout';
 import type { DisplayTrack, TrackLayout } from './types';
 interface SeriesGridCell extends GridCellGeometry {
     series?: DisplayTrack;
@@ -28,6 +29,7 @@ export interface BuildTrackLayoutsOptions {
     linePointOverrides?: Readonly<Record<string, WaveformPoint[]>>;
     hideSecondaryLabels: boolean;
     yAxisLabelX: number;
+    yAxisSlots?: readonly YAxisSlot[];
     showCompactEmptyTracks: boolean;
 }
 export declare function buildTrackLayouts(options: BuildTrackLayoutsOptions): TrackLayout[];

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

@@ -3,4 +3,5 @@ export declare const Y_AXIS_TICK_PADDING = 7;
 export declare const Y_AXIS_OUTER_PADDING = 4;
 export declare const Y_AXIS_LABEL_GAP = 0;
 export declare const Y_AXIS_LABEL_BAND_WIDTH = 12;
+export declare const Y_AXIS_RIGHT_LABEL_OFFSET = 10;
 export declare function resolveYAxisSides(axisCount: number): Array<'left' | 'right'>;

package/package.json

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

package/src/App.test.ts

@@ -231,7 +231,7 @@ describe('App workspace layout', { timeout: 20_000 }, () => {
       tracks.map((track) =>
         track.findAll('.waveform-chart__series').map((item) => item.attributes('data-series-name')),
       ),
-    ).toEqual([['正弦基波'], ['谐波扰动', '谐波对比'], ['阻尼振荡'], ['阶跃响应']])
+    ).toEqual([['正弦基波'], ['谐波扰动', '谐波对比', '谐波校正'], ['阻尼振荡'], ['阶跃响应']])
     expect(
       tracks
         .slice(1)
@@ -250,6 +250,7 @@ describe('App workspace layout', { timeout: 20_000 }, () => {
       '正弦基波',
       '谐波扰动',
       '谐波对比',
+      '谐波校正',
       '阻尼振荡',
       '阶跃响应',
       '脉冲响应',

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

@@ -254,7 +254,7 @@ describe('multi-value Y-axis grouping', () => {
       })),
     ).toEqual([
       { side: 'left', labelOffset: 55 },
-      { side: 'right', labelOffset: 55 },
+      { side: 'right', labelOffset: 45 },
     ])
   })
 

package/src/components/core/layout.ts

@@ -35,6 +35,14 @@ export interface YAxisSeriesGroup {
   fixed: boolean
 }
 
+export interface YAxisSlot {
+  side: 'left' | 'right'
+  sideIndex: number
+  axisOffset: number
+  labelOffset: number
+  clearance: number
+}
+
 function resolveAxisSides(axisCount: number): Array<'left' | 'right'> {
   if (axisCount >= 4) return ['left', 'left', 'right', 'right']
   if (axisCount === 3) return ['left', 'right', 'right']
@@ -181,6 +189,61 @@ export function measureTrackYAxisClearance(
   )
 }
 
+/**
+ * Reserves stable Y-axis positions for every visible track on the current page.
+ * Slots are ordered from the plot edge outward for each side.
+ */
+export function buildYAxisSlots(
+  tracks: readonly DisplayTrack[],
+  overlayMode: WaveformOverlayMode,
+  yDomain?: WaveformYDomain,
+  yDomains?: Record<string, WaveformYDomain>,
+  tickCount?: number,
+  nice = true,
+): { slots: YAxisSlot[]; clearance: { left: number; right: number } } {
+  const widths = new Map<string, number>()
+  tracks.forEach((track) => {
+    const sideIndexes = { left: 0, right: 0 }
+    resolveYAxisSeriesGroups(track, overlayMode, yDomain, yDomains).forEach((group) => {
+      const sideIndex = sideIndexes[group.side]++
+      const key = `${group.side}:${sideIndex}`
+      const width = axisTextMetrics(
+        group.domain,
+        nice,
+        undefined,
+        group.seriesList[0]?.unit,
+        tickCount,
+      ).tickTextWidth
+      widths.set(key, Math.max(widths.get(key) ?? Y_AXIS_CHARACTER_WIDTH, width))
+    })
+  })
+
+  const slots: YAxisSlot[] = []
+  const clearance = { left: 0, right: 0 }
+  ;(['left', 'right'] as const).forEach((side) => {
+    const sideIndexes = Array.from(widths.keys())
+      .filter((key) => key.startsWith(`${side}:`))
+      .map((key) => Number(key.slice(side.length + 1)))
+      .sort((first, second) => first - second)
+    sideIndexes.forEach((sideIndex) => {
+      const tickTextWidth = widths.get(`${side}:${sideIndex}`) ?? Y_AXIS_CHARACTER_WIDTH
+      const axisOffset = side === 'left' && clearance.left > 0 ? -clearance.left : clearance[side]
+      const labelDistance =
+        tickTextWidth + Y_AXIS_TICK_PADDING + Y_AXIS_LABEL_GAP + Y_AXIS_LABEL_BAND_WIDTH / 2
+      const labelOffset = axisOffset + labelDistance * (side === 'left' ? -1 : 1)
+      const fullClearance =
+        tickTextWidth +
+        Y_AXIS_TICK_PADDING +
+        Y_AXIS_LABEL_GAP +
+        Y_AXIS_LABEL_BAND_WIDTH +
+        Y_AXIS_OUTER_PADDING
+      slots.push({ side, sideIndex, axisOffset, labelOffset, clearance: fullClearance })
+      clearance[side] += fullClearance
+    })
+  })
+  return { slots, clearance }
+}
+
 type PositionedTrack = Pick<TrackLayout, 'left' | 'top' | 'width' | 'height'>
 
 export function findClosestTrackAtPointer<T extends PositionedTrack>(

package/src/components/core/trackLayoutBuilder.ts

@@ -25,13 +25,19 @@ import {
   type GridCellGeometry,
   type NormalizedWaveformGridOptions,
 } from './grid'
-import { axisTextMetrics, resolveYAxisSeriesGroups, resolveYAxisTickCount } from './layout'
+import {
+  axisTextMetrics,
+  resolveYAxisSeriesGroups,
+  resolveYAxisTickCount,
+  type YAxisSlot,
+} from './layout'
 import type { DisplayTrack, TrackLayout, WaveformYAxisLayout } from './types'
 import { applyXDomainStrategy } from './xDomain'
 import {
   Y_AXIS_LABEL_BAND_WIDTH,
   Y_AXIS_LABEL_GAP,
   Y_AXIS_OUTER_PADDING,
+  Y_AXIS_RIGHT_LABEL_OFFSET,
   Y_AXIS_TICK_PADDING,
 } from './yAxisConstants'
 
@@ -61,6 +67,7 @@ export interface BuildTrackLayoutsOptions {
   linePointOverrides?: Readonly<Record<string, WaveformPoint[]>>
   hideSecondaryLabels: boolean
   yAxisLabelX: number
+  yAxisSlots?: readonly YAxisSlot[]
   showCompactEmptyTracks: boolean
 }
 
@@ -117,8 +124,10 @@ export function buildTrackLayouts(options: BuildTrackLayoutsOptions): TrackLayou
     ).map((group) =>
       !group.fixed && configuredYDomain ? { ...group, domain: configuredYDomain } : group,
     )
+    const sideIndexes = { left: 0, right: 0 }
     const sideOffsets = { left: 0, right: 0 }
     const yAxes: WaveformYAxisLayout[] = yAxisGroups.map((group) => {
+      const sideIndex = sideIndexes[group.side]++
       const tickCount = resolveYAxisTickCount(cell.plotHeight, options.yAxisSplitNumber)
       const niceCount = Math.max(1, tickCount - 1)
       const scale = scaleLinear(group.domain, [cell.plotHeight, 0])
@@ -144,11 +153,22 @@ export function buildTrackLayouts(options: BuildTrackLayoutsOptions): TrackLayou
         Y_AXIS_LABEL_GAP +
         Y_AXIS_LABEL_BAND_WIDTH +
         Y_AXIS_OUTER_PADDING
-      const x = group.side === 'left' ? -sideOffsets.left : cell.width + sideOffsets.right
+      const slot = options.yAxisSlots?.find(
+        (candidate) => candidate.side === group.side && candidate.sideIndex === sideIndex,
+      )
+      const x = slot
+        ? (group.side === 'left' ? 0 : cell.width) + slot.axisOffset
+        : group.side === 'left'
+          ? -sideOffsets.left
+          : cell.width + sideOffsets.right
       const labelDistance =
         tickTextWidth + Y_AXIS_TICK_PADDING + Y_AXIS_LABEL_GAP + Y_AXIS_LABEL_BAND_WIDTH / 2
-      const labelX = x + (group.side === 'left' ? -labelDistance : labelDistance)
-      sideOffsets[group.side] += clearance
+      const labelX =
+        (slot
+          ? (group.side === 'left' ? 0 : cell.width) + slot.labelOffset
+          : x + (group.side === 'left' ? -labelDistance : labelDistance)) -
+        (group.side === 'right' ? Y_AXIS_RIGHT_LABEL_OFFSET : 0)
+      if (!slot) sideOffsets[group.side] += clearance
       return {
         index: group.index,
         side: group.side,

package/src/components/core/useWaveformLayout.ts

@@ -27,7 +27,7 @@ import {
 import {
   buildTrackLayouts,
   axisTextMetrics,
-  measureTrackYAxisClearance,
+  buildYAxisSlots,
   resolveYAxisSeriesGroups,
 } from './layout'
 import type { DisplaySeries, DisplayTrack, TrackLayout } from './types'
@@ -169,33 +169,24 @@ export function useWaveformLayout(context: LayoutContext) {
           : 0,
     ),
   )
-  const multiAxisClearance = computed(() =>
-    chartTracks.value.reduce(
-      (maximum, track) => {
-        const clearance = measureTrackYAxisClearance(
-          track,
-          props.overlayMode,
-          props.yDomain,
-          props.yDomains,
-          props.axes?.y?.splitNumber,
-          props.axes?.y?.nice !== false,
-        )
-        return {
-          left: Math.max(maximum.left, clearance.left),
-          right: Math.max(maximum.right, clearance.right),
-        }
-      },
-      { left: 0, right: 0 },
+  const yAxisSlots = computed(() =>
+    buildYAxisSlots(
+      layoutTracks.value.filter((track) => track.visibleSeries.length > 0),
+      props.overlayMode,
+      props.yDomain,
+      props.yDomains,
+      props.axes?.y?.splitNumber,
+      props.axes?.y?.nice !== false,
     ),
   )
   const resolvedChartLeftMargin = computed(() =>
     props.overlayMode === 'multi-axis'
-      ? Math.max(chartLeftMargin.value, multiAxisClearance.value.left)
+      ? Math.max(chartLeftMargin.value, yAxisSlots.value.clearance.left)
       : chartLeftMargin.value,
   )
   const chartRightMargin = computed(() =>
     props.overlayMode === 'multi-axis'
-      ? Math.max(margin.right, multiAxisClearance.value.right)
+      ? Math.max(margin.right, yAxisSlots.value.clearance.right)
       : margin.right,
   )
   const innerWidth = computed(() =>
@@ -212,7 +203,7 @@ export function useWaveformLayout(context: LayoutContext) {
     return {
       horizontalGap:
         props.overlayMode === 'multi-axis' && hasMultipleColumns && hasVisibleWaveformData.value
-          ? Math.max(baseGap, multiAxisClearance.value.left + multiAxisClearance.value.right)
+          ? Math.max(baseGap, yAxisSlots.value.clearance.left + yAxisSlots.value.clearance.right)
           : hasMultipleColumns && hasVisibleWaveformData.value
             ? hasYAxisLabels.value && canReserveLabelClearance
               ? fullGap
@@ -323,7 +314,10 @@ export function useWaveformLayout(context: LayoutContext) {
       rendering: renderingOptions.value,
       linePointOverrides: linePointOverrides?.value,
       hideSecondaryLabels: isCleanView.value || yAxisLayout.value.hideSecondaryLabels,
-      yAxisLabelX: yAxisMetrics.value.labelCenterX,
+      yAxisLabelX:
+        yAxisSlots.value.slots.find((slot) => slot.side === 'left' && slot.sideIndex === 0)
+          ?.labelOffset ?? yAxisMetrics.value.labelCenterX,
+      yAxisSlots: props.overlayMode === 'multi-axis' ? yAxisSlots.value.slots : undefined,
       showCompactEmptyTracks: props.displayMode === 'compact' && hasWaveformData.value,
     }),
   )

package/src/components/core/yAxisConstants.ts

@@ -3,6 +3,7 @@ export const Y_AXIS_TICK_PADDING = 7
 export const Y_AXIS_OUTER_PADDING = 4
 export const Y_AXIS_LABEL_GAP = 0
 export const Y_AXIS_LABEL_BAND_WIDTH = 12
+export const Y_AXIS_RIGHT_LABEL_OFFSET = 10
 
 export function resolveYAxisSides(axisCount: number): Array<'left' | 'right'> {
   if (axisCount >= 4) return ['left', 'left', 'right', 'right']

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/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',