@hayro_o7/labyrinth 0.0.3 → 0.0.4

package/dist/algorithms/bidirectional-bfs.d.ts

@@ -0,0 +1,6 @@
+import type { GeneralGraph, BFSResult } from '../types';
+export declare function bidirectionalBFS(graph: GeneralGraph, startId: string, endId: string): BFSResult;
+export declare function findOptimalMultiGoalPath(graph: GeneralGraph, startId: string, goalIds: string[]): {
+    optimalPath: string[];
+    allPaths: Map<string, Map<string, string[]>>;
+};

package/dist/algorithms/bidirectional-bfs.js

@@ -0,0 +1,153 @@
+export function bidirectionalBFS(graph, startId, endId) {
+    const steps = [];
+    // Forward search from start
+    const forwardQueue = [[startId]];
+    const forwardVisited = new Map();
+    forwardVisited.set(startId, [startId]);
+    // Backward search from end
+    const backwardQueue = [[endId]];
+    const backwardVisited = new Map();
+    backwardVisited.set(endId, [endId]);
+    steps.push({ nodeId: startId, type: 'start-forward', side: 'forward', level: 0 });
+    steps.push({ nodeId: endId, type: 'start-backward', side: 'backward', level: 0 });
+    let level = 0;
+    while (forwardQueue.length > 0 && backwardQueue.length > 0) {
+        level++;
+        // Process entire forward level
+        const forwardLevelSize = forwardQueue.length;
+        const forwardNewLevel = [];
+        for (let i = 0; i < forwardLevelSize; i++) {
+            const currentPath = forwardQueue.shift();
+            const currentId = currentPath[currentPath.length - 1];
+            steps.push({ nodeId: currentId, type: 'current-forward', side: 'forward', level });
+            const currentNode = graph.nodes.get(currentId);
+            if (!currentNode)
+                continue;
+            for (const neighborId of currentNode.neighbors) {
+                // Check for intersection with backward search
+                if (backwardVisited.has(neighborId)) {
+                    const backwardPath = backwardVisited.get(neighborId);
+                    const fullPath = [...currentPath, ...backwardPath.slice().reverse()];
+                    steps.push({ nodeId: neighborId, type: 'intersection', level });
+                    // Mark final path
+                    for (const nodeId of fullPath) {
+                        steps.push({ nodeId, type: 'path' });
+                    }
+                    return {
+                        path: fullPath,
+                        steps,
+                        found: true,
+                        intersectionNode: neighborId
+                    };
+                }
+                if (!forwardVisited.has(neighborId)) {
+                    const newPath = [...currentPath, neighborId];
+                    forwardVisited.set(neighborId, newPath);
+                    forwardNewLevel.push(newPath);
+                    steps.push({ nodeId: neighborId, type: 'goal-forward', side: 'forward', level });
+                }
+            }
+            steps.push({ nodeId: currentId, type: 'visited-forward', side: 'forward', level });
+        }
+        forwardQueue.push(...forwardNewLevel);
+        // Process entire backward level
+        const backwardLevelSize = backwardQueue.length;
+        const backwardNewLevel = [];
+        for (let i = 0; i < backwardLevelSize; i++) {
+            const currentPath = backwardQueue.shift();
+            const currentId = currentPath[currentPath.length - 1];
+            steps.push({ nodeId: currentId, type: 'current-backward', side: 'backward', level });
+            const currentNode = graph.nodes.get(currentId);
+            if (!currentNode)
+                continue;
+            for (const neighborId of currentNode.neighbors) {
+                // Check for intersection with forward search
+                if (forwardVisited.has(neighborId)) {
+                    const forwardPath = forwardVisited.get(neighborId);
+                    const fullPath = [...forwardPath, ...currentPath.slice().reverse()];
+                    steps.push({ nodeId: neighborId, type: 'intersection', level });
+                    // Mark final path
+                    for (const nodeId of fullPath) {
+                        steps.push({ nodeId, type: 'path' });
+                    }
+                    return {
+                        path: fullPath,
+                        steps,
+                        found: true,
+                        intersectionNode: neighborId
+                    };
+                }
+                if (!backwardVisited.has(neighborId)) {
+                    const newPath = [...currentPath, neighborId];
+                    backwardVisited.set(neighborId, newPath);
+                    backwardNewLevel.push(newPath);
+                    steps.push({ nodeId: neighborId, type: 'goal-backward', side: 'backward', level });
+                }
+            }
+            steps.push({ nodeId: currentId, type: 'visited-backward', side: 'backward', level });
+        }
+        backwardQueue.push(...backwardNewLevel);
+    }
+    return {
+        path: [],
+        steps,
+        found: false
+    };
+}
+function permutations(arr) {
+    if (arr.length <= 1)
+        return [arr];
+    const result = [];
+    for (let i = 0; i < arr.length; i++) {
+        const rest = [...arr.slice(0, i), ...arr.slice(i + 1)];
+        const perms = permutations(rest);
+        for (const perm of perms) {
+            result.push([arr[i], ...perm]);
+        }
+    }
+    return result;
+}
+export function findOptimalMultiGoalPath(graph, startId, goalIds) {
+    const allPaths = new Map();
+    // Compute paths between all pairs
+    const allNodes = [startId, ...goalIds];
+    for (const from of allNodes) {
+        const pathsFrom = new Map();
+        for (const to of allNodes) {
+            if (from !== to) {
+                const result = bidirectionalBFS(graph, from, to);
+                if (result.found) {
+                    pathsFrom.set(to, result.path);
+                }
+            }
+        }
+        allPaths.set(from, pathsFrom);
+    }
+    // Try all permutations to find shortest tour
+    let shortestPath = [];
+    let shortestLength = Infinity;
+    const goalPermutations = permutations(goalIds);
+    for (const perm of goalPermutations) {
+        const tour = [startId, ...perm];
+        let totalPath = [];
+        let valid = true;
+        for (let i = 0; i < tour.length - 1; i++) {
+            const segment = allPaths.get(tour[i])?.get(tour[i + 1]);
+            if (!segment) {
+                valid = false;
+                break;
+            }
+            if (i === 0) {
+                totalPath = [...segment];
+            }
+            else {
+                totalPath = [...totalPath.slice(0, -1), ...segment];
+            }
+        }
+        if (valid && totalPath.length < shortestLength) {
+            shortestPath = totalPath;
+            shortestLength = totalPath.length;
+        }
+    }
+    return { optimalPath: shortestPath, allPaths };
+}

