reactigoded 1.0.0-beta.26

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

@@ -0,0 +1,60 @@
+import { HTMLAttributes, ReactNode, Ref } from 'react';
+export type SkeletonVariant = "text" | "title" | "avatar" | "avatar-lg" | "card" | "image" | "button";
+export interface SkeletonProps extends HTMLAttributes<HTMLDivElement> {
+    /**
+     * Forma del placeholder. `text` (default) es una línea de texto, `title` una
+     * más alta, `avatar`/`avatar-lg` círculos, `card`/`image` rectángulos
+     * grandes y `button` un placeholder de botón.
+     */
+    variant?: SkeletonVariant | undefined;
+    ref?: Ref<HTMLDivElement> | undefined;
+}
+/**
+ * Skeleton — placeholder animado **decorativo** mientras se carga
+ * contenido. NO anuncia carga al lector de pantalla por sí solo:
+ * `role="presentation"` + `aria-hidden="true"`.
+ *
+ * Para anunciar el estado de carga al SR, envuelve un grupo de
+ * `Skeleton` en `<SkeletonContainer label="...">`. El container
+ * dispara UN solo aviso al SR (no uno por cada `Skeleton`, que era
+ * el bug del patrón anterior con `role="status"` por instancia).
+ *
+ * Cualquier tamaño extra puede pasarse por `style` (`width`, `height`).
+ *
+ * @example
+ * <SkeletonContainer label="Cargando perfil">
+ *   <Skeleton variant="avatar" />
+ *   <Skeleton variant="title" />
+ *   <Skeleton variant="text" />
+ * </SkeletonContainer>
+ *
+ * <Skeleton variant="card" style={{ height: 200 }} />
+  *
+ * @server-safe
+ */
+export declare function Skeleton({ variant, className, ref, ...rest }: SkeletonProps): import("react").JSX.Element;
+export interface SkeletonContainerProps extends HTMLAttributes<HTMLDivElement> {
+    /**
+     * Etiqueta para SR. Por defecto `"Cargando contenido…"` (ES).
+     * Pasa una string específica del contexto para mejor UX SR.
+     */
+    label?: string | undefined;
+    children: ReactNode;
+    ref?: Ref<HTMLDivElement> | undefined;
+}
+/**
+ * SkeletonContainer — wrapper accesible para grupos de `Skeleton`.
+ * Anuncia estado de carga UNA vez al lector de pantalla
+ * (`role="status"` + `aria-busy="true"` + `aria-live="polite"` +
+ * `aria-label`). El layout es neutro (`display: contents`): NO
+ * añade caja al flujo, los hijos se posicionan como si el container
+ * no existiese.
+ *
+ * @example
+ * <SkeletonContainer label="Cargando lista de pedidos">
+ *   <Skeleton variant="text" />
+ *   <Skeleton variant="text" />
+ *   <Skeleton variant="text" />
+ * </SkeletonContainer>
+ */
+export declare function SkeletonContainer({ label, children, className, ref, ...rest }: SkeletonContainerProps): import("react").JSX.Element;

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

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

package/dist/components/Slider/Slider.d.ts

