@exegia/corpora-ui 2.0.0 → 3.1.0

package/dist-lib/components/blocks/shell/index.d.ts

@@ -1,4 +1,5 @@
 import { ShellLayout } from './shell-layout';
+export { ShellLayout };
 export type * from './type';
 export * from './shell-metrics';
 export * from './use-shell-panels';

package/dist-lib/components/composed/chat/chart/chart-atom.d.ts

@@ -0,0 +1,30 @@
+import { IChartState, TChartInstanceId } from './type';
+export declare const chartSelectedKeyAtom: (id: TChartInstanceId) => import('jotai').PrimitiveAtom<string | null> & {
+    init: string | null;
+};
+export declare const chartStateAtom: (id: TChartInstanceId) => import('jotai').Atom<IChartState>;
+export declare const selectChartKeyAtom: (id: TChartInstanceId) => import('jotai').WritableAtom<null, [key: string | null], void> & {
+    init: null;
+};
+export declare const toggleChartKeyAtom: (id: TChartInstanceId) => import('jotai').WritableAtom<null, [key: string], void> & {
+    init: null;
+};
+export declare const resetChartAtom: (id: TChartInstanceId) => import('jotai').WritableAtom<null, [], void> & {
+    init: null;
+};
+/** @internal Mounted root projects configuration and controlled props. */
+export declare const chartConfigAtom: (id: TChartInstanceId) => import('jotai').PrimitiveAtom<{
+    controlled: boolean;
+    initial: string | null;
+    keys: readonly string[];
+    onChange?: (key: string | null) => void;
+}> & {
+    init: {
+        controlled: boolean;
+        initial: string | null;
+        keys: readonly string[];
+        onChange?: (key: string | null) => void;
+    };
+};
+/** Call only after all consumers of a named instance have unmounted. */
+export declare function removeChartInstance(id: TChartInstanceId): void;

package/dist-lib/components/composed/chat/chart/chart-context.d.ts

@@ -0,0 +1,2 @@
+export declare const ChartContext: import('react').Context<string | null>;
+export declare function useChartContext(): string;

package/dist-lib/components/composed/chat/chart/chart-legend.d.ts

@@ -0,0 +1,4 @@
+import { IChartProps } from './type';
+export declare function ChartLegend({ type, data, series, selectedKey, interactive, onSelect, }: Pick<IChartProps, "type" | "data" | "series" | "selectedKey" | "interactive"> & {
+    onSelect: (key: string) => void;
+}): import("react").JSX.Element;

package/dist-lib/components/composed/chat/chart/chart-plot.d.ts

@@ -0,0 +1,3 @@
+import { IChartProps } from './type';
+/** Wait for layout before initializing ECharts (also supports hidden tabs and SSR). */
+export declare function ChartPlot(props: IChartProps): import("react").JSX.Element;

package/dist-lib/components/composed/chat/chart/chart-root.d.ts

@@ -0,0 +1,3 @@
+import { IChartProps } from './type';
+import type * as React from "react";
+export declare function ChartRoot({ ref, ...allProps }: IChartProps): React.ReactElement;

package/dist-lib/components/composed/chat/chart/chart-tooltip.d.ts

@@ -0,0 +1,4 @@
+import { TooltipProps } from './evilcharts/echarts-area-chart';
+import { IChartSeries, TChartDatum, TChartType } from './type';
+/** React escapes labels and formatted nodes before they enter ECharts' HTML tooltip. */
+export declare function createChartTooltip(type: TChartType, data: TChartDatum[], series: IChartSeries[], options?: TooltipProps): (params: unknown) => string;

package/dist-lib/components/composed/chat/chart/constants.d.ts

@@ -0,0 +1,3 @@
+import { TChartType } from './type';
+export declare const CHART_TYPE_LABEL: Record<TChartType, string>;
+export declare const CHART_DEFAULT_HEIGHT = 150;

package/dist-lib/components/composed/chat/chart/evilcharts/echarts-area-chart.d.ts

