@runtypelabs/react-flow 1.0.39 → 1.0.41

package/src/utils/layout.ts

@@ -1,8 +1,5 @@
 import type { RuntypeNode, RuntypeEdge } from '../types'
 
-// ============================================================================
-// Layout Constants
-// ============================================================================
 
 const DEFAULT_NODE_WIDTH = 280
 const DEFAULT_NODE_HEIGHT = 150
@@ -10,9 +7,6 @@ const HORIZONTAL_SPACING = 100
 const VERTICAL_SPACING = 80
 const BRANCH_OFFSET = 350
 
-// ============================================================================
-// Auto Layout Algorithm
-// ============================================================================
 
 export interface LayoutOptions {
   /** Direction of the flow */
@@ -47,7 +41,6 @@ export function autoLayout(
     branchOffset = BRANCH_OFFSET,
   } = options
 
-  // Build adjacency map from edges
   const adjacencyMap = new Map<string, string[]>()
   const incomingMap = new Map<string, string[]>()
 
@@ -59,25 +52,20 @@ export function autoLayout(
     incomingMap.set(edge.target, [...incoming, edge.source])
   }
 
-  // Find root nodes (nodes with no incoming edges)
   const rootNodes = nodes.filter((node) => {
     const incoming = incomingMap.get(node.id)
     return !incoming || incoming.length === 0
   })
 
-  // If no root nodes found, use the first node
   if (rootNodes.length === 0 && nodes.length > 0) {
     rootNodes.push(nodes[0])
   }
 
-  // Track positioned nodes
   const positionedNodes = new Map<string, { x: number; y: number }>()
   const visited = new Set<string>()
 
-  // Position nodes using BFS
   const queue: Array<{ nodeId: string; x: number; y: number; depth: number }> = []
 
-  // Start with root nodes
   let startX = startPosition.x
   for (const rootNode of rootNodes) {
     queue.push({ nodeId: rootNode.id, x: startX, y: startPosition.y, depth: 0 })
@@ -92,20 +80,16 @@ export function autoLayout(
 
     positionedNodes.set(nodeId, { x, y })
 
-    // Get children
     const children = adjacencyMap.get(nodeId) || []
     const node = nodes.find((n) => n.id === nodeId)
 
-    // Check if this is a conditional node
     const isConditional = node?.data.step.type === 'conditional'
 
     if (isConditional && children.length > 0) {
-      // Position conditional branches side by side
       const trueBranch = children.filter((c) => c.includes('-true-'))
       const falseBranch = children.filter((c) => c.includes('-false-'))
       const normalChildren = children.filter((c) => !c.includes('-true-') && !c.includes('-false-'))
 
-      // Position true branch to the right
       let trueY = y + nodeHeight + verticalSpacing
       for (const childId of trueBranch) {
         if (!visited.has(childId)) {
@@ -119,7 +103,6 @@ export function autoLayout(
         }
       }
 
-      // Position false branch to the left
       let falseY = y + nodeHeight + verticalSpacing
       for (const childId of falseBranch) {
         if (!visited.has(childId)) {
@@ -133,7 +116,6 @@ export function autoLayout(
         }
       }
 
-      // Position normal children below
       const maxBranchY = Math.max(trueY, falseY)
       let childY = maxBranchY
       for (const childId of normalChildren) {
@@ -148,7 +130,6 @@ export function autoLayout(
         }
       }
     } else {
-      // Position children in sequence
       let childY = y + nodeHeight + verticalSpacing
       let childX = x
 
@@ -177,7 +158,6 @@ export function autoLayout(
     }
   }
 
-  // Apply positions to nodes
   return nodes.map((node) => {
     const position = positionedNodes.get(node.id)
     if (position) {
@@ -200,7 +180,6 @@ export function centerNodes(
 ): RuntypeNode[] {
   if (nodes.length === 0) return nodes
 
-  // Calculate bounding box
   let minX = Infinity
   let maxX = -Infinity
   let minY = Infinity
@@ -213,13 +192,11 @@ export function centerNodes(
     maxY = Math.max(maxY, node.position.y + DEFAULT_NODE_HEIGHT)
   }
 
-  // Calculate offset to center
   const contentWidth = maxX - minX
   const contentHeight = maxY - minY
   const offsetX = (viewportWidth - contentWidth) / 2 - minX
   const offsetY = (viewportHeight - contentHeight) / 2 - minY
 
-  // Apply offset
   return nodes.map((node) => ({
     ...node,
     position: {

package/tsup.config.ts

@@ -3,8 +3,6 @@ import { defineConfig } from 'tsup'
 export default defineConfig({
   entry: ['src/index.ts'],
   format: ['cjs', 'esm'],
-  // DTS generation disabled due to React version conflicts in the monorepo
-  // Types are exported from src/types/index.ts and can be imported directly
   dts: false,
   splitting: false,
   sourcemap: false,

package/.turbo/turbo-build.log

@@ -1,13 +0,0 @@
-$ tsup
-CLI Building entry: src/index.ts
-CLI Using tsconfig: tsconfig.json
-CLI tsup v8.5.1
-CLI Using tsup config: /home/runner/actions-runner/_work/core/core/packages/react-flow/tsup.config.ts
-CLI Target: es2020
-CLI Cleaning output folder
-CJS Build start
-ESM Build start
-ESM dist/index.mjs 101.48 KB
-ESM ⚡️ Build success in 984ms
-CJS dist/index.js 105.53 KB
-CJS ⚡️ Build success in 985ms