@@ -0,0 +1,44 @@
+import { InputHTMLAttributes, Ref } from 'react';
+export interface SliderProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "type" | "onChange"> {
+    /** Mostrar el valor actual junto al slider. */
+    showValue?: boolean | undefined;
+    /** Formateador opcional para el valor visible y para `aria-valuetext`. */
+    formatValue?: ((value: number) => string) | undefined;
+    /**
+     * Callback con el valor numérico decodificado.
+     *
+     * B-02 / H-17 (RC1): pre-RC1 Slider exponía `onChange` (ChangeEvent
+     * nativo) Y `onValueChange` (number). Ambos en paralelo confundían al
+     * consumer (¿cuál uso?). RC1 estandariza con el resto del DS: queda
+     * solo `onValueChange<number>`. Si necesitas el ChangeEvent nativo
+     * por algún motivo (analytics del DOM event, e.g.), añade un wrapper
+     * `<input type="range" onChange={...}>` manual.
+     */
+    onValueChange?: ((value: number) => void) | undefined;
+    /**
+     * Ids extra para `aria-describedby`. Pasar string para un único id o
+     * array para varios. Se concatenan con cualquier `aria-describedby`
+     * que el consumer pase por rest. Patrón canónico del DS para enlazar
+     * `Helper` / `ErrorText` / live-regions con tecnologías asistivas.
+     */
+    describedBy?: string | string[] | undefined;
+    ref?: Ref<HTMLInputElement> | undefined;
+}
+/**
+ * Slider — `<input type="range">` estilizado. Con `showValue` muestra el
+ * valor actual al lado (controlado o no). Soporta `formatValue` para
+ * formatear (ej. `(v) => `${v}%``).
+ *
+ * `formatValue` también se aplica a `aria-valuetext` para que los lectores
+ * de pantalla anuncien el formato (`50%` en vez de `50`).
+ *
+ * @example
+ * <Slider
+ *   aria-label="Volumen"
+ *   value={vol}
+ *   onValueChange={setVol}
+ *   showValue
+ *   formatValue={(v) => `${v}%`}
+ * />
+ */
+export declare function Slider({ min, max, step, value, defaultValue, showValue, formatValue, className, onValueChange, describedBy, ref, ...rest }: SliderProps): import("react").JSX.Element;

package/dist/components/Slider/index.d.ts

@@ -0,0 +1,2 @@
+export { Slider } from './Slider.js';
+export type { SliderProps } from './Slider.js';

package/dist/components/Slot/Slot.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/Slot/composeEventHandlers.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/Slot/composeRefs.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/Slot/index.d.ts

@@ -0,0 +1,3 @@
+export type { SlotProps } from './Slot.js';
+export { composeRefs } from './composeRefs.js';
+export { composeEventHandlers } from './composeEventHandlers.js';

package/dist/components/Spinner/Spinner.d.ts

@@ -0,0 +1,31 @@
+import { HTMLAttributes, Ref } from 'react';
+export type SpinnerVariant = "brand" | "secondary" | "success" | "warning" | "danger" | "info";
+export type SpinnerSize = "xs" | "sm" | "md" | "lg" | "xl";
+export interface SpinnerProps extends HTMLAttributes<HTMLSpanElement> {
+    /** Color del spinner. Por defecto `"brand"`. */
+    variant?: SpinnerVariant | undefined;
+    /** Tamaño. `"md"` por defecto. */
+    size?: SpinnerSize | undefined;
+    /**
+     * Etiqueta accesible para SR. Por defecto `"Cargando…"` (ES). Sustituye
+     * el `aria-label` del componente para i18n. Si pasas también
+     * `aria-label` directo (vía rest), `aria-label` gana sobre `label`.
+     */
+    label?: string | undefined;
+    ref?: Ref<HTMLSpanElement> | undefined;
+}
+/**
+ * Spinner — indicador de carga circular animado.
+ *
+ * Aplica `role="status"` y `aria-label` (default "Cargando…") para que los
+ * lectores de pantalla anuncien el estado de carga. Pasa `aria-label` para
+ * personalizar (i18n o contexto específico).
+ *
+ * @example
+ * <Spinner />
+ * <Spinner variant="success" size="lg" />
+ * <Spinner aria-label="Procesando pago…" />
+ *
+ * @server-safe
+ */
+export declare function Spinner({ variant, size, label, className, ref, ...rest }: SpinnerProps): import("react").JSX.Element;

package/dist/components/Spinner/index.d.ts

@@ -0,0 +1,2 @@
+export { Spinner } from './Spinner.js';
+export type { SpinnerProps, SpinnerVariant, SpinnerSize } from './Spinner.js';

package/dist/components/Stepper/Step.d.ts

@@ -0,0 +1,17 @@
+import { HTMLAttributes, ReactNode, Ref } from 'react';
+export interface StepProps extends HTMLAttributes<HTMLDivElement> {
+    /** Etiqueta debajo del círculo (sólo aplica con `Stepper labeled`). */
+    label?: ReactNode | undefined;
+    ref?: Ref<HTMLDivElement> | undefined;
+}
+/**
+ * Step — un paso de un `Stepper`. No se usa suelto: pasa los `Step`s como
+ * children del `Stepper` y este se encarga de inyectar `index`/`active`/`complete`.
+ *
+ * Cuando el Stepper padre es interactivo (`onActiveChange` definido),
+ * el dot del Step lleva `role="button"` + `tabIndex` roving y soporta
+ * activación por teclado (Enter/Space) y navegación (ArrowKey/Home/End).
+  *
+ * @server-safe
+ */
+export declare function Step(props: StepProps): import("react").JSX.Element;

