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

package/dist/src/components/common/helpers/chart-consts.d.ts

@@ -0,0 +1,39 @@
+import { ICommonGradientColor } from '../common.interface';
+export declare const BORDER_WIDTH: {
+    ZERO: number;
+    INITIAL: number;
+    HOVERED: number;
+    POINT_HOVERED: number;
+};
+export declare const BORDER_COLOR = "rgba(0,0,0,0.1)";
+export declare const ANNOTATION_DASH: number[];
+export declare const DEFAULT_FONT_SIZE = 12;
+export declare const DEFAULT_FONT_FAMILY = "\"Roobert\", \"Noto Sans\", sans-serif";
+export declare const DEFAULT_COLOR = "hsl(60, 10.34482759%, 12.5%)";
+export declare const LEGEND_LABEL_BOX_SIZE = 12;
+export declare const TOOLTIP_PADDING = 8;
+export declare const TOOLTIP_BOX_PADDING = 4;
+export declare const TRANSPARENT = "transparent";
+export declare const LOGARITHMIC_STEPS: number[];
+export declare const COLORS: string[];
+/**
+ * @type {string}
+ * @desc equivalent of 0.6 rgba alpha chanel
+ */
+export declare const ALPHA_CHANEL = "99";
+/**
+ * @type {number}
+ * @desc #FFFFFF as decimal number
+ */
+export declare const WHITE_COLOR_AS_DECIMAL = 16777215;
+export declare const AUTO = "auto";
+export declare const ANIMATION_DURATION: {
+    NO: number;
+    SLOW: number;
+    FAST: number;
+};
+export declare const DEFAULT_CHART_NAME = "new_chart";
+export declare const CUSTOM_LEGEND_PLUGIN_NAME = "htmlLegend";
+export declare const DECIMAL_POINT_TOLERANCE = 9;
+export declare const MAX_DECIMAL_DIFF: number;
+export declare const GRADIENT_COLORS: ICommonGradientColor[];

package/dist/src/components/common/helpers/chart-utils.d.ts

@@ -0,0 +1,86 @@
+import { ChartTypeRegistry, LegendItem, Plugin } from 'chart.js';
+import { ICommonCustomLegend, UnusedParameter } from '../common.interface';
+import { Position } from '../enums';
+export interface IChartGraph {
+    showMinorGridlines?: boolean;
+}
+interface IOptions {
+    title?: string | string[];
+    legend?: {
+        position?: Position;
+        display?: boolean;
+        align?: string;
+        usePointStyle?: boolean;
+    };
+}
+interface IStyling {
+    width?: string | number;
+    height?: string | number;
+    squareAspectRatio?: number | boolean;
+    maintainAspectRatio?: boolean;
+    staticChartHeight?: boolean;
+    performanceMode?: boolean;
+}
+interface IAxis {
+    label?: string;
+}
+interface ILegend {
+    customLegend?: ICommonCustomLegend<any>;
+}
+/**
+ * @param { graph } graph - graph data from chart options
+ * @param { legend } legend
+ * @return {[]}
+ */
+export declare const getPlugins: <T extends keyof ChartTypeRegistry>(graph: IChartGraph | undefined, legend: ILegend) => Plugin<T>[] | any;
+/**
+ * @param {string[]} colors - color schema
+ * @return {string} - random color
+ */
+export declare const generateRandomColor: (colors: string[]) => string[];
+/**
+ * @param {ICommonChartOptions} options - chart options object
+ * @return {{color: (string|undefined), display: boolean, text}|{}}
+ */
+export declare const getTitle: (options: IOptions) => {
+    display: boolean;
+    text: string | string[];
+} | {
+    display?: undefined;
+    text?: undefined;
+};
+/**
+ * @function isVertical
+ */
+export declare const isVertical: (direction: "vertical" | "horizontal") => direction is "vertical";
+/**
+ * @param {'x'|'y'} axisType
+ * @param {number} i - index
+ * @return {'top'|'bottom'|'left'|'right'|*}
+ */
+export declare const getAxisPosition: (axisType: string, i: number) => Position;
+/**
+ * @param {chartStyling} chartStyling
+ * @param {Object} styles - styles imported form .less file
+ * @return {string} - class name
+ */
+export declare const getClassName: (chartStyling: IStyling, styles: Record<string, string>) => string;
+export declare const getLegend: (options: IOptions, clickHandler: (_: UnusedParameter, legendItem: LegendItem) => void) => {
+    position: any;
+    display: boolean | undefined;
+    align: "center" | "start" | "end";
+    labels: {
+        boxHeight: number;
+        boxWidth: number | undefined;
+        usePointStyle: boolean | undefined;
+    };
+    onClick: (_: UnusedParameter, legendItem: LegendItem) => void;
+};
+export declare const afterLabelCallback: (tooltipItem: Record<string, any>) => string;
+export declare const getTooltipLabel: (tooltipItem: Record<string, any>, showLabelsInTooltips: boolean) => string;
+export declare const sanitize: (str: string) => string;
+export declare const getChartFileName: (axes?: IAxis[]) => string;
+export declare const setDefaultTheme: () => void;
+export declare const isNilOrEmpty: <T>(value: T | null | undefined) => boolean;
+export declare const isEmptyString: (value: string) => value is "";
+export {};

