waveform-analysis 0.1.75 → 0.1.77

package/src/components/interaction/useWaveformZoom.ts

@@ -1,23 +1,13 @@
-import {
-  scaleLinear,
-  select,
-  zoom,
-  zoomIdentity,
-  zoomTransform,
-  type D3ZoomEvent,
-  type ZoomBehavior,
-  type ZoomTransform,
-} from 'd3'
+import { pointer, scaleLinear, select, zoomIdentity, zoomTransform, type ZoomTransform } from 'd3'
 import type { ComputedRef, ShallowRef } from 'vue'
 
-import { hasMinimumVisibleXValues } from '../../core/rendering'
-import { WHEEL_ZOOM_DEBOUNCE_MS, ZOOM_CONSTRAINTS } from '../core/constants'
+import { WHEEL_ZOOM_DEBOUNCE_MS } from '../core/constants'
 import type { TrackLayout } from '../core/types'
 import type { ResolvedWaveformChartProps, WaveformChartEmit } from '../core/waveformChartTypes'
 import { useAnimationFrameThrottle } from '../utils/useAnimationFrameThrottle'
-import { constrainViewportZoom, remotePanBoundary } from './remoteViewport'
+import { resolveStepZoomDomain, sameZoomDomain } from './stepZoom'
 import { normalizeIntegerZoomDomain } from './integerZoom'
