@principal-ai/logo-component 0.1.5 → 0.1.6

package/dist/esm/MazeDemoNew.js

@@ -1,339 +0,0 @@
-import React, { useMemo, useState, useEffect } from "react";
-import { MazeGenerator } from "./utils/mazeGenerator";
-export const MazeDemoNew = ({ width = 450, height = 620, mazeColor = "#6366f1", errorColor = "#ef4444", searchColor = "#f59e0b", solutionColor = "#10b981", mazeSeed = 42, }) => {
-    // Maze configuration
-    const gridSize = 10;
-    const cellSize = 30;
-    const padding = 50;
-    const mazeWidth = gridSize * cellSize;
-    const mazeHeight = gridSize * cellSize;
-    const mazeX = (width - mazeWidth) / 2;
-    // Key positions
-    const startCol = 0;
-    const startRow = 0;
-    const destCol = 9;
-    const destRow = 9;
-    // State
-    const [revealedCells, setRevealedCells] = useState([]);
-    const [directionHint, setDirectionHint] = useState("");
-    const [timeCost, setTimeCost] = useState(0);
-    const [clickCost, setClickCost] = useState(0);
-    const [blockageFound, setBlockageFound] = useState(false);
-    const [startTime, setStartTime] = useState(null);
-    const [started, setStarted] = useState(false);
-    const [currentSeed, setCurrentSeed] = useState(() => Math.floor(Math.random() * 10000));
-    const [blockageInjected, setBlockageInjected] = useState(false);
-    const [deployed, setDeployed] = useState(false);
-    const [mode, setMode] = useState('initial');
-    // Total incident cost
-    const incidentCost = timeCost + clickCost;
-    // Update currentSeed when mazeSeed prop changes
-    useEffect(() => {
-        setCurrentSeed(mazeSeed);
-    }, [mazeSeed]);
-    // Increment time cost
-    useEffect(() => {
-        if (blockageFound || !startTime || !started)
-            return;
-        const interval = setInterval(() => {
-            setTimeCost(prev => prev + 1);
-        }, 10);
-        return () => clearInterval(interval);
-    }, [blockageFound, startTime, started]);
-    // Generate maze
-    const { horizontalWalls, verticalWalls, blockageWall, actualBlockageCol, actualBlockageRow } = useMemo(() => {
-        let seed = currentSeed;
-        const seededRandom = () => {
-            seed = (seed * 9301 + 49297) % 233280;
-            return seed / 233280;
-        };
-        const originalRandom = Math.random;
-        Math.random = seededRandom;
-        const generator = new MazeGenerator(gridSize, gridSize);
-        generator.generate(startRow, startCol);
-        let blockCell = { row: 5, col: 5 };
-        let direction = 'east';
-        let blockageWall = null;
-        if (blockageInjected) {
-            const path = generator.findPath(startRow, startCol, destRow, destCol);
-            if (path.length > 2) {
-                const middleStart = Math.floor(path.length * 0.3);
-                const middleEnd = Math.floor(path.length * 0.7);
-                const blockIndex = Math.floor(seededRandom() * (middleEnd - middleStart)) + middleStart;
-                blockCell = path[blockIndex];
-                if (blockIndex < path.length - 1) {
-                    const nextCell = path[blockIndex + 1];
-                    const rowDiff = nextCell.row - blockCell.row;
-                    const colDiff = nextCell.col - blockCell.col;
-                    if (rowDiff === 1)
-                        direction = 'south';
-                    else if (rowDiff === -1)
-                        direction = 'north';
-                    else if (colDiff === 1)
-                        direction = 'east';
-                    else if (colDiff === -1)
-                        direction = 'west';
-                }
-            }
-            generator.addBlockage(blockCell.row, blockCell.col, direction);
-        }
-        const walls = generator.getWalls();
-        if (blockageInjected) {
-            if (direction === 'east' || direction === 'west') {
-                const targetCol = direction === 'east' ? blockCell.col + 1 : blockCell.col;
-                const targetRow = blockCell.row;
-                const wallSegment = walls.vertical.find(wall => {
-                    const [col, row1, , row2] = wall;
-                    return col === targetCol && row1 <= targetRow && row2 > targetRow;
-                });
-                if (wallSegment) {
-                    const [col, row1, , row2] = wallSegment;
-                    blockageWall = { type: 'vertical', col, row1, row2 };
-                }
-            }
-            else {
-                const targetRow = direction === 'south' ? blockCell.row + 1 : blockCell.row;
-                const targetCol = blockCell.col;
-                const wallSegment = walls.horizontal.find(wall => {
-                    const [col1, row, col2] = wall;
-                    return row === targetRow && col1 <= targetCol && col2 > targetCol;
-                });
-                if (wallSegment) {
-                    const [col1, row, col2] = wallSegment;
-                    blockageWall = { type: 'horizontal', row, col1, col2 };
-                }
-            }
-        }
-        Math.random = originalRandom;
-        return {
-            horizontalWalls: walls.horizontal,
-            verticalWalls: walls.vertical,
-            blockageWall,
-            actualBlockageCol: blockCell.col,
-            actualBlockageRow: blockCell.row,
-        };
-    }, [currentSeed, blockageInjected]);
-    // Handlers
-    const handleModeSelect = (selectedMode) => {
-        setMode(selectedMode);
-    };
-    const handleDeploy = () => {
-        setDeployed(true);
-        setTimeout(() => {
-            setBlockageInjected(true);
-            setStarted(true);
-            setStartTime(Date.now());
-        }, 3000);
-    };
-    const handleTryPrincipal = () => {
-        setMode('principal');
-        setRevealedCells([]);
-        setDirectionHint("");
-        setBlockageFound(false);
-        setTimeCost(0);
-        setClickCost(0);
-        setStartTime(null);
-        setStarted(false);
-        setDeployed(false);
-        setBlockageInjected(false); // Principal mode still needs to deploy first
-    };
-    const handleTryAgain = () => {
-        setRevealedCells([]);
-        setDirectionHint("");
-        setBlockageFound(false);
-        setTimeCost(0);
-        setClickCost(0);
-        setStartTime(null);
-        setStarted(false);
-        setBlockageInjected(false);
-        setDeployed(false);
-        setMode('initial');
-        setCurrentSeed(Math.floor(Math.random() * 10000));
-    };
-    const handleCellClick = (col, row) => {
-        if (blockageFound || !started)
-            return;
-        // In principal mode, only allow clicking the blockage cell
-        if (mode === 'principal') {
-            const isBlockageCell = col === actualBlockageCol && row === actualBlockageRow;
-            if (isBlockageCell) {
-                setDirectionHint("🎯 Blockage Found!");
-                setBlockageFound(true);
-            }
-            return;
-        }
-        const alreadyRevealed = revealedCells.some(cell => cell.col === col && cell.row === row);
-        if (alreadyRevealed)
-            return;
-        setClickCost(prev => prev + 500);
-        setRevealedCells([...revealedCells, { col, row }]);
-        const isBlockageCell = col === actualBlockageCol && row === actualBlockageRow;
-        if (isBlockageCell) {
-            setDirectionHint("🎯 Blockage Found!");
-            setBlockageFound(true);
-            const cellsToReveal = [...revealedCells];
-            for (let r = 0; r < gridSize; r++) {
-                for (let c = 0; c < gridSize; c++) {
-                    const distance = Math.abs(actualBlockageCol - c) + Math.abs(actualBlockageRow - r);
-                    if (distance <= 3) {
-                        const alreadyInList = cellsToReveal.some(cell => cell.col === c && cell.row === r);
-                        if (!alreadyInList) {
-                            cellsToReveal.push({ col: c, row: r });
-                        }
-                    }
-                }
-            }
-            setRevealedCells(cellsToReveal);
-        }
-        else {
-            const colDiff = actualBlockageCol - col;
-            const rowDiff = actualBlockageRow - row;
-            let direction = "";
-            if (Math.abs(rowDiff) > 1) {
-                direction += rowDiff > 0 ? "↓ " : "↑ ";
-            }
-            if (Math.abs(colDiff) > 1) {
-                direction += colDiff > 0 ? "→" : "←";
-            }
-            const distance = Math.abs(colDiff) + Math.abs(rowDiff);
-            let proximity = "";
-            if (distance <= 2)
-                proximity = "Very close!";
-            else if (distance <= 4)
-                proximity = "Getting warmer...";
-            else if (distance <= 6)
-                proximity = "Still far...";
-            else
-                proximity = "Cold...";
-            setDirectionHint(`${direction} ${proximity}`);
-        }
-    };
-    // Render maze
-    const renderMaze = (showBlockage, opacity = 1) => {
-        const elements = [];
-        elements.push(React.createElement("rect", { key: "background", x: mazeX, y: padding, width: mazeWidth, height: mazeHeight, fill: "none", stroke: mazeColor, strokeWidth: "3", opacity: 0.3 * opacity }));
-        const isBlockageWall = (type, wall) => {
-            if (!showBlockage || !blockageWall)
-                return false;
-            if (type === 'vertical') {
-                const [x, y1, , y2] = wall;
-                return (blockageWall.type === 'vertical' &&
-                    x === blockageWall.col &&
-                    y1 === blockageWall.row1 &&
-                    y2 === blockageWall.row2);
-            }
-            else if (type === 'horizontal') {
-                const [x1, y, x2] = wall;
-                return (blockageWall.type === 'horizontal' &&
-                    y === blockageWall.row &&
-                    x1 === blockageWall.col1 &&
-                    x2 === blockageWall.col2);
-            }
-            return false;
-        };
-        horizontalWalls.forEach((wall, idx) => {
-            const [x1, y, x2] = wall;
-            const isBlockage = isBlockageWall('horizontal', wall);
-            elements.push(React.createElement("line", { key: `h-wall-${idx}`, x1: mazeX + x1 * cellSize, y1: padding + y * cellSize, x2: mazeX + x2 * cellSize, y2: padding + y * cellSize, stroke: isBlockage ? errorColor : mazeColor, strokeWidth: isBlockage ? 4 : 2.5, strokeLinecap: "round", opacity: opacity }, isBlockage && showBlockage && (React.createElement("animate", { attributeName: "stroke-width", values: "4;6;4", dur: "1.5s", repeatCount: "indefinite" }))));
-        });
-        verticalWalls.forEach((wall, idx) => {
-            const [x, y1, , y2] = wall;
-            const isBlockage = isBlockageWall('vertical', wall);
-            elements.push(React.createElement("line", { key: `v-wall-${idx}`, x1: mazeX + x * cellSize, y1: padding + y1 * cellSize, x2: mazeX + x * cellSize, y2: padding + y2 * cellSize, stroke: isBlockage ? errorColor : mazeColor, strokeWidth: isBlockage ? 4 : 2.5, strokeLinecap: "round", opacity: opacity }, isBlockage && showBlockage && (React.createElement("animate", { attributeName: "stroke-width", values: "4;6;4", dur: "1.5s", repeatCount: "indefinite" }))));
-        });
-        for (let row = 0; row <= gridSize; row++) {
-            elements.push(React.createElement("line", { key: `grid-h-${row}`, x1: mazeX, y1: padding + row * cellSize, x2: mazeX + mazeWidth, y2: padding + row * cellSize, stroke: mazeColor, strokeWidth: "0.5", opacity: 0.15 * opacity }));
-        }
-        for (let col = 0; col <= gridSize; col++) {
-            elements.push(React.createElement("line", { key: `grid-v-${col}`, x1: mazeX + col * cellSize, y1: padding, x2: mazeX + col * cellSize, y2: padding + mazeHeight, stroke: mazeColor, strokeWidth: "0.5", opacity: 0.15 * opacity }));
-        }
-        return elements;
-    };
-    const getTitle = () => {
-        if (mode === 'principal')
-            return "With Principal";
-        if (mode === 'agentic')
-            return "With Agentic Coding";
-        if (mode === 'no-agentic')
-            return "Without Agentic Coding";
-        return "Choose Your Approach";
-    };
-    const getSubtitle = () => {
-        if (mode === 'principal')
-            return "Full visibility - See everything";
-        if (started)
-            return "Find the blockage";
-        if (deployed)
-            return "Running smoothly...";
-        return "How will you handle production?";
-    };
-    const showCover = mode === 'agentic' || (deployed && mode === 'no-agentic');
-    const coverOpacity = 1; // Always full opacity for the cover
-    const mazeOpacity = 1; // Maze always at full opacity, cover handles visibility
-    return (React.createElement("svg", { width: width, height: height, xmlns: "http://www.w3.org/2000/svg" },
-        React.createElement("text", { x: width / 2, y: 25, textAnchor: "middle", fill: mazeColor, fontSize: "16", fontWeight: "bold" }, getTitle()),
-        React.createElement("text", { x: width / 2, y: 40, textAnchor: "middle", fill: mazeColor, fontSize: "11", opacity: "0.6" }, getSubtitle()),
-        mode !== 'initial' && (React.createElement(React.Fragment, null,
-            React.createElement("g", null, renderMaze(mode === 'principal' || blockageFound, mazeOpacity)),
-            React.createElement("circle", { cx: mazeX + (startCol + 0.5) * cellSize, cy: padding + (startRow + 0.5) * cellSize, r: "5", fill: searchColor }),
-            React.createElement("text", { x: mazeX - 5, y: padding - 5, textAnchor: "end", fontSize: "10", fill: searchColor, fontWeight: "bold" }, "START"),
-            React.createElement("g", null,
-                React.createElement("circle", { cx: mazeX + (destCol + 0.5) * cellSize, cy: padding + (destRow + 0.5) * cellSize, r: "8", fill: "none", stroke: mazeColor, strokeWidth: "1.5", opacity: "0.5" }),
-                React.createElement("circle", { cx: mazeX + (destCol + 0.5) * cellSize, cy: padding + (destRow + 0.5) * cellSize, r: "5", fill: "none", stroke: mazeColor, strokeWidth: "1.5", opacity: "0.6" }),
-                React.createElement("circle", { cx: mazeX + (destCol + 0.5) * cellSize, cy: padding + (destRow + 0.5) * cellSize, r: "2", fill: mazeColor, opacity: "0.7" })),
-            React.createElement("text", { x: mazeX + mazeWidth + 5, y: padding + mazeHeight + 15, textAnchor: "start", fontSize: "9", fill: mazeColor, fontWeight: "bold" }, "DEST"))),
-        showCover && (React.createElement(React.Fragment, null,
-            React.createElement("defs", null,
-                React.createElement("mask", { id: "mazeCoverMask" },
-                    React.createElement("rect", { x: mazeX, y: padding, width: mazeWidth, height: mazeHeight, fill: "white" }),
-                    revealedCells.map((cell, idx) => (React.createElement("rect", { key: idx, x: mazeX + cell.col * cellSize, y: padding + cell.row * cellSize, width: cellSize, height: cellSize, fill: "black" }))))),
-            React.createElement("g", null,
-                React.createElement("rect", { x: mazeX, y: padding, width: mazeWidth, height: mazeHeight, fill: "#2a2a2a", opacity: coverOpacity, mask: "url(#mazeCoverMask)" }),
-                React.createElement("rect", { x: mazeX, y: padding, width: mazeWidth, height: mazeHeight, fill: "none", stroke: mazeColor, strokeWidth: "3", opacity: "0.4" }),
-                started && revealedCells.length === 0 && (React.createElement("g", null,
-                    React.createElement("rect", { x: mazeX + mazeWidth / 2 - 130, y: padding + mazeHeight / 2 - 40, width: 260, height: 80, fill: "#000000", opacity: "0.7", rx: "8", pointerEvents: "none" }),
-                    React.createElement("text", { x: mazeX + mazeWidth / 2, y: padding + mazeHeight / 2 - 15, textAnchor: "middle", fontSize: "18", fill: errorColor, fontWeight: "bold", pointerEvents: "none" }, "\uD83D\uDEA8 INCIDENT ALERT"),
-                    React.createElement("text", { x: mazeX + mazeWidth / 2, y: padding + mazeHeight / 2 + 10, textAnchor: "middle", fontSize: "13", fill: "#ffffff", fontWeight: "normal", pointerEvents: "none" }, "It's 3:00 AM - Find the blockage!"))),
-                started && revealedCells.length > 0 && directionHint && (React.createElement("g", null,
-                    React.createElement("rect", { x: mazeX + mazeWidth / 2 - 100, y: padding + mazeHeight / 2 - 25, width: 200, height: 40, fill: "#000000", opacity: "0.7", rx: "6", pointerEvents: "none" }),
-                    React.createElement("text", { x: mazeX + mazeWidth / 2, y: padding + mazeHeight / 2, textAnchor: "middle", fontSize: "16", fill: "#ffffff", fontWeight: "bold", pointerEvents: "none" }, directionHint)))))),
-        started && (React.createElement("g", null, Array.from({ length: gridSize }).map((_, row) => Array.from({ length: gridSize }).map((_, col) => (React.createElement("rect", { key: `cell-${row}-${col}`, x: mazeX + col * cellSize, y: padding + row * cellSize, width: cellSize, height: cellSize, fill: "transparent", stroke: "none", style: { cursor: 'pointer' }, onClick: () => handleCellClick(col, row), onMouseEnter: (e) => {
-                e.currentTarget.setAttribute('fill', searchColor);
-                e.currentTarget.setAttribute('opacity', '0.1');
-            }, onMouseLeave: (e) => {
-                e.currentTarget.setAttribute('fill', 'transparent');
-                e.currentTarget.setAttribute('opacity', '1');
-            } })))))),
-        mode === 'initial' && (React.createElement("g", null,
-            React.createElement("g", { style: { cursor: 'pointer' }, onClick: () => handleModeSelect('no-agentic') },
-                React.createElement("rect", { x: mazeX + mazeWidth / 2 - 130, y: padding + mazeHeight + 25, width: 120, height: 40, fill: searchColor, rx: "6" }),
-                React.createElement("text", { x: mazeX + mazeWidth / 2 - 70, y: padding + mazeHeight + 52, textAnchor: "middle", fontSize: "12", fill: "#ffffff", fontWeight: "bold", pointerEvents: "none" }, "No Agentic")),
-            React.createElement("g", { style: { cursor: 'pointer' }, onClick: () => handleModeSelect('agentic') },
-                React.createElement("rect", { x: mazeX + mazeWidth / 2 + 10, y: padding + mazeHeight + 25, width: 120, height: 40, fill: mazeColor, rx: "6" }),
-                React.createElement("text", { x: mazeX + mazeWidth / 2 + 70, y: padding + mazeHeight + 52, textAnchor: "middle", fontSize: "12", fill: "#ffffff", fontWeight: "bold", pointerEvents: "none" }, "Agentic Coding")))),
-        (mode === 'no-agentic' || mode === 'agentic' || mode === 'principal') && !deployed && (React.createElement("g", null,
-            React.createElement("g", { style: { cursor: 'pointer' }, onClick: handleDeploy },
-                React.createElement("rect", { x: mazeX + mazeWidth / 2 - 60, y: padding + mazeHeight + 25, width: 120, height: 40, fill: searchColor, rx: "6" }),
-                React.createElement("text", { x: mazeX + mazeWidth / 2, y: padding + mazeHeight + 52, textAnchor: "middle", fontSize: "16", fill: "#ffffff", fontWeight: "bold", pointerEvents: "none" }, "DEPLOY")))),
-        deployed && !started && (React.createElement("g", null,
-            React.createElement("rect", { x: mazeX, y: padding + mazeHeight + 20, width: mazeWidth, height: 35, fill: solutionColor, opacity: "0.9", rx: "4" }),
-            React.createElement("text", { x: mazeX + mazeWidth / 2, y: padding + mazeHeight + 35, textAnchor: "middle", fontSize: "11", fill: "#ffffff", fontWeight: "normal" }, "\u2713 Deployment Successful"),
-            React.createElement("text", { x: mazeX + mazeWidth / 2, y: padding + mazeHeight + 50, textAnchor: "middle", fontSize: "14", fill: "#ffffff", fontWeight: "bold" }, "All systems operational"))),
-        started && (React.createElement("g", null,
-            React.createElement("rect", { x: mazeX, y: padding + mazeHeight + 20, width: mazeWidth, height: 35, fill: blockageFound ? solutionColor : errorColor, opacity: "0.9", rx: "4" }),
-            React.createElement("text", { x: mazeX + mazeWidth / 2, y: padding + mazeHeight + 35, textAnchor: "middle", fontSize: "11", fill: "#ffffff", fontWeight: "normal" }, blockageFound ? "Incident Resolved!" : "Incident Cost"),
-            React.createElement("text", { x: mazeX + mazeWidth / 2, y: padding + mazeHeight + 50, textAnchor: "middle", fontSize: "18", fill: "#ffffff", fontWeight: "bold" },
-                "$",
-                incidentCost.toLocaleString()))),
-        started && blockageFound && mode !== 'principal' && (React.createElement("g", null,
-            React.createElement("g", { style: { cursor: 'pointer' }, onClick: handleTryAgain },
-                React.createElement("rect", { x: mazeX + mazeWidth / 2 - 130, y: padding + mazeHeight + 65, width: 120, height: 25, fill: mazeColor, opacity: "0.2", rx: "4" }),
-                React.createElement("text", { x: mazeX + mazeWidth / 2 - 70, y: padding + mazeHeight + 82, textAnchor: "middle", fontSize: "10", fill: mazeColor, fontWeight: "bold", pointerEvents: "none" }, "Try Again")),
-            React.createElement("g", { style: { cursor: 'pointer' }, onClick: handleTryPrincipal },
-                React.createElement("rect", { x: mazeX + mazeWidth / 2 + 10, y: padding + mazeHeight + 65, width: 120, height: 25, fill: solutionColor, opacity: "0.8", rx: "4" }),
-                React.createElement("text", { x: mazeX + mazeWidth / 2 + 70, y: padding + mazeHeight + 82, textAnchor: "middle", fontSize: "10", fill: "#ffffff", fontWeight: "bold", pointerEvents: "none" }, "Try with Principal")))),
-        mode === 'principal' && blockageFound && (React.createElement("g", null,
-            React.createElement("g", { style: { cursor: 'pointer' }, onClick: handleTryAgain },
-                React.createElement("rect", { x: mazeX + mazeWidth / 2 - 60, y: padding + mazeHeight + 65, width: 120, height: 25, fill: mazeColor, opacity: "0.3", rx: "4" }),
-                React.createElement("text", { x: mazeX + mazeWidth / 2, y: padding + mazeHeight + 82, textAnchor: "middle", fontSize: "10", fill: mazeColor, fontWeight: "bold", pointerEvents: "none" }, "Try Again"))))));
-};

