@rfkit/charts 1.2.28 → 1.3.1

package/utils/array.d.ts

@@ -0,0 +1,40 @@
+/**
+ * 数组操作工具函数
+ */
+/**
+ * 查找数组最大值及索引
+ */
+export declare function arrayFindMax(arr: Array<number>): {
+    max?: undefined;
+    maxIndex?: undefined;
+} | {
+    max: number;
+    maxIndex: number;
+};
+interface MinResult {
+    min: number;
+    minIndex: number;
+}
+/**
+ * 查找数组最小值及索引
+ */
+export declare function arrayFindMin(arr: Array<number>): MinResult | 0;
+/**
+ * 是否为有效数字
+ */
+export declare const isNumberAlias: (n: unknown) => boolean;
+/**
+ * 获取平均值、最大值、最小值
+ */
+export declare function getDimInfo(d: Array<number>): {
+    min?: number;
+    minIndex?: number;
+    max?: number;
+    maxIndex?: number;
+    avg?: number;
+};
+/**
+ * 获取中间索引
+ */
+export declare function getMidIndex(indexStart: number, indexEnd: number): number;
+export {};

package/utils/frequency.d.ts

@@ -0,0 +1,72 @@
+/**
+ * 频率计算工具函数
+ */
+import { FrequencyUnit } from '../config/constants';
+import type { RecursiveObject, SegmentsOriginal, SegmentsType } from '../types';
+/**
+ * 格式化频率为固定小数位字符串
+ */
+export declare const getFrequencyToFixed: (frequency: number, fixedNum?: number) => string;
+/**
+ * 是否是 dBm 单位
+ */
+export declare function isdBm(unit: string): boolean;
+/**
+ * 通过 left segments 格式化 frequency 频谱信息
+ */
+export declare const leftSegments2frequency: (segments: SegmentsType) => (left: number) => string;
+/**
+ * 点信息转换成频率
+ */
+export declare function leftPoints2frequency<T>(points: Array<T>): (left: number) => T | undefined;
+interface ScopeInfo {
+    segments: SegmentsType;
+    startLeft: number;
+    endLeft: number;
+}
+/**
+ * 通过范围框中信息的 left segments 转换成 bandwidth
+ */
+export declare const scopeLeftSegments2bandwidth: (e: ScopeInfo | null | undefined) => number;
+/**
+ * 生成频率段
+ */
+export declare const generateFrequencySegments: (e: RecursiveObject) => SegmentsType;
+/**
+ * 为无频率规则的模式生成默认 segments（如 LiteNormalized）
+ */
+export declare const generateNormalizedSegments: (totalPoints: number) => SegmentsType;
+/**
+ * 生成大段频率数据
+ */
+export declare const generateGreatSegments: (prevSegments: SegmentsOriginal[]) => SegmentsType;
+/**
+ * 频率单位自适应结果
+ */
+export interface FrequencyUnitResult {
+    value: number;
+    unit: FrequencyUnit;
+    formatted: string;
+}
+/**
+ * 频率单位自适应转换（基于 kHz）
+ * @param frequencyKHz 频率（单位：kHz）
+ * @param precision 小数位数，默认 2
+ * @returns 转换后的频率值、单位和格式化字符串
+ */
+export declare const formatFrequencyUnit: (frequencyKHz: number, precision?: number) => FrequencyUnitResult;
+/**
+ * 频率单位自适应转换（基于 MHz）
+ * @param frequencyMHz 频率（单位：MHz）
+ * @param precision 小数位数，默认 2
+ * @returns 转换后的频率值、单位和格式化字符串
+ */
+export declare const formatFrequencyUnitFromMHz: (frequencyMHz: number, precision?: number) => FrequencyUnitResult;
+/**
+ * 频率单位自适应转换（基于 Hz）
+ * @param frequencyHz 频率（单位：Hz）
+ * @param precision 小数位数，默认 2
+ * @returns 转换后的频率值、单位和格式化字符串
+ */
+export declare const formatFrequencyUnitFromHz: (frequencyHz: number, precision?: number) => FrequencyUnitResult;
+export {};

package/utils/index.d.ts

