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

package/dist/src/components/bar-chart/bar-chart-const.d.ts

@@ -0,0 +1,2 @@
+export declare const DISPLAY_SCIENTIFIC_LOWER_BOUND = 0.0001;
+export declare const DISPLAY_SCIENTIFIC_UPPER_BOUND = 10000000;

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

@@ -0,0 +1,3 @@
+import { IBarChartProps, IBarDefaultProps, IBarOptionsInput } from './bar-chart.interface';
+export declare const normalizeBarOptions: (options?: IBarOptionsInput) => IBarDefaultProps["options"];
+export declare const getDefaultProps: (props: IBarChartProps) => IBarDefaultProps;

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

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

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

@@ -0,0 +1,141 @@
+import { ChartDataset } from 'chart.js';
+import { DeepPartial, ICommonAdditionalAxesOptions, ICommonAnnotations, ICommonAnnotationsData, ICommonAxis, ICommonChartOptions, ICommonCustomLegend, ICommonData, ICommonDataset, ICommonDataValue, ICommonDragData, ICommonGraph, ICommonInteractions, ICommonLegend, ICommonOptions, ICommonScales, ICommonStyling, ICommonTooltip } from '../common/common.interface';
+import { IChartGraph } from '../common/helpers/chart-utils';
+import { ChartType } from '../common/enums';
+export interface IBarStyling extends ICommonStyling {
+    squareAspectRatio?: boolean;
+    layoutPadding?: string | number | {
+        top: number;
+        bottom: number;
+        left: number;
+        right: number;
+    };
+}
+export interface IBarLegend extends ICommonLegend {
+    customLegend?: ICommonCustomLegend<any>;
+}
+export interface IBarAxes {
+    x: ICommonAxis<'top' | 'bottom'>[];
+    y: ICommonAxis<'left' | 'right'>[];
+    [key: string]: ICommonAxis[];
+}
+export interface IBarAdditionalAxesOptions extends ICommonAdditionalAxesOptions {
+    stackedX?: boolean;
+    stackedY?: boolean;
+}
+export interface IBarOptions extends ICommonOptions {
+    direction?: 'vertical' | 'horizontal';
+    axes: IBarAxes;
+    scales?: ICommonScales;
+    additionalAxesOptions?: IBarAdditionalAxesOptions;
+    chartStyling: IBarStyling;
+    graph?: ICommonGraph;
+    annotations?: ICommonAnnotations;
+    legend?: IBarLegend;
+    dragData?: ICommonDragData;
+}
+export interface IBarChartDataset extends ICommonDataset {
+    isAnnotation?: boolean;
+    annotationIndex?: number;
+    borderSkipped?: boolean;
+    borderRadius?: number;
+    xAxisID?: string;
+    yAxisID?: string;
+    hidden?: boolean;
+    displayGroup?: string | number;
+    type?: ChartType.BAR;
+}
+export interface IBarChartBaseData {
+    labels: string[];
+    datasets: IBarChartDataset[];
+}
+export interface IBarChartData extends ICommonData {
+    testId?: string;
+    controlsPortalId?: string;
+    data: IBarChartBaseData;
+    options: IBarOptions;
+}
+type ILooseBarAxis = DeepPartial<ICommonAxis<string>> & {
+    [key: string]: unknown;
+};
+type ILooseBarAnnotation = DeepPartial<ICommonAnnotationsData> & {
+    [key: string]: unknown;
+} & {
+    annotationAxis?: string;
+    type?: string;
+    value?: number | string | null;
+};
+export type IBarOptionsInput = Omit<DeepPartial<IBarOptions>, 'title' | 'direction' | 'axes' | 'legend' | 'chartStyling' | 'interactions' | 'annotations'> & {
+    [key: string]: unknown;
+    title?: unknown;
+    direction?: string;
+    axes?: {
+        x?: ILooseBarAxis[];
+        y?: ILooseBarAxis[];
+        [key: string]: ILooseBarAxis[] | undefined;
+    };
+    legend?: Omit<DeepPartial<IBarLegend>, 'position' | 'align'> & {
+        position?: string;
+        align?: string;
+        [key: string]: unknown;
+    };
+    chartStyling?: DeepPartial<IBarStyling> & {
+        hideControls?: boolean;
+        minHeight?: number | string;
+        [key: string]: unknown;
+    };
+    interactions?: DeepPartial<ICommonInteractions> & {
+        enableZoom?: boolean;
+        enablePan?: boolean;
+        [key: string]: unknown;
+    };
+    annotations?: (DeepPartial<ICommonAnnotations> & {
+        annotationsData?: ILooseBarAnnotation[];
+    }) | null;
+};
+export interface IBarChartDataInput extends Omit<IBarChartData, 'options' | 'data'> {
+    data?: Omit<DeepPartial<IBarChartData['data']>, 'datasets'> & {
+        datasets?: Array<DeepPartial<IBarChartDataset> | object | null>;
+    };
+    options?: IBarOptionsInput;
+}
+export interface IBarChartProps {
+    chart: IBarChartDataInput;
+}
+export interface IBarDefaultProps {
+    testId: string;
+    controlsPortalId: string;
+    data: IBarChartBaseData;
+    options: {
+        title?: string | string[];
+        direction: 'vertical' | 'horizontal';
+        axes: IBarAxes;
+        additionalAxesOptions: IBarAdditionalAxesOptions;
+        chartStyling: IBarStyling;
+        tooltip: ICommonTooltip;
+        graph: IChartGraph;
+        scales?: ICommonScales;
+        annotations: {
+            showAnnotations: boolean;
+            controlAnnotation: boolean;
+            annotationsData: ICommonAnnotationsData[];
+        };
+        legend: IBarLegend;
+        chartOptions: ICommonChartOptions;
+        interactions: ICommonInteractions;
+        dragData: ICommonDragData;
+    };
+}
+export interface IGenerateBarChartDataset extends ChartDataset<'bar', ICommonDataValue[]> {
+    borderColor: string;
+    backgroundColor: string | string[];
+    borderDash?: number[];
+    borderWidth?: number;
+    annotationType?: string;
+    hideLegend?: boolean;
+    displayGroup?: string | number;
+    isAnnotation?: boolean;
+    annotationIndex?: number;
+}
+export type TGenerateBarChartDatasets = IGenerateBarChartDataset[];
+export {};

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