-import { resolveMinimumZoomSpan, transformForDomain, type ZoomSeriesGroup } from './zoomConstraints'
+import { transformForDomain, type ZoomSeriesGroup } from './zoomConstraints'
 import {
   emitIndependentWheelZoomEnds,
   emitSharedWheelZoomEnd,
@@ -57,16 +47,13 @@ export function useWaveformZoom(context: ZoomContext) {
     initialXDomain,
     sharedZoomDomain,
     innerWidth,
-    innerHeight,
     hasChartArea,
     isZoomMode,
     isPresentationMode,
     resolveInitialTrackDomain,
     cancelPendingHover,
   } = context
-  const zoomBehaviors = new Map<number | 'shared', ZoomBehavior<SVGRectElement, unknown>>()
   const zoomThrottle = useAnimationFrameThrottle()
-  let synchronizingZoomTransform = false
   let pendingSharedZoomTransform: ZoomTransform | null = null
   let pendingSharedZoomGesture: ZoomGestureKind | null = null
   let lastSharedZoomGesture: ZoomGestureKind | null = null
@@ -75,11 +62,10 @@ export function useWaveformZoom(context: ZoomContext) {
   const lastIndependentWheelSeriesIds = new Map<string, string[]>()
   let wheelZoomEndTimer: ReturnType<typeof setTimeout> | undefined
   let preservePendingWheelDuringDataRebind = false
-  let zoomBindingEpoch = 0
 
   const scheduleZoomCommit = () => zoomThrottle.schedule(commitPendingZoom)
-  const handleSharedZoom = (event: D3ZoomEvent<SVGRectElement, unknown>) => {
-    if (synchronizingZoomTransform || isPresentationMode.value) return
+  const handleSharedZoom = (event: { transform: ZoomTransform }) => {
+    if (isPresentationMode.value) return
     cancelPendingHover()
     pendingSharedZoomTransform = event.transform
     pendingSharedZoomGesture = 'wheel'
@@ -91,11 +77,8 @@ export function useWaveformZoom(context: ZoomContext) {
     emit('zoom-intent', { start, end, gesture: 'wheel' })
     scheduleZoomCommit()
   }
-  const handleIndependentZoom = (
-    event: D3ZoomEvent<SVGRectElement, unknown>,
-    trackIndex: number,
-  ) => {
-    if (synchronizingZoomTransform || isPresentationMode.value) return
+  const handleIndependentZoom = (event: { transform: ZoomTransform }, trackIndex: number) => {
+    if (isPresentationMode.value) return
     cancelPendingHover()
     pendingIndependentZoomTransforms.set(trackIndex, event.transform)
     pendingIndependentZoomGestures.set(trackIndex, 'wheel')
@@ -166,16 +149,6 @@ export function useWaveformZoom(context: ZoomContext) {
     emitSharedWheelZoomEnd(emit, sharedZoomDomain.value, trackLayouts.value)
     lastSharedZoomGesture = null
   }
-  const flushPendingZoom = () => {
-    zoomThrottle.flush()
-    commitPendingZoom()
-    if (lastSharedZoomGesture === 'wheel' || lastIndependentWheelSeriesIds.size) return
-    emitZoomEnd()
-  }
-  const handleD3ZoomEnd = (bindingEpoch: number) => {
-    if (bindingEpoch !== zoomBindingEpoch) return
-    flushPendingZoom()
-  }
   function scheduleWheelZoomEnd() {
     if (wheelZoomEndTimer !== undefined) clearTimeout(wheelZoomEndTimer)
     wheelZoomEndTimer = setTimeout(() => {
@@ -207,81 +180,50 @@ export function useWaveformZoom(context: ZoomContext) {
     }
   }
   const clearZoomBindings = (preservePendingWheel = false) => {
-    zoomBindingEpoch += 1
     if (!preservePendingWheel) cancelPendingZoom()
     svgElement.value
       ?.querySelectorAll<SVGRectElement>('.waveform-chart__overlay')
       .forEach((overlay) => select(overlay).on('.zoom', null))
-    zoomBehaviors.clear()
   }
-  const resolveMaximumZoomScale = (
-    domain: [number, number],
-    groups: readonly ZoomSeriesGroup[],
-  ): number => {
-    const domainSpan = Math.abs(domain[1] - domain[0])
-    if (!Number.isFinite(domainSpan) || domainSpan <= 0) return ZOOM_CONSTRAINTS.MIN_SCALE
-    const minimumSpan = resolveMinimumZoomSpan(domain, groups, props)
-    return Math.max(
-      ZOOM_CONSTRAINTS.MIN_SCALE,
-      minimumSpan > 0 ? domainSpan / minimumSpan : Number.POSITIVE_INFINITY,
-    )
-  }
-  const constrainTransform = (
-    transform: ZoomTransform,
-    domain: [number, number],
+  const bindWheelZoom = (
+    overlay: SVGRectElement,
+    baseDomain: [number, number],
     width: number,
     groups: readonly ZoomSeriesGroup[],
-  ): ZoomTransform => {
-    const requested = transform.rescaleX(scaleLinear(domain, [0, width])).domain() as [
-      number,
-      number,
-    ]
-    return transformForDomain(
-      constrainViewportZoom(requested, domain, groups, props),
-      domain,
-      width,
-    )
-  }
-  const canZoomTrack = (track: TrackLayout): boolean => {
-    const minimum = Number(props.minVisiblePoints)
-    return hasMinimumVisibleXValues(
-      track.seriesList,
-      track.xScale.domain() as [number, number],
-      Number.isFinite(minimum) && minimum > 0 ? Math.ceil(minimum) + 1 : minimum,
-    )
-  }
-  const canZoomSharedTracks = (): boolean => {
-    const tracks = trackLayouts.value.filter((track) => track.hasVisibleSeries)
-    return tracks.length > 0 && tracks.every(canZoomTrack)
-  }
-  const resolveMinimumZoomScale = (domain: [number, number]): number => {
-    const boundary = remotePanBoundary(props)
-    return boundary
-      ? Math.min(1, (domain[1] - domain[0]) / (boundary[1] - boundary[0]))
-      : ZOOM_CONSTRAINTS.MIN_SCALE
-  }
-  const canHandleWheelZoom = (event: Event, canZoomIn: boolean, minimumScale: number): boolean => {
-    if (event.type !== 'wheel') return false
-    const deltaY = (event as WheelEvent).deltaY
-    const currentScale = zoomTransform(event.currentTarget as Element).k
-
-    // 放大操作：需要检查是否还有足够的数据点支持继续放大
-    if (deltaY < 0) return canZoomIn
-
-    // 缩小操作：只要当前缩放级别大于最小比例就允许
-    // 即使已达到最小可见点数限制，用户也应该能够缩小视图
-    if (deltaY > 0) {
-      // 使用小的容差避免浮点精度问题导致无法缩小到边界
-      const scaleTolerance = 1e-6
-      return currentScale > minimumScale * (1 + scaleTolerance)
-    }
-
-    return false
+    transform: ZoomTransform,
+    trackIndex?: number,
+  ) => {
+    select(overlay)
+      .property('__zoom', transform)
+      .on(
+        'wheel.zoom',
+        (event: WheelEvent) => {
+          if (!Number.isFinite(event.deltaY) || event.deltaY === 0) return
+          const current = zoomTransform(overlay)
+            .rescaleX(scaleLinear(baseDomain, [0, width]))
+            .domain() as [number, number]
+          const next = resolveStepZoomDomain(
+            current,
+            event.deltaY < 0 ? 'zoom-in' : 'zoom-out',
+            baseDomain,
+            groups,
+            props,
+            pointer(event, overlay)[0] / width,
+          )
+          if (sameZoomDomain(current, next)) return
+          event.preventDefault()
+          event.stopImmediatePropagation()
+          const transform = transformForDomain(next, baseDomain, width)
+          select(overlay).property('__zoom', transform)
+          if (trackIndex === undefined) handleSharedZoom({ transform })
+          else handleIndependentZoom({ transform }, trackIndex)
+        },
+        { passive: false },
+      )
   }
   const configureZoom = () => {
     const preservePendingWheel = preservePendingWheelDuringDataRebind
     clearZoomBindings(preservePendingWheel)
-    const bindingEpoch = zoomBindingEpoch
     if (
       isPresentationMode.value ||
       !props.zoomable ||
@@ -299,35 +241,14 @@ export function useWaveformZoom(context: ZoomContext) {
         if (!overlay) return
         const dataDomain = resolveInitialTrackDomain(track)
         const groups = [track.seriesList]
-        const minimumScale = resolveMinimumZoomScale(dataDomain)
-        const behavior = zoom<SVGRectElement, unknown>()
-          .filter((event) => {
-            const currentTrack =
-              trackLayouts.value.find((item) => item.index === track.index) ?? track
-            return canHandleWheelZoom(event, canZoomTrack(currentTrack), minimumScale)
-          })
-          .scaleExtent([minimumScale, resolveMaximumZoomScale(dataDomain, groups)])
-          .constrain((transform) => constrainTransform(transform, dataDomain, track.width, groups))
-          .extent([
-            [0, 0],
-            [track.width, track.height],
-          ])
-          .translateExtent([
-            [0, 0],
-            [track.width, track.height],
-          ])
-          .on('zoom', (event) => handleIndependentZoom(event, track.index))
-          .on('end', () => handleD3ZoomEnd(bindingEpoch))
-        zoomBehaviors.set(track.index, behavior)
-        synchronizingZoomTransform = true
-        try {
-          select(overlay)
-            .call(behavior)
-            .on('dblclick.zoom', null)
-            .call(behavior.transform, independentTransforms.value[track.index] ?? zoomIdentity)
-        } finally {
-          synchronizingZoomTransform = false
-        }
+        bindWheelZoom(
+          overlay,
+          dataDomain,
+          track.width,
+          groups,
+          independentTransforms.value[track.index] ?? zoomIdentity,
+          track.index,
+        )
       })
       return
     }
@@ -336,40 +257,12 @@ export function useWaveformZoom(context: ZoomContext) {
     const groups = trackLayouts.value
       .filter((track) => track.hasVisibleSeries)
       .map((track) => track.seriesList)
-    const minimumScale = resolveMinimumZoomScale(initialXDomain.value)
-    const behavior = zoom<SVGRectElement, unknown>()
-      .filter((event) => canHandleWheelZoom(event, canZoomSharedTracks(), minimumScale))
-      .scaleExtent([minimumScale, resolveMaximumZoomScale(initialXDomain.value, groups)])
-      .constrain((transform) =>
-        constrainTransform(transform, initialXDomain.value, innerWidth.value, groups),
-      )
-      .extent([
-        [0, 0],
-        [innerWidth.value, innerHeight.value],
-      ])
-      .translateExtent([
-        [0, 0],
-        [innerWidth.value, innerHeight.value],
-      ])
-      .on('zoom', handleSharedZoom)
-      .on('end', () => handleD3ZoomEnd(bindingEpoch))
-    zoomBehaviors.set('shared', behavior)
-    synchronizingZoomTransform = true
-    try {
-      select(overlay)
-        .call(behavior)
-        .on('dblclick.zoom', null)
-        .call(behavior.transform, sharedTransform.value)
-    } finally {
-      synchronizingZoomTransform = false
-    }
+    bindWheelZoom(overlay, initialXDomain.value, innerWidth.value, groups, sharedTransform.value)
   }
 
   return {
     cancelPendingZoom,
     clearZoomBindings,
-    canZoomTrack,
-    canZoomSharedTracks,
     configureZoom,
     prepareForDataChange,
   }

package/src/components/interaction/zoomConstraints.ts

@@ -73,7 +73,7 @@ export function resolveMinimumZoomSpan(
   groups: readonly ZoomSeriesGroup[],
   options: ZoomConstraintOptions,
 ): number {
-  const normalized = alignIntegerZoomDomain(normalizedBoundary(boundary), options)
+  const normalized = normalizedBoundary(boundary)
   const boundarySpan = normalized[1] - normalized[0]
   if (!Number.isFinite(boundarySpan) || boundarySpan <= 0) return 0
   const configuredSpan =
@@ -89,8 +89,7 @@ export function resolveMinimumZoomSpan(
       : options.maxZoomScale !== null && configuredSpan === 0 && required === 0
         ? boundarySpan / ZOOM_CONSTRAINTS.DEFAULT_MAX_SCALE
         : 0
-  const integerSpan = options.integerZoom ? (options.timeUnit === 's' ? 1 : 0.001) : 0
-  return Math.max(configuredSpan, pointSpan, scaleSpan, integerSpan)
+  return Math.max(configuredSpan, pointSpan, scaleSpan)
 }
 
 function expandToMinimumPoints(
@@ -141,7 +140,7 @@ export function constrainZoomDomain(
   groups: readonly ZoomSeriesGroup[],
   options: ZoomConstraintOptions,
 ): [number, number] {
-  const normalized = alignIntegerZoomDomain(normalizedBoundary(boundary), options)
+  const normalized = normalizedBoundary(boundary)
   const boundarySpan = normalized[1] - normalized[0]
   if (!Number.isFinite(boundarySpan) || boundarySpan <= 0) return normalized
   if (Math.abs(domain[1] - domain[0]) >= boundarySpan * (1 - 1e-12)) return normalized
@@ -159,7 +158,8 @@ export function constrainZoomDomain(
   const span = Math.max(minimumSpan, Math.min(boundarySpan, expanded[1] - expanded[0]))
   const center = (expanded[0] + expanded[1]) / 2
   const start = Math.max(normalized[0], Math.min(center - span / 2, normalized[1] - span))
-  return alignIntegerZoomDomain([start, start + span], options)
+  const aligned = alignIntegerZoomDomain([start, start + span], options)
+  return [Math.max(normalized[0], aligned[0]), Math.min(normalized[1], aligned[1])]
 }
 
 export function transformForDomain(

package/src/components/rendering/WaveformSeriesLayer.vue

@@ -7,7 +7,6 @@ import { waveformLineDasharray, waveformPointSeriesPath } from './seriesStyle'
 
 const props = defineProps<{
   track: TrackLayout
-  paginationOpacity?: number
   clipPathId: string
 }>()
 
@@ -53,7 +52,7 @@ const renderedSeriesPaths = computed<RenderedSeriesPath[]>(() =>
     <g
       v-for="seriesPath in renderedSeriesPaths"
       :key="seriesPath.presentationKey ?? seriesPath.series.id"
-      :opacity="(seriesPath.opacity ?? 1) * (paginationOpacity ?? 1)"
+      :opacity="seriesPath.opacity ?? 1"
       :clip-path="seriesPath.animationClip ? `url(#${seriesPath.animationClip.id})` : undefined"
       class="waveform-track__series-item waveform-chart__series"
       :data-series-id="seriesPath.series.id"

package/src/components/rendering/WaveformTrack.vue

@@ -12,7 +12,6 @@ import WaveformTrackBackdrop from './WaveformTrackBackdrop.vue'
 
 interface Props {
   track: TrackLayout
-  paginationOpacity?: number
   clipPathId: string
   innerWidth: number
   zoomable: boolean
@@ -137,11 +136,7 @@ const frameInset = computed(() =>
       aria-hidden="true"
     />
 
-    <WaveformSeriesLayer
-      :track="track"
-      :clip-path-id="clipPathId"
-      :pagination-opacity="paginationOpacity"
-    />
+    <WaveformSeriesLayer :track="track" :clip-path-id="clipPathId" />
     <WaveformZeroLines
       :track="track"
       :clip-path-id="clipPathId"

package/src/core/data.ts

@@ -215,10 +215,11 @@ function normalizedSeriesOptions(
 /** Internal normalized series which preserves compact TypedArray storage for chart rendering. */
 export function normalizeWaveformSeriesSources(
   data: WaveformData,
+  retainEmpty = false,
 ): NormalizedWaveformSourceSeries[] {
   if (data.kind !== 'series') {
     const source = createWaveformPointSource(data, normalizeWaveformData)
-    return source.length
+    return source.length || retainEmpty
       ? [
           {
             ...normalizedSeriesOptions('series-0', { name: '' }),
@@ -239,7 +240,9 @@ export function normalizeWaveformSeriesSources(
     }
     usedIds.add(uniqueId)
     const source = createWaveformPointSource(series.data, normalizeWaveformData)
-    return source.length ? [{ ...normalizedSeriesOptions(uniqueId, series), source }] : []
+    return source.length || retainEmpty
+      ? [{ ...normalizedSeriesOptions(uniqueId, series), source }]
+      : []
   })
 }
 

package/src/data/simulatedWaveforms.ts

@@ -1,6 +1,5 @@
 import type { WaveformData, WaveformPoint, WaveformSeries } from '../types'
 import { recordedDampedPoints } from './recordedDampedWaveform'
-import { sx2Channel } from './sx2Channel'
 
 const POINT_COUNT = 1_000
 const START_TIME = -5
@@ -177,15 +176,6 @@ const seriesDefinitions: SimulatedSeriesDefinition[] = [
     pointType: 'none',
     signal: (time) => 6e-9 * Math.exp(-(time + 5) * 0.2) * Math.cos(TWO_PI * 0.8 * time),
   },
-  {
-    id: `recorded-${sx2Channel.chnl_id}`,
-    shotNo: String(sx2Channel.shot),
-    name: sx2Channel.chnl,
-    unit: sx2Channel.dat_unit,
-    lineType: 'linear',
-    pointType: 'none',
-    signal: sx2Channel.data.map((value, index) => [sx2Channel.time[index]!, value]),
-  },
 ]
 
 export function createSimulatedWaveformData(trackCount?: number): WaveformData {

package/src/demo/DemoChartHost.vue

@@ -1,15 +1,20 @@
 <script setup lang="ts">
-import { ref } from 'vue'
+import { computed, ref } from 'vue'
 
 import { WaveformChart } from '../components'
 import type { DemoChartModel } from './types'
+import { applyXDomainStrategy } from '../components/core/xDomain'
 
 const model = defineModel<DemoChartModel>('model', { required: true })
+const xDomainStrategy = { type: 'integer-ms' as const, includeExplicit: true }
+const panXDomain = computed(() =>
+  applyXDomainStrategy(model.value.recordDomain, xDomainStrategy, true),
+)
 
 const waveformChartRef = ref<{ resetViewport: (trackIndex?: number) => void }>()
 
-function resetViewport() {
-  waveformChartRef.value?.resetViewport()
+function resetViewport(trackIndex?: number) {
+  waveformChartRef.value?.resetViewport(trackIndex)
 }
 
 defineExpose({ resetViewport })
@@ -17,6 +22,17 @@ defineExpose({ resetViewport })
 
 <template>
   <section class="chart-panel">
+    <div
+      v-if="model.loading || model.errors.length"
+      class="remote-window-status"
+      aria-live="polite"
+    >
+      <span v-if="model.loading" role="status">正在加载当前时间范围…</span>
+      <template v-if="model.errors.length">
+        <span role="alert">{{ model.errors.join('；') }}</span>
+        <button type="button" :disabled="model.loading" @click="model.retry()">重试</button>
+      </template>
+    </div>
     <WaveformChart
       ref="waveformChartRef"
       layout-preset="edge-compact"
@@ -25,15 +41,19 @@ defineExpose({ resetViewport })
       v-model:hidden-series-ids="model.hiddenSeriesIds"
       :data="model.data"
       :min-visible-points="2"
+      :min-zoom-span="model.minZoomSpan"
+      :max-zoom-scale="null"
+      :pan-x-domain="panXDomain"
       :integer-zoom="model.integerZoom"
       :initial-x-domain="model.initialXDomain"
-      :x-domain-strategy="{ type: 'integer-ms', includeExplicit: true }"
+      :x-domain-strategy="xDomainStrategy"
       :display-mode="model.displayMode"
       :overlay-mode="model.overlayMode"
       :grid="{
         rowCount: model.rowCount,
         columnCount: model.columnCount,
         showPagination: true,
+        fillIncompleteLastRow: true,
         trackLines: model.gridTrackLines,
       }"
       :title="model.title"
@@ -55,8 +75,33 @@ defineExpose({ resetViewport })
       v-model:interaction-mode="model.interactionMode"
       :toolbar="model.toolbarVisible"
       pannable
+      @zoom-intent="model.handleZoomIntent"
+      @zoom-change="model.handleZoomChange"
       @zoom-end="model.handleZoomEnd"
+      @pan-end="model.handlePanEnd"
       @zoom-reset="model.resetWaveformViewport"
     />
   </section>
 </template>
+
+<style scoped>
+.chart-panel {
+  position: relative;
+}
+
+.remote-window-status {
+  position: absolute;
+  top: 6px;
+  right: 12px;
+  z-index: 2;
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  max-width: calc(100% - 24px);
+  padding: 6px 10px;
+  border: 1px solid #d0d5dd;
+  border-radius: 4px;
+  background: #fff;
+  color: #344054;
+}
+</style>

package/src/demo/remoteWaveformLoader.ts

@@ -0,0 +1,114 @@
+import type { InjectionKey } from 'vue'
+import { normalizeWaveformSeries } from '../core'
+import { normalizeWaveformSeriesSources } from '../core/data'
+import type { WaveformData } from '../types'
+
+export interface RemoteWindowRequest {
+  start: number
+  end: number
+  seriesIds?: string[]
+}
+
+export type RemoteWindowLoader = (
+  request: RemoteWindowRequest,
+  signal: AbortSignal,
+) => Promise<WaveformData>
+
+export const remoteWindowLoaderKey: InjectionKey<RemoteWindowLoader> = Symbol('remoteWindowLoader')
+
+export interface MockWindowOptions {
+  delayMs?: number | ((request: RemoteWindowRequest) => number)
+  empty?: boolean | ((request: RemoteWindowRequest) => boolean)
+  fail?: boolean | ((request: RemoteWindowRequest) => boolean)
+}
+
+/** Preserve series identities even when a window has no samples. */
+export function selectWaveformWindow(
+  data: WaveformData,
+  request: RemoteWindowRequest,
+  empty = false,
+): WaveformData {
+  const series = normalizeWaveformSeriesSources(data, true)
+  const selected = request.seriesIds ? new Set(request.seriesIds) : undefined
+  const windows = series
+    .filter((item) => !selected || selected.has(item.id))
+    .map(({ source, ...item }) => {
+      const range = source.visibleRange([request.start, request.end])
+      return {
+        ...item,
+        data: {
+          kind: 'points' as const,
+          points: empty ? [] : source.pointsInRange(range.start, range.end),
+        },
+      }
+    })
+  return data.kind === 'series'
+    ? { kind: 'series', series: windows }
+    : (windows[0]?.data ?? { kind: 'points', points: [] })
+}
+
+export function mergeWaveformWindow(
+  current: WaveformData,
+  response: WaveformData,
+  seriesIds?: string[],
+): WaveformData {
+  if (!seriesIds || current.kind !== 'series' || response.kind !== 'series') return response
+  const selected = new Set(seriesIds)
+  const byId = new Map(response.series.map((series) => [series.id, series]))
+  return {
+    kind: 'series',
+    series: current.series.map((series) =>
+      series.id && selected.has(series.id) ? (byId.get(series.id) ?? series) : series,
+    ),
+  }
+}
+
+/** Metadata is derived from the complete record, never from a loaded window. */
+export function waveformRecordMetadata(data: WaveformData) {
+  let minimum = Infinity
+  let maximum = -Infinity
+  let minZoomSpan = Infinity
+  for (const series of normalizeWaveformSeries(data)) {
+    for (let index = 0; index < series.points.length; index++) {
+      const x = series.points[index].x
+      minimum = Math.min(minimum, x)
+      maximum = Math.max(maximum, x)
+      const previous = series.points[index - 1]?.x
+      if (previous !== undefined && x > previous) {
+        minZoomSpan = Math.min(minZoomSpan, x - previous)
+      }
+    }
+  }
+  return {
+    domain: (minimum < maximum ? [minimum, maximum] : [0, 1]) as [number, number],
+    minZoomSpan: Number.isFinite(minZoomSpan) ? minZoomSpan : undefined,
+  }
+}
+
+export function createMockWindowLoader(
+  source: () => WaveformData,
+  options: MockWindowOptions = {},
+): RemoteWindowLoader {
+  return (request, signal) =>
+    new Promise((resolve, reject) => {
+      const abort = () => {
+        clearTimeout(timer)
+        signal.removeEventListener('abort', abort)
+        reject(new DOMException('Request cancelled', 'AbortError'))
+      }
+      const delay =
+        typeof options.delayMs === 'function' ? options.delayMs(request) : options.delayMs
+      const timer = setTimeout(() => {
+        signal.removeEventListener('abort', abort)
+        const fail = typeof options.fail === 'function' ? options.fail(request) : options.fail
+        if (fail) {
+          reject(new Error('模拟数据加载失败'))
+          return
+        }
+        const empty = typeof options.empty === 'function' ? options.empty(request) : options.empty
+        resolve(selectWaveformWindow(source(), request, empty))
+      }, delay ?? 80)
+      signal.addEventListener('abort', abort, { once: true })
+      if (signal.aborted) abort()
+    })
+}

package/src/demo/types.ts

@@ -14,7 +14,9 @@ import type {
   WaveformTitleOptions,
   WaveformZeroLineOptions,
   WaveformZoomEndPayload,
+  WaveformZoomIntentPayload,
 } from '../components'
+import type { WaveformZoomResetPayload, WaveformPanEndPayload } from '../types'
 import type { DemoXAxisLabelFormat, DemoXAxisLabelTimeZone } from './useDemoXAxisLabelControls'
 
 interface SelectOption<T> {
@@ -97,6 +99,11 @@ export interface DemoChartModel {
   toolbarVisible: boolean
   data: WaveformData
   initialXDomain?: [number, number]
+  recordDomain: [number, number]
+  minZoomSpan?: number
+  loading: boolean
+  errors: string[]
+  retry: () => Promise<void[]>
   displayMode: WaveformDisplayMode
   overlayMode: WaveformOverlayMode
   rowCount: number
@@ -120,5 +127,8 @@ export interface DemoChartModel {
   interactionMode: WaveformInteractionMode
   hiddenSeriesIds: string[]
   handleZoomEnd: (payload: WaveformZoomEndPayload) => void | Promise<void>
-  resetWaveformViewport: () => void
+  handleZoomIntent: (payload: WaveformZoomIntentPayload) => void
+  handleZoomChange: (domain: [number, number]) => void
+  handlePanEnd: (payload: WaveformPanEndPayload) => void | Promise<void>
+  resetWaveformViewport: (payload?: WaveformZoomResetPayload) => void | Promise<void>
 }