@alfalab/core-components-chart 3.3.3 → 3.4.1

package/moderncssm/Component.js

@@ -0,0 +1,251 @@
+import React, { useState, useRef, useMemo, useCallback, useEffect } from 'react';
+import cn from 'classnames';
+import { ResponsiveContainer, Legend, CartesianGrid, XAxis, YAxis, Brush, Tooltip, Area, Line, Bar, LabelList, Cell, ComposedChart } from 'recharts';
+import { CustomizedLabel } from './components/CustomizedLabel.js';
+import { Dot } from './components/Dot/index.js';
+import { Legends } from './components/Legends/index.js';
+import { LinearGradient } from './components/LinearGradient.js';
+import { RectBar } from './components/RectBar.js';
+import { Tick } from './components/Tick/index.js';
+import { TooltipContent } from './components/TooltipContent/index.js';
+import { useSettings } from './hooks/useSettings/index.js';
+import styles from './index.module.css';
+
+const CustomizedHOC = (Component, options) => {
+    const NewComponent = (props) => React.createElement(Component, { ...props, ...options });
+    return NewComponent;
+};
+
+/* eslint-disable @typescript-eslint/no-explicit-any,prefer-template */
+const Chart = (props) => {
+    const [{ state, data, charts, filterCount }, { setCharts, setFilterCount }] = useSettings(props);
+    const [activeDotsState, setActiveDotsState] = useState({
+        prev: null,
+        active: null,
+    });
+    const [yBrush, setYBrush] = useState(null);
+    const [tooltipArrowSide, setTooltipArrowSide] = useState(null);
+    const [heightLegend, setHeightLegend] = useState(0);
+    const svgRef = useRef(null);
+    const tooltipRef = useRef(null);
+    const renderGradient = useMemo(() => {
+        if (!state)
+            return null;
+        return state.series.map((item) => {
+            const { chart, gradient } = item;
+            if (chart !== 'gradient' || !gradient)
+                return null;
+            const { gid, points } = gradient;
+            return (React.createElement(LinearGradient, { key: `${state.id}-${gid}`, id: state.id, gid: gid, points: points }));
+        });
+    }, [state]);
+    const toggleChart = useCallback((item) => {
+        const { chart, properties: { dataKey }, } = item;
+        const withGrad = chart === 'area';
+        let changed = false;
+        if (charts[dataKey + ''] && filterCount > 1) {
+            changed = true;
+            setFilterCount((prev) => prev - 1);
+        }
+        if (!charts[dataKey + '']) {
+            changed = true;
+            setFilterCount((prev) => prev + 1);
+        }
+        if (!changed)
+            return;
+        setCharts((prev) => {
+            const newState = { ...prev };
+            newState[dataKey + ''] = !newState[dataKey + ''];
+            if (withGrad)
+                newState[dataKey + '-gradient'] = !newState[dataKey + '-gradient'];
+            return newState;
+        });
+    }, [charts, filterCount, setCharts, setFilterCount]);
+    const legendRef = useCallback((node) => {
+        if (node !== null) {
+            setTimeout(() => {
+                const { height } = node.getBoundingClientRect();
+                setHeightLegend(height);
+            }, 0);
+        }
+    }, []);
+    const renderLegend = useMemo(() => {
+        if (!state?.legend)
+            return null;
+        const translate = state?.xAxis?.tickMargin && state?.legend?.verticalAlign !== 'top'
+            ? state.xAxis.tickMargin + (state?.brush?.brushMargin || 0)
+            : 0;
+        return (React.createElement(Legend, { ...(state.legend || null), content: React.createElement(Legends, { legend: state.legend, series: state.series, id: state.id, toggleChart: toggleChart, ref: legendRef, charts: charts }), wrapperStyle: {
+                transform: `translateY(${translate}px)`,
+            } }));
+    }, [state, charts, toggleChart, legendRef]);
+    const renderCartesianGrid = useMemo(() => {
+        if (!state?.cartesianGrid)
+            return null;
+        return React.createElement(CartesianGrid, { ...state.cartesianGrid });
+    }, [state]);
+    const renderXAxis = useMemo(() => {
+        if (!state?.xAxis)
+            return null;
+        let tick;
+        if (state?.xAxis?.tickType === 'point') {
+            tick = CustomizedHOC(Tick, { xAxis: state.xAxis });
+        }
+        else if (typeof state.xAxis.tick === 'boolean') {
+            tick = state.xAxis.tick;
+        }
+        else {
+            tick = true;
+        }
+        return React.createElement(XAxis, { ...state.xAxis, tick: tick });
+    }, [state]);
+    const renderYAxis = useMemo(() => {
+        if (!state?.yAxis)
+            return null;
+        let tick;
+        if (state?.yAxis?.tick) {
+            tick = CustomizedHOC(state.yAxis.tick, { state });
+        }
+        else if (typeof state.yAxis.tick === 'boolean') {
+            tick = state.yAxis.tick;
+        }
+        else {
+            tick = true;
+        }
+        return React.createElement(YAxis, { ...state.yAxis, tick: tick });
+    }, [state]);
+    const renderBrush = useMemo(() => {
+        if (!state?.brush)
+            return null;
+        return React.createElement(Brush, { y: typeof yBrush === 'number' ? yBrush : 0, ...state.brush });
+    }, [state, yBrush]);
+    const renderTooltip = useMemo(() => {
+        if (!state?.tooltip)
+            return null;
+        return (React.createElement(Tooltip, { ref: tooltipRef, ...state.tooltip, content: CustomizedHOC(TooltipContent, { series: state.series, tooltipArrowSide }) }));
+    }, [state, tooltipArrowSide]);
+    const renderChartsItems = useMemo(() => {
+        if (!state || !charts)
+            return null;
+        return state.series.map((item) => {
+            const { chart, properties, radius, labelList } = item;
+            const show = charts[`${properties.dataKey}`];
+            switch (chart) {
+                case 'bar':
+                    return show && !item?.hide ? (React.createElement(Bar, { key: `${state.id}-${properties.dataKey}`, ...properties, shape: React.createElement(RectBar, { radius: radius }) },
+                        labelList && (React.createElement(LabelList, { dataKey: properties.dataKey.toString(), ...labelList, content: React.createElement(CustomizedLabel, { radius: radius }) })),
+                        data.map((_, index) => {
+                            const key = `${state.id}-${properties.dataKey}-${index}`;
+                            return (React.createElement(Cell, { key: key, className: cn(styles.bar, typeof activeDotsState.active === 'number' &&
+                                    activeDotsState.active !== index
+                                    ? styles.unfocused
+                                    : '') }));
+                        }))) : null;
+                case 'area':
+                case 'line':
+                    return show && !item?.hide ? (React.createElement(Line, { key: `${state.id}-${properties.dataKey}`, ...properties, dot: properties.dot && properties.dotSettings
+                            ? CustomizedHOC(Dot, {
+                                activeDot: activeDotsState.active,
+                                dotSettings: properties.dotSettings,
+                                inherit: properties?.inheritStroke
+                                    ? properties.inheritStroke
+                                    : false,
+                            })
+                            : false, activeDot: false })) : null;
+                case 'gradient':
+                    return show && !item?.hide ? (React.createElement(Area, { ...item.properties, key: `${state.id}-${item.properties.dataKey}`, dataKey: `${item.properties.dataKey}`, stroke: 'transparent', fill: item.gradient.gid
+                            ? `url(#${state.id}-${item.gradient.gid})`
+                            : item.properties.fill, dot: false, activeDot: false })) : null;
+                default:
+                    return null;
+            }
+        });
+    }, [charts, state, activeDotsState, data]);
+    // Позиционирование brush
+    useEffect(() => {
+        if (!state || !state.brush)
+            return;
+        if (!heightLegend || heightLegend === 0)
+            return;
+        const align = state?.legend?.verticalAlign;
+        const legendHeight = align === 'top' ? 0 : heightLegend;
+        const marginTick = state?.xAxis?.tickMargin ? state?.xAxis?.tickMargin : 0;
+        const brushY = (svgRef.current?.clientHeight ? svgRef.current.clientHeight : 0) -
+            legendHeight -
+            state.brush.height -
+            (state?.composeChart?.margin?.bottom ? state.composeChart.margin.bottom : 0) +
+            marginTick +
+            (state.brush?.brushMargin ? state.brush.brushMargin : 0);
+        setYBrush(brushY);
+    }, [heightLegend, state]);
+    const leaveEvent = (isTooltipActive) => {
+        if (isTooltipActive)
+            return;
+        if (typeof activeDotsState.prev !== 'number' || typeof activeDotsState.active !== 'number')
+            return;
+        setActiveDotsState({
+            prev: null,
+            active: null,
+        });
+    };
+    const arrowTooltipEvent = (activeCoordinate) => {
+        if (!state?.tooltip?.arrow)
+            return;
+        if (state?.tooltip?.arrow && activeCoordinate?.x) {
+            const side = (svgRef?.current?.clientWidth || 0) -
+                (state?.composeChart?.margin?.right || 0) -
+                activeCoordinate.x -
+                (tooltipRef.current?.state?.boxWidth || 0) >
+                20;
+            setTooltipArrowSide(side);
+        }
+    };
+    const hoverEvent = (isTooltipActive, activeTooltipIndex) => {
+        if (!isTooltipActive)
+            return;
+        if (typeof activeDotsState.active === 'number' &&
+            activeTooltipIndex === activeDotsState.active)
+            return;
+        if (typeof activeTooltipIndex === 'number' && typeof activeDotsState.active !== 'number') {
+            setActiveDotsState({
+                prev: activeTooltipIndex,
+                active: activeTooltipIndex,
+            });
+        }
+        if (typeof activeTooltipIndex === 'number' && typeof activeDotsState.prev === 'number') {
+            setActiveDotsState((prev) => ({
+                prev: prev.active,
+                active: activeTooltipIndex,
+            }));
+        }
+    };
+    const mouseMove = (e) => {
+        if (!state?.tooltip)
+            return;
+        arrowTooltipEvent(e.activeCoordinate);
+        hoverEvent(e.isTooltipActive, e.activeTooltipIndex);
+        leaveEvent(e.isTooltipActive);
+    };
+    const mouseLeave = (e) => {
+        if (!state?.tooltip)
+            return;
+        leaveEvent(e.isTooltipActive);
+    };
+    if (!data || !charts || !state)
+        return null;
+    return (React.createElement("div", { className: styles.coreChart, ref: svgRef, id: state?.id || '', style: { width: '100%', height: '100%' } },
+        React.createElement(ResponsiveContainer, { debounce: state?.responsiveContainer?.debounce ? state.responsiveContainer.debounce : 0, width: '100%' },
+            React.createElement(ComposedChart, { ...state?.composeChart, onMouseMove: mouseMove, onMouseLeave: mouseLeave, data: data },
+                React.createElement("defs", null, renderGradient),
+                state.cartesianGrid && renderCartesianGrid,
+                state.xAxis && renderXAxis,
+                state.yAxis && renderYAxis,
+                renderChartsItems,
+                state.tooltip && renderTooltip,
+                state.brush && renderBrush,
+                state.legend && renderLegend))));
+};
+Chart.displayName = 'Chart';
+ResponsiveContainer.displayName = 'ResponsiveContainer';
+
+export { Chart };

