forlogic-core 1.15.2 → 1.15.4

package/dist/crud/generateCrudConfig.d.ts

@@ -0,0 +1,73 @@
+import { CrudConfig, EntityWithId } from '../types';
+/**
+ * Gera automaticamente configuração CRUD a partir de uma interface TypeScript
+ *
+ * **USO AVANÇADO:** Para a maioria dos casos, use `useMemo` direto com config manual.
+ * Esta função é útil para gerar configs dinamicamente em tempo de execução.
+ *
+ * Analisa os campos da entidade e cria colunas com tipos inteligentes baseados em:
+ * - Nome do campo (ex: "email" → type: 'email')
+ * - Tipo do valor (ex: boolean → type: 'boolean')
+ * - Padrões comuns (ex: "description" → type: 'textarea')
+ *
+ * Para exemplos completos de configuração manual, veja o README (Tutorial CRUD de Examples).
+ *
+ * @example
+ * ```typescript
+ * interface Employee {
+ *   id: string;
+ *   name: string;
+ *   email: string;
+ *   is_active: boolean;
+ *   description: string;
+ *   created_at: string;
+ * }
+ *
+ * const config = generateCrudConfig<Employee>(
+ *   'Funcionários',
+ *   { name: '', email: '', is_active: true, description: '' }
+ * );
+ *
+ * // Resultado:
+ * // {
+ * //   title: 'Funcionários',
+ * //   columns: [
+ * //     { key: 'name', header: 'Name', type: 'text', sortable: true },
+ * //     { key: 'email', header: 'Email', type: 'email', sortable: true },
+ * //     { key: 'is_active', header: 'Is Active', type: 'boolean' },
+ * //     { key: 'description', header: 'Description', type: 'textarea' }
+ * //   ],
+ * //   searchPlaceholder: 'Buscar funcionários...',
+ * //   enableCreate: true,
+ * //   enableEdit: true,
+ * //   enableDelete: true
+ * // }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Com overrides para customizar
+ * const config = generateCrudConfig<Employee>(
+ *   'Funcionários',
+ *   { name: '', email: '', status: 'active' },
+ *   {
+ *     enableDelete: false,  // Desabilita exclusão
+ *     itemsPerPage: 25,     // Customiza paginação
+ *     columns: [            // Sobrescreve colunas específicas
+ *       { key: 'status', header: 'Status', type: 'select',
+ *         options: ['active', 'inactive', 'pending'] }
+ *     ]
+ *   }
+ * );
+ * ```
+ *
+ * @param title Título da página/entidade (ex: 'Funcionários')
+ * @param sampleEntity Objeto com campos da entidade (valores podem ser vazios)
+ * @param overrides Sobrescreve configurações auto-geradas
+ *
+ * @returns Configuração CRUD completa pronta para usar com createCrudPage
+ *
+ * @see {@link withPreset} - Para usar presets prontos (user, product, order, category)
+ * @see {@link crudPresets} - Presets disponíveis
+ */
+export declare function generateCrudConfig<T extends EntityWithId>(title: string, sampleEntity: Partial<T>, overrides?: Partial<CrudConfig<T>>): CrudConfig<T>;

package/dist/crud/hooks/useBaseForm.d.ts

@@ -0,0 +1,8 @@
+import { FormField } from '../../types';
+export declare function useBaseForm<T extends Record<string, any>>(fields: FormField[], initialData?: Partial<T>, onFormDataChange?: (data: T) => void, open?: boolean): {
+    formData: T;
+    errors: Record<string, string>;
+    updateField: (fieldName: string, value: any) => void;
+    validateForm: () => boolean;
+    handleSubmit: (onSubmit: (data: T) => void) => (e?: React.FormEvent) => void;
+};

