danielgm-ui 0.1.0

package/dist/fields.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Campos de texto y selección con un contrato común de etiquetas, ayuda y errores.
+ * Este módulo agrupa la infraestructura compartida y sus tres controles nativos.
+ * Ninguno almacena el valor: el navegador o el componente consumidor lo controla.
+ */
+import { type InputHTMLAttributes, type TextareaHTMLAttributes, type SelectHTMLAttributes, type ReactNode } from 'react';
+/** Opciones de presentación compartidas por Input, Textarea y Select. */
+interface FieldProps {
+    /** Etiqueta visible. Debe aportar un nombre comprensible, aunque se admita ReactNode. */
+    label: ReactNode;
+    /** Ayuda opcional que se vincula al control mediante aria-describedby. */
+    description?: ReactNode;
+    /** Contenido de error. Marca el campo como inválido; no ejecuta validación por sí solo. */
+    error?: ReactNode;
+    /** Clase del contenedor; className se aplica al input, textarea o select. */
+    wrapperClassName?: string;
+}
+/** Props nativas de input. El ancho se define con CSS; la prop HTML size se excluye. */
+export interface InputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'size'>, FieldProps {
+    /** Visibilidad controlada de type="password"; no altera el valor del campo. */
+    visible?: boolean;
+    /** Visibilidad inicial no controlada. @defaultValue false */
+    defaultVisible?: boolean;
+    /** Solicita el cambio de visibilidad al pulsar el ojo. */
+    onVisibleChange?: (visible: boolean) => void;
+    /** Idioma del botón de contraseña. @defaultValue 'en' */
+    locale?: 'es' | 'en';
+}
+/** Props nativas de textarea; rows utiliza 4 como altura inicial por defecto. */
+export interface TextareaProps extends TextareaHTMLAttributes<HTMLTextAreaElement>, FieldProps {
+}
+/**
+ * Props nativas de select, incluidas multiple, value, defaultValue y sus opciones hijas.
+ * @deprecated Usa CustomSelectProps para nuevas selecciones únicas. Se conserva por compatibilidad.
+ */
+export interface SelectProps extends SelectHTMLAttributes<HTMLSelectElement>, FieldProps {
+}
+/**
+ * Entrada nativa con etiqueta asociada y ref al HTMLInputElement.
+ * Admite value/onChange (controlado) o defaultValue (no controlado).
+ * Un error propio fuerza aria-invalid; sin error se respeta el valor del consumidor.
+ *
+ * @example
+ * <Input label="Email" type="email" name="email" autoComplete="email" />
+ */
+export declare const Input: import("react").ForwardRefExoticComponent<InputProps & import("react").RefAttributes<HTMLInputElement>>;
+/**
+ * Entrada de varias líneas con ref al HTMLTextAreaElement y altura inicial de 4 filas.
+ * Conserva maxLength, required, name y los eventos nativos. El CSS permite redimensionar
+ * verticalmente sin desbordar el contenedor en pantallas pequeñas.
+ */
+export declare const Textarea: import("react").ForwardRefExoticComponent<TextareaProps & import("react").RefAttributes<HTMLTextAreaElement>>;
+/**
+ * Selector nativo con ref al HTMLSelectElement.
+ * children debe contener option u optgroup; se conserva el selector del sistema en
+ * móvil y su comportamiento de teclado. No se reemplaza por un menú personalizado.
+ * @deprecated Usa CustomSelect en código nuevo. Migra children a options y onChange a
+ * onValueChange. CustomSelect no admite multiple, optgroup ni ref de HTMLSelectElement;
+ * esos casos pueden seguir usando Select mientras no exista una alternativa equivalente.
+ */
+export declare const Select: import("react").ForwardRefExoticComponent<SelectProps & import("react").RefAttributes<HTMLSelectElement>>;
+export {};

package/dist/fields.js

