@rfkit/charts 1.5.0 → 1.6.0

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/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/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/Limit/thresholdStyle.d.ts

@@ -0,0 +1,6 @@
+export declare const LIMIT_THRESHOLD_TEXT_STYLE: {
+    color: "#A855F7";
+};
+export declare const LIMIT_THRESHOLD_LINE_STYLE: {
+    borderColor: "#A855F7";
+};

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/modules/Spectrum/useSpectrumAnalyzer/thresholdData.d.ts

@@ -0,0 +1,8 @@
+import type { PublishSpectrum } from '../../../types';
+export type SpectrumThresholdDataOptions = Pick<PublishSpectrum, 'segmentOffset' | 'offset'>;
+export declare function resolveThresholdDataOptions({ segmentOffset, offset }: SpectrumThresholdDataOptions): SpectrumThresholdDataOptions | undefined;
+type ThresholdDataTarget = {
+    setThresholdData: (data?: PublishSpectrum['thresholdData'], options?: SpectrumThresholdDataOptions) => void;
+};
+export declare function setAnalyzerThresholdData(analyzer: ThresholdDataTarget, payload: PublishSpectrum): void;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rfkit/charts",
-  "version": "1.5.0",
+  "version": "1.6.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/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;