@rfkit/charts 1.5.1 → 1.7.0

package/modules/Dial/index.d.ts

@@ -1,2 +1,2 @@
-declare const Dial: () => import("react/jsx-runtime").JSX.Element;
+declare const Dial: () => import("react").JSX.Element;
 export default Dial;

package/modules/Heatmap/cursorValue.d.ts

@@ -0,0 +1,38 @@
+import type { TimestampedFloat32Array } from '@rfkit/spectrum-analyzer';
+export interface HeatmapGridInfo {
+    columnCount: number;
+    rowCount: number;
+}
+export interface HeatmapRowRange {
+    endIndex: number;
+    startIndex: number;
+}
+export interface HeatmapColumnRange {
+    endCol: number;
+    startCol: number;
+}
+export interface HeatmapGridRange extends HeatmapRowRange, HeatmapColumnRange {
+}
+export interface HeatmapCursorValue {
+    columnIndex: number;
+    rowIndex: number;
+    timestamp: string;
+    value: number | null;
+}
+export declare const resolveHeatmapColumnCount: (waterfallData: TimestampedFloat32Array[]) => number;
+export declare const resolveHeatmapGridInfo: (waterfallData: TimestampedFloat32Array[]) => HeatmapGridInfo;
+export declare const resolveHeatmapRowIndex: (top: number, rowCount: number) => number;
+export declare const resolveHeatmapColumnIndex: (left: number, columnCount: number) => number;
+export declare const resolveHeatmapRowRange: (topA: number, topB: number, rowCount: number) => HeatmapRowRange | null;
+export declare const resolveHeatmapColumnRange: (leftA: number, leftB: number, columnCount: number) => HeatmapColumnRange | null;
+export declare const resolveHeatmapGridRange: (waterfallData: TimestampedFloat32Array[], bounds: {
+    endLeft: number;
+    endTop: number;
+    startLeft: number;
+    startTop: number;
+}) => HeatmapGridRange | null;
+export declare const resolveHeatmapRangeData: (waterfallData: TimestampedFloat32Array[], range: HeatmapGridRange) => number[][];
+export declare const resolveHeatmapCursorValue: (waterfallData: TimestampedFloat32Array[], coord: {
+    left: number;
+    top: number;
+}) => HeatmapCursorValue | null;

package/modules/IQEye/index.d.ts

@@ -2,5 +2,5 @@ import { type IQChartType } from '../base';
 interface IQEyeProps {
     type?: IQChartType;
 }
-export default function IQEye({ type }: IQEyeProps): import("react/jsx-runtime").JSX.Element;
+export default function IQEye({ type }: IQEyeProps): import("react").JSX.Element;
 export {};

package/modules/IQPlanisphere/index.d.ts

@@ -2,5 +2,5 @@ import { type IQChartType } from '../base';
 interface IQPlanisphereProps {
     type?: IQChartType;
 }
-export default function IQPlanisphere({ type }: IQPlanisphereProps): import("react/jsx-runtime").JSX.Element;
+export default function IQPlanisphere({ type }: IQPlanisphereProps): import("react").JSX.Element;
 export {};

package/modules/Occupancy/CursorPopover.d.ts

@@ -1,3 +1,6 @@
 import type React from 'react';
-declare const OccupancyCursorPopover: React.FC;
+interface OccupancyCursorPopoverProps {
+    id: string;
+}
+declare const OccupancyCursorPopover: React.FC<OccupancyCursorPopoverProps>;
 export default OccupancyCursorPopover;

package/modules/Spectrum/AxisYCanvas/index.d.ts

@@ -2,5 +2,5 @@ import type { RenderChartType } from '../../../types';
 interface AxisYCanvasProps {
     chart: RenderChartType | null;
 }
-export default function AxisYCanvas(props: AxisYCanvasProps): import("react/jsx-runtime").JSX.Element | null;
+export default function AxisYCanvas(props: AxisYCanvasProps): import("react").JSX.Element | null;
 export {};

package/modules/Spectrum/BandLayer/bandState.d.ts

