@plenustech/design-system 0.1.1

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

@@ -0,0 +1,41 @@
+import type { ReactNode } from 'react';
+import { type AxisTick } from './Axis.js';
+import type { ChartLegendAlign, ChartLegendEntry, ChartLegendPosition } from './ChartLegend.js';
+import { type GridOrientation } from './Grid.js';
+import type { AxisLabelRotation, AxisVisibility, ChartMargins, ChartPlot } from './cartesianLayout.js';
+export interface CartesianAxis {
+    hideLine?: boolean;
+    labelRotation?: AxisLabelRotation;
+    ticks: readonly AxisTick[];
+    visibility?: AxisVisibility;
+}
+export interface CartesianGrid {
+    baseline?: number;
+    lines: readonly number[];
+    orientation: GridOrientation;
+}
+export interface CartesianFrameProps {
+    children: ReactNode;
+    containerRef: (node: HTMLElement | null) => void;
+    empty: boolean;
+    emptyMessage: string;
+    fillHeight: boolean;
+    grid?: readonly CartesianGrid[];
+    height: number;
+    legend?: readonly ChartLegendEntry[];
+    legendAlign?: ChartLegendAlign;
+    legendPosition: ChartLegendPosition;
+    margins: ChartMargins;
+    onToggleSeries?: (label: string) => void;
+    plot: ChartPlot;
+    title: string;
+    width: number;
+    xAxis: CartesianAxis;
+    yAxis: CartesianAxis;
+    yAxisRight?: CartesianAxis;
+}
+/**
+ * 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;

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

@@ -0,0 +1,31 @@
+import { type ReactNode } from 'react';
+import { type ChartLegendAlign, type ChartLegendEntry, type ChartLegendPosition, type ChartLegendSwatch } from './ChartLegend.js';
+export interface ChartFrameProps {
+    /** Marcas do grafico, em coordenadas da area de desenho. */
+    children: ReactNode;
+    /**
+     * Leva a origem das marcas para o centro da area, de modo que o filho
+     * raciocine em raio e angulo em vez de converter coordenadas.
+     */
+    centerOrigin?: boolean;
+    containerRef: (node: HTMLElement | null) => void;
+    empty: boolean;
+    emptyMessage: string;
+    fillHeight: boolean;
+    height: number;
+    legend?: readonly ChartLegendEntry[];
+    legendAlign?: ChartLegendAlign;
+    legendPosition: ChartLegendPosition;
+    /** A partir de quantas entradas a legenda aparece. */
+    minLegendEntries?: number;
+    onToggleSeries?: (label: string) => void;
+    swatch?: ChartLegendSwatch;
+    title: string;
+    width: number;
+}
+/**
+ * Moldura de qualquer grafico: titulo, area de desenho, estado vazio e legenda.
+ * 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;

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

@@ -0,0 +1,24 @@
+export type ChartLegendPosition = 'top' | 'bottom' | 'left' | 'right' | 'none';
+export interface ChartLegendEntry {
+    color: string;
+    hidden?: boolean;
+    label: string;
+    /** Medida da entrada, alinhada a direita. Serve a legenda em lista do anel. */
+    value?: string;
+}
+export type ChartLegendSwatch = 'square' | 'dot';
+/** Onde a legenda horizontal se apoia na largura do grafico. */
+export type ChartLegendAlign = 'left' | 'center' | 'right';
+interface ChartLegendProps {
+    align?: ChartLegendAlign;
+    entries: readonly ChartLegendEntry[];
+    onToggle?: (label: string) => void;
+    position: ChartLegendPosition;
+    swatch?: ChartLegendSwatch;
+}
+/**
+ * Legenda do grafico. Quando existe um alvo para o clique, cada entrada vira um
+ * botao que liga e desliga a serie, com o estado exposto por `aria-pressed`.
+ */
+export declare function ChartLegend({ align, entries, onToggle, position, swatch, }: ChartLegendProps): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,12 @@
+export type GridOrientation = 'horizontal' | 'vertical';
+export interface GridProps {
+    baseline?: number;
+    length: number;
+    lines: readonly number[];
+    orientation: GridOrientation;
+}
+/**
+ * Linhas de referencia do grafico. A linha da base recebe destaque proprio:
+ * ela separa valores positivos de negativos e nao e apenas mais uma marca.
+ */
+export declare function Grid({ baseline, length, lines, orientation }: GridProps): import("react").JSX.Element;

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

