@oliasoft-open-source/charts-library 5.0.0-beta-2 → 5.0.0

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

@@ -0,0 +1,6 @@
+import { IControls } from './controls-interfaces';
+/**
+ * @param {import('./controls-interfaces').IControls} obj
+ */
+declare const Controls: ({ headerComponent, subheaderComponent, table, chartRef, state, options, dispatch, generatedDatasets, translations, controlsPortalId, }: IControls) => import("react/jsx-runtime").JSX.Element;
+export default Controls;

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

@@ -0,0 +1,14 @@
+export interface IDragOptions {
+    onTogglePan: () => void;
+    onToggleZoom: () => void;
+    panEnabled: boolean;
+    zoomEnabled: boolean;
+    enableDragPoints?: boolean;
+    enableDragAnnotation?: boolean;
+    isDragDataAllowed?: boolean;
+    isDragAnnotationAllowed?: boolean;
+    onToggleDragAnnotation: () => void;
+    onToggleDragPoints: () => void;
+    onDisableDragOptions: () => void;
+    translations: Record<string, string>;
+}

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

@@ -0,0 +1,23 @@
+import { IMenuSection } from '@oliasoft-open-source/react-ui-library';
+import { IDragOptions } from './drag-options-interfaces';
+export declare function getDragOptions({ onTogglePan, onToggleZoom, panEnabled, zoomEnabled, enableDragPoints, enableDragAnnotation, isDragDataAllowed, isDragAnnotationAllowed, onToggleDragAnnotation, onToggleDragPoints, onDisableDragOptions, translations: { dragToZoom, doubleClickToReset, dragToPan, dragToMovePoints, dragDisabled, dragToMoveAnnotation, }, }: IDragOptions): ({
+    label: string;
+    description: string;
+    icon: import("react/jsx-runtime").JSX.Element;
+    selected: boolean;
+    type: string;
+    onClick: () => void;
+} | {
+    label: string;
+    icon: import("react/jsx-runtime").JSX.Element;
+    selected: boolean | undefined;
+    type: string;
+    onClick: () => void;
+    description?: undefined;
+})[];
+/**
+ * @param {import('./drag-options-interfaces').IDragOptions} obj
+ */
+export declare const DragOptions: ({ options }: {
+    options: IMenuSection[];
+}) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,19 @@
+import { IMenuSection } from '@oliasoft-open-source/react-ui-library';
+interface ILineOptions {
+    lineEnabled: boolean;
+    onToggleLine: () => void;
+    onTogglePoints: () => void;
+    pointsEnabled: boolean;
+    translations: Record<string, string>;
+}
+export declare function getLineOptions({ lineEnabled, onToggleLine, onTogglePoints, pointsEnabled, translations, }: ILineOptions): {
+    type: string;
+    label: string;
+    icon: import("react/jsx-runtime").JSX.Element;
+    selected: boolean;
+    onClick: () => void;
+}[];
+export declare const LineOptions: ({ options }: {
+    options: IMenuSection[];
+}) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,32 @@
+import { Dispatch, KeyboardEvent, RefObject, SetStateAction } from 'react';
+import { Chart, ChartEvent } from 'chart.js';
+import { ICommonDataValue, ICommonHoveredItems } from '../../common/common.interface';
+import { ILineChartOptions, TGeneratedLineChartDatasets } from '../line-chart.interface';
+import { IAxisState, IState } from '../state/state.interfaces';
+interface IUseChartFunctions {
+    chartRef: RefObject<Chart>;
+    state: IState;
+    options: ILineChartOptions;
+    dispatch: Dispatch<any>;
+    generatedDatasets: TGeneratedLineChartDatasets;
+}
+/**
+ * Custom hook that encapsulates the chart-related functions and their dependencies
+ */
+export declare const useChartFunctions: ({ chartRef, state, options, dispatch, generatedDatasets, }: IUseChartFunctions) => {
+    resetZoom: () => void;
+    onHover: (hoveredPoint: ICommonDataValue | null, setHoveredPoint: Dispatch<SetStateAction<ICommonDataValue | null>>) => (evt: ChartEvent, hoveredItems: ICommonHoveredItems[]) => void;
+    handleDownload: () => void;
+    handleKeyDown: (event: KeyboardEvent<HTMLDivElement>) => void;
+    handleKeyUp: (event: KeyboardEvent<HTMLDivElement>) => void;
+    controlsAxesLabels: {
+        id: string;
+        label: string;
+    }[];
+    updateAxesRangesFromChart: () => void;
+    onResetAxes: () => void;
+    onUpdateAxes: ({ axes }: {
+        axes: IAxisState;
+    }) => void;
+};
+export {};

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