@@ -1,121 +1,19 @@
-import type { TimestampedFloat32Array } from '@rfkit/spectrum-analyzer';
-import type { ModuleType } from '../config';
-import type { RecursiveObject, SegmentsOriginal, SegmentsType } from '../types';
-/**
- * GUID
- * @returns {string}
- */
-export declare const createGUID: () => string;
-export interface TimestampFormatOptions {
-    dateSeparator?: string;
-    timeSeparator?: string;
-    timeOnly?: boolean;
-}
-export declare const formatTimestamp: (input?: number | Date, options?: TimestampFormatOptions) => string;
-export declare const dateTimeToTimestamp: (dateTimeStr: unknown, // 改为 unknown 类型，强制运行时检查
-sep1?: string, sep2?: string, isTimeOnly?: boolean) => number;
-/**
- * 节流
- */
-export declare function throttle(func?: (...arg: any[]) => void, wait?: number): (...arg: any[]) => void;
-export declare function throttleRequestAnimationFrame(func?: (e?: any) => void): (e?: any) => void;
-export declare function throttleTimer(func?: (e: any) => void, wait?: number): (e?: any) => void;
-/**
- * 通过left segments格式化frequency频谱信息
- */
-export declare const leftSegments2frequency: (segments: SegmentsType) => (left: number) => string;
-export declare const leftSegmentsFindStep: (segments: any) => (left: number) => number;
-/**
- * 点信息转换成频率
- */
-export declare function leftPoints2frequency(points: Array<any>): (left: number) => any;
-/**
- * 通过范围框中信息的left segments转换成bandwidth
- */
-export declare const scopeLeftSegments2bandwidth: (e: any) => number;
-/**
- * 是否是dBm
- */
-export declare function isdBm(unit: string): boolean;
 /**
- * 求极值
+ * 工具函数统一导出
  */
-export declare function arrayFindMax(arr: Array<number>): {
-    max?: undefined;
-    maxIndex?: undefined;
-} | {
-    max: number;
-    maxIndex: number;
-};
-export declare function arrayFindMin(arr: Array<any>): 0 | {
-    min: number;
-    minIndex: number;
-};
-export declare const generateFrequencySegments: (e: RecursiveObject) => SegmentsType;
-/**
- * 为无频率规则的模式生成默认 segments（如 LiteNormalized）
- * @param totalPoints 数据点数
- * @returns SegmentsType
- */
-export declare const generateNormalizedSegments: (totalPoints: number) => SegmentsType;
-export declare const generateGreatSegments: (prevSegments: SegmentsOriginal[]) => SegmentsType;
-/**
- * 获取平均值、最大值、最小值
- */
-export declare function getDimInfo(d: Array<number>): {
-    min?: number;
-    minIndex?: number;
-    max?: number;
-    maxIndex?: number;
-    avg?: number;
-};
-/**
- * 是否为刻度值
- */
-export declare const isNumberAlias: (n: any) => boolean;
-export declare const weakenArray: (data: Array<number>, interval: number, factor: Array<number> | undefined) => Array<number | undefined>;
-export declare const getRowCol: (unknownArray: Array<any>) => {
-    row: number;
-    col: number;
-};
-export declare function expandArray(arr: Array<number>): number[];
-export declare function getThemeFillStyle(): {
-    fillStyle: string;
-    fillStylePrimary: string;
-    fillStyleTransparentBase: string;
-};
+import type { TimestampedFloat32Array } from '@rfkit/spectrum-analyzer';
+export * from './array';
+export * from './frequency';
+export * from './frequencyCalculation';
+export * from './object';
+export * from './theme';
+export * from './throttle';
+export * from './time';
 /**
- * 混合对象 - 将参数对象合并到源对象中
- * @param source 源对象
- * @param params 要混合的参数
- * @returns 混合后的对象
+ * GUID 生成
  */