@@ -0,0 +1,93 @@
+import { ChartConfig, EChartsRenderer } from './echarts-chart';
+import { TooltipPosition, TooltipRoundness, TooltipVariant } from './echarts-tooltip';
+import { BrushProps } from './echarts-brush';
+import { FC, ReactNode } from 'react';
+import { DotVariant } from './echarts-dot';
+import { LegendVariant } from './echarts-legend';
+export type { ChartConfig, DotVariant, EChartsRenderer, LegendVariant, TooltipPosition, TooltipRoundness, TooltipVariant, };
+export type AreaVariant = "gradient" | "gradient-reverse" | "solid" | "dotted" | "lines" | "hatched" | "none";
+export type StrokeVariant = "solid" | "dashed" | "animated-dashed";
+export type StackType = "default" | "stacked" | "expanded";
+export type AreaAnimationType = "none" | "left-to-right" | "right-to-left" | "center-out" | "edges-in";
+export type CurveType = "linear" | "smooth" | "bump" | "monotone" | "monotoneX" | "monotoneY" | "natural" | "step";
+export interface EChartsAreaChartProps<TData extends Record<string, unknown>> {
+    data: TData[];
+    config: ChartConfig;
+    renderer?: EChartsRenderer;
+    xDataKey?: keyof TData & string;
+    className?: string;
+    curveType?: CurveType;
+    stackType?: StackType;
+    animation?: boolean;
+    animationType?: AreaAnimationType;
+    enableHoverHighlight?: boolean;
+    enableHoverReveal?: boolean;
+    defaultSelectedDataKey?: string | null;
+    selectedDataKey?: string | null;
+    onSelectionChange?: (key: string | null) => void;
+    isLoading?: boolean;
+    loadingPoints?: number;
+    chartOptions?: Record<string, unknown>;
+    children?: ReactNode;
+}
+export interface AreaProps {
+    dataKey: string;
+    variant?: AreaVariant;
+    strokeVariant?: StrokeVariant;
+    strokeWidth?: number;
+    curveType?: CurveType;
+    animationType?: AreaAnimationType;
+    connectNulls?: boolean;
+    isClickable?: boolean;
+    enableBufferLine?: boolean;
+    children?: ReactNode;
+}
+export interface DotProps {
+    variant?: DotVariant;
+}
+export interface XAxisProps {
+    dataKey?: string;
+    tickFormatter?: (value: string, index: number) => string;
+    label?: string;
+    hideDots?: boolean;
+}
+export interface YAxisProps {
+    dataKey?: string;
+    tickFormatter?: (value: number, index: number) => string;
+    label?: string;
+    hideDots?: boolean;
+}
+export interface TooltipProps {
+    variant?: TooltipVariant;
+    roundness?: TooltipRoundness;
+    cursor?: boolean;
+    position?: TooltipPosition;
+}
+export interface LegendProps {
+    variant?: LegendVariant;
+    align?: "left" | "center" | "right";
+    verticalAlign?: "top" | "middle" | "bottom";
+    isClickable?: boolean;
+}
+/**
+ * Apache ECharts port of the EvilCharts area chart, exposing a compound-as-config
+ * API so its JSX reads identically to the Recharts twin. The root owns the data,
+ * config, selection state, loading skeleton, intro reveal, and optional zoom
+ * brush; every visual part — `<Area>`, `<XAxis>`, `<YAxis>`, `<Grid>`,
+ * `<Tooltip>`, `<Legend>` — is composed as a declarative child that renders
+ * nothing. The root walks those children by reference and drives a single
+ * imperative ECharts instance. Fully self-contained: its only dependencies are
+ * `react` and `echarts`.
+ */
+export declare function EChartsAreaChart<TData extends Record<string, unknown>>({ data, config, renderer, xDataKey, className, curveType, stackType, animation, animationType, enableHoverHighlight, enableHoverReveal, defaultSelectedDataKey, selectedDataKey: selectedDataKeyProp, onSelectionChange, isLoading, loadingPoints, chartOptions, children, }: EChartsAreaChartProps<TData>): import("react").JSX.Element;
+export declare namespace EChartsAreaChart {
+    var Area: FC<AreaProps>;
+    var Dot: FC<DotProps>;
+    var ActiveDot: FC<DotProps>;
+    var XAxis: FC<XAxisProps>;
+    var YAxis: FC<YAxisProps>;
+    var Grid: FC;
+    var Tooltip: FC<TooltipProps>;
+    var Legend: FC<LegendProps>;
+    var Brush: FC<BrushProps>;
+}