@@ -0,0 +1,27 @@
+export declare const VOLTA: number;
+export interface ArcAngles {
+    endAngle: number;
+    startAngle: number;
+}
+export interface ArcShape extends ArcAngles {
+    cornerRadius?: number;
+    innerRadius: number;
+    outerRadius: number;
+    padAngle?: number;
+}
+export interface SliceAnglesOptions {
+    endAngle?: number;
+    padAngle?: number;
+    startAngle?: number;
+}
+/**
+ * Angulo de cada fatia, **na ordem recebida**. A ordenacao por valor fica de
+ * fora: a fatia precisa ficar onde o consumidor a colocou, porque e essa ordem
+ * que a legenda repete.
+ */
+export declare function sliceAngles(values: readonly number[], { endAngle, padAngle, startAngle }?: SliceAnglesOptions): ArcAngles[];
+export declare function arcPath({ cornerRadius, endAngle, innerRadius, outerRadius, padAngle, startAngle }: ArcShape): string;
+/** Centro geometrico do arco, onde um rotulo sobre a fatia se apoia. */
+export declare function arcCentroid({ endAngle, innerRadius, outerRadius, startAngle }: ArcShape): [number, number];
+/** Ponto na borda do arco, de onde parte o conector de um rotulo externo. */
+export declare function arcAnchor(angles: ArcAngles, radius: number): [number, number];

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

@@ -0,0 +1,70 @@
+import { type LabelFont } from './measureText.js';
+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.
+ */
+export type AxisVisibility = 'visible' | 'hidden' | 'onHover';
+/** Altura do desenho: um numero fixa, `fill` entrega a decisao ao contêiner. */
+export type ChartHeight = number | 'fill';
+export interface ResolvedHeight {
+    fillHeight: boolean;
+    value: number;
+}
+/**
+ * Altura efetiva do desenho. Com `fill`, ela vem da medida do contêiner, o que
+ * permite ao grafico ocupar a celula de um painel sem que ninguem repita a
+ * medida em JavaScript.
+ */
+export declare function chartHeight(height: ChartHeight, measured: number): ResolvedHeight;
+export interface ChartMargins {
+    bottom: number;
+    left: number;
+    right: number;
+    top: number;
+}
+export interface ChartPlot {
+    height: number;
+    width: number;
+}
+export interface CartesianLayoutOptions {
+    bottomLabels: readonly string[];
+    font: LabelFont;
+    height: number;
+    labelAngle: AxisLabelAngle;
+    leftLabels: readonly string[];
+    rightLabels: readonly string[];
+    topRoom: number;
+    width: number;
+    xAxis: AxisVisibility;
+    yAxis: AxisVisibility;
+    yAxisRight: AxisVisibility;
+}
+export interface CartesianLayout {
+    margins: ChartMargins;
+    plot: ChartPlot;
+    rotation: AxisLabelRotation;
+}
+/**
+ * Angulo dos rotulos do eixo de baixo. Em zero grau, dois rotulos vizinhos nao
+ * podem se tocar. Girados, o que precisa caber e a distancia perpendicular
+ * entre duas linhas de base vizinhas, que vale o passo vezes o seno do angulo.
+ */
+export declare function bottomLabelRotation(labels: readonly string[], font: LabelFont, step: number): AxisLabelRotation;
+/**
+ * Margens derivadas do conteudo, e nao de constantes. A ordem resolve sozinha a
+ * dependencia entre elas: as calhas laterais definem a largura util, a largura
+ * 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;
+/**
+ * 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
+ * render uma marca a mais ou a menos: a largura do rotulo mais largo nao muda
+ * por isso, e e so ela que a medida precisa.
+ */
+export declare function valueLabelsFor(domain: NumericRange, length: number, format: (value: number) => string): string[];

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