@@ -0,0 +1,16 @@
+import { Dispatch, RefObject } from 'react';
+import { Chart } from 'chart.js';
+import { IState } from '../state/state.interfaces';
+import { ILineChartOptions, TGeneratedLineChartDatasets } from '../line-chart.interface';
+interface IUseChartOptions {
+    chartRef: RefObject<Chart>;
+    state: IState;
+    options: ILineChartOptions;
+    dispatch: Dispatch<any>;
+    generatedDatasets: TGeneratedLineChartDatasets;
+}
+/**
+ * Custom hook to generate chart options.
+ */
+export declare const useChartOptions: ({ chartRef, state, options, dispatch, generatedDatasets, }: IUseChartOptions) => any;
+export {};

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

@@ -0,0 +1,7 @@
+import { ILineChartOptions } from '../line-chart.interface';
+interface IUseChartPlugins {
+    options: ILineChartOptions;
+    resetZoom: () => void;
+}
+export declare const useChartPlugins: ({ options, resetZoom }: IUseChartPlugins) => any[];
+export {};

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

@@ -0,0 +1,17 @@
+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;
+    dispatch: Dispatch<any>;
+    persistenceId?: string;
+    generatedDatasets: ILineChartDataset[];
+}
+/**
+ * Hook for managing the state of the chart.
+ */
+export declare const useChartState: ({ chartRef, options, state, dispatch, persistenceId, generatedDatasets, }: IUseChartState) => void;
+export {};

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

@@ -0,0 +1,12 @@
+import { Dispatch } from 'react';
+export declare const useToggleHandlers: (dispatch: Dispatch<any>) => {
+    onToggleLegend: () => void;
+    onToggleLine: () => void;
+    onTogglePan: () => void;
+    onTogglePoints: () => void;
+    onToggleTable: () => void;
+    onToggleZoom: () => void;
+    onToggleDragPoints: () => void;
+    onToggleDragAnnotation: () => void;
+    onDisableDragOptions: () => void;
+};

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

@@ -0,0 +1,12 @@
+/**
+ * Retrieve the value for the given key from the config object.
+ * @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: (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: string | Record<string, string>) => void;

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

@@ -0,0 +1,12 @@
+/**
+ * Initialize the charts library with the provided configurations.
+ * This function will store the configuration options in a config object.
+ * @param {object} options - An object containing the configuration options for the library.
+ * @param {object} options.translations - The translations to be used in the library.
+ * @param {string} options.languageKey - The language key to be stored in the config object, used for translations.
+ * @param {...object} options - Any additional options to be stored in the config object.
+ */
+export declare const initializeLineChart: ({ languageKey, ...options }: {
+    [x: string]: any;
+    languageKey?: string | undefined;
+}) => void;

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

@@ -0,0 +1,2 @@
+import { ILineChartData, ILineChartProps } from './line-chart.interface';
+export declare const getDefaultProps: (props: ILineChartProps) => ILineChartData;

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

@@ -0,0 +1,3 @@
+import { ILineChartProps } from './line-chart.interface';
+declare const LineChartWithLegend: (props: ILineChartProps) => import("react/jsx-runtime").JSX.Element;
+export { LineChartWithLegend as LineChart };

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

@@ -0,0 +1,146 @@
+import { ReactNode } from 'react';
+import { ICommonAnnotations, ICommonChartOptions, ICommonCustomLegend, ICommonData, ICommonDataset, ICommonDataValue, ICommonDragData, ICommonInteractions, ICommonLegend, ICommonOptions, ICommonScales, ICommonStyling, ICommonTooltip } from '../common/common.interface';
+export interface ILChartOptions extends ICommonChartOptions {
+    showPoints: boolean;
+    closeOnOutsideClick: boolean;
+    showLine: 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 = any> {
+    id?: string;
+    label: string;
+    position: PositionType;
+    color: string | string[];
+    unit?: IUnitOptions;
+    stepSize?: number;
+    gridLines?: ILineChartGraph;
+}
+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;
+}
+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: ILineChartData;
+    table?: ReactNode;
+}
+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[];

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/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: 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/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/helpers/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 SAVE_INITIAL_AXES_RANGES = "SAVE_INITIAL_AXES_RANGES";
+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";

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

@@ -0,0 +1,14 @@
+import { IState } from './state.interfaces';
+import { ILineChartOptions } from '../line-chart.interface';
+interface inputInitState {
+    options: ILineChartOptions;
+    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 }: 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,34 @@
+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;
+    enableDragAnnotation: 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/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,11 @@
+import { RefObject } from 'react';
+import { Chart } from 'chart.js';
+import { ILineChartOptions, TGeneratedLineChartDatasets } from '../../line-chart.interface';
+import { IState } from '../../state/state.interfaces';
+/**
+ * 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, chartRef: RefObject<Chart>) => {};

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 {};

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

@@ -0,0 +1,20 @@
+interface IChartArea {
+    left: number | null;
+    right: number | null;
+    bottom: number | null;
+}
+interface IChartMeta {
+    data: Array<{
+        x: number | null;
+        y: number | null;
+    }>;
+}
+export interface IAlignmentContext {
+    chart: {
+        chartArea: IChartArea;
+        getDatasetMeta: (datasetIndex: number) => IChartMeta;
+    };
+    dataIndex: number;
+    datasetIndex: number;
+}
+export {};

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

@@ -0,0 +1,8 @@
+/**
+ * Returning boolean condition depends on label position and chart area
+ */
+export declare const getCondition: (x: number | null, y: number | null, left: number | null, right: number | null, bottom: number | null) => {
+    overLeftSide: boolean;
+    overRightSide: boolean;
+    overBottomSide: boolean;
+};

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