package/dist-lib/components/composed/chat/chart/evilcharts/echarts-bar-chart.d.ts

@@ -0,0 +1,86 @@
+import { ChartConfig, EChartsRenderer } from './echarts-chart';
+import { TooltipPosition, TooltipRoundness, TooltipVariant } from './echarts-tooltip';
+import { BrushProps } from './echarts-brush';
+import { FC, ReactNode } from 'react';
+import { LegendVariant } from './echarts-legend';
+export type { ChartConfig, EChartsRenderer, LegendVariant, TooltipPosition, TooltipRoundness, TooltipVariant, };
+export type BarVariant = "default" | "hatched" | "duotone" | "duotone-reverse" | "gradient" | "stripped" | "blocks" | "expandable";
+export type StackType = "default" | "stacked" | "percent";
+export type BarLayout = "vertical" | "horizontal";
+export type BarAnimationType = "none" | "left-to-right" | "right-to-left" | "center-out" | "edges-in";
+export interface EChartsBarChartProps<TData extends Record<string, unknown>> {
+    data: TData[];
+    config: ChartConfig;
+    renderer?: EChartsRenderer;
+    xDataKey?: keyof TData & string;
+    className?: string;
+    stackType?: StackType;
+    layout?: BarLayout;
+    barRadius?: number;
+    animation?: boolean;
+    animationType?: BarAnimationType;
+    barGap?: number;
+    barCategoryGap?: number;
+    selectedDataKey?: string | null;
+    defaultSelectedDataKey?: string | null;
+    onSelectionChange?: (key: string | null) => void;
+    enableMaxValueHighlight?: boolean;
+    isLoading?: boolean;
+    loadingBars?: number;
+    chartOptions?: Record<string, unknown>;
+    children?: ReactNode;
+}
+export interface BarProps {
+    dataKey: string;
+    variant?: BarVariant;
+    radius?: number;
+    animationType?: BarAnimationType;
+    isClickable?: boolean;
+    enableHoverHighlight?: boolean;
+    glowing?: boolean;
+    bufferBar?: boolean;
+}
+export interface XAxisProps {
+    dataKey?: string;
+    tickFormatter?: (value: string, index: number) => string;
+    label?: string;
+    hideDots?: boolean;
+}
+export interface YAxisProps {
+    dataKey?: string;
+    tickFormatter?: (value: string, index: number) => string;
+    label?: string;
+    hideDots?: boolean;
+}
+export interface TooltipProps {
+    variant?: TooltipVariant;
+    roundness?: TooltipRoundness;
+    defaultIndex?: number;
+    position?: TooltipPosition;
+}
+export interface LegendProps {
+    variant?: LegendVariant;
+    align?: "left" | "center" | "right";
+    verticalAlign?: "top" | "middle" | "bottom";
+    isClickable?: boolean;
+}
+/**
+ * Apache ECharts port of the EvilCharts bar chart, exposing a compound-as-config
+ * API so its JSX reads identically to the Recharts twin. The root owns the data,
+ * config, selection state, loading skeleton, intro grow-in, and optional zoom
+ * brush; every visual part — `<Bar>`, `<XAxis>`, `<YAxis>`, `<Grid>`,
+ * `<Tooltip>`, `<Legend>` — is composed as a declarative child that renders
+ * nothing. The root walks those children by reference and drives a single
+ * imperative ECharts instance. Fully self-contained: its only dependencies are
+ * `react`, `echarts`, and `motion`.
+ */
+export declare function EChartsBarChart<TData extends Record<string, unknown>>({ data, config, renderer, xDataKey, className, stackType, layout, barRadius, animation, animationType, barGap, barCategoryGap, selectedDataKey: selectedDataKeyProp, defaultSelectedDataKey, onSelectionChange, enableMaxValueHighlight, isLoading, loadingBars, chartOptions, children, }: EChartsBarChartProps<TData>): import("react").JSX.Element;
+export declare namespace EChartsBarChart {
+    var Bar: FC<BarProps>;
+    var XAxis: FC<XAxisProps>;
+    var YAxis: FC<YAxisProps>;
+    var Grid: FC;
+    var Tooltip: FC<TooltipProps>;
+    var Legend: FC<LegendProps>;
+    var Brush: FC<BrushProps>;
+}