package/dist/components/Stepper/Stepper.d.ts

@@ -0,0 +1,97 @@
+import { HTMLAttributes, ReactNode, Ref } from 'react';
+export interface StepperProps extends HTMLAttributes<HTMLDivElement> {
+    /**
+     * Índice (0-based) del step activo en **modo controlled**. Steps
+     * anteriores se marcan completos; el de este índice lleva
+     * `aria-current="step"`.
+     *
+     * **D5 (beta.24)**: `active` ahora es opcional. Patrón controlled/
+     * uncontrolled DS-wide alineado con Pagination, Sidebar, Tabs,
+     * Switch, Accordion:
+     *
+     *   - Pasas `active` → controlled. Tu app gestiona el estado y este
+     *     debe actualizarse en respuesta a `onActiveChange`. Si lo dejas
+     *     congelado, el Stepper se queda congelado (consciente).
+     *   - Omites `active` (y opcionalmente pasas `defaultActive`) →
+     *     uncontrolled. El Stepper mantiene su propio estado interno y
+     *     `onActiveChange` actúa como observer (callback opcional).
+     *
+     * En modo controlled SIN `onActiveChange` el Stepper queda
+     * presentational (sin keyboard nav ni clicks activos). En modo
+     * uncontrolled siempre es interactive — `defaultActive` solo describe
+     * el valor inicial; sin un mecanismo para mutarlo el componente sería
+     * un display estático sin razón de ser.
+     */
+    active?: number | undefined;
+    /**
+     * Valor inicial en **modo uncontrolled** (cuando `active` es
+     * undefined). Por defecto `0`. Ignorado en modo controlled.
+     */
+    defaultActive?: number | undefined;
+    /**
+     * Callback cuando el usuario navega o activa por teclado / click.
+     * Dispara en ambos modos:
+     *
+     *   - **Controlled** (`active` definido): el callback es el único
+     *     mecanismo para que el consumer actualice `active`. Si está
+     *     omitido en controlled, el Stepper queda presentational
+     *     (consumer no puede observar cambios → sin sentido habilitar
+     *     interactive).
+     *   - **Uncontrolled** (`active` undefined): el callback actúa como
+     *     observer. El Stepper actualiza su estado interno aunque el
+     *     consumer no pase callback.
+     *
+     * Interactive mode (focus + keyboard nav):
+     * - Cada step lleva `role="button"` + `tabIndex` roving.
+     * - ArrowLeft / ArrowUp → step anterior.
+     * - ArrowRight / ArrowDown → step siguiente.
+     * - Home → primer step.
+     * - End → último step.
+     * - Enter / Space → activa el step focuseado.
+     *
+     * El callback recibe el índice 0-based del step destino. En modo
+     * controlled el consumer decide si lo aplica (puede rechazar saltos
+     * hacia adelante en un wizard, p.ej.).
+     */
+    onActiveChange?: ((next: number) => void) | undefined;
+    /** Si true, usa el layout con labels debajo (`ig-stepper-labeled`). */
+    labeled?: boolean | undefined;
+    /** Una lista de `Step`. */
+    children: ReactNode;
+    ref?: Ref<HTMLDivElement> | undefined;
+}
+/**
+ * Stepper — secuencia visual de pasos. Steps con índice menor que `active`
+ * se marcan como `complete`; el del índice `active` lleva `aria-current="step"`.
+ *
+ * Dos layouts:
+ *   - **Compacto** (default): círculos conectados por una línea fina.
+ *   - **Labeled** (`labeled`): círculos sobre labels; conector como `::after`.
+ *
+ * Pasa los `Step`s como children — el Stepper inyecta `index`/`active`/`complete`
+ * a cada uno automáticamente.
+ *
+ * **Modo interactive** (cuando `onActiveChange` está definido):
+ * cada step es focuseable con roving tabIndex y soporta teclado completo
+ * (ArrowKey, Home/End, Enter/Space). Patrón inspirado en WAI-ARIA APG
+ * Tabs adaptado a stepper. El consumer es quien finalmente aplica el
+ * cambio actualizando `active`.
+ *
+ * @example
+ * // Presentational (sin keyboard nav, default)
+ * <Stepper active={2}>
+ *   <Step label="Paso 1" />
+ *   <Step label="Paso 2" />
+ *   <Step label="Paso 3" />
+ * </Stepper>
+ *
+ * @example
+ * // Interactive (teclado completo)
+ * const [step, setStep] = useState(0);
+ * <Stepper active={step} onActiveChange={setStep} labeled>
+ *   <Step label="Datos" />
+ *   <Step label="Pago" />
+ *   <Step label="Confirmar" />
+ * </Stepper>
+ */
+export declare function Stepper({ active, defaultActive, onActiveChange, labeled, className, children, ref, ...rest }: StepperProps): import("react").JSX.Element;