@@ -0,0 +1,10 @@
+import { IBarOptions } from '../bar-chart.interface.ts';
+type ExtendedDisplayOptions = 'auto' | boolean;
+export interface IExtendedDataLabelsOptions {
+    display: ExtendedDisplayOptions;
+}
+/**
+ * Returns the data labels configuration for a bar chart.
+ */
+declare const getBarChartDataLabels: (options: IBarOptions) => IExtendedDataLabelsOptions;
+export default getBarChartDataLabels;

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

@@ -0,0 +1,3 @@
+import { IBarDefaultProps } from '../bar-chart.interface';
+declare const getBarChartScales: (chart: IBarDefaultProps) => any;
+export default getBarChartScales;

package/dist/src/components/bar-chart/utils/get-bar-chart-tooltips.d.ts

@@ -0,0 +1,6 @@
+import { IBarOptions } from '../bar-chart.interface';
+/**
+ * @param {IBarOptions} options - bar chart options object
+ */
+declare const getBarChartToolTips: (options: IBarOptions) => Record<string, any>;
+export default getBarChartToolTips;

package/dist/src/components/bar-chart/utils/use-bar-chart-config.d.ts

@@ -0,0 +1,13 @@
+import { RefObject } from 'react';
+import { ActiveElement, Chart, ChartEvent } from 'chart.js';
+import { IBarDefaultProps, IBarOptions, TGenerateBarChartDatasets } from '../bar-chart.interface';
+import { ICommonHoveredItems } from '../../common/common.interface';
+export interface IGenerateBarChartDatasetsProps {
+    datasets: TGenerateBarChartDatasets;
+    options: IBarOptions;
+}
+export declare const useBarChartConfig: (_chartRef: RefObject<Chart>, chart: IBarDefaultProps) => {
+    generatedDatasets: TGenerateBarChartDatasets;
+    onClick: (_evt: ChartEvent, _elements: ActiveElement[], chartInstance: Chart) => void;
+    onHover: (evt: ChartEvent, hoveredItems: ICommonHoveredItems[]) => void;
+};