@@ -0,0 +1,11 @@
+import { IAlignmentContext } from './datalabels-alignment.interface';
+/**
+ * Returning destructured data from context
+ */
+export declare const getAlignmentData: (context: IAlignmentContext) => {
+    x: number | null;
+    y: number | null;
+    left: number | null;
+    right: number | null;
+    bottom: number | null;
+};

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

@@ -0,0 +1,6 @@
+import { AlignOptions } from '../../../common/helpers/enums';
+import { IAlignmentContext } from './datalabels-alignment.interface.ts';
+/**
+ * Returning position depends on condition
+ */
+export declare const getPosition: () => (context: IAlignmentContext) => AlignOptions.End | AlignOptions.Start | AlignOptions.Right | AlignOptions.Left;

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

@@ -0,0 +1,4 @@
+export declare enum CUSTOM_OPTION {
+    showLine = "showLine",
+    showPoints = "showPoints"
+}

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

@@ -0,0 +1,8 @@
+import { IState } from '../state/state.interfaces';
+import { ILineChartOptions, TGeneratedLineChartDatasets } from '../line-chart.interface';
+/**
+ * Generates line chart datasets based on the provided datasets, state, and options.
+ */
+export declare const generateLineChartDatasets: (datasets: Array<any>, state: IState, options: ILineChartOptions, { label }: {
+    label: string;
+}) => TGeneratedLineChartDatasets;

package/dist/src/components/line-chart/utils/get-annotations-data.d.ts

@@ -0,0 +1 @@
+export function getAnnotationsData(data: any[]): Object;

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

@@ -0,0 +1 @@
+export function getAxesDataFromMetasets(chartRef: Object, scalesKeys: any[], annotationsData: Object): Object;

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

@@ -0,0 +1,9 @@
+import { Chart } from 'chart.js';
+import { RefObject } from 'react';
+import { ILineChartAxes } from '../line-chart.interface';
+export declare const getAxesRangesFromChart: (chartRef: RefObject<Chart>, axes: ILineChartAxes) => {
+    unit?: import('../line-chart.interface').IUnitOptions | undefined;
+    id: string;
+    min: number;
+    max: number;
+}[];

package/dist/src/components/line-chart/utils/get-axis-range-by-type.d.ts

@@ -0,0 +1,10 @@
+import { RefObject } from 'react';
+import { Chart } from 'chart.js';
+import { ICommonAnnotationsData } from '../../common/common.interface.ts';
+export type TAxisType = 'x' | 'y' | 'x1' | 'y1';
+interface IMinMax {
+    min: number;
+    max: number;
+}
+export declare const getAxisRangeByType: (chartRef: RefObject<Chart>, axesType: TAxisType, annotationsData: ICommonAnnotationsData[]) => IMinMax | null;
+export {};

package/dist/src/components/line-chart/utils/get-generated-labels.d.ts

@@ -0,0 +1,2 @@
+import { Chart, LegendItem } from 'chart.js';
+export declare const getGeneratedLabels: (chart: Chart) => LegendItem[];

package/dist/src/components/line-chart/utils/get-line-chart-data-labels.d.ts

@@ -0,0 +1,19 @@
+import { TooltipItem } from 'chart.js';
+import { ILineChartOptions } from '../line-chart.interface';
+import { UnusedParameter } from '../../common/common.interface';
+/**
+ * adjusts the position of the label depends on chart area
+ *
+ * @param {import('../line-chart.interface').ILineChartOptions} options - line chart options object
+ * @return {object} - returning position, if label exist in datasets item
+ */
+declare const getLineChartDataLabels: (options: ILineChartOptions) => {
+    display: string;
+    align: (context: import('./datalabels-alignment/datalabels-alignment.interface').IAlignmentContext) => import("../../../..").AlignOptions.End | import("../../../..").AlignOptions.Start | import("../../../..").AlignOptions.Right | import("../../../..").AlignOptions.Left;
+    formatter: (_: UnusedParameter, context: TooltipItem<any>) => any;
+} | {
+    display: boolean;
+    align?: undefined;
+    formatter?: undefined;
+};
+export default getLineChartDataLabels;

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

@@ -0,0 +1,4 @@
+import { IState } from '../state/state.interfaces';
+import { ILineChartOptions } from '../line-chart.interface';
+declare const getLineChartScales: (options: ILineChartOptions, state: IState) => {};
+export default getLineChartScales;