package/dist/components/Stepper/index.d.ts

@@ -0,0 +1,4 @@
+export { Stepper } from './Stepper.js';
+export type { StepperProps } from './Stepper.js';
+export { Step } from './Step.js';
+export type { StepProps } from './Step.js';

package/dist/components/Switch/Switch.d.ts

@@ -0,0 +1,53 @@
+import { InputHTMLAttributes, Ref } from 'react';
+export type SwitchVariant = "brand" | "secondary" | "success" | "warning" | "danger" | "info";
+export interface SwitchProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "type" | "size"> {
+    /** Color del switch cuando está activo. */
+    variant?: SwitchVariant | undefined;
+    /** Etiqueta visible junto al switch. */
+    children?: React.ReactNode | undefined;
+    /**
+     * Activa el tercer estado visual del switch (thumb centrado en el
+     * track, color de variante de fondo). Se aplica vía
+     * `el.indeterminate = true` en el `<input>` nativo y reemplaza
+     * `aria-checked` por `"mixed"` para lectores de pantalla. Útil en
+     * toggles maestros que controlan un grupo donde unos hijos están
+     * on y otros off (desde 1.0.0-beta.8).
+     */
+    indeterminate?: boolean | undefined;
+    /**
+     * Ids extra para `aria-describedby`. Pasar string para un único id o
+     * array para varios. Se concatenan con cualquier `aria-describedby`
+     * que el consumer pase por rest. Patrón canónico del DS para enlazar
+     * `Helper` / `ErrorText` / live-regions con tecnologías asistivas.
+     */
+    describedBy?: string | string[] | undefined;
+    ref?: Ref<HTMLInputElement> | undefined;
+}
+/**
+ * Switch — toggle accesible. Internamente es un `<input type="checkbox">`
+ * con `role="switch"` + `aria-checked` para que los lectores de pantalla lo
+ * anuncien como toggle (no como checkbox). Va envuelto en `<label>` con una
+ * pista visual decorativa.
+ *
+ * **Estructura DOM**:
+ * ```
+ * <label class="ig-switch ig-switch-{variant}">
+ *   <input type="checkbox" role="switch" />
+ *   <span class="ig-switch-track" aria-hidden="true" />
+ *   {children}  ← label de texto opcional
+ * </label>
+ * ```
+ *
+ * La clase `ig-switch` vive en el `<label>` wrapper, NO en el `<input>`.
+ * En tests, `screen.getByRole("switch")` devuelve el input — para
+ * asserts sobre la clase wrapper desde el input usar
+ * `input.closest("label")`.
+ *
+ * @example
+ * <Switch defaultChecked>Recibir notificaciones</Switch>
+ * <Switch indeterminate>Notificaciones por categoría</Switch>
+ * <Switch checked={on} onChange={(e) => setOn(e.target.checked)}>
+ *   Modo experimental
+ * </Switch>
+ */
+export declare function Switch({ variant, className, children, ref, disabled, checked, defaultChecked, indeterminate, describedBy, onChange, ...rest }: SwitchProps): import("react").JSX.Element;