@@ -0,0 +1,70 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Campos de texto y selección con un contrato común de etiquetas, ayuda y errores.
+ * Este módulo agrupa la infraestructura compartida y sus tres controles nativos.
+ * Ninguno almacena el valor: el navegador o el componente consumidor lo controla.
+ */
+import { forwardRef, useId, } from 'react';
+import { cx, hasContent } from './utils.js';
+import { useControllable } from './internal/state.js';
+import { EyeIcon, EyeOffIcon } from './internal/icons.js';
+/**
+ * Construye el ID del control y los enlaces con su ayuda y error.
+ * Conserva las descripciones que ya haya definido el consumidor y añade las propias.
+ * useId se llama siempre, incluso si llega un id, para mantener el orden de hooks.
+ * React puede reproducir estos IDs al hidratar si el árbol de servidor y cliente coincide.
+ */
+function useField(id, description, error, describedBy) {
+    const generatedId = useId();
+    const fieldId = id ?? `dgm-${generatedId}`;
+    return {
+        id: fieldId,
+        'aria-describedby': cx(describedBy, hasContent(description) && `${fieldId}-description`, hasContent(error) && `${fieldId}-error`) || undefined,
+    };
+}
+/**
+ * Estructura visual interna. El control se recibe en children para reutilizar la
+ * asociación de etiquetas sin sustituir la semántica de cada elemento nativo.
+ * El asterisco es decorativo: required se aplica también al control correspondiente.
+ */
+function Field({ id, label, description, error, wrapperClassName, required, children, }) {
+    return (_jsxs("div", { className: cx('dgm-field', wrapperClassName), children: [_jsxs("label", { className: "dgm-label", htmlFor: id, children: [label, required && _jsx("span", { "aria-hidden": "true", children: " *" })] }), children, hasContent(description) && (_jsx("span", { className: "dgm-description", id: `${id}-description`, children: description })), hasContent(error) && (_jsx("span", { className: "dgm-error", id: `${id}-error`, children: error }))] }));
+}
+/**
+ * Entrada nativa con etiqueta asociada y ref al HTMLInputElement.
+ * Admite value/onChange (controlado) o defaultValue (no controlado).
+ * Un error propio fuerza aria-invalid; sin error se respeta el valor del consumidor.
+ *
+ * @example
+ * <Input label="Email" type="email" name="email" autoComplete="email" />
+ */
+export const Input = forwardRef(function Input({ label, description, error, wrapperClassName, className, id, required, type = 'text', disabled, visible, defaultVisible = false, onVisibleChange, locale = 'en', 'aria-describedby': describedBy, 'aria-invalid': invalid, ...props }, ref) {
+    const field = useField(id, description, error, describedBy);
+    const [shown, changeVisibility] = useControllable(visible, defaultVisible, onVisibleChange);
+    const password = type === 'password';
+    // El mismo nodo input conserva valor, ref y validación al cambiar su presentación.
+    const control = (_jsx("input", { ...props, ...field, ref: ref, required: required, disabled: disabled, type: password && shown ? 'text' : type, "aria-invalid": hasContent(error) ? true : invalid, className: cx('dgm-input', password && 'dgm-input--password', className) }));
+    return (_jsx(Field, { label, description, error, wrapperClassName, required, id: field.id, children: _jsxs("div", { className: "dgm-input-control", children: [control, password && (_jsx("button", { type: "button", className: "dgm-password-toggle", disabled: disabled, "aria-label": locale === 'es' ? 'Mostrar contraseña' : 'Show password', "aria-pressed": shown, "aria-controls": field.id, onClick: () => changeVisibility(!shown), children: shown ? _jsx(EyeOffIcon, {}) : _jsx(EyeIcon, {}) }))] }) }));
+});
+/**
+ * Entrada de varias líneas con ref al HTMLTextAreaElement y altura inicial de 4 filas.
+ * Conserva maxLength, required, name y los eventos nativos. El CSS permite redimensionar
+ * verticalmente sin desbordar el contenedor en pantallas pequeñas.
+ */
+export const Textarea = forwardRef(function Textarea({ label, description, error, wrapperClassName, className, id, required, rows = 4, 'aria-describedby': describedBy, 'aria-invalid': invalid, ...props }, ref) {
+    const field = useField(id, description, error, describedBy);
+    return (_jsx(Field, { label, description, error, wrapperClassName, required, id: field.id, children: _jsx("textarea", { ...props, ...field, ref: ref, required: required, rows: rows, "aria-invalid": hasContent(error) ? true : invalid, className: cx('dgm-input', 'dgm-textarea', className) }) }));
+});
+/**
+ * Selector nativo con ref al HTMLSelectElement.
+ * children debe contener option u optgroup; se conserva el selector del sistema en
+ * móvil y su comportamiento de teclado. No se reemplaza por un menú personalizado.
+ * @deprecated Usa CustomSelect en código nuevo. Migra children a options y onChange a
+ * onValueChange. CustomSelect no admite multiple, optgroup ni ref de HTMLSelectElement;
+ * esos casos pueden seguir usando Select mientras no exista una alternativa equivalente.
+ */
+export const Select = forwardRef(function Select({ label, description, error, wrapperClassName, className, id, required, children, multiple, size, 'aria-describedby': describedBy, 'aria-invalid': invalid, ...props }, ref) {
+    const field = useField(id, description, error, describedBy);
+    return (_jsx(Field, { label, description, error, wrapperClassName, required, id: field.id, children: _jsx("div", { className: cx('dgm-select-control', !multiple && (size === undefined || size <= 1) && 'dgm-select-control--dropdown'), children: _jsx("select", { ...props, ...field, ref: ref, multiple: multiple, size: size, required: required, "aria-invalid": hasContent(error) ? true : invalid, className: cx('dgm-input', 'dgm-select', className), children: children }) }) }));
+});

