@archbase/admin 4.0.19 → 4.0.20

package/dist/ArchbaseNavigationProgress.d.ts

@@ -2,6 +2,7 @@ import { default as React } from 'react';
 interface NavigationProgressContextValue {
     start: () => void;
     done: () => void;
+    isNavigating: boolean;
 }
 export declare const useNavigationProgress: () => NavigationProgressContextValue;
 export declare function NavigationProgressProvider({ children }: {

package/dist/ArchbaseStatefulRoutes.d.ts

@@ -0,0 +1,23 @@
+import { default as React } from 'react';
+export interface StatefulRouteProps {
+    path: string;
+    element: React.ReactElement;
+}
+export interface ArchbaseStatefulRoutesProps {
+    /** Lista de rotas a serem renderizadas com estado persistente */
+    routes: StatefulRouteProps[];
+    /** Elemento de fallback para rotas nao encontradas */
+    fallback?: React.ReactNode;
+    /**
+     * Funcao para gerar ID unico da tab a partir do pathname e search.
+     * Por padrao usa pathname + search.
+     */
+    getTabId?: (pathname: string, search: string) => string;
+}
+/**
+ * Componente que renderiza rotas com estado persistente por tab.
+ * Cada rota recebe um TabStoreProvider que gerencia seu estado local.
+ * Quando o usuario troca de tab, o estado e salvo no TabRegistryStore.
+ * Quando retorna a tab, o estado e restaurado automaticamente.
+ */
+export declare const ArchbaseStatefulRoutes: React.FC<ArchbaseStatefulRoutesProps>;

package/dist/components/TabStoreProvider.d.ts

@@ -0,0 +1,23 @@
+import { default as React } from 'react';
+import { TabStore, TabLocalState } from '../state/createTabStore';
+export interface TabStoreProviderProps {
+    tabId: string;
+    children: React.ReactNode;
+}
+export declare const TabStoreProvider: React.FC<TabStoreProviderProps>;
+/**
+ * Hook para acessar o store local da tab com um selector
+ * @param selector Funcao que seleciona parte do estado
+ * @returns O valor selecionado do estado
+ */
+export declare function useTabStore<T>(selector: (state: TabLocalState) => T): T;
+/**
+ * Hook para acessar o store completo (para casos avancados)
+ * @returns A instancia do store da tab
+ */
+export declare function useTabStoreApi(): TabStore;
+/**
+ * Hook opcional que retorna o store se disponivel, ou null caso contrario
+ * Util para componentes que podem ou nao estar dentro de um TabStoreProvider
+ */
+export declare function useTabStoreOptional(): TabStore | null;

package/dist/components/index.d.ts

@@ -0,0 +1,2 @@
+export { TabStoreProvider, useTabStore, useTabStoreApi, useTabStoreOptional } from './TabStoreProvider';
+export type { TabStoreProviderProps } from './TabStoreProvider';

package/dist/hooks/index.d.ts

@@ -1 +1,9 @@
 export * from './useArchbaseAdminStore';
+export { useArchbaseState, useArchbaseStateNamed } from './useArchbaseState';
+export { useArchbaseGridState } from './useArchbaseGridState';
+export type { ArchbaseGridPersistedState } from './useArchbaseGridState';
+export { useArchbaseTreeState, useArchbaseAccordionState } from './useArchbaseTreeState';
+export type { ArchbaseTreePersistedState } from './useArchbaseTreeState';
+export { useArchbaseScrollRestore, // Persistir scroll automaticamente
+useArchbaseTabActive, // Detectar quando tab fica ativa
+useArchbaseDrawerState, } from './useArchbasePersistedState';

package/dist/hooks/useArchbaseAdminStore.d.ts

@@ -8,4 +8,19 @@ export interface AdminState {
     setActiveTabId: (activeTabId: any) => void;
     setCollapsed: (collapsed: boolean) => void;
 }
+/**
+ * @deprecated Use `useTabRegistryStore` de `state/tabRegistryStore` para gerenciar
+ * estado de tabs com persistencia. Este store sera removido em versoes futuras.
+ *
+ * Migracao:
+ * ```tsx
+ * // Antes
+ * const { activeTabId, setActiveTabId } = useArchbaseAdminStore();
+ *
+ * // Depois
+ * import { useTabRegistryStore } from '@archbase/admin';
+ * const activeTabId = useTabRegistryStore((s) => s.activeTabId);
+ * const setActiveTab = useTabRegistryStore((s) => s.setActiveTab);
+ * ```
+ */
 export declare const useArchbaseAdminStore: import('zustand').UseBoundStore<import('zustand').StoreApi<AdminState>>;

package/dist/hooks/useArchbaseGridState.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Estado completo de um DataGrid que deve persistir.
+ */
+export interface ArchbaseGridPersistedState {
+    /** Pagina atual (0-indexed) */
+    page: number;
+    /** Registros por pagina */
+    pageSize: number;
+    /** Modelo de ordenacao */
+    sortModel: Array<{
+        field: string;
+        sort: 'asc' | 'desc';
+    }>;
+    /** Modelo de filtros por coluna */
+    filterModel: Record<string, any>;
+    /** IDs das linhas selecionadas/marcadas */
+    selectedRowIds: string[];
+    /** Larguras das colunas (colId -> width) */
+    columnWidths: Record<string, number>;
+    /** Ordem das colunas (array de colIds) */
+    columnOrder: string[];
+    /** Colunas ocultas (array de colIds) */
+    hiddenColumns: string[];
+    /** IDs das linhas expandidas (master-detail) */
+    expandedRowIds: string[];
+    /** Posicao do scroll */
+    scrollPosition: {
+        top: number;
+        left: number;
+    };
+}
+/**
+ * Hook para persistir estado completo de um DataGrid.
+ * Pode ser usado diretamente ou integrado em componentes de Grid.
+ *
+ * @param gridId Identificador unico do grid na tela
+ * @param initialState Estado inicial customizado (opcional)
+ *
+ * @example
+ * ```tsx
+ * // Uso direto
+ * const grid = useArchbaseGridState('customersGrid');
+ *
+ * <ArchbaseDataGridAG
+ *   pageIndex={grid.state.page}
+ *   pageSize={grid.state.pageSize}
+ *   sortModel={grid.state.sortModel}
+ *   onPaginationChange={(page, pageSize) => grid.update({ page, pageSize })}
+ *   onSortModelChange={(sortModel) => grid.update({ sortModel })}
+ *   onSelectionChange={(ids) => grid.update({ selectedRowIds: ids })}
+ * />
+ *
+ * // Ou o componente pode aceitar stateKey e fazer isso internamente
+ * <ArchbaseDataGridAG stateKey="customersGrid" />
+ * ```
+ */
+export declare function useArchbaseGridState(gridId: string, initialState?: Partial<ArchbaseGridPersistedState>): {
+    /** Estado completo do grid */
+    state: ArchbaseGridPersistedState;
+    /** Atualizar multiplos campos */
+    update: (partial: Partial<ArchbaseGridPersistedState>) => void;
+    /** Resetar para estado inicial */
+    reset: () => void;
+    setPage: (page: number) => void;
+    setPageSize: (pageSize: number) => void;
+    setSortModel: (sortModel: ArchbaseGridPersistedState["sortModel"]) => void;
+    setFilterModel: (filterModel: ArchbaseGridPersistedState["filterModel"]) => void;
+    setSelectedRowIds: (selectedRowIds: string[]) => void;
+    toggleRowSelection: (rowId: string) => void;
+    selectAllRows: (rowIds: string[]) => void;
+    clearSelection: () => void;
+    isRowSelected: (rowId: string) => boolean;
+    /** Quantidade de linhas selecionadas */
+    selectedCount: number;
+    /** Se tem alguma linha selecionada */
+    hasSelection: boolean;
+    toggleRowExpansion: (rowId: string) => void;
+    isRowExpanded: (rowId: string) => boolean;
+};

package/dist/hooks/useArchbasePersistedState.d.ts

@@ -0,0 +1,61 @@
+import { RefObject } from 'react';
+/**
+ * Hook para persistir scroll automaticamente.
+ * Basta passar a ref - restaura e salva automaticamente.
+ *
+ * @example
+ * ```tsx
+ * const scrollRef = useRef<HTMLDivElement>(null);
+ * useArchbaseScrollRestore(scrollRef);
+ *
+ * return <div ref={scrollRef} style={{ overflow: 'auto' }}>...</div>;
+ * ```
+ */
+export declare function useArchbaseScrollRestore(containerRef: RefObject<HTMLElement | null>, options?: {
+    debounceMs?: number;
+}): void;
+/**
+ * Hook para detectar quando a tab fica ativa (visivel).
+ * Retorna boolean e opcionalmente executa callback.
+ *
+ * @example
+ * ```tsx
+ * // Simples - so detecta
+ * const isActive = useArchbaseTabActive();
+ *
+ * // Com callback - refresh quando ativar
+ * const isActive = useArchbaseTabActive(() => {
+ *   dataSource.refreshData();
+ * });
+ *
+ * // Condicional
+ * if (isActive) {
+ *   // Tab esta visivel
+ * }
+ * ```
+ */
+export declare function useArchbaseTabActive(onActivate?: () => void): boolean;
+/**
+ * Hook para estado de modal/drawer com dado associado.
+ * Persiste entre trocas de tab.
+ *
+ * @example
+ * ```tsx
+ * const drawer = useArchbaseDrawerState<VisitaDTO>('detalhes');
+ *
+ * // Abrir com dados
+ * <Button onClick={() => drawer.open(visitaSelecionada)}>Ver</Button>
+ *
+ * // No drawer
+ * <Drawer opened={drawer.isOpen} onClose={drawer.close}>
+ *   {drawer.data && <Detalhes visita={drawer.data} />}
+ * </Drawer>
+ * ```
+ */
+export declare function useArchbaseDrawerState<T = any>(key: string): {
+    isOpen: boolean;
+    data: T;
+    open: (itemData?: T) => void;
+    close: () => void;
+    closeAndClear: () => void;
+};

package/dist/hooks/useArchbaseState.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Drop-in replacement para useState que persiste entre trocas de tab.
+ *
+ * Funciona EXATAMENTE como useState - mesma assinatura, mesmo comportamento.
+ * A unica diferenca: o valor persiste quando o usuario troca de tab e volta.
+ *
+ * Se usado fora de um TabStoreProvider, funciona como useState normal.
+ *
+ * @param key Chave unica para identificar este estado na tab
+ * @param initialValue Valor inicial (igual useState)
+ * @returns [value, setValue] - igual useState
+ *
+ * @example
+ * ```tsx
+ * // ANTES (useState normal - perde estado ao trocar tab)
+ * const [filtro, setFiltro] = useState('');
+ * const [pagina, setPagina] = useState(0);
+ * const [aberto, setAberto] = useState(false);
+ *
+ * // DEPOIS (useArchbaseState - persiste entre tabs)
+ * const [filtro, setFiltro] = useArchbaseState('filtro', '');
+ * const [pagina, setPagina] = useArchbaseState('pagina', 0);
+ * const [aberto, setAberto] = useArchbaseState('aberto', false);
+ *
+ * // Uso identico ao useState
+ * setFiltro('novo valor');
+ * setPagina(prev => prev + 1);
+ * setAberto(true);
+ * ```
+ */
+export declare function useArchbaseState<T>(key: string, initialValue: T | (() => T)): [T, (value: T | ((prev: T) => T)) => void];
+/**
+ * Versao simplificada que usa o nome da variavel como chave.
+ * Util para migracao rapida de codigo existente.
+ *
+ * @example
+ * ```tsx
+ * // Cria estado com chave 'filters' automaticamente
+ * const [filters, setFilters] = useArchbaseStateAuto({ status: null, date: null });
+ * ```
+ */
+export declare function useArchbaseStateNamed<T>(name: string, initialValue: T): [T, React.Dispatch<React.SetStateAction<T>>];

package/dist/hooks/useArchbaseTreeState.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Estado de TreeView/Arvore que deve persistir.
+ */
+export interface ArchbaseTreePersistedState {
+    /** IDs dos nos expandidos */
+    expandedNodeIds: string[];
+    /** IDs dos nos selecionados */
+    selectedNodeIds: string[];
+    /** ID do no focado */
+    focusedNodeId: string | null;
+}
+/**
+ * Hook para persistir estado de TreeView/Arvore.
+ *
+ * @param treeId Identificador unico da arvore
+ * @param initialExpanded IDs dos nos que devem iniciar expandidos
+ *
+ * @example
+ * ```tsx
+ * const tree = useArchbaseTreeState('menuTree', ['root', 'config']);
+ *
+ * <TreeView
+ *   expanded={tree.state.expandedNodeIds}
+ *   selected={tree.state.selectedNodeIds}
+ *   onNodeToggle={(nodeId) => tree.toggleExpanded(nodeId)}
+ *   onNodeSelect={(nodeId) => tree.setSelected([nodeId])}
+ * />
+ * ```
+ */
+export declare function useArchbaseTreeState(treeId: string, initialExpanded?: string[]): {
+    state: ArchbaseTreePersistedState;
+    reset: () => void;
+    toggleExpanded: (nodeId: string) => void;
+    expand: (nodeId: string) => void;
+    collapse: (nodeId: string) => void;
+    expandAll: (allNodeIds: string[]) => void;
+    collapseAll: () => void;
+    isExpanded: (nodeId: string) => boolean;
+    setSelected: (nodeIds: string[]) => void;
+    toggleSelected: (nodeId: string) => void;
+    clearSelection: () => void;
+    isSelected: (nodeId: string) => boolean;
+    selectedCount: number;
+    hasSelection: boolean;
+    setFocused: (nodeId: string | null) => void;
+    focusedNodeId: string;
+};
+/**
+ * Hook para persistir estado de Accordion/Paineis expansiveis.
+ *
+ * @param accordionId Identificador unico
+ * @param initialExpanded IDs dos paineis que devem iniciar expandidos
+ * @param allowMultiple Se permite multiplos paineis abertos (default: true)
+ *
+ * @example
+ * ```tsx
+ * const accordion = useArchbaseAccordionState('filters', ['basic']);
+ *
+ * <Accordion
+ *   multiple
+ *   value={accordion.expandedIds}
+ *   onChange={accordion.setExpanded}
+ * >
+ *   <Accordion.Item value="basic">...</Accordion.Item>
+ *   <Accordion.Item value="advanced">...</Accordion.Item>
+ * </Accordion>
+ * ```
+ */
+export declare function useArchbaseAccordionState(accordionId: string, initialExpanded?: string[], allowMultiple?: boolean): {
+    /** IDs dos paineis expandidos */
+    expandedIds: string[];
+    /** Para usar direto no Accordion.value */
+    value: string | string[];
+    /** Setar expandidos (compativel com Mantine Accordion.onChange) */
+    setExpanded: (value: string | string[] | null) => void;
+    toggle: (panelId: string) => void;
+    expand: (panelId: string) => void;
+    collapse: (panelId: string) => void;
+    collapseAll: () => void;
+    isExpanded: (panelId: string) => boolean;
+};

package/dist/index.d.ts

@@ -35,3 +35,11 @@ export { ArchbaseMyProfileModal, defaultMyProfileModalOptions } from './Archbase
 export type { ArchbaseMyProfileModalProps, MyProfileModalOptions } from './ArchbaseMyProfileModal';
 export { NavigationProgressProvider, useNavigationProgress } from './ArchbaseNavigationProgress';
 export * from './hooks';
+export { ArchbaseStatefulRoutes } from './ArchbaseStatefulRoutes';
+export type { ArchbaseStatefulRoutesProps, StatefulRouteProps } from './ArchbaseStatefulRoutes';
+export { TabStoreProvider, useTabStore, useTabStoreApi, useTabStoreOptional } from './components/TabStoreProvider';
+export type { TabStoreProviderProps } from './components/TabStoreProvider';
+export { useTabRegistryStore } from './state/tabRegistryStore';
+export type { TabSnapshot, TabRegistryState } from './state/tabRegistryStore';
+export { createTabStore } from './state/createTabStore';
+export type { TabStore, TabLocalState, SerializedTabState, GridState } from './state/createTabStore';