package/dist/components/Switch/index.d.ts

@@ -0,0 +1,2 @@
+export { Switch } from './Switch.js';
+export type { SwitchProps, SwitchVariant } from './Switch.js';

package/dist/components/Table/Table.d.ts

@@ -0,0 +1,74 @@
+import { HTMLAttributes, Ref, TableHTMLAttributes, TdHTMLAttributes, ThHTMLAttributes } from 'react';
+export type TableLayout = "auto" | "fixed";
+export interface TableProps extends TableHTMLAttributes<HTMLTableElement> {
+    /** Filas alternas con color de fondo. */
+    striped?: boolean | undefined;
+    /** Fila destacada al hover. */
+    hover?: boolean | undefined;
+    /** Bordes en todas las celdas. */
+    bordered?: boolean | undefined;
+    /** Padding reducido. */
+    compact?: boolean | undefined;
+    /** `table-layout`: `auto` (defecto del navegador) o `fixed`. */
+    layout?: TableLayout | undefined;
+    /**
+     * Si se proporciona, envuelve la tabla en un `<div>` con scroll horizontal.
+     * Útil para tablas anchas en mobile.
+     */
+    scrollable?: boolean | undefined;
+    /**
+     * Etiqueta accesible del wrapper scrollable. Aplica sólo cuando
+     * `scrollable=true`. Por defecto "Tabla con scroll horizontal".
+     */
+    scrollAreaLabel?: string | undefined;
+    ref?: Ref<HTMLTableElement> | undefined;
+}
+/**
+ * Table — tabla con clases del design system.
+ *
+ * Componer con `TableHead`, `TableBody`, `TableFoot`, `TableRow`,
+ * `TableHeaderCell` (`<th>`) y `TableCell` (`<td>`), o usar las etiquetas
+ * HTML nativas directamente — todas las variantes se aplican vía clases en
+ * `<table>`.
+  *
+ * @server-safe
+ */
+export declare function Table({ className, striped, hover, bordered, compact, layout, scrollable, scrollAreaLabel, ref, ...rest }: TableProps): import("react").JSX.Element;
+export interface TableHeadProps extends HTMLAttributes<HTMLTableSectionElement> {
+    ref?: Ref<HTMLTableSectionElement> | undefined;
+}
+/** TableHead — sección `<thead>` de la tabla. */
+export declare function TableHead({ ref, ...rest }: TableHeadProps): import("react").JSX.Element;
+export interface TableBodyProps extends HTMLAttributes<HTMLTableSectionElement> {
+    ref?: Ref<HTMLTableSectionElement> | undefined;
+}
+/** TableBody — sección `<tbody>` de la tabla. */
+export declare function TableBody({ ref, ...rest }: TableBodyProps): import("react").JSX.Element;
+export interface TableFootProps extends HTMLAttributes<HTMLTableSectionElement> {
+    ref?: Ref<HTMLTableSectionElement> | undefined;
+}
+/** TableFoot — sección `<tfoot>` de la tabla. */
+export declare function TableFoot({ ref, ...rest }: TableFootProps): import("react").JSX.Element;
+export interface TableRowProps extends HTMLAttributes<HTMLTableRowElement> {
+    ref?: Ref<HTMLTableRowElement> | undefined;
+}
+/** TableRow — fila `<tr>`. */
+export declare function TableRow({ ref, ...rest }: TableRowProps): import("react").JSX.Element;
+export interface TableHeaderCellProps extends ThHTMLAttributes<HTMLTableCellElement> {
+    ref?: Ref<HTMLTableCellElement> | undefined;
+}
+/** TableHeaderCell — celda `<th>`. Acepta `scope`, `colSpan`, etc. */
+export declare function TableHeaderCell({ ref, ...rest }: TableHeaderCellProps): import("react").JSX.Element;
+export interface TableCellProps extends TdHTMLAttributes<HTMLTableCellElement> {
+    ref?: Ref<HTMLTableCellElement> | undefined;
+}
+/** TableCell — celda `<td>`. */
+export declare function TableCell({ ref, ...rest }: TableCellProps): import("react").JSX.Element;
+export type TableCaptionSide = "top" | "bottom";
+export interface TableCaptionProps extends HTMLAttributes<HTMLTableCaptionElement> {
+    /** Posiciona el caption arriba o abajo de la tabla. */
+    side?: TableCaptionSide | undefined;
+    ref?: Ref<HTMLTableCaptionElement> | undefined;
+}
+/** TableCaption — `<caption>` de la tabla con prop `side` (top/bottom). */
+export declare function TableCaption({ className, side, ref, ...rest }: TableCaptionProps): import("react").JSX.Element;