package/dist/src/components/common/helpers/container.d.ts

@@ -0,0 +1,18 @@
+import { CSSProperties, ReactNode } from 'react';
+interface ContainerProps {
+    style?: CSSProperties;
+    children: ReactNode;
+    margin?: boolean;
+    deprecatedMessage?: string;
+    warningMessage?: string;
+}
+export declare const Container: {
+    ({ style, children, margin, deprecatedMessage, warningMessage, }: ContainerProps): import("react/jsx-runtime").JSX.Element;
+    defaultProps: {
+        style: {};
+        margin: boolean;
+        deprecatedMessage: null;
+        warningMessage: null;
+    };
+};
+export {};

package/dist/src/components/common/helpers/custom-format-number.d.ts

@@ -0,0 +1 @@
+export declare const customFormatNumber: (labelNumber: number, scientificNotation: boolean) => string;

package/dist/src/components/common/helpers/download-pgn.d.ts

@@ -0,0 +1,3 @@
+import { RefObject } from 'react';
+import { Chart } from 'chart.js';
+export declare const downloadPgn: (chartRef: RefObject<Chart>) => void;

package/dist/src/components/common/helpers/get-chart-annotation.d.ts

@@ -0,0 +1,139 @@
+import { Chart } from 'chart.js';
+import { AnnotationType } from '../plugins/annotation-dragger-plugin/enums';
+import { Position } from '../enums';
+import { ICommonAnnotationElement, ICommonAnnotationsData, ICoordinates } from '../common.interface';
+export interface IGetAnnotationsProps {
+    showAnnotations: boolean;
+    annotationsData: ICommonAnnotationsData[];
+}
+interface TChart extends Chart {
+    hoveredAnnotationId?: string | null;
+}
+export declare const generateAnn: (ann: ICommonAnnotationsData, index: number) => {
+    display: boolean | undefined;
+    annotationIndex: number;
+    id: string;
+    scaleID: "x" | "y" | undefined;
+    label: {
+        backgroundColor: string;
+        content: string | undefined;
+        display: boolean;
+        position: Position;
+        color?: undefined;
+        font?: undefined;
+        borderWidth?: undefined;
+        padding?: undefined;
+        borderRadius?: undefined;
+        borderColor?: undefined;
+    } | {
+        backgroundColor: string;
+        content: string | undefined;
+        display: boolean;
+        position: string;
+        color: string;
+        font: string;
+        borderWidth: number;
+        padding: number;
+        borderRadius: number;
+        borderColor: string;
+    } | {
+        position: {
+            x: string;
+            y: string;
+        } | undefined;
+        content: string | undefined;
+        backgroundColor?: string;
+        display: boolean;
+        color?: string;
+        font: string | {
+            weight: string;
+        };
+        borderColor?: string;
+        callout?: Record<string, unknown>;
+        borderWidth?: undefined;
+        padding?: undefined;
+        borderRadius?: undefined;
+    } | {
+        position: {
+            x: string;
+            y: string;
+        } | undefined;
+        content: string | undefined;
+        backgroundColor?: string;
+        display: boolean;
+        color?: string;
+        font: string | {
+            weight: string;
+        };
+        borderColor?: string;
+        callout?: Record<string, unknown>;
+        borderWidth?: undefined;
+        padding?: undefined;
+        borderRadius?: undefined;
+    } | {
+        position: {
+            x: string;
+            y: string;
+        } | undefined;
+        content: string | undefined;
+        backgroundColor?: string;
+        display: boolean;
+        color?: string;
+        font: string | {
+            weight: string;
+        };
+        borderColor?: string;
+        callout?: Record<string, unknown>;
+        borderWidth?: undefined;
+        padding?: undefined;
+        borderRadius?: undefined;
+    };
+    backgroundColor: string;
+    borderColor: string;
+    borderWidth: number;
+    borderDash: number[] | undefined;
+    type: AnnotationType;
+    adjustScaleRange: boolean | undefined;
+    enter: ({ element, }: {
+        element: ICommonAnnotationElement;
+    }, { chart, }: {
+        chart: TChart;
+    }) => void;
+    leave: ({ element, }: {
+        element: ICommonAnnotationElement;
+    }, { chart, }: {
+        chart: TChart;
+    }) => void;
+    onDragStart: () => (cord: ICoordinates, annotation: ICommonAnnotationsData) => void;
+    onDrag: () => (cord: ICoordinates, annotation: ICommonAnnotationsData) => void;
+    onDragEnd: () => (cord: ICoordinates, annotation: ICommonAnnotationsData) => void;
+    pointStyle: string;
+    resizable: boolean;
+    displayDragCoordinates: boolean;
+    hideLegend?: boolean;
+    labelOffsetPx?: number;
+    annotationAxis?: "x" | "y";
+    rotation?: number;
+    color?: string;
+    endValue?: number;
+    labelConfig?: import('../common.interface').IAnnotationLabelConfig;
+    value?: number;
+    xMin?: number;
+    xMax?: number;
+    yMin?: number;
+    yMax?: number;
+    xValue?: number;
+    yValue?: number;
+    radius?: number;
+    enableDrag?: boolean;
+    dragAxis?: import('../plugins/annotation-dragger-plugin/enums').DragAxis;
+    dragRange?: {
+        x?: [number, number];
+        y?: [number, number];
+    };
+    xScaleID?: string;
+    yScaleID?: string;
+    opacity?: number;
+};
+export declare const getAnnotation: ({ showAnnotations, annotationsData, }: IGetAnnotationsProps) => ICommonAnnotationElement[] | Record<string, any>[];
+export {};