package/dist/esm/utils/mazeGenerator.js

@@ -1,266 +0,0 @@
-/**
- * Maze Generator using Recursive Backtracking
- * Creates a perfect maze (exactly one path between any two cells)
- */
-export class MazeGenerator {
-    constructor(rows, cols) {
-        this.rows = rows;
-        this.cols = cols;
-        this.grid = this.initializeGrid();
-    }
-    initializeGrid() {
-        const grid = [];
-        for (let row = 0; row < this.rows; row++) {
-            grid[row] = [];
-            for (let col = 0; col < this.cols; col++) {
-                grid[row][col] = {
-                    row,
-                    col,
-                    visited: false,
-                    walls: {
-                        north: true,
-                        south: true,
-                        east: true,
-                        west: true,
-                    },
-                };
-            }
-        }
-        return grid;
-    }
-    getCell(row, col) {
-        if (row < 0 || row >= this.rows || col < 0 || col >= this.cols) {
-            return null;
-        }
-        return this.grid[row][col];
-    }
-    getUnvisitedNeighbors(cell) {
-        const neighbors = [];
-        const { row, col } = cell;
-        // North
-        const north = this.getCell(row - 1, col);
-        if (north && !north.visited)
-            neighbors.push(north);
-        // South
-        const south = this.getCell(row + 1, col);
-        if (south && !south.visited)
-            neighbors.push(south);
-        // East
-        const east = this.getCell(row, col + 1);
-        if (east && !east.visited)
-            neighbors.push(east);
-        // West
-        const west = this.getCell(row, col - 1);
-        if (west && !west.visited)
-            neighbors.push(west);
-        return neighbors;
-    }
-    removeWallBetween(current, next) {
-        const rowDiff = current.row - next.row;
-        const colDiff = current.col - next.col;
-        // North
-        if (rowDiff === 1) {
-            current.walls.north = false;
-            next.walls.south = false;
-        }
-        // South
-        else if (rowDiff === -1) {
-            current.walls.south = false;
-            next.walls.north = false;
-        }
-        // East
-        else if (colDiff === -1) {
-            current.walls.east = false;
-            next.walls.west = false;
-        }
-        // West
-        else if (colDiff === 1) {
-            current.walls.west = false;
-            next.walls.east = false;
-        }
-    }
-    recursiveBacktrack(cell) {
-        cell.visited = true;
-        const neighbors = this.getUnvisitedNeighbors(cell);
-        // Shuffle neighbors for randomness
-        this.shuffle(neighbors);
-        for (const neighbor of neighbors) {
-            if (!neighbor.visited) {
-                this.removeWallBetween(cell, neighbor);
-                this.recursiveBacktrack(neighbor);
-            }
-        }
-    }
-    shuffle(array) {
-        for (let i = array.length - 1; i > 0; i--) {
-            const j = Math.floor(Math.random() * (i + 1));
-            [array[i], array[j]] = [array[j], array[i]];
-        }
-    }
-    /**
-     * Generate the maze starting from a specific cell
-     */
-    generate(startRow = 0, startCol = 0) {
-        const startCell = this.getCell(startRow, startCol);
-        if (startCell) {
-            this.recursiveBacktrack(startCell);
-        }
-    }
-    /**
-     * Convert the maze to wall segments for rendering
-     */
-    getWalls() {
-        const horizontal = [];
-        const vertical = [];
-        // Convert cell walls to line segments
-        for (let row = 0; row < this.rows; row++) {
-            for (let col = 0; col < this.cols; col++) {
-                const cell = this.grid[row][col];
-                // North wall
-                if (cell.walls.north) {
-                    // Check if we can extend an existing horizontal wall
-                    const lastHWall = horizontal[horizontal.length - 1];
-                    if (lastHWall && lastHWall[1] === row && lastHWall[2] === col) {
-                        // Extend the wall
-                        lastHWall[2] = col + 1;
-                    }
-                    else {
-                        // Create new wall segment
-                        horizontal.push([col, row, col + 1, row]);
-                    }
-                }
-                // West wall
-                if (cell.walls.west) {
-                    // Check if we can extend an existing vertical wall
-                    const lastVWall = vertical[vertical.length - 1];
-                    if (lastVWall && lastVWall[0] === col && lastVWall[3] === row) {
-                        // Extend the wall
-                        lastVWall[3] = row + 1;
-                    }
-                    else {
-                        // Create new wall segment
-                        vertical.push([col, row, col, row + 1]);
-                    }
-                }
-                // South wall (only for bottom row)
-                if (row === this.rows - 1 && cell.walls.south) {
-                    const lastHWall = horizontal[horizontal.length - 1];
-                    if (lastHWall && lastHWall[1] === row + 1 && lastHWall[2] === col) {
-                        lastHWall[2] = col + 1;
-                    }
-                    else {
-                        horizontal.push([col, row + 1, col + 1, row + 1]);
-                    }
-                }
-                // East wall (only for rightmost column)
-                if (col === this.cols - 1 && cell.walls.east) {
-                    const lastVWall = vertical[vertical.length - 1];
-                    if (lastVWall && lastVWall[0] === col + 1 && lastVWall[3] === row) {
-                        lastVWall[3] = row + 1;
-                    }
-                    else {
-                        vertical.push([col + 1, row, col + 1, row + 1]);
-                    }
-                }
-            }
-        }
-        return { horizontal, vertical };
-    }
-    /**
-     * Get a copy of the grid for debugging or analysis
-     */
-    getGrid() {
-        return this.grid;
-    }
-    /**
-     * Find path from start to end using BFS
-     * Returns array of cells representing the path
-     */
-    findPath(startRow, startCol, endRow, endCol) {
-        const visited = new Set();
-        const queue = [];
-        const startCell = this.getCell(startRow, startCol);
-        if (!startCell)
-            return [];
-        queue.push({ cell: startCell, path: [startCell] });
-        visited.add(`${startRow},${startCol}`);
-        while (queue.length > 0) {
-            const { cell, path } = queue.shift();
-            if (cell.row === endRow && cell.col === endCol) {
-                return path;
-            }
-            // Check all four directions
-            const neighbors = [
-                { dir: 'north', dr: -1, dc: 0, wall: cell.walls.north },
-                { dir: 'south', dr: 1, dc: 0, wall: cell.walls.south },
-                { dir: 'east', dr: 0, dc: 1, wall: cell.walls.east },
-                { dir: 'west', dr: 0, dc: -1, wall: cell.walls.west },
-            ];
-            for (const { dr, dc, wall } of neighbors) {
-                if (wall)
-                    continue; // Can't go through wall
-                const nextRow = cell.row + dr;
-                const nextCol = cell.col + dc;
-                const key = `${nextRow},${nextCol}`;
-                if (visited.has(key))
-                    continue;
-                const nextCell = this.getCell(nextRow, nextCol);
-                if (!nextCell)
-                    continue;
-                visited.add(key);
-                queue.push({
-                    cell: nextCell,
-                    path: [...path, nextCell]
-                });
-            }
-        }
-        return []; // No path found
-    }
-    /**
-     * Add a blockage (wall) at a specific position
-     */
-    addBlockage(row, col, direction) {
-        const cell = this.getCell(row, col);
-        if (!cell)
-            return;
-        cell.walls[direction] = true;
-        // Also add the wall to the adjacent cell
-        if (direction === 'north') {
-            const neighbor = this.getCell(row - 1, col);
-            if (neighbor)
-                neighbor.walls.south = true;
-        }
-        else if (direction === 'south') {
-            const neighbor = this.getCell(row + 1, col);
-            if (neighbor)
-                neighbor.walls.north = true;
-        }
-        else if (direction === 'east') {
-            const neighbor = this.getCell(row, col + 1);
-            if (neighbor)
-                neighbor.walls.west = true;
-        }
-        else if (direction === 'west') {
-            const neighbor = this.getCell(row, col - 1);
-            if (neighbor)
-                neighbor.walls.east = true;
-        }
-    }
-}
-/**
- * Helper function to generate a maze with default settings
- */
-export function generateMaze(rows, cols, seed) {
-    // Use seed for reproducible mazes (if provided)
-    if (seed !== undefined) {
-        // Simple seeded random (not cryptographically secure)
-        let currentSeed = seed;
-        Math.random = () => {
-            currentSeed = (currentSeed * 9301 + 49297) % 233280;
-            return currentSeed / 233280;
-        };
-    }
-    const generator = new MazeGenerator(rows, cols);
-    generator.generate(0, 0);
-    return generator.getWalls();
-}