@@ -0,0 +1,9 @@
+import type { SegmentType } from '../../../types/common.ts';
+import { type BandState } from '../../../types/store/ui.ts';
+export { resolveBandState } from '../../../store/bandState.ts';
+export interface BandPosition {
+    key: string;
+    left: number;
+    width: number;
+}
+export declare function resolveBandPositions(band: BandState, segments: SegmentType[]): BandPosition[];

package/modules/Spectrum/FrequencyAllocation/model/channelModel.d.ts

@@ -0,0 +1,16 @@
+import type { FrequencyAllocationChannel, FrequencyAllocationItem } from '../../../../types';
+export declare const DEFAULT_FREQUENCY_ALLOCATION_CHANNEL_ID = "default";
+export interface ResolvedFrequencyAllocationChannel {
+    id: string;
+    title?: string;
+    data: FrequencyAllocationItem[];
+}
+export interface ResolveFrequencyAllocationChannelsOptions {
+    data?: FrequencyAllocationItem[];
+    channels?: FrequencyAllocationChannel[];
+    cachedData?: FrequencyAllocationItem[] | null;
+    cachedChannels?: FrequencyAllocationChannel[] | null;
+    presetData: FrequencyAllocationItem[];
+    normalizeData: (data: FrequencyAllocationItem[]) => FrequencyAllocationItem[];
+}
+export declare function resolveFrequencyAllocationChannelModel({ data, channels, cachedData, cachedChannels, presetData, normalizeData }: ResolveFrequencyAllocationChannelsOptions): ResolvedFrequencyAllocationChannel[];

package/modules/Spectrum/FrequencyAllocation/model/density.d.ts

@@ -0,0 +1,13 @@
+import type { FrequencyAllocationDensity } from '../../../../types';
+export declare const FREQUENCY_ALLOCATION_LANE_HEIGHT = 14;
+export declare const FREQUENCY_ALLOCATION_COMPACT_LANE_HEIGHT = 5;
+export declare const FREQUENCY_ALLOCATION_COMPACT_THRESHOLD = 4;
+export interface FrequencyAllocationDensityModel {
+    compact: boolean;
+    laneHeight: number;
+    showLabels: boolean;
+}
+export declare const resolveFrequencyAllocationDensity: ({ density, channelCount }: {
+    density?: FrequencyAllocationDensity;
+    channelCount: number;
+}) => FrequencyAllocationDensityModel;

package/modules/Spectrum/FrequencyAllocation/model/index.d.ts

@@ -1,4 +1,5 @@
-export { resolveFrequencyAllocationData } from './resolveFrequencyAllocationData';
-export { type FrequencyAllocationSegmentData, findFrequencyAllocationAtCursor, resolveFrequencyAllocationRange, resolveFrequencyAllocationSegments } from './resolver';
+export { FREQUENCY_ALLOCATION_COMPACT_LANE_HEIGHT, FREQUENCY_ALLOCATION_COMPACT_THRESHOLD, FREQUENCY_ALLOCATION_LANE_HEIGHT, type FrequencyAllocationDensityModel, resolveFrequencyAllocationDensity } from './density';
+export { type ResolvedFrequencyAllocationChannel, resolveFrequencyAllocationChannels, resolveFrequencyAllocationData } from './resolveFrequencyAllocationData';
+export { createFrequencyAllocationRangeIndex, type FrequencyAllocationLaneData, type FrequencyAllocationRangeCandidate, type FrequencyAllocationSegmentData, findFrequencyAllocationAtCursor, findFrequencyAllocationInRangeIndex, resolveFrequencyAllocationLanes, resolveFrequencyAllocationRange, resolveFrequencyAllocationSegments } from './resolver';
 export { useAllocationAtCursor, useAllocationFinder } from './useAllocationAtCursor';
-export { useFrequencyAllocationData } from './useFrequencyAllocationData';
+export { useFrequencyAllocationChannels, useFrequencyAllocationData } from './useFrequencyAllocationData';

package/modules/Spectrum/FrequencyAllocation/model/resolveFrequencyAllocationData.d.ts

