@oliasoft-open-source/charts-library 5.13.0 → 5.14.0-beta-2

package/dist/src/components/line-chart/line-chart.interface.d.ts

@@ -0,0 +1,236 @@
+import { ReactNode } from 'react';
+import { DeepPartial, ICommonAnnotations, ICommonChartOptions, ICommonCustomLegend, ICommonData, ICommonDataset, ICommonDataValue, ICommonDragData, ICommonInteractions, ICommonLegend, ICommonOptions, ICommonScales, ICommonStyling, ICommonTooltip, TAxisPosition } from '../common/common.interface';
+export interface ILChartOptions extends ICommonChartOptions {
+    showPoints?: boolean;
+    closeOnOutsideClick?: boolean;
+    showLine?: boolean;
+    enableZoom?: boolean;
+    enablePan?: boolean;
+    enableDragAnnotation?: boolean;
+}
+export interface ILineChartGraph {
+    lineTension?: number;
+    spanGaps?: boolean;
+    showDataLabels?: boolean;
+    showMinorGridlines?: boolean;
+}
+export interface ILineChartTooltip extends ICommonTooltip {
+    hideSimulationName?: boolean;
+    scientificNotation?: boolean;
+}
+export interface ILineChartRange {
+    min?: number;
+    max?: number;
+}
+export interface ILineRange {
+    [key: string]: ILineChartRange;
+}
+export interface ILineChartAdditionalAxesOptions {
+    chartScaleType?: 'linear' | 'logarithmic';
+    reverse?: boolean;
+    beginAtZero?: boolean;
+    stepSize?: number;
+    suggestedMin?: number;
+    suggestedMax?: number;
+    range?: ILineRange;
+    autoAxisPadding?: boolean;
+}
+export interface IUnitOptions {
+    options: string[];
+    selectedUnit: string;
+    setSelectedUnit: () => void;
+}
+export interface ILineChartAxis<PositionType = TAxisPosition> {
+    id?: string;
+    label?: string;
+    position?: PositionType;
+    color?: string | string[];
+    unit?: IUnitOptions | string;
+    stepSize?: number;
+    gridLines?: ILineChartGraph;
+    min?: number | string;
+    max?: number | string;
+}
+export interface ILineChartAxes {
+    x: ILineChartAxis<'top' | 'bottom'>[];
+    y: ILineChartAxis<'left' | 'right'>[];
+    [key: string]: ILineChartAxis[];
+}
+export interface IDepthType {
+    options: string[];
+    selectedUnit: string;
+    setSelectedUnit: () => void;
+}
+export interface ILineChartStyling extends ICommonStyling {
+    squareAspectRatio?: number | boolean;
+    layoutPadding?: number | {
+        top: number;
+        bottom: number;
+        left: number;
+        right: number;
+    };
+}
+export interface ILineInteractions extends ICommonInteractions {
+    onAnimationComplete?: () => void;
+}
+export interface ILineLegend extends ICommonLegend {
+    customLegend?: ICommonCustomLegend<any>;
+    usePointStyle?: boolean;
+}
+export interface ILineChartOptions extends ICommonOptions {
+    title?: string | string[];
+    axes: ILineChartAxes;
+    scales: ICommonScales;
+    additionalAxesOptions: ILineChartAdditionalAxesOptions;
+    chartStyling: ILineChartStyling;
+    tooltip: ILineChartTooltip;
+    graph: ILineChartGraph;
+    annotations: ICommonAnnotations;
+    legend: ILineLegend;
+    chartOptions: ILChartOptions;
+    interactions: ILineInteractions;
+    dragData?: ICommonDragData;
+    depthType?: IDepthType | object;
+}
+type ILooseLineAxis = DeepPartial<ILineChartAxis<string>> & {
+    [key: string]: unknown;
+    stepSize?: unknown;
+};
+type ILooseLineAnnotation = {
+    [key: string]: unknown;
+    id?: string;
+    label?: string;
+    color?: string;
+    borderColor?: string;
+    backgroundColor?: string;
+    borderWidth?: number;
+    display?: boolean;
+    adjustScaleRange?: boolean;
+    opacity?: number;
+    hideLegend?: boolean;
+    labelOffsetPx?: number;
+    annotationAxis?: string;
+    type?: string;
+    value?: number | string | null;
+    xMin?: number | string | null;
+    xMax?: number | string | null;
+    yMin?: number | string | null;
+    yMax?: number | string | null;
+    xValue?: number | string | null;
+    yValue?: number | string | null;
+    onDragStart?: (...args: unknown[]) => void;
+    onDrag?: (...args: unknown[]) => void;
+    onDragEnd?: (...args: unknown[]) => void;
+};
+export type ILineChartOptionsInput = Omit<DeepPartial<ILineChartOptions>, 'title' | 'axes' | 'legend' | 'chartStyling' | 'interactions' | 'graph' | 'annotations' | 'additionalAxesOptions'> & {
+    [key: string]: unknown;
+    title?: unknown;
+    direction?: string;
+    axes?: {
+        x?: ILooseLineAxis[];
+        y?: ILooseLineAxis[];
+        [key: string]: ILooseLineAxis[] | undefined;
+    };
+    legend?: Omit<DeepPartial<ILineLegend>, 'position' | 'align'> & {
+        position?: string;
+        align?: string;
+        [key: string]: unknown;
+    };
+    chartStyling?: DeepPartial<ILineChartStyling> & {
+        hideControls?: boolean;
+        minHeight?: number | string;
+        [key: string]: unknown;
+    };
+    interactions?: DeepPartial<ILineInteractions> & {
+        enableZoom?: boolean;
+        enablePan?: boolean;
+        [key: string]: unknown;
+    };
+    graph?: DeepPartial<ILineChartGraph> & {
+        tooltip?: unknown;
+        [key: string]: unknown;
+    };
+    annotations?: (Omit<DeepPartial<ICommonAnnotations>, 'annotationsData'> & {
+        annotationsData?: ILooseLineAnnotation[];
+    }) | ILooseLineAnnotation[] | null;
+    additionalAxesOptions?: DeepPartial<ILineChartAdditionalAxesOptions> & {
+        stepSize?: unknown;
+        range?: ILineRange | ILineChartRange | Record<string, ILineChartRange | undefined>;
+    } & Record<string, unknown>;
+};
+export interface ILineChartDataInput extends Omit<ILineChartData, 'data' | 'options'> {
+    data?: Omit<DeepPartial<ILineChartData['data']>, 'datasets'> & {
+        datasets?: Array<(DeepPartial<ILineChartDataset> & {
+            lineTension?: number | string;
+            fill?: boolean | string | Record<string, unknown>;
+            pointStyle?: unknown;
+            showPoint?: boolean;
+            showPoints?: boolean;
+            lineHeight?: number;
+            data?: Array<DeepPartial<ICommonDataValue> | null>;
+            [key: string]: unknown;
+        }) | object | null> | object;
+    };
+    options?: ILineChartOptionsInput;
+}
+export interface ILineChartDataset extends ICommonDataset {
+    lineTension?: number;
+    pointBackgroundColor?: string;
+    pointRadius?: number;
+    pointHoverRadius?: number;
+    pointHitRadius?: number;
+    fill?: boolean;
+    xAxisID?: string;
+    yAxisID?: string;
+    formation?: boolean;
+    displayGroup?: string | number;
+    pointStyle?: string;
+}
+export interface ILineChartData extends ICommonData {
+    data?: {
+        datasets: ILineChartDataset[];
+    };
+    options: ILineChartOptions;
+    persistenceId?: string;
+    controlsPortalId?: string;
+}
+export interface ILineChartProps {
+    chart: ILineChartDataInput;
+    table?: ReactNode;
+    headerComponent?: ReactNode;
+    subheaderComponent?: ReactNode;
+}
+export interface LineChart extends ILineChartDataInput {
+}
+export interface IGeneratedLineChartDataset {
+    label?: string;
+    data: ICommonDataValue[];
+    showLine?: boolean;
+    lineTension: number;
+    spanGaps: boolean;
+    borderWidth: number;
+    borderDash: number[];
+    borderJoinStyle: 'round' | 'bevel' | 'miter';
+    borderColor: string;
+    backgroundColor: string | string[];
+    pointBackgroundColor: string;
+    pointRadius: number;
+    pointHoverRadius: number;
+    pointHitRadius: number;
+    isAnnotation?: boolean;
+    annotationType?: string;
+    annotationIndex?: number;
+    annotationLabel?: string;
+    annotationBackgroundColor?: string;
+    annotationPointBackgroundColor?: string;
+    annotationBorderColor?: string;
+    annotationBorderDash?: number[];
+    annotationBorderWidth?: number;
+    displayGroup?: string | number;
+    hideLegend?: boolean;
+    pointStyle?: string;
+    xAxisID?: string;
+    yAxisID?: string;
+}
+export type TGeneratedLineChartDatasets = IGeneratedLineChartDataset[];
+export {};

