@principal-ai/logo-component 0.1.4 → 0.1.5

package/dist/MazeDemo.d.ts

@@ -0,0 +1,12 @@
+import React from "react";
+interface MazeDemoProps {
+    width?: number;
+    height?: number;
+    mazeColor?: string;
+    errorColor?: string;
+    searchColor?: string;
+    solutionColor?: string;
+    mazeSeed?: number;
+}
+export declare const MazeDemo: React.FC<MazeDemoProps>;
+export {};

package/dist/MazeDemo.js

@@ -0,0 +1,376 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MazeDemo = void 0;
+const react_1 = __importStar(require("react"));
+const mazeGenerator_1 = require("./utils/mazeGenerator");
+const MazeDemo = ({ 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] = (0, react_1.useState)([]);
+    const [directionHint, setDirectionHint] = (0, react_1.useState)("");
+    const [timeCost, setTimeCost] = (0, react_1.useState)(0);
+    const [clickCost, setClickCost] = (0, react_1.useState)(0);
+    const [blockageFound, setBlockageFound] = (0, react_1.useState)(false);
+    const [startTime, setStartTime] = (0, react_1.useState)(null);
+    const [started, setStarted] = (0, react_1.useState)(false);
+    const [currentSeed, setCurrentSeed] = (0, react_1.useState)(() => Math.floor(Math.random() * 10000));
+    const [blockageInjected, setBlockageInjected] = (0, react_1.useState)(false);
+    const [deployed, setDeployed] = (0, react_1.useState)(false);
+    const [mode, setMode] = (0, react_1.useState)('initial');
+    // Total incident cost
+    const incidentCost = timeCost + clickCost;
+    // Update currentSeed when mazeSeed prop changes
+    (0, react_1.useEffect)(() => {
+        setCurrentSeed(mazeSeed);
+    }, [mazeSeed]);
+    // Increment time cost
+    (0, react_1.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 } = (0, react_1.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_1.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_1.default.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_1.default.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_1.default.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_1.default.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_1.default.createElement("animate", { attributeName: "stroke-width", values: "4;6;4", dur: "1.5s", repeatCount: "indefinite" }))));
+        });
+        for (let row = 0; row <= gridSize; row++) {
+            elements.push(react_1.default.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_1.default.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_1.default.createElement("svg", { width: width, height: height, xmlns: "http://www.w3.org/2000/svg" },
+        react_1.default.createElement("text", { x: width / 2, y: 25, textAnchor: "middle", fill: mazeColor, fontSize: "16", fontWeight: "bold" }, getTitle()),
+        react_1.default.createElement("text", { x: width / 2, y: 40, textAnchor: "middle", fill: mazeColor, fontSize: "11", opacity: "0.6" }, getSubtitle()),
+        mode !== 'initial' && (react_1.default.createElement(react_1.default.Fragment, null,
+            react_1.default.createElement("g", null, renderMaze(mode === 'principal' || blockageFound, mazeOpacity)),
+            react_1.default.createElement("circle", { cx: mazeX + (startCol + 0.5) * cellSize, cy: padding + (startRow + 0.5) * cellSize, r: "5", fill: searchColor }),
+            react_1.default.createElement("text", { x: mazeX - 5, y: padding - 5, textAnchor: "end", fontSize: "10", fill: searchColor, fontWeight: "bold" }, "START"),
+            react_1.default.createElement("g", null,
+                react_1.default.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_1.default.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_1.default.createElement("circle", { cx: mazeX + (destCol + 0.5) * cellSize, cy: padding + (destRow + 0.5) * cellSize, r: "2", fill: mazeColor, opacity: "0.7" })),
+            react_1.default.createElement("text", { x: mazeX + mazeWidth + 5, y: padding + mazeHeight + 15, textAnchor: "start", fontSize: "9", fill: mazeColor, fontWeight: "bold" }, "DEST"))),
+        showCover && (react_1.default.createElement(react_1.default.Fragment, null,
+            react_1.default.createElement("defs", null,
+                react_1.default.createElement("mask", { id: "mazeCoverMask" },
+                    react_1.default.createElement("rect", { x: mazeX, y: padding, width: mazeWidth, height: mazeHeight, fill: "white" }),
+                    revealedCells.map((cell, idx) => (react_1.default.createElement("rect", { key: idx, x: mazeX + cell.col * cellSize, y: padding + cell.row * cellSize, width: cellSize, height: cellSize, fill: "black" }))))),
+            react_1.default.createElement("g", null,
+                react_1.default.createElement("rect", { x: mazeX, y: padding, width: mazeWidth, height: mazeHeight, fill: "#2a2a2a", opacity: coverOpacity, mask: "url(#mazeCoverMask)" }),
+                react_1.default.createElement("rect", { x: mazeX, y: padding, width: mazeWidth, height: mazeHeight, fill: "none", stroke: mazeColor, strokeWidth: "3", opacity: "0.4" }),
+                started && revealedCells.length === 0 && (react_1.default.createElement("g", null,
+                    react_1.default.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_1.default.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_1.default.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_1.default.createElement("g", null,
+                    react_1.default.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_1.default.createElement("text", { x: mazeX + mazeWidth / 2, y: padding + mazeHeight / 2, textAnchor: "middle", fontSize: "16", fill: "#ffffff", fontWeight: "bold", pointerEvents: "none" }, directionHint)))))),
+        started && (react_1.default.createElement("g", null, Array.from({ length: gridSize }).map((_, row) => Array.from({ length: gridSize }).map((_, col) => (react_1.default.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_1.default.createElement("g", null,
+            react_1.default.createElement("g", { style: { cursor: 'pointer' }, onClick: () => handleModeSelect('no-agentic') },
+                react_1.default.createElement("rect", { x: mazeX + mazeWidth / 2 - 130, y: padding + mazeHeight + 25, width: 120, height: 40, fill: searchColor, rx: "6" }),
+                react_1.default.createElement("text", { x: mazeX + mazeWidth / 2 - 70, y: padding + mazeHeight + 52, textAnchor: "middle", fontSize: "12", fill: "#ffffff", fontWeight: "bold", pointerEvents: "none" }, "No Agentic")),
+            react_1.default.createElement("g", { style: { cursor: 'pointer' }, onClick: () => handleModeSelect('agentic') },
+                react_1.default.createElement("rect", { x: mazeX + mazeWidth / 2 + 10, y: padding + mazeHeight + 25, width: 120, height: 40, fill: mazeColor, rx: "6" }),
+                react_1.default.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_1.default.createElement("g", null,
+            react_1.default.createElement("g", { style: { cursor: 'pointer' }, onClick: handleDeploy },
+                react_1.default.createElement("rect", { x: mazeX + mazeWidth / 2 - 60, y: padding + mazeHeight + 25, width: 120, height: 40, fill: searchColor, rx: "6" }),
+                react_1.default.createElement("text", { x: mazeX + mazeWidth / 2, y: padding + mazeHeight + 52, textAnchor: "middle", fontSize: "16", fill: "#ffffff", fontWeight: "bold", pointerEvents: "none" }, "DEPLOY")))),
+        deployed && !started && (react_1.default.createElement("g", null,
+            react_1.default.createElement("rect", { x: mazeX, y: padding + mazeHeight + 20, width: mazeWidth, height: 35, fill: solutionColor, opacity: "0.9", rx: "4" }),
+            react_1.default.createElement("text", { x: mazeX + mazeWidth / 2, y: padding + mazeHeight + 35, textAnchor: "middle", fontSize: "11", fill: "#ffffff", fontWeight: "normal" }, "\u2713 Deployment Successful"),
+            react_1.default.createElement("text", { x: mazeX + mazeWidth / 2, y: padding + mazeHeight + 50, textAnchor: "middle", fontSize: "14", fill: "#ffffff", fontWeight: "bold" }, "All systems operational"))),
+        started && (react_1.default.createElement("g", null,
+            react_1.default.createElement("rect", { x: mazeX, y: padding + mazeHeight + 20, width: mazeWidth, height: 35, fill: blockageFound ? solutionColor : errorColor, opacity: "0.9", rx: "4" }),
+            react_1.default.createElement("text", { x: mazeX + mazeWidth / 2, y: padding + mazeHeight + 35, textAnchor: "middle", fontSize: "11", fill: "#ffffff", fontWeight: "normal" }, blockageFound ? "Incident Resolved!" : "Incident Cost"),
+            react_1.default.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_1.default.createElement("g", null,
+            react_1.default.createElement("g", { style: { cursor: 'pointer' }, onClick: handleTryAgain },
+                react_1.default.createElement("rect", { x: mazeX + mazeWidth / 2 - 130, y: padding + mazeHeight + 65, width: 120, height: 25, fill: mazeColor, opacity: "0.2", rx: "4" }),
+                react_1.default.createElement("text", { x: mazeX + mazeWidth / 2 - 70, y: padding + mazeHeight + 82, textAnchor: "middle", fontSize: "10", fill: mazeColor, fontWeight: "bold", pointerEvents: "none" }, "Try Again")),
+            react_1.default.createElement("g", { style: { cursor: 'pointer' }, onClick: handleTryPrincipal },
+                react_1.default.createElement("rect", { x: mazeX + mazeWidth / 2 + 10, y: padding + mazeHeight + 65, width: 120, height: 25, fill: solutionColor, opacity: "0.8", rx: "4" }),
+                react_1.default.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_1.default.createElement("g", null,
+            react_1.default.createElement("g", { style: { cursor: 'pointer' }, onClick: handleTryAgain },
+                react_1.default.createElement("rect", { x: mazeX + mazeWidth / 2 - 60, y: padding + mazeHeight + 65, width: 120, height: 25, fill: mazeColor, opacity: "0.3", rx: "4" }),
+                react_1.default.createElement("text", { x: mazeX + mazeWidth / 2, y: padding + mazeHeight + 82, textAnchor: "middle", fontSize: "10", fill: mazeColor, fontWeight: "bold", pointerEvents: "none" }, "Try Again"))))));
+};
+exports.MazeDemo = MazeDemo;

package/dist/MazeDemoNew.d.ts

@@ -0,0 +1,12 @@
+import React from "react";
+interface MazeDemoProps {
+    width?: number;
+    height?: number;
+    mazeColor?: string;
+    errorColor?: string;
+    searchColor?: string;
+    solutionColor?: string;
+    mazeSeed?: number;
+}
+export declare const MazeDemoNew: React.FC<MazeDemoProps>;
+export {};