@@ -1,2 +1,8 @@
-import type { FrequencyAllocationItem } from '../../../../types';
+import type { FrequencyAllocationChannel, FrequencyAllocationItem } from '../../../../types';
+import { type ResolvedFrequencyAllocationChannel } from './channelModel';
+export type { ResolvedFrequencyAllocationChannel };
+export declare function resolveFrequencyAllocationChannels({ data, channels }: {
+    data?: FrequencyAllocationItem[];
+    channels?: FrequencyAllocationChannel[];
+}): ResolvedFrequencyAllocationChannel[];
 export declare function resolveFrequencyAllocationData(data?: FrequencyAllocationItem[]): FrequencyAllocationItem[];

package/modules/Spectrum/FrequencyAllocation/model/resolver.d.ts

@@ -1,17 +1,42 @@
 import type { CSSProperties } from 'react';
 import type { FrequencyAllocationItem, SegmentType } from '../../../../types';
+import { type FrequencyRange as CalculatedFrequencyRange } from '../../../../utils';
 import type { BandPosition, FrequencyRange } from '../types';
+import type { ResolvedFrequencyAllocationChannel } from './resolveFrequencyAllocationData';
 export interface FrequencyAllocationSegmentData {
     segment: SegmentType;
     segmentIndex: number;
     bandPositions: BandPosition[];
     style: CSSProperties;
 }
+export interface FrequencyAllocationLaneData {
+    channel: ResolvedFrequencyAllocationChannel;
+    channelIndex: number;
+    segmentData: FrequencyAllocationSegmentData[];
+}
+export interface FrequencyAllocationRangeCandidate {
+    item: FrequencyAllocationItem;
+    range: CalculatedFrequencyRange;
+    width: number;
+    center: number;
+    title: string;
+}
 export declare const resolveFrequencyAllocationRange: (band: FrequencyAllocationItem) => FrequencyRange | null;