package/dist/src/components/common/helpers/get-chart-from-ctx.d.ts

@@ -0,0 +1 @@
+export declare const getChartFromCtx: (ctx: any) => any;

package/dist/src/components/common/helpers/get-custom-legend-plugin-example.d.ts

@@ -0,0 +1,8 @@
+import { Chart, ChartConfiguration, Plugin } from 'chart.js';
+/**
+ * Gets an example custom legend plugin for use in storybook.
+ * @param {string} customLegendContainerID - the id of the div container to put the generated legend in
+ */
+export declare const getCustomLegendPlugin: (customLegendContainerID: string) => {
+    afterUpdate(chart: Chart, _args: Plugin, _options: ChartConfiguration): void;
+};

package/dist/src/components/common/helpers/get-draggableData.d.ts

@@ -0,0 +1,18 @@
+import { ICommonOptions } from '../common.interface';
+export interface IDraggableDataOptions {
+    dragX: boolean;
+    dragY: boolean;
+    round: boolean;
+    showTooltip: boolean;
+    onDragStart: () => void;
+    onDrag: () => void;
+    onDragEnd: () => void;
+}
+export interface IDraggableData {
+    dragData: IDraggableDataOptions;
+}
+/**
+ * @param {ICommonChartOptions} options - line chart options object
+ */
+declare const getDraggableData: (options: ICommonOptions) => IDraggableData | object;
+export default getDraggableData;