package/dist/src/components/bar-chart/utils/use-bar-chart-options.d.ts

@@ -0,0 +1,55 @@
+import { MutableRefObject } from 'react';
+import { Chart } from 'chart.js';
+import { AxisType, ChartHoverMode } from '../../common/enums';
+import { IBarDefaultProps } from '../bar-chart.interface';
+export interface IUseBarChartOptionsProps {
+    chart: IBarDefaultProps;
+    chartRef: MutableRefObject<Chart | null>;
+}
+export declare const useBarChartOptions: ({ chart, chartRef, }: IUseBarChartOptionsProps) => {
+    onClick: (_evt: import('chart.js').ChartEvent, _elements: import('chart.js').ActiveElement[], chartInstance: Chart) => void;
+    onHover: (evt: import('chart.js').ChartEvent, hoveredItems: import('../../common/common.interface').ICommonHoveredItems[]) => void;
+    indexAxis: AxisType;
+    maintainAspectRatio: boolean | undefined;
+    animation: false | {
+        duration: number;
+    } | undefined;
+    hover: {
+        mode: ChartHoverMode;
+        intersect: boolean;
+    };
+    scales: any;
+    plugins: {
+        title: {
+            display: boolean;
+            text: string | string[];
+        } | {
+            display?: undefined;
+            text?: undefined;
+        };
+        datalabels: import('./get-bar-chart-data-labels').IExtendedDataLabelsOptions;
+        annotation: {
+            annotations: {};
+        };
+        tooltip: Record<string, any>;
+        legend: {
+            display: boolean;
+            events: never[];
+            position: any;
+            align: "center" | "start" | "end";
+            labels: {
+                boxHeight: number;
+                boxWidth: number | undefined;
+                usePointStyle: boolean | undefined;
+            };
+            onClick: (_: import('../../common/common.interface').UnusedParameter, legendItem: import('chart.js').LegendItem) => void;
+        };
+        customLegendPlugin: {
+            htmlLegend: any;
+        };
+        chartAreaBorder: {
+            borderColor: string;
+        };
+        dragData: false | object | import('../../common/helpers/get-draggableData').IDraggableData | undefined;
+    };
+};

package/dist/src/components/common/common.interface.d.ts