package/dist/crud/hooks/useCrud.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Hook genérico para operações CRUD com React Query
+ *
+ * **USO AVANÇADO** - Para a maioria dos casos, use `createSimpleService` que já retorna este hook.
+ *
+ * Fornece gerenciamento completo de estado para operações CRUD:
+ * - ✅ Busca, ordenação e paginação via URL params
+ * - ✅ Cache inteligente com React Query
+ * - ✅ Mutations com feedback automático (toasts)
+ * - ✅ Seleção múltipla e ações em massa
+ * - ✅ Invalidação automática de cache
+ * - ✅ Estados de loading separados por operação
+ *
+ * @example
+ * ```typescript
+ * // Normalmente você NÃO usa este hook diretamente, mas sim via createSimpleService:
+ * const { useCrudHook } = createSimpleService({ tableName: 'employees', ... });
+ * const manager = useCrudHook();
+ *
+ * // manager retorna:
+ * const {
+ *   entities,           // Array de dados
+ *   isLoading,          // Loading inicial
+ *   isCreating,         // Loading ao criar
+ *   isUpdating,         // Loading ao atualizar
+ *   isDeleting,         // Loading ao deletar
+ *
+ *   createEntity,       // Função para criar
+ *   updateEntity,       // Função para atualizar
+ *   deleteEntity,       // Função para deletar
+ *
+ *   pagination: {
+ *     currentPage,
+ *     totalPages,
+ *     totalItems,
+ *     hasNextPage
+ *   },
+ *
+ *   handleSearch,       // Função para busca
+ *   handleSort,         // Função para ordenação
+ *   handlePageChange,   // Função para paginação
+ *
+ *   selectedIds,        // IDs selecionados (bulk)
+ *   selectAll,          // Selecionar todos
+ *   bulkDelete          // Deletar selecionados
+ * } = manager;
+ * ```
+ *
+ * @param config Configuração do hook
+ * @param config.queryKey Chave única para cache do React Query
+ * @param config.service Service com métodos getAll, create, update, delete
+ * @param config.entityName Nome da entidade para mensagens de toast
+ * @param config.searchFields Campos para busca (opcional, default no service)
+ * @param config.additionalFilters Filtros adicionais sempre aplicados
+ * @param config.onSuccess Callback executado após create/update com sucesso
+ *
+ * @returns Manager completo com dados, estados e funções de CRUD
+ *
+ * @see {@link createSimpleService} - Método recomendado que já usa este hook
+ */
+interface CrudService<T, TInsert = Partial<T>, TUpdate = Partial<T>> {
+    getAll: (params: any) => Promise<any>;
+    create: (data: TInsert) => Promise<T>;
+    update: (id: string, data: TUpdate) => Promise<T>;
+    delete: (id: string) => Promise<void>;
+}
+interface CrudConfig<T, TInsert = Partial<T>, TUpdate = Partial<T>> {
+    queryKey: string;
+    service: CrudService<T, TInsert, TUpdate>;
+    entityName: string;
+    searchFields?: string[];
+    additionalFilters?: Record<string, any>;
+    onSuccess?: () => void;
+}
+export declare function useCrud<T extends {
+    id: string;
+}, TInsert = Partial<T>, TUpdate = Partial<T>>({ queryKey, service, entityName, searchFields, additionalFilters, onSuccess }: CrudConfig<T, TInsert, TUpdate>): {
+    entities: any;
+    pagination: {
+        data: any;
+        currentPage: any;
+        totalPages: any;
+        totalItems: any;
+        itemsPerPage: any;
+        hasNextPage: any;
+        hasPreviousPage: any;
+    };
+    isLoading: boolean;
+    isCreating: boolean;
+    isUpdating: boolean;
+    isDeleting: boolean;
+    error: Error;
+    searchTerm: string;
+    sortField: string;
+    sortDirection: "desc" | "asc";
+    currentPage: number;
+    itemsPerPage: number;
+    queryKey: string;
+    createEntity: import("@tanstack/react-query").UseMutateFunction<T, any, TInsert, unknown>;
+    updateEntity: (id: string, data: TUpdate) => void;
+    deleteEntity: import("@tanstack/react-query").UseMutateFunction<void, any, string, unknown>;
+    save: (data: any, transform?: (data: any) => any) => void;
+    handleSearch: (search: string) => void;
+    handleSort: (field: string) => void;
+    handlePageChange: (newPage: number) => void;
+    handleItemsPerPageChange: (newLimit: number) => void;
+    clearFilters: () => void;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<any, Error>>;
+    selectedIds: string[];
+    selectItem: (id: string) => void;
+    selectAll: () => void;
+    clearSelection: () => void;
+    isAllSelected: boolean;
+    bulkDelete: (ids: string[]) => Promise<void>;
+    isBulkDeleting: boolean;
+};
+export {};