-export declare const mergeObjects: <T extends RecursiveObject>(source: T, params: RecursiveObject) => T;
-export declare function getMidIndex(indexStart: number, indexEnd: number): number;
-export declare const getFrequencyToFixed: (frequency: number, fixedNum?: number) => string;
-export declare const createChartRenderID: ({ moduleType, globalID }: {
-    moduleType?: ModuleType;
-    globalID?: string;
-}) => string;
+export declare const createGUID: () => string;
 /**
- * 将原始数据转换为带时间戳的Float32Array数组
- * @param data 原始数据数组
- * @param timestamps 可选的时间戳数组
- * @returns 转换后的TimestampedFloat32Array数组
+ * 将原始数据转换为带时间戳的 Float32Array 数组
  */
 export declare const convertToTimestampedArrays: (data: number[][], timestamps?: Array<string>) => TimestampedFloat32Array[];
-/**
- * 防抖函数
- * @param fn 需要防抖的函数
- * @param delay 延迟时间（毫秒）
- * @returns 带有cancel方法的防抖函数
- */
-export declare const debounce: <T extends (...args: unknown[]) => unknown>(fn: T, delay?: number) => ((...args: Parameters<T>) => void) & {
-    cancel: () => void;
-};
-/**
- * 基于 requestAnimationFrame 的节流函数，适合视觉更新相关操作
- */
-export declare function debounceRequestAnimationFrame<T extends unknown[]>(func?: (...args: T) => void): (...args: T) => void;
-export declare const getThemeColor: (property: string, opacity?: number) => string;
-export * from './frequencyCalculation';

package/utils/object.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 对象操作工具函数
+ */
+import type { RecursiveObject } from '../types';
+/**
+ * 混合对象 - 将参数对象合并到源对象中
+ * @param source 源对象
+ * @param params 要混合的参数
+ * @returns 混合后的对象
+ */
+export declare const mergeObjects: <T extends RecursiveObject>(source: T, params: RecursiveObject) => T;

package/utils/series/events.d.ts

@@ -2,7 +2,7 @@
  * Series 事件系统
  * 提供通用的发布-订阅机制，支持 React 组件和普通 JS 模块
  */
-import type { GraphicType } from '../../engine';
+import type { GraphicType } from '@rfkit/renderer';
 import type { SeriesConfig } from './index';
 import type { ModeConfig, SeriesMode } from './modes';
 /**

package/utils/series/index.d.ts

@@ -1,5 +1,5 @@
+import { GraphicType } from '@rfkit/renderer';
 import { type SeriesConfig as ExternalSeriesConfig, SeriesManager } from '@rfkit/spectrum-analyzer';
-import { GraphicType } from '../../engine';
 /**
  * 本地 SeriesConfig 类型定义
  */

package/utils/series/modes.d.ts

@@ -2,7 +2,7 @@
  * Series 模式管理
  * 集成新的事件系统，支持通用的订阅机制
  */
-import { GraphicType } from '../../engine';
+import { GraphicType } from '@rfkit/renderer';
 /**
  * 显示模式类型
  */

package/utils/subscription.d.ts

@@ -1,16 +1,34 @@
 import type { SpectrumAnalyzer, SpectrumData } from '@rfkit/spectrum-analyzer';
 import type { RecursiveFunction } from '../types';
-export declare function openData(globalID: string, data: unknown, defaultData: unknown): any;
+interface ChartsGlobal {
+    datas: Record<string, unknown>;
+    subscriptions: ChartSubscriptions;
+}
+declare global {
+    interface Window {
+        charts?: ChartsGlobal;
+    }
+}
+export declare function openData<T = unknown>(globalID: string, data: T | undefined, defaultData: T): T;
 /**
  * 共享订阅
+ * Note: Using any[] for callback args since this is a generic pub/sub system
+ * that can be called with various argument types across the codebase.
  */
 export type CSMCallback = (...args: any[]) => void;
+interface Subscription {
+    [key: string]: CSMCallback;
+}
+interface ChartSubscriptions {
+    [id: string]: Subscription;
+}
 export declare function createSubscriptionManager(id: string, name?: string, func?: CSMCallback): (...args: any[]) => void;
 export interface rawData {
     getAllRawData: () => SpectrumData;
 }
 export declare const getDefaultData: () => rawData;