@@ -0,0 +1,275 @@
+import { ChartEvent, ChartTypeRegistry, LinearScaleOptions, Plugin } from 'chart.js';
+import { LabelOptions } from 'chartjs-plugin-annotation';
+import { GradientDirection } from './plugins/gradient-background-plugin/enums';
+import { AnnotationType as DraggableAnnotationType, DragAxis } from './plugins/annotation-dragger-plugin/enums';
+import { AlignOptions, Position } from './enums';
+import { ILineMarkersAnnotation } from '../line-chart/plugins/line-markers-plugin/types';
+export type TAxisPosition = 'top' | 'bottom' | 'left' | 'right';
+export type DeepPartial<T> = T extends (...args: unknown[]) => unknown ? T : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends object ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : T;
+export interface ICommonDataValue {
+    x: number;
+    y: number;
+    label?: string;
+}
+export interface ICommonDataset {
+    label?: string;
+    borderColor?: string;
+    backgroundColor?: string | string[];
+    borderWidth?: number;
+    data: ICommonDataValue[];
+    hidden?: boolean;
+}
+export interface ICommonScales extends Partial<Record<string, LinearScaleOptions>> {
+    x: LinearScaleOptions;
+    y: LinearScaleOptions;
+}
+export interface ICommonAnnotationElement {
+    id?: string;
+    display: boolean;
+    annotationIndex: number;
+    label: {
+        options: LabelOptions;
+        content: string;
+    };
+    options: {
+        id?: string;
+        scaleID?: string;
+        borderColor?: string;
+        borderWidth?: number;
+        radius?: number;
+        label?: {
+            content?: string;
+            position?: string;
+            enabled?: boolean;
+            xAdjust?: number;
+        };
+    };
+}
+export interface ICoordinates {
+    x: number;
+    y: number;
+}
+export interface ICalloutLabelConfig {
+    enabled?: boolean;
+    color?: string;
+    font?: string;
+    borderColor?: string;
+    strokeStyle?: string;
+    lineWidth?: number;
+    startOffset?: number;
+    endOffset?: number;
+    margin?: number;
+    xValue?: number;
+    yValue?: number;
+    xAdjust?: number;
+    yAdjust?: number;
+    onDragStart?: (coordinates: ICoordinates, annotation: ICommonAnnotationsData) => void;
+    onDrag?: (coordinates: ICoordinates, annotation: ICommonAnnotationsData) => void;
+    onDragEnd?: (coordinates: ICoordinates, annotation: ICommonAnnotationsData) => void;
+}
+export interface IAnnotationLabelConfig {
+    backgroundColor?: string;
+    display?: boolean;
+    position?: string;
+    color?: string;
+    font?: string;
+    borderColor?: string;
+    callout?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export interface ICommonAnnotationsData {
+    display?: boolean;
+    hideLegend?: boolean;
+    labelOffsetPx?: number;
+    id?: string;
+    adjustScaleRange?: boolean;
+    annotationAxis?: 'x' | 'y';
+    rotation?: number;
+    color?: string;
+    endValue?: number;
+    borderWidth?: number;
+    backgroundColor?: string;
+    label?: string;
+    labelConfig?: IAnnotationLabelConfig;
+    type?: DraggableAnnotationType;
+    value?: number;
+    xMin?: number;
+    xMax?: number;
+    yMin?: number;
+    yMax?: number;
+    xValue?: number;
+    yValue?: number;
+    radius?: number;
+    enableDrag?: boolean;
+    onDragStart?: (coordinates: ICoordinates, annotation: ICommonAnnotationsData) => void;
+    onDrag?: (coordinates: ICoordinates, annotation: ICommonAnnotationsData) => void;
+    onDragEnd?: (coordinates: ICoordinates, annotation: ICommonAnnotationsData) => void;
+    dragAxis?: DragAxis;
+    pointStyle?: string;
+    resizable?: boolean;
+    dragRange?: {
+        x?: [number, number];
+        y?: [number, number];
+    };
+    displayDragCoordinates?: boolean;
+    xScaleID?: string;
+    yScaleID?: string;
+    opacity?: number;
+}
+export interface ICommonGradientColor {
+    offset: number;
+    color: string;
+}
+export interface ICommonGradient {
+    display: boolean;
+    gradientColors?: ICommonGradientColor[];
+    direction?: GradientDirection;
+}
+export interface ICommonStyling {
+    width?: number | string;
+    height?: number | string;
+    maintainAspectRatio?: boolean;
+    staticChartHeight?: boolean;
+    performanceMode?: boolean;
+    gradient?: ICommonGradient;
+}
+export interface ICommonLegend {
+    display: boolean;
+    position?: Position;
+    align?: AlignOptions;
+}
+export interface ICommonTooltipCallbacks {
+    title?: () => void;
+    label?: () => void;
+    afterLabel?: () => void;
+}
+export interface ICommonTooltip {
+    tooltips?: boolean;
+    showLabelsInTooltips?: boolean;
+    scientificNotation?: boolean;
+    callbacks?: ICommonTooltipCallbacks;
+}
+export interface ICommonAdditionalAxesOptions {
+    chartScaleType?: 'linear' | 'logarithmic';
+    reverse?: boolean;
+    beginAtZero?: boolean;
+    stepSize?: number;
+    stacked?: boolean;
+    suggestedMin?: number;
+    suggestedMax?: number;
+    min?: number;
+    max?: number;
+}
+export interface ICommonAnnotation {
+    showLabel?: boolean;
+    text?: string | string[];
+    position?: string;
+    fontSize?: number;
+    xOffset?: number;
+    yOffset?: number;
+    maxWidth?: number;
+    lineHeight?: number;
+}
+export interface ICommonAnnotations {
+    showAnnotations?: boolean;
+    controlAnnotation?: boolean;
+    enableDragAnnotation?: boolean;
+    enableCalloutAnnotation?: boolean;
+    lineMarkersAnnotation?: ILineMarkersAnnotation;
+    annotationsData?: ICommonAnnotationsData[];
+    labelAnnotation?: ICommonAnnotation;
+}
+export interface ICommonGraph {
+    lineTension?: number;
+    spanGaps?: boolean;
+    showDataLabels?: boolean;
+    showMinorGridlines?: boolean;
+}
+export interface ICommonInteractions {
+    onLegendClick?: (text: string, hidden: boolean) => void;
+    onHover?: (event?: ChartEvent, datasetIndex?: number, index?: number, generatedDataset?: any[]) => void;
+    onUnhover?: (event?: ChartEvent, datasetIndex?: number, index?: number, generatedDataset?: any[]) => void;
+}
+export interface ICommonCustomLegend<T extends keyof ChartTypeRegistry> {
+    customLegendPlugin: Plugin<T> | null;
+    customLegendContainerID: string;
+}
+export interface ICommonChartOptions {
+    enableZoom?: boolean;
+    enablePan?: boolean;
+}
+export interface ICommonDragData {
+    enableDragData?: boolean;
+    showTooltip?: boolean;
+    roundPoints?: boolean;
+    dragX?: boolean;
+    dragY?: boolean;
+    onDragStart?: () => void;
+    onDrag?: () => void;
+    onDragEnd?: () => void;
+}
+export interface ICommonOptions {
+    title?: string | string[];
+    chartStyling?: ICommonStyling;
+    tooltip?: ICommonTooltip;
+    legend?: ICommonLegend;
+    chartOptions?: ICommonChartOptions;
+    interactions?: ICommonInteractions;
+    dragData?: ICommonDragData;
+    annotations?: ICommonAnnotations;
+    plugins?: {
+        lineMarkersPlugin?: {
+            enabled?: boolean;
+        };
+    };
+}
+export interface ICommonData {
+    testId?: string;
+    data?: {
+        labels?: string[];
+        datasets?: ICommonDataset[];
+    };
+    options: ICommonOptions;
+}
+export interface ICommonHoveredItems {
+    index: number;
+    datasetIndex: number;
+}
+export interface ICommonChartPlugins {
+    legend: {
+        position: TAxisPosition;
+    };
+    title: {
+        display: boolean;
+        text: string;
+    };
+}
+export interface ICommonAxis<PositionType = string> {
+    label?: string;
+    position?: PositionType;
+    color?: string | string[];
+    unit?: string;
+    gridLines?: boolean;
+    stepSize?: number;
+}
+export interface IChartGeneratedLabel {
+    text: string;
+    fillStyle: string;
+    strokeStyle: string;
+    index: number;
+}
+export interface IChartLegendItemFilter {
+    index: number;
+    datasetIndex: number;
+    hidden: boolean;
+}
+export interface IChartDataLabelsOptions {
+    display?: 'auto' | boolean;
+    align?: 'center';
+    anchor?: 'center';
+    formatter?: (_value: unknown, context: unknown) => unknown;
+}
+export type UnusedParameter = unknown;
+export type TPrimitive = string | number | boolean | null;

package/dist/src/components/common/controls-portal.d.ts

@@ -0,0 +1,7 @@
+import { ReactElement } from 'react';
+interface ControlsPortalProps {
+    children: ReactElement;
+    controlsPortalId: string;
+}
+declare const ControlsPortal: ({ children, controlsPortalId, }: ControlsPortalProps) => import("react/jsx-runtime").JSX.Element;
+export default ControlsPortal;

package/dist/src/components/common/enums.d.ts

@@ -0,0 +1,87 @@
+export declare enum AxisType {
+    X = "x",
+    Y = "y"
+}
+export declare enum Position {
+    Bottom = "bottom",
+    Top = "top",
+    Left = "left",
+    Right = "right",
+    TopRight = "top-right",
+    TopLeft = "top-left",
+    BottomLeft = "bottom-left",
+    BottomRight = "bottom-right"
+}
+export declare enum ChartType {
+    LINE = "line",
+    BAR = "bar",
+    PIE = "pie",
+    DOUGHNUT = "doughnut",
+    SCATTER = "scatter"
+}
+export declare enum CursorStyle {
+    Pointer = "pointer",
+    Initial = "initial",
+    Grab = "grab",
+    Grabbing = "grabbing",
+    Crosshair = "crosshair",
+    Move = "move"
+}
+export declare enum ScaleType {
+    Category = "category",
+    Linear = "linear",
+    Logarithmic = "logarithmic"
+}
+export declare enum ChartDirection {
+    VERTICAL = "vertical",
+    HORIZONTAL = "horizontal"
+}
+export declare enum TooltipLabel {
+    Y = "yLabel",
+    X = "xLabel"
+}
+export declare enum AlignOptions {
+    End = "end",
+    Start = "start",
+    Center = "center",
+    Right = "right",
+    Left = "left"
+}
+export declare enum PointType {
+    Casing = "casing"
+}
+export declare enum AnnotationType {
+    Box = "box",
+    Ellipse = "ellipse",
+    Line = "line",
+    Text = "text",
+    Label = "label"
+}
+export declare enum PointStyle {
+    Circle = "circle",
+    Square = "rect",
+    Diamond = "rectRot",
+    Triangle = "triangle"
+}
+export declare enum ChartHoverMode {
+    Nearest = "nearest"
+}
+export declare enum PanZoomMode {
+    X = "x",
+    Y = "y",
+    XY = "xy",
+    Z = "z"
+}
+export declare enum Key {
+    Shift = "Shift"
+}
+export declare enum Events {
+    Mousemove = "mousemove",
+    Mouseout = "mouseout",
+    Click = "click",
+    Touchstart = "touchstart",
+    Touchmove = "touchmove",
+    Dblclick = "dblclick"
+}
+export { AnnotationType as DraggableAnnotationType, DragAxis, } from './plugins/annotation-dragger-plugin/enums';
+export { GradientDirection } from './plugins/gradient-background-plugin/enums';

package/dist/src/components/common/helpers/add-transparency/add-transparency.d.ts

@@ -0,0 +1 @@
+export declare function addTransparency(input: string, alpha: number, out?: 'rgb' | 'hex'): string;

package/dist/src/components/common/helpers/callout-helpers/callout-helpers.d.ts

@@ -0,0 +1,25 @@
+import { ICommonAnnotationsData } from '../../common.interface';
+export interface ICalloutCfg extends Record<string, unknown> {
+    enabled?: boolean;
+    onlyWhenOverlapping?: boolean;
+    margin?: number;
+    gapPx?: number;
+    minConnectorLengthPx?: number;
+    xAdjust?: number;
+    yAdjust?: number;
+    xValue?: number;
+    yValue?: number;
+    font?: string | {
+        size?: number | string;
+    };
+    padding?: number | {
+        top?: number;
+        right?: number;
+        bottom?: number;
+        left?: number;
+    };
+}
+export declare const isCalloutOverlapping: (ctx: any, refAnnotation: ICommonAnnotationsData, index: number) => boolean;
+export declare const resolveCalloutXValue: (ctx: any, refAnnotation: ICommonAnnotationsData, calloutCfg: ICalloutCfg, index: number) => number | undefined;
+export declare const resolveCalloutYValue: (ctx: any, refAnnotation: ICommonAnnotationsData, calloutCfg: ICalloutCfg, index: number) => number | undefined;
+export declare const isCalloutAnchorInChartArea: (ctx: any, refAnnotation: ICommonAnnotationsData, margin?: number) => boolean;

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

@@ -0,0 +1,16 @@
+import { Chart } from 'chart.js';
+import { UnusedParameter } from '../common.interface';
+interface IChartAreaBorderPluginOptions {
+    borderColor: string;
+    borderWidth: number;
+    borderDash: number[];
+    borderDashOffset?: number;
+}
+/**
+ * Chart border plugin config
+ */
+export declare const chartAreaBorderPlugin: {
+    id: string;
+    beforeDraw(chart: Chart, _: UnusedParameter, options: IChartAreaBorderPluginOptions): void;
+};
+export {};