@plenustech/design-system 0.2.2 → 0.2.3

package/dist/types/components/charts/ChartSankey/ChartSankey.d.ts

@@ -26,6 +26,8 @@ export interface ChartSankeyProps {
     flowColor?: ChartSankeyFlowColor;
     flowValuePosition?: ChartSankeyFlowValuePosition;
     flows: readonly ChartSankeyFlow[];
+    /** Formato dos valores no balao. Sem ele, vale o `formatValue`. */
+    formatTooltipValue?: (value: number) => string;
     formatValue?: (value: number) => string;
     height?: ChartHeight;
     nodeAlign?: ChartSankeyAlign;
@@ -36,6 +38,8 @@ export interface ChartSankeyProps {
     nodeWidth?: number;
     showFlowValues?: boolean;
     showLabels?: boolean;
+    /** Balao com o detalhe do que esta sob o ponteiro. Desligue para nao mostrar nada alem do `<title>` nativo. */
+    showTooltip?: boolean;
     title: string;
 }
-export declare function ChartSankey({ accent, cyclicMessage, emptyMessage, flowColor, flowValuePosition, flows, formatValue, height, nodeAlign, nodes, nodePadding, nodeWidth, showFlowValues, showLabels, title, }: ChartSankeyProps): import("react").JSX.Element;
+export declare function ChartSankey({ accent, cyclicMessage, emptyMessage, flowColor, flowValuePosition, flows, formatTooltipValue, formatValue, height, nodeAlign, nodes, nodePadding, nodeWidth, showFlowValues, showLabels, showTooltip, title, }: ChartSankeyProps): import("react").JSX.Element;

package/dist/types/components/charts/ChartScatter/ChartScatter.d.ts

@@ -29,9 +29,15 @@ export interface ChartScatterProps {
     legendAlign?: ChartLegendAlign;
     onHiddenSeriesChange?: (hidden: readonly string[]) => void;
     series: readonly ChartScatterSeries[];
+    /** Balao com o detalhe do que esta sob o ponteiro. Desligue para nao mostrar nada alem do `<title>` nativo. */
+    showTooltip?: boolean;
     title: string;
+    /** Nome de cada medida no balao. */
+    xLabel?: string;
+    yLabel?: string;
+    zLabel?: string;
     xAxis?: AxisVisibility;
     yAxis?: AxisVisibility;
     yAxisRight?: AxisVisibility;
 }
-export declare function ChartScatter({ accent, defaultHiddenSeries, emptyMessage, formatX, formatY, formatZ, height, includeZero, hiddenSeries, legend, legendAlign, onHiddenSeriesChange, series, title, xAxis, yAxis, yAxisRight, }: ChartScatterProps): import("react").JSX.Element;
+export declare function ChartScatter({ accent, defaultHiddenSeries, emptyMessage, formatX, formatY, formatZ, height, includeZero, hiddenSeries, legend, legendAlign, onHiddenSeriesChange, series, showTooltip, title, xLabel, yLabel, zLabel, xAxis, yAxis, yAxisRight, }: ChartScatterProps): import("react").JSX.Element;

package/dist/types/components/charts/ChartSunburst/ChartSunburst.d.ts

@@ -1,4 +1,4 @@
-import { type ChartHeight, type ChartLegendAlign, type ChartLegendPosition } from '../core/index.js';
+import { type ChartHeight, type ChartHoveredNode, type ChartLegendAlign, type ChartLegendPosition } from '../core/index.js';
 import { type SeriesAppearance } from '../palette/index.js';
 export interface ChartSunburstNode extends SeriesAppearance {
     children?: readonly ChartSunburstNode[];
@@ -10,6 +10,8 @@ export interface ChartSunburstProps {
     defaultHiddenGroups?: readonly string[];
     emptyMessage?: string;
     formatPercent?: (ratio: number) => string;
+    /** Formato dos valores no balao. Sem ele, vale o `formatValue`: o eixo pode sair compacto e o balao, exato. */
+    formatTooltipValue?: (value: number) => string;
     formatValue?: (value: number) => string;
     height?: ChartHeight;
     hiddenGroups?: readonly string[];
@@ -17,11 +19,18 @@ export interface ChartSunburstProps {
     legendAlign?: ChartLegendAlign;
     nodes: readonly ChartSunburstNode[];
     onHiddenGroupsChange?: (hidden: readonly string[]) => void;
+    /** Caminho ate o no sob o ponteiro, do grupo ao no, cada nivel com o valor somado, ou `null` ao sair. */
+    onHoverNode?: (path: readonly ChartHoveredNode[] | null) => void;
     /** Folga entre dois aneis vizinhos. */
     ringGap?: number;
     /** Raio das pontas de cada arco. Sem valor, o token de raio pequeno. */
     sliceRadius?: number;
     showLabels?: boolean;
+    /**
+     * Balao com o caminho ate o no sob o ponteiro. Desligue para montar o proprio `ChartTooltip`
+     * pela costura; sem balao nem costura, o no volta a ter o `<title>`.
+     */
+    showTooltip?: boolean;
     title: string;
 }
-export declare function ChartSunburst({ accent, defaultHiddenGroups, emptyMessage, formatPercent, formatValue, height, hiddenGroups, legend, legendAlign, nodes, onHiddenGroupsChange, ringGap, showLabels, sliceRadius, title, }: ChartSunburstProps): import("react").JSX.Element;
+export declare function ChartSunburst({ accent, defaultHiddenGroups, emptyMessage, formatPercent, formatTooltipValue, formatValue, height, hiddenGroups, legend, legendAlign, nodes, onHiddenGroupsChange, onHoverNode, ringGap, showLabels, showTooltip, sliceRadius, title, }: ChartSunburstProps): import("react").JSX.Element;

package/dist/types/components/charts/ChartTooltip/ChartTooltip.d.ts

@@ -3,6 +3,8 @@ export interface ChartTooltipRow {
     color?: string;
     /** Realca a linha, como a serie sob o ponteiro entre as demais. */
     emphasis?: boolean;
+    /** Formato dos valores desta linha, quando difere do da coluna, como a serie do eixo da direita. */
+    format?: (value: number) => string;
     label: string;
     values: readonly number[];
 }

package/dist/types/components/charts/ChartTreemap/ChartTreemap.d.ts

@@ -1,4 +1,4 @@
-import { type ChartHeight, type ChartLegendAlign, type ChartLegendPosition } from '../core/index.js';
+import { type ChartHeight, type ChartHoveredNode, type ChartLegendAlign, type ChartLegendPosition } from '../core/index.js';
 import { type SeriesAppearance, type SeriesIntent } from '../palette/index.js';
 export interface ChartTreemapNode extends SeriesAppearance {
     children?: readonly ChartTreemapNode[];
@@ -9,6 +9,8 @@ export interface ChartTreemapProps {
     accent?: string;
     defaultHiddenGroups?: readonly string[];
     emptyMessage?: string;
+    /** Formato dos valores no balao. Sem ele, vale o `formatValue`: o eixo pode sair compacto e o balao, exato. */
+    formatTooltipValue?: (value: number) => string;
     formatValue?: (value: number) => string;
     /** Folga entre dois retangulos vizinhos. */
     gap?: number;
@@ -24,7 +26,14 @@ export interface ChartTreemapProps {
     legendAlign?: ChartLegendAlign;
     nodes: readonly ChartTreemapNode[];
     onHiddenGroupsChange?: (hidden: readonly string[]) => void;
+    /** Caminho ate o no sob o ponteiro, do grupo ao no, cada nivel com o valor somado, ou `null` ao sair. */
+    onHoverNode?: (path: readonly ChartHoveredNode[] | null) => void;
     showDataLabels?: boolean;
+    /**
+     * Balao com o caminho ate o no sob o ponteiro. Desligue para montar o proprio `ChartTooltip`
+     * pela costura; sem balao nem costura, o no volta a ter o `<title>`.
+     */
+    showTooltip?: boolean;
     title: string;
 }
-export declare function ChartTreemap({ accent, defaultHiddenGroups, emptyMessage, formatValue, gap, height, hiddenGroups, intentLabels, legend, legendAlign, nodes, onHiddenGroupsChange, showDataLabels, title, }: ChartTreemapProps): import("react").JSX.Element;
+export declare function ChartTreemap({ accent, defaultHiddenGroups, emptyMessage, formatTooltipValue, formatValue, gap, height, hiddenGroups, intentLabels, legend, legendAlign, nodes, onHiddenGroupsChange, onHoverNode, showDataLabels, showTooltip, title, }: ChartTreemapProps): import("react").JSX.Element;

package/dist/types/components/charts/ChartWaterfall/ChartWaterfall.d.ts

@@ -1,4 +1,4 @@
-import { type AxisLabelAngle, type AxisVisibility, type ChartHeight } from '../core/index.js';
+import { type AxisLabelAngle, type AxisVisibility, type MarkVisibility, type ChartHeight } from '../core/index.js';
 import { type SeriesIntent } from '../palette/index.js';
 export interface ChartWaterfallStep {
     color?: string;
@@ -9,16 +9,21 @@ export interface ChartWaterfallStep {
 }
 export interface ChartWaterfallProps {
     emptyMessage?: string;
+    /** Formato dos valores no balao. Sem ele, vale o `formatValue`: o eixo pode sair compacto e o balao, exato. */
+    formatTooltipValue?: (value: number) => string;
     formatValue?: (value: number) => string;
     height?: ChartHeight;
     labelAngle?: AxisLabelAngle;
     /** Indice do passo sob o ponteiro, ou `null` ao sair dele. */
     onHoverStep?: (index: number | null) => void;
-    showDataLabels?: boolean;
+    /** Variacao acima de cada passo. Em `onHover`, so a do passo sob o ponteiro. */
+    showDataLabels?: MarkVisibility;
+    /** Balao com a variacao do passo sob o ponteiro e o acumulado ate ele. Desligue para montar o proprio `ChartTooltip`. */
+    showTooltip?: boolean;
     steps: readonly ChartWaterfallStep[];
     title: string;
     xAxis?: AxisVisibility;
     yAxis?: AxisVisibility;
     yAxisRight?: AxisVisibility;
 }
-export declare function ChartWaterfall({ emptyMessage, formatValue, height, labelAngle, onHoverStep, showDataLabels, steps, title, xAxis, yAxis, yAxisRight, }: ChartWaterfallProps): import("react").JSX.Element;
+export declare function ChartWaterfall({ emptyMessage, formatTooltipValue, formatValue, height, labelAngle, onHoverStep, showDataLabels, showTooltip, steps, title, xAxis, yAxis, yAxisRight, }: ChartWaterfallProps): import("react").JSX.Element;

package/dist/types/components/charts/core/CartesianFrame.d.ts

@@ -1,8 +1,10 @@
 import type { ReactNode } from 'react';
 import { type AxisTick } from './Axis.js';
 import type { ChartLegendAlign, ChartLegendEntry, ChartLegendPosition } from './ChartLegend.js';
+import type { ChartFrameProps } from './ChartFrame.js';
 import { type GridOrientation } from './Grid.js';
 import type { AxisLabelRotation, AxisVisibility, ChartMargins, ChartPlot } from './cartesianLayout.js';
+import type { AxisReveal } from './useCartesianLayout.js';
 export interface CartesianAxis {
     hideLine?: boolean;
     labelRotation?: AxisLabelRotation;
@@ -15,6 +17,8 @@ export interface CartesianGrid {
     orientation: GridOrientation;
 }
 export interface CartesianFrameProps {
+    /** Estado e gatilhos dos eixos `onHover`, vindos de `useCartesianLayout`. */
+    axisReveal?: AxisReveal;
     children: ReactNode;
     containerRef: (node: HTMLElement | null) => void;
     empty: boolean;
@@ -29,6 +33,7 @@ export interface CartesianFrameProps {
     onToggleSeries?: (label: string) => void;
     plot: ChartPlot;
     title: string;
+    tooltip?: ChartFrameProps['tooltip'];
     width: number;
     xAxis: CartesianAxis;
     yAxis: CartesianAxis;
@@ -38,4 +43,4 @@ export interface CartesianFrameProps {
  * Camada cartesiana sobre a moldura comum: grade, os dois eixos e as marcas,
  * todos dentro das margens ja calculadas a partir dos rotulos.
  */
-export declare function CartesianFrame({ children, containerRef, empty, emptyMessage, fillHeight, grid, height, legend, legendAlign, legendPosition, margins, onToggleSeries, plot, title, width, xAxis, yAxis, yAxisRight, }: CartesianFrameProps): import("react").JSX.Element;
+export declare function CartesianFrame({ axisReveal, children, containerRef, empty, emptyMessage, fillHeight, grid, height, legend, legendAlign, legendPosition, margins, onToggleSeries, plot, title, tooltip, width, xAxis, yAxis, yAxisRight, }: CartesianFrameProps): import("react").JSX.Element;

package/dist/types/components/charts/core/ChartFrame.d.ts

@@ -1,5 +1,6 @@
 import { type ReactNode } from 'react';
 import { type ChartLegendAlign, type ChartLegendEntry, type ChartLegendPosition, type ChartLegendSwatch } from './ChartLegend.js';
+import { type ChartTooltipProps } from '../ChartTooltip/ChartTooltip.js';
 export interface ChartFrameProps {
     /** Marcas do grafico, em coordenadas da area de desenho. */
     children: ReactNode;
@@ -18,9 +19,14 @@ export interface ChartFrameProps {
     legendPosition: ChartLegendPosition;
     /** A partir de quantas entradas a legenda aparece. */
     minLegendEntries?: number;
+    /** Ponteiro entrando e saindo da area de desenho, para quem revela os eixos `onHover`. */
+    onPointerEnter?: () => void;
+    onPointerLeave?: () => void;
     onToggleSeries?: (label: string) => void;
     swatch?: ChartLegendSwatch;
     title: string;
+    /** O balao do que esta sob o ponteiro, montado pelo grafico. Sem linhas, nao aparece. */
+    tooltip?: Omit<ChartTooltipProps, 'children'>;
     width: number;
 }
 /**
@@ -28,4 +34,4 @@ export interface ChartFrameProps {
  * O que muda entre as familias e o que se desenha dentro dela — eixos, aneis ou
  * a area inteira —, e nao o cerco, que era o mesmo repetido tres vezes.
  */
-export declare function ChartFrame({ children, centerOrigin, containerRef, empty, emptyMessage, fillHeight, height, legend, legendAlign, legendPosition, minLegendEntries, onToggleSeries, swatch, title, width, }: ChartFrameProps): import("react").JSX.Element;
+export declare function ChartFrame({ children, centerOrigin, containerRef, empty, emptyMessage, fillHeight, height, legend, legendAlign, legendPosition, minLegendEntries, onPointerEnter, onPointerLeave, onToggleSeries, swatch, title, tooltip, width, }: ChartFrameProps): import("react").JSX.Element;

package/dist/types/components/charts/core/PointBands.d.ts

@@ -0,0 +1,22 @@
+import type { ChartPlot } from './cartesianLayout.js';
+import type { ChartPoint } from './shapes.js';
+export interface PointBandsProps {
+    onHover: (index: number | null) => void;
+    /** Altura do ponteiro na area de desenho, para quem escolhe a serie mais proxima dele. */
+    onPointerY?: (y: number | null) => void;
+    plot: ChartPlot;
+    /** Posicao de cada categoria no eixo, na ordem das categorias. */
+    positions: readonly number[];
+}
+/**
+ * Faixas invisiveis sobre a area de desenho, uma por categoria, que vao do ponto
+ * ate o meio do caminho para cada vizinho: o ponteiro sempre cai no ponto mais proximo.
+ */
+export declare function PointBands({ onHover, onPointerY, plot, positions }: PointBandsProps): import("react").JSX.Element;
+/** Guia vertical no ponto sob o ponteiro, atras das marcas. */
+export declare function PointCursor({ plot, position }: {
+    plot: ChartPlot;
+    position: number;
+}): import("react").JSX.Element;
+/** A serie visivel com ponto na categoria cujo ponto fica mais perto da altura do ponteiro. */
+export declare function nearestSeriesAt(pointsBySeries: readonly (readonly (ChartPoint | null)[])[], category: number | null, y: number | null, isHidden: (seriesIndex: number) => boolean): null;

package/dist/types/components/charts/core/cartesianLayout.d.ts

@@ -3,11 +3,15 @@ import { type NumericRange } from '../scales/index.js';
 export type AxisLabelRotation = 0 | 45 | 90;
 export type AxisLabelAngle = AxisLabelRotation | 'auto';
 /**
- * Como o eixo se mostra. `onHover` reserva a calha e desliza o eixo para dentro
- * dela, de modo que o desenho nao se mexa sob o ponteiro; `hidden` dispensa a
- * calha, e e o unico modo em que a area de desenho realmente cresce.
+ * Como o eixo se mostra. `onHover` nao reserva a calha: o desenho ocupa o espaco
+ * todo e, depois de um instante com o ponteiro sobre o grafico, encolhe para o
+ * eixo entrar; `hidden` dispensa o eixo de vez.
  */
 export type AxisVisibility = 'visible' | 'hidden' | 'onHover';
+/** Como pontos e rotulos de valor se mostram. `onHover` mostra os da serie sob o ponteiro, e so eles. */
+export type MarkVisibility = 'visible' | 'hidden' | 'onHover';
+/** Se a marca da serie aparece: sempre, nunca, ou so com a serie sob o ponteiro. */
+export declare function markShown(visibility: MarkVisibility, seriesFocused: boolean): boolean;
 /** Altura do desenho: um numero fixa, `fill` entrega a decisao ao contêiner. */
 export type ChartHeight = number | 'fill';
 export interface ResolvedHeight {
@@ -36,6 +40,8 @@ export interface CartesianLayoutOptions {
     height: number;
     labelAngle: AxisLabelAngle;
     leftLabels: readonly string[];
+    /** Os eixos `onHover` estao a vista e ocupam a calha. */
+    revealed?: boolean;
     rightLabels: readonly string[];
     topRoom: number;
     width: number;
@@ -60,7 +66,7 @@ export declare function bottomLabelRotation(labels: readonly string[], font: Lab
  * util define o passo entre categorias, o passo define o angulo dos rotulos e o
  * angulo define a altura que eles ocupam embaixo.
  */
-export declare function cartesianLayout({ bottomLabels, font, height, labelAngle, leftLabels, rightLabels, topRoom, width, xAxis, yAxis, yAxisRight, }: CartesianLayoutOptions): CartesianLayout;
+export declare function cartesianLayout({ bottomLabels, font, height, labelAngle, leftLabels, revealed, rightLabels, topRoom, width, xAxis, yAxis, yAxisRight, }: CartesianLayoutOptions): CartesianLayout;
 /**
  * Rotulos de valor usados apenas para medir a calha do eixo, antes de a area de
  * desenho existir. Eles saem da altura total em vez da altura util, o que pode

package/dist/types/components/charts/core/hoverPath.d.ts

@@ -0,0 +1,10 @@
+import type { HierarchyNode } from 'd3-hierarchy';
+/** Um nivel do caminho ate o no sob o ponteiro, com o valor somado daquele nivel. */
+export interface ChartHoveredNode {
+    label: string;
+    value: number;
+}
+/** Caminho do grupo de topo ate o no, sem a raiz que o layout cria por fora. */
+export declare function hoverPath(node: HierarchyNode<{
+    label: string;
+}>): ChartHoveredNode[];

package/dist/types/components/charts/core/index.d.ts

@@ -2,10 +2,18 @@ export { BandCursor } from './BandCursor.js';
 export type { BandCursorProps, BandOrientation } from './BandCursor.js';
 export { Axis } from './Axis.js';
 export type { AxisOrientation, AxisProps, AxisTick } from './Axis.js';
+export { nearestSeriesAt, PointBands, PointCursor } from './PointBands.js';
+export { pointLabelPlacement } from './pointLabels.js';
+export type { PointLabelPlacement } from './pointLabels.js';
+export type { PointBandsProps } from './PointBands.js';
+export { categoryTooltip, pathTooltip, sliceTooltip } from './tooltips.js';
+export type { CategoryTooltipOptions, CategoryTooltipSeries, ChartFrameTooltip, PathTooltipOptions, SliceTooltipOptions } from './tooltips.js';
+export { hoverPath } from './hoverPath.js';
+export type { ChartHoveredNode } from './hoverPath.js';
 export { Grid } from './Grid.js';
 export type { GridOrientation, GridProps } from './Grid.js';
-export { bottomLabelRotation, cartesianLayout, chartHeight, valueLabelsFor, } from './cartesianLayout.js';
-export type { AxisLabelAngle, AxisLabelRotation, AxisVisibility, CartesianLayout, CartesianLayoutOptions, ChartHeight, ChartMargins, ChartPlot, ResolvedHeight, } from './cartesianLayout.js';
+export { bottomLabelRotation, cartesianLayout, chartHeight, markShown, valueLabelsFor, } from './cartesianLayout.js';
+export type { AxisLabelAngle, AxisLabelRotation, AxisVisibility, CartesianLayout, CartesianLayoutOptions, ChartHeight, ChartMargins, ChartPlot, MarkVisibility, ResolvedHeight, } from './cartesianLayout.js';
 export { arcAnchor, arcCentroid, arcPath, sliceAngles, VOLTA } from './arcs.js';
 export type { ArcAngles, ArcShape, SliceAnglesOptions } from './arcs.js';
 export { centerTextRadius, fitCenterText } from './centerText.js';
@@ -24,11 +32,13 @@ export { areaPath, linePath, roundedBarPath } from './shapes.js';
 export { groupSmallSlices } from './slices.js';
 export type { ChartSlice, GroupSmallSlicesOptions } from './slices.js';
 export type { ChartBand, ChartCurve, ChartPoint, CornerRadii } from './shapes.js';
+export { useCartesianLayout } from './useCartesianLayout.js';
+export type { AxisReveal } from './useCartesianLayout.js';
 export { useChartMetrics } from './useChartMetrics.js';
 export type { ChartMetrics } from './useChartMetrics.js';
 export { useHoveredBand } from './useHoveredBand.js';
 export type { HoveredBand } from './useHoveredBand.js';
-export { useSeriesToggle } from './useSeriesToggle.js';
+export { seriesInScale, useSeriesToggle } from './useSeriesToggle.js';
 export type { SeriesToggle, UseSeriesToggleOptions } from './useSeriesToggle.js';
 export { useSliceRing } from './useSliceRing.js';
 export type { SliceRing, UseSliceRingOptions } from './useSliceRing.js';

package/dist/types/components/charts/core/pointLabels.d.ts

@@ -0,0 +1,13 @@
+import type { ChartPoint } from './shapes.js';
+export interface PointLabelPlacement {
+    /** Abaixo do ponto, quando outra serie tem ponto logo acima na mesma categoria. */
+    below: boolean;
+    /** Afastamento horizontal do ponto: nas pontas, o rotulo sai de lado para nao encostar no marcador. */
+    dx: number;
+    textAnchor: 'start' | 'middle' | 'end';
+}
+/**
+ * Onde vai o rotulo de um ponto. Nas pontas ele se alinha para dentro, para nao cobrir os numeros do eixo; e,
+ * quando o rotulo de uma serie alcancaria o ponto de outra logo acima, na mesma categoria, ele desce para baixo do ponto.
+ */
+export declare function pointLabelPlacement(pointsBySeries: readonly (readonly (ChartPoint | null)[])[], series: number, category: number, lineHeight: number, isHidden: (seriesIndex: number) => boolean): PointLabelPlacement;

package/dist/types/components/charts/core/tooltips.d.ts

@@ -0,0 +1,49 @@
+import type { ChartFrameProps } from './ChartFrame.js';
+import type { ChartHoveredNode } from './hoverPath.js';
+export type ChartFrameTooltip = NonNullable<ChartFrameProps['tooltip']>;
+export interface CategoryTooltipSeries {
+    /** Formato desta serie, quando difere do grafico, como a do eixo da direita. */
+    format?: (value: number) => string;
+    label: string;
+    values: readonly (number | null)[];
+}
+export interface CategoryTooltipOptions {
+    categories: readonly string[];
+    colors: readonly string[];
+    format: (value: number) => string;
+    /** Categoria sob o ponteiro; `null` deixa o balao sem linhas, e ele nao aparece. */
+    index: number | null;
+    isHidden: (label: string) => boolean;
+    series: readonly CategoryTooltipSeries[];
+    /** Soma das series na ultima linha, para a pilha. */
+    showTotal?: boolean;
+}
+/** Balao dos graficos de categoria: uma linha por serie visivel, com a cor dela e o valor naquela categoria. */
+export declare function categoryTooltip({ categories, colors, format, index, isHidden, series, showTotal, }: CategoryTooltipOptions): ChartFrameTooltip;
+export interface SliceTooltipOptions {
+    colors: readonly string[];
+    formatPercent: (ratio: number) => string;
+    formatValue: (value: number) => string;
+    /** Fatia sob o ponteiro; `null` deixa o balao sem linhas. */
+    index: number | null;
+    slices: readonly {
+        label: string;
+        value: number;
+    }[];
+    /** Soma das fatias ligadas, base da porcentagem. */
+    total: number;
+}
+/** Balao do anel: a fatia sob o ponteiro, com o valor e a parte do total. */
+export declare function sliceTooltip({ colors, formatPercent, formatValue, index, slices, total }: SliceTooltipOptions): ChartFrameTooltip;
+export interface PathTooltipOptions {
+    /** Cor do no sob o ponteiro. */
+    color?: string;
+    format: (value: number) => string;
+    /** Com ele, cada nivel mostra tambem a parte do total. */
+    formatPercent?: (ratio: number) => string;
+    /** Caminho do grupo ate o no; `null` deixa o balao sem linhas. */
+    path: readonly ChartHoveredNode[] | null;
+    total?: number;
+}
+/** Balao dos hierarquicos: uma linha por nivel do caminho, com o no sob o ponteiro em destaque. */
+export declare function pathTooltip({ color, format, formatPercent, path, total }: PathTooltipOptions): ChartFrameTooltip;

package/dist/types/components/charts/core/useCartesianLayout.d.ts

@@ -0,0 +1,20 @@
+import { type CartesianLayoutOptions, type ChartMargins } from './cartesianLayout.js';
+export interface AxisReveal {
+    onPointerEnter: () => void;
+    onPointerLeave: () => void;
+    revealed: boolean;
+}
+/**
+ * Layout cartesiano com os eixos `onHover`. Sem eles revelados, o desenho ocupa
+ * o espaco todo; revelados, ele encolhe ate as calhas, numa transicao so. Dado
+ * ou tamanho que mudam reposicionam na hora: o que anima e a revelacao.
+ */
+export declare function useCartesianLayout(options: Omit<CartesianLayoutOptions, 'revealed'>): {
+    axisReveal: AxisReveal;
+    margins: ChartMargins;
+    plot: {
+        height: number;
+        width: number;
+    };
+    rotation: import("./cartesianLayout").AxisLabelRotation;
+};

package/dist/types/components/charts/core/useSeriesToggle.d.ts

@@ -1,10 +1,17 @@
 export interface UseSeriesToggleOptions {
     defaultHiddenSeries?: readonly string[];
     hiddenSeries?: readonly string[];
+    /** Todos os rotulos; com eles, desligar a ultima serie mantem a escala de antes. */
+    labels?: readonly string[];
     onHiddenSeriesChange?: (hidden: readonly string[]) => void;
 }
 export interface SeriesToggle {
     isHidden: (label: string) => boolean;
+    /**
+     * Se a serie fica fora da escala de valores. E o `isHidden` enquanto alguma esta ligada; com todas desligadas
+     * pela legenda, vale o que estava ligado antes da ultima sair, e a escala nao se mexe enquanto ela some.
+     */
+    isOutOfScale: (label: string) => boolean;
     toggle: (label: string) => void;
 }
 /**
@@ -13,4 +20,11 @@ export interface SeriesToggle {
  * secao 6. Trabalha com rotulos porque e o rotulo que a legenda exibe e o que
  * o produto reconhece; indices mudariam de significado ao reordenar as series.
  */
-export declare function useSeriesToggle({ defaultHiddenSeries, hiddenSeries, onHiddenSeriesChange, }: UseSeriesToggleOptions): SeriesToggle;
+export declare function useSeriesToggle({ defaultHiddenSeries, hiddenSeries, labels, onHiddenSeriesChange, }: UseSeriesToggleOptions): SeriesToggle;
+/**
+ * Series que entram na escala de valores, ou todas quando nenhuma entra. Sem isso a escala desabava ao
+ * desligar a ultima, e ela saia esticada para fora do grafico em vez de encolher no lugar.
+ */
+export declare function seriesInScale<T extends {
+    label: string;
+}>(series: readonly T[], isHidden: (label: string) => boolean): readonly T[];

package/dist/types/components/data-display/Accordion/Accordion.d.ts

@@ -2,10 +2,13 @@ import { type ComponentPropsWithRef, type ReactNode } from 'react';
 export interface AccordionItem {
     content: ReactNode;
     disabled?: boolean;
+    /** Id do cabecalho, para um link de ancora apontar a secao. */
+    id?: string;
     key: string;
     label: string;
 }
 export type AccordionIconPosition = 'left' | 'right';
+export type AccordionHeadingLevel = 2 | 3 | 4 | 5 | 6;
 export interface AccordionProps extends ComponentPropsWithRef<'div'> {
     defaultExpandedKeys?: readonly string[];
     expandedKeys?: readonly string[];
@@ -16,5 +19,7 @@ export interface AccordionProps extends ComponentPropsWithRef<'div'> {
     iconPosition?: AccordionIconPosition;
     /** Divisor entre as secoes, com a folga que ele exige. */
     divider?: boolean;
+    /** Nivel do titulo de cada secao, na hierarquia da pagina em que o acordeao esta. */
+    headingLevel?: AccordionHeadingLevel;
 }
-export declare function Accordion({ className, defaultExpandedKeys, expandedKeys, items, multiple, onExpandedChange, iconPosition, divider, ...props }: AccordionProps): import("react").JSX.Element;
+export declare function Accordion({ className, defaultExpandedKeys, expandedKeys, items, multiple, onExpandedChange, iconPosition, divider, headingLevel, ...props }: AccordionProps): import("react").JSX.Element;

package/dist/types/components/data-display/Accordion/index.d.ts

@@ -1,2 +1,2 @@
 export { Accordion } from './Accordion.js';
-export type { AccordionProps, AccordionItem, AccordionIconPosition } from './Accordion.js';
+export type { AccordionHeadingLevel, AccordionProps, AccordionItem, AccordionIconPosition } from './Accordion.js';

package/dist/types/components/data-display/SortableList/SortableList.d.ts

@@ -0,0 +1,22 @@
+import { type ComponentPropsWithRef, type ReactNode } from 'react';
+export interface SortableListItem {
+    /** Ações da linha, como `ButtonIcon`: alcançadas pelas setas para os lados. */
+    actions?: ReactNode;
+    excerpt?: string;
+    icon?: ReactNode;
+    key: string;
+    /** Nível de aninhamento, a partir de 1. Só recua a linha. */
+    level?: number;
+    title: string;
+}
+export interface SortableListProps extends Omit<ComponentPropsWithRef<'div'>, 'children' | 'onKeyDown'> {
+    defaultSelectedKey?: string;
+    items: readonly SortableListItem[];
+    /** Nome da lista, para o leitor de tela. */
+    label: string;
+    onReorder: (fromIndex: number, toIndex: number) => void;
+    onSelectionChange?: (key: string) => void;
+    /** `null` deixa a lista controlada sem nenhum item escolhido. */
+    selectedKey?: string | null;
+}
+export declare function SortableList({ className, defaultSelectedKey, items, label, onReorder, onSelectionChange, selectedKey, ...props }: SortableListProps): import("react").JSX.Element;

package/dist/types/components/data-display/SortableList/index.d.ts

@@ -0,0 +1,2 @@
+export { SortableList } from './SortableList.js';
+export type { SortableListItem, SortableListProps } from './SortableList.js';

package/dist/types/components/data-display/Tag/Tag.d.ts

@@ -0,0 +1,13 @@
+import { type HTMLAttributes, type ReactNode } from 'react';
+export type TagSize = 'sm' | 'md';
+export interface TagProps extends Omit<HTMLAttributes<HTMLSpanElement>, 'children'> {
+    children: ReactNode;
+    disabled?: boolean;
+    /** Mostra o botao de remover, nomeado como "Remover" seguido do texto da etiqueta. */
+    onRemove?: () => void;
+    /** Com `selected`, a etiqueta vira um botao de alternar, como o filtro que se liga e desliga. */
+    onSelectedChange?: (selected: boolean) => void;
+    selected?: boolean;
+    size?: TagSize;
+}
+export declare function Tag({ children, className, disabled, onRemove, onSelectedChange, selected, size, ...props }: TagProps): import("react").JSX.Element;

package/dist/types/components/data-display/Tag/index.d.ts

@@ -0,0 +1,2 @@
+export { Tag } from './Tag.js';
+export type { TagProps, TagSize } from './Tag.js';

package/dist/types/components/data-display/Timeline/Timeline.d.ts

@@ -0,0 +1,15 @@
+import type { ComponentPropsWithRef } from 'react';
+export interface TimelineItem {
+    date?: string;
+    description?: string;
+    key: string;
+    label: string;
+}
+export interface TimelineProps extends Omit<ComponentPropsWithRef<'ol'>, 'children'> {
+    /** Chave do estado atual. Os anteriores contam como concluídos, os seguintes como por vir. */
+    current: string;
+    items: readonly TimelineItem[];
+    /** Nome da lista, para o leitor de tela. */
+    label: string;
+}
+export declare function Timeline({ className, current, items, label, ...props }: TimelineProps): import("react").JSX.Element;

package/dist/types/components/data-display/Timeline/index.d.ts

@@ -0,0 +1,2 @@
+export { Timeline } from './Timeline.js';
+export type { TimelineItem, TimelineProps } from './Timeline.js';

package/dist/types/components/feedback/Skeleton/Skeleton.d.ts

@@ -0,0 +1,13 @@
+import type { HTMLAttributes } from 'react';
+export type SkeletonShape = 'line' | 'circle' | 'block';
+export interface SkeletonProps extends HTMLAttributes<HTMLSpanElement> {
+    /** Numero em pixels ou qualquer medida CSS. Sem altura, cada forma tem a sua: linha de texto, avatar ou bloco. */
+    height?: number | string;
+    shape?: SkeletonShape;
+    width?: number | string;
+}
+/**
+ * Lugar de um conteudo que ainda carrega. E decorativo e fica fora da leitura:
+ * quem envolve os esqueletos anuncia o carregamento, com `aria-busy` ou uma mensagem de status.
+ */
+export declare function Skeleton({ className, height, shape, style, width, ...props }: SkeletonProps): import("react").JSX.Element;

package/dist/types/components/feedback/Skeleton/index.d.ts

@@ -0,0 +1,2 @@
+export { Skeleton } from './Skeleton.js';
+export type { SkeletonProps, SkeletonShape } from './Skeleton.js';

package/dist/types/components/feedback/Toast/ToastRegion.d.ts

@@ -0,0 +1,2 @@
+/** Canto onde os avisos de `showToast` aparecem. Montado uma vez, na raiz da aplicacao. */
+export declare function ToastRegion(): import("react").JSX.Element;

package/dist/types/components/feedback/Toast/index.d.ts

@@ -0,0 +1,3 @@
+export { ToastRegion } from './ToastRegion.js';
+export { dismissToast, showToast } from './toastStore.js';
+export type { ToastAction, ToastOptions, ToastTone } from './toastStore.js';

package/dist/types/components/feedback/Toast/toastStore.d.ts

@@ -0,0 +1,24 @@
+import type { AlertTone } from '../Alert/index.js';
+export type ToastTone = AlertTone;
+export interface ToastAction {
+    label: string;
+    onClick: () => void;
+}
+export interface ToastOptions {
+    /** Botao unico de acao, como tentar de novo. Acionar fecha o aviso. */
+    action?: ToastAction;
+    description?: string;
+    /** Milissegundos ate sumir. `null` mantem ate a pessoa fechar; o padrao e 6s, e o erro fica. */
+    duration?: number | null;
+    title: string;
+    tone?: ToastTone;
+}
+export interface ToastEntry extends ToastOptions {
+    id: string;
+}
+/** Mostra um aviso no `ToastRegion` da pagina e devolve o id para fecha-lo antes do tempo. */
+export declare function showToast(options: ToastOptions): string;
+export declare function dismissToast(id: string): void;
+export declare function subscribeToasts(listener: () => void): () => void;
+export declare function getToasts(): ToastEntry[];
+export declare function getServerToasts(): ToastEntry[];

package/dist/types/components/forms/CheckboxGroup/CheckboxGroup.d.ts

@@ -0,0 +1,28 @@
+import { type ComponentPropsWithRef, type ReactNode } from 'react';
+interface CheckboxGroupContextValue {
+    disabled: boolean;
+    invalid: boolean;
+    name: string;
+    required: boolean;
+    toggle: (value: string, checked: boolean) => void;
+    values: readonly string[];
+}
+/** O `Checkbox` com `value` dentro de um grupo lê daqui o estado; fora dele, segue solto. */
+export declare function useCheckboxGroup(): CheckboxGroupContextValue | null;
+export type CheckboxGroupOrientation = 'vertical' | 'horizontal';
+export interface CheckboxGroupProps extends Omit<ComponentPropsWithRef<'fieldset'>, 'defaultValue' | 'onChange'> {
+    children: ReactNode;
+    defaultValue?: readonly string[];
+    disabled?: boolean;
+    error?: string;
+    hint?: string;
+    label: string;
+    name?: string;
+    onValueChange?: (values: string[]) => void;
+    orientation?: CheckboxGroupOrientation;
+    /** Exige ao menos uma caixa marcada no envio. */
+    required?: boolean;
+    value?: readonly string[];
+}
+export declare function CheckboxGroup({ 'aria-describedby': ariaDescribedBy, children, className, defaultValue, disabled, error, hint, label, name: providedName, onValueChange, orientation, ref, required, value, ...props }: CheckboxGroupProps): import("react").JSX.Element;
+export {};

package/dist/types/components/forms/CheckboxGroup/index.d.ts

@@ -0,0 +1,2 @@
+export { CheckboxGroup } from './CheckboxGroup.js';
+export type { CheckboxGroupOrientation, CheckboxGroupProps } from './CheckboxGroup.js';