-export default function withDatabase(globalID: string, data?: any): rawData;
+export default function withDatabase(globalID: string, data?: rawData): rawData;
 export declare const withUpdateData: (id?: string, name?: string, func?: RecursiveFunction) => (...args: any[]) => void;
 export declare const setScanDF360Prob: (id?: string, func?: RecursiveFunction) => (...args: any[]) => void;
 export declare function withSpectrumAnalyzerSYNC(globalID: string, analyzer?: SpectrumAnalyzer): SpectrumAnalyzer;
+export {};

package/utils/theme.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 主题相关工具函数
+ */
+export interface ThemeFillStyle {
+    fillStyle: string;
+    fillStylePrimary: string;
+    fillStyleTransparentBase: string;
+}
+/**
+ * 获取主题填充样式
+ */
+export declare function getThemeFillStyle(): ThemeFillStyle;
+/**
+ * 获取主题颜色，支持透明度改变
+ * @param property CSS 变量名
+ * @param opacity 可选的透明度 (0-1)
+ */
+export declare const getThemeColor: (property: string, opacity?: number) => string;

package/utils/throttle.d.ts

@@ -0,0 +1,52 @@
+/**
+ * 节流与防抖工具函数
+ */
+/**
+ * 节流函数
+ * @param func 需要节流的函数
+ * @param wait 等待时间（毫秒），默认 1000/30
+ */
+export declare function throttle<T extends unknown[]>(func?: (...arg: T) => void, wait?: number): (...arg: T) => void;
+interface EventSnapshot {
+    currentTarget: EventTarget | null;
+    target: EventTarget | null;
+    clientX?: number;
+    clientY?: number;
+    buttons?: number;
+    nativeEvent?: Event;
+    _originalEvent?: unknown;
+}
+interface ReactLikeEvent {
+    nativeEvent?: Event;
+    persist?: () => void;
+    currentTarget?: EventTarget | null;
+    target?: EventTarget | null;
+    clientX?: number;
+    clientY?: number;
+    buttons?: number;
+}
+/**
+ * 基于 requestAnimationFrame 的节流函数
+ * @param func 需要节流的函数
+ */
+export declare function throttleRequestAnimationFrame<T = unknown>(func?: (e?: T | EventSnapshot) => void): (e?: T | ReactLikeEvent) => void;
+/**
+ * 基于定时器的节流函数
+ * @param func 需要节流的函数
+ * @param wait 等待时间（毫秒）
+ */
+export declare function throttleTimer<T = unknown>(func?: (e?: T) => void, wait?: number): (e?: T) => void;
+/**
+ * 防抖函数
+ * @param fn 需要防抖的函数
+ * @param delay 延迟时间（毫秒）
+ * @returns 带有 cancel 方法的防抖函数
+ */
+export declare const debounce: <T extends (...args: unknown[]) => unknown>(fn: T, delay?: number) => ((...args: Parameters<T>) => void) & {
+    cancel: () => void;
+};
+/**
+ * 基于 requestAnimationFrame 的防抖函数，适合视觉更新相关操作
+ */
+export declare function debounceRequestAnimationFrame<T extends unknown[]>(func?: (...args: T) => void): (...args: T) => void;
+export {};

package/utils/time.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 时间处理工具函数
+ */
+/**
+ * 时间戳格式化选项
+ */
+export interface TimestampFormatOptions {
+    dateSeparator?: string;
+    timeSeparator?: string;
+    timeOnly?: boolean;
+}
+/**
+ * 格式化时间戳为字符串
+ * @param input 时间戳或 Date 对象
+ * @param options 格式化选项
+ * @returns 格式化后的时间字符串
+ */
+export declare const formatTimestamp: (input?: number | Date, options?: TimestampFormatOptions) => string;
+/**
+ * 将日期时间字符串转换为时间戳
+ * @param dateTimeStr 日期时间字符串
+ * @param sep1 日期分隔符
+ * @param sep2 时间分隔符
+ * @param isTimeOnly 是否仅为时间字符串
+ * @returns 时间戳（毫秒）
+ */
+export declare const dateTimeToTimestamp: (dateTimeStr: unknown, sep1?: string, sep2?: string, isTimeOnly?: boolean) => number;

package/engine/ColorInterpolator.d.ts

