@giro-ds/react 2.0.0 → 3.0.0

package/dist/components/Button/Button.d.ts

@@ -1,4 +1,4 @@
 import React from 'react';
 import type { ButtonProps } from './Button.types';
-declare const Button: React.ForwardRefExoticComponent<Omit<ButtonProps, "ref"> & React.RefAttributes<HTMLElement>>;
+declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLElement>>;
 export default Button;

package/dist/components/Button/Button.types.d.ts

@@ -1,43 +1,23 @@
 import React from 'react';
-export interface ButtonProps {
-    /** Define o elemento a ser renderizado (ex: 'button', 'a', ou componente de roteamento) */
+export interface ButtonProps extends React.HTMLAttributes<HTMLElement> {
     as?: React.ElementType;
-    /** Define o texto principal do botão */
     children?: React.ReactNode;
-    /** Define tipo do botão entre as opções */
     variant?: 'filled' | 'outlined' | 'text';
     iconOnly?: boolean;
-    /** Define a posição do ícone entre as opções */
-    iconPosition?: 'none' | 'left' | 'right';
-    /** URL para links externos (ex: https://example.com) */
+    iconPosition?: 'left' | 'right' | 'both';
     href?: string;
-    /** Rota interna para navegação SPA (ex: /dashboard, /profile) */
     to?: string;
-    /** Indica se o link é externo */
     external?: boolean;
-    /** Target para links (_blank, _self, etc.) */
     target?: string;
-    /** Rel attribute para links */
     rel?: string;
-    /** Props para React Router (replace, state, etc.) */
-    routerProps?: Record<string, any>;
     type?: 'button' | 'submit' | 'reset';
-    /** Desabilita interações do botão */
     disabled?: boolean;
-    /** Função a ser chamada quando o botão é clicado */
     onClick?: (event: React.MouseEvent<HTMLElement>) => void;
-    /** Define o tamanho do botão entre as opções */
     size?: 'lg' | 'sm';
-    /** Classe CSS opcional */
     className?: string;
-    /** ID opcional */
     id?: string;
-    /** Ícone opcional */
     icon?: React.ReactNode;
-    /** Define se o botão deve ocupar toda a largura */
     fullWidth?: boolean;
-    /** Texto para acessibilidade */
     ariaLabel?: string;
-    /** Outros props específicos do elemento/componente */
-    [key: string]: any;
+    loading?: boolean;
 }

package/dist/components/Button/__tests__/Button.test.d.ts

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

package/dist/components/Menu/Menu.d.ts

@@ -1,4 +1,4 @@
+import { MenuProps } from './Menu.types';
 import React from 'react';
-import type { MenuProps } from './Menu.types';
 declare const Menu: React.FC<MenuProps>;
 export default Menu;

package/dist/components/Menu/Menu.types.d.ts

@@ -1,41 +1,32 @@
-import { ReactNode, ReactElement } from 'react';
-export interface MenuItem {
-    /** ID único do item */
-    id: string;
-    /** Texto principal do item */
-    text: string;
-    /** Texto secundário opcional */
+import { ReactElement } from 'react';
+export interface MenuItemProps {
+    id?: string;
+    text?: string;
     subText?: string;
-    /** Ícone do item */
-    icon?: ReactNode;
-    /** Estado desabilitado */
     disabled?: boolean;
-    /** Valor customizado do item */
-    value?: unknown;
+    icon?: React.ReactNode;
+    children?: MenuItemProps[];
+    value?: string;
+}
+export interface DefaultMenuItemProps {
+    item: MenuItemProps;
+    isSelected: boolean;
+    onSelect: (item: MenuItemProps) => void;
 }
 export interface MenuProps {
-    /** Elemento React que será usado como âncora do menu (obrigatório) */
-    children: ReactElement<any, any>;
-    /** Array de itens do menu */
-    menuItems?: MenuItem[];
-    /** Callback executado quando um item do menu é clicado */
-    onMenuItemClick?: (item: MenuItem) => void;
-    /** Callback executado quando o menu é aberto/fechado */
-    onToggle?: (isOpen: boolean) => void;
-    /** Tipo do dropdown */
+    items: MenuItemProps[];
+    children?: ReactElement;
     type?: 'text' | 'icon';
-    /** Habilita campo de busca */
-    applySearch?: boolean;
-    /** Placeholder do campo de busca */
-    placeholder?: string;
-    /** Controla exibição do subtexto */
-    showSubText?: boolean;
-    /** Classes CSS adicionais */
     className?: string;
-    /** ID único do componente */
-    id?: string;
-    maxWidth?: string | number;
-    minWidth?: string | number;
-    /** Posição do menu em relação ao elemento âncora */
-    position?: 'left' | 'right';
+    onItemSelect?: (items: MenuItemProps) => void;
+    selectedItems?: MenuItemProps[];
+    search?: boolean;
+    align?: 'start' | 'end' | 'center';
+    maxHeight?: number | string;
+    enableInfiniteScroll?: boolean;
+    onScrollEnd?: () => void;
+    isLoadingMore?: boolean;
+    enableApiSearch?: boolean;
+    onApiSearch?: (searchTerm: string) => void;
+    onOpenChange?: (open: boolean) => void;
 }

package/dist/components/Menu/__tests__/Menu.test.d.ts

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

package/dist/components/{MenuRadix → Menu}/components/MenuItem.d.ts

@@ -1,8 +1,3 @@
-import { MenuItemProps } from '../MenuRadix.types';
-interface DefaultMenuItemProps {
-    item: MenuItemProps;
-    isSelected: boolean;
-    onSelect: (item: MenuItemProps) => void;
-}
+import { DefaultMenuItemProps } from '../Menu.types';
 export declare const MenuItem: import("react").MemoExoticComponent<({ item, isSelected, onSelect }: DefaultMenuItemProps) => import("react/jsx-runtime").JSX.Element>;
 export default MenuItem;

package/dist/components/{MenuRadix → Menu}/hooks/useMenuLogic.d.ts

@@ -1,4 +1,4 @@
-import { MenuItemProps } from '../MenuRadix.types';
+import { MenuItemProps } from '../Menu.types';
 export interface UseMenuLogicProps {
     selectedItems?: MenuItemProps[];
     onItemSelect?: (items: MenuItemProps) => void;

package/dist/components/{MenuRadix → Menu}/hooks/useSearchLogic.d.ts

@@ -1,4 +1,4 @@
-import { MenuItemProps } from '../MenuRadix.types';
+import { MenuItemProps } from '../Menu.types';
 interface UseSearchLogicProps {
     items: MenuItemProps[];
     searchValue: string;

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

@@ -1,2 +1,2 @@
 export { default } from './Menu';
-export type { MenuProps, MenuItem } from './Menu.types';
+export type { MenuProps, MenuItemProps } from './Menu.types';

package/dist/components/Search/Search.types.d.ts

@@ -12,4 +12,5 @@ export interface SearchProps {
     onMouseDown?: (e: React.MouseEvent<HTMLDivElement>) => void;
     className?: string;
     id?: string;
+    'data-testid'?: string;
 }

package/dist/components/Select/Select.d.ts

@@ -1,4 +1,4 @@
 import React from 'react';
-import type { SelectProps } from './Select.types';
-declare const Select: React.NamedExoticComponent<SelectProps>;
+import { SelectProps } from './Select.types';
+declare const Select: React.FC<SelectProps>;
 export default Select;

package/dist/components/Select/Select.types.d.ts

@@ -1,67 +1,115 @@
-import React from 'react';
-import { DropdownType } from '../Dropdown/Dropdown.types';
-export interface SelectOption {
-    /** ID único da opção (opcional, será gerado automaticamente se não fornecido) */
+import { ReactNode } from 'react';
+export interface SelectItemProps {
     id?: string;
-    /** Texto principal da opção */
-    text: string;
-    /** Texto secundário/descrição da opção */
-    subText?: string;
-    /** Ícone da opção (React node) */
-    icon?: React.ReactNode;
-    /** Define se a opção está desabilitada */
+    text: ReactNode;
+    subTitle?: ReactNode;
+    icon?: ReactNode;
     disabled?: boolean;
+    value: string;
+    selected?: boolean;
+    children?: SelectItemProps[];
 }
+export interface CheckboxItemProps extends SelectItemProps {
+    checked: boolean;
+    onCheckedChange: (checked: boolean) => void;
+}
+export type SelectVariant = 'text' | 'icon' | 'checkbox';
 export interface SelectProps {
-    /** ID único do componente */
-    id?: string;
-    /** Array de opções para seleção - obrigatório */
-    options: SelectOption[];
-    /** Valor(es) selecionado(s) */
+    items: SelectItemProps[];
+    onValueChange?: (value: string | string[]) => void;
+    onOpenChange?: (open: boolean) => void;
+    variant: SelectVariant;
+    required?: boolean;
     value?: string | string[];
-    /** Valor inicial para seleção (usado apenas na primeira renderização) */
-    initialValue?: string | string[];
-    /** Callback para mudanças na seleção */
-    onChange?: (selectedItems: SelectOption[]) => void;
-    /** Placeholder do campo */
+    multiple?: boolean;
     placeholder?: string;
-    /** Tipo do dropdown (single ou multiple) */
-    type?: DropdownType;
-    maxHeight?: string;
-    /** Label do campo */
+    search?: boolean;
     label?: string;
-    /** Texto de ajuda */
     helperText?: string;
-    /** Mensagem de erro */
+    maxWidth?: number;
     errorMessage?: string;
-    /** Campo obrigatório */
-    required?: boolean;
-    /** Campo desabilitado */
     disabled?: boolean;
-    /** Classes CSS adicionais */
     className?: string;
-    /** Texto para acessibilidade */
-    showSubText?: boolean;
-    /** Aria-label do campo */
-    ariaLabel?: string;
-    /** Habilita campo de busca */
-    applySearch?: boolean;
-    /** Placeholder do campo de busca */
-    searchPlaceholder?: string;
-    maxWidth?: string;
-    minWidth?: string;
+    'aria-label'?: string;
+    'data-testid'?: string;
     tooltip?: boolean;
     tooltipText?: string;
-    width?: string;
-    /** Força posição do dropdown: 'top' abre para cima, 'bottom' abre para baixo. Se não especificado, usa detecção automática */
-    position?: 'top' | 'bottom';
-    positionTooltip?: 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left' | 'left' | 'right';
-    infiniteScroll?: {
-        status: 'idle' | 'loading' | 'succeeded' | 'failed';
-        page: number;
-        lastPage: number;
-        onLoadMore: () => void;
-        threshold?: number;
-        rootMargin?: string;
+    side?: "top" | "right" | "bottom" | "left";
+    align?: "start" | "center" | "end";
+    enableInfiniteScroll?: boolean;
+    onScrollEnd?: () => void;
+    isLoadingMore?: boolean;
+    enableApiSearch?: boolean;
+    onApiSearch?: (term: string) => void;
+    isSearching?: boolean;
+}
+export interface SelectState {
+    isOpen: boolean;
+    selectedValues: string[];
+    searchInput: string;
+    searchTerm: string;
+    touched: boolean;
+    hasError: boolean;
+}
+export type SelectAction = {
+    type: 'SET_OPEN';
+    payload: boolean;
+} | {
+    type: 'SET_SELECTED_VALUES';
+    payload: string[];
+} | {
+    type: 'SET_SEARCH_INPUT';
+    payload: string;
+} | {
+    type: 'SET_SEARCH_TERM';
+    payload: string;
+} | {
+    type: 'SET_TOUCHED';
+    payload: boolean;
+} | {
+    type: 'SET_ERROR';
+    payload: boolean;
+} | {
+    type: 'RESET_SEARCH';
+} | {
+    type: 'VALIDATE';
+    payload: {
+        required: boolean;
+    };
+};
+export interface UseSelectLogicProps {
+    value?: string | string[];
+    required?: boolean;
+    search?: boolean;
+    onValueChange?: (value: string | string[]) => void;
+    onOpenChange?: (open: boolean) => void;
+    enableApiSearch?: boolean;
+    onApiSearch?: (term: string) => void;
+    isSearching?: boolean;
+}
+export interface UseSelectLogicReturn {
+    state: SelectState;
+    actions: {
+        setOpen: (open: boolean) => void;
+        setSelectedValues: (values: string[]) => void;
+        setSearchInput: (input: string) => void;
+        setSearchTerm: (term: string) => void;
+        setTouched: (touched: boolean) => void;
+        setError: (error: boolean) => void;
+        resetSearch: () => void;
+        validate: () => void;
+        handleSingleSelect: (value: string) => void;
+        handleMultipleSelect: (value: string, checked: boolean) => void;
+    };
+    computed: {
+        displayText: string;
+        filteredItems: SelectItemProps[];
+    };
+    refs: {
+        searchInputRef: React.RefObject<HTMLInputElement | null>;
+    };
+    utils: {
+        getDisplayText: (selectedValues: string[], placeholder: string, variant: string, items: SelectItemProps[]) => string;
+        getFilteredItems: (items: SelectItemProps[], searchTerm: string) => SelectItemProps[];
     };
 }

package/dist/components/Select/__tests__/SelectRadix.test.d.ts

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

package/dist/components/{SelectRadix → Select}/components/CheckboxSelectItem.d.ts

@@ -1,4 +1,4 @@
 import React from 'react';
-import { CheckboxItemProps } from '../SelectRadix.types';
+import { CheckboxItemProps } from '../Select.types';
 declare const CheckboxSelectItem: React.FC<CheckboxItemProps>;
 export default CheckboxSelectItem;

package/dist/components/Select/components/ExpandableSelectItem.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import type { SelectItemProps, SelectVariant } from '../Select.types';
+interface ExpandableSelectItemProps {
+    item: SelectItemProps;
+    variant: SelectVariant;
+    onSelect: (value: string) => void;
+    selectedValues: string[];
+    level?: number;
+}
+declare const ExpandableSelectItem: React.FC<ExpandableSelectItemProps>;
+export default ExpandableSelectItem;

package/dist/components/{SelectRadix → Select}/components/SelectItem.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
-import { SelectItemProps, SelectVariant } from '../SelectRadix.types';
+import { SelectItemProps, SelectVariant } from '../Select.types';
 interface SelectItemComponentProps extends SelectItemProps {
     variant?: SelectVariant;
 }

package/dist/components/{SelectRadix → Select}/hooks/useSelectLogic.d.ts

@@ -1,3 +1,3 @@
-import { UseSelectLogicProps, UseSelectLogicReturn } from '../SelectRadix.types';
+import { UseSelectLogicProps, UseSelectLogicReturn } from '../Select.types';
 export declare function useSelectLogic({ value, required, search, onValueChange, onOpenChange, enableApiSearch, onApiSearch, isSearching, }: UseSelectLogicProps): UseSelectLogicReturn;
 export default useSelectLogic;

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

@@ -1,2 +1,5 @@
 export { default } from './Select';
-export type { SelectProps, SelectOption } from './Select.types';
+export type { SelectProps, SelectItemProps, CheckboxItemProps, SelectVariant, SelectState, SelectAction, UseSelectLogicProps, UseSelectLogicReturn } from './Select.types';
+export { useSelectLogic } from './hooks/useSelectLogic';
+export { default as CheckboxSelectItem } from './components/CheckboxSelectItem';
+export { default as SelectItem } from './components/SelectItem';

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

@@ -1,6 +1,6 @@
 export interface SwitchProps {
-    defaultChecked: boolean;
-    disabled: boolean;
+    defaultChecked?: boolean;
+    disabled?: boolean;
     onCheckedChange?: (checked: boolean) => void;
     name?: string;
     value?: string;

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

@@ -1,4 +1,3 @@
-import React from 'react';
-import type { TableProps } from './Table.types';
-declare const Table: React.FC<TableProps>;
+import type { TableRowData, TableProps } from './Table.types';
+declare const Table: <T extends TableRowData = TableRowData>({ columns, dataSource, className, loading, rowSelection, locale, onRow, }: TableProps<T>) => import("react/jsx-runtime").JSX.Element | null;
 export default Table;

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

@@ -1,35 +1,71 @@
 import { ReactNode, CSSProperties } from 'react';
+/**
+ * Tipo base para dados da tabela. Use `<Table<SeuTipo>>` para type-safety completo.
+ * @example <Table<User> dataSource={users} />
+ */
+export type TableRowData = Record<string, any>;
+/** Tipos de coluna suportados */
 export type TableColumnType = 'text' | 'datetime' | 'custom';
+/** Opções de alinhamento de coluna */
 export type TableAlign = 'left' | 'center' | 'right';
-export interface TableColumn {
+/**
+ * Configuração de coluna da tabela
+ * @typeParam T - Tipo dos dados da linha
+ */
+export interface TableColumn<T = TableRowData> {
+    /** Chave única identificadora da coluna */
     key: string;
+    /** Conteúdo do cabeçalho da coluna */
     label: ReactNode;
+    /** Tipo de dados da coluna */
     type?: TableColumnType;
+    /** Formato de exibição (ex: 'dd/MM/yyyy' para datetime) */
     format?: string;
-    render?: (row: TableRowData, index: number) => ReactNode;
+    /** Função customizada para renderizar o conteúdo da célula */
+    render?: (row: T, index: number) => ReactNode;
+    /** Alinhamento do conteúdo */
     align?: TableAlign;
+    /** Estilos CSS customizados */
     style?: CSSProperties;
 }
-export type TableRowData = Record<string, any>;
-export interface TableProps {
-    columns: TableColumn[];
-    dataSource: TableRowData[];
+/**
+ * Props do componente Table. Use genérico para autocomplete: `<Table<User>>`
+ * @typeParam T - Tipo dos dados da linha
+ */
+export interface TableProps<T = TableRowData> {
+    /** Configuração das colunas */
+    columns: TableColumn<T>[];
+    /** Array de dados a serem exibidos */
+    dataSource: T[];
+    /** Classe CSS customizada */
     className?: string;
+    /** Estado de carregamento */
     loading?: boolean;
+    /** Configuração de seleção de linhas */
     rowSelection?: {
+        /** Keys das linhas selecionadas (modo controlado) */
         selectedRowKeys?: (string | number)[];
-        onChange?: (keys: (string | number)[], rows: TableRowData[]) => void;
-        getCheckboxProps?: (row: TableRowData, index: number) => {
+        /** Callback quando seleção muda: (keys, rows) => void */
+        onChange?: (keys: (string | number)[], rows: T[]) => void;
+        /** Customiza props dos checkboxes: (row, index) => { disabled? } */
+        getCheckboxProps?: (row: T, index: number) => {
             disabled?: boolean;
         };
+        /** Desabilita o checkbox "selecionar todos" */
+        disableSelectAll?: boolean;
     };
+    /** Configurações de localização */
     locale?: {
+        /** Texto quando não há dados */
         emptyText?: ReactNode;
     };
-    /** Eventos de linha */
-    onRow?: (row: TableRowData, index: number) => {
+    /** Eventos de linha: (row, index) => { onClick?, onDoubleClick?, className? } */
+    onRow?: (row: T, index: number) => {
+        /** Clique simples na linha */
         onClick?: () => void;
+        /** Clique duplo na linha */
         onDoubleClick?: () => void;
+        /** Classe CSS da linha */
         className?: string;
     };
 }

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

@@ -1,6 +1,6 @@
 export { default } from './Table';
 export { default as Table } from './Table';
-export type { TableProps, TableColumn, TableRowData, } from './Table.types';
+export type { TableProps, TableColumn, TableRowData, TableColumnType, TableAlign, } from './Table.types';
 export { default as TableHeader } from './TableHeader';
 export type { TableHeaderProps } from './TableHeader';
 export { default as TablePagination } from './TablePagination';

package/dist/components/index.d.ts

@@ -27,9 +27,7 @@ export { type FilterProps } from './Filter/Filter.types';
 export { default as ListItem } from './ListItem';
 export { type ListItemProps } from './ListItem/ListItem.types';
 export { default as Menu } from './Menu';
-export { type MenuProps, type MenuItem } from './Menu/Menu.types';
-export { default as MenuRadix } from './MenuRadix';
-export { type MenuRadixProps } from './MenuRadix/MenuRadix.types';
+export { type MenuProps } from './Menu/Menu.types';
 export { default as Quantity } from './Quantity';
 export { type QuantityProps } from './Quantity/Quantity.types';
 export { default as Radio } from './Radio';
@@ -37,11 +35,7 @@ export { type RadioGroupProps, type RadioProps } from './Radio/Radio.types';
 export { default as Search } from './Search';
 export { type SearchProps } from './Search/Search.types';
 export { default as Select } from './Select';
-export { type SelectProps, type SelectOption } from './Select/Select.types';
-export { default as SelectField } from './SelectField/SelectField';
-export { type SelectFieldProps } from './SelectField/SelectField.types';
-export { default as SelectRadix } from './SelectRadix';
-export { type SelectRadixProps } from './SelectRadix/SelectRadix.types';
+export { type SelectProps } from './Select/Select.types';
 export { default as Table } from './Table';
 export { default as TableHeader } from './Table/TableHeader';
 export { default as TablePagination } from './Table/TablePagination';