package/dist/file-upload.d.ts

@@ -0,0 +1,33 @@
+/** Selección local de archivos. No sube datos: entrega File[] para que el consumidor decida el transporte. */
+import { type ReactElement, type ReactNode } from 'react';
+export interface FileRejection {
+    file: File;
+    reason: 'type' | 'size' | 'count' | 'duplicate';
+}
+export interface FileUploadProps {
+    label: ReactNode;
+    /** Archivos controlados; no se pueden precargar en el input nativo por razones del navegador. */
+    value?: readonly File[];
+    onValueChange?: (files: File[]) => void;
+    /** Acepta tipos MIME, comodines image/* o extensiones, separados por comas. */
+    accept?: string;
+    /** @defaultValue false */
+    multiple?: boolean;
+    /** Límite total al acumular selecciones. @defaultValue 5 */
+    maxFiles?: number;
+    /** Bytes máximos por archivo. @defaultValue 10485760 */
+    maxSize?: number;
+    /** Notifica los archivos rechazados junto a su causa. */
+    onReject?: (rejections: FileRejection[]) => void;
+    description?: ReactNode;
+    error?: ReactNode;
+    disabled?: boolean;
+    /** Exige al menos un archivo antes del envío del formulario. */
+    required?: boolean;
+    /** Miniaturas locales de imágenes. Las URLs se revocan al retirar o desmontar. @defaultValue true */
+    preview?: boolean;
+    locale?: 'es' | 'en';
+    className?: string;
+}
+/** El mismo filtrado se aplica al diálogo nativo y al arrastre; nunca se envían archivos en esta capa. */
+export declare function FileUpload({ label, value, onValueChange, accept, multiple, maxFiles, maxSize, onReject, description, error, disabled, required, preview, locale, className, }: FileUploadProps): ReactElement;

package/dist/file-upload.js