package/dist/src/components/common/helpers/get-grouped-color-scheme/get-grouped-color-scheme.d.ts

@@ -0,0 +1 @@
+export declare const getGroupedColorScheme: (length: number, startingColor: string) => string[];

package/dist/src/components/common/helpers/input-normalizers.d.ts

@@ -0,0 +1,15 @@
+import { AlignOptions, ChartDirection, Position } from '../enums';
+type TDragRange = {
+    x?: [number, number];
+    y?: [number, number];
+};
+export declare const normalizeTitle: (title: unknown) => string | string[];
+export declare const normalizeCartesianDirection: (direction: unknown) => "vertical" | "horizontal";
+export declare const normalizeChartDirection: (direction: unknown) => ChartDirection;
+export declare const normalizeLegendPosition: (position: unknown, fallback: Position) => Position;
+export declare const normalizeLegendAlign: (align: unknown, fallback: AlignOptions) => AlignOptions;
+export declare const normalizeDragRange: (range?: {
+    x?: number[] | [number, number];
+    y?: number[] | [number, number];
+}) => TDragRange;
+export {};

package/dist/src/components/common/helpers/range/estimate-data-series-have-close-values.d.ts

@@ -0,0 +1,8 @@
+import { TGeneratedLineChartDatasets } from '../../../line-chart/line-chart.interface';
+/**
+ * Estimates whether any of the data series has values that are all close together
+ * - checks only the first and last values in each series (i.e. assumes they are ordered)
+ * - uses an equality check with tolerance for decimal precision noise
+ * - this is just an inexpensive "guesstimate" (full min/max detection can be used afterwards)
+ */
+export declare const estimateDataSeriesHaveCloseValues: (generatedDatasets: TGeneratedLineChartDatasets) => boolean;

package/dist/src/components/common/helpers/range/range.d.ts

@@ -0,0 +1,33 @@
+interface IGetSuggestedAxisRange {
+    data: number[];
+    beginAtZero: boolean;
+    autoAxisPadding: boolean;
+}
+/**
+ * Overrides the default chart.js axis range for some edge-cases:
+ * - when no data -> default range
+ * - when all values are close to zero -> default range
+ * - when all values are close to each other -> custom 5% padding
+ * - when autoAxisPadding is set -> custom 5% padding
+ * - all other cases fall back to chart.js default behaviour
+ *
+ * `autoAxisPadding` feature requirements:
+ * - specified by Truls and ported by Mark+Oleg
+ * - numbers that are equal (within tolerance) shall be presented as a straight line
+ * - all other data series shall use 90% of width of axis (5% padding each side)
+ * - the padding on each side shall be symmetric
+ *
+ * @param {object} args
+ * @param {array<number|null>} args.data
+ * @param {boolean} [args.beginAtZero]
+ * @param {boolean>} [args.autoAxisPadding]
+ * @returns {object} returns {min, max} pair
+ */
+export declare const getSuggestedAxisRange: ({ data, beginAtZero, autoAxisPadding, }: IGetSuggestedAxisRange) => {
+    min: number;
+    max: number;
+} | {
+    min: undefined;
+    max: undefined;
+};
+export {};

package/dist/src/components/common/helpers/text.d.ts

@@ -0,0 +1 @@
+export declare const getTextWidth: (text: string, font: string) => number | undefined;

package/dist/src/components/common/helpers/to-annotation.d.ts

@@ -0,0 +1,4 @@
+import { ICommonAnnotationElement } from '../common.interface';
+export declare const toAnnotationObject: (annotationArr?: ICommonAnnotationElement[]) => {
+    annotations: {};
+};

package/dist/src/components/common/hooks/use-generated-labels.d.ts

@@ -0,0 +1,4 @@
+import { RefObject } from 'react';
+import { Chart } from 'chart.js';
+import { TLegendDatasets } from '../legend-component/legend-interface';
+export declare const useGeneratedLabels: (chartRef: RefObject<Chart>, generatedDatasets: TLegendDatasets) => any[];

package/dist/src/components/common/hooks/use-legend-state.d.ts