package/moderncssm/components/CustomizedLabel.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import React from 'react';
+declare const CustomizedLabel: React.FC<any>;
+export { CustomizedLabel };

package/moderncssm/components/CustomizedLabel.js

@@ -0,0 +1,11 @@
+import React from 'react';
+import { usePathBar } from '../hooks/usePathBar/index.js';
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const CustomizedLabel = ({ x, y, value, offset, radius, height, width, formatter, }) => {
+    const [initHeight] = usePathBar({ radius, height });
+    return (React.createElement("text", { x: x + width / 2, y: y + height - (initHeight + offset), width: width, height: initHeight, textAnchor: 'middle' },
+        React.createElement("tspan", { x: x + width / 2 }, formatter ? formatter(value) : value)));
+};
+
+export { CustomizedLabel };

package/moderncssm/components/Dot/index.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+import React from 'react';
+import { DotProps } from "../../types/utils/dot.types";
+declare const Dot: React.ForwardRefExoticComponent<DotProps & React.RefAttributes<SVGSVGElement>>;
+export { Dot };

package/moderncssm/components/Dot/index.js

@@ -0,0 +1,43 @@
+import React, { useState, useEffect } from 'react';
+import cn from 'classnames';
+import { PointIcon } from '../../icons/Point.js';
+import styles from './index.module.css';
+
+const Dot = React.forwardRef(({ cx, cy, index, activeDot, dataKey, dotSettings, value, stroke }, ref) => {
+    const [windowWidth, setWindowWidth] = useState(0);
+    const [height, setHeight] = useState(0);
+    const [width, setWidth] = useState(0);
+    const [option, setOption] = useState(null);
+    useEffect(() => {
+        let dotSetting = Array.isArray(dotSettings) && dotSettings.length > 0
+            ? dotSettings.find((item) => item.media && windowWidth < item.media)
+            : dotSettings;
+        if (Array.isArray(dotSettings) && dotSettings.length > 0 && !dotSetting) {
+            dotSetting = dotSettings[dotSettings.length - 1];
+        }
+        setWindowWidth(window.innerWidth);
+        setOption(dotSetting);
+    }, [dotSettings, windowWidth]);
+    useEffect(() => {
+        if (!option)
+            return;
+        if (typeof activeDot === 'number' && activeDot === index) {
+            setHeight(option.height * option.scale);
+            setWidth(option.width * option.scale);
+        }
+        else {
+            setHeight(option.height * option.initScale);
+            setWidth(option.width * option.initScale);
+        }
+    }, [activeDot, index, option]);
+    if (!value)
+        return null;
+    return (React.createElement("g", { ref: ref, className: cn(styles.dot), transform: `translate(${cx - width / 2}, ${cy - height / 2})` },
+        React.createElement("g", { className: cn(styles.dotWrap), transform: `scale(${activeDot === index ? option?.scale || 0 : option?.initScale || 0})` },
+            React.createElement("svg", { className: cn(styles.dotItem, activeDot === index ? styles.dotActive : '', typeof activeDot === 'number' && activeDot !== index
+                    ? styles.dotUnfocused
+                    : ''), "data-id": index, "data-name": dataKey, width: option?.width || 0, height: option?.height || 0 },
+                React.createElement(PointIcon, { fill: stroke })))));
+});
+
+export { Dot };