@@ -0,0 +1,111 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/** Selección local de archivos. No sube datos: entrega File[] para que el consumidor decida el transporte. */
+import { useEffect, useId, useRef, useState } from 'react';
+import { Button } from './button.js';
+import { useControllable } from './internal/state.js';
+import { CloseIcon } from './internal/icons.js';
+import { cx, hasContent } from './utils.js';
+/** accept usa la sintaxis del input nativo y se comprueba también al arrastrar. */
+function matchesType(file, accept) {
+    if (!accept)
+        return true;
+    return accept.split(',').some((raw) => {
+        const type = raw.trim().toLowerCase();
+        return type.startsWith('.')
+            ? file.name.toLowerCase().endsWith(type)
+            : type.endsWith('/*')
+                ? file.type.toLowerCase().startsWith(type.slice(0, -1))
+                : file.type.toLowerCase() === type;
+    });
+}
+/** Evita acumular una misma selección sin leer el contenido completo del archivo. */
+function sameFile(a, b) {
+    return (a.name === b.name && a.size === b.size && a.lastModified === b.lastModified && a.type === b.type);
+}
+/** Una URL temporal por miniatura; el cleanup evita conservar archivos retirados en memoria. */
+function Preview({ file }) {
+    const [url, setUrl] = useState();
+    useEffect(() => {
+        if (!file.type.startsWith('image/') || !URL.createObjectURL)
+            return;
+        const next = URL.createObjectURL(file);
+        setUrl(next);
+        return () => URL.revokeObjectURL(next);
+    }, [file]);
+    return url ? _jsx("img", { className: "dgm-file-preview", src: url, alt: "" }) : null;
+}
+/** El mismo filtrado se aplica al diálogo nativo y al arrastre; nunca se envían archivos en esta capa. */
+export function FileUpload({ label, value, onValueChange, accept, multiple = false, maxFiles = 5, maxSize = 10485760, onReject, description, error, disabled, required, preview = true, locale = 'en', className, }) {
+    const [files, change] = useControllable(value, [], onValueChange ? (next) => onValueChange([...next]) : undefined);
+    const [rejections, setRejections] = useState([]);
+    const [dragging, setDragging] = useState(false);
+    const [missing, setMissing] = useState(false);
+    const input = useRef(null);
+    const button = useRef(null);
+    const id = useId();
+    const es = locale === 'es';
+    const maxCount = multiple
+        ? Number.isFinite(maxFiles)
+            ? Math.max(1, Math.floor(maxFiles))
+            : 5
+        : 1;
+    const sizeLimit = Number.isFinite(maxSize) && maxSize >= 0 ? maxSize : 10485760;
+    const reasons = {
+        type: es ? 'Tipo no admitido' : 'Unsupported type',
+        size: es ? 'Archivo demasiado grande' : 'File too large',
+        count: es ? 'Límite de archivos alcanzado' : 'File limit reached',
+        duplicate: es ? 'Archivo ya añadido' : 'File already added',
+    };
+    const message = error || (missing ? (es ? 'Añade al menos un archivo.' : 'Add at least one file.') : undefined);
+    function add(incoming) {
+        if (disabled)
+            return;
+        const accepted = multiple ? [...files] : [];
+        const rejected = [];
+        for (const file of incoming) {
+            const reason = !matchesType(file, accept)
+                ? 'type'
+                : file.size > sizeLimit
+                    ? 'size'
+                    : accepted.some((existing) => sameFile(existing, file))
+                        ? 'duplicate'
+                        : accepted.length >= maxCount
+                            ? 'count'
+                            : undefined;
+            if (reason)
+                rejected.push({ file, reason });
+            else
+                accepted.push(file);
+        }
+        if (accepted.length) {
+            change(accepted);
+            setMissing(false);
+        }
+        setRejections(rejected);
+        if (rejected.length)
+            onReject?.(rejected);
+    }
+    return (_jsxs("div", { className: cx('dgm-file-upload', className), children: [_jsxs("span", { className: "dgm-label", id: `${id}-label`, children: [label, required && _jsx("span", { "aria-hidden": "true", children: " *" })] }), _jsx("input", { ref: input, type: "file", className: "dgm-visually-hidden", tabIndex: -1, "aria-hidden": "true", accept: accept, multiple: multiple, disabled: disabled, onChange: (event) => {
+                    add(Array.from(event.target.files ?? []));
+                    event.target.value = '';
+                } }), _jsx("input", { className: "dgm-form-value", tabIndex: -1, "aria-hidden": "true", required: required, disabled: disabled, value: files.length ? 'selected' : '', onChange: () => { }, onInvalid: (event) => {
+                    event.preventDefault();
+                    setMissing(true);
+                    button.current?.focus({ preventScroll: true });
+                } }), _jsxs("div", { className: "dgm-file-dropzone", "data-dragging": dragging || undefined, "data-disabled": disabled || undefined, onDragOver: (event) => {
+                    event.preventDefault();
+                    if (!disabled)
+                        setDragging(true);
+                }, onDragLeave: (event) => {
+                    if (!event.currentTarget.contains(event.relatedTarget))
+                        setDragging(false);
+                }, onDrop: (event) => {
+                    event.preventDefault();
+                    setDragging(false);
+                    add(Array.from(event.dataTransfer.files));
+                }, children: [_jsx("p", { children: es ? 'Arrastra tus archivos aquí' : 'Drop your files here' }), _jsx(Button, { ref: button, variant: "outline", disabled: disabled, "aria-labelledby": `${id}-choose ${id}-label`, "aria-describedby": cx(hasContent(description) && `${id}-description`, hasContent(message) && `${id}-error`) || undefined, "aria-invalid": hasContent(message) || undefined, onClick: () => input.current?.click(), children: _jsx("span", { id: `${id}-choose`, children: es ? 'Seleccionar archivos' : 'Choose files' }) })] }), hasContent(description) && (_jsx("p", { className: "dgm-description", id: `${id}-description`, children: description })), hasContent(message) && (_jsx("p", { className: "dgm-error", id: `${id}-error`, children: message })), _jsx("ul", { className: "dgm-file-list", "aria-labelledby": `${id}-label`, children: files.map((file, index) => (_jsxs("li", { children: [preview && _jsx(Preview, { file: file }), _jsxs("span", { className: "dgm-file-name", children: [file.name, _jsxs("small", { children: [Math.ceil(file.size / 1024), " KB"] })] }), _jsx(Button, { iconOnly: true, variant: "ghost", disabled: disabled, "aria-label": `${es ? 'Quitar' : 'Remove'} ${file.name}`, onClick: () => {
+                                change(files.filter((_, position) => position !== index));
+                                button.current?.focus({ preventScroll: true });
+                            }, children: _jsx(CloseIcon, {}) })] }, `${file.name}-${file.size}-${file.lastModified}`))) }), _jsxs("div", { role: "status", className: "dgm-description", children: [files.length, " ", es ? 'archivos seleccionados' : 'files selected', rejections.map((item, index) => (_jsxs("p", { children: [item.file.name, ": ", reasons[item.reason]] }, index)))] })] }));
+}

package/dist/index.d.ts