package/dist-lib/components/composed/chat/chart/evilcharts/echarts-brush.d.ts

@@ -0,0 +1,65 @@
+import { ResolvedColors } from './echarts-chart';
+import { DataZoomComponentOption } from 'echarts/components';
+import { FC } from 'react';
+import * as echarts from "echarts/core";
+type EChartsInstance = ReturnType<typeof echarts.init>;
+declare const BRUSH_BORDER_OPACITY = 1;
+export { BRUSH_BORDER_OPACITY };
+export interface BrushProps {
+    height?: number;
+    formatLabel?: (value: string, index: number) => string;
+    onChange?: (range: {
+        startIndex: number;
+        endIndex: number;
+    }) => void;
+}
+/** Declares the zoom brush below the chart. Presence renders it; renders nothing itself. */
+export declare const Brush: FC<BrushProps>;
+export type BrushRange = {
+    start: number;
+    end: number;
+};
+export type BrushGeometry = {
+    bottom: number;
+    height: number;
+};
+export type BrushOverlayParams = {
+    range: BrushRange;
+    geom: BrushGeometry;
+    size: {
+        width: number;
+        height: number;
+    };
+    tokens: ResolvedColors["tokens"];
+    labels: {
+        start: string;
+        end: string;
+    } | null;
+    showLabels: boolean;
+    hover: {
+        left: boolean;
+        right: boolean;
+    };
+};
+type ZrRect = InstanceType<typeof echarts.graphic.Rect>;
+type ZrCircle = InstanceType<typeof echarts.graphic.Circle>;
+type ZrText = InstanceType<typeof echarts.graphic.Text>;
+export type BrushOverlayElements = {
+    dimLeft: ZrRect;
+    dimRight: ZrRect;
+    frame: ZrRect;
+    pillLeft: ZrRect;
+    pillRight: ZrRect;
+    grips: ZrCircle[];
+    labelStart: ZrText;
+    labelEnd: ZrText;
+};
+export declare function syncBrushOverlay(chart: EChartsInstance, store: {
+    brushOverlay: BrushOverlayElements | null;
+}, params: BrushOverlayParams | null): void;
+export declare function buildBrushDataZoom(params: {
+    brushBottom: number;
+    brushHeight: number;
+    brushRange: BrushRange;
+    fillerColor: string;
+}): DataZoomComponentOption[];

package/dist-lib/components/composed/chat/chart/evilcharts/echarts-chart.d.ts

@@ -0,0 +1,44 @@
+import { ComponentType, ReactNode } from 'react';
+import * as echarts from "echarts/core";
+export declare const ECHARTS_RENDERERS: {
+    readonly canvas: "canvas";
+    readonly svg: "svg";
+};
+export type EChartsRenderer = (typeof ECHARTS_RENDERERS)[keyof typeof ECHARTS_RENDERERS];
+export declare const DEFAULT_ECHARTS_RENDERER: "canvas";
+export declare const THEMES: {
+    readonly light: "";
+    readonly dark: ".dark";
+};
+export type ThemeKey = keyof typeof THEMES;
+export declare const THEME_KEYS: ThemeKey[];
+export type AtLeastOneThemeColor = {
+    light: string[];
+    dark?: string[];
+} | {
+    light?: string[];
+    dark: string[];
+};
+export type ChartConfig = Record<string, {
+    label?: ReactNode;
+    icon?: ComponentType;
+    colors?: AtLeastOneThemeColor;
+}>;
+export declare function getColorsCount(item: ChartConfig[string]): number;
+export declare function distributeColors(colors: string[], maxCount: number): string[];
+export declare function buildChartCss(id: string, config: ChartConfig): string;
+export declare function normalizeColor(value: string): string;
+export declare function withAlpha(color: string, alpha: number): string;
+export type ResolvedColors = {
+    series: Record<string, string[]>;
+    tokens: {
+        mutedForeground: string;
+        border: string;
+        foreground: string;
+        background: string;
+    };
+};
+export declare function resolveColors(container: HTMLElement, config: ChartConfig, seriesKeys: string[]): ResolvedColors;
+export declare function seriesPaint(slots: string[]): string | echarts.graphic.LinearGradient;
+export declare function indicatorBackground(key: string, colorsCount: number): string;
+export declare function flattenColor(color: string, base: string): string;