package/moderncssm/components/Dot/index.module.css

@@ -0,0 +1,22 @@
+.dotUnfocused {
+    opacity: 0.3;
+}
+
+.dot,
+.dotItem,
+.dotWrap {
+    transition: all 0.2s ease;
+}
+
+.dot {
+    animation: showDot 0.5s ease;
+}
+
+@keyframes showDot {
+    from {
+        opacity: 0;
+    }
+    to {
+        opacity: 1;
+    }
+}

package/moderncssm/components/Legends/index.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="react" />
+import React from 'react';
+import { LegendProps } from "../../types/legend.types";
+import { SeriaProps } from "../../types/seria.types";
+import { DataDynamicBooleanProps } from "../../types/utils/data.types";
+interface Props {
+    legend: LegendProps;
+    series: SeriaProps[];
+    id: string;
+    charts: DataDynamicBooleanProps;
+    toggleChart(item: SeriaProps): void;
+}
+declare const Legends: React.ForwardRefExoticComponent<Props & React.RefAttributes<HTMLUListElement>>;
+export { Legends };

package/moderncssm/components/Legends/index.js

@@ -0,0 +1,36 @@
+import React from 'react';
+import cn from 'classnames';
+import { Typography } from '@alfalab/core-components-typography/moderncssm';
+import { CircleIcon } from '../../icons/Circle.js';
+import { CircleLineIcon } from '../../icons/CircleLine.js';
+import { FilledCircleIcon } from '../../icons/FilledCircle.js';
+import { StrokeCircleIcon } from '../../icons/StrokeCircle.js';
+import styles from './index.module.css';
+
+const icons = {
+    circleLine: CircleLineIcon,
+    filledCircle: FilledCircleIcon,
+    strokeCircle: StrokeCircleIcon,
+    circle: CircleIcon,
+};
+const Legends = React.forwardRef(({ legend, series, id, charts, toggleChart }, ref) => {
+    const style = {
+        textAlign: legend.align || 'center',
+        transform: `translateY(${(legend?.marginTop ? legend.marginTop : 0) *
+            (legend.verticalAlign === 'top' ? -1 : 1)}px)`,
+    };
+    return (React.createElement("ul", { ref: ref, className: cn(styles.legendWrap), style: style }, series.map((item) => {
+        if (item.hideLegend || item.hide)
+            return null;
+        const Icon = icons[item.icon] || CircleIcon;
+        return (React.createElement("li", { role: 'presentation', key: `${id}-${item.properties.dataKey}`, className: cn(styles.legendItem, charts[`${item.properties.dataKey}`] ? '' : styles.legendUnactive), onClick: () => toggleChart(item) },
+            React.createElement("div", { className: cn(styles.legendContent) },
+                Icon ? (React.createElement("i", { className: cn(styles.legendIcon) },
+                    React.createElement(Icon, { fill: item.properties?.fill ||
+                            item.properties?.stroke ||
+                            '', height: legend.iconHeight || 16 }))) : null,
+                React.createElement(Typography.Text, { view: 'primary-medium', tag: 'span', className: cn(styles.legendValue) }, item.properties.name))));
+    })));
+});
+
+export { Legends };