package/dist/components/Table/index.d.ts

@@ -0,0 +1,2 @@
+export { Table, TableHead, TableBody, TableFoot, TableRow, TableHeaderCell, TableCell, TableCaption, } from './Table.js';
+export type { TableProps, TableHeadProps, TableBodyProps, TableFootProps, TableRowProps, TableHeaderCellProps, TableCellProps, TableCaptionProps, TableLayout, TableCaptionSide, } from './Table.js';

package/dist/components/Tabs/Tabs.d.ts

@@ -0,0 +1,41 @@
+import { HTMLAttributes, Ref } from 'react';
+export type TabsVariant = "brand" | "secondary" | "success" | "warning" | "danger" | "info";
+export interface TabsProps extends HTMLAttributes<HTMLDivElement> {
+    /** TabsTrigger seleccionado (modo controlado). */
+    value?: string | undefined;
+    /** TabsTrigger inicial (modo no controlado). */
+    defaultValue?: string | undefined;
+    /** Callback al cambiar de tab. */
+    onValueChange?: ((value: string) => void) | undefined;
+    /** Color del indicador del tab activo. */
+    variant?: TabsVariant | undefined;
+    /** Estilo "pills" en vez de underline. */
+    pills?: boolean | undefined;
+    /** Orientación del tablist. */
+    orientation?: "horizontal" | "vertical" | undefined;
+    ref?: Ref<HTMLDivElement> | undefined;
+}
+/**
+ * Tabs — wrapper que provee contexto a `TabsList`+`TabsTrigger`+`TabsContent`.
+ *
+ * Soporta controlled (`value`+`onValueChange`) y uncontrolled (`defaultValue`).
+ * `TabsTrigger` es un `<button role="tab">` y `TabsContent` un `<div role="tabpanel">`
+ * conectados por `aria-controls`/`aria-labelledby`. Keyboard nav con flechas
+ * (←→ horizontal, ↑↓ vertical) + Home/End.
+ *
+ * **Auto-selección del primer TabsTrigger desde `1.0.0-beta.3`**: si el consumer no
+ * pasa ni `value` ni `defaultValue`, el primer `TabsTrigger` que se monte queda
+ * seleccionado automáticamente. Antes el tablist se quedaba sin tab stop
+ * (todos los `tabIndex=-1`), inaccesible por teclado.
+ *
+ * @example
+ * <Tabs defaultValue="perfil">
+ *   <TabsList aria-label="Cuenta">
+ *     <TabsTrigger value="perfil">Perfil</TabsTrigger>
+ *     <TabsTrigger value="seguridad">Seguridad</TabsTrigger>
+ *   </TabsList>
+ *   <TabsContent value="perfil">Datos personales</TabsContent>
+ *   <TabsContent value="seguridad" keepMounted>Contraseña y 2FA</TabsContent>
+ * </Tabs>
+ */
+export declare function Tabs({ value, defaultValue, onValueChange, variant, pills, orientation, className, children, ref, ...rest }: TabsProps): import("react").JSX.Element;

package/dist/components/Tabs/TabsContent.d.ts

@@ -0,0 +1,15 @@
+import { HTMLAttributes, Ref } from 'react';
+export interface TabsContentProps extends HTMLAttributes<HTMLDivElement> {
+    /** Identificador del tab al que pertenece este panel. */
+    value: string;
+    /** Si `true`, el panel se mantiene en el DOM aunque no sea el activo (oculto con `hidden`). */
+    keepMounted?: boolean | undefined;
+    ref?: Ref<HTMLDivElement> | undefined;
+}
+/**
+ * TabsContent — contenedor `role="tabpanel"`. Por defecto sólo se renderiza
+ * cuando su `value` coincide con el tab activo; con `keepMounted` se mantiene
+ * en el DOM y se oculta vía atributo `hidden` (útil si necesitas conservar
+ * estado interno del panel al cambiar de tab).
+ */
+export declare function TabsContent({ value, keepMounted, className, children, ref, ...rest }: TabsContentProps): import("react").JSX.Element | null;