@@ -0,0 +1,14 @@
+import { type LabelFont } from './measureText.js';
+export interface CenterText {
+    family: string;
+    label: string;
+    lineHeight: number;
+    size: number;
+    value: string;
+}
+/**
+ * Valor e rotulo do centro, no maior degrau da escala em que o texto ainda cabe
+ * dentro do anel. O SVG nao quebra linha nem corta o que transborda, entao quem
+ * precisa caber e o texto: ele desce de degrau e, no ultimo, e cortado.
+ */
+export declare function fitCenterText(value: string, label: string, font: LabelFont, innerDiameter: number): CenterText;

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

@@ -0,0 +1,36 @@
+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 { 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 { arcAnchor, arcCentroid, arcPath, sliceAngles, VOLTA } from './arcs.js';
+export type { ArcAngles, ArcShape, SliceAnglesOptions } from './arcs.js';
+export { fitCenterText } from './centerText.js';
+export type { CenterText } from './centerText.js';
+export { CartesianFrame } from './CartesianFrame.js';
+export type { CartesianAxis, CartesianFrameProps, CartesianGrid } from './CartesianFrame.js';
+export { ChartFrame } from './ChartFrame.js';
+export type { ChartFrameProps } from './ChartFrame.js';
+export { ChartLegend } from './ChartLegend.js';
+export type { ChartLegendAlign, ChartLegendEntry, ChartLegendPosition, ChartLegendSwatch, } from './ChartLegend.js';
+export { labelFontOf, measureLabel, truncateToWidth, widestLabel } from './measureText.js';
+export { CHART_BAR_GAP, CHART_EDGE_GAP, CHART_LABEL_BAND, CHART_LABEL_OFFSET, NO_BAR_SLOT, barSlots, ringDiameter, valueLabelRoom, } from './spacing.js';
+export type { BarSlot } from './spacing.js';
+export type { LabelFont } from './measureText.js';
+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 { 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 type { SeriesToggle, UseSeriesToggleOptions } from './useSeriesToggle.js';
+export { useSliceRing } from './useSliceRing.js';
+export type { SliceRing, UseSliceRingOptions } from './useSliceRing.js';
+export { useTweenedNumbers } from './useTweenedNumbers.js';
+export type { TweenOptions } from './useTweenedNumbers.js';

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

@@ -0,0 +1,25 @@
+export interface LabelFont {
+    family: string;
+    /** Familia de display, usada onde o valor e um KPI. */
+    headingFamily: string;
+    lineHeight: number;
+    size: number;
+}
+/**
+ * Fonte dos rotulos, lida dos tokens no proprio elemento do grafico. Ler do
+ * elemento evita repetir em JavaScript um valor que ja pertence ao CSS.
+ */
+export declare function labelFontOf(node: Element | null): LabelFont;
+/**
+ * Largura do texto na fonte informada. O canvas mede sem inserir nada na
+ * pagina; onde ele nao existe, a estimativa por caractere mantem o calculo
+ * deterministico, em vez de devolver zero e amontoar os rotulos.
+ */
+export declare function measureLabel(text: string, font: LabelFont): number;
+export declare function widestLabel(labels: readonly string[], font: LabelFont): number;
+/**
+ * Texto cortado para caber na largura, com reticencia. Onde o desenho e o
+ * proprio espaco — o centro de um anel, o retangulo de um mapa de area — nao ha
+ * caixa que corte por conta propria.
+ */
+export declare function truncateToWidth(text: string, font: LabelFont, maxWidth: number): string;

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

@@ -0,0 +1,26 @@
+export type ChartCurve = 'smooth' | 'straight';
+export interface ChartPoint {
+    x: number;
+    y: number;
+}
+export interface ChartBand {
+    x: number;
+    y0: number;
+    y1: number;
+}
+/**
+ * Caminho de uma curva, com interrupcao onde o valor nao existe. Emendar sobre
+ * o buraco desenharia um trecho que o dado nao afirma.
+ */
+export declare function linePath(points: readonly (ChartPoint | null)[], curve: ChartCurve): string;
+/** Caminho da faixa entre duas linhas. A base varia quando as areas empilham. */
+export declare function areaPath(bands: readonly (ChartBand | null)[], curve: ChartCurve): string;
+/** Raios dos quatro cantos, no sentido horario a partir do superior esquerdo. */
+export type CornerRadii = [number, number, number, number];
+/**
+ * Retangulo com raio por canto, arredondado por curva quadratica com o controle
+ * no proprio canto. O atributo `rx` arredonda os quatro de uma vez, e numa barra
+ * empilhada isso separa os segmentos: a pilha precisa das duas pontas
+ * arredondadas e do meio reto, para parecer uma barra so.
+ */
+export declare function roundedBarPath(x: number, y: number, width: number, height: number, radii: CornerRadii): string;

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

@@ -0,0 +1,18 @@
+import type { SeriesAppearance } from '../palette/index.js';
+export interface ChartSlice extends SeriesAppearance {
+    label: string;
+    value: number;
+}
+export interface GroupSmallSlicesOptions {
+    label: string;
+    threshold: number;
+}
+/**
+ * Reune as fatias pequenas numa so. Abaixo de um limiar a fatia deixa de ser
+ * legivel no anel e ainda ocupa uma linha da legenda; o agrupamento e a regra
+ * de percentual minimo da referencia.
+ *
+ * A fatia reunida entra no lugar da primeira pequena, para que a ordem das
+ * demais, que a legenda repete, permaneca a mesma.
+ */
+export declare function groupSmallSlices(slices: readonly ChartSlice[], { label, threshold }: GroupSmallSlicesOptions): readonly ChartSlice[];

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

@@ -0,0 +1,39 @@
+import type { LabelFont } from './measureText.js';
+/**
+ * Medidas de espaco do desenho. Elas vivem aqui, e nao em cada grafico, porque
+ * sao a mesma decisao visual repetida: quando cada arquivo guardava a sua, o
+ * mesmo conceito aparecia com valores diferentes em dois vizinhos.
+ *
+ * Geometria em SVG nao le variavel CSS, entao estes sao numeros — mas numeros
+ * de um lugar so.
+ */
+/** Distancia entre uma marca e o rotulo que a descreve. */
+export declare const CHART_LABEL_OFFSET = 8;
+/** Folga minima nas bordas, para o rotulo das pontas nao encostar no limite. */
+export declare const CHART_EDGE_GAP = 12;
+/** Teto da banda de rotulos projetados, como fracao da largura. */
+export declare const CHART_LABEL_BAND = 0.24;
+/**
+ * Espaco que um rotulo de valor ocupa acima da marca. Sai da entrelinha medida,
+ * e nao de um numero fixo: o rotulo ocupa o que o texto ocupa.
+ */
+export declare function valueLabelRoom(font: LabelFont): number;
+/** Folga entre duas barras vizinhas dentro da mesma faixa. */
+export declare const CHART_BAR_GAP = 2;
+export interface BarSlot {
+    offset: number;
+    thickness: number;
+}
+/**
+ * Faixa de um indice que ainda nao existe. Quando entra uma serie, o tween
+ * devolve o array anterior por um render, e ali a nova nao tem presenca.
+ */
+export declare const NO_BAR_SLOT: BarSlot;
+/**
+ * Espessura e deslocamento de cada barra dentro da faixa, a partir da presenca
+ * de cada serie. A barra desligada encolhe a zero e as demais ocupam o lugar
+ * dela, sem deixar a folga sobrando no fim.
+ */
+export declare function barSlots(band: number, presences: readonly number[]): BarSlot[];
+/** Diametro do anel: o lado menor da area disponivel, menos a folga. */
+export declare function ringDiameter(width: number, height: number): number;

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

@@ -0,0 +1,19 @@
+import { type LabelFont } from './measureText.js';
+export interface ChartMetrics {
+    font: LabelFont;
+    height: number;
+    /** Raio dos cantos, lido do token: geometria de caminho nao le variavel CSS. */
+    radius: number;
+    ref: (node: HTMLElement | null) => void;
+    width: number;
+}
+/**
+ * Mede o espaco em que o grafico sera desenhado: largura, altura e a fonte que
+ * os rotulos vao usar. A area de desenho nao entra no fluxo, entao a medida e
+ * sempre o que o layout concedeu, e nunca o que o proprio grafico ocupou.
+ *
+ * A fonte sai da mesma medida porque as duas vem do elemento e mudam juntas:
+ * as margens do grafico dependem da largura dos rotulos, e a largura de um
+ * rotulo depende da fonte resolvida ali.
+ */
+export declare function useChartMetrics(): ChartMetrics;

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

@@ -0,0 +1,9 @@
+export interface HoveredBand {
+    hover: (index: number | null) => void;
+    hovered: number | null;
+}
+/**
+ * Faixa sob o ponteiro. O grafico a usa para o realce e o consumidor recebe o
+ * aviso pela mesma porta, em vez de cada grafico repetir estado e callback.
+ */
+export declare function useHoveredBand(onHover?: (index: number | null) => void): HoveredBand;

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

@@ -0,0 +1,16 @@
+export interface UseSeriesToggleOptions {
+    defaultHiddenSeries?: readonly string[];
+    hiddenSeries?: readonly string[];
+    onHiddenSeriesChange?: (hidden: readonly string[]) => void;
+}
+export interface SeriesToggle {
+    isHidden: (label: string) => boolean;
+    toggle: (label: string) => void;
+}
+/**
+ * Quais series estao ocultas. Controlado quando o produto informa
+ * `hiddenSeries`, nao controlado em caso contrario, conforme `COMPONENTS.md`
+ * 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;

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

@@ -0,0 +1,31 @@
+import { type ArcAngles } from './arcs.js';
+import { type ChartSlice } from './slices.js';
+export interface UseSliceRingOptions {
+    accent?: string;
+    defaultHiddenSlices?: readonly string[];
+    hiddenSlices?: readonly string[];
+    onHiddenSlicesChange?: (hidden: readonly string[]) => void;
+    /** Fatia sob o ponteiro, ja agrupada, ou `null` ao sair dela. */
+    onHoverSlice?: (slice: ChartSlice | null) => void;
+    otherLabel: string;
+    slices: readonly ChartSlice[];
+    smallSliceThreshold: number;
+}
+export interface SliceRing {
+    angles: readonly ArcAngles[];
+    colors: readonly string[];
+    focus: (index: number | null) => void;
+    focused: number | null;
+    isHidden: (label: string) => boolean;
+    ratioOf: (index: number) => number;
+    slices: readonly ChartSlice[];
+    toggle: (label: string) => void;
+    total: number;
+    values: readonly number[];
+}
+/**
+ * O anel repartido: fatias pequenas ja reunidas, cores resolvidas, valores das
+ * fatias ligadas e os angulos em movimento. E o que `ChartPie` e `ChartDonut`
+ * compartilham — o anel, nao o componente.
+ */
+export declare function useSliceRing({ accent, defaultHiddenSlices, hiddenSlices, onHiddenSlicesChange, onHoverSlice, otherLabel, slices, smallSliceThreshold, }: UseSliceRingOptions): SliceRing;

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

@@ -0,0 +1,14 @@
+/**
+ * Numeros que caminham ate o alvo em vez de saltar. Animar o dominio de uma
+ * escala move o grafico inteiro — barras, curvas, grade e marcas do eixo — com
+ * uma unica animacao, em vez de uma por marca.
+ *
+ * Quando a quantidade de numeros muda nao existe par para interpolar, e o valor
+ * assume o alvo de imediato.
+ */
+export interface TweenOptions {
+    duration?: number;
+    /** Ponto de partida do primeiro quadro, para o grafico entrar em vez de surgir pronto. */
+    from?: readonly number[];
+}
+export declare function useTweenedNumbers(target: readonly number[], { duration, from }?: TweenOptions): readonly number[];

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

@@ -0,0 +1,3 @@
+export { SERIES_TOKENS, paletteWithAccent, seriesColors } from './palette.js';
+export { INTENT_TOKENS, resolveSeriesColors } from './seriesColor.js';
+export type { ResolveSeriesColorsOptions, SeriesAppearance, SeriesIntent } from './seriesColor.js';

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

@@ -0,0 +1,17 @@
+/** Quantidade de series que a paleta do Design System cobre. */
+export declare const SERIES_TOKENS = 6;
+/**
+ * Cores das series na paleta do Design System, como variaveis CSS. Resolvem
+ * tema claro e escuro sozinhas, e a serie N usa sempre o mesmo token, para que
+ * um filtro que reduza as series nao repinte as restantes.
+ */
+export declare function seriesColors(quantidade: number): string[];
+/**
+ * Paleta que abre com a cor escolhida pela aplicacao e segue com as do Design
+ * System, saltando a posicao que repetiria essa cor.
+ *
+ * Gerar as demais a partir da cor escolhida foi medido e descartado: girar a
+ * matiz em passos iguais nao separa as series de forma perceptivel, e a paleta
+ * resultante reprova na verificacao de deficiencia de visao de cores.
+ */
+export declare function paletteWithAccent(accent: string, quantidade: number): string[];

package/dist/types/components/charts/palette/seriesColor.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Papel da serie quando a cor carrega significado. Uma serie com intencao nao
+ * entra na rotacao categorica: pintar despesa com a cor de tema do usuario
+ * trocaria o significado da barra a cada usuario.
+ */
+export type SeriesIntent = 'positive' | 'negative' | 'warning' | 'neutral';
+export interface SeriesAppearance {
+    color?: string;
+    intent?: SeriesIntent;
+}
+export interface ResolveSeriesColorsOptions {
+    accent?: string;
+}
+/** Token de cada intencao. A paleta e quem detem esse mapa. */
+export declare const INTENT_TOKENS: Record<SeriesIntent, string>;
+/**
+ * Cor de cada serie, em tres niveis de precedencia: a cor informada pelo
+ * implementador vence; depois a intencao semantica; por fim a paleta
+ * categorica, que abre com a cor de tema quando houver.
+ *
+ * Series com cor ou intencao nao consomem posicao da paleta, para que as
+ * categoricas sigam a ordem sem deixar buracos.
+ */
+export declare function resolveSeriesColors(series: readonly SeriesAppearance[], { accent }?: ResolveSeriesColorsOptions): string[];

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

@@ -0,0 +1,2 @@
+export { bandScale, domainOf, linearScale, logScale, mergeDomains, pointScale, radiusScale, stackedExtremes, ticksFor, timeScale, } from './scales.js';
+export type { CategoricalScaleOptions, ContinuousScaleOptions, NumericRange, ScaleKind } from './scales.js';

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

@@ -0,0 +1,57 @@
+export type ScaleKind = 'linear' | 'log' | 'time' | 'band' | 'point';
+export interface NumericRange {
+    max: number;
+    min: number;
+}
+export interface ContinuousScaleOptions {
+    clamp?: boolean;
+    domain: NumericRange;
+    nice?: boolean;
+    range: [number, number];
+}
+export interface CategoricalScaleOptions {
+    domain: readonly string[];
+    padding?: number;
+    range: [number, number];
+}
+/**
+ * Faixa que cobre os valores, com o zero incluido por padrao. Uma barra que
+ * nao parte do zero exagera a diferenca entre os valores.
+ */
+export declare function domainOf(values: readonly number[], { includeZero }?: {
+    includeZero?: boolean | undefined;
+}): NumericRange;
+/** Une varias series na mesma faixa, para que compartilhem um unico eixo. */
+/**
+ * Extremos que uma pilha alcanca, e nao apenas onde ela termina. Com sinais
+ * mistos o total engana: `+10` e `-5` somam `5`, mas o segmento positivo chega
+ * a `10` e ficaria desenhado fora da area. O dominio precisa do caminho do
+ * acumulado, incluindo o zero de onde ele parte.
+ */
+export declare function stackedExtremes(contributions: readonly number[]): number[];
+export declare function mergeDomains(domains: readonly NumericRange[]): NumericRange;
+export declare function linearScale({ clamp, domain, nice, range }: ContinuousScaleOptions): import("d3-scale").ScaleLinear<number, number, never>;
+/**
+ * Escala logaritmica. Nao existe log de zero ou de negativo, entao o dominio
+ * e recortado para o primeiro valor positivo.
+ */
+export declare function logScale({ clamp, domain, nice, range }: ContinuousScaleOptions): import("d3-scale").ScaleLogarithmic<number, number, never>;
+export declare function timeScale({ clamp, domain, nice, range }: ContinuousScaleOptions): import("d3-scale").ScaleTime<number, number, never>;
+/** Faixas de largura igual, uma por categoria. Serve barras. */
+export declare function bandScale({ domain, padding, range }: CategoricalScaleOptions): import("d3-scale").ScaleBand<string>;
+/** Pontos sem largura, um por categoria. Serve linhas e dispersao. */
+export declare function pointScale({ domain, padding, range }: CategoricalScaleOptions): import("d3-scale").ScalePoint<string>;
+/**
+ * Raio pela raiz do valor, para que a area da bolha acompanhe o dado em vez do
+ * raio. Mapeando o valor direto ao raio, a area cresceria com o quadrado dele e
+ * exageraria a diferenca.
+ */
+export declare function radiusScale(maxValue: number, range: [number, number]): import("d3-scale").ScalePower<number, number, never>;
+/**
+ * Marcas de um eixo continuo. Sem contagem informada, o eixo decide pelo
+ * espaco que tem, para nao amontoar rotulos em area estreita. Em escala
+ * categorica as marcas sao o proprio dominio.
+ */
+export declare function ticksFor(scale: {
+    ticks: (count?: number) => number[];
+}, length: number, count?: number): number[];

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

@@ -0,0 +1,20 @@
+import { type ComponentPropsWithRef, type ReactNode } from 'react';
+export interface AccordionItem {
+    content: ReactNode;
+    disabled?: boolean;
+    key: string;
+    label: string;
+}
+export type AccordionIconPosition = 'left' | 'right';
+export interface AccordionProps extends ComponentPropsWithRef<'div'> {
+    defaultExpandedKeys?: readonly string[];
+    expandedKeys?: readonly string[];
+    items: readonly AccordionItem[];
+    multiple?: boolean;
+    onExpandedChange?: (keys: readonly string[]) => void;
+    /** Direita e a convencao da web; esquerda serve a rotulos curtos em coluna estreita. */
+    iconPosition?: AccordionIconPosition;
+    /** Divisor entre as secoes, com a folga que ele exige. */
+    divider?: boolean;
+}
+export declare function Accordion({ className, defaultExpandedKeys, expandedKeys, items, multiple, onExpandedChange, iconPosition, divider, ...props }: AccordionProps): import("react").JSX.Element;

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

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

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

@@ -0,0 +1,8 @@
+import { type HTMLAttributes } from 'react';
+export type AvatarSize = 'sm' | 'md' | 'lg';
+export interface AvatarProps extends HTMLAttributes<HTMLElement> {
+    name: string;
+    size?: AvatarSize;
+    src?: string;
+}
+export declare function Avatar({ className, name, onError, size, src, ...props }: AvatarProps): import("react").JSX.Element;

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

@@ -0,0 +1,2 @@
+export { Avatar } from './Avatar.js';
+export type { AvatarProps, AvatarSize } from './Avatar.js';

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

@@ -0,0 +1,8 @@
+import type { HTMLAttributes } from 'react';
+export type BadgeTone = 'ok' | 'warn' | 'info' | 'danger' | 'primary' | 'neutral';
+export interface BadgeProps extends HTMLAttributes<HTMLSpanElement> {
+    dot?: boolean;
+    outline?: boolean;
+    tone?: BadgeTone;
+}
+export declare function Badge({ children, className, dot, outline, tone, ...props }: BadgeProps): import("react").JSX.Element;

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

@@ -0,0 +1,2 @@
+export { Badge } from './Badge.js';
+export type { BadgeProps, BadgeTone } from './Badge.js';