package/dist/utils/mazeGenerator.d.ts

@@ -1,56 +0,0 @@
-/**
- * Maze Generator using Recursive Backtracking
- * Creates a perfect maze (exactly one path between any two cells)
- */
-export interface MazeCell {
-    row: number;
-    col: number;
-    visited: boolean;
-    walls: {
-        north: boolean;
-        south: boolean;
-        east: boolean;
-        west: boolean;
-    };
-}
-export interface MazeWalls {
-    horizontal: number[][];
-    vertical: number[][];
-}
-export declare class MazeGenerator {
-    private grid;
-    private rows;
-    private cols;
-    constructor(rows: number, cols: number);
-    private initializeGrid;
-    private getCell;
-    private getUnvisitedNeighbors;
-    private removeWallBetween;
-    private recursiveBacktrack;
-    private shuffle;
-    /**
-     * Generate the maze starting from a specific cell
-     */
-    generate(startRow?: number, startCol?: number): void;
-    /**
-     * Convert the maze to wall segments for rendering
-     */
-    getWalls(): MazeWalls;
-    /**
-     * Get a copy of the grid for debugging or analysis
-     */
-    getGrid(): MazeCell[][];
-    /**
-     * Find path from start to end using BFS
-     * Returns array of cells representing the path
-     */
-    findPath(startRow: number, startCol: number, endRow: number, endCol: number): MazeCell[];
-    /**
-     * Add a blockage (wall) at a specific position
-     */
-    addBlockage(row: number, col: number, direction: 'north' | 'south' | 'east' | 'west'): void;
-}
-/**
- * Helper function to generate a maze with default settings
- */
-export declare function generateMaze(rows: number, cols: number, seed?: number): MazeWalls;