package/dist-lib/components/composed/chat/chart/evilcharts/echarts-dot.d.ts

@@ -0,0 +1,16 @@
+import type * as echarts from "echarts/core";
+export type DotVariant = "none" | "default" | "border" | "colored-border" | "ping";
+export type DotItemStyleOption = {
+    color?: string | echarts.graphic.LinearGradient;
+    borderColor?: string | echarts.graphic.LinearGradient;
+    borderWidth?: number;
+    opacity?: number;
+};
+export type DotStyle = {
+    size: number;
+    itemStyle: DotItemStyleOption;
+};
+export declare function dotItemStyle(variant: DotVariant, paint: string | echarts.graphic.LinearGradient, background: string): DotItemStyleOption;
+export declare const DOT_SIZES: Record<DotVariant, number>;
+export declare function dotStyle(variant: DotVariant, paint: string | echarts.graphic.LinearGradient, background: string): DotStyle;
+export declare function sampleGradient(slots: string[], t: number): string;

package/dist-lib/components/composed/chat/chart/evilcharts/echarts-legend.d.ts

@@ -0,0 +1,24 @@
+import { ChartConfig } from './echarts-chart';
+import { CSSProperties } from 'react';
+export type LegendVariant = "square" | "circle" | "circle-outline" | "rounded-square" | "rounded-square-outline" | "vertical-bar" | "horizontal-bar";
+export declare function legendFillStyle(key: string, colorsCount: number): CSSProperties;
+export declare function legendOutlineStyle(key: string, colorsCount: number): CSSProperties;
+export declare function LegendIndicator({ variant, dataKey, colorsCount, }: {
+    variant: LegendVariant;
+    dataKey: string;
+    colorsCount: number;
+}): import("react").JSX.Element;
+type LegendOverlayProps = {
+    seriesKeys: string[];
+    config: ChartConfig;
+    variant: LegendVariant;
+    align: "left" | "center" | "right";
+    verticalAlign: "top" | "middle" | "bottom";
+    selectedKey: string | null;
+    hoveredKey: string | null;
+    isClickable: boolean;
+    onToggle: (key: string) => void;
+    style: CSSProperties;
+};
+export declare function LegendOverlay({ seriesKeys, config, variant, align, selectedKey, hoveredKey, isClickable, onToggle, style, }: LegendOverlayProps): import("react").JSX.Element;
+export {};

package/dist-lib/components/composed/chat/chart/evilcharts/echarts-line-chart.d.ts

