forlogic-core 2.2.8 → 2.3.1

package/dist/sign/integrations/clarity/clarityTracking.d.ts

@@ -0,0 +1,31 @@
+import type { Module } from '../../components/modules/types';
+interface ModuleClickContext {
+    module: Module;
+    isContracted: boolean;
+    sourceModule?: string;
+    alias?: string;
+}
+/**
+ * Função utilitária `trackModuleClick`.
+ * @example
+ * trackModuleClick();
+ */
+export declare function trackModuleClick({ module, isContracted, sourceModule, alias }: ModuleClickContext): void;
+/**
+ * Função utilitária `trackInterestClick`.
+ * @example
+ * trackInterestClick();
+ */
+export declare function trackInterestClick({ module, sourceModule, alias }: Omit<ModuleClickContext, 'isContracted'>): void;
+interface FooterClickContext {
+    resource: 'educa' | 'saber-gestao' | 'wiki';
+    sourceModule?: string;
+    alias?: string;
+}
+/**
+ * Função utilitária `trackFooterClick`.
+ * @example
+ * trackFooterClick();
+ */
+export declare function trackFooterClick({ resource, sourceModule, alias }: FooterClickContext): void;
+export {};

package/dist/sign/integrations/clarity/index.d.ts

@@ -0,0 +1,3 @@
+export { useClarity } from './useClarity';
+export { trackModuleClick, trackInterestClick, trackFooterClick } from './clarityTracking';
+export type { ClarityMode, ClarityRuntimeMode, ModuleClickEventTags, FooterClickEventTags } from './types';

package/dist/sign/integrations/clarity/types.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Modos de operação do Clarity na forlogic-core.
+ * - `auto` (padrão): inicializa o Clarity Forlogic se nenhum outro estiver presente; caso contrário, "pega carona" no existente, prefixando eventos com `forlogic_*`.
+ * - `disabled`: nunca inicializa nem dispara eventos.
+ *
+ * @example
+ * const value: ClarityMode = {} as ClarityMode;
+ */
+export type ClarityMode = 'auto' | 'disabled';
+/** Estado interno de operação após detecção/inicialização *
+ * @example
+ * const value: ClarityRuntimeMode = {} as ClarityRuntimeMode;
+ */
+export type ClarityRuntimeMode = 'owned' | 'piggyback' | 'inactive';
+/**
+ * Tipo `ModuleClickEventTags` exportado pela lib.
+ * @example
+ * const value: ModuleClickEventTags = {} as ModuleClickEventTags;
+ */
+export interface ModuleClickEventTags {
+    clicked_module: string;
+    clicked_module_id?: string;
+    is_contracted: string;
+    source_module?: string;
+    alias?: string;
+}
+/**
+ * Tipo `FooterClickEventTags` exportado pela lib.
+ * @example
+ * const value: FooterClickEventTags = {} as FooterClickEventTags;
+ */
+export interface FooterClickEventTags {
+    footer_resource: 'educa' | 'saber-gestao' | 'wiki';
+    source_module?: string;
+    alias?: string;
+}
+declare global {
+    interface Window {
+        /** Função global instanciada pelo snippet do Clarity (qualquer projeto) */
+        clarity?: ((...args: unknown[]) => void) & Record<string, unknown>;
+        /** Sinaliza que a forlogic-core foi quem inicializou o Clarity */
+        __forlogicClarityOwned?: boolean;
+        /** Modo de operação detectado pela forlogic-core */
+        __forlogicClarityMode?: ClarityRuntimeMode;
+    }
+}

package/dist/sign/integrations/clarity/useClarity.d.ts