package/dist/src/components/line-chart/plugins/callout-plugin/callout-plugin.d.ts

@@ -0,0 +1,11 @@
+import { ChartType, Plugin } from 'chart.js';
+import { TCalloutConnector } from './helpers';
+declare module 'chart.js' {
+    interface PluginOptionsByType<TType extends ChartType> {
+        calloutConnectorPlugin?: {
+            enableCalloutAnnotation?: boolean;
+        };
+    }
+}
+export declare const calloutConnectorPlugin: Plugin;
+export type { TCalloutConnector };

package/dist/src/components/line-chart/plugins/callout-plugin/helpers.d.ts

@@ -0,0 +1,42 @@
+export type TCalloutConnector = {
+    enabled?: boolean | ((context: {
+        chart: any;
+        labelEl?: TAnnotationLike;
+        fromEl?: TAnnotationLike;
+        option?: any;
+    }) => boolean);
+    fromId: string;
+    strokeStyle?: string;
+    lineWidth?: number;
+    lineDash?: number[];
+    startOffset?: number;
+    endOffset?: number;
+    anchor?: {
+        position?: string;
+        xAdjust?: number;
+        yAdjust?: number;
+        labelOffsetPx?: number;
+        tickSize?: number;
+    };
+};
+export type TAnnotationLike = {
+    centerX: number;
+    centerY: number;
+    width?: number;
+    height?: number;
+    options?: {
+        display: boolean;
+        radius?: number;
+    };
+};
+export type TConnectorPoints = {
+    startX: number;
+    startY: number;
+    endX: number;
+    endY: number;
+    tickStartX: number;
+    tickStartY: number;
+    tickEndX: number;
+    tickEndY: number;
+};
+export declare const computeConnectorPoints: (fromEl: TAnnotationLike, labelEl: TAnnotationLike, connector: TCalloutConnector) => TConnectorPoints;