package/moderncssm/components/Legends/index.module.css

@@ -0,0 +1,36 @@
+/* */
+
+.legendContent {
+    display: flex;
+    align-items: center;
+    flex-wrap: wrap;
+}
+
+.legendWrap {
+    width: 100%;
+    margin: var(--gap-0);
+    padding: var(--gap-0);
+}
+
+.legendItem {
+    margin-right: var(--gap-32);
+    cursor: pointer;
+    display: inline-block;
+}
+
+.legendItem:last-child {
+    margin-right: var(--gap-0);
+}
+
+.legendUnactive {
+    opacity: 0.3;
+}
+
+.legendIcon {
+    margin-right: 13px;
+    display: flex;
+}
+
+.legendValue {
+    text-transform: capitalize;
+}

package/moderncssm/components/LinearGradient.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+import React from 'react';
+import { LinearGradientProps } from "../types/utils/gradient.types";
+declare const LinearGradient: ({ id, gid, points }: LinearGradientProps) => React.ReactElement;
+export { LinearGradient };

package/moderncssm/components/LinearGradient.js

@@ -0,0 +1,5 @@
+import React from 'react';
+
+const LinearGradient = ({ id, gid, points }) => (React.createElement("linearGradient", { key: `${id}-${gid}`, id: `${id}-${gid}`, x1: '0', y1: '0', x2: '0', y2: '1' }, points.map((point, index) => (React.createElement("stop", { key: `${id}${gid}-${index.toString()}`, offset: `${point.offset}%`, stopColor: point.stopColor, stopOpacity: point.stopOpacity })))));
+
+export { LinearGradient };