@@ -0,0 +1,34 @@
+import type { ClarityMode } from './types';
+interface UseClarityOptions {
+    projectId?: string;
+    mode?: ClarityMode;
+}
+/**
+ * Hook que inicializa o Microsoft Clarity de forma idempotente e identifica o usuário autenticado.
+ *
+ * Comportamento:
+ * - Se `mode === 'disabled'`, não faz nada.
+ * - Em preview/local (shouldUseDevTokens), desabilitado.
+ * - Se já existir uma instância Clarity de outro projeto consumidor, entra em modo `piggyback`
+ *   (não reinicializa, mas eventos disparados pela lib serão prefixados com `forlogic_*`).
+ * - Caso contrário, inicializa com o `projectId` informado (modo `owned`).
+ *
+ * Chame **uma única vez** no topo da árvore (App.tsx ou layout raiz) — internamente
+ * sincroniza com o `AuthContext` e re-identifica o usuário em cada login.
+ *
+ * @example
+ * // App.tsx — habilitado apenas em produção
+ * function App() {
+ *   useClarity({
+ *     projectId: import.meta.env.VITE_CLARITY_PROJECT_ID,
+ *     mode: import.meta.env.PROD ? 'auto' : 'disabled',
+ *   });
+ *   return <CoreProviders>...</CoreProviders>;
+ * }
+ *
+ * @example
+ * // Desabilitar explicitamente (ex: ambiente sandbox de cliente)
+ * useClarity({ mode: 'disabled' });
+ */
+export declare function useClarity({ projectId, mode }: UseClarityOptions): void;
+export {};

package/dist/sign/integrations/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @module integrations
+ * Integrações externas opcionais. Ver `./README.md`.
+ */
+export * from './clarity';

package/dist/sign/leadership/components/LeadershipDialog.d.ts