package/dist/crud/primitives/ActionMenu.d.ts

@@ -0,0 +1,28 @@
+/**
+ * ActionMenu Primitive Component
+ *
+ * Menu de ações reutilizável que pode ser renderizado como dropdown ou inline.
+ * Suporta ações padrão (Edit, Delete, Toggle) e ações customizadas.
+ *
+ * @example
+ * ```tsx
+ * // Dropdown (padrão)
+ * <ActionMenu
+ *   onEdit={() => console.log('edit')}
+ *   onDelete={() => console.log('delete')}
+ *   renderAs="dropdown"
+ * />
+ *
+ * // Inline com ações customizadas
+ * <ActionMenu
+ *   onEdit={() => console.log('edit')}
+ *   customActions={[
+ *     { label: 'Duplicar', icon: Copy, onClick: () => {}, variant: 'default' }
+ *   ]}
+ *   renderAs="inline"
+ *   variant="compact"
+ * />
+ * ```
+ */
+import type { ActionMenuProps } from './types';
+export declare function ActionMenu({ onEdit, onDelete, onToggleStatus, isActive, canEdit, canDelete, customActions, renderAs, variant }: ActionMenuProps): import("react/jsx-runtime").JSX.Element;

package/dist/crud/primitives/FilterBar.d.ts

@@ -0,0 +1,24 @@
+/**
+ * FilterBar Primitive Component
+ *
+ * Barra de filtros reutilizável com campo de busca e slots para filtros customizados.
+ *
+ * @example
+ * ```tsx
+ * <FilterBar
+ *   searchValue={search}
+ *   onSearchChange={setSearch}
+ *   customFilters={[
+ *     <StatusSelect value={status} onChange={setStatus} />,
+ *     <CategorySelect value={category} onChange={setCategory} />
+ *   ]}
+ *   onClearFilters={() => {
+ *     setSearch('');
+ *     setStatus('all');
+ *     setCategory('all');
+ *   }}
+ * />
+ * ```
+ */
+import type { FilterBarProps } from './types';
+export declare function FilterBar({ searchValue, onSearchChange, customFilters, onClearFilters, showClearButton, layout }: FilterBarProps): import("react/jsx-runtime").JSX.Element;

package/dist/crud/primitives/Pagination.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Pagination Primitive Component
+ *
+ * Controles de paginação reutilizáveis sem dependências de CRUD logic.
+ *
+ * Layout Visual: 3 colunas responsivas
+ * [Itens por página: 10 ▼]    [1-10 de 100 itens (página 1 de 10)]    [<< < | 1 de 10 | > >>]
+ *      └─ Esquerda                        └─ Centro                          └─ Direita
+ *
+ * @example
+ * ```tsx
+ * <Pagination
+ *   currentPage={1}
+ *   totalPages={10}
+ *   totalItems={100}
+ *   itemsPerPage={10}
+ *   onPageChange={(page) => setPage(page)}
+ *   onItemsPerPageChange={(limit) => setLimit(limit)}
+ *   variant="full"
+ * />
+ * ```
+ */
+import type { PaginationProps } from "./types";
+export declare function Pagination({ currentPage, totalPages, totalItems, itemsPerPage, onPageChange, onItemsPerPageChange, variant, }: PaginationProps): import("react/jsx-runtime").JSX.Element;