-export declare const resolveFrequencyAllocationSegments: ({ segments, allocations }: {
+export declare const resolveFrequencyAllocationSegments: ({ segments, allocations, channelIndex, channelTitle }: {
     segments: SegmentType[];
     allocations: FrequencyAllocationItem[];
+    channelIndex?: number;
+    channelTitle?: string;
 }) => FrequencyAllocationSegmentData[];
+export declare const resolveFrequencyAllocationLanes: ({ segments, channels }: {
+    segments: SegmentType[];
+    channels: ResolvedFrequencyAllocationChannel[];
+}) => FrequencyAllocationLaneData[];
+export declare const createFrequencyAllocationRangeIndex: (allocations: FrequencyAllocationItem[]) => FrequencyAllocationRangeCandidate[];
+export declare const findFrequencyAllocationInRangeIndex: ({ rangeIndex, frequency }: {
+    rangeIndex: FrequencyAllocationRangeCandidate[];
+    frequency: number;
+}) => FrequencyAllocationItem | undefined;
 export declare const findFrequencyAllocationAtCursor: ({ allocations, frequency }: {
     allocations: FrequencyAllocationItem[];
     frequency: number;

package/modules/Spectrum/FrequencyAllocation/model/useAllocationAtCursor.d.ts

@@ -1,6 +1,8 @@
+import type { CursorSampleSnapshot } from '../../../../runtime/interaction';
 interface UseAllocationFinderProps {
     frequency: string;
+    cursorSample?: CursorSampleSnapshot | null;
 }
-export declare function useAllocationAtCursor({ frequency }: UseAllocationFinderProps): import("../../../..").FrequencyAllocationItem | undefined;
+export declare function useAllocationAtCursor({ frequency, cursorSample }: UseAllocationFinderProps): import("../../../..").FrequencyAllocationItem | undefined;
 export declare const useAllocationFinder: typeof useAllocationAtCursor;
 export {};

package/modules/Spectrum/FrequencyAllocation/model/useFrequencyAllocationData.d.ts

@@ -1 +1,2 @@
 export declare function useFrequencyAllocationData(): import("../../../..").FrequencyAllocationItem[];
+export declare function useFrequencyAllocationChannels(): import("./channelModel").ResolvedFrequencyAllocationChannel[];

package/modules/Spectrum/FrequencyAllocation/overlays/Tooltip/index.d.ts

@@ -1,4 +1,11 @@
 import type React from 'react';
 import type { TooltipState } from '../../types';
-declare const Tooltip: React.FC<TooltipState>;
+interface TooltipProps extends TooltipState {
+    positionRef: React.RefObject<{
+        x: number;
+        y: number;
+    }>;
+    scheduleRef: React.RefObject<(() => void) | null>;
+}
+declare const Tooltip: React.FC<TooltipProps>;
 export default Tooltip;

package/modules/Spectrum/FrequencyAllocation/presenters/AllocationInfo/index.d.ts

@@ -5,6 +5,7 @@ interface Props {
         startFrequency?: string | number;
         stopFrequency?: string | number;
         centerFrequency?: string | number;
+        channelTitle?: string;
     };
     variant?: 'default' | 'board';
 }

package/modules/Spectrum/FrequencyAllocation/presenters/AllocationSegments/index.d.ts

@@ -1,10 +1,10 @@
 import type React from 'react';
-import type { BandPosition, FrequencyRange } from '../../types';
-import type { FrequencyAllocationItem } from '../../../../../types';
+import type { BandPosition } from '../../types';
 interface AllocationSegmentsProps {
     style: React.CSSProperties;
     bandPositions: BandPosition[];
-    onMouseEnter: (band: FrequencyAllocationItem, range: FrequencyRange) => (event: React.MouseEvent) => void;
+    showLabels: boolean;
+    onMouseEnter: (position: BandPosition) => (event: React.MouseEvent) => void;
     onMouseMove: (event: React.MouseEvent) => void;
     onMouseLeave: () => void;
 }

package/modules/Spectrum/FrequencyAllocation/tools.d.ts

@@ -1,14 +1,24 @@
-import type { FrequencyAllocationItem } from '../../../types';
+import type { FrequencyAllocationChannel, FrequencyAllocationItem } from '../../../types';
 /**
  * 从本地缓存读取FrequencyAllocation数据
  * @returns FrequencyAllocationItem数组或null
  */
 export declare const getFrequencyAllocationFromCache: () => FrequencyAllocationItem[] | null;
+/**
+ * 从本地缓存读取多通道FrequencyAllocation数据
+ * @returns FrequencyAllocationChannel数组或null
+ */
+export declare const getFrequencyAllocationChannelsFromCache: () => FrequencyAllocationChannel[] | null;
 /**
  * 将FrequencyAllocation数据保存到本地缓存
  * @param data FrequencyAllocationItem数组
  */
 export declare const setFrequencyAllocationToCache: (data: FrequencyAllocationItem[]) => void;
+/**
+ * 将多通道FrequencyAllocation数据保存到本地缓存
+ * @param channels FrequencyAllocationChannel数组
+ */
+export declare const setFrequencyAllocationChannelsToCache: (channels: FrequencyAllocationChannel[]) => void;
 /**
  * 清除本地缓存的FrequencyAllocation数据
  */

package/modules/Spectrum/FrequencyAllocation/types.d.ts

@@ -3,6 +3,7 @@ export interface TooltipState extends FrequencyAllocationItem {
     visible: boolean;
     x: number;
     y: number;
+    channelTitle?: string;
 }
 export interface FrequencyRange {
     start: number;
@@ -14,6 +15,8 @@ export interface FrequencyRange {
 export interface BandPosition {
     band: FrequencyAllocationItem;
     range: FrequencyRange;
+    channelIndex: number;
+    channelTitle?: string;
     position: {
         left: string;
         width: string;

package/modules/Spectrum/FrequencyDataBoard/index.d.ts

@@ -1,4 +1,5 @@
 import React from 'react';
+import type { CursorSampleSnapshot } from '../../../runtime/interaction';
 interface Props {
     left: number;
     onChange?: (e: {
@@ -7,6 +8,7 @@ interface Props {
     }) => void;
     updateKey?: number;
     showStationInfo?: boolean;
+    cursorSample?: CursorSampleSnapshot | null;
 }
 declare const _default: React.NamedExoticComponent<Props>;
 export default _default;

package/modules/Spectrum/Signal/index.d.ts

@@ -4,6 +4,7 @@ export { useStationFinder } from './model';
 export { useSignalDataManager } from './useSignalDataManager';
 export { SignalSwitch };
 interface Props {
+    id: string;
     left?: number;
     show?: boolean;
     display?: boolean;

package/modules/Spectrum/Signal/model/index.d.ts

@@ -1,3 +1,3 @@
-export { findStationAtCursor, resolveSignalMatchCandidates, resolveSignalPositions, resolveSignalSegments, type SignalPosition, type SignalSegmentData } from './resolver';
+export { createStationRangeIndex, findStationAtCursor, findStationInRangeIndex, resolveActiveSignalKey, resolveSignalMatchCandidates, resolveSignalPositions, resolveSignalSegments, resolveStaticSignalSegments, type SignalPosition, type SignalSegmentData } from './resolver';
 export { useStationFinder, useStationInfoAtCursor } from './useStationInfoAtCursor';
 export { useUnifiedSignals } from './useUnifiedSignals';

package/modules/Spectrum/Signal/model/resolver.d.ts

@@ -29,6 +29,19 @@ export declare const resolveSignalSegments: ({ segments, signalItems, isCursorAc
         pointIndex: number;
     };
 }) => SignalSegmentData[];
+export declare const resolveStaticSignalSegments: ({ segments, signalItems }: {
+    segments: SegmentType[];
+    signalItems: UnifiedSignalItem[];
+}) => SignalSegmentData[];
+export declare const resolveActiveSignalKey: ({ segmentData, isCursorActive, currentFrequency, currentPosition }: {
+    segmentData: SignalSegmentData[];
+    isCursorActive: boolean;
+    currentFrequency: number;
+    currentPosition: {
+        segmentIndex: number;
+        pointIndex: number;
+    };
+}) => string | undefined;
 export declare const findStationAtCursor: ({ frequency, signalItems, segments, currentPosition }: {
     frequency: number;
     signalItems: UnifiedSignalItem[];
@@ -38,3 +51,15 @@ export declare const findStationAtCursor: ({ frequency, signalItems, segments, c
         pointIndex: number;
     };
 }) => StationInfoType | undefined;
+export declare const createStationRangeIndex: ({ signalItems, segments }: {
+    signalItems: UnifiedSignalItem[];
+    segments: SegmentType[];
+}) => SignalMatchCandidate[][];
+export declare const findStationInRangeIndex: ({ frequency, stationRangeIndex, currentPosition }: {
+    frequency: number;
+    stationRangeIndex: SignalMatchCandidate[][];
+    currentPosition: {
+        segmentIndex: number;
+        pointIndex: number;
+    };
+}) => StationInfoType | undefined;

package/modules/Spectrum/Signal/model/useStationInfoAtCursor.d.ts

@@ -1,7 +1,9 @@
+import type { CursorSampleSnapshot } from '../../../../runtime/interaction';
 interface UseStationFinderProps {
     frequency: string;
     enabled?: boolean;
+    cursorSample?: CursorSampleSnapshot | null;
 }
-export declare function useStationInfoAtCursor({ frequency, enabled }: UseStationFinderProps): import("../../../..").StationInfoType | undefined;
+export declare function useStationInfoAtCursor({ frequency, enabled, cursorSample }: UseStationFinderProps): import("../../../..").StationInfoType | undefined;
 export declare const useStationFinder: typeof useStationInfoAtCursor;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rfkit/charts",
-  "version": "1.5.1",
+  "version": "1.7.0",
   "type": "module",
   "description": "Chart components for wireless monitoring web applications",
   "exports": {

package/runtime/interaction/index.d.ts

@@ -0,0 +1,71 @@
+import type { ModuleType } from '../../config';
+import type { CursorEventSnapshot } from '../../types/store';
+export interface InteractionBounds {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+    width: number;
+    height: number;
+}
+export interface PointerSnapshot {
+    sourceId: string;
+    sourceType: ModuleType;
+    clientX: number;
+    clientY: number;
+    coord: {
+        left: number;
+        top: number;
+    };
+    bounds: InteractionBounds;
+    version: number;
+    timestamp: number;
+}
+export interface CursorSampleSnapshot extends PointerSnapshot {
+    sampledIndex?: number;
+    globalIndex?: number;
+    rowIndex?: number;
+}
+export type InteractionClearReason = 'leave' | 'bounds' | 'blur' | 'visibility' | 'mouseout' | 'dispose' | 'manual';
+export interface InteractionRuntimeOptions {
+    sampleIntervalMs?: number;
+    sampleIdleDelayMs?: number;
+    now?: () => number;
+    requestFrame?: (callback: () => void) => number;
+    cancelFrame?: (id: number) => void;
+    setTimer?: (callback: () => void, delay: number) => number | ReturnType<typeof setTimeout>;
+    clearTimer?: (id: number | ReturnType<typeof setTimeout>) => void;
+}
+type PointerListener = (snapshot: PointerSnapshot | null) => void;
+type SampleListener = (snapshot: CursorSampleSnapshot | null) => void;
+export declare class InteractionRuntime {
+    private readonly entries;
+    private readonly sampleIntervalMs;
+    private readonly sampleIdleDelayMs;
+    private readonly now;
+    private readonly requestFrame;
+    private readonly cancelFrame;
+    private readonly setTimer;
+    private readonly clearTimer;
+    constructor(options?: InteractionRuntimeOptions);
+    updatePointer(id: string, snapshot: Omit<PointerSnapshot, 'version' | 'timestamp'>): void;
+    refreshBounds(id: string, bounds: InteractionBounds): void;
+    clearPointer(id: string, _reason?: InteractionClearReason): void;
+    subscribePointer(id: string, listener: PointerListener): () => void;
+    subscribeSample(id: string, listener: SampleListener): () => void;
+    getPointer(id: string): PointerSnapshot | null;
+    getSample(id: string): CursorSampleSnapshot | null;
+    dispose(id?: string): void;
+    private ensureEntry;
+    private schedulePointerFrame;
+    private scheduleSample;
+    private flushSample;
+    private notifyPointer;
+    private notifySample;
+    private clearEntryTimers;
+    private cleanupEntryIfEmpty;
+}
+export declare const interactionRuntime: InteractionRuntime;
+export declare const createInteractionBounds: (left: number, top: number, right: number, bottom: number) => InteractionBounds;
+export declare const toCursorSnapshotEvent: (snapshot: PointerSnapshot | CursorSampleSnapshot) => CursorEventSnapshot;
+export {};

package/store/bandState.d.ts

@@ -0,0 +1,7 @@
+import { type BandState } from '../types/store/ui.ts';
+export type BandUpdateStrategy = 'merge' | 'replace';
+/**
+ * 将 prop / publish 的 Band 输入归一化为唯一内部状态。
+ * 无效输入返回当前状态引用，避免破坏已生效的 Band。
+ */
+export declare function resolveBandState(input: Record<string, unknown>, current?: BandState, strategy?: BandUpdateStrategy): BandState;

package/types/publish.d.ts

@@ -111,9 +111,9 @@ export interface PointsEvent {
     pstype: 'points';
     data: number[];
 }
-export interface BandEvent extends BandProps {
+export type BandEvent = BandProps & {
     pstype: 'band';
-}
+};
 export interface ScopeEvent extends RecursiveObject {
     pstype: 'scope';
     frequency: number;

package/types/store/frequency.d.ts

@@ -12,8 +12,16 @@ export interface FrequencyAllocationItem {
     color?: string;
     gradientColors?: [string, string];
 }
+export interface FrequencyAllocationChannel {
+    id?: string;
+    title?: string;
+    data: FrequencyAllocationItem[];
+}
+export type FrequencyAllocationDensity = 'auto' | 'normal' | 'compact';
 export interface FrequencyAllocationProps {
     show: boolean;
     display: boolean;
     data: FrequencyAllocationItem[];
+    channels?: FrequencyAllocationChannel[];
+    density?: FrequencyAllocationDensity;
 }

package/types/store/heatmap.d.ts

@@ -4,6 +4,7 @@ export declare enum HeatmapCaptureType {
     Slider = "slider",
     RowIndex = "rowIndex"
 }
+export type HeatmapCaptureToolbarVariant = 'default' | 'deltaMeasurement';
 export interface HeatmapSliderData {
     startIndex: number;
     endIndex: number;
@@ -41,6 +42,7 @@ export interface HeatmapCaptureProps {
     type: HeatmapCaptureType;
     show: boolean;
     display: boolean;
+    toolbarVariant?: HeatmapCaptureToolbarVariant;
     sync: boolean;
     interval: {
         startIndex: number;

package/types/store/index.d.ts

@@ -24,7 +24,7 @@ import type { HeatmapCaptureProps } from './heatmap';
 import type { MarkerProps } from './marker';
 import type { LevelStreamProps, SeriesProps } from './series';
 import type { SignalAnalysisProps, SignalProps } from './signal';
-import type { BandProps, BlazeProps, CursorProps, DeltaMeasurementProps, EventBusProps, FluorescenceProps, FrequencyTagLineBoardProps, LegendProps, LimitProps, ScopeProps, StripeProps, SystemConfig, ToolbarProps, ZoomProps } from './ui';
+import type { BandProps, BandState, BlazeProps, CursorProps, DeltaMeasurementProps, EventBusProps, FluorescenceProps, FrequencyTagLineBoardProps, LegendProps, LimitProps, ScopeProps, StripeProps, SystemConfig, ToolbarProps, ZoomProps } from './ui';
 export interface StoreState {
     globalID: string;
     config: unknown;
@@ -43,7 +43,7 @@ export interface StoreState {
     zoom: ZoomProps;
     signal: SignalProps;
     signalAnalysis: SignalAnalysisProps;
-    band: BandProps;
+    band: BandState;
     scope: ScopeProps;
     gridLines: boolean;
     legend: LegendProps;
@@ -89,7 +89,7 @@ export interface ParamsProps {
     frequencyTagLine?: Partial<FrequencyTagLineBoardProps>;
     frequencyAllocation?: Partial<FrequencyAllocationProps>;
     toolbar?: Partial<ToolbarProps>;
-    band?: Partial<BandProps>;
+    band?: BandProps;
     levelStream?: Partial<LevelStreamProps>;
     deltaMeasurement?: Partial<DeltaMeasurementProps>;
     publish?: Publish;

package/types/store/ui.d.ts

@@ -53,12 +53,62 @@ export interface ZoomProps {
     onChange: (se: [string, string], interval: AxisXRange) => void;
     autoCloseTimeout: number;
 }
-export interface BandProps {
+type BandSharedProps = {
+    show?: boolean;
+    color?: string;
+};
+type BandPositionProps = {
+    left?: number;
+    width?: number;
+    frequency?: never;
+    bandwidth?: never;
+    startFrequency?: never;
+    stopFrequency?: never;
+};
+type BandCenterBandwidthProps = {
+    frequency: number;
+    bandwidth: number;
+    left?: never;
+    width?: never;
+    startFrequency?: never;
+    stopFrequency?: never;
+};
+type BandFrequencyRangeProps = {
+    startFrequency: number;
+    stopFrequency: number;
+    left?: never;
+    width?: never;
+    frequency?: never;
+    bandwidth?: never;
+};
+/** Band 对外配置：百分比、中心频率带宽、起止频率三种定位方式互斥。 */
+export type BandProps = BandSharedProps & (BandPositionProps | BandCenterBandwidthProps | BandFrequencyRangeProps);
+export declare const BandKind: {
+    readonly Position: "position";
+    readonly CenterBandwidth: "centerBandwidth";
+    readonly FrequencyRange: "frequencyRange";
+};
+export type BandKind = (typeof BandKind)[keyof typeof BandKind];
+/** Band 内部归一化状态。 */
+export type BandState = {
+    kind: typeof BandKind.Position;
     show: boolean;
+    color?: string;
     left?: number;
     width: number;
+} | {
+    kind: typeof BandKind.CenterBandwidth;
+    show: boolean;
     color?: string;
-}
+    frequency: number;
+    bandwidth: number;
+} | {
+    kind: typeof BandKind.FrequencyRange;
+    show: boolean;
+    color?: string;
+    startFrequency: number;
+    stopFrequency: number;
+};
 export interface ScopeProps {
     show: boolean;
     left: number;
@@ -112,3 +162,4 @@ export interface EventBusProps {
     onDoubleClick: (frequency: string, e: RecursiveObject) => void;
     [key: string]: unknown;
 }
+export {};

package/utils/object.d.ts

@@ -3,7 +3,7 @@
  */
 import type { RecursiveObject } from '../types';
 /**
- * 混合对象 - 将参数对象合并到源对象中
+ * 混合对象 - 将参数对象合并到源对象副本中
  * @param source 源对象
  * @param params 要混合的参数
  * @returns 混合后的对象