package/dist/components/GraphVisualizer.svelte

@@ -0,0 +1,449 @@
+<script lang="ts">
+	import type { GeneralGraph, BFSStep, ColorScheme, LabyrinthControls } from '../types';
+	import { bidirectionalBFS, findOptimalMultiGoalPath } from '../algorithms/bidirectional-bfs';
+
+	interface Props {
+		graph: GeneralGraph;
+		startNode?: string;
+		goalNodes?: string[];
+		nodeRadius?: number;
+		autoPlay?: boolean;
+		buttons?: boolean;
+		legend?: boolean;
+		stepCount?: boolean;
+		animationSpeed?: number;
+		colors?: ColorScheme;
+		showMultiGoal?: boolean;
+		onControls?: (controls: LabyrinthControls) => void;
+	}
+
+	let {
+		graph,
+		startNode,
+		goalNodes = [],
+		nodeRadius = 20,
+		autoPlay = false,
+		buttons = true,
+		legend = true,
+		stepCount = true,
+		animationSpeed = 100,
+		colors,
+		showMultiGoal = false,
+		onControls
+	}: Props = $props();
+
+	const defaultColors: Required<ColorScheme> = {
+		start: '#22c55e',
+		end: '#ef4444',
+		current: '#f59e0b',
+		visiting: '#fef3c7',
+		visited: '#e5e7eb',
+		path: '#3b82f6',
+		background: '#ffffff',
+		wall: '#1f2937',
+		grid: '#e5e7eb',
+		legend: '#f9fafb',
+		legendtext: '#1f2937',
+		buttons: '#3b82f6',
+		buttonshover: '#2563eb',
+		buttonsdisabled: '#9ca3af',
+		buttonstext: '#ffffff'
+	};
+
+	const colorScheme = $derived({ ...defaultColors, ...colors });
+	
+	const nodeIds = $derived(Array.from(graph.nodes.keys()));
+	const computedStartNode = $derived(startNode ?? nodeIds[0]);
+	const computedGoalNodes = $derived(
+		goalNodes.length > 0 ? goalNodes : [nodeIds[Math.floor(nodeIds.length / 2)]]
+	);
+
+	const cssVars = $derived(
+		`--graph-buttons:${colorScheme.buttons};
+		--graph-buttonstext:${colorScheme.buttonstext};
+		--graph-buttonshover:${colorScheme.buttonshover};
+		--graph-buttonsdisabled:${colorScheme.buttonsdisabled};
+		--graph-legend:${colorScheme.legend};
+		--graph-legend-text:${colorScheme.legendtext};`
+	);
+
+	let currentStepIndex = $state(0);
+	let isPlaying = $state(false);
+	let steps: BFSStep[] = $state([]);
+	let intervalId: number | null = null;
+	let optimalPath: string[] = $state([]);
+
+	const forwardVisitedNodes = $derived(
+		new Set(
+			steps
+				.slice(0, currentStepIndex)
+				.filter((s) => s.type === 'visited-forward')
+				.map((s) => s.nodeId)
+		)
+	);
+
+	const backwardVisitedNodes = $derived(
+		new Set(
+			steps
+				.slice(0, currentStepIndex)
+				.filter((s) => s.type === 'visited-backward')
+				.map((s) => s.nodeId)
+		)
+	);
+
+	const forwardFrontier = $derived(
+		new Set(
+			steps
+				.slice(0, currentStepIndex)
+				.filter((s) => s.type === 'goal-forward')
+				.map((s) => s.nodeId)
+		)
+	);
+
+	const backwardFrontier = $derived(
+		new Set(
+			steps
+				.slice(0, currentStepIndex)
+				.filter((s) => s.type === 'goal-backward')
+				.map((s) => s.nodeId)
+		)
+	);
+
+	const currentForwardNode = $derived(
+		steps[currentStepIndex - 1]?.type === 'current-forward'
+			? steps[currentStepIndex - 1]?.nodeId
+			: null
+	);
+
+	const currentBackwardNode = $derived(
+		steps[currentStepIndex - 1]?.type === 'current-backward'
+			? steps[currentStepIndex - 1]?.nodeId
+			: null
+	);
+
+	const intersectionNode = $derived(
+		steps.slice(0, currentStepIndex).find((s) => s.type === 'intersection')?.nodeId
+	);
+
+	const pathNodes = $derived(
+		new Set(steps.slice(0, currentStepIndex).filter((s) => s.type === 'path').map((s) => s.nodeId))
+	);
+
+	function runAlgorithm() {
+		if (showMultiGoal && computedGoalNodes.length > 1) {
+			const result = findOptimalMultiGoalPath(graph, computedStartNode, computedGoalNodes);
+			optimalPath = result.optimalPath;
+			
+			// Generate visualization steps for the optimal path
+			steps = [];
+			for (const nodeId of optimalPath) {
+				steps.push({ nodeId, type: 'path' });
+			}
+		} else {
+			const result = bidirectionalBFS(graph, computedStartNode, computedGoalNodes[0]);
+			steps = result.steps;
+			optimalPath = result.path;
+		}
+		currentStepIndex = 0;
+	}
+
+	$effect(() => {
+		computedStartNode;
+		computedGoalNodes;
+		reset();
+	});
+
+	function play() {
+		if (steps.length === 0) {
+			runAlgorithm();
+		}
+
+		isPlaying = true;
+		intervalId = window.setInterval(() => {
+			if (currentStepIndex < steps.length) {
+				currentStepIndex++;
+			} else {
+				pause();
+			}
+		}, animationSpeed);
+	}
+
+	function pause() {
+		isPlaying = false;
+		if (intervalId !== null) {
+			clearInterval(intervalId);
+			intervalId = null;
+		}
+	}
+
+	function reset() {
+		pause();
+		currentStepIndex = 0;
+		steps = [];
+		optimalPath = [];
+	}
+
+	function stepForward() {
+		if (steps.length === 0) {
+			runAlgorithm();
+		}
+		if (currentStepIndex < steps.length) {
+			currentStepIndex++;
+		}
+	}
+
+	function stepBackward() {
+		if (currentStepIndex > 0) {
+			currentStepIndex--;
+		}
+	}
+
+	function getNodeColor(nodeId: string): string {
+		if (nodeId === computedStartNode) return colorScheme.start;
+		if (computedGoalNodes.includes(nodeId)) return colorScheme.end;
+		if (pathNodes.has(nodeId)) return colorScheme.path;
+		if (nodeId === intersectionNode) return '#a855f7';
+		if (nodeId === currentForwardNode) return colorScheme.current;
+		if (nodeId === currentBackwardNode) return '#f97316';
+		if (forwardVisitedNodes.has(nodeId)) return colorScheme.visited;
+		if (backwardVisitedNodes.has(nodeId)) return '#fecaca';
+		if (forwardFrontier.has(nodeId)) return colorScheme.visiting;
+		if (backwardFrontier.has(nodeId)) return '#fed7aa';
+		return colorScheme.background;
+	}
+
+	function getNodeStroke(nodeId: string): string {
+		if (nodeId === computedStartNode || computedGoalNodes.includes(nodeId)) {
+			return colorScheme.wall;
+		}
+		if (pathNodes.has(nodeId)) return colorScheme.path;
+		return colorScheme.grid;
+	}
+
+	$effect(() => {
+		if (autoPlay && steps.length === 0) {
+			play();
+		}
+	});
+
+	$effect(() => {
+		return () => {
+			if (intervalId !== null) {
+				clearInterval(intervalId);
+			}
+		};
+	});
+
+	const controlApi: LabyrinthControls = {
+		play,
+		pause,
+		reset,
+		stepForward,
+		stepBackward
+	};
+
+	$effect(() => {
+		onControls?.(controlApi);
+	});
+
+	const svgWidth = 650;
+	const svgHeight = 650;
+</script>
+
+<div class="graph-container" style={cssVars}>
+	<svg width={svgWidth} height={svgHeight} class="graph-svg">
+		<defs>
+			<marker
+				id="arrowhead"
+				markerWidth="10"
+				markerHeight="7"
+				refX="9"
+				refY="3.5"
+				orient="auto"
+			>
+				<polygon points="0 0, 10 3.5, 0 7" fill={colorScheme.grid} />
+			</marker>
+		</defs>
+
+		{#each Array.from(graph.nodes.values()) as node}
+			{#each node.neighbors as neighborId}
+				{@const neighbor = graph.nodes.get(neighborId)}
+				{#if neighbor && node.id < neighborId}
+					<line
+						x1={node.x}
+						y1={node.y}
+						x2={neighbor.x}
+						y2={neighbor.y}
+						stroke={colorScheme.grid}
+						stroke-width="2"
+					/>
+				{/if}
+			{/each}
+		{/each}
+
+		{#each Array.from(graph.nodes.values()) as node}
+			{@const color = getNodeColor(node.id)}
+			{@const stroke = getNodeStroke(node.id)}
+			<circle
+				cx={node.x}
+				cy={node.y}
+				r={nodeRadius}
+				fill={color}
+				stroke={stroke}
+				stroke-width="3"
+			/>
+			<text
+				x={node.x}
+				y={node.y}
+				text-anchor="middle"
+				dominant-baseline="middle"
+				font-size="10"
+				font-weight="600"
+				fill={colorScheme.wall}
+			>
+				{node.id.replace('n', '')}
+			</text>
+		{/each}
+	</svg>
+
+	<div class="controls">
+		{#if buttons}
+			<button onclick={play} disabled={isPlaying}>Play</button>
+			<button onclick={pause} disabled={!isPlaying}>Pause</button>
+			<button onclick={reset}>Reset</button>
+			<button onclick={stepBackward} disabled={isPlaying || currentStepIndex === 0}>
+				Step Back
+			</button>
+			<button onclick={stepForward} disabled={isPlaying || currentStepIndex === steps.length}>
+				Step Forward
+			</button>
+		{/if}
+		{#if stepCount}
+			<span class="step-counter">
+				Step: {currentStepIndex} / {steps.length}
+			</span>
+		{/if}
+	</div>
+
+	{#if legend}
+		<div class="legend">
+			<div class="legend-item">
+				<div class="legend-color" style="background-color: {colorScheme.start};"></div>
+				<span>Start</span>
+			</div>
+			<div class="legend-item">
+				<div class="legend-color" style="background-color: {colorScheme.end};"></div>
+				<span>Goal{computedGoalNodes.length > 1 ? 's' : ''}</span>
+			</div>
+			<div class="legend-item">
+				<div class="legend-color" style="background-color: {colorScheme.current};"></div>
+				<span>Forward</span>
+			</div>
+			<div class="legend-item">
+				<div class="legend-color" style="background-color: #f97316;"></div>
+				<span>Backward</span>
+			</div>
+			<div class="legend-item">
+				<div class="legend-color" style="background-color: {colorScheme.visiting};"></div>
+				<span>Forward Frontier</span>
+			</div>
+			<div class="legend-item">
+				<div class="legend-color" style="background-color: #fed7aa;"></div>
+				<span>Backward Frontier</span>
+			</div>
+			<div class="legend-item">
+				<div class="legend-color" style="background-color: {colorScheme.visited};"></div>
+				<span>Forward Visited</span>
+			</div>
+			<div class="legend-item">
+				<div class="legend-color" style="background-color: #fecaca;"></div>
+				<span>Backward Visited</span>
+			</div>
+			<div class="legend-item">
+				<div class="legend-color" style="background-color: #a855f7;"></div>
+				<span>Intersection</span>
+			</div>
+			<div class="legend-item">
+				<div class="legend-color" style="background-color: {colorScheme.path};"></div>
+				<span>Path</span>
+			</div>
+		</div>
+	{/if}
+</div>
+
+<style>
+	.graph-container {
+		display: flex;
+		flex-direction: column;
+		gap: 1rem;
+		align-items: center;
+		padding: 1rem;
+	}
+
+	.graph-svg {
+		background-color: white;
+		box-shadow: 0 4px 6px -1px rgb(0 0 0 / 0.1);
+		border: 2px solid #e5e7eb;
+		border-radius: 0.5rem;
+	}
+
+	.controls {
+		display: flex;
+		gap: 0.5rem;
+		align-items: center;
+		flex-wrap: wrap;
+	}
+
+	.controls button {
+		padding: 0.5rem 1rem;
+		border: none;
+		border-radius: 0.375rem;
+		cursor: pointer;
+		font-weight: 500;
+		transition: background-color 0.2s;
+		background-color: var(--graph-buttons);
+		color: var(--graph-buttonstext);
+	}
+
+	.controls button:hover:not(:disabled) {
+		background-color: var(--graph-buttonshover);
+	}
+
+	.controls button:disabled {
+		background-color: var(--graph-buttonsdisabled);
+		cursor: not-allowed;
+	}
+
+	.step-counter {
+		padding: 0.5rem 1rem;
+		border-radius: 0.375rem;
+		font-weight: 500;
+		background-color: var(--graph-legend);
+		color: var(--graph-legend-text);
+	}
+
+	.legend {
+		display: flex;
+		gap: 1rem;
+		flex-wrap: wrap;
+		padding: 0.75rem;
+		border-radius: 0.5rem;
+		background-color: var(--graph-legend);
+		color: var(--graph-legend-text);
+		max-width: 650px;
+	}
+
+	.legend-item {
+		display: flex;
+		align-items: center;
+		gap: 0.5rem;
+		font-size: 0.875rem;
+	}
+
+	.legend-color {
+		width: 1.5rem;
+		height: 1.5rem;
+		border-radius: 0.25rem;
+		border: 1px solid var(--graph-legend-text);
+	}
+</style>

package/dist/components/GraphVisualizer.svelte.d.ts

@@ -0,0 +1,18 @@
+import type { GeneralGraph, ColorScheme, LabyrinthControls } from '../types';
+interface Props {
+    graph: GeneralGraph;
+    startNode?: string;
+    goalNodes?: string[];
+    nodeRadius?: number;
+    autoPlay?: boolean;
+    buttons?: boolean;
+    legend?: boolean;
+    stepCount?: boolean;
+    animationSpeed?: number;
+    colors?: ColorScheme;
+    showMultiGoal?: boolean;
+    onControls?: (controls: LabyrinthControls) => void;
+}
+declare const GraphVisualizer: import("svelte").Component<Props, {}, "">;
+type GraphVisualizer = ReturnType<typeof GraphVisualizer>;
+export default GraphVisualizer;

package/dist/graph-generator.d.ts

@@ -0,0 +1,7 @@
+import type { GeneralGraph } from './types';
+export interface GraphGeneratorOptions {
+    nodeCount: number;
+    avgDegree: number;
+    seed?: number;
+}
+export declare function generateRandomGraph(options: GraphGeneratorOptions): GeneralGraph;

package/dist/graph-generator.js

@@ -0,0 +1,57 @@
+function seededRandom(seed) {
+    let state = seed;
+    return () => {
+        state = (state * 1664525 + 1013904223) % 4294967296;
+        return state / 4294967296;
+    };
+}
+export function generateRandomGraph(options) {
+    const { nodeCount, avgDegree, seed } = options;
+    const random = seed !== undefined ? seededRandom(seed) : Math.random;
+    const nodes = new Map();
+    // Create nodes in a circular layout for better visualization
+    const radius = 200;
+    const centerX = 300;
+    const centerY = 300;
+    for (let i = 0; i < nodeCount; i++) {
+        const angle = (i / nodeCount) * 2 * Math.PI;
+        const x = centerX + radius * Math.cos(angle);
+        const y = centerY + radius * Math.sin(angle);
+        nodes.set(`n${i}`, {
+            id: `n${i}`,
+            x,
+            y,
+            neighbors: []
+        });
+    }
+    // Connect nodes to create a connected graph
+    // First, create a spanning tree to ensure connectivity
+    const nodeIds = Array.from(nodes.keys());
+    const connected = new Set([nodeIds[0]]);
+    const unconnected = new Set(nodeIds.slice(1));
+    while (unconnected.size > 0) {
+        const connectedNode = Array.from(connected)[Math.floor(random() * connected.size)];
+        const unconnectedNode = Array.from(unconnected)[Math.floor(random() * unconnected.size)];
+        nodes.get(connectedNode).neighbors.push(unconnectedNode);
+        nodes.get(unconnectedNode).neighbors.push(connectedNode);
+        connected.add(unconnectedNode);
+        unconnected.delete(unconnectedNode);
+    }
+    // Add additional edges to reach target average degree
+    const targetEdges = Math.floor((nodeCount * avgDegree) / 2);
+    const currentEdges = nodeCount - 1; // from spanning tree
+    const edgesToAdd = targetEdges - currentEdges;
+    for (let i = 0; i < edgesToAdd; i++) {
+        const node1Id = nodeIds[Math.floor(random() * nodeIds.length)];
+        const node2Id = nodeIds[Math.floor(random() * nodeIds.length)];
+        if (node1Id === node2Id)
+            continue;
+        const node1 = nodes.get(node1Id);
+        const node2 = nodes.get(node2Id);
+        if (!node1.neighbors.includes(node2Id)) {
+            node1.neighbors.push(node2Id);
+            node2.neighbors.push(node1Id);
+        }
+    }
+    return { nodes };
+}

package/dist/index.d.ts

@@ -1,5 +1,8 @@
 export { generateLabyrinth } from './labyrinth-generator';
+export { generateRandomGraph } from './graph-generator';
 export { dijkstra } from './algorithms/dijkstra';
 export { astar } from './algorithms/astar';
+export { bidirectionalBFS, findOptimalMultiGoalPath } from './algorithms/bidirectional-bfs';
 export { default as Labyrinth } from './components/Labyrinth.svelte';
-export type { Graph, GraphNode, Point, Cell, PathStep, AlgorithmResult, AlgorithmType, ColorScheme, LabyrinthControls } from './types';
+export { default as GraphVisualizer } from './components/GraphVisualizer.svelte';
+export type { Graph, GraphNode, Point, Cell, PathStep, AlgorithmResult, AlgorithmType, ColorScheme, LabyrinthControls, GeneralGraph, GeneralGraphNode, BFSStep, BFSResult, MultiGoalResult } from './types';

package/dist/index.js

@@ -1,4 +1,7 @@
 export { generateLabyrinth } from './labyrinth-generator';
+export { generateRandomGraph } from './graph-generator';
 export { dijkstra } from './algorithms/dijkstra';
 export { astar } from './algorithms/astar';
+export { bidirectionalBFS, findOptimalMultiGoalPath } from './algorithms/bidirectional-bfs';
 export { default as Labyrinth } from './components/Labyrinth.svelte';
+export { default as GraphVisualizer } from './components/GraphVisualizer.svelte';

package/dist/types.d.ts

@@ -61,3 +61,30 @@ export interface LabyrinthControls {
     stepForward: () => void;
     stepBackward: () => void;
 }
+export interface GeneralGraphNode {
+    id: string;
+    x: number;
+    y: number;
+    neighbors: string[];
+}
+export interface GeneralGraph {
+    nodes: Map<string, GeneralGraphNode>;
+}
+export interface BFSStep {
+    nodeId: string;
+    type: 'start-forward' | 'start-backward' | 'goal-forward' | 'goal-backward' | 'visited-forward' | 'visited-backward' | 'path' | 'current-forward' | 'current-backward' | 'intersection';
+    side?: 'forward' | 'backward';
+    level?: number;
+}
+export interface BFSResult {
+    path: string[];
+    steps: BFSStep[];
+    found: boolean;
+    intersectionNode?: string;
+}
+export interface MultiGoalResult {
+    goals: string[];
+    paths: Map<string, string[]>;
+    optimalTour: string[];
+    steps: BFSStep[];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@hayro_o7/labyrinth",
-	"version": "0.0.3",
+	"version": "0.0.4",
 	"type": "module",
 	"scripts": {
 		"dev": "vite dev",