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

package/dist/line-chart/constants/default-translations.d.ts

@@ -0,0 +1,25 @@
+export declare enum defaultTranslations {
+    label = "Label",
+    pointsLines = "Points & lines",
+    linesOnly = "Lines only",
+    pointsOnly = "Points only",
+    axesOptions = "Axes options",
+    resetAxes = "Reset Axes",
+    done = "Done",
+    downloadAsPNG = "Download as PNG",
+    showChart = "Show chart",
+    showTable = "Show table",
+    dragToZoom = "Drag to zoom",
+    dragToPan = "Drag to pan",
+    dragToMovePoints = "Drag to move points",
+    dragToMoveAnnotation = "Drag to move annotation",
+    dragDisabled = "Drag disabled",
+    hideLegend = "Hide Legend",
+    showLegend = "Show Legend",
+    mustHaveAValue = "Must have a value",
+    mustBeANumber = "Must be a number",
+    mustBeLessThanMax = "Must be less than max",
+    mustBeGreaterThanMin = "Must be greater than min",
+    doubleClickToReset = "Double click on canvas to reset",
+    orDoubleClickToCanvas = "or double click on canvas"
+}

package/dist/line-chart/constants/line-chart-consts.d.ts

@@ -0,0 +1,13 @@
+export declare const DEFAULT_POINT_RADIUS = 2;
+export declare const DEFAULT_HOVER_RADIUS = 5;
+export declare const DEFAULT_BORDER_WIDTH = 1;
+export declare const BORDER_JOIN_STYLE = "round";
+export declare const DEFAULT_BACKGROUND_COLOR = "transparent";
+export declare const ZOOM_BOX_BACKGROUND_COLOR = "rgba(0, 0, 0, 0.1)";
+export declare const DOUBLE_CLICK = "dblclick";
+export declare const INIT_KEYS: {
+    TRANSLATIONS: string;
+    LANGUAGE_KEY: string;
+};
+export declare const LOWER_BOUND = 0.0001;
+export declare const UPPER_BOUND = 10000000;

package/dist/line-chart/controls/axes-options/action-types.d.ts

@@ -0,0 +1,5 @@
+export declare enum actionTypes {
+    Reset = "reset",
+    ValueUpdated = "valueUpdated",
+    UnitUpdated = "unitUpdated"
+}

package/dist/line-chart/controls/axes-options/axes-options-form-state.d.ts

@@ -0,0 +1,23 @@
+import { IState } from '../../state/state.interfaces';
+import { IAction, IFormState, IInitializeAxisFormState } from './axes-options-interfaces.ts';
+/**
+ * Initialize local component form state for a custom loads density table
+ *
+ * @param {Object} args
+ * @param {Object} args.initialAxesRanges
+ * @param {Array} [args.axes]
+ * @returns {Object} formState
+ */
+export declare const initializeFormState: ({ initialAxesRanges, axes, }: Partial<IState>) => IInitializeAxisFormState;
+export declare const validateAxes: (formState: IFormState) => {
+    errors: never[];
+    valid: boolean;
+};
+/**
+ * Local component form state reducer for a axes options form
+ *
+ * @param {Object} state Local component form state
+ * @param {Action} action Action with type and payload
+ * @returns {Object} FormState
+ */
+export declare const reducer: (state: IFormState, action: IAction) => IInitializeAxisFormState;

package/dist/line-chart/controls/axes-options/axes-options-form-state.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/line-chart/controls/axes-options/axes-options-interfaces.d.ts

@@ -0,0 +1,54 @@
+import { IUnitOptions } from '../../line-chart.interface.ts';
+import { IAxisState, IInitAxisRange } from '../../state/state.interfaces.ts';
+export interface IDepthType {
+    selectedDepthType?: string;
+    setSelectedDepthType?: (type: string) => void;
+    options?: Array<string>;
+}
+export interface IAxisControlLabel {
+    id: string;
+    label: string;
+}
+export interface IAxesOptions {
+    initialAxesRanges: IInitAxisRange[];
+    axes: IAxisState[];
+    controlsAxesLabels: IAxisControlLabel[];
+    onUpdateAxes: ({ axes }: {
+        axes: IAxisState;
+    }) => void;
+    onResetAxes: () => void;
+    depthType?: IDepthType | object;
+    close?: () => void;
+}
+export interface IOnEdit {
+    name?: string;
+    value?: string;
+    id?: string;
+}
+export interface IAxisFormState {
+    id: string;
+    min: number | string;
+    max: number | string;
+    unit?: string | IUnitOptions;
+}
+export type IInitializeAxisFormState = IAxisFormState[];
+export interface IError {
+    id: string;
+    min: string[];
+    max: string[];
+}
+export interface IFormState extends IInitializeAxisFormState {
+    errors?: IError[];
+    valid?: boolean;
+}
+type ActionType = 'reset' | 'valueUpdated' | 'unitUpdated';
+export type AxisKey = 'min' | 'max' | 'unit';
+interface ActionPayload extends IOnEdit {
+    initialAxesRanges?: IInitAxisRange[];
+    axes?: IAxisState[];
+}
+export interface IAction {
+    type: ActionType;
+    payload: ActionPayload;
+}
+export {};

package/dist/line-chart/controls/axes-options/axes-options.d.ts

@@ -0,0 +1,6 @@
+import { IAxesOptions } from './axes-options-interfaces';
+interface IAxesOptionsWithTranslations extends IAxesOptions {
+    translations: Record<string, string>;
+}
+export declare const AxesOptions: (optionsPopover: IAxesOptionsWithTranslations) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/line-chart/controls/controls-interfaces.d.ts

@@ -0,0 +1,20 @@
+import { Dispatch, ReactNode, RefObject } from 'react';
+import { Chart } from 'chart.js';
+import { ILineChartOptions, TGeneratedLineChartDatasets } from '../line-chart.interface';
+import { IState } from '../state/state.interfaces';
+export interface IControls {
+    headerComponent?: ReactNode;
+    subheaderComponent?: Element;
+    table?: ReactNode;
+    chartRef: RefObject<Chart>;
+    state: IState;
+    options: ILineChartOptions;
+    dispatch: Dispatch<any>;
+    generatedDatasets: TGeneratedLineChartDatasets;
+    translations: Record<string, string>;
+    controlsPortalId?: string;
+}
+export interface AxisControls {
+    id?: string;
+    label?: string;
+}

package/dist/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/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/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/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/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/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/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/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/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/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/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/line-chart/initialize/initialize-line-chart.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/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/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/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[];