@gravity-ui/charts 1.46.0 → 1.47.0

package/dist/esm/hooks/useShapes/x-range/index.js

@@ -1,112 +1,17 @@
 import React from 'react';
-import { color } from 'd3-color';
-import { select } from 'd3-selection';
-import get from 'lodash/get';
-import { getLineDashArray } from '../../../core/utils';
+import { renderXRange } from '../../../core/shapes/x-range/renderer';
 import { block } from '../../../utils';
 import { HtmlLayer } from '../HtmlLayer';
-import { getRectPath } from '../utils';
-export { prepareXRangeData } from './prepare-data';
+export { prepareXRangeData } from '../../../core/shapes/x-range/prepare-data';
 const b = block('x-range');
 export function XRangeSeriesShapes(args) {
     const { dispatcher, preparedData, seriesOptions, htmlLayout, clipPathId } = args;
-    const hoveredDataRef = React.useRef(null);
     const ref = React.useRef(null);
     React.useEffect(() => {
-        var _a;
         if (!ref.current) {
             return () => { };
         }
-        const svgElement = select(ref.current);
-        svgElement.selectAll('*').remove();
-        const segmentSelection = svgElement
-            .selectAll(`path.${b('segment')}`)
-            .data(preparedData)
-            .join('path')
-            .attr('d', (d) => {
-            const borderRadius = Math.min(d.height / 2, d.width / 2, d.series.borderRadius);
-            return getRectPath({
-                x: d.x,
-                y: d.y,
-                width: d.width,
-                height: d.height,
-                borderRadius,
-            }).toString();
-        })
-            .attr('class', b('segment'))
-            .attr('fill', (d) => d.color)
-            .attr('opacity', (d) => { var _a; return (_a = d.data.opacity) !== null && _a !== void 0 ? _a : d.series.opacity; })
-            .attr('cursor', (d) => d.series.cursor);
-        svgElement
-            .selectAll(`path.${b('segment-border')}`)
-            .data(preparedData.filter((d) => d.series.borderWidth > 0))
-            .join('path')
-            .attr('d', (d) => {
-            const borderRadius = Math.min(d.height / 2, d.width / 2, d.series.borderRadius);
-            return getRectPath({
-                x: d.x,
-                y: d.y,
-                width: d.width,
-                height: d.height,
-                borderRadius,
-            }).toString();
-        })
-            .attr('class', b('segment-border'))
-            .attr('fill', 'none')
-            .attr('stroke', (d) => d.series.borderColor)
-            .attr('stroke-width', (d) => d.series.borderWidth)
-            .attr('stroke-dasharray', (d) => getLineDashArray(d.series.borderDashStyle, d.series.borderWidth))
-            .attr('opacity', (d) => { var _a; return (_a = d.data.opacity) !== null && _a !== void 0 ? _a : d.series.opacity; })
-            .attr('pointer-events', 'none');
-        const svgLabels = preparedData.flatMap((d) => d.svgLabels);
-        svgElement
-            .selectAll(`text.${b('label')}`)
-            .data(svgLabels)
-            .join('text')
-            .attr('class', b('label'))
-            .attr('x', (d) => d.x)
-            .attr('y', (d) => d.y)
-            .attr('text-anchor', (d) => d.textAnchor)
-            .attr('dominant-baseline', 'central')
-            .attr('pointer-events', 'none')
-            .style('font-size', (d) => d.style.fontSize)
-            .style('font-weight', (d) => d.style.fontWeight || null)
-            .style('fill', (d) => d.style.fontColor || null)
-            .html((d) => d.text);
-        const hoverOptions = get(seriesOptions, 'x-range.states.hover');
-        const inactiveOptions = get(seriesOptions, 'x-range.states.inactive');
-        function handleShapeHover(data) {
-            hoveredDataRef.current = data;
-            if (hoverOptions === null || hoverOptions === void 0 ? void 0 : hoverOptions.enabled) {
-                const hoveredSet = new Set(data === null || data === void 0 ? void 0 : data.map((d) => d.data));
-                segmentSelection.attr('fill', (d) => {
-                    var _a;
-                    const fillColor = d.color;
-                    if (hoveredSet.has(d.data)) {
-                        return (((_a = color(fillColor)) === null || _a === void 0 ? void 0 : _a.brighter(hoverOptions.brightness).toString()) ||
-                            fillColor);
-                    }
-                    return fillColor;
-                });
-            }
-            if (inactiveOptions === null || inactiveOptions === void 0 ? void 0 : inactiveOptions.enabled) {
-                const hoveredSeries = data === null || data === void 0 ? void 0 : data.map((d) => d.series.id);
-                segmentSelection.attr('opacity', (d) => {
-                    var _a, _b;
-                    if ((hoveredSeries === null || hoveredSeries === void 0 ? void 0 : hoveredSeries.length) && !hoveredSeries.includes(d.series.id)) {
-                        return inactiveOptions.opacity || null;
-                    }
-                    return (_b = (_a = d.data.opacity) !== null && _a !== void 0 ? _a : d.series.opacity) !== null && _b !== void 0 ? _b : null;
-                });
-            }
-        }
-        if (hoveredDataRef.current !== null) {
-            handleShapeHover((_a = hoveredDataRef.current) !== null && _a !== void 0 ? _a : undefined);
-        }
-        dispatcher === null || dispatcher === void 0 ? void 0 : dispatcher.on('hover-shape.x-range', handleShapeHover);
-        return () => {
-            dispatcher === null || dispatcher === void 0 ? void 0 : dispatcher.on('hover-shape.x-range', null);
-        };
+        return renderXRange({ plot: ref.current }, preparedData, seriesOptions, dispatcher);
     }, [dispatcher, preparedData, seriesOptions]);
     const htmlLayerData = React.useMemo(() => ({ htmlElements: preparedData.flatMap((d) => d.htmlLabels) }), [preparedData]);
     return (React.createElement(React.Fragment, null,

package/dist/esm/hooks/useZoom/index.d.ts

@@ -1,8 +1,8 @@
 import type { PreparedSplit } from '../../core/layout/split-types';
 import type { ChartScale } from '../../core/scales/types';
+import type { ZoomState } from '../../core/zoom/types';
 import type { PreparedZoom } from '../types';
 import type { PreparedXAxis, PreparedYAxis } from '../useAxis/types';
-import type { ZoomState } from './types';
 interface UseZoomProps {
     node: SVGGElement | null;
     onUpdate: (zoomState: Partial<ZoomState>) => void;

package/dist/esm/hooks/useZoom/index.js

@@ -1,7 +1,7 @@
 import React from 'react';
 import { select } from 'd3-selection';
+import { selectionToZoomBounds } from '../../core/zoom/utils';
 import { useBrush } from '../useBrush';
-import { selectionToZoomBounds } from './utils';
 export function useZoom(props) {
     const { node, onUpdate, plotContainerHeight, plotContainerWidth, preparedSplit, preparedZoom, rangeSliderDomain, xAxis, xScale, yAxis, yScale, } = props;
     const isBrushDisabled = Boolean(!xAxis || !yAxis || !xScale || !yScale);

package/dist/esm/index.d.ts

@@ -1,5 +1,6 @@
 export { CustomShapeRenderer } from './utils';
 export { getFormattedValue } from './core/utils';
 export { getDefaultTooltipHeaderFormat } from './core/utils/tooltip';
+export { FORMAT_UNITS_BITS, FORMAT_UNITS_BYTES, FORMAT_UNITS_NUMBERS, } from './libs/format-number/presets';
 export * from './components';
 export * from './types';

package/dist/esm/index.js

@@ -1,5 +1,6 @@
 export { CustomShapeRenderer } from './utils';
 export { getFormattedValue } from './core/utils';
 export { getDefaultTooltipHeaderFormat } from './core/utils/tooltip';
+export { FORMAT_UNITS_BITS, FORMAT_UNITS_BYTES, FORMAT_UNITS_NUMBERS, } from './libs/format-number/presets';
 export * from './components';
 export * from './types';

package/dist/esm/libs/format-number/index.js

@@ -11,26 +11,30 @@ function getUnitRate(value, exponent, unitsI18nKeys) {
     }
     return resultUnitRate - 1;
 }
+const formatScaledNumber = (value, options) => {
+    const { precision, showRankDelimiter = true, lang } = options;
+    let result = value;
+    if (typeof precision === 'number') {
+        result = Number(result.toFixed(precision));
+    }
+    else if (precision === 'auto' && result % 1 !== 0) {
+        result = Number(result.toFixed(Math.abs(result) > 1 ? 2 : 4));
+    }
+    return new Intl.NumberFormat(lang !== null && lang !== void 0 ? lang : i18nInstance.lang, {
+        minimumFractionDigits: typeof precision === 'number' ? precision : 0,
+        maximumFractionDigits: 20,
+        useGrouping: showRankDelimiter,
+    }).format(result);
+};
 const unitFormatter = ({ exponent, unitsI18nKeys, unitDelimiterI18nKey, }) => {
     return function formatUnit(value, options = {}) {
-        const { precision, unitRate, showRankDelimiter = true, lang } = options;
+        const { unitRate, lang } = options;
         const i18nLang = i18nInstance.lang;
         if (lang) {
             i18nInstance.setLang(lang);
         }
         const resultUnitRate = typeof unitRate === 'number' ? unitRate : getUnitRate(value, exponent, unitsI18nKeys);
-        let result = value / Math.pow(exponent, resultUnitRate);
-        if (typeof precision === 'number') {
-            result = Number(result.toFixed(precision));
-        }
-        else if (precision === 'auto' && result % 1 !== 0) {
-            result = Number(result.toFixed(Math.abs(result) > 1 ? 2 : 4));
-        }
-        result = new Intl.NumberFormat(lang !== null && lang !== void 0 ? lang : i18nLang, {
-            minimumFractionDigits: typeof precision === 'number' ? precision : 0,
-            maximumFractionDigits: 20,
-            useGrouping: showRankDelimiter,
-        }).format(result);
+        const result = formatScaledNumber(value / Math.pow(exponent, resultUnitRate), options);
         const unit = i18n(unitsI18nKeys[resultUnitRate]);
         const delimiter = i18n(unitDelimiterI18nKey);
         i18nInstance.setLang(i18nLang);
@@ -59,6 +63,65 @@ const baseFormatNumber = unitFormatter({
     unitDelimiterI18nKey: 'value_number-delimiter',
     unitsI18nKeys: BASE_NUMBER_FORMAT_UNIT_KEYS,
 });
+const resolvePostfix = (postfix, lang) => {
+    var _a, _b;
+    if (typeof postfix === 'string') {
+        return postfix;
+    }
+    return (_b = (_a = postfix[lang]) !== null && _a !== void 0 ? _a : postfix.en) !== null && _b !== void 0 ? _b : '';
+};
+const FALLBACK_UNIT_ENTRY = { factor: 1, postfix: '' };
+const normalizedUnitsCache = new WeakMap();
+const normalizeUnits = (units) => {
+    const cached = normalizedUnitsCache.get(units);
+    if (cached) {
+        return cached;
+    }
+    const { scale } = units;
+    const rawEntries = Array.isArray(scale)
+        ? scale.map((e) => ({ factor: e.factor, postfix: e.postfix }))
+        : scale.postfixes.map((postfix, i) => ({ factor: Math.pow(scale.base, i), postfix }));
+    const valid = rawEntries.filter((e) => Number.isFinite(e.factor) && e.factor > 0);
+    valid.sort((a, b) => a.factor - b.factor);
+    const deduped = [];
+    for (const e of valid) {
+        if (deduped.length === 0 || deduped[deduped.length - 1].factor !== e.factor) {
+            deduped.push(e);
+        }
+    }
+    const result = deduped.length > 0 ? deduped : [FALLBACK_UNIT_ENTRY];
+    normalizedUnitsCache.set(units, result);
+    return result;
+};
+const pickUnitEntry = (value, scale) => {
+    const av = Math.abs(value);
+    let chosen = scale[0];
+    for (const e of scale) {
+        if (av / e.factor >= 1) {
+            chosen = e;
+        }
+        else {
+            break;
+        }
+    }
+    return chosen;
+};
+const customUnitFormatter = (value, units, options) => {
+    const { lang } = options;
+    const i18nLang = i18nInstance.lang;
+    if (lang) {
+        i18nInstance.setLang(lang);
+    }
+    const normalizedScale = normalizeUnits(units);
+    const entry = pickUnitEntry(value, normalizedScale);
+    const result = formatScaledNumber(value / entry.factor, options);
+    const effectiveLang = lang !== null && lang !== void 0 ? lang : i18nLang;
+    const resolvedPostfix = resolvePostfix(entry.postfix, effectiveLang);
+    const resolvedDelimiter = typeof units.delimiter === 'string' ? units.delimiter : ' ';
+    const delimiter = resolvedPostfix ? resolvedDelimiter : '';
+    i18nInstance.setLang(i18nLang);
+    return `${result}${delimiter}${resolvedPostfix}`;
+};
 const NUMBER_UNIT_RATE_BY_UNIT = {
     default: 0,
     auto: undefined,
@@ -77,7 +140,7 @@ export const formatNumber = (value, options = {}) => {
     if (Number.isNaN(value) || Number.isNaN(Number(value))) {
         return new Intl.NumberFormat('en').format(Number(value));
     }
-    const { format = 'number', multiplier = 1, prefix = '', postfix = '', unit, labelMode } = options;
+    const { format = 'number', multiplier = 1, prefix = '', postfix = '', unit, units, labelMode, } = options;
     let changedMultiplier = multiplier;
     let prePostfix = '';
     if (format === 'percent') {
@@ -87,6 +150,11 @@ export const formatNumber = (value, options = {}) => {
     if (labelMode === 'percent') {
         prePostfix = '%';
     }
+    if (units) {
+        const unitScale = 'scale' in units ? units : { scale: [units] };
+        const formattedValue = customUnitFormatter(Number(value) * changedMultiplier, unitScale, options);
+        return `${prefix}${formattedValue}${prePostfix}${postfix}`;
+    }
     const formattedValue = baseFormatNumber(Number(value) * changedMultiplier, Object.assign(Object.assign({}, options), { unitRate: NUMBER_UNIT_RATE_BY_UNIT[unit !== null && unit !== void 0 ? unit : 'default'] }));
     return `${prefix}${formattedValue}${prePostfix}${postfix}`;
 };

package/dist/esm/libs/format-number/presets.d.ts

@@ -0,0 +1,40 @@
+import type { FormatUnitScale } from './types';
+/**
+ * Byte scale with binary base (`1024`) and localized postfixes.
+ *
+ * @example
+ * ```ts
+ * tooltip: {
+ *   valueFormat: {type: 'number', units: FORMAT_UNITS_BYTES, precision: 1},
+ * }
+ * ```
+ */
+export declare const FORMAT_UNITS_BYTES: FormatUnitScale;
+/**
+ * Short number scale with decimal base (`1000`). Renders large numbers
+ * compactly as `K/M/B/T`. Postfixes are plain Latin letters and stay the
+ * same regardless of language. The first entry has an empty postfix, so
+ * values below `1000` render as plain numbers without a delimiter.
+ *
+ * @example
+ * ```ts
+ * tooltip: {
+ *   valueFormat: {type: 'number', units: FORMAT_UNITS_NUMBERS, precision: 1},
+ * }
+ * // 300       → "300"
+ * // 1_500     → "1.5 K"
+ * // 1_500_000 → "1.5 M"
+ * ```
+ */
+export declare const FORMAT_UNITS_NUMBERS: FormatUnitScale;
+/**
+ * Bit scale with decimal base (`1000`) and localized postfixes.
+ *
+ * @example
+ * ```ts
+ * tooltip: {
+ *   valueFormat: {type: 'number', units: FORMAT_UNITS_BITS, precision: 1},
+ * }
+ * ```
+ */
+export declare const FORMAT_UNITS_BITS: FormatUnitScale;

package/dist/esm/libs/format-number/presets.js

@@ -0,0 +1,66 @@
+/**
+ * Byte scale with binary base (`1024`) and localized postfixes.
+ *
+ * @example
+ * ```ts
+ * tooltip: {
+ *   valueFormat: {type: 'number', units: FORMAT_UNITS_BYTES, precision: 1},
+ * }
+ * ```
+ */
+export const FORMAT_UNITS_BYTES = {
+    scale: {
+        base: 1024,
+        postfixes: [
+            { en: 'B', ru: 'Б' },
+            { en: 'KB', ru: 'КБ' },
+            { en: 'MB', ru: 'МБ' },
+            { en: 'GB', ru: 'ГБ' },
+            { en: 'TB', ru: 'ТБ' },
+        ],
+    },
+};
+/**
+ * Short number scale with decimal base (`1000`). Renders large numbers
+ * compactly as `K/M/B/T`. Postfixes are plain Latin letters and stay the
+ * same regardless of language. The first entry has an empty postfix, so
+ * values below `1000` render as plain numbers without a delimiter.
+ *
+ * @example
+ * ```ts
+ * tooltip: {
+ *   valueFormat: {type: 'number', units: FORMAT_UNITS_NUMBERS, precision: 1},
+ * }
+ * // 300       → "300"
+ * // 1_500     → "1.5 K"
+ * // 1_500_000 → "1.5 M"
+ * ```
+ */
+export const FORMAT_UNITS_NUMBERS = {
+    scale: {
+        base: 1000,
+        postfixes: ['', 'K', 'M', 'B', 'T'],
+    },
+};
+/**
+ * Bit scale with decimal base (`1000`) and localized postfixes.
+ *
+ * @example
+ * ```ts
+ * tooltip: {
+ *   valueFormat: {type: 'number', units: FORMAT_UNITS_BITS, precision: 1},
+ * }
+ * ```
+ */
+export const FORMAT_UNITS_BITS = {
+    scale: {
+        base: 1000,
+        postfixes: [
+            { en: 'bit', ru: 'бит' },
+            { en: 'Kbit', ru: 'Кбит' },
+            { en: 'Mbit', ru: 'Мбит' },
+            { en: 'Gbit', ru: 'Гбит' },
+            { en: 'Tbit', ru: 'Тбит' },
+        ],
+    },
+};

package/dist/esm/libs/format-number/types.d.ts

@@ -1,13 +1,92 @@
-export type FormatOptions = {
+export interface FormatOptions {
+    /**
+     * Number of decimal places to display.
+     * Use `'auto'` to determine precision automatically based on the value magnitude.
+     */
     precision?: number | 'auto';
+    /** When `true`, inserts a thousands separator (e.g. `1 500 000`). */
     showRankDelimiter?: boolean;
+    /**
+     * BCP 47 language tag used for locale-aware formatting (e.g. `'en'`, `'ru'`).
+     * Defaults to the application locale when omitted.
+     */
     lang?: string;
+    /** Internal rendering hint for axis label layout. Not intended for public use. */
     labelMode?: string;
+}
+/**
+ * Plain string or a per-language dictionary of strings.
+ * When a dictionary is used, the lookup chain is:
+ * current `lang` → `en` → empty string.
+ */
+export type FormatI18nString = string | Partial<Record<string, string>>;
+/** Single entry of a custom unit scale. */
+export type FormatUnitScaleEntry = {
+    /** Positive multiplier applied to the value. The entry wins when `|value| / factor >= 1`. */
+    factor: number;
+    /**
+     * String appended after the scaled value (e.g. `'KB'`).
+     * Use an empty string to suppress the suffix and the delimiter.
+     * Pass a `{lang: string}` dictionary to localize the postfix — resolution falls back to `en`, then to empty.
+     */
+    postfix: FormatI18nString;
 };
-export type FormatNumberOptions = FormatOptions & {
+/**
+ * Custom unit scale for numeric formatting.
+ *
+ * `scale` describes the unit table in one of two forms:
+ * - `{base, postfixes}` — geometric progression: `postfixes[i]` is bound to `factor = base^i` (e.g. `{base: 1024, postfixes: ['B','KB','MB']}`).
+ * - `FormatUnitScaleEntry[]` — arbitrary factors; required for non-linear scales (e.g. `[{factor:1,postfix:'s'},{factor:60,postfix:'min'},{factor:3600,postfix:'h'}]`).
+ *
+ * `delimiter` is the shared string placed between the scaled value and the
+ * postfix. Defaults to a locale-aware space; pass `''` to suppress it.
+ *
+ * The normalized scale is cached by object identity, so for best performance
+ * reuse the same `units` object across `formatNumber` calls instead of
+ * creating a new inline literal on every render.
+ */
+export type FormatUnitScale = {
+    scale: {
+        base: number;
+        postfixes: FormatI18nString[];
+    } | FormatUnitScaleEntry[];
+    delimiter?: string;
+};
+export interface FormatNumberOptions extends FormatOptions {
+    /**
+     * Display mode for the numeric value.
+     * - `'number'` — plain number (default).
+     * - `'percent'` — value is multiplied by 100 and rendered with a `%` suffix.
+     *
+     * Combining `'percent'` with `units` is not meaningful and should be avoided.
+     */
     format?: 'number' | 'percent';
+    /** Factor applied to the value before formatting. For example, `multiplier: 1000` converts seconds to milliseconds. */
     multiplier?: number;
+    /** String prepended to the formatted value (e.g. `'$'`). */
     prefix?: string;
+    /** String appended to the formatted value (e.g. `' USD'`). */
     postfix?: string;
+    /**
+     * Compact unit suffix applied to large numbers.
+     * - `'auto'` — picks the most appropriate unit automatically (`k`, `m`, `b`, `t`).
+     * - `'k'` — thousands (÷ 1 000).
+     * - `'m'` — millions (÷ 1 000 000).
+     * - `'b'` — billions (÷ 1 000 000 000).
+     * - `'t'` — trillions (÷ 1 000 000 000 000).
+     * - `null` — no unit suffix.
+     *
+     * @deprecated Use `units` for custom scales. This option is fully ignored when `units` is set.
+     */
     unit?: 'auto' | 'k' | 'm' | 'b' | 't' | null;
-};
+    /**
+     * Custom unit scale, or a single `FormatUnitScaleEntry` as sugar for
+     * locking every value to one unit (equivalent to the legacy `unit: 'k'`).
+     * When set, fully overrides `unit`.
+     *
+     * Unit selection is always automatic: the entry with the largest `factor`
+     * such that `|value| / factor >= 1`, clamped to the smallest entry for
+     * very small values.
+     */
+    units?: FormatUnitScale | FormatUnitScaleEntry;
+}

package/dist/esm/setup-jsdom.js

@@ -10,6 +10,13 @@ if (typeof document !== 'undefined') {
         });
     }
 }
+if (typeof ResizeObserver === 'undefined') {
+    global.ResizeObserver = class ResizeObserver {
+        observe() { }
+        unobserve() { }
+        disconnect() { }
+    };
+}
 if (typeof HTMLCanvasElement !== 'undefined') {
     // jsdom does not implement HTMLCanvasElement.prototype.getContext (used for text measurement)
     HTMLCanvasElement.prototype.getContext = (() => ({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gravity-ui/charts",
-  "version": "1.46.0",
+  "version": "1.47.0",
   "description": "A flexible JavaScript library for data visualization and chart rendering using React",
   "license": "MIT",
   "main": "dist/cjs/index.js",
@@ -54,7 +54,8 @@
     "prepublishOnly": "npm run build",
     "docs:deps": "cd ./docs && npm ci",
     "docs:dev": "cd ./docs && npm run docs:dev",
-    "docs:build": "cd ./docs && npm run docs:build",
+    "docs:build-examples": "vite build --config docs/examples/vite.config.ts",
+    "docs:build": "npm run docs:build-examples && cd ./docs && npm run docs:build",
     "playwright:install": "playwright install chromium webkit --with-deps",
     "playwright": "playwright test --config=playwright/playwright.config.ts",
     "playwright:visual": "playwright test --project=chromium --project=webkit --config=playwright/playwright.config.ts",
@@ -113,6 +114,7 @@
     "@types/lodash": "^4.17.12",
     "@types/react": "^18.3.2",
     "@types/react-dom": "^18.3.0",
+    "@vitejs/plugin-react": "^4.7.0",
     "eslint": "^9.39.4",
     "eslint-plugin-jsx-a11y": "^6.10.2",
     "eslint-plugin-storybook": "^10.2.16",
@@ -127,6 +129,7 @@
     "jest": "^29.7.0",
     "jest-environment-jsdom": "^29.7.0",
     "jest-transform-css": "^6.0.1",
+    "monaco-editor": "^0.55.1",
     "nano-staged": "^0.8.0",
     "npm-run-all": "^4.1.5",
     "prettier": "^3.8.1",

package/dist/cjs/hooks/useSeries/index.d.ts

@@ -1,12 +0,0 @@
-import type { PreparedLegend, PreparedSeries } from '../../core/series/types';
-import type { ChartData } from '../../types';
-export declare const getVisibleSeries: ({ preparedSeries, activeLegendItems, }: {
-    preparedSeries: PreparedSeries[];
-    activeLegendItems: string[];
-}) => PreparedSeries[];
-export declare const getPreparedSeries: ({ seriesData, seriesOptions, colors, preparedLegend, }: {
-    seriesData: ChartData["series"]["data"];
-    seriesOptions: ChartData["series"]["options"];
-    colors: string[];
-    preparedLegend?: PreparedLegend | null;
-}) => Promise<PreparedSeries[]>;

package/dist/cjs/hooks/useSeries/index.js

@@ -1,40 +0,0 @@
-import { group } from 'd3-array';
-import { scaleOrdinal } from 'd3-scale';
-import { prepareSeries } from '../../core/series/prepareSeries';
-import { getSeriesNames } from '../../core/utils';
-export const getVisibleSeries = ({ preparedSeries, activeLegendItems, }) => {
-    return preparedSeries.map((singleSeries) => {
-        if (singleSeries.legend.enabled) {
-            return Object.assign(Object.assign({}, singleSeries), { visible: activeLegendItems.includes(singleSeries.legend.groupId) });
-        }
-        return singleSeries;
-    });
-};
-export const getPreparedSeries = async ({ seriesData, seriesOptions, colors, preparedLegend, }) => {
-    const seriesNames = getSeriesNames(seriesData);
-    const colorScale = scaleOrdinal(seriesNames, colors);
-    const groupedSeries = group(seriesData, (item, index) => {
-        if (item.type === 'line') {
-            return `${item.type}_${index}`;
-        }
-        return item.type;
-    });
-    const acc = [];
-    if (!preparedLegend) {
-        return acc;
-    }
-    const list = Array.from(groupedSeries);
-    for (let i = 0; i < list.length; i++) {
-        const [_groupId, seriesList] = list[i];
-        const seriesType = seriesList[0].type;
-        acc.push(...(await prepareSeries({
-            type: seriesType,
-            series: seriesList,
-            seriesOptions,
-            legend: preparedLegend,
-            colorScale,
-            colors,
-        })));
-    }
-    return acc;
-};

package/dist/cjs/hooks/useSeries/types.d.ts

@@ -1 +0,0 @@
-export * from '../../core/series/types';

package/dist/cjs/hooks/useSeries/types.js

@@ -1 +0,0 @@
-export * from '../../core/series/types';

package/dist/cjs/hooks/useSeries/utils.d.ts

@@ -1 +0,0 @@
-export * from '../../core/series/utils';

package/dist/cjs/hooks/useSeries/utils.js

@@ -1 +0,0 @@
-export * from '../../core/series/utils';

package/dist/cjs/hooks/useShapes/marker.d.ts

@@ -1,15 +0,0 @@
-import type { BaseType, Selection } from 'd3-selection';
-import { SymbolType } from '../../core/constants';
-import type { MarkerData as AreaMarkerData } from './area/types';
-import type { MarkerData as LineMarkerData } from './line/types';
-import type { RadarMarkerData } from './radar/types';
-import type { MarkerData as ScatterMarkerData } from './scatter/types';
-type MarkerData = LineMarkerData | AreaMarkerData | ScatterMarkerData | RadarMarkerData;
-export declare function renderMarker<T extends MarkerData>(selection: Selection<BaseType, T, BaseType, unknown>): Selection<BaseType, T, BaseType, unknown>;
-export declare function getMarkerVisibility(d: MarkerData): "" | "hidden";
-export declare function getMarkerHaloVisibility(d: MarkerData): "" | "hidden";
-export declare function setMarker<T extends BaseType, D extends MarkerData>(selection: Selection<T, D, BaseType | null, unknown>, state: 'normal' | 'hover'): void;
-export declare function getMarkerSymbol(type: `${SymbolType}` | undefined, radius: number): string | null;
-export declare function selectMarkerHalo<T>(parentSelection: Selection<BaseType, T, null, undefined>): Selection<BaseType, T, null, undefined>;
-export declare function selectMarkerSymbol<T>(parentSelection: Selection<BaseType, T, null, undefined>): Selection<BaseType, T, null, undefined>;
-export {};

package/dist/cjs/hooks/utils/index.d.ts

@@ -1 +0,0 @@
-export * from './bar-y';

package/dist/cjs/hooks/utils/index.js

@@ -1 +0,0 @@
-export * from './bar-y';

package/dist/esm/hooks/useSeries/index.d.ts

@@ -1,12 +0,0 @@
-import type { PreparedLegend, PreparedSeries } from '../../core/series/types';
-import type { ChartData } from '../../types';
-export declare const getVisibleSeries: ({ preparedSeries, activeLegendItems, }: {
-    preparedSeries: PreparedSeries[];
-    activeLegendItems: string[];
-}) => PreparedSeries[];
-export declare const getPreparedSeries: ({ seriesData, seriesOptions, colors, preparedLegend, }: {
-    seriesData: ChartData["series"]["data"];
-    seriesOptions: ChartData["series"]["options"];
-    colors: string[];
-    preparedLegend?: PreparedLegend | null;
-}) => Promise<PreparedSeries[]>;