@@ -0,0 +1,90 @@
+import { ChartConfig, EChartsRenderer } from './echarts-chart';
+import { TooltipPosition, TooltipRoundness, TooltipVariant } from './echarts-tooltip';
+import { BrushProps } from './echarts-brush';
+import { FC, ReactNode } from 'react';
+import { DotVariant } from './echarts-dot';
+import { LegendVariant } from './echarts-legend';
+export type { ChartConfig, DotVariant, EChartsRenderer, LegendVariant, TooltipPosition, TooltipRoundness, TooltipVariant, };
+export type StrokeVariant = "solid" | "dashed" | "animated-dashed";
+export type LineAnimationType = "none" | "left-to-right" | "right-to-left" | "center-out" | "edges-in";
+export type CurveType = "linear" | "smooth" | "bump" | "monotone" | "monotoneX" | "monotoneY" | "natural" | "step";
+export interface EChartsLineChartProps<TData extends Record<string, unknown>> {
+    data: TData[];
+    config: ChartConfig;
+    renderer?: EChartsRenderer;
+    xDataKey?: keyof TData & string;
+    className?: string;
+    curveType?: CurveType;
+    animation?: boolean;
+    animationType?: LineAnimationType;
+    enableHoverHighlight?: boolean;
+    enableHoverReveal?: boolean;
+    selectedDataKey?: string | null;
+    defaultSelectedDataKey?: string | null;
+    onSelectionChange?: (key: string | null) => void;
+    isLoading?: boolean;
+    loadingPoints?: number;
+    chartOptions?: Record<string, unknown>;
+    children?: ReactNode;
+}
+export interface LineProps {
+    dataKey: string;
+    strokeVariant?: StrokeVariant;
+    strokeWidth?: number;
+    curveType?: CurveType;
+    animationType?: LineAnimationType;
+    connectNulls?: boolean;
+    isClickable?: boolean;
+    glowing?: boolean;
+    enableBufferLine?: boolean;
+    children?: ReactNode;
+}
+export interface DotProps {
+    variant?: DotVariant;
+}
+export interface XAxisProps {
+    dataKey?: string;
+    tickFormatter?: (value: string, index: number) => string;
+    label?: string;
+    hideDots?: boolean;
+}
+export interface YAxisProps {
+    dataKey?: string;
+    tickFormatter?: (value: number, index: number) => string;
+    label?: string;
+    hideDots?: boolean;
+}
+export interface TooltipProps {
+    variant?: TooltipVariant;
+    roundness?: TooltipRoundness;
+    cursor?: boolean;
+    position?: TooltipPosition;
+}
+export interface LegendProps {
+    variant?: LegendVariant;
+    align?: "left" | "center" | "right";
+    verticalAlign?: "top" | "middle" | "bottom";
+    isClickable?: boolean;
+}
+/**
+ * Apache ECharts port of the EvilCharts line chart, exposing a compound-as-config
+ * API so its JSX reads identically to the Recharts twin. The root owns the data,
+ * config, selection state, loading skeleton, intro reveal, and optional zoom
+ * brush; every visual part — `<Line>`, `<XAxis>`, `<YAxis>`, `<Grid>`,
+ * `<Tooltip>`, `<Legend>` — is composed as a declarative child that renders
+ * nothing. The root walks those children by reference and drives a single
+ * imperative ECharts instance. Fully self-contained: its only dependencies are
+ * `react`, `echarts`, and `motion`.
+ */
+export declare function EChartsLineChart<TData extends Record<string, unknown>>({ data, config, renderer, xDataKey, className, curveType, animation, animationType, enableHoverHighlight, enableHoverReveal, selectedDataKey: selectedDataKeyProp, defaultSelectedDataKey, onSelectionChange, isLoading, loadingPoints, chartOptions, children, }: EChartsLineChartProps<TData>): import("react").JSX.Element;
+export declare namespace EChartsLineChart {
+    var Line: FC<LineProps>;
+    var Dot: FC<DotProps>;
+    var ActiveDot: FC<DotProps>;
+    var XAxis: FC<XAxisProps>;
+    var YAxis: FC<YAxisProps>;
+    var Grid: FC;
+    var Tooltip: FC<TooltipProps>;
+    var Legend: FC<LegendProps>;
+    var Brush: FC<BrushProps>;
+}

package/dist-lib/components/composed/chat/chart/evilcharts/echarts-pie-chart.d.ts