@@ -0,0 +1,10 @@
+import { Leader } from '../types';
+interface LeadershipDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    leader?: Leader;
+    prefilledLeaderId?: string | null;
+    title: string;
+}
+export declare function LeadershipDialog({ open, onOpenChange, leader, prefilledLeaderId, title }: LeadershipDialogProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/sign/leadership/components/LeadershipForm.d.ts

@@ -0,0 +1,8 @@
+import { Leader } from '../types';
+interface LeadershipFormProps {
+    leader?: Leader;
+    prefilledLeaderId?: string | null;
+    onSuccess?: () => void;
+}
+export declare function LeadershipForm({ leader, prefilledLeaderId, onSuccess }: LeadershipFormProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/sign/leadership/components/LeadershipPage.d.ts

@@ -0,0 +1,19 @@
+import type { TreeTableColumn } from '../../crud/primitives/types';
+import { LeaderNode, UnassociatedUser } from '../types';
+export interface LeadershipPageProps {
+    /** Lista de usuários não associados à hierarquia (fornecida pelo consumidor) */
+    unassociatedUsers?: UnassociatedUser[];
+    /** Callback quando um usuário não associado é movido para a hierarquia */
+    onAssociateUser?: (userId: string, targetLeaderId: string | null) => void;
+    /** Callback para movimentação customizada (default: usa useUpdateLeaderMutation) */
+    onMoveNode?: (draggedId: string, targetId: string | null) => void;
+    /** Callback para movimentação em lote customizada */
+    onMoveNodes?: (draggedIds: string[], targetId: string | null) => void;
+    /** Colunas customizadas para o TreeTable (default: Subordinados + Email) */
+    columns?: TreeTableColumn<LeaderNode>[];
+    /** Header da coluna de nome (default: "Líder") */
+    nameHeader?: string;
+    /** Texto da zona de drop raiz (default: t('leadership_make_root')) */
+    rootDropLabel?: string;
+}
+export declare function LeadershipPage({ unassociatedUsers, onAssociateUser, onMoveNode: customMoveNode, onMoveNodes: customMoveNodes, columns: customColumns, nameHeader, rootDropLabel, }?: LeadershipPageProps): import("react/jsx-runtime").JSX.Element;

package/dist/sign/leadership/hooks/useLeadershipApi.d.ts

@@ -0,0 +1,4 @@
+import { LeaderNode } from '../types';
+export declare function useLeadershipApi(): import("@tanstack/react-query").UseQueryResult<any[], Error> & {
+    data: LeaderNode[] | undefined;
+};

package/dist/sign/leadership/hooks/useLeadershipMutations.d.ts

@@ -0,0 +1,29 @@
+interface CreateLeaderData {
+    id_user: string;
+    id_leader: string | null;
+}
+interface CreateMultipleLeadersData {
+    id_leader: string | null;
+    users: Array<{
+        id_user: string;
+    }>;
+}
+interface UpdateLeaderData {
+    id: string;
+    id_leader: string | null;
+}
+export declare function useCreateSingleLeaderMutation(): import("@tanstack/react-query").UseMutationResult<any, Error, CreateLeaderData, unknown>;
+export declare function useCreateMultipleLeadersMutation(): import("@tanstack/react-query").UseMutationResult<any, Error, CreateMultipleLeadersData, unknown>;
+export declare function useUpdateLeaderMutation(): import("@tanstack/react-query").UseMutationResult<any, Error, UpdateLeaderData, unknown>;
+export declare function useRemoveLeaderMutation(): import("@tanstack/react-query").UseMutationResult<void, Error, string, unknown>;
+export declare function useSyncSubordinatesMutation(): import("@tanstack/react-query").UseMutationResult<{
+    unlinked: number;
+    updated: number;
+    created: number;
+}, Error, {
+    leaderUserId: string;
+    selectedUsers: Array<{
+        id_user: string;
+    }>;
+}, unknown>;
+export {};

package/dist/sign/leadership/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Leadership Module
+ *
+ * Componente hierárquico de liderança reutilizável para gerenciar
+ * relações de liderança entre usuários do Qualiex.
+ */
+export * from './types';
+export * from './utils/leadershipUtils';
+export * from './hooks/useLeadershipApi';
+export * from './hooks/useLeadershipMutations';
+export * from './components/LeadershipPage';
+export * from './components/LeadershipDialog';
+export * from './components/LeadershipForm';

package/dist/sign/leadership/types.d.ts

@@ -0,0 +1,23 @@
+export interface Leader {
+    id: string;
+    alias: string;
+    id_user: string;
+    id_leader: string | null;
+    is_removed: boolean;
+    is_active: boolean;
+    created_at: string;
+    updated_at: string;
+    name?: string;
+    email?: string;
+    subordinatesCount?: number;
+    subordinateNames?: string[];
+}
+export interface UnassociatedUser {
+    id: string;
+    name: string;
+    email: string;
+}
+export interface LeaderNode extends Leader {
+    children: LeaderNode[];
+    level: number;
+}

package/dist/sign/leadership/utils/leadershipUtils.d.ts

@@ -0,0 +1,8 @@
+import { Leader, LeaderNode } from '../types';
+/**
+ * Filtra líderes inválidos (sem nome enriquecido) e promove seus filhos
+ * para o ancestral válido mais próximo ou para a raiz
+ */
+export declare function filterAndPromoteOrphans(leaders: Leader[], validUserIds: Set<string>): Leader[];
+export declare function buildHierarchy(leaders: Leader[]): LeaderNode[];
+export declare function flattenTree(nodes: LeaderNode[]): LeaderNode[];

package/dist/sign/media/components/ImageEditor.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Image Editor Component
+ *
+ * Editor genérico de imagem para forlogic-core.
+ * Suporta URL e upload de arquivos.
+ *
+ * @example
+ * ```tsx
+ * import { ImageEditor } from 'forlogic-core';
+ *
+ * <ImageEditor
+ *   value={imageData}
+ *   onChange={setImageData}
+ *   onSubmit={handleSave}
+ *   onCancel={handleCancel}
+ *   uploadFunction={myUploadFunction}
+ *   uploadOptions={{ bucket: 'images', folder: 'content' }}
+ * />
+ * ```
+ */
+import type { MediaEditorProps, ImageBlockContent } from '../types';
+export declare function ImageEditor({ value, onChange, onSubmit, onCancel, uploadFunction, deleteFunction, uploadOptions }: MediaEditorProps<ImageBlockContent>): import("react/jsx-runtime").JSX.Element;

package/dist/sign/media/components/ImageRenderer.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Image Renderer Component
+ *
+ * Renderizador genérico de imagem para forlogic-core.
+ * Suporta alinhamento, legenda, alt text e download.
+ *
+ * @example
+ * ```tsx
+ * import { ImageRenderer } from 'forlogic-core';
+ *
+ * <ImageRenderer
+ *   content={{
+ *     imageUrl: 'https://example.com/image.jpg',
+ *     caption: 'Minha imagem',
+ *     alt: t('image_description'),
+ *     alignment: 'center',
+ *     allowDownload: true
+ *   }}
+ * />
+ * ```
+ */
+import type { MediaRendererProps, ImageBlockContent } from '../types';
+export declare function ImageRenderer({ content, className, style }: MediaRendererProps<ImageBlockContent>): import("react/jsx-runtime").JSX.Element;

package/dist/sign/media/components/VideoEditor.d.ts

@@ -0,0 +1,2 @@
+import type { MediaEditorProps, VideoBlockContent } from '../types';
+export declare function VideoEditor({ value, onChange, onSubmit, onCancel, uploadFunction, deleteFunction, uploadOptions }: MediaEditorProps<VideoBlockContent>): import("react/jsx-runtime").JSX.Element;

package/dist/sign/media/components/VideoRenderer.d.ts

@@ -0,0 +1,2 @@
+import type { MediaRendererProps, VideoBlockContent } from '../types';
+export declare function VideoRenderer({ content, className, style }: MediaRendererProps<VideoBlockContent>): import("react/jsx-runtime").JSX.Element;

package/dist/sign/media/hooks/useMediaUpload.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Generic Media Upload Hook
+ *
+ * Hook genérico para upload de mídia (imagens, vídeos, arquivos).
+ * Requer que o projeto forneça uma função de upload via props.
+ */
+import type { UploadResult, UploadFunction, UploadOptions, DeleteFunction } from '../types';
+export interface UseMediaUploadOptions {
+    uploadFunction?: UploadFunction;
+    deleteFunction?: DeleteFunction;
+    defaultOptions?: UploadOptions;
+    onSuccess?: (result: UploadResult) => void;
+    onError?: (error: Error) => void;
+}
+export declare function useMediaUpload(options?: UseMediaUploadOptions): {
+    upload: (file: File, uploadOptions?: UploadOptions) => Promise<UploadResult>;
+    deleteMedia: (path: string, bucket?: string) => Promise<void>;
+    uploading: boolean;
+};

package/dist/sign/media/index.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Media Module
+ *
+ * Módulo genérico para gerenciamento de mídia (vídeo, imagem, áudio).
+ * Componentes reutilizáveis e independentes de contexto.
+ *
+ * @example Importar componentes
+ * ```tsx
+ * import { VideoEditor, VideoRenderer } from 'forlogic-core';
+ * ```
+ *
+ * @example Usar com função de upload customizada
+ * ```tsx
+ * import { VideoEditor } from 'forlogic-core';
+ * import { myUploadService } from './services/upload';
+ *
+ * function MyComponent() {
+ *   const uploadFunction = async (file, options) => {
+ *     const result = await myUploadService.upload(file, options.bucket, options.folder);
+ *     return {
+ *       url: result.publicUrl,
+ *       name: file.name,
+ *       size: file.size,
+ *       type: file.type,
+ *       path: result.path
+ *     };
+ *   };
+ *
+ *   return (
+ *     <VideoEditor
+ *       value={videoData}
+ *       uploadFunction={uploadFunction}
+ *       uploadOptions={{ bucket: 'videos', folder: 'content' }}
+ *       onSubmit={handleSave}
+ *       onCancel={handleCancel}
+ *     />
+ *   );
+ * }
+ * ```
+ */
+export type { UploadResult, UploadOptions, UploadFunction, DeleteFunction, VideoInputType, VideoProvider, VideoBlockContent, ImageBlockContent, MediaEditorProps, MediaRendererProps } from './types';
+export { VideoEditor } from './components/VideoEditor';
+export { VideoRenderer } from './components/VideoRenderer';
+export { ImageEditor } from './components/ImageEditor';
+export { ImageRenderer } from './components/ImageRenderer';
+export { useMediaUpload } from './hooks/useMediaUpload';
+export type { UseMediaUploadOptions } from './hooks/useMediaUpload';
+export { extractYouTubeId, normalizeYouTubeUrl, extractVimeoId, normalizeVimeoUrl, parseIframeSrc, detectVideoProvider, normalizeVideoUrl } from './utils/videoHelpers';
+export { calculateAspectRatio, resizeKeepingAspect, isImageUrl, extractImageFileName, formatFileSize } from './utils/imageHelpers';

package/dist/sign/media/types.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Media Module Types
+ *
+ * Tipos genéricos para gerenciamento de mídia (vídeo, imagem, áudio)
+ * em aplicações que utilizam forlogic-core.
+ */
+export interface UploadResult {
+    url: string;
+    name: string;
+    size: number;
+    type: string;
+    path: string;
+    bucket?: string;
+}
+export interface UploadOptions {
+    bucket?: string;
+    folder?: string;
+    maxSize?: number;
+    allowedTypes?: string[];
+}
+export type UploadFunction = (file: File, options?: UploadOptions) => Promise<UploadResult>;
+export interface DeleteFunction {
+    (path: string, bucket?: string): Promise<void>;
+}
+export type VideoInputType = 'url' | 'upload' | 'embed';
+export type VideoProvider = 'youtube' | 'vimeo' | 'file' | 'embed';
+export interface VideoBlockContent {
+    inputType?: VideoInputType;
+    videoUrl?: string;
+    videoFile?: string;
+    videoPath?: string;
+    videoSize?: number;
+    embedCode?: string;
+    thumbnail?: string;
+    thumbnailFile?: string;
+    thumbnailPath?: string;
+    title?: string;
+    autoplay?: boolean;
+    controls?: boolean;
+}
+export interface ImageBlockContent {
+    imageUrl?: string;
+    imageFile?: string;
+    imagePath?: string;
+    imageSize?: number;
+    caption?: string;
+    alt?: string;
+    width?: number;
+    height?: number;
+    alignment?: 'left' | 'center' | 'right';
+    allowDownload?: boolean;
+}
+export interface MediaEditorProps<T> {
+    value: T;
+    onChange: (value: T) => void;
+    onSubmit: (value: T) => void;
+    onCancel: () => void;
+    uploadFunction?: UploadFunction;
+    deleteFunction?: DeleteFunction;
+    uploadOptions?: UploadOptions;
+}
+export interface MediaRendererProps<T> {
+    content: T;
+    className?: string;
+    style?: React.CSSProperties;
+}

package/dist/sign/media/utils/imageHelpers.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Image Helpers
+ *
+ * Funções utilitárias para manipulação de imagens
+ */
+/**
+ * Calcula a proporção (aspect ratio) de uma imagem
+ */
+export declare function calculateAspectRatio(width: number, height: number): number;
+/**
+ * Redimensiona mantendo a proporção
+ */
+export declare function resizeKeepingAspect(originalWidth: number, originalHeight: number, targetWidth?: number, targetHeight?: number): {
+    width: number;
+    height: number;
+};
+/**
+ * Verifica se uma URL é de imagem baseado na extensão
+ */
+export declare function isImageUrl(src: string): boolean;
+/**
+ * Extrai o nome do arquivo de uma URL
+ */
+export declare function extractImageFileName(url: string): string;
+/**
+ * Formata tamanho de arquivo em bytes para string legível
+ */
+export declare function formatFileSize(bytes: number): string;

package/dist/sign/media/utils/videoHelpers.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Video Helpers
+ *
+ * Funções utilitárias para manipulação de URLs de vídeo
+ * (YouTube, Vimeo, etc.)
+ */
+import { VideoProvider } from '../types';
+/**
+ * Extrai o ID de um vídeo do YouTube a partir de várias URLs possíveis
+ */
+export declare function extractYouTubeId(url: string): string | null;
+/**
+ * Normaliza URL do YouTube para formato embed
+ */
+export declare function normalizeYouTubeUrl(urlOrId: string, autoplay?: boolean): string;
+/**
+ * Extrai o ID de um vídeo do Vimeo
+ */
+export declare function extractVimeoId(url: string): string | null;
+/**
+ * Normaliza URL do Vimeo para formato embed
+ */
+export declare function normalizeVimeoUrl(urlOrId: string, autoplay?: boolean): string;
+/**
+ * Extrai URL do src de um código iframe embed
+ */
+export declare function parseIframeSrc(embedCode?: string): string | undefined;
+/**
+ * Detecta o provider de um vídeo baseado na URL
+ */
+export declare function detectVideoProvider(url: string): VideoProvider;
+/**
+ * Normaliza URL de vídeo baseado no provider detectado
+ */
+export declare function normalizeVideoUrl(url: string, provider?: VideoProvider, autoplay?: boolean): string;

package/dist/sign/mind-map/components/MindMap.d.ts

@@ -0,0 +1,23 @@
+import * as React from 'react';
+import type { MindMapNode, MindMapProps } from '../types';
+/**
+ * Componente de mapa mental controlado/uncontrolled inspirado no FreeMind.
+ *
+ * @example
+ * ```tsx
+ * <MindMap defaultValue={{ id: 'root', text: 'Ideia Central' }} />
+ * ```
+ *
+ * Atalhos:
+ * - `Enter` cria um nó irmão
+ * - `Insert` ou `Tab` cria um filho
+ * - `Delete` remove o nó (e descendentes)
+ * - `F2` renomeia
+ * - `Espaço` colapsa/expande
+ * - `Ctrl+Z` / `Ctrl+Shift+Z` undo/redo
+ * - Setas para navegar
+ *
+ * Pan: arrastar o fundo. Zoom: `Ctrl/⌘ + scroll` ou botões da toolbar.
+ */
+export declare const MindMap: React.FC<MindMapProps>;
+export type { MindMapNode, MindMapProps };

package/dist/sign/mind-map/components/MindMapConnection.d.ts

@@ -0,0 +1,12 @@
+import * as React from 'react';
+import type { MindMapLayoutNode } from '../types';
+interface MindMapConnectionProps {
+    parent: MindMapLayoutNode;
+    child: MindMapLayoutNode;
+}
+/**
+ * Renderiza uma curva Bézier conectando o pai a um filho. Usa coordenadas
+ * absolutas dentro do `<svg>` do canvas.
+ */
+export declare const MindMapConnection: React.FC<MindMapConnectionProps>;
+export {};

package/dist/sign/mind-map/components/MindMapNodeView.d.ts

@@ -0,0 +1,24 @@
+import * as React from 'react';
+import type { MindMapLayoutNode, MindMapNode } from '../types';
+interface MindMapNodeViewProps {
+    layout: MindMapLayoutNode;
+    selected: boolean;
+    editing: boolean;
+    readOnly: boolean;
+    onSelect: () => void;
+    onStartEditing: () => void;
+    onFinishEditing: (newText: string | null) => void;
+    onToggle: () => void;
+    onDragStart?: (e: React.DragEvent) => void;
+    onDragOver?: (e: React.DragEvent) => void;
+    onDragLeave?: (e: React.DragEvent) => void;
+    onDrop?: (e: React.DragEvent) => void;
+    isDropTarget?: boolean;
+    renderNodeContent?: (node: MindMapNode) => React.ReactNode;
+}
+/**
+ * Renderiza a "caixa" de um nó do mapa mental: ícone opcional, texto, indicador
+ * de filhos colapsados e tooltip de nota.
+ */
+export declare const MindMapNodeView: React.FC<MindMapNodeViewProps>;
+export {};

package/dist/sign/mind-map/components/MindMapToolbar.d.ts

@@ -0,0 +1,26 @@
+import * as React from 'react';
+interface MindMapToolbarProps {
+    canAddChild: boolean;
+    canAddSibling: boolean;
+    canDelete: boolean;
+    canUndo: boolean;
+    canRedo: boolean;
+    onAddChild: () => void;
+    onAddSibling: () => void;
+    onDelete: () => void;
+    onExpandAll: () => void;
+    onCollapseAll: () => void;
+    onFit: () => void;
+    onZoomIn: () => void;
+    onZoomOut: () => void;
+    onUndo: () => void;
+    onRedo: () => void;
+    onExportJson: () => void;
+    onExportImage: () => void;
+}
+/**
+ * Toolbar superior do MindMap. Botões agrupados por função: edição, visualização,
+ * histórico e exportação.
+ */
+export declare const MindMapToolbar: React.FC<MindMapToolbarProps>;
+export {};

package/dist/sign/mind-map/hooks/useMindMapKeyboard.d.ts

@@ -0,0 +1,15 @@
+import type { MindMapLayoutResult, MindMapShortcut } from '../types';
+import type { MindMapStateApi } from './useMindMapState';
+export interface UseMindMapKeyboardOptions {
+    api: MindMapStateApi;
+    layout: MindMapLayoutResult;
+    containerRef: React.RefObject<HTMLElement>;
+    onStartEditing: (id: string) => void;
+    readOnly?: boolean;
+    extraShortcuts?: MindMapShortcut[];
+}
+/**
+ * Atalhos de teclado estilo FreeMind. Disparado apenas quando o foco está
+ * dentro do container do MindMap (e não em um input contentEditable em edição).
+ */
+export declare function useMindMapKeyboard({ api, layout, containerRef, onStartEditing, readOnly, extraShortcuts, }: UseMindMapKeyboardOptions): void;

package/dist/sign/mind-map/hooks/useMindMapLayout.d.ts

@@ -0,0 +1,5 @@
+import type { MindMapNode } from '../types';
+/**
+ * Recalcula o layout do mapa sempre que a árvore mudar. Memoizado em ref-equality.
+ */
+export declare function useMindMapLayout(root: MindMapNode): import("..").MindMapLayoutResult;

package/dist/sign/mind-map/hooks/useMindMapPanZoom.d.ts

@@ -0,0 +1,21 @@
+export interface PanZoomState {
+    x: number;
+    y: number;
+    scale: number;
+}
+/**
+ * Pan + zoom para o canvas do mapa mental. Pan via arrasto no fundo (botão esquerdo
+ * do mouse + tecla espaço, ou botão do meio); zoom via Ctrl/Meta + scroll, ou botões.
+ */
+export declare function useMindMapPanZoom(initial?: Partial<PanZoomState>): {
+    transform: PanZoomState;
+    setTransform: import("react").Dispatch<import("react").SetStateAction<PanZoomState>>;
+    zoomIn: () => void;
+    zoomOut: () => void;
+    reset: () => void;
+    fitTo: (contentW: number, contentH: number, viewportW: number, viewportH: number) => void;
+    onBackgroundPointerDown: (e: React.PointerEvent) => void;
+    onPointerMove: (e: React.PointerEvent) => void;
+    onPointerUp: (e: React.PointerEvent) => void;
+    onWheel: (e: React.WheelEvent) => void;
+};