@@ -0,0 +1,48 @@
+/**
+ * API pública de danielgm-ui: componentes y tipos disponibles desde el paquete npm.
+ * Mantener este barrel sin `use client` permite usar las piezas estáticas en servidor.
+ * Los controles interactivos declaran su frontera en sus propios módulos.
+ * Las extensiones .js son intencionadas: TypeScript emitirá módulos ESM para NodeNext.
+ * El CSS se importa por separado desde `danielgm-ui/styles.css`.
+ */
+export { Button, type ButtonProps } from './button.js';
+export { Typography, type TypographyProps, type TypographyVariant, type TypographyElement, type TypographyTone, } from './typography.js';
+export { Slider, RangeSlider, type SliderProps, type RangeSliderProps, type SliderBaseProps, } from './slider.js';
+export { MultiSelect, type MultiSelectProps } from './multi-select.js';
+export { NumberInput, type NumberInputProps } from './number-input.js';
+export { ToggleGroup, type ToggleGroupProps, type ToggleOption } from './toggle-group.js';
+export { EmptyState, type EmptyStateProps } from './empty-state.js';
+export { NavigationMenu, type NavigationMenuProps, type NavigationMenuItem, type NavigationLink, } from './navigation-menu.js';
+export { AspectRatio, type AspectRatioProps } from './aspect-ratio.js';
+export { ResizablePanels, type ResizablePanelsProps } from './resizable-panels.js';
+export { TreeView, type TreeViewProps, type TreeNode } from './tree-view.js';
+export { Carousel, type CarouselProps, type CarouselItem } from './carousel.js';
+export { Container, type ContainerProps, type ContainerElement, type ContainerSize, } from './container.js';
+export { Popover, type PopoverProps } from './popover.js';
+export { Drawer, Sheet, type DrawerProps, type SheetProps } from './drawer.js';
+export { Combobox, Autocomplete, type ComboboxProps, type ComboboxOption, type AutocompleteProps, } from './combobox.js';
+export { Pagination, type PaginationProps } from './pagination.js';
+export { Breadcrumbs, type BreadcrumbsProps, type BreadcrumbItem } from './breadcrumbs.js';
+export { Avatar, type AvatarProps, type AvatarStatus } from './avatar.js';
+export { Progress, type ProgressProps } from './progress.js';
+export { CheckboxGroup, SwitchGroup, type CheckboxGroupProps, type SwitchGroupProps, type ChoiceGroupOption, } from './choice-group.js';
+export { DatePicker, DateRangePicker, type DatePickerProps, type DateRangePickerProps, type DateRangeValue, type DatePickerBaseProps, } from './date-picker.js';
+export { DataTable, type DataTableProps, type DataColumn, type DataTableSort, } from './data-table.js';
+export { FileUpload, type FileUploadProps, type FileRejection } from './file-upload.js';
+export { CommandPalette, type CommandPaletteProps, type CommandAction } from './command-palette.js';
+export { Stepper, type StepperProps, type StepItem } from './stepper.js';
+export { DropdownMenu, type DropdownMenuProps, type DropdownMenuItem } from './dropdown-menu.js';
+export { ContextMenu, type ContextMenuProps, type ContextMenuItem } from './context-menu.js';
+export { RadioGroup, type RadioGroupProps, type RadioOption } from './radio-group.js';
+export { Skeleton, type SkeletonProps } from './skeleton.js';
+export { Loader, type LoaderProps } from './loader.js';
+export { ToastProvider, useToast, type ToastProviderProps, type ToastOptions, type ToastContextValue, } from './toast.js';
+export { CustomSelect, type CustomSelectProps, type SelectOption } from './custom-select.js';
+export { Modal, type ModalProps } from './modal.js';
+export { Tooltip, type TooltipProps } from './tooltip.js';
+export { Transition, type TransitionProps } from './transition.js';
+export { Tabs, type TabsProps, type TabItem } from './tabs.js';
+export { Accordion, type AccordionProps, type AccordionItem, type AccordionSingleProps, type AccordionMultipleProps, } from './accordion.js';
+export { Input, Textarea, Select, type InputProps, type TextareaProps, type SelectProps, } from './fields.js';
+export { Checkbox, Switch, type CheckboxProps, type SwitchProps } from './toggles.js';
+export { Badge, Card, CardHeader, CardContent, CardFooter, Alert, Separator, type BadgeProps, type CardProps, type AlertProps, type SeparatorProps, type Tone, } from './display.js';

package/dist/index.js