@@ -0,0 +1,73 @@
+import { TooltipPosition, TooltipRoundness, TooltipVariant } from './echarts-tooltip';
+import { ChartConfig, EChartsRenderer } from './echarts-chart';
+import { FC, ReactNode } from 'react';
+import { LegendVariant } from './echarts-legend';
+export type { ChartConfig, EChartsRenderer, LegendVariant, TooltipPosition, TooltipRoundness, TooltipVariant, };
+export type PieVariant = "gradient";
+export type LabelPosition = "inside" | "outside";
+export type BackgroundVariant = "dots" | "grid" | "cross-hatch" | "diagonal-lines" | "plus" | "falling-triangles" | "4-pointed-star" | "tiny-checkers" | "overlapping-circles" | "wiggle-lines" | "bubbles";
+export interface EChartsPieChartProps<TData extends Record<string, unknown>> {
+    data: TData[];
+    config: ChartConfig;
+    dataKey: keyof TData & string;
+    nameKey: keyof TData & string;
+    className?: string;
+    renderer?: EChartsRenderer;
+    animation?: boolean;
+    defaultSelectedSector?: string | null;
+    selectedSector?: string | null;
+    onSelectionChange?: (selection: {
+        dataKey: string;
+        value: number;
+    } | null) => void;
+    isLoading?: boolean;
+    chartOptions?: Record<string, unknown>;
+    children?: ReactNode;
+}
+export interface PieProps {
+    variant?: PieVariant;
+    innerRadius?: number | string;
+    outerRadius?: number | string;
+    cornerRadius?: number;
+    paddingAngle?: number;
+    startAngle?: number;
+    endAngle?: number;
+    isClickable?: boolean;
+    children?: ReactNode;
+}
+export interface LabelProps {
+    dataKey?: string;
+    position?: LabelPosition;
+}
+export interface TooltipProps {
+    variant?: TooltipVariant;
+    roundness?: TooltipRoundness;
+    defaultIndex?: number;
+    position?: TooltipPosition;
+}
+export interface LegendProps {
+    variant?: LegendVariant;
+    align?: "left" | "center" | "right";
+    verticalAlign?: "top" | "middle" | "bottom";
+    isClickable?: boolean;
+}
+export interface BackgroundProps {
+    variant?: BackgroundVariant;
+}
+/**
+ * Apache ECharts port of the EvilCharts pie chart, exposing a compound-as-config
+ * API so its JSX reads identically to the Recharts twin. The root owns the data,
+ * config, selection state, loading skeleton, and intro reveal; every visual part —
+ * `<Pie>`, `<Tooltip>`, `<Legend>`, `<Background>` — is composed as a declarative
+ * child that renders nothing. The root walks those children by reference and
+ * drives a single imperative ECharts instance. Fully self-contained: its only
+ * dependencies are `react`, `echarts`, and `motion`.
+ */
+export declare function EChartsPieChart<TData extends Record<string, unknown>>({ data, config, dataKey, nameKey, className, renderer, animation, defaultSelectedSector, selectedSector: selectedSectorProp, onSelectionChange, isLoading, chartOptions, children, }: EChartsPieChartProps<TData>): import("react").JSX.Element;
+export declare namespace EChartsPieChart {
+    var Pie: FC<PieProps>;
+    var Label: FC<LabelProps>;
+    var Tooltip: FC<TooltipProps>;
+    var Legend: FC<LegendProps>;
+    var Background: FC<BackgroundProps>;
+}

package/dist-lib/components/composed/chat/chart/evilcharts/echarts-tooltip.d.ts

@@ -0,0 +1,29 @@
+import { ResolvedColors } from './echarts-chart';
+import { TooltipComponentOption } from 'echarts/components';
+export type TooltipVariant = "default" | "frosted-glass";
+export type TooltipRoundness = "sm" | "md" | "lg" | "xl";
+export type TooltipPosition = "fixed" | "variable";
+export declare const roundnessClass: Record<TooltipRoundness, string>;
+export declare const tooltipVariantClass: Record<TooltipVariant, string>;
+export declare function tooltipIndicatorHtml(key: string, colorsCount: number): string;
+export declare function tooltipRow({ indicatorHtml, labelText, valueText, dimmed, }: {
+    indicatorHtml: string;
+    labelText: string;
+    valueText: string;
+    dimmed: string;
+}): string;
+export declare function tooltipShell({ label, body, roundness, variant, }: {
+    label: string;
+    body: string;
+    roundness: TooltipRoundness;
+    variant: TooltipVariant;
+}): string;
+export declare function resolveTooltipPosition(position: TooltipPosition): TooltipComponentOption["position"];
+export declare function tooltipBaseOption(params: {
+    present: boolean;
+    cursor: boolean;
+    tokens: ResolvedColors["tokens"];
+    position: TooltipPosition;
+    axisPointerColor: string;
+    strokeWidth: number;
+}): TooltipComponentOption;

package/dist-lib/components/composed/chat/chart/index.d.ts

@@ -0,0 +1,6 @@
+export { ChartRoot as Chart, ChartRoot } from './chart-root';
+export { useChartContext } from './chart-context';
+export { useChartActions, useChartState } from './use-chart-state';
+export { chartSelectedKeyAtom, chartStateAtom, selectChartKeyAtom, toggleChartKeyAtom, resetChartAtom, removeChartInstance, } from './chart-atom';
+export { CHART_TYPE_LABEL, CHART_DEFAULT_HEIGHT } from './constants';
+export type * from './type';