@@ -0,0 +1,28 @@
+import { RefObject } from 'react';
+import { Chart, LegendItem } from 'chart.js';
+import { UnusedParameter } from '../common.interface';
+export interface IUseLegendStateProps {
+    chartRef: RefObject<Chart>;
+    options: any;
+}
+/**
+ * Custom hook to manage legend state.
+ */
+export declare const useLegendState: ({ chartRef, options }: IUseLegendStateProps) => {
+    legendClick: (_: UnusedParameter, legendItem: LegendItem) => void;
+    annotation: import('../common.interface').ICommonAnnotationElement[];
+    legend: {
+        position: any;
+        display: boolean | undefined;
+        align: "center" | "start" | "end";
+        labels: {
+            boxHeight: number;
+            boxWidth: number | undefined;
+            usePointStyle: boolean | undefined;
+        };
+        onClick: (_: UnusedParameter, legendItem: LegendItem) => void;
+    };
+    customLegendPlugin: {
+        htmlLegend: any;
+    };
+};

package/dist/src/components/common/hooks/use-legend.d.ts

@@ -0,0 +1,4 @@
+export declare const useLegend: () => {
+    state: import('../legend-component/state/legend-state-reducer').ILegendState;
+    dispatch: React.Dispatch<any>;
+};

package/dist/src/components/common/hooks/use-update-annotations.d.ts

@@ -0,0 +1,4 @@
+import { Dispatch } from 'react';
+import { TLegendAction } from '../legend-component/state/legend-state-reducer';
+import { TChartsOption } from '../legend-component/legend-interface';
+export declare const useUpdateAnnotations: (options: TChartsOption, dispatch: Dispatch<TLegendAction>) => void;

package/dist/src/components/common/legend-component/legend-dropzone.d.ts

@@ -0,0 +1,3 @@
+import { ILegendDropZones } from './legend-interface';
+declare const LegendDropZones: (legendDropZonesProps: ILegendDropZones) => import("react/jsx-runtime").JSX.Element;
+export default LegendDropZones;

package/dist/src/components/common/legend-component/legend-interface.d.ts

@@ -0,0 +1,47 @@
+import { MouseEventHandler, RefObject } from 'react';
+import { Chart, ChartArea } from 'chart.js';
+import { IGeneratedScatterChartDataset, TGeneratedScatterChartDatasets, IScatterOptions } from '../../scatter-chart/scatter-chart.interface';
+import { Position, ChartType } from '../enums';
+import { IGeneratedLineChartDataset, ILineChartOptions, TGeneratedLineChartDatasets } from '../../line-chart/line-chart.interface';
+import { IBarOptions, IGenerateBarChartDataset, TGenerateBarChartDatasets } from '../../bar-chart/bar-chart.interface';
+import { IGeneratedPieChartDataset, IPieOptions, TGeneratedPieChartDatasets } from '../../pie-chart/pie-chart.interface';
+export interface ILegendDropZone {
+    position: Position;
+    onDrop: () => void;
+    placeholderSize?: {
+        width?: number;
+        height?: number;
+    };
+}
+export interface ILegendDropZones {
+    chartArea?: ChartArea;
+    setLegendPosition: (position: Position) => void;
+    isDragging: boolean;
+    placeholderSize?: {
+        width?: number;
+        height?: number;
+    };
+}
+export type TLegendDataset = IGeneratedLineChartDataset | IGenerateBarChartDataset | IGeneratedPieChartDataset | IGeneratedScatterChartDataset;
+export type TLegendDatasets = TGeneratedLineChartDatasets | TGenerateBarChartDatasets | TGeneratedPieChartDatasets | TGeneratedScatterChartDatasets;
+export type TChartsOption = ILineChartOptions | IBarOptions | IPieOptions | IScatterOptions;
+export interface ILegendItem {
+    hidden: boolean;
+    dataset: TLegendDataset;
+    handleClick: MouseEventHandler<HTMLDivElement>;
+    chartType: ChartType;
+    index: number;
+}
+export interface ILegendConfig {
+    options: TChartsOption;
+    generatedDatasets: TLegendDatasets;
+    chartType: ChartType;
+}
+export interface ILegend {
+    chartRef: RefObject<Chart>;
+    legendConfig: ILegendConfig;
+}
+export interface ILegendPanel extends ILegend {
+    legendPosition: Position;
+    isDragging: boolean;
+}