@@ -0,0 +1,48 @@
+/**
+ * API pública de danielgm-ui: componentes y tipos disponibles desde el paquete npm.
+ * Mantener este barrel sin `use client` permite usar las piezas estáticas en servidor.
+ * Los controles interactivos declaran su frontera en sus propios módulos.
+ * Las extensiones .js son intencionadas: TypeScript emitirá módulos ESM para NodeNext.
+ * El CSS se importa por separado desde `danielgm-ui/styles.css`.
+ */
+export { Button } from './button.js';
+export { Typography, } from './typography.js';
+export { Slider, RangeSlider, } from './slider.js';
+export { MultiSelect } from './multi-select.js';
+export { NumberInput } from './number-input.js';
+export { ToggleGroup } from './toggle-group.js';
+export { EmptyState } from './empty-state.js';
+export { NavigationMenu, } from './navigation-menu.js';
+export { AspectRatio } from './aspect-ratio.js';
+export { ResizablePanels } from './resizable-panels.js';
+export { TreeView } from './tree-view.js';
+export { Carousel } from './carousel.js';
+export { Container, } from './container.js';
+export { Popover } from './popover.js';
+export { Drawer, Sheet } from './drawer.js';
+export { Combobox, Autocomplete, } from './combobox.js';
+export { Pagination } from './pagination.js';
+export { Breadcrumbs } from './breadcrumbs.js';
+export { Avatar } from './avatar.js';
+export { Progress } from './progress.js';
+export { CheckboxGroup, SwitchGroup, } from './choice-group.js';
+export { DatePicker, DateRangePicker, } from './date-picker.js';
+export { DataTable, } from './data-table.js';
+export { FileUpload } from './file-upload.js';
+export { CommandPalette } from './command-palette.js';
+export { Stepper } from './stepper.js';
+export { DropdownMenu } from './dropdown-menu.js';
+export { ContextMenu } from './context-menu.js';
+export { RadioGroup } from './radio-group.js';
+export { Skeleton } from './skeleton.js';
+export { Loader } from './loader.js';
+export { ToastProvider, useToast, } from './toast.js';
+export { CustomSelect } from './custom-select.js';
+export { Modal } from './modal.js';
+export { Tooltip } from './tooltip.js';
+export { Transition } from './transition.js';
+export { Tabs } from './tabs.js';
+export { Accordion, } from './accordion.js';
+export { Input, Textarea, Select, } from './fields.js';
+export { Checkbox, Switch } from './toggles.js';
+export { Badge, Card, CardHeader, CardContent, CardFooter, Alert, Separator, } from './display.js';

package/dist/internal/field-open.d.ts

@@ -0,0 +1,2 @@
+/** Cierra un campo al desactivarlo y evita que reaparezca al volver a habilitarlo. */
+export declare function useFieldOpen(disabled?: boolean): readonly [boolean, (next: boolean) => void];

package/dist/internal/field-open.js

@@ -0,0 +1,15 @@
+'use client';
+import { useEffect, useState } from 'react';
+/** Cierra un campo al desactivarlo y evita que reaparezca al volver a habilitarlo. */
+export function useFieldOpen(disabled = false) {
+    const [open, setOpen] = useState(false);
+    useEffect(() => {
+        if (disabled)
+            setOpen(false);
+    }, [disabled]);
+    function changeOpen(next) {
+        setOpen(!disabled && next);
+    }
+    // El panel deja de ser interactivo en el mismo render que recibe disabled.
+    return [!disabled && open, changeOpen];
+}

package/dist/internal/focus.d.ts

@@ -0,0 +1,4 @@
+/** Permite a Tooltip ignorar únicamente el foco restaurado sobre su propio disparador. */
+export declare function isRestoringFocus(element: HTMLElement): boolean;
+/** Devuelve el foco sin desplazar la página ni reabrir ayudas contextuales. */
+export declare function restoreFocus(element: HTMLElement | null | undefined): void;

package/dist/internal/focus.js

@@ -0,0 +1,27 @@
+'use client';
+/**
+ * Distingue el retorno del foco al cerrar una capa de una nueva interacción.
+ * La marca solo existe durante focus(), que despacha el evento de forma síncrona.
+ * No requiere timers, listeners globales ni estado en el componente consumidor.
+ */
+const restoringFocus = new WeakSet();
+/** Permite a Tooltip ignorar únicamente el foco restaurado sobre su propio disparador. */
+export function isRestoringFocus(element) {
+    return restoringFocus.has(element);
+}
+/** Devuelve el foco sin desplazar la página ni reabrir ayudas contextuales. */
+export function restoreFocus(element) {
+    if (!element?.isConnected)
+        return;
+    const alreadyRestoring = restoringFocus.has(element);
+    restoringFocus.add(element);
+    try {
+        element.focus({ preventScroll: true });
+    }
+    finally {
+        // También se limpia si el destino no admite foco o focus() produce una excepción.
+        // Una llamada anidada sobre el mismo elemento conserva la marca de la exterior.
+        if (!alreadyRestoring)
+            restoringFocus.delete(element);
+    }
+}

package/dist/internal/icons.d.ts

