@oliasoft-open-source/charts-library 3.4.6 → 3.4.7-beta-1

package/dist/src/components/line-chart/controls/drag-options-interfaces.d.ts

@@ -1,11 +1,11 @@
 export interface IDragOptions {
-    onTogglePan: () => any;
-    onToggleZoom: () => any;
+    onTogglePan: () => void;
+    onToggleZoom: () => void;
     panEnabled: boolean;
     zoomEnabled: boolean;
     enableDragPoints: boolean;
     isDragDataAllowed: boolean;
-    onToggleDragPoints: () => any;
-    onDisableDragOptions: () => any;
-    translations: any;
+    onToggleDragPoints: () => void;
+    onDisableDragOptions: () => void;
+    translations: Record<string, string>;
 }

package/dist/src/components/line-chart/controls/line-options.d.ts

@@ -1 +1,9 @@
-export declare const LineOptions: ({ lineEnabled, onToggleLine, onTogglePoints, pointsEnabled, translations, }: any) => JSX.Element;
+interface ILineOptions {
+    lineEnabled: boolean;
+    onToggleLine: () => void;
+    onTogglePoints: () => void;
+    pointsEnabled: boolean;
+    translations: Record<string, string>;
+}
+export declare const LineOptions: ({ lineEnabled, onToggleLine, onTogglePoints, pointsEnabled, translations, }: ILineOptions) => JSX.Element;
+export {};

package/dist/src/components/line-chart/hooks/use-chart-functions.d.ts

@@ -1,4 +1,15 @@
-import { IHooksInterface } from './hooks.interface';
+import { Dispatch, RefObject } from 'react';
+import { Chart, ChartEvent } from 'chart.js';
+import { ICommonHoveredItems } from '../../common/common.interface';
+import { ILineChartDataset, ILineChartOptions } from '../line-chart.interface';
+import { IState } from '../state/state.interfaces';
+interface IUseChartFunctions {
+    chartRef: RefObject<Chart>;
+    state: IState;
+    options: ILineChartOptions;
+    dispatch: Dispatch<any>;
+    generatedDatasets: ILineChartDataset[];
+}
 /**
  * Custom hook that encapsulates the chart-related functions and their dependencies
  * @param {Object} chartRef - Chart reference
@@ -8,16 +19,27 @@ import { IHooksInterface } from './hooks.interface';
  * @param {Array} generatedDatasets - Chart datasets
  * @returns {Object} An object containing the chart-related functions
  */
