waveform-analysis 0.1.75 → 0.1.76

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>
 }

package/src/demo/useRemoteWaveformWindow.ts

@@ -0,0 +1,229 @@
+import { computed, onScopeDispose, shallowRef, watch, type Ref } from 'vue'
+import type {
+  WaveformData,
+  WaveformPanEndPayload,
+  WaveformZoomEndPayload,
+  WaveformZoomIntentPayload,
+  WaveformZoomResetPayload,
+} from '../types'
+import {
+  createMockWindowLoader,
+  mergeWaveformWindow,
+  selectWaveformWindow,
+  waveformRecordMetadata,
+  type RemoteWindowLoader,
+  type RemoteWindowRequest,
+} from './remoteWaveformLoader'
+
+interface WindowState {
+  request: RemoteWindowRequest
+  version: number
+  controller?: AbortController
+  loading: boolean
+  error?: string
+}
+
+interface RemoteWindowOptions {
+  loadWindow?: RemoteWindowLoader
+  resetViewport?: (trackIndex?: number) => void
+}
+
+type WindowPayload = WaveformPanEndPayload | WaveformZoomEndPayload
+
+export function useRemoteWaveformWindow(
+  source: Ref<WaveformData>,
+  options: RemoteWindowOptions = {},
+) {
+  const metadata = computed(() => waveformRecordMetadata(source.value))
+  const recordDomain = computed(() => metadata.value.domain)
+  const initialXDomain = computed(() => recordDomain.value)
+  const minZoomSpan = computed(() => metadata.value.minZoomSpan)
+  const chartData = shallowRef<WaveformData>(
+    selectWaveformWindow(
+      source.value,
+      { start: recordDomain.value[0], end: recordDomain.value[1] },
+      true,
+    ),
+  )
+  const states = shallowRef(new Map<string, WindowState>())
+  const loadWindow = options.loadWindow ?? createMockWindowLoader(() => source.value)
+  let disposed = false
+  let intentTarget: string | undefined
+  let intentSequence = 0
+  const pendingCommands = new Map<string, object>()
+
+  const keyFor = (seriesIds?: string[]) =>
+    seriesIds?.length ? JSON.stringify([...seriesIds].sort()) : 'shared'
+  const publish = () => (states.value = new Map(states.value))
+
+  function cancel(key: string) {
+    const state = states.value.get(key)
+    if (!state) return
+    state.version++
+    state.controller?.abort()
+    state.controller = undefined
+    state.loading = false
+    state.error = undefined
+  }
+
+  function cancelAll() {
+    for (const key of states.value.keys()) cancel(key)
+    publish()
+  }
+
+  function handleZoomIntent(payload: WaveformZoomIntentPayload) {
+    const key = keyFor(payload.seriesIds)
+    if (key === 'shared') pendingCommands.clear()
+    else pendingCommands.delete(key)
+    if (key === 'shared') cancelAll()
+    else {
+      cancel('shared')
+      cancel(key)
+    }
+    const previous = states.value.get(key)
+    states.value.set(key, {
+      request: { start: payload.start, end: payload.end, seriesIds: payload.seriesIds },
+      version: previous?.version ?? 0,
+      loading: false,
+    })
+    publish()
+    // Command intent/change/end arrive synchronously per target. Scope their
+    // changes so the next target cannot cancel a valid request in the same batch.
+    intentTarget = key
+    const sequence = ++intentSequence
+    queueMicrotask(() => {
+      if (sequence === intentSequence) intentTarget = undefined
+    })
+  }
+
+  function handleZoomChange(domain: [number, number]) {
+    if (intentTarget) {
+      cancel(intentTarget)
+      publish()
+    } else {
+      cancelAll()
+      // This event has no target metadata. It must never start an unscoped
+      // request in independent mode; pan-end supplies the final target.
+      for (const state of states.value.values()) {
+        state.request = { ...state.request, start: domain[0], end: domain[1] }
+      }
+    }
+  }
+
+  async function load(payload: WindowPayload) {
+    if (disposed) return
+    const key = keyFor(payload.seriesIds)
+    if (key === 'shared') cancelAll()
+    else cancel('shared')
+    cancel(key)
+    const controller = new AbortController()
+    const state: WindowState = {
+      request: {
+        start: payload.start,
+        end: payload.end,
+        ...(payload.seriesIds?.length ? { seriesIds: [...payload.seriesIds] } : {}),
+      },
+      version: (states.value.get(key)?.version ?? 0) + 1,
+      controller,
+      loading: true,
+    }
+    const version = state.version
+    const record = source.value
+    states.value.set(key, state)
+    publish()
+    const current = () =>
+      !disposed &&
+      source.value === record &&
+      !controller.signal.aborted &&
+      states.value.get(key) === state &&
+      state.version === version
+    try {
+      const response = await loadWindow(state.request, controller.signal)
+      if (!current()) return
+      chartData.value = mergeWaveformWindow(chartData.value, response, state.request.seriesIds)
+    } catch (error) {
+      if (!current()) return
+      state.error = error instanceof Error ? error.message : '数据加载失败'
+    } finally {
+      if (current()) {
+        state.loading = false
+        state.controller = undefined
+        publish()
+      }
+    }
+  }
+
+  function resetWaveformViewport(payload?: WaveformZoomResetPayload) {
+    pendingCommands.clear()
+    if (!payload?.seriesIds?.length) {
+      cancelAll()
+      states.value = new Map()
+    }
+    options.resetViewport?.(payload?.trackIndex)
+    return load({
+      start: initialXDomain.value[0],
+      end: initialXDomain.value[1],
+      seriesIds: payload?.seriesIds,
+    })
+  }
+
+  function retry() {
+    return Promise.all(
+      [...states.value.values()].filter((state) => state.error).map((state) => load(state.request)),
+    )
+  }
+
+  async function handleZoomEnd(payload: WaveformZoomEndPayload) {
+    if (!payload.commandId) return load(payload)
+    const key = keyFor(payload.seriesIds)
+    const pending = {}
+    const record = source.value
+    pendingCommands.set(key, pending)
+    // Collect the synchronous command batch before starting requests. Fit has
+    // no intent event, so its unscoped changes would otherwise cancel siblings.
+    await Promise.resolve()
+    if (disposed || source.value !== record || pendingCommands.get(key) !== pending) return
+    pendingCommands.delete(key)
+    return load(payload)
+  }
+
+  function handlePanEnd(payload: WaveformPanEndPayload) {
+    pendingCommands.clear()
+    return load(payload)
+  }
+
+  watch(source, () => {
+    pendingCommands.clear()
+    cancelAll()
+    states.value = new Map()
+    intentTarget = undefined
+    chartData.value = selectWaveformWindow(
+      source.value,
+      { start: recordDomain.value[0], end: recordDomain.value[1] },
+      true,
+    )
+    void resetWaveformViewport()
+  })
+  onScopeDispose(() => {
+    disposed = true
+    pendingCommands.clear()
+    cancelAll()
+  })
+
+  return {
+    chartData,
+    recordDomain,
+    initialXDomain,
+    minZoomSpan,
+    loading: computed(() => [...states.value.values()].some((state) => state.loading)),
+    errors: computed(() =>
+      [...states.value.values()].flatMap((state) => (state.error ? [state.error] : [])),
+    ),
+    handleZoomIntent,
+    handleZoomChange,
+    handleZoomEnd,
+    handlePanEnd,
+    resetWaveformViewport,
+    retry,
+  }
+}

