forlogic-core 2.2.1 → 2.2.3

package/dist/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/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/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/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/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/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/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;
+};

package/dist/mind-map/hooks/useMindMapState.d.ts

@@ -0,0 +1,32 @@
+import type { MindMapNode } from '../types';
+export interface UseMindMapStateOptions {
+    value?: MindMapNode;
+    defaultValue?: MindMapNode;
+    onChange?: (root: MindMapNode) => void;
+    readOnly?: boolean;
+}
+/**
+ * Estado central do MindMap: árvore controlada/uncontrolled, seleção e histórico
+ * de undo/redo. Expõe ações imutáveis (sempre produzem nova árvore).
+ */
+export declare function useMindMapState(opts: UseMindMapStateOptions): {
+    root: MindMapNode;
+    setRoot: (next: MindMapNode) => void;
+    selectedId: string;
+    selectedNode: MindMapNode;
+    setSelectedId: import("react").Dispatch<import("react").SetStateAction<string>>;
+    renameNode: (id: string, text: string) => void;
+    updateNodeProps: (id: string, patch: Partial<MindMapNode>) => void;
+    addChild: (parentId: string, text?: string) => string;
+    addSibling: (nodeId: string, text?: string) => string;
+    removeNode: (id: string) => void;
+    moveNode: (id: string, newParentId: string) => void;
+    toggleNode: (id: string) => void;
+    expandAll: () => void;
+    collapseAll: () => void;
+    undo: () => void;
+    redo: () => void;
+    canUndo: boolean;
+    canRedo: boolean;
+};
+export type MindMapStateApi = ReturnType<typeof useMindMapState>;

package/dist/mind-map/index.d.ts

@@ -0,0 +1,4 @@
+export { MindMap } from './components/MindMap';
+export { createMindMapNode, findNode, addChild, addSibling, removeNode, moveNode, toggleCollapsed, setCollapsedAll, generateNodeId, } from './utils/nodeOps';
+export { exportMindMap, importMindMap } from './utils/serialize';
+export type { MindMapNode, MindMapProps, MindMapShortcut, MindMapContext, MindMapLayoutNode, MindMapLayoutResult, } from './types';

package/dist/mind-map/types.d.ts

@@ -0,0 +1,91 @@
+import type * as React from 'react';
+/**
+ * Nó do mapa mental. Estrutura recursiva e serializável.
+ */
+export interface MindMapNode {
+    /** Identificador único do nó. */
+    id: string;
+    /** Texto principal exibido na caixa do nó. */
+    text: string;
+    /** Filhos do nó (opcional). */
+    children?: MindMapNode[];
+    /** Quando true, oculta a subárvore visualmente (mas preserva no modelo). */
+    collapsed?: boolean;
+    /** Cor de fundo da caixa do nó. Aceita hex/HSL/qualquer valor CSS válido. */
+    color?: string;
+    /** Nome de um ícone Lucide a exibir antes do texto (ex: "Star"). */
+    icon?: string;
+    /** Texto longo opcional, exibido em tooltip por um ícone na caixa. */
+    note?: string;
+    /** Lado em relação à raiz. Apenas filhos diretos da raiz definem livremente. */
+    side?: 'left' | 'right';
+}
+/**
+ * Snapshot da posição calculada de um nó, usado pelo layout.
+ */
+export interface MindMapLayoutNode {
+    node: MindMapNode;
+    parent: MindMapNode | null;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    side: 'left' | 'right' | 'root';
+    depth: number;
+    visibleChildren: MindMapLayoutNode[];
+}
+/**
+ * Resultado completo do cálculo de layout.
+ */
+export interface MindMapLayoutResult {
+    nodes: MindMapLayoutNode[];
+    byId: Map<string, MindMapLayoutNode>;
+    width: number;
+    height: number;
+}
+/**
+ * Contexto exposto a atalhos custom.
+ */
+export interface MindMapContext {
+    selectedId: string | null;
+    root: MindMapNode;
+    setRoot: (next: MindMapNode) => void;
+    select: (id: string | null) => void;
+}
+/**
+ * Atalho de teclado adicional para o MindMap.
+ */
+export interface MindMapShortcut {
+    /** Chave (ex: "k", "F2", "Enter"). */
+    key: string;
+    /** Modificadores opcionais. */
+    ctrl?: boolean;
+    shift?: boolean;
+    alt?: boolean;
+    handler: (ctx: MindMapContext) => void;
+}
+/**
+ * Props do componente `MindMap`.
+ */
+export interface MindMapProps {
+    /** Modo controlado: árvore atual. */
+    value?: MindMapNode;
+    /** Modo não-controlado: árvore inicial. */
+    defaultValue?: MindMapNode;
+    /** Callback chamado a cada mutação aplicada. */
+    onChange?: (root: MindMapNode) => void;
+    /** Callback ao selecionar um nó. */
+    onNodeSelect?: (node: MindMapNode | null) => void;
+    /** Modo somente leitura (sem edição/atalhos de mutação). */
+    readOnly?: boolean;
+    /** Esconde a toolbar superior. */
+    hideToolbar?: boolean;
+    /** Atalhos custom adicionais (são processados depois dos padrão). */
+    extraShortcuts?: MindMapShortcut[];
+    /** Render custom do conteúdo interno do nó (ícone + texto). */
+    renderNodeContent?: (node: MindMapNode) => React.ReactNode;
+    /** Classe extra no container raiz. */
+    className?: string;
+    /** Altura do canvas. Default 600px. */
+    height?: string | number;
+}