package/moderncssm/components/RectBar.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+declare const RectBar: ({ fill, x, y, width, height, radius, background }: any) => JSX.Element;
+export { RectBar };

package/moderncssm/components/RectBar.js

@@ -0,0 +1,27 @@
+import React, { useMemo } from 'react';
+import { usePathBar } from '../hooks/usePathBar/index.js';
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+// eslint-disable-next-line complexity
+const getPath = (x, width, height, initHeight, topRadius, bottomRadius, initY) => `
+        M${x + ((height !== 0 && bottomRadius) || 0)} ${initY + initHeight || 0}
+        Q${x} ${initY + initHeight} ${x} ${initY + initHeight - ((height !== 0 && bottomRadius) || 0)}
+        L${x} ${initY + ((height !== 0 && topRadius) || 0)}
+        Q${x} ${initY} ${x + ((height !== 0 && topRadius) || 0)} ${initY}
+        L${x + width - ((height !== 0 && topRadius) || 0)} ${initY}
+        Q${x + width} ${initY} ${x + width} ${initY + (topRadius || 0)}
+        L${x + width} ${initY + initHeight - ((height !== 0 && bottomRadius) || 0)}
+        Q${x + width} ${initY + initHeight} ${x + width - ((height !== 0 && bottomRadius) || 0)} ${initY + initHeight}
+        Z
+    `;
+const RectBar = ({ fill, x, y, width, height, radius, background }) => {
+    const [initHeight, topRadius, bottomRadius, initY] = usePathBar({
+        radius,
+        height,
+        background,
+        y,
+    });
+    return useMemo(() => (React.createElement("path", { d: getPath(x, width, height, initHeight, topRadius, bottomRadius, initY), stroke: 'none', fill: fill })), [x, width, height, initHeight, topRadius, bottomRadius, initY, fill]);
+};
+
+export { RectBar };