@@ -0,0 +1,29 @@
+/** Iconos decorativos de Tabler. El nombre accesible pertenece al control exterior.
+ * Los imports explícitos permiten descartar los iconos no utilizados al empaquetar.
+ */
+import type { ReactElement } from 'react';
+import { type IconProps } from '@tabler/icons-react';
+export declare const CloseIcon: (props: IconProps) => ReactElement;
+export declare const ChevronIcon: (props: IconProps) => ReactElement;
+export declare const ChevronUpIcon: (props: IconProps) => ReactElement;
+export declare const ChevronLeftIcon: (props: IconProps) => ReactElement;
+export declare const ChevronRightIcon: (props: IconProps) => ReactElement;
+export declare const CheckIcon: (props: IconProps) => ReactElement;
+export declare const CalendarIcon: (props: IconProps) => ReactElement;
+export declare const PlusIcon: (props: IconProps) => ReactElement;
+export declare const MinusIcon: (props: IconProps) => ReactElement;
+export declare const ExpandIcon: (props: IconProps) => ReactElement;
+export declare const CollapseIcon: (props: IconProps) => ReactElement;
+export declare const FolderIcon: (props: IconProps) => ReactElement;
+export declare const FolderOpenIcon: (props: IconProps) => ReactElement;
+export declare const FileIcon: (props: IconProps) => ReactElement;
+export declare const SearchIcon: (props: IconProps) => ReactElement;
+export declare const EyeIcon: (props: IconProps) => ReactElement;
+export declare const EyeOffIcon: (props: IconProps) => ReactElement;
+export declare const SuccessIcon: (props: IconProps) => ReactElement;
+export declare const InfoIcon: (props: IconProps) => ReactElement;
+export declare const WarningIcon: (props: IconProps) => ReactElement;
+export declare const DangerIcon: (props: IconProps) => ReactElement;
+export declare const ArrowUpIcon: (props: IconProps) => ReactElement;
+export declare const ArrowDownIcon: (props: IconProps) => ReactElement;
+export declare const SortIcon: (props: IconProps) => ReactElement;

package/dist/internal/icons.js

@@ -0,0 +1,32 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { IconX, IconChevronDown, IconChevronUp, IconChevronLeft, IconChevronRight, IconCheck, IconCalendar, IconPlus, IconMinus, IconSquarePlus, IconSquareMinus, IconFolder, IconFolderOpen, IconFile, IconSearch, IconEye, IconEyeOff, IconCircleCheck, IconInfoCircle, IconAlertTriangle, IconAlertCircle, IconArrowUp, IconArrowDown, IconArrowsSort, } from '@tabler/icons-react';
+/** Tamaño común y color heredado; no introduce foco ni nombres accesibles duplicados. */
+function decorative(Icon) {
+    return function DecorativeIcon(props) {
+        return _jsx(Icon, { size: 18, stroke: 2, "aria-hidden": "true", focusable: "false", ...props });
+    };
+}
+export const CloseIcon = decorative(IconX);
+export const ChevronIcon = decorative(IconChevronDown);
+export const ChevronUpIcon = decorative(IconChevronUp);
+export const ChevronLeftIcon = decorative(IconChevronLeft);
+export const ChevronRightIcon = decorative(IconChevronRight);
+export const CheckIcon = decorative(IconCheck);
+export const CalendarIcon = decorative(IconCalendar);
+export const PlusIcon = decorative(IconPlus);
+export const MinusIcon = decorative(IconMinus);
+export const ExpandIcon = decorative(IconSquarePlus);
+export const CollapseIcon = decorative(IconSquareMinus);
+export const FolderIcon = decorative(IconFolder);
+export const FolderOpenIcon = decorative(IconFolderOpen);
+export const FileIcon = decorative(IconFile);
+export const SearchIcon = decorative(IconSearch);
+export const EyeIcon = decorative(IconEye);
+export const EyeOffIcon = decorative(IconEyeOff);
+export const SuccessIcon = decorative(IconCircleCheck);
+export const InfoIcon = decorative(IconInfoCircle);
+export const WarningIcon = decorative(IconAlertTriangle);
+export const DangerIcon = decorative(IconAlertCircle);
+export const ArrowUpIcon = decorative(IconArrowUp);
+export const ArrowDownIcon = decorative(IconArrowDown);
+export const SortIcon = decorative(IconArrowsSort);

package/dist/internal/navigation-origin.d.ts

@@ -0,0 +1,2 @@
+/** NavigationMenu no usa Popper: situamos el origen en el borde más próximo a su disparador. */
+export declare function observeNavigationOrigin(panel: HTMLElement, trigger: HTMLElement): () => void;

package/dist/internal/navigation-origin.js