package/dist/src/components/line-chart/plugins/chart-area-text-plugin.d.ts

@@ -0,0 +1,17 @@
+import { Chart, ChartConfiguration, Plugin } from 'chart.js';
+import { Position } from '../../common/enums';
+interface CustomChartConfiguration extends ChartConfiguration {
+    showLabel?: boolean;
+    text: string;
+    fontSize: number;
+    xOffset: number;
+    yOffset: number;
+    lineHeight: number;
+    maxWidth: number;
+    position: Position;
+}
+export declare const chartAreaTextPlugin: {
+    id: string;
+    beforeDraw: (chart: Chart, _args: Plugin, options: CustomChartConfiguration) => void;
+};
+export {};

package/dist/src/components/line-chart/plugins/line-chart.minor-gridlines-plugin.d.ts

@@ -0,0 +1,8 @@
+import { Chart, Scale } from 'chart.js';
+export declare const getLargestMajorTickWidth: (majorTickPositions: number[]) => number;
+export declare const isValidPosition: (minorTickPosition: number, majorTickPositions: number[], scale: Scale) => boolean;
+export declare const getMinorTickPositions: (majorTickPositions: number[], scale: Scale) => number[];
+export declare const chartMinorGridlinesPlugin: {
+    id: string;
+    beforeDatasetsDraw: (chart: Chart) => void;
+};

package/dist/src/components/line-chart/plugins/line-markers-plugin/draw.d.ts

@@ -0,0 +1,39 @@
+import { Chart } from 'chart.js';
+import { TLineMarkerTick, TLineMarkerDirection, TStickSide } from './types.ts';
+export type TDrawLineArgs = {
+    chart: Chart;
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    color: string;
+    opacity: number;
+    lineWidth: number;
+    lineDash: number[];
+};
+export declare const drawLineSegment: ({ chart, x1, y1, x2, y2, color, opacity, lineWidth, lineDash, }: TDrawLineArgs) => {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+};
+export type TDrawTickArgs = {
+    ctx: CanvasRenderingContext2D;
+    chartArea: {
+        left: number;
+        right: number;
+        top: number;
+        bottom: number;
+    };
+    direction: TLineMarkerDirection;
+    x: number;
+    y: number;
+    side: TStickSide;
+    reverse?: boolean;
+    labelY?: number;
+    tick: TLineMarkerTick;
+    defaultColor: string;
+    defaultFont: string;
+};
+export declare const drawTick: (args: TDrawTickArgs) => void;
+export declare const getTickLabelHeight: (tick: TLineMarkerTick, defaultFont: string) => number;