package/moderncssm/components/Tick/index.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+import React from 'react';
+import { TickProps } from "../../types/utils/tick.types";
+declare const Tick: ({ y, payload, tickFormatter, xAxis }: TickProps) => React.JSX.Element;
+export { Tick };

package/moderncssm/components/Tick/index.js

@@ -0,0 +1,16 @@
+import React from 'react';
+import cn from 'classnames';
+import styles from './index.module.css';
+
+const Tick = ({ y, payload, tickFormatter, xAxis }) => {
+    const radius = 4;
+    const marginTick = xAxis?.tickMargin &&
+        (xAxis.tickMargin > 0 ? xAxis.tickMargin - radius / 2 : xAxis.tickMargin === 0)
+        ? (radius / 2) * -1
+        : null;
+    return (React.createElement("g", { className: cn(styles.tick), opacity: '1', textAnchor: 'middle', transform: `translate(${payload.coordinate}, ${y - (typeof marginTick === 'number' ? marginTick : 0) - radius * 2})` },
+        React.createElement("text", { className: cn(styles.tickText), y: '30' }, tickFormatter ? tickFormatter(payload.value) : payload.value),
+        React.createElement("circle", { r: radius, className: cn(styles.circle) })));
+};
+
+export { Tick };

package/moderncssm/components/Tick/index.module.css

@@ -0,0 +1,18 @@
+/* */
+
+.tickText {
+    fill: var(--color-light-text-primary);
+    font-size: 16px;
+    line-height: 24px;
+    font-weight: 400;
+}
+
+.circle {
+    opacity: 0.3;
+    fill: var(--color-dark-base-bg-primary);
+}
+
+.circle {
+    opacity: 0.3;
+    fill: var(--color-dark-base-bg-primary);
+}

package/moderncssm/components/TooltipContent/index.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+import React from 'react';
+import { PayloadProps } from "../../types/payload.types";
+import { SeriaProps } from "../../types/seria.types";
+import { TooltipProps } from "../../types/tooltip.types";
+interface TooltipContentProps extends TooltipProps {
+    payload: PayloadProps[];
+    series: SeriaProps[];
+}
+declare const TooltipContent: ({ payload, separator, label, tooltipArrowSide, arrow, series, labelFormatter, labelStyle, }: TooltipContentProps) => React.JSX.Element | null;
+export { TooltipContentProps, TooltipContent };