package/dist/components/Tabs/TabsContext.d.ts

@@ -0,0 +1,61 @@
+export interface TabsContextValue {
+    /** Id del tab seleccionado. */
+    selected: string;
+    /** Cambia el tab seleccionado. */
+    setSelected: (value: string) => void;
+    /** Prefijo único para generar IDs de tab/panel relacionados. */
+    baseId: string;
+    /** Orientación: condiciona el keyboard nav (←→ vs ↑↓). */
+    orientation: "horizontal" | "vertical";
+    /**
+     * Registra un TabsTrigger al montarse. Devuelve un cleanup que lo desregistra.
+     * Si el Tabs no recibió `value`/`defaultValue`, usa el primer TabsTrigger
+     * registrado como selección inicial. Permite que el consumer omita
+     * `defaultValue` sin dejar el tablist sin tab stop accesible.
+     */
+    register: (value: string) => () => void;
+    /**
+     * H-26: `true` si `selected` matchea el `value` de algún TabsTrigger montado.
+     * En modo controlled con `value` inválido, este flag es `false` y
+     * el primer TabsTrigger registrado entra en modo "fallback tabindex" para
+     * NO dejar el tablist sin tab stop accesible.
+     */
+    selectedExists: boolean;
+    /**
+     * H-26: `value` del primer TabsTrigger registrado. Sirve como fallback de
+     * tab stop cuando `selectedExists === false`.
+     */
+    firstRegistered: string | undefined;
+}
+export declare const TabsContext: import('react').Context<TabsContextValue | null>;
+/**
+ * Hook que expone el contexto de un `<Tabs>` (selected, setSelected,
+ * orientation, baseId, register). Lo usan internamente `TabsTrigger`, `TabsList` y
+ * `TabsContent`. Útil también si construyes tu propio sub-componente que
+ * vive dentro del árbol de un `<Tabs>` y necesita reaccionar al tab
+ * seleccionado.
+ *
+ * @example
+ * // Indicador "tab actual" custom:
+ * function CurrentTabBadge() {
+ *   const { selected } = useTabs();
+ *   return <Badge variant="brand">{selected || "ninguno"}</Badge>;
+ * }
+ *
+ * function App() {
+ *   return (
+ *     <Tabs defaultValue="perfil">
+ *       <TabsList aria-label="Cuenta">
+ *         <TabsTrigger value="perfil">Perfil</TabsTrigger>
+ *         <TabsTrigger value="seguridad">Seguridad</TabsTrigger>
+ *       </TabsList>
+ *       <CurrentTabBadge />
+ *       <TabsContent value="perfil">…</TabsContent>
+ *       <TabsContent value="seguridad">…</TabsContent>
+ *     </Tabs>
+ *   );
+ * }
+ *
+ * @throws Error si se usa fuera de `<Tabs>`.
+ */
+export declare function useTabs(): TabsContextValue;

package/dist/components/Tabs/TabsList.d.ts

@@ -0,0 +1,10 @@
+import { HTMLAttributes, Ref } from 'react';
+export interface TabsListProps extends HTMLAttributes<HTMLDivElement> {
+    ref?: Ref<HTMLDivElement> | undefined;
+}
+/**
+ * TabsList — contenedor `role="tablist"` para `TabsTrigger`s. Hereda la orientación
+ * del `Tabs` padre. Pasa `aria-label` para etiquetar el tablist (i18n vía
+ * el atributo HTML estándar).
+ */
+export declare function TabsList({ className, children, ref, ...rest }: TabsListProps): import("react").JSX.Element;

package/dist/components/Tabs/TabsTrigger.d.ts