package/dist/crud/primitives/Table.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Table Primitive Component
+ *
+ * Componente de tabela "puro" sem dependências de lógica CRUD.
+ * Responsável apenas por renderizar dados em formato tabular com sorting visual.
+ * Suporta redimensionamento de colunas via drag (habilitado por padrão).
+ *
+ * @example
+ * ```tsx
+ * <Table
+ *   data={users}
+ *   columns={[
+ *     { key: 'name', header: 'Nome', sortable: true },
+ *     { key: 'email', header: 'Email' }
+ *   ]}
+ *   sortField="name"
+ *   sortDirection="asc"
+ *   onSort={(field) => console.log('Sort by:', field)}
+ *   renderActions={(user) => <button>Editar</button>}
+ * />
+ * ```
+ */
+import type { TableProps } from './types';
+export declare function Table<T extends {
+    id: string;
+}>({ data, columns, sortField, sortDirection, onSort, onRowClick, renderActions, isLoading, emptyMessage, className, enableSelection, selectedIds, onSelectItem, onSelectAll, isAllSelected, enableColumnResize, onColumnResize, storageKey }: TableProps<T>): import("react/jsx-runtime").JSX.Element;

package/dist/crud/primitives/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * CRUD Primitives
+ *
+ * Componentes "puros" sem dependências de lógica CRUD.
+ * Use-os quando precisar de controle total sobre o comportamento.
+ */
+export { Table } from './Table';
+export { ActionMenu } from './ActionMenu';
+export { Pagination } from './Pagination';
+export { FilterBar } from './FilterBar';
+export type { TableProps, TableColumn, ActionMenuProps, ActionItem, PaginationProps, FilterBarProps, } from './types';

package/dist/crud/primitives/types.d.ts

@@ -0,0 +1,76 @@
+import React from 'react';
+export interface TableColumn<T = any> {
+    key: keyof T;
+    header: string;
+    sortable?: boolean;
+    render?: (item: T) => React.ReactNode;
+    className?: string;
+    minWidth?: number;
+    maxWidth?: number;
+    weight?: number;
+    width?: number;
+    resizable?: boolean;
+}
+export interface TableProps<T> {
+    data: T[];
+    columns: TableColumn<T>[];
+    sortField?: string;
+    sortDirection?: 'asc' | 'desc';
+    onSort?: (field: string) => void;
+    onRowClick?: (item: T) => void;
+    renderActions?: (item: T) => React.ReactNode;
+    isLoading?: boolean;
+    emptyMessage?: string;
+    className?: string;
+    enableSelection?: boolean;
+    selectedIds?: string[];
+    onSelectItem?: (id: string) => void;
+    onSelectAll?: () => void;
+    isAllSelected?: boolean;
+    enableColumnResize?: boolean;
+    columnWidths?: Record<string, number>;
+    onColumnResize?: (widths: Record<string, number>) => void;
+    storageKey?: string;
+}
+export interface ActionItem {
+    label: string;
+    icon?: React.ComponentType<{
+        size?: number;
+        className?: string;
+    }>;
+    onClick: () => void;
+    variant?: 'default' | 'destructive';
+    show?: boolean;
+    /** Se a ação está desabilitada */
+    disabled?: boolean;
+    /** Motivo do bloqueio (exibido em tooltip quando disabled=true) */
+    disabledReason?: string;
+}
+export interface ActionMenuProps {
+    onEdit?: () => void;
+    onDelete?: () => void;
+    onToggleStatus?: () => void;
+    isActive?: boolean;
+    canEdit?: boolean;
+    canDelete?: boolean;
+    customActions?: ActionItem[];
+    renderAs?: 'dropdown' | 'inline';
+    variant?: 'default' | 'compact';
+}
+export interface PaginationProps {
+    currentPage: number;
+    totalPages: number;
+    totalItems: number;
+    itemsPerPage: number;
+    onPageChange: (page: number) => void;
+    onItemsPerPageChange: (limit: number) => void;
+    variant?: 'full' | 'compact';
+}
+export interface FilterBarProps {
+    searchValue?: string;
+    onSearchChange?: (value: string) => void;
+    customFilters?: React.ReactNode[];
+    onClearFilters?: () => void;
+    showClearButton?: boolean;
+    layout?: 'horizontal' | 'vertical';
+}