@@ -0,0 +1,23 @@
+/** NavigationMenu no usa Popper: situamos el origen en el borde más próximo a su disparador. */
+export function observeNavigationOrigin(panel, trigger) {
+    const container = panel.offsetParent instanceof HTMLElement
+        ? panel.offsetParent
+        : panel.closest('.dgm-navigation');
+    if (!container)
+        return () => { };
+    const update = () => {
+        const anchor = trigger.getBoundingClientRect();
+        const parent = container.getBoundingClientRect();
+        // offsetLeft no incluye el scale de la animación en curso; medir el panel con
+        // getBoundingClientRect desplazaría el propio origen a medida que crece.
+        const left = parent.left + container.clientLeft - container.scrollLeft + panel.offsetLeft;
+        const x = Math.min(panel.offsetWidth, Math.max(0, anchor.left + anchor.width / 2 - left));
+        panel.style.setProperty('--dgm-navigation-origin-x', `${x}px`);
+    };
+    const resize = new ResizeObserver(update);
+    resize.observe(container);
+    resize.observe(trigger);
+    resize.observe(panel);
+    update();
+    return () => resize.disconnect();
+}

package/dist/internal/overlay-layer.d.ts

@@ -0,0 +1,12 @@
+/** La profundidad React atraviesa los portales sin cambiar su destino ni su geometría. */
+import { type CSSProperties, type ReactNode } from 'react';
+/** Cada panel pertenece a la siguiente capa del panel que contiene su disparador. */
+export declare function useOverlayLayer(): {
+    depth: number;
+    style: CSSProperties;
+};
+/** Sin contenedor DOM: los portales siguen escapando del overflow y transform del padre. */
+export declare function OverlayLayerProvider({ depth, children }: {
+    depth: number;
+    children: ReactNode;
+}): import("react").JSX.Element;

package/dist/internal/overlay-layer.js

@@ -0,0 +1,14 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+/** La profundidad React atraviesa los portales sin cambiar su destino ni su geometría. */
+import { createContext, useContext } from 'react';
+const OverlayDepth = createContext(-1);
+/** Cada panel pertenece a la siguiente capa del panel que contiene su disparador. */
+export function useOverlayLayer() {
+    const depth = useContext(OverlayDepth) + 1;
+    return { depth, style: { '--dgm-layer-depth': depth } };
+}
+/** Sin contenedor DOM: los portales siguen escapando del overflow y transform del padre. */
+export function OverlayLayerProvider({ depth, children }) {
+    return _jsx(OverlayDepth.Provider, { value: depth, children: children });
+}

package/dist/internal/pagination.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Construye una ventana para un presupuesto de celdas (números y elipsis).
+ * Conserva la página actual y, cuando caben, los extremos. Cerca del principio
+ * o del final desplaza la ventana para aprovechar también el espacio sobrante.
+ */
+export declare function fitPaginationPages(current: number, count: number, slots: number): number[];

package/dist/internal/pagination.js

@@ -0,0 +1,36 @@
+/**
+ * Construye una ventana para un presupuesto de celdas (números y elipsis).
+ * Conserva la página actual y, cuando caben, los extremos. Cerca del principio
+ * o del final desplaza la ventana para aprovechar también el espacio sobrante.
+ */
+export function fitPaginationPages(current, count, slots) {
+    const budget = Math.max(1, Math.floor(slots));
+    if (count === 0)
+        return [];
+    if (count <= budget)
+        return Array.from({ length: count }, (_, index) => index + 1);
+    for (let length = budget; length >= 1; length--) {
+        const start = Math.max(1, Math.min(count - length + 1, current - Math.floor((length - 1) / 2)));
+        const pages = new Set(Array.from({ length }, (_, index) => start + index));
+        // En móviles muy estrechos priorizamos los vecinos y la página actual.
+        if (budget >= 5) {
+            pages.add(1);
+            pages.add(count);
+        }
+        const ordered = [...pages].sort((left, right) => left - right);
+        const expanded = [];
+        let gaps = 0;
+        ordered.forEach((page, index) => {
+            const distance = index > 0 ? page - ordered[index - 1] : 0;
+            // Un único número omitido ocupa lo mismo que una elipsis y aporta más información.
+            if (distance === 2)
+                expanded.push(page - 1);
+            else if (distance > 2)
+                gaps++;
+            expanded.push(page);
+        });
+        if (expanded.length + gaps <= budget)
+            return expanded;
+    }
+    return [current];
+}

package/dist/internal/scroll-hints.d.ts

@@ -0,0 +1,8 @@
+import { type ReactNode } from 'react';
+/** Decoración interna: el primer hijo conserva el scroll, su semántica y su foco.
+ * Observamos tamaño y contenido porque buscar, traducir o cargar opciones puede
+ * cambiar el desbordamiento sin que el usuario desplace la lista. */
+export declare function ScrollHints({ children, className }: {
+    children: ReactNode;
+    className?: string;
+}): import("react").JSX.Element;