@@ -0,0 +1,15 @@
+import { ButtonHTMLAttributes, Ref } from 'react';
+export interface TabsTriggerProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    /** Identificador único del tab. Debe coincidir con el `value` del `TabsContent` correspondiente. */
+    value: string;
+    ref?: Ref<HTMLButtonElement> | undefined;
+}
+/**
+ * TabsTrigger — botón `role="tab"` dentro de `TabsList`. Incluye `aria-selected`,
+ * `aria-controls` y roving tabindex (sólo el activo es focuseable directamente).
+ *
+ * Keyboard:
+ *   - ←/→ (horizontal) o ↑/↓ (vertical): mueve foco al sibling y lo activa.
+ *   - Home/End: salta al primero/último activable.
+ */
+export declare function TabsTrigger({ value, className, children, disabled, onKeyDown, ref, ...rest }: TabsTriggerProps): import("react").JSX.Element;

package/dist/components/Tabs/index.d.ts

@@ -0,0 +1,8 @@
+export { Tabs } from './Tabs.js';
+export type { TabsProps, TabsVariant } from './Tabs.js';
+export { TabsList } from './TabsList.js';
+export type { TabsListProps } from './TabsList.js';
+export { TabsTrigger } from './TabsTrigger.js';
+export type { TabsTriggerProps } from './TabsTrigger.js';
+export { TabsContent } from './TabsContent.js';
+export type { TabsContentProps } from './TabsContent.js';

package/dist/components/Textarea/Textarea.d.ts

@@ -0,0 +1,51 @@
+import { Ref, TextareaHTMLAttributes } from 'react';
+export type TextareaState = "default" | "invalid" | "valid";
+export interface TextareaProps extends TextareaHTMLAttributes<HTMLTextAreaElement> {
+    /** Auto-resize basado en contenido. */
+    auto?: boolean | undefined;
+    /** Estado de validación visual. */
+    state?: TextareaState | undefined;
+    /**
+     * IDs de elementos descriptivos (`Helper`/`ErrorText`) combinados en
+     * `aria-describedby`. Acepta un id o lista de ids. Si pasas también
+     * `aria-describedby` directo (vía rest), AMBOS se concatenan.
+     */
+    describedBy?: string | string[] | undefined;
+    ref?: Ref<HTMLTextAreaElement> | undefined;
+}
+/**
+ * Textarea — `<textarea>` estilizado. `auto=true` activa auto-grow basado en
+ * contenido (clase `ig-textarea-auto`).
+ *
+ * **Soporte de `auto`**: usa `field-sizing: content` (CSS).
+ * - Chrome/Edge 123+ (mar 2024) ✅
+ * - Safari 17.4+ (mar 2024) ✅
+ * - Firefox: aún no (en progreso, sin ETA pública).
+ *   Bugs Mozilla: #1977176 (input), #1977177 (textarea).
+ *
+ * En Firefox el textarea cae al comportamiento por defecto (`rows`) sin
+ * auto-grow. Para auto-grow universal, gestiona el alto vía JS desde el
+ * consumer, idealmente envuelto en un `@supports not (field-sizing: content)`.
+ *
+ * Detección runtime para activar fallback JS:
+ * ```js
+ * const needsJsFallback = !CSS.supports('field-sizing', 'content');
+ * ```
+ *
+ * Y a nivel CSS:
+ * ```css
+ * @supports not (field-sizing: content) {
+ *   // estilos del fallback
+ * }
+ * ```
+ *
+ * **A11y dev warn**: si en desarrollo se monta sin `<Label htmlFor>`,
+ * `aria-label`, `aria-labelledby` ni `placeholder`, se emite warn
+ * `[reactigoded] <Textarea> sin label asociado.` (capa 1.1 debt doc).
+ *
+ * @example
+ * <Textarea placeholder="Cuéntanos…" rows={4} />
+ * <Textarea state="invalid" describedBy={errorId} />
+ * <Textarea auto value={text} onChange={(e) => setText(e.target.value)} />
+ */
+export declare function Textarea({ auto, state, describedBy, className, ref, ...rest }: TextareaProps): import("react").JSX.Element;

package/dist/components/Textarea/index.d.ts

@@ -0,0 +1,2 @@
+export { Textarea } from './Textarea.js';
+export type { TextareaProps, TextareaState } from './Textarea.js';