package/dist/crud/utils/routingHelpers.d.ts

@@ -0,0 +1,30 @@
+import type { CrudEntity } from '../../types';
+export interface RoutingConfig {
+    basePath: string;
+    newPath?: string;
+    editPath?: string;
+}
+/**
+ * Creates routing handlers for CRUD operations
+ * @param config Configuration for routing paths
+ * @returns Object with onNew and onEdit handlers
+ */
+export declare function createRoutingHandlers<T extends CrudEntity>(config: RoutingConfig): {
+    onNew: () => void;
+    onEdit: (entity: T) => void;
+};
+/**
+ * Helper para configurar CRUD com routing customizado
+ * @param basePath Base path for the CRUD routes (e.g., '/articles')
+ * @param config Optional custom paths
+ * @returns Configuration object for CrudPageConfig
+ */
+export declare function createCrudRoutingConfig<T extends CrudEntity>(basePath: string, config?: {
+    newPath?: string;
+    editPath?: string;
+    preservePagination?: boolean;
+}): {
+    useCustomRouting: boolean;
+    onNew: () => void;
+    onEdit: (entity: T) => void;
+};

package/dist/exports/crud.d.ts

@@ -0,0 +1,21 @@
+export { createSimpleService } from '../crud/createSimpleService';
+export { createCrudPage, createSimpleSaveHandler, CrudPageInternal } from '../crud/createCrudPage';
+export { generateCrudConfig } from '../crud/generateCrudConfig';
+export { default as BaseForm } from '../crud/components/BaseForm';
+export { CrudTable } from '../crud/components/CrudTable';
+export { CrudGrid } from '../crud/components/CrudGrid';
+export type { CrudGridProps } from '../crud/components/CrudGrid';
+export { FilterBar } from '../crud/components/FilterBar';
+export { CrudPagination } from '../crud/components/CrudPagination';
+export { TableRowActions } from '../crud/components/TableRowActions';
+export { ActionMenuItems } from '../crud/components/ActionMenuItems';
+export { CrudActionBar } from '../crud/components/CrudActionBar';
+export type { CrudActionBarProps, CustomAction, ViewMode as CrudViewMode } from '../crud/components/CrudActionBar';
+export { useCrud } from '../crud/hooks/useCrud';
+export { useBaseForm } from '../crud/hooks/useBaseForm';
+export { Table as CrudPrimitiveTable } from '../crud/primitives/Table';
+export { ActionMenu } from '../crud/primitives/ActionMenu';
+export { Pagination as CrudPrimitivePagination } from '../crud/primitives/Pagination';
+export { FilterBar as CrudPrimitiveFilterBar } from '../crud/primitives/FilterBar';
+export type { TableProps as CrudPrimitiveTableProps, TableColumn, ActionMenuProps, ActionItem, PaginationProps as CrudPrimitivePaginationProps, FilterBarProps as CrudPrimitiveFilterBarProps, } from '../crud/primitives/types';
+export * from '../crud/utils/routingHelpers';

package/dist/exports/integrations.d.ts

@@ -0,0 +1,13 @@
+export { getSupabaseClient } from '../supabase/SupabaseSingleton';
+export * from '../qualiex/components/QualiexUserField';
+export * from '../qualiex/hooks/useQualiexUsers';
+export * from '../qualiex/services/qualiexApi';
+export * from '../qualiex/utils/QualiexErrorInterceptor';
+export * from '../auth/contexts/AuthContext';
+export * from '../auth/components/ProtectedRoute';
+export * from '../auth/components/UserInfo';
+export * from '../auth/pages/CallbackPage';
+export * from '../auth/services/AuthService';
+export { TokenManager } from '../auth/services/TokenManager';
+export * from '../auth/services/TokenService';
+export * from '../auth/utils/ErrorInterceptor';