package/src/index.ts

@@ -62,6 +62,8 @@ export type {
 // 类型定义
 export type {
   // 图表类型
+  WaveformAmplitudeLimit,
+  WaveformAmplitudeLimits,
   WaveformPoint,
   WaveformDisplayMode,
   WaveformUnitDisplayMode,

package/src/types/chart.ts

@@ -81,7 +81,7 @@ export interface WaveformZoomIntentPayload extends WaveformCommandMetadata {
   seriesIds?: string[]
 }
 
-/** Identifies the viewport reset by a double-click gesture. */
+/** Identifies the viewport reset by a toolbar or API command. */
 export interface WaveformZoomResetPayload extends WaveformCommandMetadata {
   trackIndex?: number
   seriesIds?: string[]
@@ -319,3 +319,12 @@ export interface WaveformZeroLineOptions {
   /** Hide within this fraction of a Y-axis tick interval from either boundary. Defaults to 0.02. */
   boundaryThreshold?: number
 }
+
+/** Strict amplitude display bounds, in the series' original Y units. */
+export interface WaveformAmplitudeLimit {
+  lower?: number
+  upper?: number
+}
+
+/** Keyed by stable normalized series IDs (not track IDs). */
+export type WaveformAmplitudeLimits = Record<string, WaveformAmplitudeLimit>

package/src/types/index.ts

@@ -4,6 +4,8 @@
 
 // 图表类型
 export type {
+  WaveformAmplitudeLimit,
+  WaveformAmplitudeLimits,
   WaveformPoint,
   WaveformDisplayMode,
   WaveformUnitDisplayMode,

package/src/utils/formatters.ts

@@ -1,4 +1,5 @@
 import type { WaveformXAxisLabelFormatter, WaveformXAxisLabelKind } from '../types'
+import { formatXAxisNumber } from './xAxisNumber'
 
 /**
  * 时间单位类型
@@ -147,7 +148,11 @@ export function formatXAxisLabel(
   formatter?: WaveformXAxisLabelFormatter,
 ): string {
   const value = displayTime(rawValue, timeUnit)
-  if (!formatter) return formatPlainNumber(value)
+  if (!formatter)
+    return formatXAxisNumber(value, [
+      displayTime(domain[0], timeUnit),
+      displayTime(domain[1], timeUnit),
+    ])
 
   return formatter(value, {
     kind,
@@ -173,9 +178,9 @@ export function endpointFractionDigits(domain: [number, number], timeUnit: TimeU
 }
 
 /**
- * 将 X 轴端点时间格式化为当前显示单位下的普通十进制文本
+ * 将 X 轴端点时间格式化为当前显示单位下的自适应精度文本
  * @param value 时间值（秒）
- * @param _domain 数据域（为保持现有调用签名而保留）
+ * @param _domain 用于计算显示精度的可视域
  * @param timeUnit 时间单位
  * @returns 格式化的时间字符串
  */
@@ -188,10 +193,10 @@ export function formatEndpointTime(
 }
 
 /**
- * 将 X 轴时间刻度格式化为当前显示单位下的普通十进制文本
+ * 将 X 轴时间刻度格式化为当前显示单位下的自适应精度文本
  * @param value 时间值（秒）
  * @param timeUnit 时间单位
- * @param _domain 数据域（为保持现有调用签名而保留）
+ * @param _domain 用于计算显示精度的可视域
  * @returns 格式化的时间字符串
  */
 export function formatAxisTime(

package/src/utils/xAxisNumber.ts

@@ -0,0 +1,36 @@
+/** Compact labels share precision so even extremely close endpoints stay distinct. */
+export function formatXAxisNumber(value: number, domain: [number, number]): string {
+  if (!Number.isFinite(value)) return String(value)
+  const span = Math.abs(domain[1] - domain[0])
+  const digits =
+    Number.isFinite(span) && span > 0 ? Math.max(0, Math.ceil(-Math.log10(span)) + 1) : 0
+  const clean = (number: number) => Number(number.toPrecision(15))
+  const fractionalDigits = (number: number) => {
+    const text = String(clean(number))
+    return text.includes('e') ? 6 : (text.split('.')[1]?.length ?? 0)
+  }
+  // Wide windows can still have fractional boundaries; do not label 2.76 as 3.
+  const precision =
+    span >= 1 || span === 0 ? Math.max(digits, Math.min(6, fractionalDigits(value))) : digits
+  const fixed = (number: number) => {
+    const rounded = Number(clean(number).toFixed(Math.min(6, precision)))
+    return Math.abs(rounded) >= 1e21
+      ? rounded.toLocaleString('en-US', { useGrouping: false, maximumFractionDigits: 6 })
+      : String(rounded)
+  }
+  if (
+    precision <= 6 &&
+    (value === 0 || Number(fixed(value)) !== 0) &&
+    (span === 0 || fixed(domain[0]) !== fixed(domain[1]))
+  ) {
+    return fixed(value)
+  }
+  for (let significant = 2; significant <= 17; significant++) {
+    const scientific = (number: number) => {
+      const [mantissa, exponent] = number.toExponential(significant - 1).split('e')
+      return `${Number(mantissa)}e${exponent}`
+    }
+    if (span === 0 || scientific(domain[0]) !== scientific(domain[1])) return scientific(value)
+  }
+  return value.toExponential(16)
+}

package/dist/types/data/sx2Channel.d.ts

@@ -1,10 +0,0 @@
-export declare const sx2Channel: {
-    chnl: string;
-    chnl_id: number;
-    dat_unit: string;
-    dev: number;
-    shot: number;
-    time_unit: string;
-    data: number[];
-    time: number[];
-};