@@ -1,49 +0,0 @@
-/**
- * Color 类型定义，用于表示 RGBA 颜色。
- */
-interface Color {
-    r: number;
-    g: number;
-    b: number;
-    a: number;
-    hax?: string;
-}
-type Colors = Color[];
-/**
- * 颜色插值器类，用于在设定范围内插值颜色。
- */
-export default class ColorInterpolator {
-    private colorsPresetList;
-    private range;
-    private readonly transparent;
-    /**
-     * 构造函数，接收颜色数组和范围信息，生成插值颜色列表。
-     * @param colors 颜色数组，用于插值
-     * @param rangeMin 插值范围的最小值
-     * @param rangeMax 插值范围的最大值
-     * @param stepSize 插值步长，默认为0.1
-     */
-    constructor(colors: Colors, rangeMin: number, rangeMax: number, stepSize?: number);
-    /**
-     * 设置颜色数组并生成插值颜色列表。
-     * @param colors 颜色数组，用于插值
-     * @param rangeMin 插值范围最小值
-     * @param rangeMax 插值范围最大值
-     * @param stepSize 插值步长
-     */
-    setColors(colors: Colors, rangeMin: number, rangeMax: number, stepSize: number): void;
-    /**
-     * 根据位置值在颜色数组之间进行插值计算。
-     * @param colors 颜色数组，用于插值
-     * @param position 归一化的位置值 (0 - 1)
-     * @returns 插值后的颜色
-     */
-    private interpolateColor;
-    /**
-     * 根据给定值获取插值后的颜色。
-     * @param value 输入的数值，应该在设定的范围内
-     * @returns 插值后的颜色对象
-     */
-    getColor(value: number): Color;
-}
-export {};

package/engine/dial.d.ts

@@ -1,13 +0,0 @@
-import Engine from './engine';
-import type { StateProps } from './type';
-export default class Dial extends Engine {
-    init(props: StateProps): void;
-    clear(): void;
-    resize(): void;
-    render(data: {
-        [key: string]: unknown;
-    }): void;
-    drawTicks(): void;
-    drawBackground(): void;
-    draw(): void;
-}

package/engine/engine.d.ts

@@ -1,10 +0,0 @@
-import type { StateProps } from './type';
-export default class Engine {
-    state: StateProps;
-    constructor(props: StateProps);
-    updateProps(e: Partial<StateProps>): void;
-    init(p: StateProps): void;
-    clearRect(): void;
-    resize(draw?: boolean): void;
-    draw(): void;
-}

package/engine/fillImageData.d.ts

@@ -1,34 +0,0 @@
-interface Color {
-    r: number;
-    g: number;
-    b: number;
-    a: number;
-}
-type Colors = Color[];
-/**
- * 设置颜色数组，并计算插值颜色列表。
- * @param colors 颜色数组，用于插值
- * @param rangeMin 插值范围最小值
- * @param rangeMax 插值范围最大值
- * @param stepSize 插值步长，默认为0.1
- */
-export declare const setColors: (colors: Colors, rangeMin: number, rangeMax: number, stepSize?: number) => void;
-/**
- * 根据给定值获取插值后的颜色。
- * @param value 给定的值，在设定的范围内
- * @returns 插值后的颜色对象
- */
-export declare const getColor: (value: number) => Color;
-/**
- * 根据给定的数据数组填充图像数据
- * @param rangeMin 最小范围值
- * @param rangeMax 最大范围值
- * @param colors 颜色数组
- * @param canvasWidth 画布宽度
- * @param canvasHeight 画布高度
- * @param data 数据数组
- * @param imageData 图像数据对象
- * @returns 填充后的图像数据对象
- */
-export declare const fillImageData: (canvasWidth: number, canvasHeight: number, data: number[][], imageData: ImageData["data"]) => void;
-export {};

package/engine/fluorescence.d.ts