package/dist/src/components/common/legend-component/legend-item/LegendItemLine.d.ts

@@ -0,0 +1,5 @@
+import { IGeneratedLineChartDataset } from '../../../line-chart/line-chart.interface';
+export interface ILineLegendItemProp {
+    dataset: IGeneratedLineChartDataset;
+}
+export declare const LegendItemLine: ({ dataset }: Record<string, any>) => import("react/jsx-runtime").JSX.Element;

package/dist/src/components/common/legend-component/legend-item/legend-item.d.ts

@@ -0,0 +1,3 @@
+import { ILegendItem } from '../legend-interface';
+declare const LegendItem: ({ hidden, dataset, handleClick, chartType, index, }: ILegendItem) => import("react/jsx-runtime").JSX.Element;
+export default LegendItem;

package/dist/src/components/common/legend-component/legend-panel.d.ts

@@ -0,0 +1,3 @@
+import { ILegendPanel } from './legend-interface';
+declare const LegendPanel: import('react').ForwardRefExoticComponent<ILegendPanel & import('react').RefAttributes<HTMLDivElement>>;
+export default LegendPanel;

package/dist/src/components/common/legend-component/legend.d.ts

@@ -0,0 +1,3 @@
+import { ILegend } from './legend-interface';
+declare const Legend: ({ chartRef, legendConfig }: ILegend) => import("react/jsx-runtime").JSX.Element;
+export default Legend;

package/dist/src/components/common/legend-component/state/legend-action-types.d.ts

@@ -0,0 +1,3 @@
+export declare const TOGGLE_DATA_VISIBILITY = "TOGGLE_DATA_VISIBILITY";
+export declare const RESET_STATE = "RESET_STATE";
+export declare const SET_ANNOTATION = "SET_ANNOTATION";

package/dist/src/components/common/legend-component/state/legend-context.d.ts

@@ -0,0 +1,14 @@
+import { default as React, ReactNode } from 'react';
+import { ILegendState } from './legend-state-reducer';
+import { TChartsOption } from '../legend-interface';
+import { ICommonDataset } from '../../common.interface';
+export declare const LegendContext: React.Context<{
+    state: ILegendState;
+    dispatch: React.Dispatch<any>;
+} | undefined>;
+export interface ILegendProviderProps {
+    children: ReactNode;
+    options: TChartsOption;
+    datasets?: ICommonDataset[];
+}
+export declare const LegendProvider: ({ children, options, datasets, }: ILegendProviderProps) => import("react/jsx-runtime").JSX.Element;

package/dist/src/components/common/legend-component/state/legend-state-reducer.d.ts

@@ -0,0 +1,30 @@
+import { Chart } from 'chart.js';
+import { TLegendDataset, TLegendDatasets } from '../legend-interface';
+import { RESET_STATE, SET_ANNOTATION, TOGGLE_DATA_VISIBILITY } from './legend-action-types';
+import { ICommonAnnotationElement, ICommonDataset } from '../../common.interface';
+export interface ILegendState {
+    datasets: ICommonDataset[];
+    annotation: ICommonAnnotationElement[];
+}
+export type TLegendAction = {
+    type: typeof TOGGLE_DATA_VISIBILITY;
+    payload: {
+        chartInstance: Chart;
+        dsConfig: {
+            datasetIndex: number;
+            dataset: TLegendDataset;
+            datasets: TLegendDatasets;
+        };
+        annotationConfig: {
+            annotationIndex: number;
+        };
+    };
+} | {
+    type: typeof RESET_STATE;
+    payload: ILegendState;
+} | {
+    type: typeof SET_ANNOTATION;
+    payload: ICommonAnnotationElement[];
+};
+export declare const legendInitialState: ILegendState;
+export declare const legendReducer: (state: ILegendState, action: TLegendAction) => ILegendState;