package/moderncssm/components/TooltipContent/index.js

@@ -0,0 +1,26 @@
+import React from 'react';
+import cn from 'classnames';
+import { Typography } from '@alfalab/core-components-typography/moderncssm';
+import styles from './index.module.css';
+
+const TooltipContent = ({ payload, separator, label, tooltipArrowSide, arrow, series, labelFormatter, labelStyle, }) => {
+    if (!label || payload.length === 0)
+        return null;
+    return (React.createElement("div", { className: cn(styles.tooltip) },
+        arrow && (React.createElement("span", { className: cn(styles.tooltipArrow, tooltipArrowSide ? '' : styles.tooltipArrowRight) })),
+        React.createElement("ul", { className: cn(styles.tooltipList) },
+            React.createElement("li", { className: cn(styles.tooltipItem), style: labelStyle },
+                React.createElement(Typography.Text, { view: 'primary-medium', tag: 'span', weight: 'medium', className: cn(styles.tooltipLabel) }, labelFormatter ? labelFormatter(label) : label)),
+            payload.map((entry) => {
+                const data = series.find((d) => d.properties.dataKey === entry.dataKey);
+                if (data?.hideTooltip || data?.hide)
+                    return null;
+                return (React.createElement("li", { className: cn(styles.tooltipItem), key: entry.dataKey, style: { color: entry.color } },
+                    React.createElement(Typography.Text, { view: 'primary-medium', tag: 'span', weight: 'medium', className: cn(styles.tooltipValue) },
+                        entry?.formatter ? entry.formatter(entry.value) : entry.value,
+                        separator || ' '),
+                    React.createElement(Typography.Text, { view: 'secondary-large', tag: 'span', className: cn(styles.tooltipName) }, `${entry.name}`)));
+            }))));
+};
+
+export { TooltipContent };

package/moderncssm/components/TooltipContent/index.module.css

@@ -0,0 +1,51 @@
+/* */
+
+.tooltip {
+    background-color: var(--color-light-base-bg-primary);
+    border: 1px solid var(--color-light-neutral-400);
+    box-shadow: var(--shadow-l);
+    border-radius: var(--border-radius-8);
+    padding: var(--gap-12) var(--gap-16);
+    pointer-events: none;
+    position: relative;
+}
+
+.tooltipList {
+    position: relative;
+    z-index: 5;
+    list-style-type: none;
+    padding: var(--gap-0);
+    margin: var(--gap-0);
+}
+
+.tooltipItem {
+    margin-bottom: 10px;
+}
+
+.tooltipArrow {
+    position: absolute;
+    left: var(--gap-0);
+    top: 50%;
+    transform: translate(-50%, -50%) scale(1, 1) rotate(45deg);
+    width: 10px;
+    height: 10px;
+    border: 1px solid var(--color-light-neutral-400);
+    background-color: var(--color-light-base-bg-primary);
+}
+
+.tooltipArrow:before {
+    content: '';
+    position: absolute;
+    left: var(--gap-2-neg);
+    top: var(--gap-2-neg);
+    width: 0;
+    height: 0;
+    border-style: solid;
+    border-width: 0 24px 24px 0;
+    border-color: transparent var(--color-light-base-bg-primary) transparent transparent;
+}
+
+.tooltipArrowRight {
+    left: 100%;
+    transform: translate(-50%, -50%) scale(-1, 1) rotate(45deg);
+}

package/moderncssm/hooks/usePathBar/index.d.ts

@@ -0,0 +1,14 @@
+import { RadiusProp } from "../../types/seria.types";
+type usePathBarProps = {
+    radius?: RadiusProp;
+    height: number;
+    background?: {
+        x: number;
+        y: number;
+        height: number;
+        width: number;
+    };
+    y?: number;
+};
+declare const usePathBar: (props: usePathBarProps) => number[];
+export { usePathBarProps, usePathBar };