@flowtomic/logic 0.1.0 → 0.1.2

package/dist/hooks/useGenealogy/useGenealogy.js

@@ -0,0 +1,335 @@
+/**
+ * useGenealogy - Headless UI Hook
+ *
+ * Fornece apenas: lógica, estado, processamento e API para árvores genealógicas
+ * NÃO fornece: markup, styles ou implementações pré-construídas
+ *
+ * Padrão Headless UI: você controla o markup e styles
+ */
+import { useCallback, useMemo, useState } from "react";
+/**
+ * Calcula o nível (geração) de cada entidade na hierarquia
+ * Retorna um Map com entityId -> nível (0 = raiz, 1 = filhos da raiz, etc)
+ */
+function calculateLevels(hierarchy) {
+    const levels = new Map();
+    const visited = new Set();
+    // Função recursiva para calcular nível
+    const calculateLevel = (entityId) => {
+        if (levels.has(entityId)) {
+            return levels.get(entityId);
+        }
+        if (visited.has(entityId)) {
+            // Ciclo detectado, retornar 0 como fallback
+            return 0;
+        }
+        visited.add(entityId);
+        const entityHierarchy = hierarchy.get(entityId);
+        if (!entityHierarchy || entityHierarchy.parents.length === 0) {
+            // Sem pais = raiz (nível 0)
+            levels.set(entityId, 0);
+            return 0;
+        }
+        // Nível = nível do pai mais alto + 1
+        const parentLevels = entityHierarchy.parents.map((parent) => calculateLevel(parent.id));
+        const maxParentLevel = Math.max(...parentLevels);
+        const level = maxParentLevel + 1;
+        levels.set(entityId, level);
+        return level;
+    };
+    // Calcular nível para todas as entidades
+    hierarchy.forEach((_, entityId) => {
+        calculateLevel(entityId);
+    });
+    return levels;
+}
+/**
+ * Organiza entidades por nível (geração) e calcula posições hierárquicas
+ */
+function calculateHierarchicalPositions(data, hierarchy, nodeWidth, nodeHeight, horizontalSpacing, verticalSpacing) {
+    const positions = new Map();
+    const levels = calculateLevels(hierarchy);
+    // Agrupar entidades por nível
+    const entitiesByLevel = new Map();
+    levels.forEach((level, entityId) => {
+        if (!entitiesByLevel.has(level)) {
+            entitiesByLevel.set(level, []);
+        }
+        entitiesByLevel.get(level).push(entityId);
+    });
+    // Calcular posições para cada nível, começando do nível 0 (raiz)
+    const sortedLevels = Array.from(entitiesByLevel.keys()).sort((a, b) => a - b);
+    sortedLevels.forEach((level) => {
+        const entityIds = entitiesByLevel.get(level);
+        // Ordenar entidades do mesmo nível (por ID para consistência)
+        entityIds.sort();
+        // Calcular posição Y baseada no nível (pais acima, filhos abaixo)
+        const y = level * (nodeHeight + verticalSpacing);
+        // Para cada entidade, tentar centralizar abaixo dos pais
+        entityIds.forEach((entityId) => {
+            const entityHierarchy = hierarchy.get(entityId);
+            let x = 0;
+            if (entityHierarchy && entityHierarchy.parents.length > 0) {
+                // Calcular posição média dos pais
+                const parentPositions = entityHierarchy.parents
+                    .map((parent) => positions.get(parent.id))
+                    .filter((pos) => pos !== undefined);
+                if (parentPositions.length > 0) {
+                    const avgX = parentPositions.reduce((sum, pos) => sum + pos.x, 0) / parentPositions.length;
+                    x = avgX;
+                }
+            }
+            // Se não tem pais ou não conseguiu calcular, distribuir horizontalmente
+            if (x === 0 && entityIds.length > 1) {
+                const index = entityIds.indexOf(entityId);
+                const totalWidth = entityIds.length * nodeWidth + (entityIds.length - 1) * horizontalSpacing;
+                const startX = -totalWidth / 2 + nodeWidth / 2;
+                x = startX + index * (nodeWidth + horizontalSpacing);
+            }
+            positions.set(entityId, { x, y });
+        });
+        // Ajustar posições para evitar sobreposição
+        entityIds.forEach((entityId, index) => {
+            const currentPos = positions.get(entityId);
+            const minX = currentPos.x;
+            // Verificar se há sobreposição com outros nós do mesmo nível
+            entityIds.slice(0, index).forEach((otherId) => {
+                const otherPos = positions.get(otherId);
+                if (Math.abs(currentPos.x - otherPos.x) < nodeWidth + horizontalSpacing) {
+                    // Ajustar para evitar sobreposição
+                    currentPos.x = otherPos.x + nodeWidth + horizontalSpacing;
+                }
+            });
+        });
+    });
+    return positions;
+}
+/**
+ * Gera nodes do ReactFlow a partir dos dados de genealogia
+ */
+function generateNodes(data, hierarchy, expansionState, nodeWidth, nodeHeight, horizontalSpacing, verticalSpacing) {
+    const nodes = [];
+    // Calcular posições hierárquicas
+    const positions = calculateHierarchicalPositions(data, hierarchy, nodeWidth, nodeHeight, horizontalSpacing, verticalSpacing);
+    // Criar nodes com posições calculadas
+    data.people.forEach((entity) => {
+        const position = positions.get(entity.id) || { x: 0, y: 0 };
+        const entityHierarchy = hierarchy.get(entity.id);
+        nodes.push({
+            id: entity.id,
+            type: "genealogy",
+            position,
+            data: {
+                person: entity,
+                hierarchy: entityHierarchy,
+                isExpanded: expansionState[entity.id] ?? false,
+            },
+        });
+    });
+    return nodes;
+}
+/**
+ * Gera edges do ReactFlow a partir dos relacionamentos
+ * Para hierarquia vertical: source (pai) -> target (filho)
+ */
+function generateEdges(data, hierarchy, expansionState) {
+    const edges = [];
+    const edgeIds = new Set();
+    data.relationships.forEach((relationship) => {
+        // Determinar source e target baseado no tipo de relacionamento
+        let source;
+        let target;
+        switch (relationship.type) {
+            case "father":
+            case "mother": {
+                // from é pai/mãe de to
+                // source = pai (from), target = filho (to)
+                source = relationship.from;
+                target = relationship.to;
+                break;
+            }
+            case "child": {
+                // from é filho de to
+                // source = pai (to), target = filho (from)
+                source = relationship.to;
+                target = relationship.from;
+                break;
+            }
+            default: {
+                source = relationship.from;
+                target = relationship.to;
+            }
+        }
+        // Criar edge ID único
+        const edgeId = `e-${source}-${target}-${relationship.type}`;
+        // Evitar duplicatas
+        if (edgeIds.has(edgeId)) {
+            return;
+        }
+        edgeIds.add(edgeId);
+        // Verificar se ambos os nós existem
+        const sourceHierarchy = hierarchy.get(source);
+        const targetHierarchy = hierarchy.get(target);
+        if (!sourceHierarchy || !targetHierarchy) {
+            return;
+        }
+        // Só criar edge se ambos os nós estiverem visíveis (expandidos ou raiz)
+        const sourceExpanded = expansionState[source] ?? true;
+        const targetExpanded = expansionState[target] ?? true;
+        // Para relacionamentos pai/filho, só mostrar se o nó pai estiver expandido
+        if (relationship.type === "father" ||
+            relationship.type === "mother" ||
+            relationship.type === "child") {
+            if (!sourceExpanded || !targetExpanded)
+                return;
+        }
+        edges.push({
+            id: edgeId,
+            source,
+            target,
+            type: "animated",
+            data: {
+                relationship,
+            },
+        });
+    });
+    return edges;
+}
+/**
+ * Constrói hierarquia de entidades a partir dos dados
+ */
+function buildHierarchy(data) {
+    const hierarchy = new Map();
+    // Inicializar todas as entidades
+    data.people.forEach((entity) => {
+        hierarchy.set(entity.id, {
+            person: entity,
+            parents: [],
+            children: [],
+            adoptions: [],
+            siblings: [],
+        });
+    });
+    // Processar relacionamentos
+    data.relationships.forEach((relationship) => {
+        const fromHierarchy = hierarchy.get(relationship.from);
+        const toHierarchy = hierarchy.get(relationship.to);
+        if (!fromHierarchy || !toHierarchy)
+            return;
+        switch (relationship.type) {
+            case "father":
+            case "mother": {
+                // from é pai/mãe de to
+                if (!toHierarchy.parents.find((p) => p.id === relationship.from)) {
+                    toHierarchy.parents.push(fromHierarchy.person);
+                }
+                if (relationship.type === "father") {
+                    toHierarchy.father = fromHierarchy.person;
+                }
+                else if (relationship.type === "mother") {
+                    toHierarchy.mother = fromHierarchy.person;
+                }
+                if (!fromHierarchy.children.find((c) => c.id === relationship.to)) {
+                    fromHierarchy.children.push(toHierarchy.person);
+                }
+                break;
+            }
+            case "child": {
+                // from é filho de to
+                if (!toHierarchy.children.find((c) => c.id === relationship.from)) {
+                    toHierarchy.children.push(fromHierarchy.person);
+                }
+                if (!fromHierarchy.parents.find((p) => p.id === relationship.to)) {
+                    fromHierarchy.parents.push(toHierarchy.person);
+                }
+                break;
+            }
+        }
+    });
+    // Calcular irmãos (pessoas com os mesmos pais)
+    hierarchy.forEach((personHierarchy) => {
+        if (personHierarchy.parents.length > 0) {
+            const parentIds = personHierarchy.parents.map((p) => p.id);
+            hierarchy.forEach((otherHierarchy, otherId) => {
+                if (otherId !== personHierarchy.person.id) {
+                    const hasCommonParent = otherHierarchy.parents.some((p) => parentIds.includes(p.id));
+                    if (hasCommonParent && !personHierarchy.siblings.find((s) => s.id === otherId)) {
+                        personHierarchy.siblings.push(otherHierarchy.person);
+                    }
+                }
+            });
+        }
+    });
+    return hierarchy;
+}
+/**
+ * Hook headless para gerenciar árvores genealógicas
+ */
+export function useGenealogy({ data, initialExpanded = [], nodeWidth = 200, nodeHeight = 100, horizontalSpacing = 250, verticalSpacing = 150, onNodeSelect, onNodeExpand, onAddRelation, }) {
+    // Estado de expansão dos nós
+    const [expansionState, setExpansionState] = useState(() => {
+        const state = {};
+        initialExpanded.forEach((id) => {
+            state[id] = true;
+        });
+        return state;
+    });
+    // Estado de seleção
+    const [selectedNodeId, setSelectedNodeId] = useState(null);
+    // Construir hierarquia
+    const hierarchy = useMemo(() => buildHierarchy(data), [data]);
+    // Gerar nodes e edges
+    const nodes = useMemo(() => generateNodes(data, hierarchy, expansionState, nodeWidth, nodeHeight, horizontalSpacing, verticalSpacing), [data, hierarchy, expansionState, nodeWidth, nodeHeight, horizontalSpacing, verticalSpacing]);
+    const edges = useMemo(() => generateEdges(data, hierarchy, expansionState), [data, hierarchy, expansionState]);
+    // Função para selecionar um nó
+    const selectNode = useCallback((nodeId) => {
+        setSelectedNodeId(nodeId);
+        const entity = data.people.find((p) => p.id === nodeId);
+        if (entity && onNodeSelect) {
+            onNodeSelect(nodeId, entity);
+        }
+    }, [data.people, onNodeSelect]);
+    // Função para expandir/colapsar um nó
+    const expandNode = useCallback((nodeId, expanded) => {
+        setExpansionState((prev) => {
+            const newState = { ...prev };
+            const isCurrentlyExpanded = prev[nodeId] ?? false;
+            newState[nodeId] = expanded ?? !isCurrentlyExpanded;
+            if (onNodeExpand) {
+                onNodeExpand(nodeId, newState[nodeId]);
+            }
+            return newState;
+        });
+    }, [onNodeExpand]);
+    // Função para colapsar um nó
+    const collapseNode = useCallback((nodeId) => {
+        expandNode(nodeId, false);
+    }, [expandNode]);
+    // Função para adicionar relacionamento
+    const addRelation = useCallback((fromId, toId, type) => {
+        if (onAddRelation) {
+            onAddRelation(fromId, toId, type);
+        }
+    }, [onAddRelation]);
+    // Função para obter hierarquia de uma pessoa
+    const getPersonHierarchy = useCallback((personId) => {
+        return hierarchy.get(personId);
+    }, [hierarchy]);
+    // Função para obter relacionamentos de uma pessoa
+    const getPersonRelations = useCallback((personId) => {
+        return data.relationships.filter((r) => r.from === personId || r.to === personId);
+    }, [data.relationships]);
+    return {
+        nodes,
+        edges,
+        hierarchy,
+        selectedNodeId,
+        expansionState,
+        selectNode,
+        expandNode,
+        collapseNode,
+        addRelation,
+        getPersonHierarchy,
+        getPersonRelations,
+    };
+}