package/dist/src/components/line-chart/plugins/line-markers-plugin/line-markers-plugin.d.ts

@@ -0,0 +1,10 @@
+import { ChartType, Plugin } from 'chart.js';
+import { TLineMarkersOptions } from './types';
+declare module 'chart.js' {
+    interface PluginOptionsByType<TType extends ChartType> {
+        lineMarkersPlugin?: {
+            enabled?: boolean;
+        } | TLineMarkersOptions;
+    }
+}
+export declare const lineMarkersPlugin: Plugin;

package/dist/src/components/line-chart/plugins/line-markers-plugin/types.d.ts

@@ -0,0 +1,109 @@
+export declare enum LineMarkerSide {
+    Left = "left",
+    Right = "right"
+}
+export declare enum LineMarkerDirection {
+    Vertical = "vertical",
+    Horizontal = "horizontal"
+}
+export declare enum LineMarkerLabelPosition {
+    Left = "left",
+    Right = "right",
+    Top = "top",
+    Bottom = "bottom",
+    OnLine = "onLine"
+}
+export declare enum LineMarkerTextAlign {
+    Left = "left",
+    Right = "right",
+    Center = "center"
+}
+export type TStickSide = LineMarkerSide;
+export type TLineMarkerDirection = LineMarkerDirection;
+export type TLineMarkerLabelPosition = LineMarkerLabelPosition;
+export type TLineMarkerTextAlign = LineMarkerTextAlign;
+export type TLineMarkerTick = {
+    enabled?: boolean;
+    label?: string | string[];
+    color?: string;
+    font?: string;
+    labelOffsetPx?: number;
+    labelPosition?: TLineMarkerLabelPosition;
+    side?: TStickSide;
+    reverse?: boolean;
+    sizePx?: number;
+};
+export type TMarkerExtraItem = {
+    id?: string;
+    display?: boolean;
+    yScaleID?: string;
+    yValue?: number;
+    value?: number;
+    lengthPx?: number;
+    side?: TStickSide;
+    reverse?: boolean;
+    color?: string;
+    opacity?: number;
+    lineWidth?: number;
+    lineDash?: number[];
+    tick?: TLineMarkerTick;
+};
+export type TLineMarkerItem = {
+    id?: string;
+    direction?: TLineMarkerDirection;
+    xScaleID?: string;
+    yScaleID?: string;
+    xValue?: number;
+    yValue?: number;
+    yStartValue?: number;
+    yEndValue?: number;
+    xStartValue?: number;
+    xEndValue?: number;
+    lengthPx?: number;
+    value?: number;
+    label?: string | string[];
+    font?: string;
+    labelOffsetPx?: number;
+    stickToEdge?: boolean;
+    stickToGroup?: boolean;
+    stickSide?: TStickSide;
+    groupOffsetPx?: number;
+    reverse?: boolean;
+    color?: string;
+    opacity?: number;
+    lineWidth?: number;
+    lineDash?: number[];
+    startTick?: TLineMarkerTick;
+    endTick?: TLineMarkerTick;
+    extras?: TMarkerExtraItem[];
+    display?: boolean;
+};
+export type TLineMarkersOptions = {
+    enabled?: boolean;
+    itemGapPx?: number;
+    edgePaddingPx?: number;
+    horizontalLineLengthPx?: number;
+    lineDirection?: TLineMarkerDirection;
+    labelCollisionPx?: number;
+    labelCollisionClusterXPx?: number;
+    enableLabelCollisionResolver?: boolean;
+    stickToEdge?: boolean;
+    stickToGroup?: boolean;
+    stickSide?: TStickSide;
+    reverse?: boolean;
+    xValue?: number;
+    yValue?: number;
+    yEndValue?: number;
+    xStartValue?: number;
+    xEndValue?: number;
+    lengthPx?: number;
+    yStartValue?: number;
+    color?: string;
+    opacity?: number;
+    lineWidth?: number;
+    lineDash?: number[];
+    startTick?: TLineMarkerTick;
+    endTick?: TLineMarkerTick;
+    items?: TLineMarkerItem[];
+};
+export type ILineMarkersAnnotation = TLineMarkersOptions;