-export declare const useChartFunctions: ({ chartRef, state, options, dispatch, generatedDatasets, }: IHooksInterface) => {
-    legendClick: (e: any, legendItem: any) => void;
+export declare const useChartFunctions: ({ chartRef, state, options, dispatch, generatedDatasets, }: IUseChartFunctions) => {
+    legendClick: (_e: ChartEvent, legendItem: any) => void;
     resetZoom: () => void;
-    onHover: (hoveredPoint: any, setHoveredPoint: any) => (evt: Event, hoveredItems: Array<any>) => void;
+    onHover: (hoveredPoint: any, setHoveredPoint: any) => (evt: ChartEvent, hoveredItems: ICommonHoveredItems[]) => void;
     handleDownload: () => void;
     handleKeyDown: (evt: any) => void;
     handleKeyUp: (evt: any) => void;
-    controlsAxes: any;
-    controlsAxesLabels: any[];
+    controlsAxes: {
+        max?: number | undefined;
+        min?: number | undefined;
+        id?: string | undefined;
+        label?: string | undefined;
+        unit?: string | import("../line-chart.interface").IUnitOptions | undefined;
+        axisType?: string | undefined;
+    }[];
+    controlsAxesLabels: {
+        id: string;
+        label: string;
+    }[];
     updateAxesRangesFromChart: () => void;
     onResetAxes: () => void;
     onUpdateAxes: ({ axes }: any) => void;
 };
+export {};

package/dist/src/components/line-chart/{state → hooks}/use-chart-state.d.ts

@@ -1,4 +1,15 @@
-import { IUseChartState } from './state.interfaces';
+import { Dispatch, RefObject } from 'react';
+import { Chart } from 'chart.js';
+import { IState } from '../state/state.interfaces';
+import { ILineChartDataset, ILineChartOptions } from '../line-chart.interface';
+interface IUseChartState {
+    chartRef: RefObject<Chart>;
+    options: ILineChartOptions;
+    state: IState;
+    generatedDatasets: ILineChartDataset[];
+    dispatch: Dispatch<any>;
+    persistenceId?: string;
+}
 /**
  * Hook for managing the state of the chart.
  *
@@ -10,3 +21,4 @@ import { IUseChartState } from './state.interfaces';
  * @param persistenceId - The chart persistenceId.
  */
 export declare const useChartState: ({ chartRef, options, state, generatedDatasets, dispatch, persistenceId, }: IUseChartState) => void;
+export {};

package/dist/src/components/line-chart/hooks/use-toggle-handler.d.ts

@@ -1,4 +1,5 @@
-export declare const useToggleHandlers: (dispatch: any) => {
+import { Dispatch } from 'react';
+export declare const useToggleHandlers: (dispatch: Dispatch<any>) => {
     onToggleLegend: () => void;
     onToggleLine: () => void;
     onTogglePan: () => void;

package/dist/src/components/line-chart/initialize/config.d.ts

@@ -3,10 +3,10 @@
  * @param {string} key - The key to access the corresponding value in the config object.
  * @returns {*} - The value associated with the given key in the config object or config.
  */
-export declare const getConfig: any;
+export declare const getConfig: (key?: string) => any;
 /**
  * Set a new value for the given key in the config object.
  * @param {string} key - The key to access the corresponding value in the config object.
  * @param {*} newValue - The new value to be set for the given key.
  */
-export declare const setConfig: (key: string, newValue: any) => void;
+export declare const setConfig: (key: string, newValue: string | Record<string, string>) => void;

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

@@ -1,31 +1,37 @@
-import { Position } from '../../../helpers/enums';
+import { Dispatch, MouseEventHandler, RefObject } from 'react';
+import { Chart, ChartArea } from 'chart.js';
+import { IState } from '../state/state.interfaces';
+import { ILineChartDataset, ILineChartOptions } from '../line-chart.interface';
+import { Position } from '../../common/helpers/enums';
 export interface ILegendDropZone {
-    position: string;
-    onDrop: () => any;
-    placeholderSize: any;
+    position: Position;
+    onDrop: () => void;
+    placeholderSize?: {
+        width?: number;
+        height?: number;
+    };
 }
 export interface ILegendDropZones {
-    chartArea: any;
+    chartArea: ChartArea;
     setLegendPosition: (position: Position) => void;
-    isDragging: any;
-    placeholderSize: {
-        width: string;
-        height: string;
+    isDragging: boolean;
+    placeholderSize?: {
+        width?: number;
+        height?: number;
     };
 }
 export interface ILegendItem {
     hidden: boolean;
-    dataset: any;
-    handleClick: (e: Event) => any;
+    dataset: ILineChartDataset;
+    handleClick: MouseEventHandler<HTMLDivElement>;
 }
 export interface ILegend {
-    chartRef: {
-        current: any;
-    };
-    state: any;
-    options: any;
-    dispatch: () => any;
-    generatedDatasets: any;
+    chartRef: RefObject<Chart>;
+    state: IState;
+    options: ILineChartOptions;
+    dispatch: Dispatch<any>;
+    generatedDatasets: ILineChartDataset[];
+    translations: Record<string, string>;
 }
 export interface ILegendPanel extends ILegend {
     legendPosition: Position;

package/dist/src/components/line-chart/legend/legend-panel.d.ts

@@ -1,4 +1,4 @@
-import React from 'react';
+/// <reference types="react" />
 import { ILegendPanel } from './legend-interface';
-declare const LegendPanel: React.ForwardRefExoticComponent<ILegendPanel & React.RefAttributes<unknown>>;
+declare const LegendPanel: import("react").ForwardRefExoticComponent<ILegendPanel & import("react").RefAttributes<HTMLDivElement>>;
 export default LegendPanel;

package/dist/src/components/line-chart/line-chart-get-default-props.d.ts

@@ -1,34 +1,42 @@
 import { ILineChartProps } from './line-chart.interface';
+import { AlignOptions, Position } from '../common/helpers/enums';
 export declare const getDefaultProps: (props: ILineChartProps) => {
     persistenceId: string;
-    controlsPortalId: string | null;
+    controlsPortalId: string;
     testId: string | null;
-    data: any;
+    data: {
+        datasets: import("./line-chart.interface").ILineChartDataset[];
+    } | undefined;
     options: {
         title: string | string[];
-        scales: any;
+        scales: import("../common/common.interface").ICommonScales;
         axes: {
-            x: any;
-            y: any;
+            x: import("./line-chart.interface").ILineChartAxis<"top" | "bottom">[];
+            y: import("./line-chart.interface").ILineChartAxis<"left" | "right">[];
         };
         additionalAxesOptions: {
-            chartScaleType: any;
-            reverse: any;
-            beginAtZero: any;
-            stepSize: any;
-            suggestedMin: any;
-            suggestedMax: any;
-            range: any;
-            autoAxisPadding: any;
+            chartScaleType: "linear" | "logarithmic";
+            reverse: boolean;
+            beginAtZero: boolean;
+            stepSize: number | undefined;
+            suggestedMin: number | undefined;
+            suggestedMax: number | undefined;
+            range: import("./line-chart.interface").ILineRange;
+            autoAxisPadding: boolean;
         };
         chartStyling: {
-            width: string | number;
-            height: string | number;
+            width: string | number | undefined;
+            height: string | number | undefined;
             maintainAspectRatio: boolean;
             staticChartHeight: boolean;
             performanceMode: boolean;
-            squareAspectRatio: boolean;
-            layoutPadding: any;
+            squareAspectRatio: number | undefined;
+            layoutPadding: string | number | {
+                top: number;
+                bottom: number;
+                left: number;
+                right: number;
+            };
         };
         tooltip: {
             tooltips: boolean;
@@ -54,38 +62,38 @@ export declare const getDefaultProps: (props: ILineChartProps) => {
             };
             showAnnotations: boolean;
             controlAnnotation: boolean;
-            annotationsData: import("../../helpers/chart-interface").IChartAnnotationsData[];
+            annotationsData: import("../common/common.interface").ICommonAnnotationsData[];
         };
         legend: {
             display: boolean;
-            position: "top" | "bottom" | "right";
-            align: "start" | "center" | "end";
-            customLegend: import("../../helpers/chart-interface").ICustomLegend;
+            position: Position;
+            align: AlignOptions;
+            customLegend: import("../common/common.interface").ICommonCustomLegend<any>;
             usePointStyle: boolean;
         };
         chartOptions: {
             showPoints: boolean;
-            enableZoom: true;
+            enableZoom: boolean;
             enablePan: boolean;
             showLine: boolean;
             closeOnOutsideClick: boolean;
         };
         interactions: {
-            onLegendClick: () => any;
-            onPointHover: () => any;
-            onPointUnhover: () => any;
-            onAnimationComplete: () => any;
+            onLegendClick: ((text: string, hidden: boolean) => void) | undefined;
+            onHover: ((event?: import("chart.js").ChartEvent | undefined, datasetIndex?: number | undefined, index?: number | undefined, generatedDataset?: any[] | undefined) => void) | undefined;
+            onUnhover: ((event?: import("chart.js").ChartEvent | undefined, datasetIndex?: number | undefined, index?: number | undefined, generatedDataset?: any[] | undefined) => void) | undefined;
+            onAnimationComplete: (() => void) | undefined;
         };
-        depthType: import("./line-chart.interface").IDepthType;
         dragData: {
             enableDragData: boolean;
             showTooltip: boolean;
             roundPoints: boolean;
             dragX: boolean;
             dragY: boolean;
-            onDragStart: () => any;
-            onDrag: () => any;
-            onDragEnd: () => any;
+            onDragStart: (() => void) | undefined;
+            onDrag: (() => void) | undefined;
+            onDragEnd: (() => void) | undefined;
         };
+        depthType: import("./line-chart.interface").IDepthType;
     };
 };

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

@@ -1,9 +1,6 @@
-import { LinearScaleOptions } from 'chart.js';
-import { IChartAnnotations, IChartDraggableData, IChartInteractions, IChartLegend, IChartStyling } from '../../helpers/chart-interface';
-export interface IChartOptions {
+import { ICommonAnnotations, ICommonChartOptions, ICommonCustomLegend, ICommonData, ICommonDataset, ICommonDragData, ICommonInteractions, ICommonLegend, ICommonOptions, ICommonScales, ICommonStyling, ICommonTooltip } from '../common/common.interface';
+export interface ILChartOptions extends ICommonChartOptions {
     showPoints: boolean;
-    enableZoom: boolean;
-    enablePan: boolean;
     closeOnOutsideClick: boolean;
     showLine: boolean;
 }
@@ -13,26 +10,24 @@ export interface ILineChartGraph {
     showDataLabels: boolean;
     showMinorGridlines: boolean;
 }
-export interface ILineChartTooltip {
-    tooltips: boolean;
-    showLabelsInTooltips: boolean;
+export interface ILineChartTooltip extends ICommonTooltip {
     hideSimulationName: boolean;
 }
-export interface IChartRange {
+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: {
-        x: IChartRange;
-        y: IChartRange;
-    };
+    stepSize?: number;
+    suggestedMin?: number;
+    suggestedMax?: number;
+    range?: ILineRange;
     autoAxisPadding: boolean;
 }
 export interface IUnitOptions {
@@ -43,77 +38,69 @@ export interface IUnitOptions {
 export interface ILineChartAxis<PositionType> {
     label: string;
     position: PositionType;
-    color: string;
+    color: string | string[];
     unit: IUnitOptions;
 }
 export interface ILineChartAxes {
     x: ILineChartAxis<'top' | 'bottom'>[];
     y: ILineChartAxis<'left' | 'right'>[];
-}
-export interface ILineScales {
-    x: LinearScaleOptions;
-    y: LinearScaleOptions;
+    [key: string]: ILineChartAxis<any>[];
 }
 export interface IDepthType {
     options: string[];
     selectedUnit: string;
     setSelectedUnit: () => void;
 }
-export interface IChartDragData {
-    enableDragData: boolean;
-    showTooltip: boolean;
-    roundPoints: boolean;
-    dragX: boolean;
-    dragY: boolean;
-    onDragStart: () => any;
-    onDrag: () => any;
-    onDragEnd: () => any;
-}
-export interface ILineChartOptions {
-    title: string | string[];
-    axes: any;
-    scales: any;
-    additionalAxesOptions: any;
-    chartStyling: IChartStyling;
+export interface ILineChartStyling extends ICommonStyling {
+    squareAspectRatio?: number;
+    layoutPadding?: string | 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: IChartAnnotations;
-    legend: IChartLegend;
-    chartOptions: IChartOptions;
-    interactions: IChartInteractions;
+    annotations: ICommonAnnotations;
+    legend: ILineLegend;
+    chartOptions: ILChartOptions;
+    interactions: ILineInteractions;
+    dragData?: ICommonDragData;
     depthType: IDepthType;
-    draggableData: IChartDraggableData;
-    dragData: IChartDragData;
 }
-export interface IDataPoint {
-    x: number;
-    y: number;
-    label?: string[];
-}
-export interface ILineChartDataset {
-    label?: string;
+export interface ILineChartDataset extends ICommonDataset {
     lineTension?: number;
-    borderColor?: string;
     pointBackgroundColor?: string;
-    backgroundColor?: string;
     pointRadius?: number;
     pointHoverRadius?: number;
     pointHitRadius?: number;
-    borderWidth?: number;
     fill?: boolean;
     yAxisID?: string;
     formation?: boolean;
-    data: IDataPoint[];
+    displayGroup?: any;
+    pointStyle?: string;
 }
-export interface ILineChartData {
-    testId: string | null;
-    data: {
-        labels?: string[];
+export interface ILineChartData extends ICommonData {
+    data?: {
         datasets: ILineChartDataset[];
-    } | any;
+    };
     options: ILineChartOptions;
-    persistenceId: string;
-    controlsPortalId: string | null;
+    persistenceId?: string;
+    controlsPortalId?: string;
 }
 export interface ILineChartProps {
     chart: ILineChartData;

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

@@ -1,4 +1,17 @@
+import { Chart, ChartConfiguration, Plugin } from 'chart.js';
+import { Position } from '../../common/helpers/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: any, _args: any, options: any) => void;
+    beforeDraw: (chart: Chart, _args: Plugin, options: CustomChartConfiguration) => void;
 };
+export {};

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

@@ -1,7 +1,8 @@
-export declare const getLargestMajorTickWidth: (majorTickPositions: any) => any;
-export declare const isValidPosition: (minorTickPosition: any, majorTickPositions: any, scale: any) => boolean;
-export declare const getMinorTickPositions: (majorTickPositions: Array<number>, scale: any) => number[];
+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: any) => void;
+    beforeDatasetsDraw: (chart: Chart) => void;
 };

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

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

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

@@ -1,16 +1,34 @@
+import { ILChartOptions, ILineChartAdditionalAxesOptions, ILineChartAxes, ILineLegend } from '../line-chart.interface';
+import { ICommonAnnotations, ICommonDragData } from '../../common/common.interface';
+interface inputInitState {
+    options: {
+        additionalAxesOptions: ILineChartAdditionalAxesOptions;
+        annotations: ICommonAnnotations;
+        axes: ILineChartAxes;
+        chartOptions: ILChartOptions;
+        legend: ILineLegend;
+        dragData: ICommonDragData;
+    };
+    persistenceId?: string;
+}
 /**
  Initial chart state for the line chart.
 
  @param {Object} options - The chart options.
  @return {Object} The initial chart state.
  */
-declare const initialState: ({ options, persistenceId }: any) => {
+declare const initialState: ({ options, persistenceId }: inputInitState) => {
     zoomEnabled: any;
     panEnabled: any;
     pointsEnabled: any;
     lineEnabled: any;
     legendEnabled: any;
-    axes: any[];
+    axes: {
+        unit?: import("../line-chart.interface").IUnitOptions | undefined;
+        max?: number | undefined;
+        min?: number | undefined;
+        id: string;
+    }[];
     showAnnotationLineIndex: number[];
     showTable: boolean;
     enableDragPoints: any;

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

@@ -1 +1,2 @@
-export declare const reducer: (state: any, action: any) => (base?: ((draft: any) => void) | undefined, ...args: unknown[]) => (draft: any) => void;
+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

@@ -1,14 +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;
+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: any, persistenceId: string) => void;
+export declare const storeChartStateInStorage: (state: IState, persistenceId?: string) => void;

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

@@ -1,8 +1,33 @@
-export interface IUseChartState {
-    chartRef: any;
-    options: any;
-    state: any;
-    generatedDatasets: Array<any>;
-    dispatch: () => void;
-    persistenceId: any;
+import { IUnitOptions } from '../line-chart.interface';
+export interface IAxisState {
+    id?: string;
+    label?: string;
+    min?: number;
+    max?: number;
+    unit?: IUnitOptions | string;
+    axisType?: string;
+}
+export interface InitialState {
+    zoomEnabled: boolean;
+    panEnabled: boolean;
+    pointsEnabled: boolean;
+    lineEnabled: boolean;
+    legendEnabled: boolean;
+    axes: IAxisState[];
+    showAnnotationLineIndex?: number[];
+    showTable: boolean;
+    enableDragPoints: boolean;
+}
+export interface IInitAxisRange {
+    id: string;
+    min: number;
+    max: number;
+    unit?: string;
+}
+export interface IState extends InitialState {
+    initialAxesRanges: IInitAxisRange[];
+}
+export interface IAction<T = string, P = any> {
+    type: T;
+    payload?: P;
 }

package/dist/src/components/line-chart/utils/datalabels-alignment/get-datalabels-position.d.ts

@@ -1,4 +1,4 @@
-import { AlignOptions } from '../../../../helpers/enums';
+import { AlignOptions } from '../../../common/helpers/enums';
 /** returning position depends on condition
  *
  * @return {string} - position

package/dist/src/components/line-chart/utils/generate-line-chart-datasets.d.ts

@@ -1,3 +1,5 @@
+import { IState } from '../state/state.interfaces';
+import { ILineChartOptions } from '../line-chart.interface';
 /**
  * Generates line chart datasets based on the provided datasets, state, and options.
  *
@@ -7,4 +9,4 @@
  * @param {Object} translations - The getTranslations object with the label property
  * @returns {Array} - The generated line chart datasets with applied settings and configurations.
  */
-export declare const generateLineChartDatasets: (datasets: Array<any>, state: any, options: any, { label }: any) => any[];
+export declare const generateLineChartDatasets: (datasets: Array<any>, state: IState, options: ILineChartOptions, { label }: any) => any[];

package/dist/src/components/line-chart/utils/get-axes-ranges-from-chart.d.ts

@@ -1,6 +1,13 @@
-export declare const getAxesRangesFromChart: (chartRef: any, axes: any) => {
-    unit?: any;
+import { Chart } from 'chart.js';
+import { RefObject } from 'react';
+import { IInitAxisRange } from '../state/state.interfaces';
+interface IAxes {
+    [key: string]: IInitAxisRange[];
+}
+export declare const getAxesRangesFromChart: (chartRef: RefObject<Chart>, axes: IAxes) => {
+    unit?: string | undefined;
     id: any;
     min: any;
     max: any;
 }[];
+export {};