package/dist/src/components/common/legend-component/utils/create-style-object.d.ts

@@ -0,0 +1,27 @@
+import { Position } from '../../enums';
+export declare const LEGEND_MARGIN = 4;
+interface IChartArea {
+    top: number;
+    left: number;
+    bottom: number;
+    right: number;
+}
+interface IChart {
+    height?: number;
+    width?: number;
+    chartArea: IChartArea;
+}
+interface ILegendStyle {
+    left: number | undefined;
+    right: number | undefined;
+    top: number | undefined;
+    bottom: number | undefined;
+    maxHeight: number;
+    maxWidth: number;
+    margin: number;
+}
+/**
+ * Creates a style object for positioning and sizing the legend panel based on the chart dimensions and legend position.
+ */
+export declare const createLegendStyle: (legendPosition: Position, chart: IChart | null) => ILegendStyle;
+export {};

package/dist/src/components/common/legend-component/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/common/plugins/annotation-dragger-plugin/annotation-dragger-plugin.d.ts

@@ -0,0 +1,15 @@
+import { ChartType, Plugin, Scale } from 'chart.js';
+export interface IScales {
+    x: Scale;
+    y: Scale;
+    [key: string]: Scale;
+}
+export interface AnnotationDraggerPluginOptions {
+    enabled: boolean;
+}
+declare module 'chart.js' {
+    interface PluginOptionsByType<TType extends ChartType> {
+        annotationDraggerPlugin?: AnnotationDraggerPluginOptions;
+    }
+}
+export declare const annotationDraggerPlugin: Plugin;

package/dist/src/components/common/plugins/annotation-dragger-plugin/annotation-position-storage.d.ts

@@ -0,0 +1,7 @@
+export interface TStoredAnnotationPosition {
+    x: number;
+    y: number;
+    [key: string]: any;
+}
+export declare const setAnnotationPosition: (persistenceId: string | undefined, annotationId: string, pos: TStoredAnnotationPosition) => void;
+export declare const getAnnotationPosition: (persistenceId: string | undefined, annotationId: string) => TStoredAnnotationPosition | undefined;

package/dist/src/components/common/plugins/annotation-dragger-plugin/enums.d.ts

@@ -0,0 +1,21 @@
+export declare enum FontStyle {
+    DEFAULT = "14px Arial",
+    CUSTOM = "16px Arial"
+}
+export declare enum MouseEvents {
+    MOUSEDOWN = "mousedown",
+    MOUSEMOVE = "mousemove",
+    MOUSEUP = "mouseup"
+}
+export declare enum AnnotationType {
+    POINT = "point",
+    BOX = "box",
+    LINE = "line",
+    ELLIPSE = "ellipse",
+    LABEL = "label"
+}
+export declare enum DragAxis {
+    X = "x",
+    Y = "y",
+    Both = "both"
+}

package/dist/src/components/common/plugins/annotation-dragger-plugin/event-helpers.d.ts

@@ -0,0 +1,6 @@
+import { Chart } from 'chart.js';
+import { IScales } from './annotation-dragger-plugin';
+import { ICommonAnnotationsData } from '../../common.interface';
+export declare const handleAnnotationMouseDown: (event: MouseEvent, canvas: HTMLCanvasElement, scales: IScales, annotations: Record<string, ICommonAnnotationsData>, setDraggingState: (isDragging: boolean, annotation: ICommonAnnotationsData | null, dragStartX: number, dragStartY: number) => void, hoveredAnnotationId: string | null) => void;
+export declare const handleAnnotationMouseMove: (event: MouseEvent, canvas: HTMLCanvasElement, scales: IScales, isDragging: boolean, activeAnnotation: ICommonAnnotationsData | null, dragStartX: number, dragStartY: number, chart: Chart) => void;
+export declare const handleAnnotationMouseUp: (isDragging: boolean, activeAnnotation: ICommonAnnotationsData | null, chart: Chart, canvas: HTMLCanvasElement, setDraggingState: (isDragging: boolean, annotation: ICommonAnnotationsData | null) => void, persistenceId?: string) => void;