package/dist/exports/ui.d.ts

@@ -0,0 +1,73 @@
+export * from '../components/ui/accordion';
+export * from '../components/ui/alert';
+export * from '../components/ui/alert-dialog';
+export * from '../components/ui/avatar';
+export * from '../components/ui/breadcrumb';
+export * from '../components/ui/button';
+export * from '../components/ui/button-group';
+export * from '../components/ui/badge';
+export * from '../components/ui/calendar';
+export * from '../components/ui/card';
+export * from '../components/ui/checkbox';
+export { Collapsible, CollapsibleTrigger, CollapsibleContent } from '../components/ui/collapsible';
+export * from '../components/ui/color-picker';
+export * from '../components/ui/command';
+export * from '../components/ui/context-menu';
+export * from '../components/ui/data-list';
+export * from '../components/ui/date-picker';
+export * from '../components/ui/dialog';
+export * from '../components/ui/drawer';
+export * from '../components/ui/dropdown-menu';
+export * from '../components/ui/disabled-menu-item';
+export * from '../components/ui/empty-state';
+export { Combobox, type ComboboxProps } from '../components/ui/combobox';
+export { Combobox as SelectSearch } from '../components/ui/combobox';
+export type { ComboboxProps as SelectSearchProps } from '../components/ui/combobox';
+export { Combobox as MultiSelect } from '../components/ui/combobox';
+export type { ComboboxProps as MultiSelectProps } from '../components/ui/combobox';
+export { Combobox as EntitySelect } from '../components/ui/combobox';
+export type { ComboboxProps as EntitySelectProps } from '../components/ui/combobox';
+export * from '../components/ui/form';
+export * from '../components/ui/grid';
+export * from '../components/ui/hover-card';
+export * from '../components/ui/icon-picker';
+export * from '../components/ui/input';
+export * from '../components/ui/input-group';
+export * from '../components/ui/label';
+export { LoadingState } from '../components/ui/loading-state';
+export * from '../components/ui/typography';
+export * from '../components/ui/navigation-menu';
+export * from '../components/ui/page-breadcrumb';
+export * from '../components/ui/pagination';
+export * from '../components/ui/popover';
+export * from '../components/ui/progress';
+export * from '../components/ui/radio-group';
+export * from '../components/ui/resizable';
+export * from '../components/ui/scroll-area';
+export * from '../components/ui/select';
+export * from '../components/ui/separator';
+export * from '../components/ui/sheet';
+export * from '../components/ui/sidebar';
+export * from '../components/ui/skeleton';
+export * from '../components/ui/skeleton-variants';
+export * from '../components/ui/slider';
+export { Toaster as SonnerToaster, toast as sonnerToast } from '../components/ui/sonner';
+export * from '../components/ui/spinner';
+export * from '../components/ui/switch';
+export * from '../components/ui/stack';
+export * from '../components/ui/table';
+export { TableResizeHandle } from '../components/ui/table-resize-handle';
+export * from '../components/ui/tabs';
+export * from '../components/ui/tab-page-layout';
+export * from '../components/ui/textarea';
+export * from '../components/ui/toggle';
+export * from '../components/ui/toggle-group';
+export * from '../components/ui/tooltip';
+export * from '../components/ui/truncated-cell';
+export * from '../components/ui/action-button';
+export * from '../components/ui/menubar';
+export * from '../components/ui/chart';
+export * from '../components/ui/rich-text-editor';
+export * from '../components/ui/onboarding-dialog';
+export * from '../components/ui/split-button';
+export * from '../components/ui/step-selector';

package/dist/hooks/useActiveModules.d.ts