package/dist/src/components/line-chart/plugins/line-markers-plugin/utils.d.ts

@@ -0,0 +1,40 @@
+import { Chart, Scale } from 'chart.js';
+import { TStickSide } from './types';
+export declare const isFiniteNumber: (v: unknown) => v is number;
+export declare const asArray: <T>(v: unknown) => T[];
+export declare const asObject: <T extends object>(v: unknown) => T | undefined;
+export declare const getFirstScaleByAxis: (chart: Chart, axis: "x" | "y") => Scale | undefined;
+export declare const resolveScale: (chart: Chart, scaleID: string | undefined, axis: "x" | "y") => Scale | undefined;
+export declare const getPixelForValueSafe: (scale: Scale | undefined, value: unknown) => number | undefined;
+export declare const clamp: (v: number, min: number, max: number) => number;
+export declare const crispLinePx: (v: number) => number;
+export type TChartArea = {
+    top: number;
+    bottom: number;
+};
+export declare const computeYRange: ({ chartArea, yStartPx, yEndPx, }: {
+    chartArea: TChartArea;
+    yStartPx?: number;
+    yEndPx?: number;
+}) => {
+    y1: number;
+    y2: number;
+};
+export declare const toLines: (label?: string | string[]) => string[];
+export declare const lineHeightPx: (font: string) => number;
+export type TLabelCollisionItem = {
+    id: string;
+    side: TStickSide;
+    x: number;
+    y: number;
+    height: number;
+};
+type TResolveLabelCollisionArgs = {
+    labels: TLabelCollisionItem[];
+    chartTop: number;
+    chartBottom: number;
+    clusterXPx: number;
+    gapPx: number;
+};
+export declare const resolveLabelCollisions: ({ labels, chartTop, chartBottom, clusterXPx, gapPx, }: TResolveLabelCollisionArgs) => Record<string, number>;
+export {};

package/dist/src/components/line-chart/plugins/plugin-constants.d.ts

@@ -0,0 +1,11 @@
+export declare const TextLabelPosition: {
+    TOP_LEFT: string;
+    TOP_CENTER: string;
+    TOP_RIGHT: string;
+    MIDDLE_LEFT: string;
+    MIDDLE_CENTER: string;
+    MIDDLE_RIGHT: string;
+    BOTTOM_LEFT: string;
+    BOTTOM_CENTER: string;
+    BOTTOM_RIGHT: string;
+};

package/dist/src/components/line-chart/plugins/plugins.interface.d.ts

@@ -0,0 +1,9 @@
+import { Position } from '../../common/enums';
+export interface IDrawText {
+    ctx: CanvasRenderingContext2D;
+    lines: Array<string>;
+    lineHeight: number;
+    x: number;
+    y: number;
+    position: Position;
+}

package/dist/src/components/line-chart/state/action-types.d.ts

@@ -0,0 +1,12 @@
+export declare const TOGGLE_ZOOM = "TOGGLE_ZOOM";
+export declare const TOGGLE_PAN = "TOGGLE_PAN";
+export declare const TOGGLE_POINTS = "TOGGLE_POINTS";
+export declare const TOGGLE_LINE = "TOGGLE_LINE";
+export declare const TOGGLE_LEGEND = "TOGGLE_LEGEND";
+export declare const TOGGLE_TABLE = "TOGGLE_TABLE";
+export declare const RESET_AXES_RANGES = "RESET_AXES_RANGES";
+export declare const UPDATE_AXES_RANGES = "UPDATE_AXES_RANGES";
+export declare const TOGGLE_DRAG_POINTS = "TOGGLE_DRAG_POINTS";
+export declare const TOGGLE_DRAG_ANNOTATION = "TOGGLE_DRAG_ANNOTATION";
+export declare const DISABLE_DRAG_OPTIONS = "DISABLE_DRAG_OPTIONS";
+export declare const UPDATE_EDITED = "UPDATE_EDITED";

package/dist/src/components/line-chart/state/helpers.d.ts

@@ -0,0 +1,13 @@
+import { Chart } from 'chart.js';
+import { RefObject } from 'react';
+import { IState } from './state.interfaces';
+export interface IGetInitAxes {
+    chartRef: RefObject<Chart>;
+    state: IState;
+}
+export declare const getInitAxes: ({ chartRef, state }: IGetInitAxes) => {
+    id: string;
+    min: number;
+    max: number;
+    unit: string | import('../line-chart.interface').IUnitOptions | undefined;
+}[];