package/dist/mind-map/utils/export-image.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Exporta o SVG do mapa mental como PNG, abrindo o resultado em download
+ * pelo browser. Usa um canvas off-screen para rasterizar o SVG.
+ */
+export declare function exportSvgAsPng(svg: SVGSVGElement, filename?: string): Promise<void>;
+/**
+ * Faz download de uma string como arquivo (utilitário interno).
+ */
+export declare function downloadTextFile(content: string, filename: string, mime?: string): void;

package/dist/mind-map/utils/layout.d.ts

@@ -0,0 +1,15 @@
+import type { MindMapLayoutResult, MindMapNode } from '../types';
+/**
+ * Calcula o layout de um mapa mental: posições absolutas (x,y), tamanhos e
+ * dimensão total do canvas. Compatível com pan/zoom externos via transform.
+ */
+export declare function computeLayout(root: MindMapNode): MindMapLayoutResult;
+export declare const MIND_MAP_LAYOUT_CONSTANTS: {
+    NODE_WIDTH: number;
+    NODE_HEIGHT: number;
+    ROOT_WIDTH: number;
+    ROOT_HEIGHT: number;
+    H_GAP: number;
+    V_GAP: number;
+    PADDING: number;
+};

package/dist/mind-map/utils/nodeOps.d.ts

@@ -0,0 +1,66 @@
+import type { MindMapNode } from '../types';
+/**
+ * Gera um id curto e único o suficiente para uso local em árvores de mapas mentais.
+ */
+export declare function generateNodeId(): string;
+/**
+ * Cria um novo `MindMapNode` com defaults seguros.
+ */
+export declare function createMindMapNode(text: string, partial?: Partial<MindMapNode>): MindMapNode;
+/**
+ * Procura um nó pelo id e retorna o nó + seu pai (ou null).
+ */
+export declare function findNode(root: MindMapNode, id: string): {
+    node: MindMapNode;
+    parent: MindMapNode | null;
+} | null;
+/**
+ * Retorna true se `ancestorId` está na cadeia ancestral de `descendantId`.
+ */
+export declare function isAncestor(root: MindMapNode, ancestorId: string, descendantId: string): boolean;
+/**
+ * Atualiza um nó por id retornando uma nova árvore.
+ */
+export declare function updateNode(root: MindMapNode, id: string, updater: (n: MindMapNode) => MindMapNode): MindMapNode;
+/**
+ * Adiciona um filho a um nó. Para filhos diretos da raiz, escolhe automaticamente
+ * o lado com menos nós (balanceia ramos).
+ */
+export declare function addChild(root: MindMapNode, parentId: string, text: string): {
+    root: MindMapNode;
+    newId: string;
+};
+/**
+ * Adiciona um irmão (mesmo pai) logo após o nó referência.
+ */
+export declare function addSibling(root: MindMapNode, nodeId: string, text: string): {
+    root: MindMapNode;
+    newId: string;
+};
+/**
+ * Remove um nó (e descendentes). Não permite remover a raiz.
+ */
+export declare function removeNode(root: MindMapNode, id: string): {
+    root: MindMapNode;
+    nextSelectedId: string | null;
+};
+/**
+ * Move um nó para um novo pai. Retorna a árvore inalterada se o destino for
+ * o próprio nó ou um descendente (evita ciclo).
+ */
+export declare function moveNode(root: MindMapNode, id: string, newParentId: string): MindMapNode;
+/**
+ * Alterna `collapsed` em um nó.
+ */
+export declare function toggleCollapsed(root: MindMapNode, id: string): MindMapNode;
+/**
+ * Define `collapsed` em todos os nós com filhos.
+ */
+export declare function setCollapsedAll(root: MindMapNode, collapsed: boolean): MindMapNode;
+/**
+ * Retorna lista linear (DFS) de todos os nós + pai, respeitando collapsed.
+ */
+export declare function flattenVisible(root: MindMapNode): Array<{
+    node: MindMapNode;
+    parent: MindMapNode | null;
+}>;

package/dist/mind-map/utils/serialize.d.ts

@@ -0,0 +1,10 @@
+import type { MindMapNode } from '../types';
+/**
+ * Serializa a árvore como JSON formatado.
+ */
+export declare function exportMindMap(root: MindMapNode): string;
+/**
+ * Desserializa uma string JSON em um `MindMapNode` validado.
+ * Lança em caso de JSON inválido ou estrutura incompatível.
+ */
+export declare function importMindMap(json: string): MindMapNode;

package/dist/supabase/legacyKeyGuard.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Detecta se a VITE_SUPABASE_PUBLISHABLE_KEY é uma legacy anon key (JWT)
+ * e oferece fallback via VITE_SUPABASE_PK_OVERRIDE.
+ *
+ * O Supabase desativou legacy API keys — a nova key usa formato `sb_publishable_*`.
+ * O Lovable auto-regenera o .env sobrescrevendo VITE_SUPABASE_PUBLISHABLE_KEY com a
+ * legacy key. Para contornar, os projetos podem definir VITE_SUPABASE_PK_OVERRIDE
+ * que o Lovable nunca toca.
+ */
+/** Retorna true se a key é um JWT legado (começa com `eyJ`). */
+export declare function isLegacyAnonKey(key: string | undefined): boolean;
+/**
+ * Resolve a publishable key correta:
+ * 1. Se VITE_SUPABASE_PK_OVERRIDE existe → usa ela (ignora a outra)
+ * 2. Senão → usa VITE_SUPABASE_PUBLISHABLE_KEY
+ */
+export declare function resolvePublishableKey(): string;
+/** Verifica a env var e loga erro/info no console (uma única vez). Retorna true se legada sem override. */
+export declare function warnIfLegacyKey(): boolean;