@@ -0,0 +1,45 @@
+interface UseActiveModulesOptions {
+    enabled?: boolean;
+}
+/**
+ * Hook para buscar módulos ativos da empresa/unidade atual
+ *
+ * Útil para controlar features disponíveis baseado em módulos contratados.
+ * Usa cache do React Query para evitar chamadas repetidas.
+ *
+ * @example
+ * ```typescript
+ * import { useActiveModules } from 'forlogic-core/modular';
+ *
+ * function App() {
+ *   const { data: modules, isLoading } = useActiveModules();
+ *
+ *   const hasTrainingModule = modules?.some(m => m.name === 'training');
+ *
+ *   return (
+ *     <nav>
+ *       {hasTrainingModule && <Link to="/training">Treinamentos</Link>}
+ *     </nav>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Com enabled condicional
+ * function FeatureSettings() {
+ *   const { isAuthenticated } = useAuth();
+ *
+ *   const { data: modules } = useActiveModules({
+ *     enabled: isAuthenticated
+ *   });
+ * }
+ * ```
+ *
+ * @param options Opções de configuração
+ * @param options.enabled Se false, não executa a query (default: true)
+ *
+ * @returns Query result com array de módulos ativos
+ */
+export declare const useActiveModules: (options?: UseActiveModulesOptions) => import("@tanstack/react-query").UseQueryResult<any, Error>;
+export {};

package/dist/hooks/useColumnResize.d.ts

@@ -0,0 +1,21 @@
+interface ColumnConfig {
+    key: string;
+    minWidth?: number;
+    maxWidth?: number;
+    defaultWidth?: number;
+}
+interface UseColumnResizeProps {
+    columns: ColumnConfig[];
+    storageKey?: string;
+    onResize?: (widths: Record<string, number>) => void;
+    enabled?: boolean;
+}
+interface UseColumnResizeReturn {
+    columnWidths: Record<string, number>;
+    isDragging: boolean;
+    activeColumn: string | null;
+    handleMouseDown: (columnKey: string, e: React.MouseEvent) => void;
+    resetWidths: () => void;
+}
+export declare function useColumnResize({ columns, storageKey, onResize, enabled }: UseColumnResizeProps): UseColumnResizeReturn;
+export {};

package/dist/hooks/useDebounce.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Hook para aplicar debounce em um valor com capacidade de cancelamento
+ *
+ * Útil para otimizar chamadas de API em campos de busca, evitando requisições
+ * a cada tecla digitada. Aguarda o usuário parar de digitar antes de processar.
+ *
+ * @example
+ * ```typescript
+ * import { useDebounce } from 'forlogic-core/modular';
+ *
+ * function SearchInput() {
+ *   const [searchTerm, setSearchTerm] = useState('');
+ *   const [debouncedSearch, cancelDebounce] = useDebounce(searchTerm, 500);
+ *
+ *   // API é chamada apenas quando usuário para de digitar por 500ms
+ *   const { data } = useQuery({
+ *     queryKey: ['search', debouncedSearch],
+ *     queryFn: () => api.search(debouncedSearch),
+ *     enabled: debouncedSearch.length > 0
+ *   });
+ *
+ *   return (
+ *     <input
+ *       value={searchTerm}
+ *       onChange={(e) => setSearchTerm(e.target.value)}
+ *     />
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Com cancelamento manual
+ * function AutoSave() {
+ *   const [content, setContent] = useState('');
+ *   const [debouncedContent, cancelAutoSave] = useDebounce(content, 2000);
+ *
+ *   useEffect(() => {
+ *     if (debouncedContent) {
+ *       saveToServer(debouncedContent);
+ *     }
+ *   }, [debouncedContent]);
+ *
+ *   const handleManualSave = () => {
+ *     cancelAutoSave();  // Cancela auto-save pendente
+ *     saveToServer(content);  // Salva imediatamente
+ *   };
+ * }
+ * ```
+ *
+ * @param value Valor a ser debounced (qualquer tipo)
+ * @param delay Delay em milissegundos antes de aplicar o valor
+ *
+ * @returns Tupla [valor com debounce, função para cancelar]
+ */
+export declare function useDebounce<T>(value: T, delay: number): [T, () => void];