package/dist/src/components/line-chart/state/initial-state.d.ts

@@ -0,0 +1,11 @@
+import { IState } from './state.interfaces';
+import { ILineChartOptions } from '../line-chart.interface';
+interface inputInitState {
+    options: ILineChartOptions;
+    persistenceId?: string;
+}
+/**
+ Initial chart state for the line chart.
+ */
+declare const initialState: ({ options, persistenceId }: inputInitState) => IState;
+export default initialState;

package/dist/src/components/line-chart/state/line-chart-reducer.d.ts

@@ -0,0 +1,2 @@
+import { IAction, IState } from './state.interfaces';
+export declare const reducer: (state: IState, action: IAction) => IState;

package/dist/src/components/line-chart/state/manage-state-in-local-storage.d.ts

@@ -0,0 +1,15 @@
+import { IState } from './state.interfaces';
+/**
+ * Retrieves the chart state from local storage.
+ *
+ * @param {string|''} persistenceId - The chart persistenceId.
+ * @returns {object|null} The chart state object or null if not found.
+ */
+export declare const getChartStateFromStorage: (persistenceId?: string) => any;
+/**
+ * Stores the chart state in local storage.
+ *
+ * @param {object} state - The chart state object to store.
+ * @param {string|''} persistenceId - The chart persistenceId.
+ */
+export declare const storeChartStateInStorage: (state: IState, persistenceId?: string) => void;

package/dist/src/components/line-chart/state/state.interfaces.d.ts

@@ -0,0 +1,26 @@
+import { IUnitOptions } from '../line-chart.interface';
+export interface IAxisState {
+    id?: string;
+    label?: string;
+    min?: number | string;
+    max?: number | string;
+    unit?: IUnitOptions | string;
+    axisType?: string;
+}
+export interface IState {
+    zoomEnabled: boolean;
+    panEnabled: boolean;
+    pointsEnabled: boolean;
+    lineEnabled: boolean;
+    legendEnabled: boolean;
+    axes: IAxisState[];
+    showAnnotationLineIndex?: number[];
+    showTable: boolean;
+    enableDragPoints: boolean;
+    enableDragAnnotation: boolean;
+    edited: boolean;
+}
+export interface IAction<T = string, P = any> {
+    type: T;
+    payload?: P;
+}

package/dist/src/components/line-chart/utils/axis-formatting/axis-formatting.d.ts

@@ -0,0 +1,2 @@
+import { Tick } from 'chart.js';
+export declare const formatAxisLabelNumbers: (tickValue: string | number, ticks: Tick[]) => string;

package/dist/src/components/line-chart/utils/axis-scales/axis-scales.d.ts

@@ -0,0 +1,18 @@
+import { ILineChartOptions, TGeneratedLineChartDatasets } from '../../line-chart.interface';
+import { IState } from '../../state/state.interfaces';
+interface IScaleValue {
+    min?: number;
+    max?: number;
+    [key: string]: unknown;
+}
+interface IScales {
+    [key: string]: IScaleValue;
+}
+/**
+ * Auto scales axis ranges (mix, max) if no explicit range is set
+ * - overrides some edge cases not handled well by default chart.js
+ * - supports optional padding when `autoAxisPadding` is set
+ * - otherwise does not set min/max (falls back to chart.js default)
+ */
+export declare const autoScale: (options: ILineChartOptions, state: IState, generatedDatasets: TGeneratedLineChartDatasets) => IScales;
+export {};

package/dist/src/components/line-chart/utils/check-custom-option/check-custom-option.d.ts

@@ -0,0 +1,12 @@
+import { IGeneratedLineChartDataset, TGeneratedLineChartDatasets } from '../../line-chart.interface';
+type TCustomOptionType = {
+    [key: string]: string;
+} | string | string[];
+type TDataType = IGeneratedLineChartDataset | Partial<IGeneratedLineChartDataset> | TGeneratedLineChartDatasets | Partial<TGeneratedLineChartDatasets> | any[];
+/**
+ * Checks if a single dataset or an array of datasets has a custom option.
+ * Iterates through each custom option defined in the customOptions parameter.
+ * Returns true if any dataset has any custom option, otherwise returns false.
+ */
+export declare const checkCustomOption: (data: TDataType, customOptions: TCustomOptionType) => boolean;
+export {};