@@ -1,37 +0,0 @@
-import Engine from './engine';
-import type { AxisYRange, StateProps } from './type';
-export default class Fluorescence extends Engine {
-    init(props: StateProps): void;
-    updateProps(e: Partial<StateProps>): void;
-    clearImageData(): void;
-    clearRect(): void;
-    clear(): void;
-    dispose(): void;
-    private drawBlocks;
-    resize(): void;
-    setRange(range: AxisYRange): void;
-    render(data: {
-        fluorescenceData: Map<number, number>[];
-        fluorescenceMaxCount: number;
-    }): void;
-    interpolateColor(colors: any[], ratio: number): {
-        r: number;
-        g: number;
-        b: number;
-        a: number;
-    };
-    private colorCache;
-    hexToRgb(hex: string): {
-        r: number;
-        g: number;
-        b: number;
-    };
-    private lastRenderParams;
-    private intensityMatrixCache;
-    private gridCentersCache;
-    private weightLookupCache;
-    private colorLookupCache;
-    private blockPositionsCache;
-    private lastBlockRenderParams;
-    draw(): void;
-}

package/engine/gauge.d.ts

@@ -1,16 +0,0 @@
-import Engine from './engine';
-import type { StateProps } from './type';
-interface Data {
-    value: number;
-    limit: number;
-}
-export default class Gauge extends Engine {
-    init(props: StateProps): void;
-    clear(): void;
-    resize(): void;
-    render(data: Data): void;
-    draw(): void;
-    drawLimit(): void;
-    drawBackground(): void;
-}
-export {};

package/engine/heatmap.d.ts

@@ -1,13 +0,0 @@
-import Engine from './engine';
-import type { AxisYRange, StateProps } from './type';
-export default class Heatmap extends Engine {
-    init(props: StateProps): void;
-    updateProps(e: Partial<StateProps>): void;
-    clearImageData(): void;
-    clearRect(): void;
-    clear(): void;
-    resize(): void;
-    setRange(range: AxisYRange): void;
-    render(data: number[][]): void;
-    draw(): void;
-}

package/engine/index.d.ts

@@ -1,11 +0,0 @@
-import Dial from './dial';
-import Fluorescence from './fluorescence';
-import Gauge from './gauge';
-import Heatmap from './heatmap';
-import IQ from './iq';
-import IQEye from './iqEye';
-import Radar from './radar';
-import Series from './series';
-import { type AxisYRange, GraphicType, OrientationType, type SeriesConfig, type StateProps } from './type';
-export { Dial, Fluorescence, Gauge, GraphicType, Heatmap, IQ, IQEye, OrientationType, Radar, Series };
-export type { AxisYRange, SeriesConfig, StateProps };

package/engine/iq.d.ts

@@ -1,12 +0,0 @@
-import Engine from './engine';
-interface Data {
-    IData: number[];
-    QData: number[];
-}
-export default class IQ extends Engine {
-    init(props: any): void;
-    clear(): void;
-    render(data: Data): void;
-    draw(): void;
-}
-export {};

package/engine/iqEye.d.ts

@@ -1,17 +0,0 @@
-import Engine from './engine';
-interface Data {
-    IData: number[];
-    QData: number[];
-}
-export default class IQ extends Engine {
-    init(props: any): void;
-    clear(): void;
-    render(data: Data): void;
-    draw(): void;
-    private drawAllSegments;
-    private applyColorGradient;
-    private parseColor;
-    private drawSegmentedData;
-    private drawLine;
-}
-export {};

package/engine/radar.d.ts

@@ -1,11 +0,0 @@
-import Engine from './engine';
-import type { StateProps } from './type';
-export default class Dial extends Engine {
-    init(props: StateProps): void;
-    clear(): void;
-    resize(): void;
-    render(data: any): void;
-    drawTicks(): void;
-    drawBackground(): void;
-    draw(): void;
-}

package/engine/series.d.ts

@@ -1,12 +0,0 @@
-import Engine from './engine';
-import type { AxisYRange, SeriesConfig, StateProps } from './type';
-export default class Series extends Engine {
-    init(props: StateProps): void;
-    updateProps(e: Partial<StateProps>): void;
-    clear(): void;
-    setRange(range: AxisYRange): void;
-    setIntervel(interval: number): void;
-    setSeries(e: SeriesConfig): void;
-    render(e: SeriesConfig): void;
-    draw(): void;
-}